@Override public KeyVersion load(String key) throws Exception { KeyVersion kv = provider.getKeyVersion(key); if (kv == null) { throw new KeyNotFoundException(); } return kv; } });
@Override public void close() throws IOException { KeyProvider provider = getKeyProvider(); if (provider != null && provider != this) { provider.close(); } }
/** * Calls {@link CryptoExtension#drain(String)} for the given key name on the * underlying {@link CryptoExtension}. * * @param keyName */ public void drain(String keyName) { getExtension().drain(keyName); }
@Override public void deleteKey(String name) throws IOException { getKeyProvider().deleteKey(name); getExtension().currentKeyCache.invalidate(name); getExtension().keyMetadataCache.invalidate(name); // invalidating all key versions as we don't know // which ones belonged to the deleted key getExtension().keyVersionCache.invalidateAll(); }
@Override public Metadata load(String key) throws Exception { Metadata meta = provider.getMetadata(key); if (meta == null) { throw new KeyNotFoundException(); } return meta; } });
@Override public KeyVersion createKey(String name, byte[] material, Options options) throws IOException { return keyProvider.createKey(name, material, options); }
@Override public KeyVersion rollNewVersion(String name, byte[] material) throws IOException { KeyVersion key = getKeyProvider().rollNewVersion(name, material); invalidateCache(name); return key; }
@Override public KeyVersion load(String key) throws Exception { KeyVersion kv = provider.getCurrentKey(key); if (kv == null) { throw new KeyNotFoundException(); } return kv; } });
/** * Get key metadata in bulk. * @param names the names of the keys to get * @throws IOException */ public Metadata[] getKeysMetadata(String... names) throws IOException { Metadata[] result = new Metadata[names.length]; for (int i=0; i < names.length; ++i) { result[i] = getMetadata(names[i]); } return result; }
/** * Notifies the Underlying CryptoExtension implementation to warm up any * implementation specific caches for the specified KeyVersions * @param keyNames Arrays of key Names */ public void warmUpEncryptedKeys(String... keyNames) throws IOException { getExtension().warmUpEncryptedKeys(keyNames); }
@Override public KeyVersion rollNewVersion(String name) throws NoSuchAlgorithmException, IOException { return keyProvider.rollNewVersion(name); }
public KeyProviderExtension(KeyProvider keyProvider, E extensions) { super(keyProvider.getConf()); this.keyProvider = keyProvider; this.extension = extensions; }
protected void warnIfTransientProvider() { if (provider.isTransient()) { getOut().println("WARNING: you are modifying a transient provider."); } }
@Override public String getCanonicalServiceName() { return getExtension().getCanonicalServiceName(); }
@Override public Token<?> getDelegationToken(final String renewer) throws IOException { return getExtension().getDelegationToken(renewer); }
protected boolean backupToOld(Path oldPath) throws IOException { try { renameOrFail(path, oldPath); return true; } catch (FileNotFoundException e) { return false; } }
public CachingKeyProvider(KeyProvider keyProvider, long keyTimeoutMillis, long currKeyTimeoutMillis) { super(keyProvider, new CacheExtension(keyProvider, keyTimeoutMillis, currKeyTimeoutMillis)); }
@Override public KeyVersion createKey(String name, Options options) throws NoSuchAlgorithmException, IOException { return keyProvider.createKey(name, options); }
@Override public KeyVersion rollNewVersion(String name) throws NoSuchAlgorithmException, IOException { KeyVersion key = getKeyProvider().rollNewVersion(name); invalidateCache(name); return key; }
private void revertFromOld(Path oldPath, boolean fileExisted) throws IOException { if (fileExisted) { renameOrFail(oldPath, path); } }