Datasets:
jitx
/
Methods2Test_java_unit_test_code

Dataset card Data Studio Files Community
target
stringlengths
20
113k
src_fm
stringlengths
11
86.3k
src_fm_fc
stringlengths
21
86.4k
src_fm_fc_co
stringlengths
30
86.4k
src_fm_fc_ms
stringlengths
42
86.8k
src_fm_fc_ms_ff
stringlengths
43
86.8k
@Test public void testDeleteReadonlyPolicy() throws Exception { DeletePolicyRequest request = new DeletePolicyRequest().withPolicyArn(READONLY_POLICY_ARN); partiallyMockedPolicyManager.deleteReadonlyPolicy(group); verify(mockClient, times(1)).deletePolicy(request); }
public void deleteReadonlyPolicy(SecretsGroupIdentifier group) { deletePolicy(group, AccessLevel.READONLY); }
IAMPolicyManager { public void deleteReadonlyPolicy(SecretsGroupIdentifier group) { deletePolicy(group, AccessLevel.READONLY); } }
IAMPolicyManager { public void deleteReadonlyPolicy(SecretsGroupIdentifier group) { deletePolicy(group, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); }
IAMPolicyManager { public void deleteReadonlyPolicy(SecretsGroupIdentifier group) { deletePolicy(group, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); }
IAMPolicyManager { public void deleteReadonlyPolicy(SecretsGroupIdentifier group) { deletePolicy(group, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }
@Test public void testToString() throws Exception { assertEquals(resourceName.toString(), resourceAsString); }
@Override public String toString() { return String.format("%s_%s_%s", PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name)); }
RegionLocalResourceName { @Override public String toString() { return String.format("%s_%s_%s", PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name)); } }
RegionLocalResourceName { @Override public String toString() { return String.format("%s_%s_%s", PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name)); } RegionLocalResourceName(SecretsGroupIdentifier group); }
RegionLocalResourceName { @Override public String toString() { return String.format("%s_%s_%s", PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name)); } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); }
RegionLocalResourceName { @Override public String toString() { return String.format("%s_%s_%s", PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name)); } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; }
@Test public void testFromString() throws Exception { assertEquals(RegionLocalResourceName.fromString(resourceAsString).group, resourceName.group); assertEquals(RegionLocalResourceName.fromString(resourceAsString).toString(), resourceAsString); }
public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); }
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } }
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } RegionLocalResourceName(SecretsGroupIdentifier group); }
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); }
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromStringInvalidPrefix() throws Exception { RegionLocalResourceName.fromString("sm_us-west-1_test-group"); }
public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); }
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } }
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } RegionLocalResourceName(SecretsGroupIdentifier group); }
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); }
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromStringMissingRegion() throws Exception { RegionLocalResourceName.fromString("strongbox_test-group"); }
public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); }
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } }
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } RegionLocalResourceName(SecretsGroupIdentifier group); }
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); }
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; }
@Test public void testEquals() { assertTrue(resourceName.equals(resourceName)); assertTrue(resourceName.equals(new RegionLocalResourceName(new SecretsGroupIdentifier(Region.US_WEST_1, "test.group")))); assertFalse(resourceName.equals(new RegionLocalResourceName(new SecretsGroupIdentifier(Region.EU_WEST_1, "test.group")))); assertFalse(resourceName.equals(new RegionLocalResourceName(new SecretsGroupIdentifier(Region.US_WEST_1, "test.group2")))); assertFalse(resourceName.equals(resourceAsString)); }
@Override public boolean equals(final Object obj) { if(obj instanceof RegionLocalResourceName){ final RegionLocalResourceName other = (RegionLocalResourceName) obj; return Objects.equal(group, other.group); } else{ return false; } }
RegionLocalResourceName { @Override public boolean equals(final Object obj) { if(obj instanceof RegionLocalResourceName){ final RegionLocalResourceName other = (RegionLocalResourceName) obj; return Objects.equal(group, other.group); } else{ return false; } } }
RegionLocalResourceName { @Override public boolean equals(final Object obj) { if(obj instanceof RegionLocalResourceName){ final RegionLocalResourceName other = (RegionLocalResourceName) obj; return Objects.equal(group, other.group); } else{ return false; } } RegionLocalResourceName(SecretsGroupIdentifier group); }
RegionLocalResourceName { @Override public boolean equals(final Object obj) { if(obj instanceof RegionLocalResourceName){ final RegionLocalResourceName other = (RegionLocalResourceName) obj; return Objects.equal(group, other.group); } else{ return false; } } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); }
RegionLocalResourceName { @Override public boolean equals(final Object obj) { if(obj instanceof RegionLocalResourceName){ final RegionLocalResourceName other = (RegionLocalResourceName) obj; return Objects.equal(group, other.group); } else{ return false; } } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; }
@Test public void resolve_filename() { ProfileIdentifier profile = new ProfileIdentifier("my-profile"); RoleARN arn = new RoleARN("arn:aws:iam::12345678910:role/my-role"); SessionCache sessionCache = new SessionCache(profile, arn); assertThat(sessionCache.resolveFileName(), is("my-profile--arn_aws_iam__12345678910_role-my-role.json")); }
String resolveFileName() { return String.format("%s--%s.json", profile.name, roleToAssume.toArn().replace(':', '_').replace('/', '-')); }
SessionCache { String resolveFileName() { return String.format("%s--%s.json", profile.name, roleToAssume.toArn().replace(':', '_').replace('/', '-')); } }
SessionCache { String resolveFileName() { return String.format("%s--%s.json", profile.name, roleToAssume.toArn().replace(':', '_').replace('/', '-')); } SessionCache(final ProfileIdentifier profile, final RoleARN roleToAssume); }
SessionCache { String resolveFileName() { return String.format("%s--%s.json", profile.name, roleToAssume.toArn().replace(':', '_').replace('/', '-')); } SessionCache(final ProfileIdentifier profile, final RoleARN roleToAssume); Optional<BasicSessionCredentials> load(); void save(final AssumedRoleUser assumedRoleUser, final BasicSessionCredentials credentials, final ZonedDateTime expiration); }
SessionCache { String resolveFileName() { return String.format("%s--%s.json", profile.name, roleToAssume.toArn().replace(':', '_').replace('/', '-')); } SessionCache(final ProfileIdentifier profile, final RoleARN roleToAssume); Optional<BasicSessionCredentials> load(); void save(final AssumedRoleUser assumedRoleUser, final BasicSessionCredentials credentials, final ZonedDateTime expiration); }
@Test public void single_section_single_property() { AWSCLIConfigFile configFile = new AWSCLIConfigFile(new File("")); AWSCLIConfigFile.Config config = configFile.getConfig(asBufferedReader("[default]\nkey=value\n")); assertSectionAndPropertyExists(config, "default", new AWSCLIConfigFile.Property("key", "value")); }
public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); Config getConfig(); static Optional<File> getCredentialProfilesFile(); static Optional<File> getConfigFile(); }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); Config getConfig(); static Optional<File> getCredentialProfilesFile(); static Optional<File> getConfigFile(); }
@Test public void multiple_sections_multiple_properties() { AWSCLIConfigFile configFile = new AWSCLIConfigFile(new File("")); AWSCLIConfigFile.Config config = configFile.getConfig(asBufferedReader("[default]\nkey=value\n[my section]\nkey2=value2\nkey3=value3")); assertSectionAndPropertyExists(config, "default", new AWSCLIConfigFile.Property("key", "value")); assertSectionAndPropertyExists(config, "my section", new AWSCLIConfigFile.Property("key2", "value2")); assertSectionAndPropertyExists(config, "my section", new AWSCLIConfigFile.Property("key3", "value3")); }
public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); Config getConfig(); static Optional<File> getCredentialProfilesFile(); static Optional<File> getConfigFile(); }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); Config getConfig(); static Optional<File> getCredentialProfilesFile(); static Optional<File> getConfigFile(); }
@Test public void surrounding_spaces_in_section_name() { AWSCLIConfigFile configFile = new AWSCLIConfigFile(new File("")); AWSCLIConfigFile.Config config = configFile.getConfig(asBufferedReader("[ default ]\nkey=value\n")); assertSectionAndPropertyExists(config, "default", new AWSCLIConfigFile.Property("key", "value")); }
public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); Config getConfig(); static Optional<File> getCredentialProfilesFile(); static Optional<File> getConfigFile(); }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); Config getConfig(); static Optional<File> getCredentialProfilesFile(); static Optional<File> getConfigFile(); }
@Test public void testAutoSuggestionCaseInsensitive() throws Exception { ListRolesRequest request = new ListRolesRequest().withMaxItems(1000); Role lowercase = new Role().withRoleName("foobar"); Role uppercase = new Role().withRoleName("FOOBAR"); Role mixedCase = new Role().withRoleName("FooBar"); ListRolesResult mockResult = new ListRolesResult(); mockResult.withRoles(lowercase, uppercase, mixedCase); when(mockClient.listRoles(request)).thenReturn(mockResult); List<Principal> list = partiallyMockedPrincipalAutoSuggestion.autoSuggestion("fOOb"); assertEquals(list.size(), 3); assertEquals(list.get(0).name, "foobar"); assertEquals(list.get(1).name, "FOOBAR"); assertEquals(list.get(2).name, "FooBar"); }
public List<Principal> autoSuggestion(final String name) { if (name.length() >= 3) { String lowerCaseName = name.toLowerCase(); ListRolesRequest listRolesRequest = new ListRolesRequest(); listRolesRequest.withMaxItems(1000); ListRolesResult result = client.listRoles(listRolesRequest); List<Principal> tmp = result.getRoles().stream() .filter(p -> p.getRoleName().toLowerCase().contains(lowerCaseName)) .map(p -> new Principal(PrincipalType.ROLE, p.getRoleName())).collect(Collectors.toList()); return tmp.subList(0, Math.min(5, tmp.size())); } return new ArrayList<>(); }
PrincipalAutoSuggestion { public List<Principal> autoSuggestion(final String name) { if (name.length() >= 3) { String lowerCaseName = name.toLowerCase(); ListRolesRequest listRolesRequest = new ListRolesRequest(); listRolesRequest.withMaxItems(1000); ListRolesResult result = client.listRoles(listRolesRequest); List<Principal> tmp = result.getRoles().stream() .filter(p -> p.getRoleName().toLowerCase().contains(lowerCaseName)) .map(p -> new Principal(PrincipalType.ROLE, p.getRoleName())).collect(Collectors.toList()); return tmp.subList(0, Math.min(5, tmp.size())); } return new ArrayList<>(); } }
PrincipalAutoSuggestion { public List<Principal> autoSuggestion(final String name) { if (name.length() >= 3) { String lowerCaseName = name.toLowerCase(); ListRolesRequest listRolesRequest = new ListRolesRequest(); listRolesRequest.withMaxItems(1000); ListRolesResult result = client.listRoles(listRolesRequest); List<Principal> tmp = result.getRoles().stream() .filter(p -> p.getRoleName().toLowerCase().contains(lowerCaseName)) .map(p -> new Principal(PrincipalType.ROLE, p.getRoleName())).collect(Collectors.toList()); return tmp.subList(0, Math.min(5, tmp.size())); } return new ArrayList<>(); } PrincipalAutoSuggestion(AmazonIdentityManagement client); }
PrincipalAutoSuggestion { public List<Principal> autoSuggestion(final String name) { if (name.length() >= 3) { String lowerCaseName = name.toLowerCase(); ListRolesRequest listRolesRequest = new ListRolesRequest(); listRolesRequest.withMaxItems(1000); ListRolesResult result = client.listRoles(listRolesRequest); List<Principal> tmp = result.getRoles().stream() .filter(p -> p.getRoleName().toLowerCase().contains(lowerCaseName)) .map(p -> new Principal(PrincipalType.ROLE, p.getRoleName())).collect(Collectors.toList()); return tmp.subList(0, Math.min(5, tmp.size())); } return new ArrayList<>(); } PrincipalAutoSuggestion(AmazonIdentityManagement client); static PrincipalAutoSuggestion fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); List<Principal> autoSuggestion(final String name); }
PrincipalAutoSuggestion { public List<Principal> autoSuggestion(final String name) { if (name.length() >= 3) { String lowerCaseName = name.toLowerCase(); ListRolesRequest listRolesRequest = new ListRolesRequest(); listRolesRequest.withMaxItems(1000); ListRolesResult result = client.listRoles(listRolesRequest); List<Principal> tmp = result.getRoles().stream() .filter(p -> p.getRoleName().toLowerCase().contains(lowerCaseName)) .map(p -> new Principal(PrincipalType.ROLE, p.getRoleName())).collect(Collectors.toList()); return tmp.subList(0, Math.min(5, tmp.size())); } return new ArrayList<>(); } PrincipalAutoSuggestion(AmazonIdentityManagement client); static PrincipalAutoSuggestion fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); List<Principal> autoSuggestion(final String name); }
@Test public void surrounding_spaces_in_property() { AWSCLIConfigFile configFile = new AWSCLIConfigFile(new File("")); AWSCLIConfigFile.Config config = configFile.getConfig(asBufferedReader("[default]\n key = value \n")); assertSectionAndPropertyExists(config, "default", new AWSCLIConfigFile.Property("key", "value")); }
public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); Config getConfig(); static Optional<File> getCredentialProfilesFile(); static Optional<File> getConfigFile(); }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); Config getConfig(); static Optional<File> getCredentialProfilesFile(); static Optional<File> getConfigFile(); }
@Test public void when_there_are_duplicate_properties_use_the_last() { AWSCLIConfigFile configFile = new AWSCLIConfigFile(new File("")); AWSCLIConfigFile.Config config = configFile.getConfig(asBufferedReader("[default]\nkey=value\n[default]\nkey=value2\n")); assertSectionAndPropertyExists(config, "default", new AWSCLIConfigFile.Property("key", "value2")); }
public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); Config getConfig(); static Optional<File> getCredentialProfilesFile(); static Optional<File> getConfigFile(); }
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); Config getConfig(); static Optional<File> getCredentialProfilesFile(); static Optional<File> getConfigFile(); }
@Test public void testEncrypt() throws Exception { String plaintext = "jsonblob"; EncryptionContext mockContext = mock(EncryptionContext.class); CryptoResult mockCryptoResult = mock(CryptoResult.class); Map<String, String> contextMap = new HashMap<>(); when(mockContext.toMap()).thenReturn(contextMap); when(mockCryptoResult.getResult()).thenReturn(encryptedPayload); when(mockAwsCrypto.encryptString(mockProvider, plaintext, contextMap)).thenReturn( mockCryptoResult); assertEquals(kmsEncryptor.encrypt(plaintext, mockContext), encryptedPayload); }
@Override public String encrypt(String plaintext, EncryptionContext context) { return crypto.encryptString(getProvider(), plaintext, context.toMap()).getResult(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public String encrypt(String plaintext, EncryptionContext context) { return crypto.encryptString(getProvider(), plaintext, context.toMap()).getResult(); } }
KMSEncryptor implements Encryptor, ManagedResource { @Override public String encrypt(String plaintext, EncryptionContext context) { return crypto.encryptString(getProvider(), plaintext, context.toMap()).getResult(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public String encrypt(String plaintext, EncryptionContext context) { return crypto.encryptString(getProvider(), plaintext, context.toMap()).getResult(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public String encrypt(String plaintext, EncryptionContext context) { return crypto.encryptString(getProvider(), plaintext, context.toMap()).getResult(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
@Test public void testCreate() throws Exception { when(mockKmsManager.create()).thenReturn(KMS_ARN); assertEquals(kmsEncryptor.create(), KMS_ARN); verify(mockKmsManager, times(1)).create(); }
@Override public String create() { return kmsManager.create(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public String create() { return kmsManager.create(); } }
KMSEncryptor implements Encryptor, ManagedResource { @Override public String create() { return kmsManager.create(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public String create() { return kmsManager.create(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public String create() { return kmsManager.create(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
@Test public void testDelete() throws Exception { kmsEncryptor.delete(); verify(mockKmsManager, times(1)).delete(); }
@Override public void delete() { kmsManager.delete(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public void delete() { kmsManager.delete(); } }
KMSEncryptor implements Encryptor, ManagedResource { @Override public void delete() { kmsManager.delete(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public void delete() { kmsManager.delete(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public void delete() { kmsManager.delete(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
@Test public void testAwsAdminPolicy() throws Exception { String adminPolicy = "Admin policy"; when(mockKmsManager.awsAdminPolicy()).thenReturn(Optional.of(adminPolicy)); assertEquals(kmsEncryptor.awsAdminPolicy().get(),adminPolicy); verify(mockKmsManager, times(1)).awsAdminPolicy(); }
@Override public Optional<String> awsAdminPolicy() { return kmsManager.awsAdminPolicy(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public Optional<String> awsAdminPolicy() { return kmsManager.awsAdminPolicy(); } }
KMSEncryptor implements Encryptor, ManagedResource { @Override public Optional<String> awsAdminPolicy() { return kmsManager.awsAdminPolicy(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public Optional<String> awsAdminPolicy() { return kmsManager.awsAdminPolicy(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public Optional<String> awsAdminPolicy() { return kmsManager.awsAdminPolicy(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
@Test public void testAwsReadOnlyPolicy() throws Exception { String readonlyPolicy = "Readonly policy"; when(mockKmsManager.awsReadOnlyPolicy()).thenReturn(Optional.of(readonlyPolicy)); assertEquals(kmsEncryptor.awsReadOnlyPolicy().get(), readonlyPolicy); verify(mockKmsManager, times(1)).awsReadOnlyPolicy(); }
@Override public Optional<String> awsReadOnlyPolicy() { return kmsManager.awsReadOnlyPolicy(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public Optional<String> awsReadOnlyPolicy() { return kmsManager.awsReadOnlyPolicy(); } }
KMSEncryptor implements Encryptor, ManagedResource { @Override public Optional<String> awsReadOnlyPolicy() { return kmsManager.awsReadOnlyPolicy(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public Optional<String> awsReadOnlyPolicy() { return kmsManager.awsReadOnlyPolicy(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public Optional<String> awsReadOnlyPolicy() { return kmsManager.awsReadOnlyPolicy(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
@Test public void testGetArn() throws Exception { when(mockKmsManager.getArn()).thenReturn(KMS_ARN); assertEquals(kmsEncryptor.getArn(), KMS_ARN); verify(mockKmsManager, times(1)).getArn(); }
@Override public String getArn() { return kmsManager.getArn(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public String getArn() { return kmsManager.getArn(); } }
KMSEncryptor implements Encryptor, ManagedResource { @Override public String getArn() { return kmsManager.getArn(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public String getArn() { return kmsManager.getArn(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public String getArn() { return kmsManager.getArn(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
@Test public void testExists() throws Exception { when(mockKmsManager.exists()).thenReturn(true); assertTrue(kmsEncryptor.exists()); verify(mockKmsManager, times(1)).exists(); }
@Override public boolean exists() { return kmsManager.exists(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public boolean exists() { return kmsManager.exists(); } }
KMSEncryptor implements Encryptor, ManagedResource { @Override public boolean exists() { return kmsManager.exists(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public boolean exists() { return kmsManager.exists(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
KMSEncryptor implements Encryptor, ManagedResource { @Override public boolean exists() { return kmsManager.exists(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }
@Test public void testToMap() { DefaultEncryptionContext context = new DefaultEncryptionContext( new SecretsGroupIdentifier(Region.US_WEST_1, "test.group"), new SecretIdentifier("secret1"), Long.parseUnsignedLong("8446744073709551615"), State.ENABLED, Optional.of(ZonedDateTime.of(2016,1,2,3,4,0,0, ZoneId.of("UTC"))), Optional.empty() ); Map<String, String> map = context.toMap(); assertEquals(map.get("0"), "us-west-1 "); assertEquals(map.get("0").length(), 14); assertEquals(map.get("1"), "test.group "); assertEquals(map.get("1").length(), 64); assertEquals(map.get("2"), "secret1 "); assertEquals(map.get("2").length(), 128); assertEquals(map.get("3"), "08446744073709551615"); assertEquals(map.get("3").length(), 20); assertEquals(map.get("4"), "2"); assertEquals(map.get("4").length(), 1); assertEquals(map.get("5"), "1"); assertEquals(map.get("5").length(), 1); assertEquals(map.get("6"), "00000000001451703840"); assertEquals(map.get("6").length(), 20); assertEquals(map.get("7"), "0"); assertEquals(map.get("7").length(), 1); assertEquals(map.get("8"), "00000000000000000000"); assertEquals(map.get("8").length(), 20); }
@Override public Map<String, String> toMap() { ImmutableMap.Builder<String, String> builder = ImmutableMap.builder(); builder.put("0", Padding.padWithSpaces(groupIdentifier.region.getName(), 14)); builder.put("1", Padding.padWithSpaces(groupIdentifier.name, 64)); builder.put("2", Padding.padWithSpaces(secretIdentifier.name, 128)); builder.put("3", Padding.padWithZeros(secretVersion)); builder.put("4", Padding.singleDigit(state.asByte())); builder.put("5", Padding.isPresent(notBefore)); builder.put("6", Padding.asOptionalString(notBefore)); builder.put("7", Padding.isPresent(notAfter)); builder.put("8", Padding.asOptionalString(notAfter)); return builder.build(); }
DefaultEncryptionContext implements EncryptionContext { @Override public Map<String, String> toMap() { ImmutableMap.Builder<String, String> builder = ImmutableMap.builder(); builder.put("0", Padding.padWithSpaces(groupIdentifier.region.getName(), 14)); builder.put("1", Padding.padWithSpaces(groupIdentifier.name, 64)); builder.put("2", Padding.padWithSpaces(secretIdentifier.name, 128)); builder.put("3", Padding.padWithZeros(secretVersion)); builder.put("4", Padding.singleDigit(state.asByte())); builder.put("5", Padding.isPresent(notBefore)); builder.put("6", Padding.asOptionalString(notBefore)); builder.put("7", Padding.isPresent(notAfter)); builder.put("8", Padding.asOptionalString(notAfter)); return builder.build(); } }
DefaultEncryptionContext implements EncryptionContext { @Override public Map<String, String> toMap() { ImmutableMap.Builder<String, String> builder = ImmutableMap.builder(); builder.put("0", Padding.padWithSpaces(groupIdentifier.region.getName(), 14)); builder.put("1", Padding.padWithSpaces(groupIdentifier.name, 64)); builder.put("2", Padding.padWithSpaces(secretIdentifier.name, 128)); builder.put("3", Padding.padWithZeros(secretVersion)); builder.put("4", Padding.singleDigit(state.asByte())); builder.put("5", Padding.isPresent(notBefore)); builder.put("6", Padding.asOptionalString(notBefore)); builder.put("7", Padding.isPresent(notAfter)); builder.put("8", Padding.asOptionalString(notAfter)); return builder.build(); } DefaultEncryptionContext(SecretsGroupIdentifier groupIdentifier, SecretIdentifier secretIdentifier, long secretVersion, State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); }
DefaultEncryptionContext implements EncryptionContext { @Override public Map<String, String> toMap() { ImmutableMap.Builder<String, String> builder = ImmutableMap.builder(); builder.put("0", Padding.padWithSpaces(groupIdentifier.region.getName(), 14)); builder.put("1", Padding.padWithSpaces(groupIdentifier.name, 64)); builder.put("2", Padding.padWithSpaces(secretIdentifier.name, 128)); builder.put("3", Padding.padWithZeros(secretVersion)); builder.put("4", Padding.singleDigit(state.asByte())); builder.put("5", Padding.isPresent(notBefore)); builder.put("6", Padding.asOptionalString(notBefore)); builder.put("7", Padding.isPresent(notAfter)); builder.put("8", Padding.asOptionalString(notAfter)); return builder.build(); } DefaultEncryptionContext(SecretsGroupIdentifier groupIdentifier, SecretIdentifier secretIdentifier, long secretVersion, State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); @Override Map<String, String> toMap(); }
DefaultEncryptionContext implements EncryptionContext { @Override public Map<String, String> toMap() { ImmutableMap.Builder<String, String> builder = ImmutableMap.builder(); builder.put("0", Padding.padWithSpaces(groupIdentifier.region.getName(), 14)); builder.put("1", Padding.padWithSpaces(groupIdentifier.name, 64)); builder.put("2", Padding.padWithSpaces(secretIdentifier.name, 128)); builder.put("3", Padding.padWithZeros(secretVersion)); builder.put("4", Padding.singleDigit(state.asByte())); builder.put("5", Padding.isPresent(notBefore)); builder.put("6", Padding.asOptionalString(notBefore)); builder.put("7", Padding.isPresent(notAfter)); builder.put("8", Padding.asOptionalString(notAfter)); return builder.build(); } DefaultEncryptionContext(SecretsGroupIdentifier groupIdentifier, SecretIdentifier secretIdentifier, long secretVersion, State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); @Override Map<String, String> toMap(); final SecretsGroupIdentifier groupIdentifier; final SecretIdentifier secretIdentifier; final Long secretVersion; final State state; final Optional<ZonedDateTime> notBefore; final Optional<ZonedDateTime> notAfter; }
@Test public void testGetAdminPolicyArn() throws Exception { String arn = partiallyMockedPolicyManager.getAdminPolicyArn(group); assertEquals(arn, ADMIN_POLICY_ARN); }
public String getAdminPolicyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.ADMIN); }
IAMPolicyManager { public String getAdminPolicyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.ADMIN); } }
IAMPolicyManager { public String getAdminPolicyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); }
IAMPolicyManager { public String getAdminPolicyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); }
IAMPolicyManager { public String getAdminPolicyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }
@Test public void testCreate() throws Exception { CreateKeyRequest createKeyRequest = new CreateKeyRequest().withDescription( "This key is automatically managed by Strongbox"); CreateKeyResult createKeyResult = new CreateKeyResult().withKeyMetadata(new KeyMetadata().withArn(KMS_ARN)); CreateAliasRequest createAliasRequest = new CreateAliasRequest().withAliasName(ALIAS_KEY_NAME).withTargetKeyId(KMS_ARN); when(mockKMSClient.describeKey(describeKeyRequest)) .thenThrow(NotFoundException.class) .thenThrow(NotFoundException.class) .thenReturn(enabledKeyResult()); when(mockKMSClient.createKey(createKeyRequest)).thenReturn(createKeyResult); String arn = kmsManager.create(); assertEquals(arn, KMS_ARN); verify(mockKMSClient, times(3)).describeKey(describeKeyRequest); verify(mockKMSClient, times(1)).createAlias(createAliasRequest); verify(mockKMSClient, times(1)).createKey(createKeyRequest); }
public String create(boolean allowExistingPendingDeletedOrDisabledKey) { String arn; Optional<KeyMetadata> current = describeKey(); if (current.isPresent()) { if (!allowExistingPendingDeletedOrDisabledKey) { throw new com.schibsted.security.strongbox.sdk.exceptions.AlreadyExistsException(String.format( "KMS key already exists for group=%s,region=%s, and override not set", group.name, group.region.getName())); } arn = current.get().getArn(); KMSKeyState state = KMSKeyState.fromString(current.get().getKeyState()); switch (state) { case PENDING_DELETION: CancelKeyDeletionRequest request = new CancelKeyDeletionRequest(); request.withKeyId(arn); kms.cancelKeyDeletion(request); case DISABLED: EnableKeyRequest enableKeyRequest = new EnableKeyRequest(); enableKeyRequest.withKeyId(arn); kms.enableKey(enableKeyRequest); break; default: throw new com.schibsted.security.strongbox.sdk.exceptions.AlreadyExistsException(String.format( "KMS key already exists for group=%s,region=%s", group.name, group.region.getName())); } } else { CreateKeyRequest keyRequest = new CreateKeyRequest(); keyRequest.setDescription("This key is automatically managed by Strongbox"); CreateKeyResult result = kms.createKey(keyRequest); arn = result.getKeyMetadata().getArn(); CreateAliasRequest createAliasRequest = new CreateAliasRequest(); createAliasRequest.setAliasName(aliasKeyName); createAliasRequest.setTargetKeyId(arn); kms.createAlias(createAliasRequest); EnableKeyRotationRequest enableKeyRotationRequest = new EnableKeyRotationRequest(); enableKeyRotationRequest.setKeyId(arn); kms.enableKeyRotation(enableKeyRotationRequest); } waitForKeyState(KMSKeyState.ENABLED); return arn; }
KMSManager implements ManagedResource { public String create(boolean allowExistingPendingDeletedOrDisabledKey) { String arn; Optional<KeyMetadata> current = describeKey(); if (current.isPresent()) { if (!allowExistingPendingDeletedOrDisabledKey) { throw new com.schibsted.security.strongbox.sdk.exceptions.AlreadyExistsException(String.format( "KMS key already exists for group=%s,region=%s, and override not set", group.name, group.region.getName())); } arn = current.get().getArn(); KMSKeyState state = KMSKeyState.fromString(current.get().getKeyState()); switch (state) { case PENDING_DELETION: CancelKeyDeletionRequest request = new CancelKeyDeletionRequest(); request.withKeyId(arn); kms.cancelKeyDeletion(request); case DISABLED: EnableKeyRequest enableKeyRequest = new EnableKeyRequest(); enableKeyRequest.withKeyId(arn); kms.enableKey(enableKeyRequest); break; default: throw new com.schibsted.security.strongbox.sdk.exceptions.AlreadyExistsException(String.format( "KMS key already exists for group=%s,region=%s", group.name, group.region.getName())); } } else { CreateKeyRequest keyRequest = new CreateKeyRequest(); keyRequest.setDescription("This key is automatically managed by Strongbox"); CreateKeyResult result = kms.createKey(keyRequest); arn = result.getKeyMetadata().getArn(); CreateAliasRequest createAliasRequest = new CreateAliasRequest(); createAliasRequest.setAliasName(aliasKeyName); createAliasRequest.setTargetKeyId(arn); kms.createAlias(createAliasRequest); EnableKeyRotationRequest enableKeyRotationRequest = new EnableKeyRotationRequest(); enableKeyRotationRequest.setKeyId(arn); kms.enableKeyRotation(enableKeyRotationRequest); } waitForKeyState(KMSKeyState.ENABLED); return arn; } }
KMSManager implements ManagedResource { public String create(boolean allowExistingPendingDeletedOrDisabledKey) { String arn; Optional<KeyMetadata> current = describeKey(); if (current.isPresent()) { if (!allowExistingPendingDeletedOrDisabledKey) { throw new com.schibsted.security.strongbox.sdk.exceptions.AlreadyExistsException(String.format( "KMS key already exists for group=%s,region=%s, and override not set", group.name, group.region.getName())); } arn = current.get().getArn(); KMSKeyState state = KMSKeyState.fromString(current.get().getKeyState()); switch (state) { case PENDING_DELETION: CancelKeyDeletionRequest request = new CancelKeyDeletionRequest(); request.withKeyId(arn); kms.cancelKeyDeletion(request); case DISABLED: EnableKeyRequest enableKeyRequest = new EnableKeyRequest(); enableKeyRequest.withKeyId(arn); kms.enableKey(enableKeyRequest); break; default: throw new com.schibsted.security.strongbox.sdk.exceptions.AlreadyExistsException(String.format( "KMS key already exists for group=%s,region=%s", group.name, group.region.getName())); } } else { CreateKeyRequest keyRequest = new CreateKeyRequest(); keyRequest.setDescription("This key is automatically managed by Strongbox"); CreateKeyResult result = kms.createKey(keyRequest); arn = result.getKeyMetadata().getArn(); CreateAliasRequest createAliasRequest = new CreateAliasRequest(); createAliasRequest.setAliasName(aliasKeyName); createAliasRequest.setTargetKeyId(arn); kms.createAlias(createAliasRequest); EnableKeyRotationRequest enableKeyRotationRequest = new EnableKeyRotationRequest(); enableKeyRotationRequest.setKeyId(arn); kms.enableKeyRotation(enableKeyRotationRequest); } waitForKeyState(KMSKeyState.ENABLED); return arn; } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); }
KMSManager implements ManagedResource { public String create(boolean allowExistingPendingDeletedOrDisabledKey) { String arn; Optional<KeyMetadata> current = describeKey(); if (current.isPresent()) { if (!allowExistingPendingDeletedOrDisabledKey) { throw new com.schibsted.security.strongbox.sdk.exceptions.AlreadyExistsException(String.format( "KMS key already exists for group=%s,region=%s, and override not set", group.name, group.region.getName())); } arn = current.get().getArn(); KMSKeyState state = KMSKeyState.fromString(current.get().getKeyState()); switch (state) { case PENDING_DELETION: CancelKeyDeletionRequest request = new CancelKeyDeletionRequest(); request.withKeyId(arn); kms.cancelKeyDeletion(request); case DISABLED: EnableKeyRequest enableKeyRequest = new EnableKeyRequest(); enableKeyRequest.withKeyId(arn); kms.enableKey(enableKeyRequest); break; default: throw new com.schibsted.security.strongbox.sdk.exceptions.AlreadyExistsException(String.format( "KMS key already exists for group=%s,region=%s", group.name, group.region.getName())); } } else { CreateKeyRequest keyRequest = new CreateKeyRequest(); keyRequest.setDescription("This key is automatically managed by Strongbox"); CreateKeyResult result = kms.createKey(keyRequest); arn = result.getKeyMetadata().getArn(); CreateAliasRequest createAliasRequest = new CreateAliasRequest(); createAliasRequest.setAliasName(aliasKeyName); createAliasRequest.setTargetKeyId(arn); kms.createAlias(createAliasRequest); EnableKeyRotationRequest enableKeyRotationRequest = new EnableKeyRotationRequest(); enableKeyRotationRequest.setKeyId(arn); kms.enableKeyRotation(enableKeyRotationRequest); } waitForKeyState(KMSKeyState.ENABLED); return arn; } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); static KMSManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override String create(); byte[] generateRandom(Integer numberOfBytes); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); String getAliasArn(); int pendingDeletionWindowInDays(); }
KMSManager implements ManagedResource { public String create(boolean allowExistingPendingDeletedOrDisabledKey) { String arn; Optional<KeyMetadata> current = describeKey(); if (current.isPresent()) { if (!allowExistingPendingDeletedOrDisabledKey) { throw new com.schibsted.security.strongbox.sdk.exceptions.AlreadyExistsException(String.format( "KMS key already exists for group=%s,region=%s, and override not set", group.name, group.region.getName())); } arn = current.get().getArn(); KMSKeyState state = KMSKeyState.fromString(current.get().getKeyState()); switch (state) { case PENDING_DELETION: CancelKeyDeletionRequest request = new CancelKeyDeletionRequest(); request.withKeyId(arn); kms.cancelKeyDeletion(request); case DISABLED: EnableKeyRequest enableKeyRequest = new EnableKeyRequest(); enableKeyRequest.withKeyId(arn); kms.enableKey(enableKeyRequest); break; default: throw new com.schibsted.security.strongbox.sdk.exceptions.AlreadyExistsException(String.format( "KMS key already exists for group=%s,region=%s", group.name, group.region.getName())); } } else { CreateKeyRequest keyRequest = new CreateKeyRequest(); keyRequest.setDescription("This key is automatically managed by Strongbox"); CreateKeyResult result = kms.createKey(keyRequest); arn = result.getKeyMetadata().getArn(); CreateAliasRequest createAliasRequest = new CreateAliasRequest(); createAliasRequest.setAliasName(aliasKeyName); createAliasRequest.setTargetKeyId(arn); kms.createAlias(createAliasRequest); EnableKeyRotationRequest enableKeyRotationRequest = new EnableKeyRotationRequest(); enableKeyRotationRequest.setKeyId(arn); kms.enableKeyRotation(enableKeyRotationRequest); } waitForKeyState(KMSKeyState.ENABLED); return arn; } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); static KMSManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override String create(); byte[] generateRandom(Integer numberOfBytes); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); String getAliasArn(); int pendingDeletionWindowInDays(); }
@Test public void testDelete() throws Exception { ScheduleKeyDeletionRequest deleteRequest = new ScheduleKeyDeletionRequest() .withKeyId(KMS_ARN) .withPendingWindowInDays(7); ScheduleKeyDeletionResult deleteResult = new ScheduleKeyDeletionResult(). withDeletionDate(new Date()); when(mockKMSClient.scheduleKeyDeletion(deleteRequest)).thenReturn(deleteResult); when(mockKMSClient.describeKey(describeKeyRequest)) .thenReturn(enabledKeyResult()) .thenReturn(enabledKeyResult()) .thenReturn(constructDescribeKeyResult(KeyState.PendingDeletion)); kmsManager.delete(); verify(mockKMSClient, times(3)).describeKey(describeKeyRequest); verify(mockKMSClient, times(1)).scheduleKeyDeletion(deleteRequest); }
@Override public void delete() { deleteAndGetSchedule(); waitForKeyState(KMSKeyState.PENDING_DELETION); }
KMSManager implements ManagedResource { @Override public void delete() { deleteAndGetSchedule(); waitForKeyState(KMSKeyState.PENDING_DELETION); } }
KMSManager implements ManagedResource { @Override public void delete() { deleteAndGetSchedule(); waitForKeyState(KMSKeyState.PENDING_DELETION); } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); }
KMSManager implements ManagedResource { @Override public void delete() { deleteAndGetSchedule(); waitForKeyState(KMSKeyState.PENDING_DELETION); } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); static KMSManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override String create(); byte[] generateRandom(Integer numberOfBytes); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); String getAliasArn(); int pendingDeletionWindowInDays(); }
KMSManager implements ManagedResource { @Override public void delete() { deleteAndGetSchedule(); waitForKeyState(KMSKeyState.PENDING_DELETION); } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); static KMSManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override String create(); byte[] generateRandom(Integer numberOfBytes); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); String getAliasArn(); int pendingDeletionWindowInDays(); }
@Test public void testExists() throws Exception { when(mockKMSClient.describeKey(describeKeyRequest)).thenReturn(enabledKeyResult()); assertTrue(kmsManager.exists()); }
@Override public boolean exists() { return exists(false); }
KMSManager implements ManagedResource { @Override public boolean exists() { return exists(false); } }
KMSManager implements ManagedResource { @Override public boolean exists() { return exists(false); } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); }
KMSManager implements ManagedResource { @Override public boolean exists() { return exists(false); } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); static KMSManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override String create(); byte[] generateRandom(Integer numberOfBytes); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); String getAliasArn(); int pendingDeletionWindowInDays(); }
KMSManager implements ManagedResource { @Override public boolean exists() { return exists(false); } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); static KMSManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override String create(); byte[] generateRandom(Integer numberOfBytes); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); String getAliasArn(); int pendingDeletionWindowInDays(); }
@Test(enabled = false) public void testSerialize() { String serialized = encryptionPayload.toJsonBlob(); assertThat(serialized, is(blob)); }
public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize to JSON blob", e); } }
EncryptionPayload implements BestEffortShred { public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize to JSON blob", e); } } }
EncryptionPayload implements BestEffortShred { public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize to JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); }
EncryptionPayload implements BestEffortShred { public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize to JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); }
EncryptionPayload implements BestEffortShred { public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize to JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }
@Test(enabled = false) public void testDeserialize() { EncryptionPayload deserialized = EncryptionPayload.fromJsonBlob(blob); assertThat(deserialized, is(encryptionPayload)); }
public static EncryptionPayload fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, EncryptionPayload.class); } catch (IOException e) { throw new ParseException("Failed to deserialize JSON blob", e); } }
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, EncryptionPayload.class); } catch (IOException e) { throw new ParseException("Failed to deserialize JSON blob", e); } } }
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, EncryptionPayload.class); } catch (IOException e) { throw new ParseException("Failed to deserialize JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); }
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, EncryptionPayload.class); } catch (IOException e) { throw new ParseException("Failed to deserialize JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); }
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, EncryptionPayload.class); } catch (IOException e) { throw new ParseException("Failed to deserialize JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }
@Test(expectedExceptions = ParseException.class) public void testDeserializeInvalidJson() { EncryptionPayload deserialized = EncryptionPayload.fromJsonBlob("{!@#$%^"); }
public static EncryptionPayload fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, EncryptionPayload.class); } catch (IOException e) { throw new ParseException("Failed to deserialize JSON blob", e); } }
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, EncryptionPayload.class); } catch (IOException e) { throw new ParseException("Failed to deserialize JSON blob", e); } } }
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, EncryptionPayload.class); } catch (IOException e) { throw new ParseException("Failed to deserialize JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); }
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, EncryptionPayload.class); } catch (IOException e) { throw new ParseException("Failed to deserialize JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); }
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, EncryptionPayload.class); } catch (IOException e) { throw new ParseException("Failed to deserialize JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }
@Test void deserializeBinary() { EncryptionPayload deserializedPayload = EncryptionPayload.fromByteArray(binaryBlob); assertThat(deserializedPayload, is(encryptionPayload)); }
public static EncryptionPayload fromByteArray(byte[] payload) { ByteBuffer byteBuffer = ByteBuffer.wrap(payload); byte version = byteBuffer.get(); if (version != (byte)1) { throw new IllegalStateException(String.format("Expected version 1, got %d", version)); } ZonedDateTime created = FormattedTimestamp.fromEpoch(byteBuffer.getLong()); ZonedDateTime modified = FormattedTimestamp.fromEpoch(byteBuffer.getLong()); Optional<UserAlias> createdBy = readOptionalString(byteBuffer).map(UserAlias::new); Optional<UserAlias> modifiedBy = readOptionalString(byteBuffer).map(UserAlias::new); Encoding encoding = Encoding.fromByte(byteBuffer.get()); SecretType secretType = SecretType.fromByte(byteBuffer.get()); SecretValue value = new SecretValue(readArray(byteBuffer), encoding, secretType); Optional<UserData> userData = readUserData(byteBuffer); Optional<Comment> comment = readComment(byteBuffer); return new EncryptionPayload(value, userData, created, createdBy, modified, modifiedBy, comment); }
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromByteArray(byte[] payload) { ByteBuffer byteBuffer = ByteBuffer.wrap(payload); byte version = byteBuffer.get(); if (version != (byte)1) { throw new IllegalStateException(String.format("Expected version 1, got %d", version)); } ZonedDateTime created = FormattedTimestamp.fromEpoch(byteBuffer.getLong()); ZonedDateTime modified = FormattedTimestamp.fromEpoch(byteBuffer.getLong()); Optional<UserAlias> createdBy = readOptionalString(byteBuffer).map(UserAlias::new); Optional<UserAlias> modifiedBy = readOptionalString(byteBuffer).map(UserAlias::new); Encoding encoding = Encoding.fromByte(byteBuffer.get()); SecretType secretType = SecretType.fromByte(byteBuffer.get()); SecretValue value = new SecretValue(readArray(byteBuffer), encoding, secretType); Optional<UserData> userData = readUserData(byteBuffer); Optional<Comment> comment = readComment(byteBuffer); return new EncryptionPayload(value, userData, created, createdBy, modified, modifiedBy, comment); } }
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromByteArray(byte[] payload) { ByteBuffer byteBuffer = ByteBuffer.wrap(payload); byte version = byteBuffer.get(); if (version != (byte)1) { throw new IllegalStateException(String.format("Expected version 1, got %d", version)); } ZonedDateTime created = FormattedTimestamp.fromEpoch(byteBuffer.getLong()); ZonedDateTime modified = FormattedTimestamp.fromEpoch(byteBuffer.getLong()); Optional<UserAlias> createdBy = readOptionalString(byteBuffer).map(UserAlias::new); Optional<UserAlias> modifiedBy = readOptionalString(byteBuffer).map(UserAlias::new); Encoding encoding = Encoding.fromByte(byteBuffer.get()); SecretType secretType = SecretType.fromByte(byteBuffer.get()); SecretValue value = new SecretValue(readArray(byteBuffer), encoding, secretType); Optional<UserData> userData = readUserData(byteBuffer); Optional<Comment> comment = readComment(byteBuffer); return new EncryptionPayload(value, userData, created, createdBy, modified, modifiedBy, comment); } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); }
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromByteArray(byte[] payload) { ByteBuffer byteBuffer = ByteBuffer.wrap(payload); byte version = byteBuffer.get(); if (version != (byte)1) { throw new IllegalStateException(String.format("Expected version 1, got %d", version)); } ZonedDateTime created = FormattedTimestamp.fromEpoch(byteBuffer.getLong()); ZonedDateTime modified = FormattedTimestamp.fromEpoch(byteBuffer.getLong()); Optional<UserAlias> createdBy = readOptionalString(byteBuffer).map(UserAlias::new); Optional<UserAlias> modifiedBy = readOptionalString(byteBuffer).map(UserAlias::new); Encoding encoding = Encoding.fromByte(byteBuffer.get()); SecretType secretType = SecretType.fromByte(byteBuffer.get()); SecretValue value = new SecretValue(readArray(byteBuffer), encoding, secretType); Optional<UserData> userData = readUserData(byteBuffer); Optional<Comment> comment = readComment(byteBuffer); return new EncryptionPayload(value, userData, created, createdBy, modified, modifiedBy, comment); } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); }
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromByteArray(byte[] payload) { ByteBuffer byteBuffer = ByteBuffer.wrap(payload); byte version = byteBuffer.get(); if (version != (byte)1) { throw new IllegalStateException(String.format("Expected version 1, got %d", version)); } ZonedDateTime created = FormattedTimestamp.fromEpoch(byteBuffer.getLong()); ZonedDateTime modified = FormattedTimestamp.fromEpoch(byteBuffer.getLong()); Optional<UserAlias> createdBy = readOptionalString(byteBuffer).map(UserAlias::new); Optional<UserAlias> modifiedBy = readOptionalString(byteBuffer).map(UserAlias::new); Encoding encoding = Encoding.fromByte(byteBuffer.get()); SecretType secretType = SecretType.fromByte(byteBuffer.get()); SecretValue value = new SecretValue(readArray(byteBuffer), encoding, secretType); Optional<UserData> userData = readUserData(byteBuffer); Optional<Comment> comment = readComment(byteBuffer); return new EncryptionPayload(value, userData, created, createdBy, modified, modifiedBy, comment); } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }
@Test public void testToString() { assertEquals( encryptionPayload.toString(), "EncryptionPayload{value=SecretValue{type=opaque, secretEncoding=utf8}, userdata=Optional[UserData{}], " + "created=2016-06-01T00:00Z[UTC], modified=2017-06-01T00:00Z[UTC], " + "comment=Optional[Comment{}]}"); }
@Override public String toString() { return MoreObjects.toStringHelper(this) .add("value", value) .add("userdata", userData) .add("created", created) .add("modified", modified) .add("comment", comment) .toString(); }
EncryptionPayload implements BestEffortShred { @Override public String toString() { return MoreObjects.toStringHelper(this) .add("value", value) .add("userdata", userData) .add("created", created) .add("modified", modified) .add("comment", comment) .toString(); } }
EncryptionPayload implements BestEffortShred { @Override public String toString() { return MoreObjects.toStringHelper(this) .add("value", value) .add("userdata", userData) .add("created", created) .add("modified", modified) .add("comment", comment) .toString(); } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); }
EncryptionPayload implements BestEffortShred { @Override public String toString() { return MoreObjects.toStringHelper(this) .add("value", value) .add("userdata", userData) .add("created", created) .add("modified", modified) .add("comment", comment) .toString(); } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); }
EncryptionPayload implements BestEffortShred { @Override public String toString() { return MoreObjects.toStringHelper(this) .add("value", value) .add("userdata", userData) .add("created", created) .add("modified", modified) .add("comment", comment) .toString(); } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }
@Test public void ensureNotCommutative() { byte[] sha1 = EncryptionPayload.computeSHA(State.ENABLED, notAfter, Optional.empty()); byte[] sha2 = EncryptionPayload.computeSHA(State.ENABLED, Optional.empty(), notAfter); assertNotEquals(sha1, sha2, "Should not be able to reorder and have the same hash"); }
public static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter) { try { MessageDigest messageDigest = MessageDigest.getInstance("SHA-256"); messageDigest.update(state.asByte()); messageDigest.update(toByteArray(notBefore)); messageDigest.update(toByteArray(notAfter)); return messageDigest.digest(); } catch (NoSuchAlgorithmException e) { throw new SerializationException("Failed to get SHA for encryption payload", e); } }
EncryptionPayload implements BestEffortShred { public static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter) { try { MessageDigest messageDigest = MessageDigest.getInstance("SHA-256"); messageDigest.update(state.asByte()); messageDigest.update(toByteArray(notBefore)); messageDigest.update(toByteArray(notAfter)); return messageDigest.digest(); } catch (NoSuchAlgorithmException e) { throw new SerializationException("Failed to get SHA for encryption payload", e); } } }
EncryptionPayload implements BestEffortShred { public static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter) { try { MessageDigest messageDigest = MessageDigest.getInstance("SHA-256"); messageDigest.update(state.asByte()); messageDigest.update(toByteArray(notBefore)); messageDigest.update(toByteArray(notAfter)); return messageDigest.digest(); } catch (NoSuchAlgorithmException e) { throw new SerializationException("Failed to get SHA for encryption payload", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); }
EncryptionPayload implements BestEffortShred { public static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter) { try { MessageDigest messageDigest = MessageDigest.getInstance("SHA-256"); messageDigest.update(state.asByte()); messageDigest.update(toByteArray(notBefore)); messageDigest.update(toByteArray(notAfter)); return messageDigest.digest(); } catch (NoSuchAlgorithmException e) { throw new SerializationException("Failed to get SHA for encryption payload", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); }
EncryptionPayload implements BestEffortShred { public static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter) { try { MessageDigest messageDigest = MessageDigest.getInstance("SHA-256"); messageDigest.update(state.asByte()); messageDigest.update(toByteArray(notBefore)); messageDigest.update(toByteArray(notAfter)); return messageDigest.digest(); } catch (NoSuchAlgorithmException e) { throw new SerializationException("Failed to get SHA for encryption payload", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }
@Test public void testEquals() { EncryptionPayload samePayload = new EncryptionPayload(value, userData, created, createdBy, modified, modifiedBy, comment); assertTrue(encryptionPayload.equals(samePayload)); EncryptionPayload differentPayload = new EncryptionPayload(new SecretValue("DifferentValue", SecretType.OPAQUE), userData, created, createdBy, modified, modifiedBy, comment); assertFalse(encryptionPayload.equals(differentPayload)); differentPayload = new EncryptionPayload(value, Optional.of(new UserData("different userdata".getBytes(StandardCharsets.UTF_8))), created, createdBy, modified, modifiedBy, comment); assertFalse(encryptionPayload.equals(differentPayload)); differentPayload = new EncryptionPayload(value, userData, ZonedDateTime.of(2017,12,1,0,0,0,0, ZoneId.of("UTC")), createdBy, modified, modifiedBy, comment); assertFalse(encryptionPayload.equals(differentPayload)); differentPayload = new EncryptionPayload(value, userData, created, createdBy, ZonedDateTime.of(2017,12,1,0,0,0,0, ZoneId.of("UTC")), modifiedBy, comment); assertFalse(encryptionPayload.equals(differentPayload)); differentPayload = new EncryptionPayload(value, userData, created, createdBy, modified, modifiedBy, Optional.of(new Comment("different comment"))); assertFalse(encryptionPayload.equals(differentPayload)); assertFalse(encryptionPayload.equals("some string value")); }
@Override public boolean equals(final Object obj) { if(obj instanceof EncryptionPayload){ final EncryptionPayload other = (EncryptionPayload) obj; return Objects.equal(value, other.value) && Objects.equal(userData, other.userData) && Objects.equal(created, other.created) && Objects.equal(modified, other.modified) && Objects.equal(comment, other.comment); } else { return false; } }
EncryptionPayload implements BestEffortShred { @Override public boolean equals(final Object obj) { if(obj instanceof EncryptionPayload){ final EncryptionPayload other = (EncryptionPayload) obj; return Objects.equal(value, other.value) && Objects.equal(userData, other.userData) && Objects.equal(created, other.created) && Objects.equal(modified, other.modified) && Objects.equal(comment, other.comment); } else { return false; } } }
EncryptionPayload implements BestEffortShred { @Override public boolean equals(final Object obj) { if(obj instanceof EncryptionPayload){ final EncryptionPayload other = (EncryptionPayload) obj; return Objects.equal(value, other.value) && Objects.equal(userData, other.userData) && Objects.equal(created, other.created) && Objects.equal(modified, other.modified) && Objects.equal(comment, other.comment); } else { return false; } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); }
EncryptionPayload implements BestEffortShred { @Override public boolean equals(final Object obj) { if(obj instanceof EncryptionPayload){ final EncryptionPayload other = (EncryptionPayload) obj; return Objects.equal(value, other.value) && Objects.equal(userData, other.userData) && Objects.equal(created, other.created) && Objects.equal(modified, other.modified) && Objects.equal(comment, other.comment); } else { return false; } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); }
EncryptionPayload implements BestEffortShred { @Override public boolean equals(final Object obj) { if(obj instanceof EncryptionPayload){ final EncryptionPayload other = (EncryptionPayload) obj; return Objects.equal(value, other.value) && Objects.equal(userData, other.userData) && Objects.equal(created, other.created) && Objects.equal(modified, other.modified) && Objects.equal(comment, other.comment); } else { return false; } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value, @JsonProperty("userdata") Optional<UserData> userData, @JsonProperty("created") ZonedDateTime created, Optional<UserAlias> createdBy, @JsonProperty("modified") ZonedDateTime modified, Optional<UserAlias> modifiedBy, @JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }
@Test public void testGetReadOnlyArn() throws Exception { String arn = partiallyMockedPolicyManager.getReadOnlyArn(group); assertEquals(arn, READONLY_POLICY_ARN); }
public String getReadOnlyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.READONLY); }
IAMPolicyManager { public String getReadOnlyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.READONLY); } }
IAMPolicyManager { public String getReadOnlyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); }
IAMPolicyManager { public String getReadOnlyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); }
IAMPolicyManager { public String getReadOnlyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }
@Test public void testToMap() { FileEncryptionContext context = new FileEncryptionContext( new SecretsGroupIdentifier(Region.EU_WEST_1, "test.group") ); Map<String, String> map = context.toMap(); assertEquals(map.get("0"), "1"); assertEquals(map.get("1"), "eu-west-1"); assertEquals(map.get("2"), "test.group"); }
@Override public Map<String, String> toMap() { return ImmutableMap.of( "0", FILE_VERSION, "1", groupIdentifier.region.getName(), "2", groupIdentifier.name); }
FileEncryptionContext implements EncryptionContext { @Override public Map<String, String> toMap() { return ImmutableMap.of( "0", FILE_VERSION, "1", groupIdentifier.region.getName(), "2", groupIdentifier.name); } }
FileEncryptionContext implements EncryptionContext { @Override public Map<String, String> toMap() { return ImmutableMap.of( "0", FILE_VERSION, "1", groupIdentifier.region.getName(), "2", groupIdentifier.name); } FileEncryptionContext(SecretsGroupIdentifier groupIdentifier); }
FileEncryptionContext implements EncryptionContext { @Override public Map<String, String> toMap() { return ImmutableMap.of( "0", FILE_VERSION, "1", groupIdentifier.region.getName(), "2", groupIdentifier.name); } FileEncryptionContext(SecretsGroupIdentifier groupIdentifier); @Override Map<String, String> toMap(); }
FileEncryptionContext implements EncryptionContext { @Override public Map<String, String> toMap() { return ImmutableMap.of( "0", FILE_VERSION, "1", groupIdentifier.region.getName(), "2", groupIdentifier.name); } FileEncryptionContext(SecretsGroupIdentifier groupIdentifier); @Override Map<String, String> toMap(); final SecretsGroupIdentifier groupIdentifier; }
@Test public void testCreateEntry() throws Exception { RawSecretEntry rawSecretEntry = constructRawEntry(SECRET_NAME); UpdateItemRequest expectedUpdateRequest = constructUpdateItemRequest(rawSecretEntry, false, Optional.empty()); dynamoDB.create(rawSecretEntry); verify(mockDynamoDBClient, times(1)).updateItem(expectedUpdateRequest); }
@Override public String create() { readWriteLock.writeLock().lock(); try { CreateTableResult result = client.createTable(constructCreateTableRequest()); waitForTableToBecomeActive(); return result.getTableDescription().getTableArn(); } catch (ResourceInUseException e) { throw new AlreadyExistsException(String.format("There is already a DynamoDB table called '%s'", tableName), e); } finally { readWriteLock.writeLock().unlock(); } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public String create() { readWriteLock.writeLock().lock(); try { CreateTableResult result = client.createTable(constructCreateTableRequest()); waitForTableToBecomeActive(); return result.getTableDescription().getTableArn(); } catch (ResourceInUseException e) { throw new AlreadyExistsException(String.format("There is already a DynamoDB table called '%s'", tableName), e); } finally { readWriteLock.writeLock().unlock(); } } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public String create() { readWriteLock.writeLock().lock(); try { CreateTableResult result = client.createTable(constructCreateTableRequest()); waitForTableToBecomeActive(); return result.getTableDescription().getTableArn(); } catch (ResourceInUseException e) { throw new AlreadyExistsException(String.format("There is already a DynamoDB table called '%s'", tableName), e); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public String create() { readWriteLock.writeLock().lock(); try { CreateTableResult result = client.createTable(constructCreateTableRequest()); waitForTableToBecomeActive(); return result.getTableDescription().getTableArn(); } catch (ResourceInUseException e) { throw new AlreadyExistsException(String.format("There is already a DynamoDB table called '%s'", tableName), e); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public String create() { readWriteLock.writeLock().lock(); try { CreateTableResult result = client.createTable(constructCreateTableRequest()); waitForTableToBecomeActive(); return result.getTableDescription().getTableArn(); } catch (ResourceInUseException e) { throw new AlreadyExistsException(String.format("There is already a DynamoDB table called '%s'", tableName), e); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
@Test public void testCreateEntryAlreadyExists() throws Exception { RawSecretEntry rawSecretEntry = constructRawEntry(SECRET_NAME); UpdateItemRequest expectedUpdateRequest = constructUpdateItemRequest(rawSecretEntry, false, Optional.empty()); when(mockDynamoDBClient.updateItem(expectedUpdateRequest)).thenThrow( new ConditionalCheckFailedException("")); boolean exceptionThrown = false; try { dynamoDB.create(rawSecretEntry); } catch (AlreadyExistsException e) { assertEquals(e.getMessage(), "DynamoDB store entry already exists:{1={S: secret1,}, 2={N: 1,}}"); exceptionThrown = true; } assertTrue(exceptionThrown); verify(mockDynamoDBClient, times(1)).updateItem(expectedUpdateRequest); }
@Override public String create() { readWriteLock.writeLock().lock(); try { CreateTableResult result = client.createTable(constructCreateTableRequest()); waitForTableToBecomeActive(); return result.getTableDescription().getTableArn(); } catch (ResourceInUseException e) { throw new AlreadyExistsException(String.format("There is already a DynamoDB table called '%s'", tableName), e); } finally { readWriteLock.writeLock().unlock(); } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public String create() { readWriteLock.writeLock().lock(); try { CreateTableResult result = client.createTable(constructCreateTableRequest()); waitForTableToBecomeActive(); return result.getTableDescription().getTableArn(); } catch (ResourceInUseException e) { throw new AlreadyExistsException(String.format("There is already a DynamoDB table called '%s'", tableName), e); } finally { readWriteLock.writeLock().unlock(); } } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public String create() { readWriteLock.writeLock().lock(); try { CreateTableResult result = client.createTable(constructCreateTableRequest()); waitForTableToBecomeActive(); return result.getTableDescription().getTableArn(); } catch (ResourceInUseException e) { throw new AlreadyExistsException(String.format("There is already a DynamoDB table called '%s'", tableName), e); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public String create() { readWriteLock.writeLock().lock(); try { CreateTableResult result = client.createTable(constructCreateTableRequest()); waitForTableToBecomeActive(); return result.getTableDescription().getTableArn(); } catch (ResourceInUseException e) { throw new AlreadyExistsException(String.format("There is already a DynamoDB table called '%s'", tableName), e); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public String create() { readWriteLock.writeLock().lock(); try { CreateTableResult result = client.createTable(constructCreateTableRequest()); waitForTableToBecomeActive(); return result.getTableDescription().getTableArn(); } catch (ResourceInUseException e) { throw new AlreadyExistsException(String.format("There is already a DynamoDB table called '%s'", tableName), e); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
@Test public void testUpdateEntry() throws Exception { RawSecretEntry rawSecretEntry = constructRawEntry(SECRET_NAME); RawSecretEntry alternativeRawSecretEntry = constructAlternativeRawSecretEntry(SECRET_NAME); UpdateItemRequest expectedUpdateRequest = constructUpdateItemRequest(rawSecretEntry, true, Optional.of(alternativeRawSecretEntry)); dynamoDB.update(rawSecretEntry, alternativeRawSecretEntry); verify(mockDynamoDBClient, times(1)).updateItem(expectedUpdateRequest); }
@Override public void update(Entry entry, Entry existingEntry) { readWriteLock.writeLock().lock(); try { Map<String, AttributeValue> keys = createKey(entry); Map<String, AttributeValueUpdate> attributes = createAttributes(entry); Map<String, ExpectedAttributeValue> expected = expectExists(existingEntry); try { executeUpdate(keys, attributes, expected); } catch (ConditionalCheckFailedException e) { throw new DoesNotExistException("Precondition to update entry in DynamoDB failed:" + keys.toString()); } } finally { readWriteLock.writeLock().unlock(); } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void update(Entry entry, Entry existingEntry) { readWriteLock.writeLock().lock(); try { Map<String, AttributeValue> keys = createKey(entry); Map<String, AttributeValueUpdate> attributes = createAttributes(entry); Map<String, ExpectedAttributeValue> expected = expectExists(existingEntry); try { executeUpdate(keys, attributes, expected); } catch (ConditionalCheckFailedException e) { throw new DoesNotExistException("Precondition to update entry in DynamoDB failed:" + keys.toString()); } } finally { readWriteLock.writeLock().unlock(); } } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void update(Entry entry, Entry existingEntry) { readWriteLock.writeLock().lock(); try { Map<String, AttributeValue> keys = createKey(entry); Map<String, AttributeValueUpdate> attributes = createAttributes(entry); Map<String, ExpectedAttributeValue> expected = expectExists(existingEntry); try { executeUpdate(keys, attributes, expected); } catch (ConditionalCheckFailedException e) { throw new DoesNotExistException("Precondition to update entry in DynamoDB failed:" + keys.toString()); } } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void update(Entry entry, Entry existingEntry) { readWriteLock.writeLock().lock(); try { Map<String, AttributeValue> keys = createKey(entry); Map<String, AttributeValueUpdate> attributes = createAttributes(entry); Map<String, ExpectedAttributeValue> expected = expectExists(existingEntry); try { executeUpdate(keys, attributes, expected); } catch (ConditionalCheckFailedException e) { throw new DoesNotExistException("Precondition to update entry in DynamoDB failed:" + keys.toString()); } } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void update(Entry entry, Entry existingEntry) { readWriteLock.writeLock().lock(); try { Map<String, AttributeValue> keys = createKey(entry); Map<String, AttributeValueUpdate> attributes = createAttributes(entry); Map<String, ExpectedAttributeValue> expected = expectExists(existingEntry); try { executeUpdate(keys, attributes, expected); } catch (ConditionalCheckFailedException e) { throw new DoesNotExistException("Precondition to update entry in DynamoDB failed:" + keys.toString()); } } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
@Test public void testUpdateEntryDoesNotExist() throws Exception { RawSecretEntry rawSecretEntry = constructRawEntry(SECRET_NAME); RawSecretEntry alternativeRawSecretEntry = constructAlternativeRawSecretEntry(SECRET_NAME); UpdateItemRequest expectedUpdateRequest = constructUpdateItemRequest(rawSecretEntry, true, Optional.of(alternativeRawSecretEntry)); when(mockDynamoDBClient.updateItem(expectedUpdateRequest)).thenThrow( new ConditionalCheckFailedException("")); boolean exceptionThrown = false; try { dynamoDB.update(rawSecretEntry, alternativeRawSecretEntry); } catch (DoesNotExistException e) { assertEquals(e.getMessage(), "Precondition to update entry in DynamoDB failed:{1={S: secret1,}, 2={N: 1,}}"); exceptionThrown = true; } assertTrue(exceptionThrown); verify(mockDynamoDBClient, times(1)).updateItem(expectedUpdateRequest); }
@Override public void update(Entry entry, Entry existingEntry) { readWriteLock.writeLock().lock(); try { Map<String, AttributeValue> keys = createKey(entry); Map<String, AttributeValueUpdate> attributes = createAttributes(entry); Map<String, ExpectedAttributeValue> expected = expectExists(existingEntry); try { executeUpdate(keys, attributes, expected); } catch (ConditionalCheckFailedException e) { throw new DoesNotExistException("Precondition to update entry in DynamoDB failed:" + keys.toString()); } } finally { readWriteLock.writeLock().unlock(); } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void update(Entry entry, Entry existingEntry) { readWriteLock.writeLock().lock(); try { Map<String, AttributeValue> keys = createKey(entry); Map<String, AttributeValueUpdate> attributes = createAttributes(entry); Map<String, ExpectedAttributeValue> expected = expectExists(existingEntry); try { executeUpdate(keys, attributes, expected); } catch (ConditionalCheckFailedException e) { throw new DoesNotExistException("Precondition to update entry in DynamoDB failed:" + keys.toString()); } } finally { readWriteLock.writeLock().unlock(); } } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void update(Entry entry, Entry existingEntry) { readWriteLock.writeLock().lock(); try { Map<String, AttributeValue> keys = createKey(entry); Map<String, AttributeValueUpdate> attributes = createAttributes(entry); Map<String, ExpectedAttributeValue> expected = expectExists(existingEntry); try { executeUpdate(keys, attributes, expected); } catch (ConditionalCheckFailedException e) { throw new DoesNotExistException("Precondition to update entry in DynamoDB failed:" + keys.toString()); } } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void update(Entry entry, Entry existingEntry) { readWriteLock.writeLock().lock(); try { Map<String, AttributeValue> keys = createKey(entry); Map<String, AttributeValueUpdate> attributes = createAttributes(entry); Map<String, ExpectedAttributeValue> expected = expectExists(existingEntry); try { executeUpdate(keys, attributes, expected); } catch (ConditionalCheckFailedException e) { throw new DoesNotExistException("Precondition to update entry in DynamoDB failed:" + keys.toString()); } } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void update(Entry entry, Entry existingEntry) { readWriteLock.writeLock().lock(); try { Map<String, AttributeValue> keys = createKey(entry); Map<String, AttributeValueUpdate> attributes = createAttributes(entry); Map<String, ExpectedAttributeValue> expected = expectExists(existingEntry); try { executeUpdate(keys, attributes, expected); } catch (ConditionalCheckFailedException e) { throw new DoesNotExistException("Precondition to update entry in DynamoDB failed:" + keys.toString()); } } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
@Test public void testKeySet() throws Exception { ScanRequest request = new ScanRequest().withConsistentRead(true).withTableName(tableName); ScanResult result = constructScanResult(); when(mockDynamoDBClient.scan(request)).thenReturn(result); Set<SecretIdentifier> keys = dynamoDB.keySet(); assertEquals(keys.size(), 2); assertTrue(keys.contains(new SecretIdentifier(SECRET_NAME))); assertTrue(keys.contains(new SecretIdentifier(SECRET2_NAME))); verify(mockDynamoDBClient, times(1)).scan(request); }
@Override public Set<Primary> keySet() { readWriteLock.readLock().lock(); try { return stream() .uniquePrimaryKey() .toJavaStream() .map(this::getUnconvertedPartitionKeyValue) .collect(Collectors.toSet()); } finally { readWriteLock.readLock().unlock(); } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public Set<Primary> keySet() { readWriteLock.readLock().lock(); try { return stream() .uniquePrimaryKey() .toJavaStream() .map(this::getUnconvertedPartitionKeyValue) .collect(Collectors.toSet()); } finally { readWriteLock.readLock().unlock(); } } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public Set<Primary> keySet() { readWriteLock.readLock().lock(); try { return stream() .uniquePrimaryKey() .toJavaStream() .map(this::getUnconvertedPartitionKeyValue) .collect(Collectors.toSet()); } finally { readWriteLock.readLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public Set<Primary> keySet() { readWriteLock.readLock().lock(); try { return stream() .uniquePrimaryKey() .toJavaStream() .map(this::getUnconvertedPartitionKeyValue) .collect(Collectors.toSet()); } finally { readWriteLock.readLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public Set<Primary> keySet() { readWriteLock.readLock().lock(); try { return stream() .uniquePrimaryKey() .toJavaStream() .map(this::getUnconvertedPartitionKeyValue) .collect(Collectors.toSet()); } finally { readWriteLock.readLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
@Test public void testKeySetEmpty() throws Exception { ScanRequest request = new ScanRequest().withConsistentRead(true).withTableName(tableName); ScanResult result = new ScanResult().withCount(0).withItems(new ArrayList<>()); when(mockDynamoDBClient.scan(request)).thenReturn(result); Set<SecretIdentifier> keySet = dynamoDB.keySet(); assertTrue(keySet.isEmpty()); verify(mockDynamoDBClient, times(1)).scan(request); }
@Override public Set<Primary> keySet() { readWriteLock.readLock().lock(); try { return stream() .uniquePrimaryKey() .toJavaStream() .map(this::getUnconvertedPartitionKeyValue) .collect(Collectors.toSet()); } finally { readWriteLock.readLock().unlock(); } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public Set<Primary> keySet() { readWriteLock.readLock().lock(); try { return stream() .uniquePrimaryKey() .toJavaStream() .map(this::getUnconvertedPartitionKeyValue) .collect(Collectors.toSet()); } finally { readWriteLock.readLock().unlock(); } } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public Set<Primary> keySet() { readWriteLock.readLock().lock(); try { return stream() .uniquePrimaryKey() .toJavaStream() .map(this::getUnconvertedPartitionKeyValue) .collect(Collectors.toSet()); } finally { readWriteLock.readLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public Set<Primary> keySet() { readWriteLock.readLock().lock(); try { return stream() .uniquePrimaryKey() .toJavaStream() .map(this::getUnconvertedPartitionKeyValue) .collect(Collectors.toSet()); } finally { readWriteLock.readLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public Set<Primary> keySet() { readWriteLock.readLock().lock(); try { return stream() .uniquePrimaryKey() .toJavaStream() .map(this::getUnconvertedPartitionKeyValue) .collect(Collectors.toSet()); } finally { readWriteLock.readLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
@Test public void testDeleteSecret() { QueryRequest request = constructQueryRequest(SECRET_NAME); QueryResult result = constructQueryResult(false); when(mockDynamoDBClient.query(request)).thenReturn(result); dynamoDB.delete(new SecretIdentifier(SECRET_NAME)); verify(mockDynamoDBClient, times(1)).query(request); verify(mockDynamoDBClient, times(1)).deleteItem(tableName, constructKey(SECRET_NAME, 1)); verify(mockDynamoDBClient, times(1)).deleteItem(tableName, constructKey(SECRET_NAME, 2)); verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET2_NAME, 1)); }
@Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
@Test public void testDeleteSecretMaliciousResults() { QueryRequest request = constructQueryRequest(SECRET_NAME); QueryResult maliciousResult = constructQueryResult(true); when(mockDynamoDBClient.query(request)).thenReturn(maliciousResult); boolean consideredMalicious = false; try { dynamoDB.delete(new SecretIdentifier(SECRET_NAME)); } catch (PotentiallyMaliciousDataException e) { consideredMalicious = true; } assertTrue(consideredMalicious); verify(mockDynamoDBClient, times(1)).query(request); verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET_NAME, 1)); verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET_NAME, 2)); verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET2_NAME, 1)); }
@Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
@Test public void testDeleteSecretNotInTable() { QueryRequest request = constructQueryRequest(SECRET_NAME); QueryResult result = new QueryResult().withCount(0).withItems(new ArrayList<>()); when(mockDynamoDBClient.query(request)).thenReturn(result); dynamoDB.delete(new SecretIdentifier(SECRET_NAME)); verify(mockDynamoDBClient, times(1)).query(request); verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET_NAME, 1)); }
@Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters, ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }
@Test public void testAttachAdminUser() throws Exception { Principal principal = new Principal(PrincipalType.USER, "alice"); partiallyMockedPolicyManager.attachAdmin(group, principal); AttachUserPolicyRequest request = new AttachUserPolicyRequest() .withPolicyArn(ADMIN_POLICY_ARN) .withUserName(principal.name); verify(mockClient, times(1)).attachUserPolicy(request); }
public void attachAdmin(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.ADMIN); }
IAMPolicyManager { public void attachAdmin(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.ADMIN); } }
IAMPolicyManager { public void attachAdmin(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); }
IAMPolicyManager { public void attachAdmin(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); }
IAMPolicyManager { public void attachAdmin(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }
@Test public void test() { assertThat(FilterGenerator.convertNumberToLetters(0), is("a")); assertThat(FilterGenerator.convertNumberToLetters(1), is("b")); assertThat(FilterGenerator.convertNumberToLetters(26-1), is("z")); assertThat(FilterGenerator.convertNumberToLetters(26), is("ba")); assertThat(FilterGenerator.convertNumberToLetters(26+1), is("bb")); assertThat(FilterGenerator.convertNumberToLetters(26*26-1), is("zz")); assertThat(FilterGenerator.convertNumberToLetters(26*26), is("baa")); assertThat(FilterGenerator.convertNumberToLetters(26*26+1), is("bab")); assertThat(FilterGenerator.convertNumberToLetters(26*26*26-1), is("zzz")); }
public static String convertNumberToLetters(int number) { int range = 'z'-'a' + 1; StringBuilder sb = new StringBuilder(); do { int last = number % range; sb.append(Character.toChars('a' + last)); number /= range; } while (number != 0); return sb.reverse().toString(); }
FilterGenerator { public static String convertNumberToLetters(int number) { int range = 'z'-'a' + 1; StringBuilder sb = new StringBuilder(); do { int last = number % range; sb.append(Character.toChars('a' + last)); number /= range; } while (number != 0); return sb.reverse().toString(); } }
FilterGenerator { public static String convertNumberToLetters(int number) { int range = 'z'-'a' + 1; StringBuilder sb = new StringBuilder(); do { int last = number % range; sb.append(Character.toChars('a' + last)); number /= range; } while (number != 0); return sb.reverse().toString(); } FilterGenerator(int startCount); FilterGenerator(); }
FilterGenerator { public static String convertNumberToLetters(int number) { int range = 'z'-'a' + 1; StringBuilder sb = new StringBuilder(); do { int last = number % range; sb.append(Character.toChars('a' + last)); number /= range; } while (number != 0); return sb.reverse().toString(); } FilterGenerator(int startCount); FilterGenerator(); Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters); Filter createTerm(RSEF.TypedTerm<T> typedTerm, Converters converters); static String getOperator(RSEF.BinaryOpType binaryOpType); static Map<A, B> merge(Map<A, B> left, Map<A, B> right); static String convertNumberToLetters(int number); }
FilterGenerator { public static String convertNumberToLetters(int number) { int range = 'z'-'a' + 1; StringBuilder sb = new StringBuilder(); do { int last = number % range; sb.append(Character.toChars('a' + last)); number /= range; } while (number != 0); return sb.reverse().toString(); } FilterGenerator(int startCount); FilterGenerator(); Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters); Filter createTerm(RSEF.TypedTerm<T> typedTerm, Converters converters); static String getOperator(RSEF.BinaryOpType binaryOpType); static Map<A, B> merge(Map<A, B> left, Map<A, B> right); static String convertNumberToLetters(int number); public int count; }
@Test public void test2() { ZonedDateTime notBeforeValue = ZonedDateTime.now(); RSEF.AttributeCondition condition = notAfter.isPresent() .AND(RSEF.NOT(notAfter.get().eq(notBeforeValue))) .OR(notAfter.get().eq(notBeforeValue)) .AND(notBefore.get().eq(notAfter.get())); RSEF.ParsedAttributeCondition ast = Parser.createAST(condition); FilterGenerator filterGenerator = new FilterGenerator(); FilterGenerator.Filter filter = filterGenerator.process(ast, Config.converters); log.info(filter.filterExpression); }
public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } }
FilterGenerator { public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } } }
FilterGenerator { public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } } FilterGenerator(int startCount); FilterGenerator(); }
FilterGenerator { public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } } FilterGenerator(int startCount); FilterGenerator(); Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters); Filter createTerm(RSEF.TypedTerm<T> typedTerm, Converters converters); static String getOperator(RSEF.BinaryOpType binaryOpType); static Map<A, B> merge(Map<A, B> left, Map<A, B> right); static String convertNumberToLetters(int number); }
FilterGenerator { public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } } FilterGenerator(int startCount); FilterGenerator(); Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters); Filter createTerm(RSEF.TypedTerm<T> typedTerm, Converters converters); static String getOperator(RSEF.BinaryOpType binaryOpType); static Map<A, B> merge(Map<A, B> left, Map<A, B> right); static String convertNumberToLetters(int number); public int count; }
@Test public void test3() { RSEF.AttributeCondition condition = notBefore.isNotPresent(); RSEF.ParsedAttributeCondition ast = Parser.createAST(condition); FilterGenerator filterGenerator = new FilterGenerator(); FilterGenerator.Filter filter = filterGenerator.process(ast, Config.converters); log.info(filter.filterExpression); }
public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } }
FilterGenerator { public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } } }
FilterGenerator { public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } } FilterGenerator(int startCount); FilterGenerator(); }
FilterGenerator { public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } } FilterGenerator(int startCount); FilterGenerator(); Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters); Filter createTerm(RSEF.TypedTerm<T> typedTerm, Converters converters); static String getOperator(RSEF.BinaryOpType binaryOpType); static Map<A, B> merge(Map<A, B> left, Map<A, B> right); static String convertNumberToLetters(int number); }
FilterGenerator { public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } } FilterGenerator(int startCount); FilterGenerator(); Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters); Filter createTerm(RSEF.TypedTerm<T> typedTerm, Converters converters); static String getOperator(RSEF.BinaryOpType binaryOpType); static Map<A, B> merge(Map<A, B> left, Map<A, B> right); static String convertNumberToLetters(int number); public int count; }
@Test public void test4() { SecretIdentifier secretIdentifier = new SecretIdentifier("MySecret"); long myVersion = 1; RSEF.KeyCondition condition = name.eq(secretIdentifier).AND(version.le(myVersion)); RSEF.ParsedKeyCondition ast = Parser.createAST(condition); KeyExpressionGenerator generator = new KeyExpressionGenerator(); KeyExpressionGenerator.KeyCondition keyCondition = generator.process(ast, Config.converters); log.info(keyCondition.keyConditionExpression); }
public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } }
FilterGenerator { public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } } }
FilterGenerator { public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } } FilterGenerator(int startCount); FilterGenerator(); }
FilterGenerator { public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } } FilterGenerator(int startCount); FilterGenerator(); Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters); Filter createTerm(RSEF.TypedTerm<T> typedTerm, Converters converters); static String getOperator(RSEF.BinaryOpType binaryOpType); static Map<A, B> merge(Map<A, B> left, Map<A, B> right); static String convertNumberToLetters(int number); }
FilterGenerator { public <Entry> Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters) { if (attributeCondition instanceof RSEF.AndOperator) { RSEF.AndOperator<Entry> current = (RSEF.AndOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) AND (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.OrOperator) { RSEF.OrOperator<Entry> current = (RSEF.OrOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); Filter right = process(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("(%s) OR (%s)", left.filterExpression, right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.NotOperator) { RSEF.NotOperator<Entry> current = (RSEF.NotOperator<Entry>) attributeCondition; Filter left = process(current.left, converters); String filterExpression = String.format("NOT (%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, left.expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ComparisonOperator) { RSEF.ComparisonOperator<Entry, ?> current = (RSEF.ComparisonOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.left, converters); Filter right = createTerm(current.right, converters); Map<String, String> expressionAttributeNames = merge(left.expressionAttributeNames, right.expressionAttributeNames); Map<String, AttributeValue> expressionAttributeValues = merge(left.expressionAttributeValues, right.expressionAttributeValues); String filterExpression = String.format("%s %s %s", left.filterExpression, getOperator(current.binaryOpType), right.filterExpression); return new Filter(expressionAttributeNames, expressionAttributeValues, filterExpression); } else if (attributeCondition instanceof RSEF.ExistsOperator) { RSEF.ExistsOperator<Entry, ?> current = (RSEF.ExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else if (attributeCondition instanceof RSEF.NotExistsOperator) { RSEF.NotExistsOperator<Entry, ?> current = (RSEF.NotExistsOperator<Entry, ?>) attributeCondition; Filter left = createTerm(current.reference, converters); String filterExpression = String.format("attribute_not_exists(%s)", left.filterExpression); return new Filter(left.expressionAttributeNames, filterExpression); } else { throw new UnsupportedTypeException(attributeCondition.getClass().getName()); } } FilterGenerator(int startCount); FilterGenerator(); Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters); Filter createTerm(RSEF.TypedTerm<T> typedTerm, Converters converters); static String getOperator(RSEF.BinaryOpType binaryOpType); static Map<A, B> merge(Map<A, B> left, Map<A, B> right); static String convertNumberToLetters(int number); public int count; }
@Test public void testToString() throws Exception { assertEquals(adminPolicyName.toString(), adminPolicyAsString); assertEquals(readonlyPolicyName.toString(), readonlyPolicyAsString); }
@Override public String toString() { return String.format("%s_%s_%s_%s", AWSResourceNameSerialization.GLOBAL_PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name), accessLevel); }
IAMPolicyName { @Override public String toString() { return String.format("%s_%s_%s_%s", AWSResourceNameSerialization.GLOBAL_PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name), accessLevel); } }
IAMPolicyName { @Override public String toString() { return String.format("%s_%s_%s_%s", AWSResourceNameSerialization.GLOBAL_PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name), accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); }
IAMPolicyName { @Override public String toString() { return String.format("%s_%s_%s_%s", AWSResourceNameSerialization.GLOBAL_PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name), accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); }
IAMPolicyName { @Override public String toString() { return String.format("%s_%s_%s_%s", AWSResourceNameSerialization.GLOBAL_PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name), accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; final AccessLevel accessLevel; }
@Test public void testFromString() throws Exception { IAMPolicyName adminFromString = IAMPolicyName.fromString(adminPolicyAsString); assertEquals(adminFromString.group, group); assertEquals(adminFromString.accessLevel, AccessLevel.ADMIN); IAMPolicyName readonlyFromString = IAMPolicyName.fromString(readonlyPolicyAsString); assertEquals(readonlyFromString.group, group); assertEquals(readonlyFromString.accessLevel, AccessLevel.READONLY); }
public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; final AccessLevel accessLevel; }
@Test(expectedExceptions = IllegalArgumentException.class) public void testFromStringInvalidAccessLevel() throws Exception { IAMPolicyName.fromString("strongbox_us-west-1_test-group_invalid"); }
public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; final AccessLevel accessLevel; }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromStringMissingRegion() throws Exception { IAMPolicyName.fromString("strongbox_test-group_admin"); }
public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; final AccessLevel accessLevel; }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromStringInvalidPrefix() throws Exception { IAMPolicyName.fromString("sm_eu-west-1_test-group_admin"); }
public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); }
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; final AccessLevel accessLevel; }
@Test public void testEquals() throws Exception { assertTrue(adminPolicyName.equals(new IAMPolicyName(group, AccessLevel.ADMIN))); assertTrue(readonlyPolicyName.equals(new IAMPolicyName(group, AccessLevel.READONLY))); assertFalse(adminPolicyName.equals(readonlyPolicyName)); assertFalse(adminPolicyName.equals( new IAMPolicyName(new SecretsGroupIdentifier(Region.EU_WEST_1, "test.group"), AccessLevel.ADMIN))); assertFalse(adminPolicyName.equals( new IAMPolicyName(new SecretsGroupIdentifier(Region.US_WEST_1, "test.group2"), AccessLevel.ADMIN))); }
@Override public boolean equals(final Object obj) { if (obj instanceof IAMPolicyName) { final IAMPolicyName other = (IAMPolicyName) obj; return Objects.equal(group, other.group) && Objects.equal(accessLevel, other.accessLevel); } else { return false; } }
IAMPolicyName { @Override public boolean equals(final Object obj) { if (obj instanceof IAMPolicyName) { final IAMPolicyName other = (IAMPolicyName) obj; return Objects.equal(group, other.group) && Objects.equal(accessLevel, other.accessLevel); } else { return false; } } }
IAMPolicyName { @Override public boolean equals(final Object obj) { if (obj instanceof IAMPolicyName) { final IAMPolicyName other = (IAMPolicyName) obj; return Objects.equal(group, other.group) && Objects.equal(accessLevel, other.accessLevel); } else { return false; } } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); }
IAMPolicyName { @Override public boolean equals(final Object obj) { if (obj instanceof IAMPolicyName) { final IAMPolicyName other = (IAMPolicyName) obj; return Objects.equal(group, other.group) && Objects.equal(accessLevel, other.accessLevel); } else { return false; } } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); }
IAMPolicyName { @Override public boolean equals(final Object obj) { if (obj instanceof IAMPolicyName) { final IAMPolicyName other = (IAMPolicyName) obj; return Objects.equal(group, other.group) && Objects.equal(accessLevel, other.accessLevel); } else { return false; } } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; final AccessLevel accessLevel; }
@Test public void testAttachAdminGroup() throws Exception { Principal principal = new Principal(PrincipalType.GROUP, "awesome-team"); partiallyMockedPolicyManager.attachAdmin(group, principal); AttachGroupPolicyRequest request = new AttachGroupPolicyRequest() .withPolicyArn(ADMIN_POLICY_ARN) .withGroupName(principal.name); verify(mockClient, times(1)).attachGroupPolicy(request); }
public void attachAdmin(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.ADMIN); }
IAMPolicyManager { public void attachAdmin(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.ADMIN); } }
IAMPolicyManager { public void attachAdmin(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); }
IAMPolicyManager { public void attachAdmin(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); }
IAMPolicyManager { public void attachAdmin(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }
@Test(expectedExceptions = AlreadyExistsException.class) public void addSamePathToConfig() { SecretsGroupIdentifier anotherGroup = new SecretsGroupIdentifier(Region.EU_CENTRAL_1, "test2.group"); userConfig.addLocalFilePath(EU_GROUP, new File("path-eu")); userConfig.addLocalFilePath(anotherGroup, new File("path-eu")); }
public void addLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueGroup(group); checkUniqueFilePath(path); localFiles.put(group, path); }
UserConfig { public void addLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueGroup(group); checkUniqueFilePath(path); localFiles.put(group, path); } }
UserConfig { public void addLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueGroup(group); checkUniqueFilePath(path); localFiles.put(group, path); } UserConfig(@JsonProperty("localFiles") Map<SecretsGroupIdentifier, File> localFiles); UserConfig(); }
UserConfig { public void addLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueGroup(group); checkUniqueFilePath(path); localFiles.put(group, path); } UserConfig(@JsonProperty("localFiles") Map<SecretsGroupIdentifier, File> localFiles); UserConfig(); Map<SecretsGroupIdentifier, File> getMap(); Optional<File> getLocalFilePath(SecretsGroupIdentifier group); void addLocalFilePath(SecretsGroupIdentifier group, File path); void updateLocalFilePath(SecretsGroupIdentifier group, File path); void removeLocalFilePath(SecretsGroupIdentifier group); }
UserConfig { public void addLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueGroup(group); checkUniqueFilePath(path); localFiles.put(group, path); } UserConfig(@JsonProperty("localFiles") Map<SecretsGroupIdentifier, File> localFiles); UserConfig(); Map<SecretsGroupIdentifier, File> getMap(); Optional<File> getLocalFilePath(SecretsGroupIdentifier group); void addLocalFilePath(SecretsGroupIdentifier group, File path); void updateLocalFilePath(SecretsGroupIdentifier group, File path); void removeLocalFilePath(SecretsGroupIdentifier group); }
@Test(expectedExceptions = AlreadyExistsException.class) public void addSameGroupToConfigWithDifferentPath() { userConfig.addLocalFilePath(EU_GROUP, new File("path-eu")); userConfig.addLocalFilePath(EU_GROUP, new File("path-foobar")); }
public void addLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueGroup(group); checkUniqueFilePath(path); localFiles.put(group, path); }
UserConfig { public void addLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueGroup(group); checkUniqueFilePath(path); localFiles.put(group, path); } }
UserConfig { public void addLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueGroup(group); checkUniqueFilePath(path); localFiles.put(group, path); } UserConfig(@JsonProperty("localFiles") Map<SecretsGroupIdentifier, File> localFiles); UserConfig(); }
UserConfig { public void addLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueGroup(group); checkUniqueFilePath(path); localFiles.put(group, path); } UserConfig(@JsonProperty("localFiles") Map<SecretsGroupIdentifier, File> localFiles); UserConfig(); Map<SecretsGroupIdentifier, File> getMap(); Optional<File> getLocalFilePath(SecretsGroupIdentifier group); void addLocalFilePath(SecretsGroupIdentifier group, File path); void updateLocalFilePath(SecretsGroupIdentifier group, File path); void removeLocalFilePath(SecretsGroupIdentifier group); }
UserConfig { public void addLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueGroup(group); checkUniqueFilePath(path); localFiles.put(group, path); } UserConfig(@JsonProperty("localFiles") Map<SecretsGroupIdentifier, File> localFiles); UserConfig(); Map<SecretsGroupIdentifier, File> getMap(); Optional<File> getLocalFilePath(SecretsGroupIdentifier group); void addLocalFilePath(SecretsGroupIdentifier group, File path); void updateLocalFilePath(SecretsGroupIdentifier group, File path); void removeLocalFilePath(SecretsGroupIdentifier group); }
@Test public void testGetLocalFilePath() throws Exception { assertEquals(fileUserConfig.getLocalFilePath(GROUP1_US), Optional.of(new File("uswest1-test-group.sm"))); assertEquals(fileUserConfig.getLocalFilePath(GROUP1_EU), Optional.of(new File("euwest1-test-group.sm"))); assertEquals(fileUserConfig.getLocalFilePath(GROUP2_EU), Optional.of(new File("euwest1-test-group2.sm"))); assertEquals(fileUserConfig.getLocalFilePath( new SecretsGroupIdentifier(Region.EU_CENTRAL_1, "test.group")), Optional.empty()); }
@Override public Optional<File> getLocalFilePath(SecretsGroupIdentifier group) { return Optional.ofNullable(localFiles.get(group)); }
FileUserConfig extends UserConfig { @Override public Optional<File> getLocalFilePath(SecretsGroupIdentifier group) { return Optional.ofNullable(localFiles.get(group)); } }
FileUserConfig extends UserConfig { @Override public Optional<File> getLocalFilePath(SecretsGroupIdentifier group) { return Optional.ofNullable(localFiles.get(group)); } FileUserConfig(File configFile); }
FileUserConfig extends UserConfig { @Override public Optional<File> getLocalFilePath(SecretsGroupIdentifier group) { return Optional.ofNullable(localFiles.get(group)); } FileUserConfig(File configFile); @Override Optional<File> getLocalFilePath(SecretsGroupIdentifier group); @Override void addLocalFilePath(SecretsGroupIdentifier group, File path); @Override void updateLocalFilePath(SecretsGroupIdentifier group, File path); @Override void removeLocalFilePath(SecretsGroupIdentifier group); }
FileUserConfig extends UserConfig { @Override public Optional<File> getLocalFilePath(SecretsGroupIdentifier group) { return Optional.ofNullable(localFiles.get(group)); } FileUserConfig(File configFile); @Override Optional<File> getLocalFilePath(SecretsGroupIdentifier group); @Override void addLocalFilePath(SecretsGroupIdentifier group, File path); @Override void updateLocalFilePath(SecretsGroupIdentifier group, File path); @Override void removeLocalFilePath(SecretsGroupIdentifier group); }
@Test public void testUpdateLocalFilePath() throws Exception { assertEquals(fileUserConfig.getLocalFilePath(GROUP1_US), Optional.of(new File("uswest1-test-group.sm"))); fileUserConfig.updateLocalFilePath(GROUP1_US, new File("some-other-file.sm")); assertEquals(fileUserConfig.getLocalFilePath(GROUP1_US), Optional.of(new File("some-other-file.sm"))); }
@Override public void updateLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueFilePath(path); localFiles.put(group, path); persist(); }
FileUserConfig extends UserConfig { @Override public void updateLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueFilePath(path); localFiles.put(group, path); persist(); } }
FileUserConfig extends UserConfig { @Override public void updateLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueFilePath(path); localFiles.put(group, path); persist(); } FileUserConfig(File configFile); }
FileUserConfig extends UserConfig { @Override public void updateLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueFilePath(path); localFiles.put(group, path); persist(); } FileUserConfig(File configFile); @Override Optional<File> getLocalFilePath(SecretsGroupIdentifier group); @Override void addLocalFilePath(SecretsGroupIdentifier group, File path); @Override void updateLocalFilePath(SecretsGroupIdentifier group, File path); @Override void removeLocalFilePath(SecretsGroupIdentifier group); }
FileUserConfig extends UserConfig { @Override public void updateLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueFilePath(path); localFiles.put(group, path); persist(); } FileUserConfig(File configFile); @Override Optional<File> getLocalFilePath(SecretsGroupIdentifier group); @Override void addLocalFilePath(SecretsGroupIdentifier group, File path); @Override void updateLocalFilePath(SecretsGroupIdentifier group, File path); @Override void removeLocalFilePath(SecretsGroupIdentifier group); }
@Test public void testRemoveLocalFilePath() throws Exception { fileUserConfig.removeLocalFilePath(GROUP1_EU); fileUserConfig.removeLocalFilePath(GROUP2_EU); assertEquals(fileUserConfig.getLocalFilePath(GROUP1_EU), Optional.empty()); assertEquals(fileUserConfig.getLocalFilePath(GROUP2_EU), Optional.empty()); assertEquals(fileUserConfig.getLocalFilePath(GROUP1_US), Optional.of(new File("uswest1-test-group.sm"))); }
@Override public void removeLocalFilePath(SecretsGroupIdentifier group) { localFiles.remove(group); persist(); }
FileUserConfig extends UserConfig { @Override public void removeLocalFilePath(SecretsGroupIdentifier group) { localFiles.remove(group); persist(); } }
FileUserConfig extends UserConfig { @Override public void removeLocalFilePath(SecretsGroupIdentifier group) { localFiles.remove(group); persist(); } FileUserConfig(File configFile); }
FileUserConfig extends UserConfig { @Override public void removeLocalFilePath(SecretsGroupIdentifier group) { localFiles.remove(group); persist(); } FileUserConfig(File configFile); @Override Optional<File> getLocalFilePath(SecretsGroupIdentifier group); @Override void addLocalFilePath(SecretsGroupIdentifier group, File path); @Override void updateLocalFilePath(SecretsGroupIdentifier group, File path); @Override void removeLocalFilePath(SecretsGroupIdentifier group); }
FileUserConfig extends UserConfig { @Override public void removeLocalFilePath(SecretsGroupIdentifier group) { localFiles.remove(group); persist(); } FileUserConfig(File configFile); @Override Optional<File> getLocalFilePath(SecretsGroupIdentifier group); @Override void addLocalFilePath(SecretsGroupIdentifier group, File path); @Override void updateLocalFilePath(SecretsGroupIdentifier group, File path); @Override void removeLocalFilePath(SecretsGroupIdentifier group); }
@Test public void testDecodeSecretsGroupName() { String decoded = AWSResourceNameSerialization.decodeSecretsGroupName("test-group-1"); assertEquals(decoded, "test.group.1"); }
public static String decodeSecretsGroupName(String encoded) { return encoded.replace('-', '.'); }
AWSResourceNameSerialization { public static String decodeSecretsGroupName(String encoded) { return encoded.replace('-', '.'); } }
AWSResourceNameSerialization { public static String decodeSecretsGroupName(String encoded) { return encoded.replace('-', '.'); } }
AWSResourceNameSerialization { public static String decodeSecretsGroupName(String encoded) { return encoded.replace('-', '.'); } static String decodeSecretsGroupName(String encoded); static String encodeSecretsGroupName(String name); }
AWSResourceNameSerialization { public static String decodeSecretsGroupName(String encoded) { return encoded.replace('-', '.'); } static String decodeSecretsGroupName(String encoded); static String encodeSecretsGroupName(String name); static final String GLOBAL_PREFIX; static final String GLOBAL_STRING_DELIMITER; }
@Test public void testEncodeSecretsGroupName() { String encoded = AWSResourceNameSerialization.encodeSecretsGroupName("test.group.1"); assertEquals(encoded, "test-group-1"); assertEquals(AWSResourceNameSerialization.encodeSecretsGroupName( AWSResourceNameSerialization.decodeSecretsGroupName("test-group-1")), "test-group-1"); }
public static String encodeSecretsGroupName(String name) { return name.replace('.', '-'); }
AWSResourceNameSerialization { public static String encodeSecretsGroupName(String name) { return name.replace('.', '-'); } }
AWSResourceNameSerialization { public static String encodeSecretsGroupName(String name) { return name.replace('.', '-'); } }
AWSResourceNameSerialization { public static String encodeSecretsGroupName(String name) { return name.replace('.', '-'); } static String decodeSecretsGroupName(String encoded); static String encodeSecretsGroupName(String name); }
AWSResourceNameSerialization { public static String encodeSecretsGroupName(String name) { return name.replace('.', '-'); } static String decodeSecretsGroupName(String encoded); static String encodeSecretsGroupName(String name); static final String GLOBAL_PREFIX; static final String GLOBAL_STRING_DELIMITER; }
@Test public void serialize() { String serialized = rawSecretEntry.toJsonBlob(); assertThat(serialized, is(jsonBlob)); }
public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize secret entry to JSON blob", e); } }
RawSecretEntry implements BestEffortShred { public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize secret entry to JSON blob", e); } } }
RawSecretEntry implements BestEffortShred { public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize secret entry to JSON blob", e); } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier, @JsonProperty("version") long version, @JsonProperty("state") State state, @JsonProperty("notBefore") Optional<ZonedDateTime> notBefore, @JsonProperty("notAfter") Optional<ZonedDateTime> notAfter, @JsonProperty("encryptedPayload") byte[] encryptedPayload); }
RawSecretEntry implements BestEffortShred { public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize secret entry to JSON blob", e); } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier, @JsonProperty("version") long version, @JsonProperty("state") State state, @JsonProperty("notBefore") Optional<ZonedDateTime> notBefore, @JsonProperty("notAfter") Optional<ZonedDateTime> notAfter, @JsonProperty("encryptedPayload") byte[] encryptedPayload); String toJsonBlob(); static RawSecretEntry fromJsonBlob(String jsonBlob); byte[] sha1OfEncryptionPayload(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); }
RawSecretEntry implements BestEffortShred { public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize secret entry to JSON blob", e); } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier, @JsonProperty("version") long version, @JsonProperty("state") State state, @JsonProperty("notBefore") Optional<ZonedDateTime> notBefore, @JsonProperty("notAfter") Optional<ZonedDateTime> notAfter, @JsonProperty("encryptedPayload") byte[] encryptedPayload); String toJsonBlob(); static RawSecretEntry fromJsonBlob(String jsonBlob); byte[] sha1OfEncryptionPayload(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); @PartitionKey(position=Config.KEY, padding = 128) @JsonProperty("secretIdentifier") public SecretIdentifier secretIdentifier; @SortKey(position=Config.VERSION) @JsonProperty("version") public Long version; @Attribute(position=Config.STATE) @JsonProperty("state") public State state; @Attribute(position=Config.NOT_BEFORE) @JsonProperty("notBefore") public Optional<ZonedDateTime> notBefore; @Attribute(position=Config.NOT_AFTER) @JsonProperty("notAfter") public Optional<ZonedDateTime> notAfter; @Attribute(position=Config.VALUE) @JsonProperty("encryptedPayload") public byte[] encryptedPayload; }
@Test public void deserialize() { RawSecretEntry deserialized = RawSecretEntry.fromJsonBlob(jsonBlob); assertThat(deserialized, is(rawSecretEntry)); }
public static RawSecretEntry fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, RawSecretEntry.class); } catch (IOException e) { throw new ParseException("Failed to deserialize secret entry from JSON blob", e); } }
RawSecretEntry implements BestEffortShred { public static RawSecretEntry fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, RawSecretEntry.class); } catch (IOException e) { throw new ParseException("Failed to deserialize secret entry from JSON blob", e); } } }
RawSecretEntry implements BestEffortShred { public static RawSecretEntry fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, RawSecretEntry.class); } catch (IOException e) { throw new ParseException("Failed to deserialize secret entry from JSON blob", e); } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier, @JsonProperty("version") long version, @JsonProperty("state") State state, @JsonProperty("notBefore") Optional<ZonedDateTime> notBefore, @JsonProperty("notAfter") Optional<ZonedDateTime> notAfter, @JsonProperty("encryptedPayload") byte[] encryptedPayload); }
RawSecretEntry implements BestEffortShred { public static RawSecretEntry fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, RawSecretEntry.class); } catch (IOException e) { throw new ParseException("Failed to deserialize secret entry from JSON blob", e); } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier, @JsonProperty("version") long version, @JsonProperty("state") State state, @JsonProperty("notBefore") Optional<ZonedDateTime> notBefore, @JsonProperty("notAfter") Optional<ZonedDateTime> notAfter, @JsonProperty("encryptedPayload") byte[] encryptedPayload); String toJsonBlob(); static RawSecretEntry fromJsonBlob(String jsonBlob); byte[] sha1OfEncryptionPayload(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); }
RawSecretEntry implements BestEffortShred { public static RawSecretEntry fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, RawSecretEntry.class); } catch (IOException e) { throw new ParseException("Failed to deserialize secret entry from JSON blob", e); } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier, @JsonProperty("version") long version, @JsonProperty("state") State state, @JsonProperty("notBefore") Optional<ZonedDateTime> notBefore, @JsonProperty("notAfter") Optional<ZonedDateTime> notAfter, @JsonProperty("encryptedPayload") byte[] encryptedPayload); String toJsonBlob(); static RawSecretEntry fromJsonBlob(String jsonBlob); byte[] sha1OfEncryptionPayload(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); @PartitionKey(position=Config.KEY, padding = 128) @JsonProperty("secretIdentifier") public SecretIdentifier secretIdentifier; @SortKey(position=Config.VERSION) @JsonProperty("version") public Long version; @Attribute(position=Config.STATE) @JsonProperty("state") public State state; @Attribute(position=Config.NOT_BEFORE) @JsonProperty("notBefore") public Optional<ZonedDateTime> notBefore; @Attribute(position=Config.NOT_AFTER) @JsonProperty("notAfter") public Optional<ZonedDateTime> notAfter; @Attribute(position=Config.VALUE) @JsonProperty("encryptedPayload") public byte[] encryptedPayload; }
@Test(expectedExceptions = ParseException.class) public void deserializeInvalidJson() { RawSecretEntry.fromJsonBlob("{#$%^&*"); }
public static RawSecretEntry fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, RawSecretEntry.class); } catch (IOException e) { throw new ParseException("Failed to deserialize secret entry from JSON blob", e); } }
RawSecretEntry implements BestEffortShred { public static RawSecretEntry fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, RawSecretEntry.class); } catch (IOException e) { throw new ParseException("Failed to deserialize secret entry from JSON blob", e); } } }
RawSecretEntry implements BestEffortShred { public static RawSecretEntry fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, RawSecretEntry.class); } catch (IOException e) { throw new ParseException("Failed to deserialize secret entry from JSON blob", e); } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier, @JsonProperty("version") long version, @JsonProperty("state") State state, @JsonProperty("notBefore") Optional<ZonedDateTime> notBefore, @JsonProperty("notAfter") Optional<ZonedDateTime> notAfter, @JsonProperty("encryptedPayload") byte[] encryptedPayload); }
RawSecretEntry implements BestEffortShred { public static RawSecretEntry fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, RawSecretEntry.class); } catch (IOException e) { throw new ParseException("Failed to deserialize secret entry from JSON blob", e); } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier, @JsonProperty("version") long version, @JsonProperty("state") State state, @JsonProperty("notBefore") Optional<ZonedDateTime> notBefore, @JsonProperty("notAfter") Optional<ZonedDateTime> notAfter, @JsonProperty("encryptedPayload") byte[] encryptedPayload); String toJsonBlob(); static RawSecretEntry fromJsonBlob(String jsonBlob); byte[] sha1OfEncryptionPayload(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); }
RawSecretEntry implements BestEffortShred { public static RawSecretEntry fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, RawSecretEntry.class); } catch (IOException e) { throw new ParseException("Failed to deserialize secret entry from JSON blob", e); } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier, @JsonProperty("version") long version, @JsonProperty("state") State state, @JsonProperty("notBefore") Optional<ZonedDateTime> notBefore, @JsonProperty("notAfter") Optional<ZonedDateTime> notAfter, @JsonProperty("encryptedPayload") byte[] encryptedPayload); String toJsonBlob(); static RawSecretEntry fromJsonBlob(String jsonBlob); byte[] sha1OfEncryptionPayload(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); @PartitionKey(position=Config.KEY, padding = 128) @JsonProperty("secretIdentifier") public SecretIdentifier secretIdentifier; @SortKey(position=Config.VERSION) @JsonProperty("version") public Long version; @Attribute(position=Config.STATE) @JsonProperty("state") public State state; @Attribute(position=Config.NOT_BEFORE) @JsonProperty("notBefore") public Optional<ZonedDateTime> notBefore; @Attribute(position=Config.NOT_AFTER) @JsonProperty("notAfter") public Optional<ZonedDateTime> notAfter; @Attribute(position=Config.VALUE) @JsonProperty("encryptedPayload") public byte[] encryptedPayload; }
@Test public void testAttachReadOnly() throws Exception { Principal principal = new Principal(PrincipalType.USER, "bob"); partiallyMockedPolicyManager.attachReadOnly(group, principal); AttachUserPolicyRequest request = new AttachUserPolicyRequest() .withPolicyArn(READONLY_POLICY_ARN) .withUserName(principal.name); verify(mockClient, times(1)).attachUserPolicy(request); }
public void attachReadOnly(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.READONLY); }
IAMPolicyManager { public void attachReadOnly(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.READONLY); } }
IAMPolicyManager { public void attachReadOnly(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); }
IAMPolicyManager { public void attachReadOnly(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); }
IAMPolicyManager { public void attachReadOnly(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }
@Test public void equals() { assertFalse(rawSecretEntry.equals(secretIdentifier)); RawSecretEntry rawSecretEntry2 = new RawSecretEntry( secretIdentifier, version, state, Optional.empty(), Optional.empty(), secret); assertFalse(rawSecretEntry.equals(rawSecretEntry2)); RawSecretEntry rawSecretEntry3 = new RawSecretEntry( secretIdentifier, version, state, Optional.empty(), Optional.empty(), secret); assertTrue(rawSecretEntry2.equals(rawSecretEntry3)); }
@Override public boolean equals(final Object obj) { if(obj instanceof RawSecretEntry){ final RawSecretEntry other = (RawSecretEntry) obj; return Objects.equal(secretIdentifier, other.secretIdentifier) && Objects.equal(version, other.version) && Objects.equal(state, other.state) && Objects.equal(notBefore, other.notBefore) && Objects.equal(notAfter, other.notAfter) && Arrays.equals(encryptedPayload, other.encryptedPayload); } else { return false; } }
RawSecretEntry implements BestEffortShred { @Override public boolean equals(final Object obj) { if(obj instanceof RawSecretEntry){ final RawSecretEntry other = (RawSecretEntry) obj; return Objects.equal(secretIdentifier, other.secretIdentifier) && Objects.equal(version, other.version) && Objects.equal(state, other.state) && Objects.equal(notBefore, other.notBefore) && Objects.equal(notAfter, other.notAfter) && Arrays.equals(encryptedPayload, other.encryptedPayload); } else { return false; } } }
RawSecretEntry implements BestEffortShred { @Override public boolean equals(final Object obj) { if(obj instanceof RawSecretEntry){ final RawSecretEntry other = (RawSecretEntry) obj; return Objects.equal(secretIdentifier, other.secretIdentifier) && Objects.equal(version, other.version) && Objects.equal(state, other.state) && Objects.equal(notBefore, other.notBefore) && Objects.equal(notAfter, other.notAfter) && Arrays.equals(encryptedPayload, other.encryptedPayload); } else { return false; } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier, @JsonProperty("version") long version, @JsonProperty("state") State state, @JsonProperty("notBefore") Optional<ZonedDateTime> notBefore, @JsonProperty("notAfter") Optional<ZonedDateTime> notAfter, @JsonProperty("encryptedPayload") byte[] encryptedPayload); }
RawSecretEntry implements BestEffortShred { @Override public boolean equals(final Object obj) { if(obj instanceof RawSecretEntry){ final RawSecretEntry other = (RawSecretEntry) obj; return Objects.equal(secretIdentifier, other.secretIdentifier) && Objects.equal(version, other.version) && Objects.equal(state, other.state) && Objects.equal(notBefore, other.notBefore) && Objects.equal(notAfter, other.notAfter) && Arrays.equals(encryptedPayload, other.encryptedPayload); } else { return false; } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier, @JsonProperty("version") long version, @JsonProperty("state") State state, @JsonProperty("notBefore") Optional<ZonedDateTime> notBefore, @JsonProperty("notAfter") Optional<ZonedDateTime> notAfter, @JsonProperty("encryptedPayload") byte[] encryptedPayload); String toJsonBlob(); static RawSecretEntry fromJsonBlob(String jsonBlob); byte[] sha1OfEncryptionPayload(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); }
RawSecretEntry implements BestEffortShred { @Override public boolean equals(final Object obj) { if(obj instanceof RawSecretEntry){ final RawSecretEntry other = (RawSecretEntry) obj; return Objects.equal(secretIdentifier, other.secretIdentifier) && Objects.equal(version, other.version) && Objects.equal(state, other.state) && Objects.equal(notBefore, other.notBefore) && Objects.equal(notAfter, other.notAfter) && Arrays.equals(encryptedPayload, other.encryptedPayload); } else { return false; } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier, @JsonProperty("version") long version, @JsonProperty("state") State state, @JsonProperty("notBefore") Optional<ZonedDateTime> notBefore, @JsonProperty("notAfter") Optional<ZonedDateTime> notAfter, @JsonProperty("encryptedPayload") byte[] encryptedPayload); String toJsonBlob(); static RawSecretEntry fromJsonBlob(String jsonBlob); byte[] sha1OfEncryptionPayload(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); @PartitionKey(position=Config.KEY, padding = 128) @JsonProperty("secretIdentifier") public SecretIdentifier secretIdentifier; @SortKey(position=Config.VERSION) @JsonProperty("version") public Long version; @Attribute(position=Config.STATE) @JsonProperty("state") public State state; @Attribute(position=Config.NOT_BEFORE) @JsonProperty("notBefore") public Optional<ZonedDateTime> notBefore; @Attribute(position=Config.NOT_AFTER) @JsonProperty("notAfter") public Optional<ZonedDateTime> notAfter; @Attribute(position=Config.VALUE) @JsonProperty("encryptedPayload") public byte[] encryptedPayload; }
@Test public void testSecretsGroupInfo() { List<Principal> readonlyPrincipals = getReadOnlyPrincipals(); List<Principal> adminPrincipals = getAdminPrincipals(); SecretsGroupInfo info = new SecretsGroupInfo( new SecretsGroupSRN(account, new SecretsGroupIdentifier(groupRegion, groupName)), encryptorArn, storageArn, adminArn, readonlyArn, adminPrincipals, readonlyPrincipals); assertEquals(info.srn.account, account); assertEquals(info.srn.groupIdentifier.name, groupName); assertEquals(info.srn.groupIdentifier.region, groupRegion); assertEquals(info.encryptorArn, encryptorArn); assertEquals(info.storageArn, storageArn); assertEquals(info.adminPolicyArn, adminArn); assertEquals(info.readOnlyPolicyArn, readonlyArn); assertEquals(info.admin, adminPrincipals); assertEquals(info.readOnly, readonlyPrincipals); assertEquals( info.toString(), "SecretsGroupInfo{srn=srn:aws:strongbox:us-west-1:1234:group/project/group1, " + "storageArn=Optional[arn:aws:dynamodb:eu-west-1:1234:table/strongbox_eu-west-1_project-group1], " + "encryptorArn=Optional[arn:aws:kms:eu-west-1:1234:key/d413a4de-5eb5-4eb4-b4af-373bcba5efdf], " + "adminPolicyArn=Optional[arn:aws:iam::1234:policy/strongbox/strongbox_eu-west-1_project-group1_admin], " + "readOnlyPolicyArn=Optional[arn:aws:iam::1234:policy/strongbox/strongbox_eu-west-1_project-group1_readonly], " + "admin=[alice [user], awesometeam [group]], readOnly=[bob [user], awesomeservice [role]]}" ); }
public SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly) { this.srn = srn; this.encryptorArn = encryptorArn; this.storageArn = storageArn; this.adminPolicyArn = adminPolicyArn; this.readOnlyPolicyArn = readOnlyPolicyArn; this.admin = admin; this.readOnly = readOnly; }
SecretsGroupInfo { public SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly) { this.srn = srn; this.encryptorArn = encryptorArn; this.storageArn = storageArn; this.adminPolicyArn = adminPolicyArn; this.readOnlyPolicyArn = readOnlyPolicyArn; this.admin = admin; this.readOnly = readOnly; } }
SecretsGroupInfo { public SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly) { this.srn = srn; this.encryptorArn = encryptorArn; this.storageArn = storageArn; this.adminPolicyArn = adminPolicyArn; this.readOnlyPolicyArn = readOnlyPolicyArn; this.admin = admin; this.readOnly = readOnly; } SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly); }
SecretsGroupInfo { public SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly) { this.srn = srn; this.encryptorArn = encryptorArn; this.storageArn = storageArn; this.adminPolicyArn = adminPolicyArn; this.readOnlyPolicyArn = readOnlyPolicyArn; this.admin = admin; this.readOnly = readOnly; } SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
SecretsGroupInfo { public SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly) { this.srn = srn; this.encryptorArn = encryptorArn; this.storageArn = storageArn; this.adminPolicyArn = adminPolicyArn; this.readOnlyPolicyArn = readOnlyPolicyArn; this.admin = admin; this.readOnly = readOnly; } SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); public SecretsGroupSRN srn; public Optional<String> encryptorArn; public Optional<String> storageArn; public Optional<String> adminPolicyArn; public Optional<String> readOnlyPolicyArn; public List<Principal> admin; public List<Principal> readOnly; }
@Test public void testEquals() { SecretsGroupInfo info = new SecretsGroupInfo( new SecretsGroupSRN(account, new SecretsGroupIdentifier(groupRegion, groupName)), encryptorArn, storageArn, adminArn, readonlyArn, new ArrayList<>(), new ArrayList<>()); SecretsGroupInfo infoCopy = new SecretsGroupInfo( new SecretsGroupSRN(account, new SecretsGroupIdentifier(groupRegion, groupName)), encryptorArn, storageArn, adminArn, readonlyArn, new ArrayList<>(), new ArrayList<>()); assertTrue(info.equals(infoCopy)); SecretsGroupInfo differentInfo = new SecretsGroupInfo( new SecretsGroupSRN(account, new SecretsGroupIdentifier(Region.EU_WEST_1, groupName)), encryptorArn, storageArn, adminArn, readonlyArn, new ArrayList<>(), new ArrayList<>()); assertFalse(info.equals(differentInfo)); differentInfo = new SecretsGroupInfo( new SecretsGroupSRN(account, new SecretsGroupIdentifier(groupRegion, "other.name")), encryptorArn, storageArn, adminArn, readonlyArn, new ArrayList<>(), new ArrayList<>()); assertFalse(info.equals(differentInfo)); differentInfo = new SecretsGroupInfo( new SecretsGroupSRN(account, new SecretsGroupIdentifier(groupRegion, groupName)), Optional.of("other encryptor ARN"), storageArn, adminArn, readonlyArn, new ArrayList<>(), new ArrayList<>()); assertFalse(info.equals(differentInfo)); differentInfo = new SecretsGroupInfo( new SecretsGroupSRN(account, new SecretsGroupIdentifier(groupRegion, groupName)), encryptorArn, Optional.of("other storage ARN"), adminArn, readonlyArn, new ArrayList<>(), new ArrayList<>()); assertFalse(info.equals(differentInfo)); differentInfo = new SecretsGroupInfo( new SecretsGroupSRN(account, new SecretsGroupIdentifier(groupRegion, groupName)), encryptorArn, storageArn, Optional.of("other admin ARN"), readonlyArn, new ArrayList<>(), new ArrayList<>()); assertFalse(info.equals(differentInfo)); differentInfo = new SecretsGroupInfo( new SecretsGroupSRN(account, new SecretsGroupIdentifier(groupRegion, groupName)), encryptorArn, storageArn, adminArn, Optional.of("other readonly ARN"), new ArrayList<>(), new ArrayList<>()); assertFalse(info.equals(differentInfo)); differentInfo = new SecretsGroupInfo( new SecretsGroupSRN(account, new SecretsGroupIdentifier(groupRegion, groupName)), encryptorArn, storageArn, adminArn, readonlyArn, getAdminPrincipals(), new ArrayList<>()); assertFalse(info.equals(differentInfo)); differentInfo = new SecretsGroupInfo( new SecretsGroupSRN(account, new SecretsGroupIdentifier(groupRegion, groupName)), encryptorArn, storageArn, adminArn, readonlyArn, new ArrayList<>(), getReadOnlyPrincipals()); assertFalse(info.equals(differentInfo)); assertFalse(info.equals("some string value")); }
@Override public boolean equals(final Object obj) { if(obj instanceof SecretsGroupInfo){ final SecretsGroupInfo other = (SecretsGroupInfo) obj; return Objects.equal(srn, other.srn) && Objects.equal(encryptorArn, other.encryptorArn) && Objects.equal(storageArn, other.storageArn) && Objects.equal(adminPolicyArn, other.adminPolicyArn) && Objects.equal(readOnlyPolicyArn, other.readOnlyPolicyArn) && Objects.equal(admin, other.admin) && Objects.equal(readOnly, other.readOnly); } else{ return false; } }
SecretsGroupInfo { @Override public boolean equals(final Object obj) { if(obj instanceof SecretsGroupInfo){ final SecretsGroupInfo other = (SecretsGroupInfo) obj; return Objects.equal(srn, other.srn) && Objects.equal(encryptorArn, other.encryptorArn) && Objects.equal(storageArn, other.storageArn) && Objects.equal(adminPolicyArn, other.adminPolicyArn) && Objects.equal(readOnlyPolicyArn, other.readOnlyPolicyArn) && Objects.equal(admin, other.admin) && Objects.equal(readOnly, other.readOnly); } else{ return false; } } }
SecretsGroupInfo { @Override public boolean equals(final Object obj) { if(obj instanceof SecretsGroupInfo){ final SecretsGroupInfo other = (SecretsGroupInfo) obj; return Objects.equal(srn, other.srn) && Objects.equal(encryptorArn, other.encryptorArn) && Objects.equal(storageArn, other.storageArn) && Objects.equal(adminPolicyArn, other.adminPolicyArn) && Objects.equal(readOnlyPolicyArn, other.readOnlyPolicyArn) && Objects.equal(admin, other.admin) && Objects.equal(readOnly, other.readOnly); } else{ return false; } } SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly); }
SecretsGroupInfo { @Override public boolean equals(final Object obj) { if(obj instanceof SecretsGroupInfo){ final SecretsGroupInfo other = (SecretsGroupInfo) obj; return Objects.equal(srn, other.srn) && Objects.equal(encryptorArn, other.encryptorArn) && Objects.equal(storageArn, other.storageArn) && Objects.equal(adminPolicyArn, other.adminPolicyArn) && Objects.equal(readOnlyPolicyArn, other.readOnlyPolicyArn) && Objects.equal(admin, other.admin) && Objects.equal(readOnly, other.readOnly); } else{ return false; } } SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
SecretsGroupInfo { @Override public boolean equals(final Object obj) { if(obj instanceof SecretsGroupInfo){ final SecretsGroupInfo other = (SecretsGroupInfo) obj; return Objects.equal(srn, other.srn) && Objects.equal(encryptorArn, other.encryptorArn) && Objects.equal(storageArn, other.storageArn) && Objects.equal(adminPolicyArn, other.adminPolicyArn) && Objects.equal(readOnlyPolicyArn, other.readOnlyPolicyArn) && Objects.equal(admin, other.admin) && Objects.equal(readOnly, other.readOnly); } else{ return false; } } SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); public SecretsGroupSRN srn; public Optional<String> encryptorArn; public Optional<String> storageArn; public Optional<String> adminPolicyArn; public Optional<String> readOnlyPolicyArn; public List<Principal> admin; public List<Principal> readOnly; }
@Test public void role() { RoleARN arn = new RoleARN("arn:aws:iam::12345:role/role-name"); assertThat(arn.getRoleName(), is("role-name")); }
public String getRoleName() { return this.resource; }
RoleARN extends ARN { public String getRoleName() { return this.resource; } }
RoleARN extends ARN { public String getRoleName() { return this.resource; } RoleARN(final String arn); }
RoleARN extends ARN { public String getRoleName() { return this.resource; } RoleARN(final String arn); String getRoleName(); }
RoleARN extends ARN { public String getRoleName() { return this.resource; } RoleARN(final String arn); String getRoleName(); }
@Test public void testEquals() { byte[] value1 = {1, 2, 3, 4}; byte[] value2 = {1, 2, 3, 4}; byte[] value3 = {1, 2, 3, 5}; SecretValue secretValue1 = new SecretValue(value1, SecretType.OPAQUE); SecretValue secretValue2 = new SecretValue(value2, SecretType.OPAQUE); SecretValue secretValue3 = new SecretValue(value3, SecretType.OPAQUE); assertTrue(secretValue1.equals(secretValue2)); assertFalse(secretValue1.equals(secretValue3)); }
@Override public boolean equals(final Object obj) { if (obj instanceof SecretValue) { final SecretValue other = (SecretValue) obj; return Arrays.equals(secretValue, other.asByteArray()) && Objects.equal(type, other.type) && Objects.equal(encoding, other.encoding); } else { return false; } }
SecretValue implements BestEffortShred { @Override public boolean equals(final Object obj) { if (obj instanceof SecretValue) { final SecretValue other = (SecretValue) obj; return Arrays.equals(secretValue, other.asByteArray()) && Objects.equal(type, other.type) && Objects.equal(encoding, other.encoding); } else { return false; } } }
SecretValue implements BestEffortShred { @Override public boolean equals(final Object obj) { if (obj instanceof SecretValue) { final SecretValue other = (SecretValue) obj; return Arrays.equals(secretValue, other.asByteArray()) && Objects.equal(type, other.type) && Objects.equal(encoding, other.encoding); } else { return false; } } SecretValue(byte[] secretValue, Encoding encoding, SecretType type); SecretValue(byte[] secretValue, SecretType type); SecretValue(String secretValue, SecretType type); }
SecretValue implements BestEffortShred { @Override public boolean equals(final Object obj) { if (obj instanceof SecretValue) { final SecretValue other = (SecretValue) obj; return Arrays.equals(secretValue, other.asByteArray()) && Objects.equal(type, other.type) && Objects.equal(encoding, other.encoding); } else { return false; } } SecretValue(byte[] secretValue, Encoding encoding, SecretType type); SecretValue(byte[] secretValue, SecretType type); SecretValue(String secretValue, SecretType type); byte[] asByteArray(); String asString(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); }
SecretValue implements BestEffortShred { @Override public boolean equals(final Object obj) { if (obj instanceof SecretValue) { final SecretValue other = (SecretValue) obj; return Arrays.equals(secretValue, other.asByteArray()) && Objects.equal(type, other.type) && Objects.equal(encoding, other.encoding); } else { return false; } } SecretValue(byte[] secretValue, Encoding encoding, SecretType type); SecretValue(byte[] secretValue, SecretType type); SecretValue(String secretValue, SecretType type); byte[] asByteArray(); String asString(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretType type; final Encoding encoding; }
@Test public void testFromArn() { Principal principal; principal = Principal.fromArn("arn:aws:iam::12345:user/bob", "12345"); assertEquals(principal.type, PrincipalType.USER); assertEquals(principal.name, "bob" ); principal = Principal.fromArn("arn:aws:iam::12345:group/team-awesome", "12345"); assertEquals(principal.type, PrincipalType.GROUP); assertEquals(principal.name, "team-awesome"); principal = Principal.fromArn("arn:aws:iam::12345:role/myrole", "12345"); assertEquals(principal.type, PrincipalType.ROLE); assertEquals(principal.name, "myrole"); }
public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final PrincipalType type; final String name; }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromArnInvalidPrefix() { Principal principal = Principal.fromArn("arn:aws:invalid::12345:user/username", "12345"); }
public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final PrincipalType type; final String name; }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromArnInvalidNumberParts() { Principal principal = Principal.fromArn("arn:aws:iam::user/username", "12345"); }
public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final PrincipalType type; final String name; }
@Test(expectedExceptions = IllegalArgumentException.class) public void testFromArnInvalidType() { Principal principal = Principal.fromArn("arn:aws:iam::12345:invalid-type/username", "12345"); }
public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final PrincipalType type; final String name; }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromArnInvalidResource() { Principal principal = Principal.fromArn("arn:aws:iam::12345:user/username/group", "12345"); }
public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final PrincipalType type; final String name; }
@Test public void testAttachReadonlyRole() throws Exception { Principal principal = new Principal(PrincipalType.ROLE, "awesome-service"); partiallyMockedPolicyManager.attachReadOnly(group, principal); AttachRolePolicyRequest request = new AttachRolePolicyRequest() .withPolicyArn(READONLY_POLICY_ARN) .withRoleName(principal.name); verify(mockClient, times(1)).attachRolePolicy(request); }
public void attachReadOnly(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.READONLY); }
IAMPolicyManager { public void attachReadOnly(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.READONLY); } }
IAMPolicyManager { public void attachReadOnly(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); }
IAMPolicyManager { public void attachReadOnly(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); }
IAMPolicyManager { public void attachReadOnly(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }
@Test public void testToString() { Principal principal = Principal.fromArn("arn:aws:iam::12345:user/bob", "12345"); assertEquals(principal.toString(), "bob [user]"); }
@Override public String toString() { return String.format("%s [%s]", name, type.toString()); }
Principal { @Override public String toString() { return String.format("%s [%s]", name, type.toString()); } }
Principal { @Override public String toString() { return String.format("%s [%s]", name, type.toString()); } Principal(PrincipalType type, String principalName); }
Principal { @Override public String toString() { return String.format("%s [%s]", name, type.toString()); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
Principal { @Override public String toString() { return String.format("%s [%s]", name, type.toString()); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final PrincipalType type; final String name; }
@Test public void testEquals() { Principal principal1 = Principal.fromArn("arn:aws:iam::12345:user/bob", "12345"); Principal principal2 = new Principal(PrincipalType.USER, "bob"); assertTrue(principal1.equals(principal2)); }
@Override public boolean equals(final Object obj) { if(obj instanceof Principal){ final Principal other = (Principal) obj; return Objects.equal(name, other.name) && Objects.equal(type, other.type); } else{ return false; } }
Principal { @Override public boolean equals(final Object obj) { if(obj instanceof Principal){ final Principal other = (Principal) obj; return Objects.equal(name, other.name) && Objects.equal(type, other.type); } else{ return false; } } }
Principal { @Override public boolean equals(final Object obj) { if(obj instanceof Principal){ final Principal other = (Principal) obj; return Objects.equal(name, other.name) && Objects.equal(type, other.type); } else{ return false; } } Principal(PrincipalType type, String principalName); }
Principal { @Override public boolean equals(final Object obj) { if(obj instanceof Principal){ final Principal other = (Principal) obj; return Objects.equal(name, other.name) && Objects.equal(type, other.type); } else{ return false; } } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
Principal { @Override public boolean equals(final Object obj) { if(obj instanceof Principal){ final Principal other = (Principal) obj; return Objects.equal(name, other.name) && Objects.equal(type, other.type); } else{ return false; } } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final PrincipalType type; final String name; }
@Test(expectedExceptions = IllegalArgumentException.class) public void testAnotherAccount() { Principal principal = Principal.fromArn("arn:aws:iam::123456:user/bob", "12345"); }
public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final PrincipalType type; final String name; }
@Test public void testSecretEntry() { EncryptionPayload payload = createPayload(true); RawSecretEntry rawEntry = createRawEntry(); SecretEntry secretEntry = new SecretEntry(payload, rawEntry); assertEquals(secretEntry.secretIdentifier.name, rawEntry.secretIdentifier.name); assertEquals(secretEntry.version, rawEntry.version.longValue()); assertEquals(secretEntry.secretValue, payload.value); assertEquals(secretEntry.created, payload.created); assertEquals(secretEntry.comment, payload.comment); assertEquals(secretEntry.userData, payload.userData); assertEquals( secretEntry.toString(), "SecretEntry{secretIdentifier=key, version=1, secretValue=SecretValue{type=opaque, secretEncoding=utf8}, " + "created=2016-06-01T00:00Z[UTC], modified=2017-06-01T00:00Z[UTC], state=enabled, notBefore=Optional[2016-06-01T13:37:42Z[UTC]], " + "notAfter=Optional.empty, comment=Optional[Comment{}], userData=Optional[UserData{}]}"); }
public SecretEntry(EncryptionPayload encryptionPayload, RawSecretEntry rawSecretEntry) { this.secretIdentifier = rawSecretEntry.secretIdentifier; this.version = rawSecretEntry.version; this.state = rawSecretEntry.state; this.notBefore = rawSecretEntry.notBefore; this.notAfter = rawSecretEntry.notAfter; this.secretValue = encryptionPayload.value; this.userData = encryptionPayload.userData; this.created = encryptionPayload.created; this.modified = encryptionPayload.modified; this.createdBy = encryptionPayload.createdBy; this.modifiedBy = encryptionPayload.modifiedBy; this.comment = encryptionPayload.comment; }
SecretEntry implements BestEffortShred { public SecretEntry(EncryptionPayload encryptionPayload, RawSecretEntry rawSecretEntry) { this.secretIdentifier = rawSecretEntry.secretIdentifier; this.version = rawSecretEntry.version; this.state = rawSecretEntry.state; this.notBefore = rawSecretEntry.notBefore; this.notAfter = rawSecretEntry.notAfter; this.secretValue = encryptionPayload.value; this.userData = encryptionPayload.userData; this.created = encryptionPayload.created; this.modified = encryptionPayload.modified; this.createdBy = encryptionPayload.createdBy; this.modifiedBy = encryptionPayload.modifiedBy; this.comment = encryptionPayload.comment; } }
SecretEntry implements BestEffortShred { public SecretEntry(EncryptionPayload encryptionPayload, RawSecretEntry rawSecretEntry) { this.secretIdentifier = rawSecretEntry.secretIdentifier; this.version = rawSecretEntry.version; this.state = rawSecretEntry.state; this.notBefore = rawSecretEntry.notBefore; this.notAfter = rawSecretEntry.notAfter; this.secretValue = encryptionPayload.value; this.userData = encryptionPayload.userData; this.created = encryptionPayload.created; this.modified = encryptionPayload.modified; this.createdBy = encryptionPayload.createdBy; this.modifiedBy = encryptionPayload.modifiedBy; this.comment = encryptionPayload.comment; } SecretEntry(EncryptionPayload encryptionPayload, RawSecretEntry rawSecretEntry); protected SecretEntry(SecretIdentifier secretIdentifier, long version, SecretValue secretValue, ZonedDateTime created, ZonedDateTime modified, Optional<UserAlias> createdBy, Optional<UserAlias> modifiedBy, State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, Optional<Comment> comment, Optional<UserData> userData); }
SecretEntry implements BestEffortShred { public SecretEntry(EncryptionPayload encryptionPayload, RawSecretEntry rawSecretEntry) { this.secretIdentifier = rawSecretEntry.secretIdentifier; this.version = rawSecretEntry.version; this.state = rawSecretEntry.state; this.notBefore = rawSecretEntry.notBefore; this.notAfter = rawSecretEntry.notAfter; this.secretValue = encryptionPayload.value; this.userData = encryptionPayload.userData; this.created = encryptionPayload.created; this.modified = encryptionPayload.modified; this.createdBy = encryptionPayload.createdBy; this.modifiedBy = encryptionPayload.modifiedBy; this.comment = encryptionPayload.comment; } SecretEntry(EncryptionPayload encryptionPayload, RawSecretEntry rawSecretEntry); protected SecretEntry(SecretIdentifier secretIdentifier, long version, SecretValue secretValue, ZonedDateTime created, ZonedDateTime modified, Optional<UserAlias> createdBy, Optional<UserAlias> modifiedBy, State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, Optional<Comment> comment, Optional<UserData> userData); @Override String toString(); @Override void bestEffortShred(); }
SecretEntry implements BestEffortShred { public SecretEntry(EncryptionPayload encryptionPayload, RawSecretEntry rawSecretEntry) { this.secretIdentifier = rawSecretEntry.secretIdentifier; this.version = rawSecretEntry.version; this.state = rawSecretEntry.state; this.notBefore = rawSecretEntry.notBefore; this.notAfter = rawSecretEntry.notAfter; this.secretValue = encryptionPayload.value; this.userData = encryptionPayload.userData; this.created = encryptionPayload.created; this.modified = encryptionPayload.modified; this.createdBy = encryptionPayload.createdBy; this.modifiedBy = encryptionPayload.modifiedBy; this.comment = encryptionPayload.comment; } SecretEntry(EncryptionPayload encryptionPayload, RawSecretEntry rawSecretEntry); protected SecretEntry(SecretIdentifier secretIdentifier, long version, SecretValue secretValue, ZonedDateTime created, ZonedDateTime modified, Optional<UserAlias> createdBy, Optional<UserAlias> modifiedBy, State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, Optional<Comment> comment, Optional<UserData> userData); @Override String toString(); @Override void bestEffortShred(); final SecretIdentifier secretIdentifier; final long version; final SecretValue secretValue; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final State state; final Optional<ZonedDateTime> notBefore; final Optional<ZonedDateTime> notAfter; final Optional<Comment> comment; final Optional<UserData> userData; }
@Test public void testConstructWithValidNames() { SecretsGroupIdentifier group = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group1"); assertEquals(group.name, "project.service.group1"); assertEquals(group.region, Region.US_WEST_1); assertEquals(group.toString(), "project.service.group1 [us-west-1]"); }
@Override public String toString() { return String.format("%s [%s]", name, region.getName()); }
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public String toString() { return String.format("%s [%s]", name, region.getName()); } }
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public String toString() { return String.format("%s [%s]", name, region.getName()); } SecretsGroupIdentifier(@JsonProperty("region") Region region, @JsonProperty("name") String name); }
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public String toString() { return String.format("%s [%s]", name, region.getName()); } SecretsGroupIdentifier(@JsonProperty("region") Region region, @JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override int compareTo(SecretsGroupIdentifier o); }
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public String toString() { return String.format("%s [%s]", name, region.getName()); } SecretsGroupIdentifier(@JsonProperty("region") Region region, @JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override int compareTo(SecretsGroupIdentifier o); @JsonProperty("region") final Region region; @JsonProperty("name") final String name; }
@Test public void testEquals() throws Exception { SecretsGroupIdentifier group1 = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group1"); SecretsGroupIdentifier group2 = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group1"); SecretsGroupIdentifier group3 = new SecretsGroupIdentifier(Region.EU_WEST_1, "project.service.group1"); SecretsGroupIdentifier group4 = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group2"); assertTrue(group1.equals(group2)); assertFalse(group1.equals(group3)); assertFalse(group1.equals(group4)); assertFalse(group1.equals("some string value")); }
@Override public boolean equals(final Object obj) { if(obj instanceof SecretsGroupIdentifier){ final SecretsGroupIdentifier other = (SecretsGroupIdentifier) obj; return Objects.equal(name, other.name) && Objects.equal(region, other.region); } else { return false; } }
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public boolean equals(final Object obj) { if(obj instanceof SecretsGroupIdentifier){ final SecretsGroupIdentifier other = (SecretsGroupIdentifier) obj; return Objects.equal(name, other.name) && Objects.equal(region, other.region); } else { return false; } } }
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public boolean equals(final Object obj) { if(obj instanceof SecretsGroupIdentifier){ final SecretsGroupIdentifier other = (SecretsGroupIdentifier) obj; return Objects.equal(name, other.name) && Objects.equal(region, other.region); } else { return false; } } SecretsGroupIdentifier(@JsonProperty("region") Region region, @JsonProperty("name") String name); }
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public boolean equals(final Object obj) { if(obj instanceof SecretsGroupIdentifier){ final SecretsGroupIdentifier other = (SecretsGroupIdentifier) obj; return Objects.equal(name, other.name) && Objects.equal(region, other.region); } else { return false; } } SecretsGroupIdentifier(@JsonProperty("region") Region region, @JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override int compareTo(SecretsGroupIdentifier o); }
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public boolean equals(final Object obj) { if(obj instanceof SecretsGroupIdentifier){ final SecretsGroupIdentifier other = (SecretsGroupIdentifier) obj; return Objects.equal(name, other.name) && Objects.equal(region, other.region); } else { return false; } } SecretsGroupIdentifier(@JsonProperty("region") Region region, @JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override int compareTo(SecretsGroupIdentifier o); @JsonProperty("region") final Region region; @JsonProperty("name") final String name; }
@Test public void testCompareTo() throws Exception { SecretsGroupIdentifier group1 = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group1"); SecretsGroupIdentifier group2 = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group1"); SecretsGroupIdentifier group3 = new SecretsGroupIdentifier(Region.EU_WEST_1, "project.service.group1"); SecretsGroupIdentifier group4 = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group2"); assertEquals(group1.compareTo(group1), 0); assertEquals(group1.compareTo(group2), 0); assertEquals(group1.compareTo(group3), -2); assertEquals(group1.compareTo(group4), -1); assertEquals(group3.compareTo(group4), 2); }
@Override public int compareTo(SecretsGroupIdentifier o) { if (region.compareTo(o.region) == 0) { return name.compareTo(o.name); } else { return region.compareTo(o.region); } }
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public int compareTo(SecretsGroupIdentifier o) { if (region.compareTo(o.region) == 0) { return name.compareTo(o.name); } else { return region.compareTo(o.region); } } }
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public int compareTo(SecretsGroupIdentifier o) { if (region.compareTo(o.region) == 0) { return name.compareTo(o.name); } else { return region.compareTo(o.region); } } SecretsGroupIdentifier(@JsonProperty("region") Region region, @JsonProperty("name") String name); }
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public int compareTo(SecretsGroupIdentifier o) { if (region.compareTo(o.region) == 0) { return name.compareTo(o.name); } else { return region.compareTo(o.region); } } SecretsGroupIdentifier(@JsonProperty("region") Region region, @JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override int compareTo(SecretsGroupIdentifier o); }
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public int compareTo(SecretsGroupIdentifier o) { if (region.compareTo(o.region) == 0) { return name.compareTo(o.name); } else { return region.compareTo(o.region); } } SecretsGroupIdentifier(@JsonProperty("region") Region region, @JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override int compareTo(SecretsGroupIdentifier o); @JsonProperty("region") final Region region; @JsonProperty("name") final String name; }
@Test public void testConstructWithValidNames() { SecretIdentifier secret = new SecretIdentifier("fooBar1"); assertEquals(secret.name, "fooBar1"); assertEquals(secret.toString(), "fooBar1"); }
@Override public String toString() { return name; }
SecretIdentifier { @Override public String toString() { return name; } }
SecretIdentifier { @Override public String toString() { return name; } @JsonCreator SecretIdentifier(@JsonProperty("name") String name); }
SecretIdentifier { @Override public String toString() { return name; } @JsonCreator SecretIdentifier(@JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
SecretIdentifier { @Override public String toString() { return name; } @JsonCreator SecretIdentifier(@JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final String name; }
@Test public void testConstructWithValidUnderscoreNames() { SecretIdentifier secret = new SecretIdentifier("foo_bar_1"); assertEquals(secret.name, "foo_bar_1"); assertEquals(secret.toString(), "foo_bar_1"); }
@Override public String toString() { return name; }
SecretIdentifier { @Override public String toString() { return name; } }
SecretIdentifier { @Override public String toString() { return name; } @JsonCreator SecretIdentifier(@JsonProperty("name") String name); }
SecretIdentifier { @Override public String toString() { return name; } @JsonCreator SecretIdentifier(@JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
SecretIdentifier { @Override public String toString() { return name; } @JsonCreator SecretIdentifier(@JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final String name; }
@Test public void testEquals() throws Exception { SecretIdentifier secret1 = new SecretIdentifier("fooBar1"); SecretIdentifier secret2 = new SecretIdentifier("fooBar1"); SecretIdentifier secret3 = new SecretIdentifier("fooBar2"); assertTrue(secret1.equals(secret2)); assertFalse(secret1.equals(secret3)); assertFalse(secret1.equals("some value")); }
@Override public boolean equals(final Object obj) { if(obj instanceof SecretIdentifier){ final SecretIdentifier other = (SecretIdentifier) obj; return Objects.equal(name, other.name); } else { return false; } }
SecretIdentifier { @Override public boolean equals(final Object obj) { if(obj instanceof SecretIdentifier){ final SecretIdentifier other = (SecretIdentifier) obj; return Objects.equal(name, other.name); } else { return false; } } }
SecretIdentifier { @Override public boolean equals(final Object obj) { if(obj instanceof SecretIdentifier){ final SecretIdentifier other = (SecretIdentifier) obj; return Objects.equal(name, other.name); } else { return false; } } @JsonCreator SecretIdentifier(@JsonProperty("name") String name); }
SecretIdentifier { @Override public boolean equals(final Object obj) { if(obj instanceof SecretIdentifier){ final SecretIdentifier other = (SecretIdentifier) obj; return Objects.equal(name, other.name); } else { return false; } } @JsonCreator SecretIdentifier(@JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }
SecretIdentifier { @Override public boolean equals(final Object obj) { if(obj instanceof SecretIdentifier){ final SecretIdentifier other = (SecretIdentifier) obj; return Objects.equal(name, other.name); } else { return false; } } @JsonCreator SecretIdentifier(@JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final String name; }
@Test public void testDetachAdminUser() throws Exception { Principal principal = new Principal(PrincipalType.USER, "alice"); partiallyMockedPolicyManager.detachAdmin(group, principal); DetachUserPolicyRequest request = new DetachUserPolicyRequest() .withPolicyArn(ADMIN_POLICY_ARN) .withUserName(principal.name); verify(mockClient, times(1)).detachUserPolicy(request); }
public void detachAdmin(SecretsGroupIdentifier group, Principal principal) { detachPrincipal(group, principal, AccessLevel.ADMIN); }
IAMPolicyManager { public void detachAdmin(SecretsGroupIdentifier group, Principal principal) { detachPrincipal(group, principal, AccessLevel.ADMIN); } }
IAMPolicyManager { public void detachAdmin(SecretsGroupIdentifier group, Principal principal) { detachPrincipal(group, principal, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); }
IAMPolicyManager { public void detachAdmin(SecretsGroupIdentifier group, Principal principal) { detachPrincipal(group, principal, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); }
IAMPolicyManager { public void detachAdmin(SecretsGroupIdentifier group, Principal principal) { detachPrincipal(group, principal, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }
@Test public void handleRequest() throws Exception { String jsonInputAndExpectedOutput = "{\"value\":\"testValue\"}"; InputStream exampleInputStream = new ByteArrayInputStream(jsonInputAndExpectedOutput.getBytes(StandardCharsets.UTF_8)); OutputStream exampleOutputStream = new OutputStream() { private final StringBuilder stringBuilder = new StringBuilder(); @Override public void write(int b) { stringBuilder.append((char) b); } @Override public String toString() { return stringBuilder.toString(); } }; TestLambdaHandler lambdaHandler = new TestLambdaHandler(); lambdaHandler.handleRequest(exampleInputStream, exampleOutputStream, null); assertEquals(jsonInputAndExpectedOutput, exampleOutputStream.toString()); }
@Override public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException { I inputObject = deserializeEventJson(input, getInputType()); O handlerResult = handleRequest(inputObject, context); serializeOutput(output, handlerResult); }
LambdaHandler implements RequestStreamHandler { @Override public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException { I inputObject = deserializeEventJson(input, getInputType()); O handlerResult = handleRequest(inputObject, context); serializeOutput(output, handlerResult); } }
LambdaHandler implements RequestStreamHandler { @Override public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException { I inputObject = deserializeEventJson(input, getInputType()); O handlerResult = handleRequest(inputObject, context); serializeOutput(output, handlerResult); } protected LambdaHandler(); }
LambdaHandler implements RequestStreamHandler { @Override public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException { I inputObject = deserializeEventJson(input, getInputType()); O handlerResult = handleRequest(inputObject, context); serializeOutput(output, handlerResult); } protected LambdaHandler(); @Override void handleRequest(InputStream input, OutputStream output, Context context); abstract O handleRequest(I input, Context context); }
LambdaHandler implements RequestStreamHandler { @Override public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException { I inputObject = deserializeEventJson(input, getInputType()); O handlerResult = handleRequest(inputObject, context); serializeOutput(output, handlerResult); } protected LambdaHandler(); @Override void handleRequest(InputStream input, OutputStream output, Context context); abstract O handleRequest(I input, Context context); }
@Test public void testFailingToken() throws Exception { Handler testHandler = new Handler(); AuthorizationInput mockEvent = createNiceMock(AuthorizationInput.class); expect(mockEvent.getAuthorizationToken()).andReturn("INVALID_TOKEN").anyTimes(); replay(mockEvent); AuthorizationOutput authorizationOutput = testHandler.handleRequest(mockEvent, null); assertEquals(PolicyStatement.Effect.DENY, authorizationOutput.getPolicyDocument().getPolicyStatements().get(0).getEffect()); }
@Override public AuthorizationOutput handleRequest(AuthorizationInput input, Context context) { final String authenticationToken = input.getAuthorizationToken(); final PolicyDocument policyDocument = new PolicyDocument(); PolicyStatement.Effect policyEffect = PolicyStatement.Effect.ALLOW; String principalId = null; try { User authenticatedUser = userService.getUserByToken(authenticationToken); principalId = String.valueOf(authenticatedUser.getId()); } catch (UserNotFoundException userNotFoundException) { policyEffect = PolicyStatement.Effect.DENY; LOGGER.info("User authentication failed for token " + authenticationToken); } policyDocument.withPolicyStatement(new PolicyStatement("execute-api:Invoke", policyEffect, input.getMethodArn())); return new AuthorizationOutput(principalId, policyDocument); }
Handler extends LambdaHandler<AuthorizationInput, AuthorizationOutput> { @Override public AuthorizationOutput handleRequest(AuthorizationInput input, Context context) { final String authenticationToken = input.getAuthorizationToken(); final PolicyDocument policyDocument = new PolicyDocument(); PolicyStatement.Effect policyEffect = PolicyStatement.Effect.ALLOW; String principalId = null; try { User authenticatedUser = userService.getUserByToken(authenticationToken); principalId = String.valueOf(authenticatedUser.getId()); } catch (UserNotFoundException userNotFoundException) { policyEffect = PolicyStatement.Effect.DENY; LOGGER.info("User authentication failed for token " + authenticationToken); } policyDocument.withPolicyStatement(new PolicyStatement("execute-api:Invoke", policyEffect, input.getMethodArn())); return new AuthorizationOutput(principalId, policyDocument); } }
Handler extends LambdaHandler<AuthorizationInput, AuthorizationOutput> { @Override public AuthorizationOutput handleRequest(AuthorizationInput input, Context context) { final String authenticationToken = input.getAuthorizationToken(); final PolicyDocument policyDocument = new PolicyDocument(); PolicyStatement.Effect policyEffect = PolicyStatement.Effect.ALLOW; String principalId = null; try { User authenticatedUser = userService.getUserByToken(authenticationToken); principalId = String.valueOf(authenticatedUser.getId()); } catch (UserNotFoundException userNotFoundException) { policyEffect = PolicyStatement.Effect.DENY; LOGGER.info("User authentication failed for token " + authenticationToken); } policyDocument.withPolicyStatement(new PolicyStatement("execute-api:Invoke", policyEffect, input.getMethodArn())); return new AuthorizationOutput(principalId, policyDocument); } Handler(); }
Handler extends LambdaHandler<AuthorizationInput, AuthorizationOutput> { @Override public AuthorizationOutput handleRequest(AuthorizationInput input, Context context) { final String authenticationToken = input.getAuthorizationToken(); final PolicyDocument policyDocument = new PolicyDocument(); PolicyStatement.Effect policyEffect = PolicyStatement.Effect.ALLOW; String principalId = null; try { User authenticatedUser = userService.getUserByToken(authenticationToken); principalId = String.valueOf(authenticatedUser.getId()); } catch (UserNotFoundException userNotFoundException) { policyEffect = PolicyStatement.Effect.DENY; LOGGER.info("User authentication failed for token " + authenticationToken); } policyDocument.withPolicyStatement(new PolicyStatement("execute-api:Invoke", policyEffect, input.getMethodArn())); return new AuthorizationOutput(principalId, policyDocument); } Handler(); @Inject void setUserService(UserService userService); @Override AuthorizationOutput handleRequest(AuthorizationInput input, Context context); }
Handler extends LambdaHandler<AuthorizationInput, AuthorizationOutput> { @Override public AuthorizationOutput handleRequest(AuthorizationInput input, Context context) { final String authenticationToken = input.getAuthorizationToken(); final PolicyDocument policyDocument = new PolicyDocument(); PolicyStatement.Effect policyEffect = PolicyStatement.Effect.ALLOW; String principalId = null; try { User authenticatedUser = userService.getUserByToken(authenticationToken); principalId = String.valueOf(authenticatedUser.getId()); } catch (UserNotFoundException userNotFoundException) { policyEffect = PolicyStatement.Effect.DENY; LOGGER.info("User authentication failed for token " + authenticationToken); } policyDocument.withPolicyStatement(new PolicyStatement("execute-api:Invoke", policyEffect, input.getMethodArn())); return new AuthorizationOutput(principalId, policyDocument); } Handler(); @Inject void setUserService(UserService userService); @Override AuthorizationOutput handleRequest(AuthorizationInput input, Context context); }
@Test public void failedUserRegistrationWithExistingUsernameTest() throws Exception { thrown.expect(AnotherUserWithSameUsernameExistsException.class); UserService userService = getUserService(); final String username = UUID.randomUUID() + "test-username"; userService.registerNewUser(username, UUID.randomUUID() + "@test.com"); userService.registerNewUser(username, UUID.randomUUID() + "@test.com"); }
@Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; }
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } }
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } @Inject UserServiceImpl(UserRepository userRepository); }
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } @Inject UserServiceImpl(UserRepository userRepository); @Override User getUserByToken(String token); @Override User registerNewUser(String username, String email); }
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } @Inject UserServiceImpl(UserRepository userRepository); @Override User getUserByToken(String token); @Override User registerNewUser(String username, String email); }
@Test public void failedUserRegistrationWithExistingEMailTest() throws Exception { thrown.expect(AnotherUserWithSameEmailExistsException.class); UserService userService = getUserService(); final String email = UUID.randomUUID() + "@test.com"; userService.registerNewUser(UUID.randomUUID().toString(), email); userService.registerNewUser(UUID.randomUUID().toString(), email); }
@Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; }
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } }
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } @Inject UserServiceImpl(UserRepository userRepository); }
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } @Inject UserServiceImpl(UserRepository userRepository); @Override User getUserByToken(String token); @Override User registerNewUser(String username, String email); }
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } @Inject UserServiceImpl(UserRepository userRepository); @Override User getUserByToken(String token); @Override User registerNewUser(String username, String email); }
@Test public void failedUserRegistrationWithInvalidEmailTest() throws Exception { thrown.expect(InvalidMailAddressException.class); UserService userService = getUserService(); userService.registerNewUser(UUID.randomUUID().toString(), "INVALID_EMAIL"); }
@Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; }
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } }
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } @Inject UserServiceImpl(UserRepository userRepository); }
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } @Inject UserServiceImpl(UserRepository userRepository); @Override User getUserByToken(String token); @Override User registerNewUser(String username, String email); }
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } @Inject UserServiceImpl(UserRepository userRepository); @Override User getUserByToken(String token); @Override User registerNewUser(String username, String email); }
@Test public void testParseNum() { assertEquals( new Long( 262144L ), Long.valueOf( Integer.class.cast( DataTypes.parseNum( "256k", Integer.class, 1 ) ) ) ); assertEquals( new Long( 262144L ), Long.class.cast( DataTypes.parseNum( "256k", Long.class, 1L ) ) ); assertEquals( new Double( 670720.0D ), Double.class.cast( DataTypes.parseNum( "655k", Double.class, 1D ) ) ); assertEquals( new Double( 262144F ), Double.valueOf( Float.class.cast( DataTypes.parseNum( "256k", Float.class, 1F ) ) ) ); assertEquals( new Long( 25 ), Long.valueOf( (long) DataTypes.parseNum( "25", Short.class, Short.valueOf( "1" ) ) ) ); assertEquals( new Long( 25 ), Long.valueOf( Byte.class.cast( DataTypes.parseNum( "25", Byte.class, Byte.valueOf( "1" ) ) ) ) ); }
public static <T extends Number> T parseNum(String num, Class<T> cls, T def) { if (num == null) { return def; } T result = def; String toParse = num; Long multiplier = 1L; try { switch (num.charAt(num.length() - 1)) { case 'k' : case 'K' : multiplier = 1024L; toParse = num.substring(0, num.length() - 1); break; case 'm' : case 'M' : multiplier = 1024L * 1024L; toParse = num.substring(0, num.length() - 1); break; case 'g' : case 'G' : multiplier = 1024L * 1024L * 1024L; toParse = num.substring(0, num.length() - 1); break; } if(cls.equals(Integer.class)) { result = cls.cast(Integer.valueOf(toParse) * multiplier.intValue()); } else if(cls.equals(Long.class)) { result = cls.cast(Long.valueOf(toParse) * multiplier); } else if(cls.equals(Double.class)) { result = cls.cast(Double.valueOf(toParse) * multiplier.doubleValue()); } else if(cls.equals(Float.class)) { result = cls.cast(Float.valueOf(toParse) * multiplier.floatValue()); } else if(cls.equals(Byte.class)) { Integer res = Byte.valueOf(toParse) * multiplier.byteValue(); result = cls.cast(res.byteValue()); } else if(cls.equals(Short.class)) { Integer res = Short.valueOf(toParse) * multiplier.shortValue(); result = cls.cast(res.shortValue()); } } catch (Exception e) { log.log( Level.WARNING, "Error parsing value: {0} as {1}, using default: {2}", new Object[] {num,cls,def}); return def; } return result; }
DataTypes { public static <T extends Number> T parseNum(String num, Class<T> cls, T def) { if (num == null) { return def; } T result = def; String toParse = num; Long multiplier = 1L; try { switch (num.charAt(num.length() - 1)) { case 'k' : case 'K' : multiplier = 1024L; toParse = num.substring(0, num.length() - 1); break; case 'm' : case 'M' : multiplier = 1024L * 1024L; toParse = num.substring(0, num.length() - 1); break; case 'g' : case 'G' : multiplier = 1024L * 1024L * 1024L; toParse = num.substring(0, num.length() - 1); break; } if(cls.equals(Integer.class)) { result = cls.cast(Integer.valueOf(toParse) * multiplier.intValue()); } else if(cls.equals(Long.class)) { result = cls.cast(Long.valueOf(toParse) * multiplier); } else if(cls.equals(Double.class)) { result = cls.cast(Double.valueOf(toParse) * multiplier.doubleValue()); } else if(cls.equals(Float.class)) { result = cls.cast(Float.valueOf(toParse) * multiplier.floatValue()); } else if(cls.equals(Byte.class)) { Integer res = Byte.valueOf(toParse) * multiplier.byteValue(); result = cls.cast(res.byteValue()); } else if(cls.equals(Short.class)) { Integer res = Short.valueOf(toParse) * multiplier.shortValue(); result = cls.cast(res.shortValue()); } } catch (Exception e) { log.log( Level.WARNING, "Error parsing value: {0} as {1}, using default: {2}", new Object[] {num,cls,def}); return def; } return result; } }
DataTypes { public static <T extends Number> T parseNum(String num, Class<T> cls, T def) { if (num == null) { return def; } T result = def; String toParse = num; Long multiplier = 1L; try { switch (num.charAt(num.length() - 1)) { case 'k' : case 'K' : multiplier = 1024L; toParse = num.substring(0, num.length() - 1); break; case 'm' : case 'M' : multiplier = 1024L * 1024L; toParse = num.substring(0, num.length() - 1); break; case 'g' : case 'G' : multiplier = 1024L * 1024L * 1024L; toParse = num.substring(0, num.length() - 1); break; } if(cls.equals(Integer.class)) { result = cls.cast(Integer.valueOf(toParse) * multiplier.intValue()); } else if(cls.equals(Long.class)) { result = cls.cast(Long.valueOf(toParse) * multiplier); } else if(cls.equals(Double.class)) { result = cls.cast(Double.valueOf(toParse) * multiplier.doubleValue()); } else if(cls.equals(Float.class)) { result = cls.cast(Float.valueOf(toParse) * multiplier.floatValue()); } else if(cls.equals(Byte.class)) { Integer res = Byte.valueOf(toParse) * multiplier.byteValue(); result = cls.cast(res.byteValue()); } else if(cls.equals(Short.class)) { Integer res = Short.valueOf(toParse) * multiplier.shortValue(); result = cls.cast(res.shortValue()); } } catch (Exception e) { log.log( Level.WARNING, "Error parsing value: {0} as {1}, using default: {2}", new Object[] {num,cls,def}); return def; } return result; } }
DataTypes { public static <T extends Number> T parseNum(String num, Class<T> cls, T def) { if (num == null) { return def; } T result = def; String toParse = num; Long multiplier = 1L; try { switch (num.charAt(num.length() - 1)) { case 'k' : case 'K' : multiplier = 1024L; toParse = num.substring(0, num.length() - 1); break; case 'm' : case 'M' : multiplier = 1024L * 1024L; toParse = num.substring(0, num.length() - 1); break; case 'g' : case 'G' : multiplier = 1024L * 1024L * 1024L; toParse = num.substring(0, num.length() - 1); break; } if(cls.equals(Integer.class)) { result = cls.cast(Integer.valueOf(toParse) * multiplier.intValue()); } else if(cls.equals(Long.class)) { result = cls.cast(Long.valueOf(toParse) * multiplier); } else if(cls.equals(Double.class)) { result = cls.cast(Double.valueOf(toParse) * multiplier.doubleValue()); } else if(cls.equals(Float.class)) { result = cls.cast(Float.valueOf(toParse) * multiplier.floatValue()); } else if(cls.equals(Byte.class)) { Integer res = Byte.valueOf(toParse) * multiplier.byteValue(); result = cls.cast(res.byteValue()); } else if(cls.equals(Short.class)) { Integer res = Short.valueOf(toParse) * multiplier.shortValue(); result = cls.cast(res.shortValue()); } } catch (Exception e) { log.log( Level.WARNING, "Error parsing value: {0} as {1}, using default: {2}", new Object[] {num,cls,def}); return def; } return result; } static T parseNum(String num, Class<T> cls, T def); static int parseSizeInt(String size, int def); static boolean parseBool(final String val); static Object decodeValueType(char typeId, String value); static String valueToString(final Object value); static char decodeTypeIdFromName(String name); static String stripNameFromTypeId(String name); static String encodeTypeIdInName(String name, Object value); static char getTypeId(Object instance); static boolean getProperty(String key, Boolean def); static void main( String[] args ); }
DataTypes { public static <T extends Number> T parseNum(String num, Class<T> cls, T def) { if (num == null) { return def; } T result = def; String toParse = num; Long multiplier = 1L; try { switch (num.charAt(num.length() - 1)) { case 'k' : case 'K' : multiplier = 1024L; toParse = num.substring(0, num.length() - 1); break; case 'm' : case 'M' : multiplier = 1024L * 1024L; toParse = num.substring(0, num.length() - 1); break; case 'g' : case 'G' : multiplier = 1024L * 1024L * 1024L; toParse = num.substring(0, num.length() - 1); break; } if(cls.equals(Integer.class)) { result = cls.cast(Integer.valueOf(toParse) * multiplier.intValue()); } else if(cls.equals(Long.class)) { result = cls.cast(Long.valueOf(toParse) * multiplier); } else if(cls.equals(Double.class)) { result = cls.cast(Double.valueOf(toParse) * multiplier.doubleValue()); } else if(cls.equals(Float.class)) { result = cls.cast(Float.valueOf(toParse) * multiplier.floatValue()); } else if(cls.equals(Byte.class)) { Integer res = Byte.valueOf(toParse) * multiplier.byteValue(); result = cls.cast(res.byteValue()); } else if(cls.equals(Short.class)) { Integer res = Short.valueOf(toParse) * multiplier.shortValue(); result = cls.cast(res.shortValue()); } } catch (Exception e) { log.log( Level.WARNING, "Error parsing value: {0} as {1}, using default: {2}", new Object[] {num,cls,def}); return def; } return result; } static T parseNum(String num, Class<T> cls, T def); static int parseSizeInt(String size, int def); static boolean parseBool(final String val); static Object decodeValueType(char typeId, String value); static String valueToString(final Object value); static char decodeTypeIdFromName(String name); static String stripNameFromTypeId(String name); static String encodeTypeIdInName(String name, Object value); static char getTypeId(Object instance); static boolean getProperty(String key, Boolean def); static void main( String[] args ); static final Map<String, Character> typesMap; }
@Test public void testRecipientEnabledFor2ResourcesPresence() throws TigaseStringprepException, NotAuthorizedException { String recipient = "recipient-1@localhost"; JID recp1 = JID.jidInstanceNS(recipient + "/res1"); JID recp2 = JID.jidInstanceNS(recipient + "/res2"); JID connId1 = JID.jidInstanceNS("c2s@localhost/recipient1-res1"); JID connId2 = JID.jidInstanceNS("c2s@localhost/recipient1-res2"); XMPPResourceConnection session1 = getSession(connId1, recp1); getSession(connId2, recp2); enableMobileV3(session1, recp1); Packet presence = Packet.packetInstance("presence", "sender-1@localhost/res1", recp1.toString(), StanzaType.available); presence.setPacketTo(connId1); ArrayDeque<Packet> results = new ArrayDeque<Packet>(); results.offer(presence); Packet[] expected = new Packet[0]; mobileV3.filter(presence, session1, null, results); Packet[] processed = results.toArray(new Packet[0]); Assert.assertArrayEquals(expected, processed); }
@Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } @Override void init(Map<String, Object> settings); @Override void process(final Packet packet, final XMPPResourceConnection session, final NonAuthUserRepository repo, final Queue<Packet> results, final Map<String, Object> settings); @Override Element[] supStreamFeatures(XMPPResourceConnection session); @Override @SuppressWarnings("unchecked") void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results); }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } @Override void init(Map<String, Object> settings); @Override void process(final Packet packet, final XMPPResourceConnection session, final NonAuthUserRepository repo, final Queue<Packet> results, final Map<String, Object> settings); @Override Element[] supStreamFeatures(XMPPResourceConnection session); @Override @SuppressWarnings("unchecked") void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results); }
@Test public void testRecipientEnabledFor2Resources2Presences() throws TigaseStringprepException, NotAuthorizedException { String recipient = "recipient-1@localhost"; JID recp1 = JID.jidInstanceNS(recipient + "/res1"); JID recp2 = JID.jidInstanceNS(recipient + "/res2"); JID connId1 = JID.jidInstanceNS("c2s@localhost/recipient1-res1"); JID connId2 = JID.jidInstanceNS("c2s@localhost/recipient1-res2"); XMPPResourceConnection session1 = getSession(connId1, recp1); getSession(connId2, recp2); enableMobileV3(session1, recp1); Packet presence = Packet.packetInstance("presence", "sender-1@localhost/res1", recp1.toString(), StanzaType.available); presence.setPacketTo(connId1); ArrayDeque<Packet> results = new ArrayDeque<Packet>(); results.offer(presence); Packet[] expected = new Packet[0]; mobileV3.filter(presence, session1, null, results); Packet[] processed = results.toArray(new Packet[0]); Assert.assertArrayEquals(expected, processed); presence = Packet.packetInstance("presence", "sender-1@localhost/res1", recp1.toString(), StanzaType.available); presence.setPacketTo(connId1); results = new ArrayDeque<Packet>(); results.offer(presence); expected = new Packet[0]; mobileV3.filter(presence, session1, null, results); processed = results.toArray(new Packet[0]); Assert.assertArrayEquals(expected, processed); results.clear(); Packet p = Packet.packetInstance("message", "sender-1@localhost/res1", recp1.toString(), StanzaType.chat); p.setPacketTo(connId1); results.offer(p); Packet p1 = Packet.packetInstance("presence", "sender-1@localhost/res1", recp1.toString(), StanzaType.error); p1.setPacketTo(connId1); results.offer(p1); expected = new Packet[] { presence, p, p1 }; mobileV3.filter(p, session1, null, results); processed = results.toArray(new Packet[0]); Assert.assertArrayEquals(expected, processed); }
@Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } @Override void init(Map<String, Object> settings); @Override void process(final Packet packet, final XMPPResourceConnection session, final NonAuthUserRepository repo, final Queue<Packet> results, final Map<String, Object> settings); @Override Element[] supStreamFeatures(XMPPResourceConnection session); @Override @SuppressWarnings("unchecked") void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results); }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } @Override void init(Map<String, Object> settings); @Override void process(final Packet packet, final XMPPResourceConnection session, final NonAuthUserRepository repo, final Queue<Packet> results, final Map<String, Object> settings); @Override Element[] supStreamFeatures(XMPPResourceConnection session); @Override @SuppressWarnings("unchecked") void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results); }
@Test public void testRecipientEnabledFor2Resources() throws TigaseStringprepException, NotAuthorizedException { String recipient = "recipient-1@localhost"; JID recp1 = JID.jidInstanceNS(recipient + "/res1"); JID recp2 = JID.jidInstanceNS(recipient + "/res2"); JID connId1 = JID.jidInstanceNS("c2s@localhost/recipient1-res1"); JID connId2 = JID.jidInstanceNS("c2s@localhost/recipient1-res2"); XMPPResourceConnection session1 = getSession(connId1, recp1); getSession(connId2, recp2); enableMobileV3(session1, recp1); Packet presence = Packet.packetInstance("presence", "sender-1@localhost/res1", recp1.toString(), StanzaType.available); presence.setPacketTo(connId1); ArrayDeque<Packet> results = new ArrayDeque<Packet>(); results.offer(presence); Packet[] expected = new Packet[0]; mobileV3.filter(presence, session1, null, results); Packet[] processed = results.toArray(new Packet[0]); Assert.assertArrayEquals(expected, processed); results.clear(); Packet p = Packet.packetInstance("message", "sender-1@localhost/res1", recp1.toString(), StanzaType.chat); p.setPacketTo(connId1); results.offer(p); Packet p1 = Packet.packetInstance("presence", "sender-1@localhost/res1", recp1.toString(), StanzaType.error); p1.setPacketTo(connId1); results.offer(p1); expected = new Packet[] { presence, p, p1 }; mobileV3.filter(p, session1, null, results); processed = results.toArray(new Packet[0]); Assert.assertArrayEquals(expected, processed); }
@Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } @Override void init(Map<String, Object> settings); @Override void process(final Packet packet, final XMPPResourceConnection session, final NonAuthUserRepository repo, final Queue<Packet> results, final Map<String, Object> settings); @Override Element[] supStreamFeatures(XMPPResourceConnection session); @Override @SuppressWarnings("unchecked") void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results); }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } @Override void init(Map<String, Object> settings); @Override void process(final Packet packet, final XMPPResourceConnection session, final NonAuthUserRepository repo, final Queue<Packet> results, final Map<String, Object> settings); @Override Element[] supStreamFeatures(XMPPResourceConnection session); @Override @SuppressWarnings("unchecked") void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results); }
@Test public void testRecipientEnabledFor2ResourcesMixed() throws TigaseStringprepException, NotAuthorizedException { String recipient = "recipient-1@localhost"; JID recp1 = JID.jidInstanceNS(recipient + "/res1"); JID recp2 = JID.jidInstanceNS(recipient + "/res2"); JID connId1 = JID.jidInstanceNS("c2s@localhost/recipient1-res1"); JID connId2 = JID.jidInstanceNS("c2s@localhost/recipient1-res2"); XMPPResourceConnection session1 = getSession(connId1, recp1); getSession(connId2, recp2); enableMobileV3(session1, recp1); Packet presence = Packet.packetInstance("presence", "sender-1@localhost/res1", recp1.toString(), StanzaType.available); presence.setPacketTo(connId1); ArrayDeque<Packet> results = new ArrayDeque<Packet>(); results.offer(presence); Packet[] expected = new Packet[0]; mobileV3.filter(presence, session1, null, results); Packet[] processed = results.toArray(new Packet[0]); Assert.assertArrayEquals(expected, processed); results.clear(); Packet m1 = Packet.packetInstance("message", recp2.toString(), recp1.toString(), StanzaType.chat); Element receivedEl = new Element("received", new String[] { "xmlns" }, new String[] { "urn:xmpp:carbons:2" }); Element forwardedEl = new Element("forwarded", new String[] {"xmlns" }, new String[] { "urn:xmpp:forward:0" }); forwardedEl.addChild(new Element("message", new String[] { "from", "to" }, new String[] { recp2.toString(), "sender-1@localhost/res1" })); receivedEl.addChild(forwardedEl); m1.getElement().addChild(receivedEl); m1.setPacketTo(connId1); results.offer(m1); expected = new Packet[0]; mobileV3.filter(m1, session1, null, results); processed = results.toArray(new Packet[0]); Assert.assertArrayEquals(expected, processed); results.clear(); presence = Packet.packetInstance("presence", "sender-1@localhost/res1", recp1.toString(), StanzaType.available); presence.setPacketTo(connId1); results.offer(presence); expected = new Packet[0]; mobileV3.filter(presence, session1, null, results); processed = results.toArray(new Packet[0]); Assert.assertArrayEquals(expected, processed); results.clear(); Packet p = Packet.packetInstance("message", "sender-1@localhost/res1", recp1.toString(), StanzaType.chat); p.setPacketTo(connId1); results.offer(p); Packet p1 = Packet.packetInstance("presence", "sender-1@localhost/res1", recp1.toString(), StanzaType.error); p1.setPacketTo(connId1); results.offer(p1); expected = new Packet[] { presence, m1, p, p1 }; mobileV3.filter(p, session1, null, results); processed = results.toArray(new Packet[0]); Assert.assertArrayEquals(expected, processed); }
@Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } @Override void init(Map<String, Object> settings); @Override void process(final Packet packet, final XMPPResourceConnection session, final NonAuthUserRepository repo, final Queue<Packet> results, final Map<String, Object> settings); @Override Element[] supStreamFeatures(XMPPResourceConnection session); @Override @SuppressWarnings("unchecked") void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results); }
MobileV3 extends AnnotatedXMPPProcessor implements XMPPProcessorIfc, XMPPPacketFilterIfc { @Override @SuppressWarnings("unchecked") public void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results) { if ((sessionFromSM == null) ||!sessionFromSM.isAuthorized() || (results == null) || (results.size() == 0)) { return; } StateHolder holder = threadState.get(); if (holder == null) { holder = new StateHolder(); threadState.set(holder); } for (Iterator<Packet> it = results.iterator(); it.hasNext(); ) { Packet res = it.next(); if ((res == null) || (res.getPacketTo() == null)) { if (log.isLoggable(Level.FINEST)) { log.finest("packet without destination"); } continue; } XMPPResourceConnection session = sessionFromSM.getParentSession() .getResourceForConnectionId(res.getPacketTo()); if (session == null) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "no session for destination {0} for packet {1}", new Object[] { res.getPacketTo().toString(), res.toString() }); } continue; } Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); if (!isQueueEnabled(session)) { if ((presenceQueue == null && packetQueue == null) || (presenceQueue.isEmpty() && packetQueue.isEmpty())) { continue; } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "mobile queues needs flushing - presences: {0}, packets: {1}", new Object[] {presenceQueue.size(), packetQueue.size() }); } holder.setState(res.getPacketTo(), QueueState.need_flush); } else { QueueState state = filter(session, res, holder.getState(res.getPacketTo()), presenceQueue, packetQueue); if (state == QueueState.queued) { it.remove(); if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "queue packet = {0}", res.toString()); if (presenceQueue.size() > maxQueueSize) { state = QueueState.need_flush; } else if (packetQueue.size() > maxQueueSize) state = QueueState.need_packet_flush; } state = holder.setState(res.getPacketTo(), state); } } for (Map.Entry<JID,QueueState> e : holder.states.entrySet()) { XMPPResourceConnection session = null; switch (e.getValue()) { case need_flush: try { session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Map<JID, Packet> presenceQueue = (Map<JID, Packet>) session.getSessionData(PRESENCE_QUEUE_KEY); synchronized (presenceQueue) { JID connId = session.getConnectionId(); for (Packet p : presenceQueue.values()) { p.setPacketTo(connId); holder.queue.offer(p); } presenceQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } case need_packet_flush: try { if (session == null) session = sessionFromSM.getParentSession().getResourceForConnectionId(e.getKey()); if (session != null) { Queue<Packet> packetQueue = (Queue<Packet>) session.getSessionData(PACKET_QUEUE_KEY); synchronized (packetQueue) { JID connId = session.getConnectionId(); Packet p = null; while ((p = packetQueue.poll()) != null) { p.setPacketTo(connId); holder.queue.offer(p); } packetQueue.clear(); } } } catch (NoConnectionIdException ex) { log.log(Level.SEVERE, "this should not happen", ex); } break; case queued: break; default: break; } } if (!holder.queue.isEmpty()) { if (log.isLoggable(Level.FINEST)) log.log(Level.FINEST, "sending queued packets = {0}", holder.queue.size()); holder.queue.addAll(results); results.clear(); results.addAll(holder.queue); } holder.reset(); } @Override void init(Map<String, Object> settings); @Override void process(final Packet packet, final XMPPResourceConnection session, final NonAuthUserRepository repo, final Queue<Packet> results, final Map<String, Object> settings); @Override Element[] supStreamFeatures(XMPPResourceConnection session); @Override @SuppressWarnings("unchecked") void filter(Packet _packet, XMPPResourceConnection sessionFromSM, NonAuthUserRepository repo, Queue<Packet> results); }
@Test public void testPreProcess() throws TigaseStringprepException, NotAuthorizedException, NoConnectionIdException { JID senderJid = JID.jidInstance("[email protected]/res-1"); JID recipientJid = JID.jidInstance("[email protected]/res-2"); XMPPResourceConnection senderSession = getSession(JID.jidInstance("[email protected]/" + UUID.randomUUID().toString()), senderJid); Element messageEl = new Element("message", new String[] { "from" }, new String[] { senderJid.toString() }); Packet p = Packet.packetInstance(messageEl); p.setPacketFrom(senderSession.getConnectionId()); Map<String,Object> settings = new HashMap<>(); Queue<Packet> results = new ArrayDeque<>(); System.out.println( p.getElement() +"" ); System.out.println( ); assertFalse(bindResource.preProcess(p, senderSession, null, results, settings)); assertEquals(0, results.size()); assertEquals(senderJid, p.getStanzaFrom()); System.out.println( p.getStanzaFrom() +"\n" ); p.getElement().setAttribute( "from", senderJid.getBareJID().toString()); System.out.println( p.getElement() +"" ); assertFalse(bindResource.preProcess(p, senderSession, null, results, settings)); assertEquals(0, results.size()); assertEquals(senderJid, p.getStanzaFrom()); System.out.println( p.getStanzaFrom() +"\n"); p.getElement().removeAttribute("from"); System.out.println( p.getElement() +""); assertFalse(bindResource.preProcess(p, senderSession, null, results, settings)); assertEquals(0, results.size()); assertEquals(senderJid, p.getStanzaFrom()); System.out.println( p.getStanzaFrom() +"\n" ); System.out.println( "=====" ); Element presenceEl = new Element("presence", new String[] { "from" }, new String[] { senderJid.toString() }); p = Packet.packetInstance(presenceEl); p.setPacketFrom(senderSession.getConnectionId()); System.out.println( p.getElement() +"" ); System.out.println( ); assertFalse(bindResource.preProcess(p, senderSession, null, results, settings)); assertEquals(0, results.size()); assertEquals(senderJid, p.getStanzaFrom()); System.out.println( p.getStanzaFrom() +"\n" ); p.getElement().setAttribute( "from", senderJid.getBareJID().toString()); System.out.println( p.getElement() +"" ); assertFalse(bindResource.preProcess(p, senderSession, null, results, settings)); assertEquals(0, results.size()); assertEquals(senderJid, p.getStanzaFrom()); System.out.println( p.getStanzaFrom() +"\n"); p.getElement().removeAttribute("from"); System.out.println( p.getElement() +""); assertFalse(bindResource.preProcess(p, senderSession, null, results, settings)); assertEquals(0, results.size()); assertEquals(senderJid, p.getStanzaFrom()); System.out.println( p.getStanzaFrom() +"\n" ); System.out.println( "=====" ); p.getElement().setAttribute( "type", "subscribe"); p.getElement().setAttribute( "from", senderJid.toString()); p = Packet.packetInstance(p.getElement()); p.setPacketFrom(senderSession.getConnectionId()); System.out.println( p.getElement() +"" ); assertFalse(bindResource.preProcess(p, senderSession, null, results, settings)); assertEquals(0, results.size()); assertEquals(JID.jidInstance( senderJid.getBareJID()), p.getStanzaFrom()); System.out.println( p.getStanzaFrom() +"\n" ); p.getElement().setAttribute( "from", senderJid.getBareJID().toString()); System.out.println( p.getElement() +"" ); assertFalse(bindResource.preProcess(p, senderSession, null, results, settings)); assertEquals(0, results.size()); assertEquals(JID.jidInstance( senderJid.getBareJID()), p.getStanzaFrom()); System.out.println( p.getStanzaFrom() +"\n"); p.getElement().removeAttribute("from"); System.out.println( p.getElement() +""); assertFalse(bindResource.preProcess(p, senderSession, null, results, settings)); assertEquals(0, results.size()); assertEquals(JID.jidInstance( senderJid.getBareJID()), p.getStanzaFrom()); System.out.println( p.getStanzaFrom() +"\n" ); }
@Override public boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings) { if ((session == null) || session.isServerSession() || !session.isAuthorized() || C2SDeliveryErrorProcessor.isDeliveryError( packet )) { return false; } try { if (session.getConnectionId().equals(packet.getPacketFrom())) { if (session.isResourceSet() || packet.isXMLNSStaticStr(Iq.IQ_BIND_PATH, "urn:ietf:params:xml:ns:xmpp-bind") || packet.isXMLNSStaticStr(COMPRESS_PATH, "http: JID from_jid = session.getJID(); if (from_jid != null) { if ( packet.getElemName() == tigase.server.Presence.ELEM_NAME && StanzaType.getSubsTypes().contains( packet.getType() ) && ( packet.getStanzaFrom() == null || !from_jid.getBareJID().equals( packet.getStanzaFrom().getBareJID() ) || packet.getStanzaFrom().getResource() != null ) ){ if ( log.isLoggable( Level.FINEST ) ){ log.log( Level.FINEST, "Setting correct from attribute: {0}", from_jid ); } packet.initVars( JID.jidInstance( from_jid.getBareJID() ), packet.getStanzaTo() ); } else if ( ( packet.getStanzaFrom() == null ) || ( ( packet.getElemName() == tigase.server.Presence.ELEM_NAME && !StanzaType.getSubsTypes().contains( packet.getType() ) || packet.getElemName() != tigase.server.Presence.ELEM_NAME ) && !from_jid.equals( packet.getStanzaFrom() ) ) ){ if ( log.isLoggable( Level.FINEST ) ){ log.log( Level.FINEST, "Setting correct from attribute: {0}", from_jid ); } packet.initVars( from_jid, packet.getStanzaTo() ); } else { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Skipping setting correct from attribute: {0}, is already correct.", packet.getStanzaFrom()); } } } else { log.log(Level.WARNING, "Session is authenticated but session.getJid() is empty: {0}", packet .toStringSecure()); } } else { results.offer(Authorization.NOT_AUTHORIZED.getResponseMessage(packet, "You must bind the resource first: " + "http: if (log.isLoggable(Level.INFO)) { log.log(Level.INFO, "Session details: connectionId={0}, sessionId={1}", new Object[] { session.getConnectionId(), session.getSessionId() }); } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Session more detais: JID={0}", session.getjid()); } return true; } } } catch (PacketErrorTypeException e) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Ignoring packet with an error to non-existen user session: {0}", packet .toStringSecure()); } } catch (Exception e) { log.log(Level.FINEST, "Packet preprocessing exception: ", e); return false; } return false; }
BindResource extends XMPPProcessor implements XMPPProcessorIfc, XMPPPreprocessorIfc { @Override public boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings) { if ((session == null) || session.isServerSession() || !session.isAuthorized() || C2SDeliveryErrorProcessor.isDeliveryError( packet )) { return false; } try { if (session.getConnectionId().equals(packet.getPacketFrom())) { if (session.isResourceSet() || packet.isXMLNSStaticStr(Iq.IQ_BIND_PATH, "urn:ietf:params:xml:ns:xmpp-bind") || packet.isXMLNSStaticStr(COMPRESS_PATH, "http: JID from_jid = session.getJID(); if (from_jid != null) { if ( packet.getElemName() == tigase.server.Presence.ELEM_NAME && StanzaType.getSubsTypes().contains( packet.getType() ) && ( packet.getStanzaFrom() == null || !from_jid.getBareJID().equals( packet.getStanzaFrom().getBareJID() ) || packet.getStanzaFrom().getResource() != null ) ){ if ( log.isLoggable( Level.FINEST ) ){ log.log( Level.FINEST, "Setting correct from attribute: {0}", from_jid ); } packet.initVars( JID.jidInstance( from_jid.getBareJID() ), packet.getStanzaTo() ); } else if ( ( packet.getStanzaFrom() == null ) || ( ( packet.getElemName() == tigase.server.Presence.ELEM_NAME && !StanzaType.getSubsTypes().contains( packet.getType() ) || packet.getElemName() != tigase.server.Presence.ELEM_NAME ) && !from_jid.equals( packet.getStanzaFrom() ) ) ){ if ( log.isLoggable( Level.FINEST ) ){ log.log( Level.FINEST, "Setting correct from attribute: {0}", from_jid ); } packet.initVars( from_jid, packet.getStanzaTo() ); } else { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Skipping setting correct from attribute: {0}, is already correct.", packet.getStanzaFrom()); } } } else { log.log(Level.WARNING, "Session is authenticated but session.getJid() is empty: {0}", packet .toStringSecure()); } } else { results.offer(Authorization.NOT_AUTHORIZED.getResponseMessage(packet, "You must bind the resource first: " + "http: if (log.isLoggable(Level.INFO)) { log.log(Level.INFO, "Session details: connectionId={0}, sessionId={1}", new Object[] { session.getConnectionId(), session.getSessionId() }); } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Session more detais: JID={0}", session.getjid()); } return true; } } } catch (PacketErrorTypeException e) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Ignoring packet with an error to non-existen user session: {0}", packet .toStringSecure()); } } catch (Exception e) { log.log(Level.FINEST, "Packet preprocessing exception: ", e); return false; } return false; } }
BindResource extends XMPPProcessor implements XMPPProcessorIfc, XMPPPreprocessorIfc { @Override public boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings) { if ((session == null) || session.isServerSession() || !session.isAuthorized() || C2SDeliveryErrorProcessor.isDeliveryError( packet )) { return false; } try { if (session.getConnectionId().equals(packet.getPacketFrom())) { if (session.isResourceSet() || packet.isXMLNSStaticStr(Iq.IQ_BIND_PATH, "urn:ietf:params:xml:ns:xmpp-bind") || packet.isXMLNSStaticStr(COMPRESS_PATH, "http: JID from_jid = session.getJID(); if (from_jid != null) { if ( packet.getElemName() == tigase.server.Presence.ELEM_NAME && StanzaType.getSubsTypes().contains( packet.getType() ) && ( packet.getStanzaFrom() == null || !from_jid.getBareJID().equals( packet.getStanzaFrom().getBareJID() ) || packet.getStanzaFrom().getResource() != null ) ){ if ( log.isLoggable( Level.FINEST ) ){ log.log( Level.FINEST, "Setting correct from attribute: {0}", from_jid ); } packet.initVars( JID.jidInstance( from_jid.getBareJID() ), packet.getStanzaTo() ); } else if ( ( packet.getStanzaFrom() == null ) || ( ( packet.getElemName() == tigase.server.Presence.ELEM_NAME && !StanzaType.getSubsTypes().contains( packet.getType() ) || packet.getElemName() != tigase.server.Presence.ELEM_NAME ) && !from_jid.equals( packet.getStanzaFrom() ) ) ){ if ( log.isLoggable( Level.FINEST ) ){ log.log( Level.FINEST, "Setting correct from attribute: {0}", from_jid ); } packet.initVars( from_jid, packet.getStanzaTo() ); } else { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Skipping setting correct from attribute: {0}, is already correct.", packet.getStanzaFrom()); } } } else { log.log(Level.WARNING, "Session is authenticated but session.getJid() is empty: {0}", packet .toStringSecure()); } } else { results.offer(Authorization.NOT_AUTHORIZED.getResponseMessage(packet, "You must bind the resource first: " + "http: if (log.isLoggable(Level.INFO)) { log.log(Level.INFO, "Session details: connectionId={0}, sessionId={1}", new Object[] { session.getConnectionId(), session.getSessionId() }); } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Session more detais: JID={0}", session.getjid()); } return true; } } } catch (PacketErrorTypeException e) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Ignoring packet with an error to non-existen user session: {0}", packet .toStringSecure()); } } catch (Exception e) { log.log(Level.FINEST, "Packet preprocessing exception: ", e); return false; } return false; } }
BindResource extends XMPPProcessor implements XMPPProcessorIfc, XMPPPreprocessorIfc { @Override public boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings) { if ((session == null) || session.isServerSession() || !session.isAuthorized() || C2SDeliveryErrorProcessor.isDeliveryError( packet )) { return false; } try { if (session.getConnectionId().equals(packet.getPacketFrom())) { if (session.isResourceSet() || packet.isXMLNSStaticStr(Iq.IQ_BIND_PATH, "urn:ietf:params:xml:ns:xmpp-bind") || packet.isXMLNSStaticStr(COMPRESS_PATH, "http: JID from_jid = session.getJID(); if (from_jid != null) { if ( packet.getElemName() == tigase.server.Presence.ELEM_NAME && StanzaType.getSubsTypes().contains( packet.getType() ) && ( packet.getStanzaFrom() == null || !from_jid.getBareJID().equals( packet.getStanzaFrom().getBareJID() ) || packet.getStanzaFrom().getResource() != null ) ){ if ( log.isLoggable( Level.FINEST ) ){ log.log( Level.FINEST, "Setting correct from attribute: {0}", from_jid ); } packet.initVars( JID.jidInstance( from_jid.getBareJID() ), packet.getStanzaTo() ); } else if ( ( packet.getStanzaFrom() == null ) || ( ( packet.getElemName() == tigase.server.Presence.ELEM_NAME && !StanzaType.getSubsTypes().contains( packet.getType() ) || packet.getElemName() != tigase.server.Presence.ELEM_NAME ) && !from_jid.equals( packet.getStanzaFrom() ) ) ){ if ( log.isLoggable( Level.FINEST ) ){ log.log( Level.FINEST, "Setting correct from attribute: {0}", from_jid ); } packet.initVars( from_jid, packet.getStanzaTo() ); } else { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Skipping setting correct from attribute: {0}, is already correct.", packet.getStanzaFrom()); } } } else { log.log(Level.WARNING, "Session is authenticated but session.getJid() is empty: {0}", packet .toStringSecure()); } } else { results.offer(Authorization.NOT_AUTHORIZED.getResponseMessage(packet, "You must bind the resource first: " + "http: if (log.isLoggable(Level.INFO)) { log.log(Level.INFO, "Session details: connectionId={0}, sessionId={1}", new Object[] { session.getConnectionId(), session.getSessionId() }); } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Session more detais: JID={0}", session.getjid()); } return true; } } } catch (PacketErrorTypeException e) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Ignoring packet with an error to non-existen user session: {0}", packet .toStringSecure()); } } catch (Exception e) { log.log(Level.FINEST, "Packet preprocessing exception: ", e); return false; } return false; } @Override String id(); @Override void init(Map<String, Object> settings); @Override boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings); @Override void process(final Packet packet, final XMPPResourceConnection session, final NonAuthUserRepository repo, final Queue<Packet> results, final Map<String, Object> settings); @Override Element[] supDiscoFeatures(final XMPPResourceConnection session); @Override String[][] supElementNamePaths(); @Override String[] supNamespaces(); @Override Element[] supStreamFeatures(final XMPPResourceConnection session); }
BindResource extends XMPPProcessor implements XMPPProcessorIfc, XMPPPreprocessorIfc { @Override public boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings) { if ((session == null) || session.isServerSession() || !session.isAuthorized() || C2SDeliveryErrorProcessor.isDeliveryError( packet )) { return false; } try { if (session.getConnectionId().equals(packet.getPacketFrom())) { if (session.isResourceSet() || packet.isXMLNSStaticStr(Iq.IQ_BIND_PATH, "urn:ietf:params:xml:ns:xmpp-bind") || packet.isXMLNSStaticStr(COMPRESS_PATH, "http: JID from_jid = session.getJID(); if (from_jid != null) { if ( packet.getElemName() == tigase.server.Presence.ELEM_NAME && StanzaType.getSubsTypes().contains( packet.getType() ) && ( packet.getStanzaFrom() == null || !from_jid.getBareJID().equals( packet.getStanzaFrom().getBareJID() ) || packet.getStanzaFrom().getResource() != null ) ){ if ( log.isLoggable( Level.FINEST ) ){ log.log( Level.FINEST, "Setting correct from attribute: {0}", from_jid ); } packet.initVars( JID.jidInstance( from_jid.getBareJID() ), packet.getStanzaTo() ); } else if ( ( packet.getStanzaFrom() == null ) || ( ( packet.getElemName() == tigase.server.Presence.ELEM_NAME && !StanzaType.getSubsTypes().contains( packet.getType() ) || packet.getElemName() != tigase.server.Presence.ELEM_NAME ) && !from_jid.equals( packet.getStanzaFrom() ) ) ){ if ( log.isLoggable( Level.FINEST ) ){ log.log( Level.FINEST, "Setting correct from attribute: {0}", from_jid ); } packet.initVars( from_jid, packet.getStanzaTo() ); } else { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Skipping setting correct from attribute: {0}, is already correct.", packet.getStanzaFrom()); } } } else { log.log(Level.WARNING, "Session is authenticated but session.getJid() is empty: {0}", packet .toStringSecure()); } } else { results.offer(Authorization.NOT_AUTHORIZED.getResponseMessage(packet, "You must bind the resource first: " + "http: if (log.isLoggable(Level.INFO)) { log.log(Level.INFO, "Session details: connectionId={0}, sessionId={1}", new Object[] { session.getConnectionId(), session.getSessionId() }); } if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Session more detais: JID={0}", session.getjid()); } return true; } } } catch (PacketErrorTypeException e) { if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "Ignoring packet with an error to non-existen user session: {0}", packet .toStringSecure()); } } catch (Exception e) { log.log(Level.FINEST, "Packet preprocessing exception: ", e); return false; } return false; } @Override String id(); @Override void init(Map<String, Object> settings); @Override boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings); @Override void process(final Packet packet, final XMPPResourceConnection session, final NonAuthUserRepository repo, final Queue<Packet> results, final Map<String, Object> settings); @Override Element[] supDiscoFeatures(final XMPPResourceConnection session); @Override String[][] supElementNamePaths(); @Override String[] supNamespaces(); @Override Element[] supStreamFeatures(final XMPPResourceConnection session); static final String DEF_RESOURCE_PREFIX_PROP_KEY; }
@Test public void testPreprocessingNotSupportedPackets() throws Exception { Element packetEl = null; Packet packet = null; JID from = JID.jidInstance("[email protected]/res"); JID to = JID.jidInstance("[email protected]"); packetEl = new Element("iq", new String[] { "id", "from", "to" }, new String[] { UUID.randomUUID().toString(), from.toString(), to.toString() }); packet = Packet.packetInstance(packetEl); assertFalse(C2SDeliveryErrorProcessor.preProcess(packet, null, null, null, null, messageProcessor)); packetEl = new Element("message", new String[] { "id", "from", "to" }, new String[] { UUID.randomUUID().toString(), from.toString(), to.toString() }); packet = Packet.packetInstance(packetEl); assertFalse(C2SDeliveryErrorProcessor.preProcess(packet, null, null, null, null, messageProcessor)); packetEl = new Element("message", new String[] { "id", "from", "to" }, new String[] { UUID.randomUUID().toString(), from.toString(), to.toString() }); packetEl.addChild(new Element("delivery-error", new String[] { "xmlns" }, new String[] { "http: packet = Packet.packetInstance(packetEl); assertFalse(C2SDeliveryErrorProcessor.preProcess(packet, null, null, null, null, messageProcessor)); }
public static boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings, Message messageProcessor) { if (packet.getElemName() != tigase.server.Message.ELEM_NAME) return false; Element deliveryError = getDeliveryError(packet); if (deliveryError == null) return false; try { if (packet.getStanzaTo() != null && packet.getStanzaTo().getResource() == null && session != null) { if (packet.getElemName() != Message.ELEM_NAME) return true; List<XMPPResourceConnection> sessionsForMessageDelivery = messageProcessor.getConnectionsForMessageDelivery(session); if (sessionsForMessageDelivery.isEmpty()) return false; String delay = deliveryError.getAttributeStaticStr("stamp"); if (delay == null) return true; long time = Long.parseLong(delay); for (XMPPResourceConnection conn : sessionsForMessageDelivery) { if (conn.getCreationTime() <= time) continue; Packet result = packet.copyElementOnly(); result.setPacketFrom(packet.getPacketTo()); result.setPacketTo(conn.getConnectionId()); results.offer(result); } return true; } return false; } catch (NotAuthorizedException ex) { if (log.isLoggable(Level.FINEST)) { log.finest("NotAuthorizedException while processing undelivered message from " + "C2S, packet = " + packet); } } catch (NoConnectionIdException ex) { if (log.isLoggable(Level.FINEST)) { log.finest("NotAuthorizedException while processing undelivered message from " + "C2S, packet = " + packet); } } return false; }
C2SDeliveryErrorProcessor { public static boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings, Message messageProcessor) { if (packet.getElemName() != tigase.server.Message.ELEM_NAME) return false; Element deliveryError = getDeliveryError(packet); if (deliveryError == null) return false; try { if (packet.getStanzaTo() != null && packet.getStanzaTo().getResource() == null && session != null) { if (packet.getElemName() != Message.ELEM_NAME) return true; List<XMPPResourceConnection> sessionsForMessageDelivery = messageProcessor.getConnectionsForMessageDelivery(session); if (sessionsForMessageDelivery.isEmpty()) return false; String delay = deliveryError.getAttributeStaticStr("stamp"); if (delay == null) return true; long time = Long.parseLong(delay); for (XMPPResourceConnection conn : sessionsForMessageDelivery) { if (conn.getCreationTime() <= time) continue; Packet result = packet.copyElementOnly(); result.setPacketFrom(packet.getPacketTo()); result.setPacketTo(conn.getConnectionId()); results.offer(result); } return true; } return false; } catch (NotAuthorizedException ex) { if (log.isLoggable(Level.FINEST)) { log.finest("NotAuthorizedException while processing undelivered message from " + "C2S, packet = " + packet); } } catch (NoConnectionIdException ex) { if (log.isLoggable(Level.FINEST)) { log.finest("NotAuthorizedException while processing undelivered message from " + "C2S, packet = " + packet); } } return false; } }
C2SDeliveryErrorProcessor { public static boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings, Message messageProcessor) { if (packet.getElemName() != tigase.server.Message.ELEM_NAME) return false; Element deliveryError = getDeliveryError(packet); if (deliveryError == null) return false; try { if (packet.getStanzaTo() != null && packet.getStanzaTo().getResource() == null && session != null) { if (packet.getElemName() != Message.ELEM_NAME) return true; List<XMPPResourceConnection> sessionsForMessageDelivery = messageProcessor.getConnectionsForMessageDelivery(session); if (sessionsForMessageDelivery.isEmpty()) return false; String delay = deliveryError.getAttributeStaticStr("stamp"); if (delay == null) return true; long time = Long.parseLong(delay); for (XMPPResourceConnection conn : sessionsForMessageDelivery) { if (conn.getCreationTime() <= time) continue; Packet result = packet.copyElementOnly(); result.setPacketFrom(packet.getPacketTo()); result.setPacketTo(conn.getConnectionId()); results.offer(result); } return true; } return false; } catch (NotAuthorizedException ex) { if (log.isLoggable(Level.FINEST)) { log.finest("NotAuthorizedException while processing undelivered message from " + "C2S, packet = " + packet); } } catch (NoConnectionIdException ex) { if (log.isLoggable(Level.FINEST)) { log.finest("NotAuthorizedException while processing undelivered message from " + "C2S, packet = " + packet); } } return false; } }
C2SDeliveryErrorProcessor { public static boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings, Message messageProcessor) { if (packet.getElemName() != tigase.server.Message.ELEM_NAME) return false; Element deliveryError = getDeliveryError(packet); if (deliveryError == null) return false; try { if (packet.getStanzaTo() != null && packet.getStanzaTo().getResource() == null && session != null) { if (packet.getElemName() != Message.ELEM_NAME) return true; List<XMPPResourceConnection> sessionsForMessageDelivery = messageProcessor.getConnectionsForMessageDelivery(session); if (sessionsForMessageDelivery.isEmpty()) return false; String delay = deliveryError.getAttributeStaticStr("stamp"); if (delay == null) return true; long time = Long.parseLong(delay); for (XMPPResourceConnection conn : sessionsForMessageDelivery) { if (conn.getCreationTime() <= time) continue; Packet result = packet.copyElementOnly(); result.setPacketFrom(packet.getPacketTo()); result.setPacketTo(conn.getConnectionId()); results.offer(result); } return true; } return false; } catch (NotAuthorizedException ex) { if (log.isLoggable(Level.FINEST)) { log.finest("NotAuthorizedException while processing undelivered message from " + "C2S, packet = " + packet); } } catch (NoConnectionIdException ex) { if (log.isLoggable(Level.FINEST)) { log.finest("NotAuthorizedException while processing undelivered message from " + "C2S, packet = " + packet); } } return false; } static void filter(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, JID toIgnore); static void filterErrorElement(Element messageElem); static boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings, Message messageProcessor); static boolean isDeliveryError(Packet packet); static Element getDeliveryError(Packet packet); static Packet makeDeliveryError(Packet packet, Long stamp); }
C2SDeliveryErrorProcessor { public static boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings, Message messageProcessor) { if (packet.getElemName() != tigase.server.Message.ELEM_NAME) return false; Element deliveryError = getDeliveryError(packet); if (deliveryError == null) return false; try { if (packet.getStanzaTo() != null && packet.getStanzaTo().getResource() == null && session != null) { if (packet.getElemName() != Message.ELEM_NAME) return true; List<XMPPResourceConnection> sessionsForMessageDelivery = messageProcessor.getConnectionsForMessageDelivery(session); if (sessionsForMessageDelivery.isEmpty()) return false; String delay = deliveryError.getAttributeStaticStr("stamp"); if (delay == null) return true; long time = Long.parseLong(delay); for (XMPPResourceConnection conn : sessionsForMessageDelivery) { if (conn.getCreationTime() <= time) continue; Packet result = packet.copyElementOnly(); result.setPacketFrom(packet.getPacketTo()); result.setPacketTo(conn.getConnectionId()); results.offer(result); } return true; } return false; } catch (NotAuthorizedException ex) { if (log.isLoggable(Level.FINEST)) { log.finest("NotAuthorizedException while processing undelivered message from " + "C2S, packet = " + packet); } } catch (NoConnectionIdException ex) { if (log.isLoggable(Level.FINEST)) { log.finest("NotAuthorizedException while processing undelivered message from " + "C2S, packet = " + packet); } } return false; } static void filter(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, JID toIgnore); static void filterErrorElement(Element messageElem); static boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings, Message messageProcessor); static boolean isDeliveryError(Packet packet); static Element getDeliveryError(Packet packet); static Packet makeDeliveryError(Packet packet, Long stamp); static final String ELEM_NAME; static final String XMLNS; }