public boolean isDirectTransferInProgress(final FrostUploadItem ulItem) {
final String id = ulItem.getGqIdentifier();
if (directPUTsInProgress.contains(id)) {
return true;
}
if (directPUTsWithoutAnswer.contains(id)) {
return true;
}
return false;
}
/**
* Adds to the given list of property descriptors the mapped properties, ie. properties that have
* a getter method taking a single String value as a parameter.
*
* @param clazz to introspect
* @param result is the list to add to
*/
protected static void addMappedProperties(Class clazz, List<InternalEventPropDescriptor> result) {
Set<String> uniquePropertyNames = new HashSet<String>();
Method[] methods = clazz.getMethods();
for (int i = 0; i < methods.length; i++) {
String methodName = methods[i].getName();
if (!methodName.startsWith("get")) {
continue;
}
String inferredName = methodName.substring(3, methodName.length());
if (inferredName.length() == 0) {
continue;
}
Class<?> parameterTypes[] = methods[i].getParameterTypes();
if (parameterTypes.length != 1) {
continue;
}
if (parameterTypes[0] != String.class) {
continue;
}
String newInferredName = null;
// Leave uppercase inferred names such as URL
if (inferredName.length() >= 2) {
if ((Character.isUpperCase(inferredName.charAt(0)))
&& (Character.isUpperCase(inferredName.charAt(1)))) {
newInferredName = inferredName;
}
}
// camelCase the inferred name
if (newInferredName == null) {
newInferredName = Character.toString(Character.toLowerCase(inferredName.charAt(0)));
if (inferredName.length() > 1) {
newInferredName += inferredName.substring(1, inferredName.length());
}
}
inferredName = newInferredName;
// if the property inferred name already exists, don't supply it
if (uniquePropertyNames.contains(inferredName)) {
continue;
}
result.add(
new InternalEventPropDescriptor(inferredName, methods[i], EventPropertyType.MAPPED));
uniquePropertyNames.add(inferredName);
}
}
public Reference createReference(Object bean) throws NamingException {
try {
BeanInfo bi = Introspector.getBeanInfo(bean.getClass());
PropertyDescriptor[] pds = bi.getPropertyDescriptors();
List refAddrs = new ArrayList();
String factoryClassLocation = defaultFactoryClassLocation;
boolean using_ref_props = referenceProperties.size() > 0;
// we only include this so that on dereference we are not surprised to find some properties
// missing
if (using_ref_props)
refAddrs.add(
new BinaryRefAddr(REF_PROPS_KEY, SerializableUtils.toByteArray(referenceProperties)));
for (int i = 0, len = pds.length; i < len; ++i) {
PropertyDescriptor pd = pds[i];
String propertyName = pd.getName();
// System.err.println("Making Reference: " + propertyName);
if (using_ref_props && !referenceProperties.contains(propertyName)) {
// System.err.println("Not a ref_prop -- continuing.");
continue;
}
Class propertyType = pd.getPropertyType();
Method getter = pd.getReadMethod();
Method setter = pd.getWriteMethod();
if (getter != null
&& setter != null) // only use properties that are both readable and writable
{
Object val = getter.invoke(bean, EMPTY_ARGS);
// System.err.println( "val: " + val );
if (propertyName.equals("factoryClassLocation")) {
if (String.class != propertyType)
throw new NamingException(
this.getClass().getName()
+ " requires a factoryClassLocation property to be a string, "
+ propertyType.getName()
+ " is not valid.");
factoryClassLocation = (String) val;
}
if (val == null) {
RefAddr addMe = new BinaryRefAddr(propertyName, NULL_TOKEN_BYTES);
refAddrs.add(addMe);
} else if (Coerce.canCoerce(propertyType)) {
RefAddr addMe = new StringRefAddr(propertyName, String.valueOf(val));
refAddrs.add(addMe);
} else // other Object properties
{
RefAddr addMe = null;
PropertyEditor pe = BeansUtils.findPropertyEditor(pd);
if (pe != null) {
pe.setValue(val);
String textValue = pe.getAsText();
if (textValue != null) addMe = new StringRefAddr(propertyName, textValue);
}
if (addMe == null) // property editor approach failed
addMe =
new BinaryRefAddr(
propertyName,
SerializableUtils.toByteArray(
val, indirector, IndirectPolicy.INDIRECT_ON_EXCEPTION));
refAddrs.add(addMe);
}
} else {
// System.err.println(this.getClass().getName() +
// ": Skipping " + propertyName + " because it is " + (setter == null ?
// "read-only." : "write-only."));
if (logger.isLoggable(MLevel.WARNING))
logger.warning(
this.getClass().getName()
+ ": Skipping "
+ propertyName
+ " because it is "
+ (setter == null ? "read-only." : "write-only."));
}
}
Reference out =
new Reference(bean.getClass().getName(), factoryClassName, factoryClassLocation);
for (Iterator ii = refAddrs.iterator(); ii.hasNext(); ) out.add((RefAddr) ii.next());
return out;
} catch (Exception e) {
// e.printStackTrace();
if (Debug.DEBUG && logger.isLoggable(MLevel.FINE))
logger.log(MLevel.FINE, "Exception trying to create Reference.", e);
throw new NamingException("Could not create reference from bean: " + e.toString());
}
}
public boolean isDirectTransferInProgress(final FrostDownloadItem dlItem) {
final String id = dlItem.getGqIdentifier();
return directGETsInProgress.contains(id);
}
/** Apply the states of FcpRequestPut to the FrostUploadItem. */
private void applyState(final FrostUploadItem ulItem, final FcpPersistentPut putReq) {
// when cancelled and we expect this, don't set failed; don't even set the old priority!
if (ulItem.isInternalRemoveExpected() && putReq.isFailed()) {
final int returnCode = putReq.getCode();
if (returnCode == 25) {
return;
}
}
if (directPUTsWithoutAnswer.contains(ulItem.getGqIdentifier())) {
// we got an answer
directPUTsWithoutAnswer.remove(ulItem.getGqIdentifier());
}
// apply externally changed priority
if (ulItem.getPriority() != putReq.getPriority()) {
if (Core.frostSettings.getBoolValue(SettingsClass.FCP2_ENFORCE_FROST_PRIO_FILE_UPLOAD)) {
// reset priority with our current value
fcpTools.changeRequestPriority(putReq.getIdentifier(), ulItem.getPriority());
} else {
// apply to uploaditem
ulItem.setPriority(putReq.getPriority());
}
}
if (!putReq.isProgressSet() && !putReq.isSuccess() && !putReq.isFailed()) {
if (ulItem.getState() == FrostUploadItem.STATE_WAITING) {
ulItem.setState(FrostUploadItem.STATE_PROGRESS);
}
return;
}
if (putReq.isProgressSet()) {
final int doneBlocks = putReq.getDoneBlocks();
final int totalBlocks = putReq.getTotalBlocks();
final boolean isFinalized = putReq.isFinalized();
if (totalBlocks > 0) {
ulItem.setDoneBlocks(doneBlocks);
ulItem.setTotalBlocks(totalBlocks);
ulItem.setFinalized(isFinalized);
ulItem.fireValueChanged();
}
if (ulItem.getState() != FrostUploadItem.STATE_PROGRESS) {
ulItem.setState(FrostUploadItem.STATE_PROGRESS);
}
}
if (putReq.isSuccess()) {
// maybe progress was not completely sent
ulItem.setFinalized(true);
if (ulItem.getTotalBlocks() > 0 && ulItem.getDoneBlocks() != ulItem.getTotalBlocks()) {
ulItem.setDoneBlocks(ulItem.getTotalBlocks());
}
final String chkKey = putReq.getUri();
if (ulItem.isExternal()) {
ulItem.setState(FrostUploadItem.STATE_DONE);
ulItem.setKey(chkKey);
} else {
final FcpResultPut result = new FcpResultPut(FcpResultPut.Success, chkKey);
FileTransferManager.inst().getUploadManager().notifyUploadFinished(ulItem, result);
}
}
if (putReq.isFailed()) {
final String desc = putReq.getCodeDesc();
if (ulItem.isExternal()) {
ulItem.setState(FrostUploadItem.STATE_FAILED);
ulItem.setErrorCodeDescription(desc);
} else {
final int returnCode = putReq.getCode();
final boolean isFatal = putReq.isFatal();
final FcpResultPut result;
if (returnCode == 9) {
result = new FcpResultPut(FcpResultPut.KeyCollision, returnCode, desc, isFatal);
} else if (returnCode == 5) {
result = new FcpResultPut(FcpResultPut.Retry, returnCode, desc, isFatal);
} else {
result = new FcpResultPut(FcpResultPut.Error, returnCode, desc, isFatal);
}
FileTransferManager.inst().getUploadManager().notifyUploadFinished(ulItem, result);
}
}
}
