/** * Creates the transfer manager factory builder from the {@link Config} * using the configured {@link TransferPlugin}. Using this builder, the * feature-wrapped transfer manager can be built. * * @see TransferManagerBuilder * @param config Local folder configuration with transfer plugin settings * @return Transfer manager builder */ public static TransferManagerBuilder build(Config config) throws StorageException { TransferManager transferManager = config.getTransferPlugin().createTransferManager(config.getConnection(), config); logger.log(Level.INFO, "Building " + transferManager.getClass().getSimpleName() + " from config '" + config.getLocalDir().getName() + "' ..."); return new TransferManagerBuilder(config, transferManager); }
private void applyFeatures() { try { for (Class<? extends Annotation> featureAnnotation : features) { boolean isFeatureSupported = ReflectionUtil.isAnnotationPresentInHierarchy(originalTransferManager.getClass(), featureAnnotation); if (isFeatureSupported) { Class<? extends TransferManager> featureTransferManagerClass = getFeatureTransferManagerClass(featureAnnotation); wrappedTransferManager = apply(wrappedTransferManager, featureTransferManagerClass, featureAnnotation); } else { logger.log(Level.INFO, "- SKIPPING unsupported optional feature " + featureAnnotation.getSimpleName()); } } } catch (IllegalAccessException | InvocationTargetException | InstantiationException e) { throw new RuntimeException("Unable to annotate TransferManager with feature.", e); } }
protected TransferManager createTransferManagerFromNullConfig(ConfigTO configTo) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException, StorageException { // Init plugin and transfer manager TransferPlugin plugin = Plugins.get(configTo.getTransferSettings().getType(), TransferPlugin.class); TransferSettings transferSettings = configTo.getTransferSettings(); transferSettings.setUserInteractionListener(listener); TransferManager transferManager = plugin.createTransferManager(transferSettings, config); // constructor is not visible and config seems to be null at this point, hence we cannot use the build method here Constructor<TransferManagerBuilder> tmbConstructor = TransferManagerBuilder.class.getDeclaredConstructor(Config.class, TransferManager.class); tmbConstructor.setAccessible(true); return tmbConstructor.newInstance(config, transferManager) .withFeature(ReadAfterWriteConsistent.class) .asDefault(); } }
public AbstractTransferOperation(Config config, String operationName) { super(config); this.eventBus = LocalEventBus.getInstance(); try { // Do NOT reuse TransferManager for action file renewal; see #140 TransferManager actionFileTransferManager = TransferManagerFactory .build(config) .withFeature(ReadAfterWriteConsistent.class) .withFeature(Retriable.class) .asDefault(); TransactionAwareFeatureTransferManager regularFileTransferManager = TransferManagerFactory .build(config) .withFeature(ReadAfterWriteConsistent.class) .withFeature(Retriable.class) .withFeature(PathAware.class) .withFeature(TransactionAware.class) .as(TransactionAware.class); this.actionHandler = new ActionFileHandler(actionFileTransferManager, operationName, config.getMachineName()); this.transferManager = regularFileTransferManager; } catch (StorageException e) { logger.log(Level.SEVERE, "Unable to create AbstractTransferOperation: Unable to create TransferManager", e); throw new RuntimeException("Unable to create AbstractTransferOperation: Unable to create TransferManager: " + e.getMessage()); } }
private <T extends TransferManager> T wrap(Class<T> desiredTransferManagerClass) { checkIfAllFeaturesSupported(); checkDuplicateFeatures(); checkRequiredFeatures(); applyFeatures(); return castToDesiredTransferManager(desiredTransferManagerClass); }
/** * Wraps of the previously requested feature transfer managers and casts the result to the requested class. * If no specific class is requested, {@link #asDefault()} can be used instead. * * @param featureAnnotation Feature annotation corresponding to the requested transfer manager * @return {@link TransferManager} casted to the feature lasted wrapped (and requested by this method) */ @SuppressWarnings("unchecked") public <T extends TransferManager> T as(Class<? extends Annotation> featureAnnotation) { Class<T> implementingTransferManagerClass = (Class<T>) getFeatureTransferManagerClass(featureAnnotation); return wrap(implementingTransferManagerClass); }
private TransferManager createTransferManager(TransferManager loadedTransferManager) throws StorageException { if (loadedTransferManager != null) { return loadedTransferManager; } else { return TransferManagerFactory .build(config) .withFeature(PathAware.class) .asDefault(); } }