@NotNull @Override public PrincipalPermissionEntries load(@NotNull String principalName) { PrincipalPermissionEntries ppe = new PrincipalPermissionEntries(); for (PermissionStoreImpl store : stores) { ppe.putAllEntries(store.load(principalName).getEntries()); } ppe.setFullyLoaded(true); return ppe; }
void load(@NotNull PermissionStore store, @NotNull Collection<PermissionEntry> ret, @NotNull String principalName, @NotNull String path) { if (entries.containsKey(principalName)) { PrincipalPermissionEntries ppe = entries.get(principalName); Collection<PermissionEntry> pes = ppe.getEntriesByPath(path); if (ppe.isFullyLoaded() || pes != null) { // no need to read from store if (pes != null) { ret.addAll(pes); } } else { // read entries for path from store pes = store.load(principalName, path); if (pes == null) { // nothing to add to the result collection 'ret'. // nevertheless, remember the absence of any permission entries // in the cache to avoid reading from store again. ppe.rememberNotAccessControlled(path); } else { ppe.putEntriesByPath(path, pes); ret.addAll(pes); } } } else { log.error("Failed to load entries for principal '%s' at path %s", principalName, path); } } }
@Override @Nonnull public PrincipalPermissionEntries load(@Nonnull String principalName) { long t0 = System.nanoTime(); PrincipalPermissionEntries ret = new PrincipalPermissionEntries(); Tree principalRoot = getPrincipalRoot(principalName); if (principalRoot != null) { for (Tree entryTree : principalRoot.getChildren()) { loadPermissionEntries(entryTree, ret.getEntries()); } } ret.setFullyLoaded(true); long t1 = System.nanoTime(); if (log.isDebugEnabled()) { log.debug(String.format("loaded %d entries in %.2fus for %s.%n", ret.getSize(), (t1 - t0) / 1000.0, principalName)); } return ret; }
@Override public PrincipalPermissionEntries load(String principalName) { PrincipalPermissionEntries ppe = new PrincipalPermissionEntries(); for (PermissionStoreImpl store : stores) { ppe.getEntries().putAll(store.load(principalName).getEntries()); } ppe.setFullyLoaded(true); return ppe; }
void load(@Nonnull PermissionStore store, @Nonnull Collection<PermissionEntry> ret, @Nonnull String principalName, @Nonnull String path) { PrincipalPermissionEntries ppe = entries.get(principalName); if (ppe == null) { ppe = new PrincipalPermissionEntries(); entries.put(principalName, ppe); } Collection<PermissionEntry> pes = ppe.getEntriesByPath(path); if (pes == null) { pes = store.load(null, principalName, path); if (pes == null) { ppe.rememberNotAccessControlled(path); } else { ppe.putEntriesByPath(path, pes); ret.addAll(pes); } } else { ret.addAll(pes); } }
@Test public void testPutEntriesByPath() { PrincipalPermissionEntries ppe = new PrincipalPermissionEntries(2); ppe.putEntriesByPath("/path", ImmutableSet.of(permissionEntry)); assertEquals(1, ppe.getEntries().size()); assertEquals(1, ppe.getSize()); }
@Test public void testRememberNotAccessControlled() { PrincipalPermissionEntries ppe = new PrincipalPermissionEntries(1); ppe.rememberNotAccessControlled("/path"); assertFalse(ppe.isFullyLoaded()); assertEquals(1, ppe.getSize()); assertTrue(ppe.getEntries().isEmpty()); Collection c = ppe.getEntriesByPath("/path"); assertNotNull(c); assertTrue(c.isEmpty()); }
@Test public void testPutEntriesByPathExceedingExpectedSizeSetsFullyLoaded() { PrincipalPermissionEntries ppe = new PrincipalPermissionEntries(1); Collection<PermissionEntry> collection = ImmutableSet.of(permissionEntry); ppe.putEntriesByPath("/path", collection); ppe.putEntriesByPath("/path2", collection); assertTrue(ppe.isFullyLoaded()); }
@Test public void testLoadMissingPrincipalRoot() { PrincipalPermissionEntries entries = permissionStore.load(testPrincipal.getName()); assertNotNull(entries); assertTrue(entries.isFullyLoaded()); assertEquals(0, entries.getSize()); }
@Test public void testGetSize() { PrincipalPermissionEntries ppe = new PrincipalPermissionEntries(); ppe.putEntriesByPath("/path", ImmutableSet.of(permissionEntry)); assertEquals(1, ppe.getSize()); ppe.rememberNotAccessControlled("/path2"); assertEquals(2, ppe.getSize()); }
@Test public void testPutAllEntriesSetsFullyLoadedIgnoresExpectedSize() { PrincipalPermissionEntries ppe = new PrincipalPermissionEntries(1); ppe.putAllEntries(ImmutableMap.of()); assertTrue(ppe.isFullyLoaded()); }
@Test public void testSetFullyLoadedNoExpectedSize() { PrincipalPermissionEntries ppe = new PrincipalPermissionEntries(); ppe.setFullyLoaded(true); assertTrue(ppe.isFullyLoaded()); }
@Override @NotNull public PrincipalPermissionEntries load(@NotNull String principalName) { long t0 = System.nanoTime(); PrincipalPermissionEntries ret = new PrincipalPermissionEntries(); Tree principalRoot = getPrincipalRoot(principalName); if (principalRoot != null) { for (Tree entryTree : principalRoot.getChildren()) { loadPermissionEntries(entryTree, ret); } } ret.setFullyLoaded(true); long t1 = System.nanoTime(); if (log.isDebugEnabled()) { log.debug(String.format("loaded %d entries in %.2fus for %s.%n", ret.getSize(), (t1 - t0) / 1000.0, principalName)); } return ret; }
@Before public void before() { permissionEntry = new PermissionEntry("/path", true, 0, PrivilegeBits.BUILT_IN.get(PrivilegeBits.JCR_READ), RestrictionPattern.EMPTY); ppe = new PrincipalPermissionEntries(); ppe.putEntriesByPath("/path", Sets.newHashSet(permissionEntry)); store = Mockito.mock(PermissionStore.class); }
@Test public void testPutAllEntries() { PrincipalPermissionEntries ppe = new PrincipalPermissionEntries(); Map<String, Collection<PermissionEntry>> allEntries = ImmutableMap.of("/path", ImmutableSet.of(permissionEntry)); ppe.putAllEntries(allEntries); assertEquals(allEntries, ppe.getEntries()); }
@Test public void testGetEntriesByPath() { PrincipalPermissionEntries ppe = new PrincipalPermissionEntries(2); Collection<PermissionEntry> collection = ImmutableSet.of(permissionEntry); Map<String, Collection<PermissionEntry>> allEntries = ImmutableMap.of("/path", collection, "/path2", collection); ppe.putAllEntries(allEntries); assertEquals(collection, ppe.getEntriesByPath("/path")); assertEquals(collection, ppe.getEntriesByPath("/path2")); assertNull(ppe.getEntriesByPath("/nonExisting")); }
@NotNull PrincipalPermissionEntries getFullyLoadedEntries(@NotNull PermissionStore store, @NotNull String principalName) { PrincipalPermissionEntries ppe = entries.get(principalName); if (ppe == null || !ppe.isFullyLoaded()) { ppe = store.load(principalName); entries.put(principalName, ppe); } return ppe; }
private void loadPermissionEntries(@NotNull Tree tree, @NotNull PrincipalPermissionEntries principalPermissionEntries) { String path = TreeUtil.getString(tree, PermissionConstants.REP_ACCESS_CONTROLLED_PATH); if (path != null) { Collection<PermissionEntry> entries = principalPermissionEntries.getEntriesByPath(path); if (entries == null) { entries = new TreeSet<>(); principalPermissionEntries.putEntriesByPath(path, entries); } for (Tree child : tree.getChildren()) { if (child.getName().charAt(0) == 'c') { loadPermissionEntries(child, principalPermissionEntries); } else { entries.add(createPermissionEntry(path, child)); } } } else { log.error("Permission entry at '{}' without rep:accessControlledPath property.", tree.getPath()); } }
void init(@NotNull String principalName, long expectedSize) { if (!entries.containsKey(principalName)) { entries.put(principalName, new PrincipalPermissionEntries(expectedSize)); } }
@Test public void testIsFullyLoadedUponCreation() { assertTrue(new PrincipalPermissionEntries(0).isFullyLoaded()); assertFalse(new PrincipalPermissionEntries(1).isFullyLoaded()); assertFalse(new PrincipalPermissionEntries().isFullyLoaded()); }