@NotNull @Override public PrivilegeBits supportedPrivileges(@Nullable Tree tree, @Nullable PrivilegeBits privilegeBits) { return (privilegeBits != null) ? privilegeBits : new PrivilegeBitsProvider(immutableRoot).getBits(PrivilegeConstants.JCR_ALL); }
PrivilegeDefinitionWriter(@NotNull Root root) { this.root = root; this.bitsMgr = new PrivilegeBitsProvider(root); Tree privilegesTree = bitsMgr.getPrivilegesTree(); if (privilegesTree.exists() && privilegesTree.hasProperty(REP_NEXT)) { next = PrivilegeBits.getInstance(privilegesTree); } else { next = PrivilegeBits.NEXT_AFTER_BUILT_INS; } }
@NotNull @Override public Set<String> getPrivileges(@Nullable Tree tree) { return bitsProvider.getPrivilegeNames(internalGetPrivileges(tree)); }
return aggregation.get(privName); } else if (AGGREGATE_PRIVILEGES.keySet().contains(privName)) { Set<String> aggregates = resolveBuiltInAggregation(privName); aggregation.put(privName, aggregates); return aggregates; } else { return extractAggregatedPrivileges(Collections.singleton(privName)); return pNames; } else { return extractAggregatedPrivileges(pNames);
@Test public void testUnknownAggregation() throws RepositoryException { PrivilegeBits bits = bitsProvider.getBits(REP_WRITE, JCR_LIFECYCLE_MANAGEMENT); Set<String> names = bitsProvider.getPrivilegeNames(bits); assertEquals(2, names.size()); }
@NotNull @Override public PrivilegeBits supportedPrivileges(@Nullable Tree tree, @Nullable PrivilegeBits privilegeBits) { return (privilegeBits == null) ? pbp.getBits(PrivilegeConstants.JCR_ALL) : privilegeBits; }
PrivilegeValidator(@NotNull Root before, @NotNull Root after, @NotNull TreeProvider treeProvider) { rootBefore = before; rootAfter = after; bitsProvider = new PrivilegeBitsProvider(rootBefore); this.treeProvider = treeProvider; }
@NotNull @Override public Iterable<String> apply(@Nullable String privName) { if (privName == null) { return Collections.emptySet(); } else { if (NON_AGGREGATE_PRIVILEGES.contains(privName)) { return Collections.singleton(privName); } else if (aggregation.containsKey(privName)) { return aggregation.get(privName); } else if (AGGREGATE_PRIVILEGES.containsKey(privName)) { return resolveBuiltInAggregation(privName); } else { ImmutableSet.Builder<String> builder = ImmutableSet.builder(); fillAggregation(getPrivilegesTree().getChild(privName), builder); Set<String> aggregates = builder.build(); if (!JCR_ALL.equals(privName) && !aggregates.isEmpty()) { aggregation.put(privName, aggregates); } return aggregates; } } }
@Test public void testGetAggregatedPrivilegeNamesMultipleBuiltIn() { Iterable<String> expected = ImmutableSet.copyOf(Iterables.concat( bitsProvider.getAggregatedPrivilegeNames(JCR_READ), bitsProvider.getAggregatedPrivilegeNames(JCR_WRITE))); // create new to avoid reading from cache PrivilegeBitsProvider bp = new PrivilegeBitsProvider(root); Iterable<String> result = bp.getAggregatedPrivilegeNames(JCR_READ, JCR_WRITE); assertEquals(expected, ImmutableSet.copyOf(result)); }
@Test public void testGetAggregatedPrivilegeNamesMultipleBuiltIn2() { Iterable<String> expected = ImmutableSet.copyOf(Iterables.concat( bitsProvider.getAggregatedPrivilegeNames(JCR_READ), bitsProvider.getAggregatedPrivilegeNames(JCR_WRITE))); // read with same provider (i.e. reading from cache) Iterable<String> result = bitsProvider.getAggregatedPrivilegeNames(JCR_READ, JCR_WRITE); assertEquals(expected, ImmutableSet.copyOf(result)); }
private Set<String> resolveBuiltInAggregation(@NotNull String privilegeName) { ImmutableSet.Builder<String> builder = ImmutableSet.builder(); for (String name : AGGREGATE_PRIVILEGES.get(privilegeName)) { if (!AGGREGATE_PRIVILEGES.containsKey(name)) { builder.add(name); } else { builder.addAll(resolveBuiltInAggregation(name)); } } Set<String> set = builder.build(); aggregation.put(privilegeName, set); return set; }
@Test public void testRedundantAggregation() throws RepositoryException { PrivilegeBits writeBits = bitsProvider.getBits(REP_WRITE); Set<String> names = bitsProvider.getPrivilegeNames(writeBits); assertEquals(1, names.size()); assertEquals(REP_WRITE, names.iterator().next()); writeBits = bitsProvider.getBits(REP_WRITE, JCR_WRITE); names = bitsProvider.getPrivilegeNames(writeBits); assertEquals(1, names.size()); assertEquals(REP_WRITE, names.iterator().next()); }
@NotNull private ACE createACE(@Nullable String oakPath, @NotNull Tree aceTree, @NotNull RestrictionProvider restrictionProvider) throws RepositoryException { boolean isAllow = NT_REP_GRANT_ACE.equals(TreeUtil.getPrimaryTypeName(aceTree)); Set<Restriction> restrictions = restrictionProvider.readRestrictions(oakPath, aceTree); Iterable<String> privNames = checkNotNull(TreeUtil.getStrings(aceTree, REP_PRIVILEGES)); return new Entry(getPrincipal(aceTree), bitsProvider.getBits(privNames), isAllow, restrictions, getNamePathMapper()); }
PrivilegeValidator(@NotNull Root before, @NotNull Root after, @NotNull TreeProvider treeProvider) { rootBefore = before; rootAfter = after; bitsProvider = new PrivilegeBitsProvider(rootBefore); this.treeProvider = treeProvider; }
@Nonnull @Override public Iterable<String> apply(@Nullable String privName) { if (privName == null) { return Collections.emptySet(); } else { if (NON_AGGREGATE_PRIVILEGES.contains(privName)) { return Collections.singleton(privName); } else if (aggregation.containsKey(privName)) { return aggregation.get(privName); } else if (AGGREGATE_PRIVILEGES.containsKey(privName)) { return resolveBuiltInAggregation(privName); } else { ImmutableSet.Builder<String> builder = ImmutableSet.builder(); fillAggregation(getPrivilegesTree().getChild(privName), builder); Set<String> aggregates = builder.build(); if (!JCR_ALL.equals(privName) && !aggregates.isEmpty()) { aggregation.put(privName, aggregates); } return aggregates; } } }
@Test public void testGetAggregatedPrivilegeNamesBuiltInTwice() { Iterable<String> agg = bitsProvider.getAggregatedPrivilegeNames(JCR_READ); assertSame(agg, bitsProvider.getAggregatedPrivilegeNames(JCR_READ)); }
return aggregation.get(privName); } else if (AGGREGATE_PRIVILEGES.keySet().contains(privName)) { Set<String> aggregates = resolveBuiltInAggregation(privName); aggregation.put(privName, aggregates); return aggregates; } else { return extractAggregatedPrivileges(Collections.singleton(privName)); return pNames; } else { return extractAggregatedPrivileges(pNames);
private Set<String> resolveBuiltInAggregation(@Nonnull String privilegeName) { ImmutableSet.Builder<String> builder = ImmutableSet.builder(); for (String name : AGGREGATE_PRIVILEGES.get(privilegeName)) { if (!AGGREGATE_PRIVILEGES.containsKey(name)) { builder.add(name); } else { builder.addAll(resolveBuiltInAggregation(name)); } } Set<String> set = builder.build(); aggregation.put(privilegeName, set); return set; }
@NotNull @Override public PrivilegeBits supportedPrivileges(@Nullable Tree tree, @Nullable PrivilegeBits privilegeBits) { return (privilegeBits != null) ? privilegeBits : new PrivilegeBitsProvider(immutableRoot).getBits(PrivilegeConstants.JCR_ALL); }
@Test public void testGetPrivilegeNames() throws RepositoryException { PrivilegeBits bits = bitsProvider.getBits(JCR_READ_ACCESS_CONTROL); Set<String> names = bitsProvider.getPrivilegeNames(bits); assertEquals(1, names.size()); assertEquals(JCR_READ_ACCESS_CONTROL, names.iterator().next()); }