public static SubstitutionStrategyRegistry newInstance() { return new SubstitutionStrategyRegistry(); }
private static List<SubstitutionStrategy> createStrategies() { final List<SubstitutionStrategy> strategies = new LinkedList<>(); // replacement for policy-subject-id strategies.add(new ModifySubjectSubstitutionStrategy()); strategies.add(new ModifySubjectsSubstitutionStrategy()); strategies.add(new ModifyPolicyEntrySubstitutionStrategy()); strategies.add(new ModifyPolicyEntriesSubstitutionStrategy()); strategies.add(new ModifyPolicySubstitutionStrategy()); strategies.add(new CreatePolicySubstitutionStrategy()); // replacement for acl-subject-id strategies.add(new ModifyAclEntrySubstitutionStrategy()); strategies.add(new ModifyAclSubstitutionStrategy()); // replacement for both policy-subject-id and acl-subject-id strategies.add(new ModifyThingSubstitutionStrategy()); strategies.add(new CreateThingSubstitutionStrategy()); return strategies; } }
/** * Get a matching strategy for handling the given {@code withDittoHeaders}. * * @param withDittoHeaders the instance of {@link WithDittoHeaders} to be handled. * @return an {@link Optional} containing the first strategy which matches; an empty {@link Optional} in case no * strategy matches. */ public final Optional<SubstitutionStrategy> getMatchingStrategy(final WithDittoHeaders withDittoHeaders) { for (final SubstitutionStrategy strategy : strategies) { if (strategy.matches(withDittoHeaders)) { return Optional.of(strategy); } } return Optional.empty(); }
@Override public CompletionStage<WithDittoHeaders> apply(final WithDittoHeaders withDittoHeaders) { requireNonNull(withDittoHeaders); final Optional<SubstitutionStrategy> firstMatchingStrategyOpt = substitutionStrategyRegistry.getMatchingStrategy(withDittoHeaders); if (firstMatchingStrategyOpt.isPresent()) { final SubstitutionStrategy firstMatchingStrategy = firstMatchingStrategyOpt.get(); return CompletableFuture.supplyAsync(() -> { @SuppressWarnings("unchecked") final WithDittoHeaders maybeSubstituted = firstMatchingStrategy.apply(withDittoHeaders, substitutionAlgorithm); return maybeSubstituted; }); } else { return CompletableFuture.completedFuture(withDittoHeaders); } }
static Iterable<PolicyEntry> substitutePolicyEntries(final Iterable<PolicyEntry> policyEntries, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm, final DittoHeaders dittoHeaders) { final Iterator<PolicyEntry> existingEntriesIterator = policyEntries.iterator(); Iterable<PolicyEntry> currentEntries = policyEntries; for (int i = 0; existingEntriesIterator.hasNext(); i++) { final PolicyEntry existingEntry = existingEntriesIterator.next(); final PolicyEntry substitutedEntry = substitutePolicyEntry(existingEntry, substitutionAlgorithm, dittoHeaders); if (!existingEntry.equals(substitutedEntry)) { currentEntries = replace(currentEntries, substitutedEntry, i); } } return currentEntries; }
private SubstitutionStrategyRegistry() { strategies = Collections.unmodifiableList(new ArrayList<>(createStrategies())); }
static AccessControlList substituteAcl(final AccessControlList acl, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm, final DittoHeaders dittoHeaders) { AccessControlList newAcl = acl; for (final AclEntry aclEntry : acl) { final AclEntry substitutedEntry = substituteAclEntry(aclEntry, substitutionAlgorithm, dittoHeaders); if (!aclEntry.equals(substitutedEntry)) { newAcl = newAcl.removeEntry(aclEntry).setEntry(substitutedEntry); } } return newAcl; }
private static PlaceholderSubstitution createInstance( final Map<String, Function<DittoHeaders, String>> replacementDefinitions) { final HeaderBasedPlaceholderSubstitutionAlgorithm algorithm = HeaderBasedPlaceholderSubstitutionAlgorithm.newInstance(replacementDefinitions); final SubstitutionStrategyRegistry substitutionStrategyRegistry = SubstitutionStrategyRegistry.newInstance(); return new PlaceholderSubstitution(algorithm, substitutionStrategyRegistry); } }
private static JsonObject substituteInitialPolicy(final JsonObject initialPolicy, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm, final DittoHeaders dittoHeaders) { Policy existingPolicy; try { existingPolicy = PoliciesModelFactory.newPolicy(initialPolicy); } catch (final RuntimeException e) { // Just log to debug, error is handled somewhere else LOGGER.debug("Failed to parse initial policy.", e); return initialPolicy; } final Policy substitutedPolicy = substitutePolicy(existingPolicy, substitutionAlgorithm, dittoHeaders); return substitutedPolicy.toJson(); }
private static JsonObject substituteInitialPolicy(final JsonObject initialPolicy, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm, final DittoHeaders dittoHeaders) { Policy existingPolicy; try { existingPolicy = PoliciesModelFactory.newPolicy(initialPolicy); } catch (final RuntimeException e) { // Just log to debug, error is handled somewhere else LOGGER.debug("Failed to parse initial policy.", e); return initialPolicy; } final Policy substitutedPolicy = substitutePolicy(existingPolicy, substitutionAlgorithm, dittoHeaders); return substitutedPolicy.toJson(); } }
@Override public WithDittoHeaders apply(final CreatePolicy createPolicy, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm) { requireNonNull(createPolicy); requireNonNull(substitutionAlgorithm); final DittoHeaders dittoHeaders = createPolicy.getDittoHeaders(); final Policy existingPolicy = createPolicy.getPolicy(); final Policy substitutedPolicy = substitutePolicy(existingPolicy, substitutionAlgorithm, dittoHeaders); if (existingPolicy.equals(substitutedPolicy)) { return createPolicy; } else { return CreatePolicy.of(substitutedPolicy, dittoHeaders); } }
@Override public WithDittoHeaders apply(final ModifyAcl modifyAcl, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm) { requireNonNull(modifyAcl); requireNonNull(substitutionAlgorithm); final DittoHeaders dittoHeaders = modifyAcl.getDittoHeaders(); final AccessControlList existingAcl = modifyAcl.getAccessControlList(); final AccessControlList substitutedAcl = substituteAcl(existingAcl, substitutionAlgorithm, dittoHeaders); if (existingAcl.equals(substitutedAcl)) { return modifyAcl; } else { return ModifyAcl.of(modifyAcl.getThingId(), substitutedAcl, dittoHeaders); } }
@Override public WithDittoHeaders apply(final ModifyAclEntry modifyAclEntry, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm) { requireNonNull(modifyAclEntry); requireNonNull(substitutionAlgorithm); final DittoHeaders dittoHeaders = modifyAclEntry.getDittoHeaders(); final AclEntry existingAclEntry = modifyAclEntry.getAclEntry(); final AclEntry substitutedAclEntry = substituteAclEntry(existingAclEntry, substitutionAlgorithm, dittoHeaders); if (existingAclEntry.equals(substitutedAclEntry)) { return modifyAclEntry; } else { return ModifyAclEntry.of(modifyAclEntry.getThingId(), substitutedAclEntry, dittoHeaders); } }
@Override public WithDittoHeaders apply(final ModifyPolicy modifyPolicy, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm) { requireNonNull(modifyPolicy); requireNonNull(substitutionAlgorithm); final DittoHeaders dittoHeaders = modifyPolicy.getDittoHeaders(); final Policy existingPolicy = modifyPolicy.getPolicy(); final Policy substitutedPolicy = substitutePolicy(existingPolicy, substitutionAlgorithm, dittoHeaders); if (existingPolicy.equals(substitutedPolicy)) { return modifyPolicy; } else { return ModifyPolicy.of(modifyPolicy.getId(), substitutedPolicy, dittoHeaders); } }
static PolicyEntry substitutePolicyEntry(final PolicyEntry existingPolicyEntry, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm, final DittoHeaders dittoHeaders) { final Subjects existingSubjects = existingPolicyEntry.getSubjects(); final Subjects substitutedSubjects = substituteSubjects(existingSubjects, substitutionAlgorithm, dittoHeaders); final PolicyEntry resultEntry; if (existingSubjects.equals(substitutedSubjects)) { resultEntry = existingPolicyEntry; } else { resultEntry = PolicyEntry.newInstance(existingPolicyEntry.getLabel(), substitutedSubjects, existingPolicyEntry.getResources()); } return resultEntry; }
@Override public WithDittoHeaders apply(final ModifyPolicyEntries modifyPolicyEntries, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm) { requireNonNull(modifyPolicyEntries); requireNonNull(substitutionAlgorithm); final DittoHeaders dittoHeaders = modifyPolicyEntries.getDittoHeaders(); final Iterable<PolicyEntry> existingPolicyEntries = modifyPolicyEntries.getPolicyEntries(); final Iterable<PolicyEntry> substitutedEntries = substitutePolicyEntries(existingPolicyEntries, substitutionAlgorithm, dittoHeaders); if (existingPolicyEntries.equals(substitutedEntries)) { return modifyPolicyEntries; } else { return ModifyPolicyEntries.of(modifyPolicyEntries.getId(), substitutedEntries, dittoHeaders); } }
@Override public WithDittoHeaders apply(final ModifyPolicyEntry modifyPolicyEntry, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm) { requireNonNull(modifyPolicyEntry); requireNonNull(substitutionAlgorithm); final DittoHeaders dittoHeaders = modifyPolicyEntry.getDittoHeaders(); final PolicyEntry existingPolicyEntry = modifyPolicyEntry.getPolicyEntry(); final PolicyEntry resultEntry = substitutePolicyEntry(existingPolicyEntry, substitutionAlgorithm, dittoHeaders); if (existingPolicyEntry.equals(resultEntry)) { return modifyPolicyEntry; } else { return ModifyPolicyEntry.of(modifyPolicyEntry.getId(), resultEntry, modifyPolicyEntry.getDittoHeaders()); } }
@Override public WithDittoHeaders apply(final ModifySubjects modifySubjects, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm) { requireNonNull(modifySubjects); requireNonNull(substitutionAlgorithm); final DittoHeaders dittoHeaders = modifySubjects.getDittoHeaders(); final Subjects existingSubjects = modifySubjects.getSubjects(); Subjects substitutedSubjects = substituteSubjects(existingSubjects, substitutionAlgorithm, dittoHeaders); if (existingSubjects.equals(substitutedSubjects)) { return modifySubjects; } else { return ModifySubjects.of(modifySubjects.getId(), modifySubjects.getLabel(), substitutedSubjects, dittoHeaders); } }
static Policy substitutePolicy(final Policy policy, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm, final DittoHeaders dittoHeaders) { final Iterable<PolicyEntry> existingEntries = policy.getEntriesSet(); final Iterable<PolicyEntry> substitutedEntries = substitutePolicyEntries(existingEntries, substitutionAlgorithm, dittoHeaders); final Policy resultPolicy; if (existingEntries.equals(substitutedEntries)) { resultPolicy = policy; } else { resultPolicy = PoliciesModelFactory.newPolicyBuilder(policy).setAll(substitutedEntries).build(); } return resultPolicy; }
static Thing substituteThing(final Thing existingThing, final HeaderBasedPlaceholderSubstitutionAlgorithm substitutionAlgorithm, final DittoHeaders dittoHeaders) { final AccessControlList existingAcl = existingThing.getAccessControlList().orElse(null); if (existingAcl == null) { return existingThing; } final AccessControlList substitutedAcl = substituteAcl(existingAcl, substitutionAlgorithm, dittoHeaders); if (existingAcl.equals(substitutedAcl)) { return existingThing; } else { return ThingsModelFactory.newThingBuilder(existingThing) .removeAllPermissions() .setPermissions(substitutedAcl).build(); } }