/** * Wrap proxy with cryptographic feature * * @param type Feature type * @param feature Proxy implementation to wrap with vault features * @return Feature implementation or null when not supported */ @SuppressWarnings("unchecked") public <T> T getFeature(final Class<T> type, final T feature) { return registry.getFeature(this, type, feature); }
@Override public Vault find(final Session session, final Path file) throws VaultUnlockCancelException { return this.find(session, file, true); }
public static Vault get(final Path directory, final String masterkey, final byte[] pepper) { return new VaultFactory().create(directory, masterkey, pepper); }
@Override public AttributedList<Path> list(final Path directory, final ListProgressListener listener) throws BackgroundException { try { final Vault vault = registry.find(session, directory); if(vault.contains(directory)) { return vault.getFeature(session, ListService.class, proxy).list(directory, listener); } if(autodetect) { return new VaultFinderListService(session, proxy, new VaultFinderListProgressListener(lookup)).list(directory, listener); } return proxy.list(directory, listener); } catch(VaultUnlockCancelException e) { log.warn(String.format("Canceled loading vault %s. %s", e.getVault(), e.getDetail())); throw e; } }
@Override @SuppressWarnings("unchecked") public T lock(final Path file) throws BackgroundException { return (T) registry.find(session, file).getFeature(session, Lock.class, proxy).lock(file); }
public static VaultRegistry create(final PasswordCallback callback) { return create(PasswordStoreFactory.get(), callback); }
@Override public AttributedList<Path> list(final Path directory, final ListProgressListener listener) throws BackgroundException { return delegate.list(vault.encrypt(session, directory), new DecryptingListProgressListener(session, vault, listener)); }
public static VaultRegistry create(final HostPasswordStore keychain, final PasswordCallback callback) { return PreferencesFactory.get().getBoolean("cryptomator.enable") ? new DefaultVaultRegistry(keychain, callback) : VaultRegistry.DISABLED; } }
@Override @SuppressWarnings("unchecked") public Output upload(final Path file, final Local local, final BandwidthThrottle throttle, final StreamListener listener, final TransferStatus status, final ConnectionCallback callback) throws BackgroundException { return (Output) registry.find(session, file).getFeature(session, Upload.class, proxy).upload(file, local, throttle, listener, status, callback); }
@Override public boolean isSupported(final Path workdir) { // Run through registry without looking for vaults to circumvent deadlock due to synchronized load of vault try { return registry.find(session, workdir, false).getFeature(session, Touch.class, proxy).isSupported(workdir); } catch(VaultUnlockCancelException e) { return proxy.isSupported(workdir); } }
@Override public boolean isRevertable(final Path file) { try { return registry.find(session, file).getFeature(session, Versioning.class, proxy).isRevertable(file); } catch(VaultUnlockCancelException e) { return false; } }
@Override public LifecycleConfiguration getConfiguration(final Path container) throws BackgroundException { return registry.find(session, container).getFeature(session, Lifecycle.class, proxy).getConfiguration(container); }
@Override public void setEncryption(final Path file, final Algorithm algorithm) throws BackgroundException { registry.find(session, file).getFeature(session, Encryption.class, proxy).setEncryption(file, algorithm); }
@Override public Algorithm getDefault(final Path file) throws BackgroundException { return registry.find(session, file).getFeature(session, Encryption.class, proxy).getDefault(file); }
@Override public void setPermission(final Path file, final Acl acl) throws BackgroundException { registry.find(session, file).getFeature(session, AclPermission.class, proxy).setPermission(file, acl); }
@Override public LoggingConfiguration getConfiguration(final Path container) throws BackgroundException { return registry.find(session, container).getFeature(session, Logging.class, proxy).getConfiguration(container); }
@Override public void setUnixOwner(final Path file, final String owner) throws BackgroundException { registry.find(session, file).getFeature(session, UnixPermission.class, proxy).setUnixOwner(file, owner); }
@Override public void setUnixPermission(final Path file, final Permission permission) throws BackgroundException { registry.find(session, file).getFeature(session, UnixPermission.class, proxy).setUnixPermission(file, permission); }
@Override public PathAttributes find(final Path file) throws BackgroundException { return registry.find(session, file).getFeature(session, AttributesFinder.class, proxy) .withCache(cache) .find(file); }
@Override public ChecksumCompute checksum(final Path file) { try { return registry.find(session, file).getFeature(session, Write.class, proxy).checksum(file); } catch(VaultUnlockCancelException e) { return proxy.checksum(file); } }