Author: angela
Date: Tue Apr 30 08:36:03 2019
New Revision: 1858410
URL: http://svn.apache.org/viewvc?rev=1858410&view=rev
Log:
OAK-8269 : Improve readability of CompositePermissionProvider and
CompositeTreePermission
Added:
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProviderAnd.java
- copied, changed from r1858013,
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProviderOr.java
- copied, changed from r1858013,
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/Util.java
(with props)
Modified:
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeAuthorizationConfiguration.java
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeTreePermission.java
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/AbstractCompositeProviderTest.java
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderCustomMixTest.java
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderGetTreePermissionTest.java
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderSupportedTest.java
Modified:
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeAuthorizationConfiguration.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeAuthorizationConfiguration.java?rev=1858410&r1=1858409&r2=1858410&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeAuthorizationConfiguration.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeAuthorizationConfiguration.java
Tue Apr 30 08:36:03 2019
@@ -186,7 +186,7 @@ public class CompositeAuthorizationConfi
pp = aggrPermissionProviders.get(0);
break;
default :
- pp = new CompositePermissionProvider(root,
aggrPermissionProviders, getContext(), compositionType, getRootProvider(),
getTreeProvider());
+ pp = CompositePermissionProvider.create(root,
aggrPermissionProviders, getContext(), compositionType, getRootProvider(),
getTreeProvider());
}
return pp;
}
Modified:
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java?rev=1858410&r1=1858409&r2=1858410&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java
Tue Apr 30 08:36:03 2019
@@ -16,9 +16,6 @@
*/
package org.apache.jackrabbit.oak.security.authorization.composite;
-import java.util.List;
-import java.util.Set;
-import java.util.function.Function;
import org.apache.jackrabbit.oak.api.PropertyState;
import org.apache.jackrabbit.oak.api.Root;
import org.apache.jackrabbit.oak.api.Tree;
@@ -40,7 +37,8 @@ import org.apache.jackrabbit.oak.spi.sec
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
-import static
org.apache.jackrabbit.oak.security.authorization.composite.CompositeAuthorizationConfiguration.CompositionType.AND;
+import java.util.List;
+import java.util.function.Function;
/**
* Permission provider implementation that aggregates a list of different
@@ -49,12 +47,11 @@ import static org.apache.jackrabbit.oak.
* {@link
org.apache.jackrabbit.oak.spi.security.authorization.permission.AggregatedPermissionProvider}
* interface.
*/
-class CompositePermissionProvider implements AggregatedPermissionProvider {
+abstract class CompositePermissionProvider implements
AggregatedPermissionProvider {
private final Root root;
private final AggregatedPermissionProvider[] pps;
private final Context ctx;
- private final CompositionType compositionType;
private final RootProvider rootProvider;
private final TreeProvider treeProvider;
@@ -65,99 +62,59 @@ class CompositePermissionProvider implem
private TreeTypeProvider typeProvider;
CompositePermissionProvider(@NotNull Root root, @NotNull
List<AggregatedPermissionProvider> pps,
- @NotNull Context acContext, @NotNull
CompositionType compositionType,
- @NotNull RootProvider rootProvider, @NotNull
TreeProvider treeProvider) {
+ @NotNull Context acContext, @NotNull
RootProvider rootProvider, @NotNull TreeProvider treeProvider) {
this.root = root;
this.pps = pps.toArray(new AggregatedPermissionProvider[0]);
this.ctx = acContext;
- this.compositionType = compositionType;
this.rootProvider = rootProvider;
this.treeProvider = treeProvider;
- repositoryPermission = new CompositeRepositoryPermission(this.pps,
this.compositionType);
+ repositoryPermission = createRepositoryPermission();
immutableRoot = rootProvider.createReadOnlyRoot(root);
privilegeBitsProvider = new PrivilegeBitsProvider(immutableRoot);
typeProvider = new TreeTypeProvider(ctx);
}
- //-------------------------------------------------< PermissionProvider
>---
- @Override
- public void refresh() {
- immutableRoot = rootProvider.createReadOnlyRoot(root);
- privilegeBitsProvider = new PrivilegeBitsProvider(immutableRoot);
-
- for (PermissionProvider pp : pps) {
- pp.refresh();
+ static CompositePermissionProvider create(@NotNull Root root, @NotNull
List<AggregatedPermissionProvider> pps,
+ @NotNull Context acContext,
@NotNull CompositionType compositionType,
+ @NotNull RootProvider
rootProvider, @NotNull TreeProvider treeProvider) {
+ if (compositionType == CompositionType.AND) {
+ return new CompositePermissionProviderAnd(root, pps, acContext,
rootProvider, treeProvider);
+ } else {
+ return new CompositePermissionProviderOr(root, pps, acContext,
rootProvider, treeProvider);
}
}
@NotNull
- @Override
- public Set<String> getPrivileges(@Nullable Tree tree) {
- Tree immutableTree = PermissionUtil.getReadOnlyTreeOrNull(tree,
immutableRoot);
+ abstract CompositionType getCompositeType();
- PrivilegeBits result = PrivilegeBits.getInstance();
- PrivilegeBits denied = PrivilegeBits.getInstance();
+ @NotNull
+ abstract RepositoryPermission createRepositoryPermission();
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
- PrivilegeBits supported =
aggregatedPermissionProvider.supportedPrivileges(immutableTree,
null).modifiable();
- if (doEvaluate(supported)) {
- PrivilegeBits granted =
privilegeBitsProvider.getBits(aggregatedPermissionProvider.getPrivileges(immutableTree));
- // add the granted privileges to the result
- if (!granted.isEmpty()) {
- result.add(granted);
- }
- if (compositionType == AND) {
- // update the set of denied privs by comparing the granted
privs
- // with the complete set of supported privileges
- denied.add(supported.diff(granted));
- }
- }
- }
- // subtract all denied privileges from the result
- if (!denied.isEmpty()) {
- result.diff(denied);
- }
- return privilegeBitsProvider.getPrivilegeNames(result);
+ @NotNull
+ Root getImmutableRoot() {
+ return immutableRoot;
}
- @Override
- public boolean hasPrivileges(@Nullable Tree tree, @NotNull String...
privilegeNames) {
- Tree immutableTree = PermissionUtil.getReadOnlyTreeOrNull(tree,
immutableRoot);
- PrivilegeBits privilegeBits =
privilegeBitsProvider.getBits(privilegeNames);
- if (privilegeBits.isEmpty()) {
- return true;
- }
+ @NotNull
+ PrivilegeBitsProvider getBitsProvider() {
+ return privilegeBitsProvider;
+ }
- boolean hasPrivileges = false;
- PrivilegeBits coveredPrivs = PrivilegeBits.getInstance();
+ @NotNull
+ AggregatedPermissionProvider[] getPermissionProviders() {
+ return pps;
+ }
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
- PrivilegeBits supported =
aggregatedPermissionProvider.supportedPrivileges(immutableTree, privilegeBits);
- if (doEvaluate(supported)) {
- Set<String> supportedNames =
privilegeBitsProvider.getPrivilegeNames(supported);
- if (compositionType == AND) {
- hasPrivileges =
aggregatedPermissionProvider.hasPrivileges(immutableTree,
- supportedNames.toArray(new String[0]));
- if (!hasPrivileges) {
- return false;
- }
- coveredPrivs.add(supported);
-
- } else {
- // evaluate one by one so we can aggregate fragments of
- // supported privileges
- for (String p : supportedNames) {
- if
(aggregatedPermissionProvider.hasPrivileges(immutableTree, p)) {
- PrivilegeBits granted =
privilegeBitsProvider.getBits(p);
- coveredPrivs.add(granted);
- hasPrivileges = true;
- }
- }
- }
- }
+ //-------------------------------------------------< PermissionProvider
>---
+ @Override
+ public void refresh() {
+ immutableRoot = rootProvider.createReadOnlyRoot(root);
+ privilegeBitsProvider = new PrivilegeBitsProvider(immutableRoot);
+
+ for (PermissionProvider pp : pps) {
+ pp.refresh();
}
- return hasPrivileges && coveredPrivs.includes(privilegeBits);
}
@NotNull
@@ -171,7 +128,7 @@ class CompositePermissionProvider implem
public TreePermission getTreePermission(@NotNull Tree tree, @NotNull
TreePermission parentPermission) {
Tree readOnlyTree = PermissionUtil.getReadOnlyTree(tree,
immutableRoot);
if (tree.isRoot()) {
- return CompositeTreePermission.create(readOnlyTree, treeProvider,
typeProvider, pps, compositionType);
+ return CompositeTreePermission.create(readOnlyTree, treeProvider,
typeProvider, pps, getCompositeType());
} else if (parentPermission instanceof CompositeTreePermission) {
return CompositeTreePermission.create(readOnlyTree, treeProvider,
((CompositeTreePermission) parentPermission));
} else {
@@ -180,34 +137,6 @@ class CompositePermissionProvider implem
}
@Override
- public boolean isGranted(@NotNull Tree parent, @Nullable PropertyState
property, long permissions) {
- Tree immParent = PermissionUtil.getReadOnlyTree(parent, immutableRoot);
-
- boolean isGranted = false;
- long coveredPermissions = Permissions.NO_PERMISSION;
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
- long supportedPermissions =
aggregatedPermissionProvider.supportedPermissions(immParent, property,
permissions);
- if (doEvaluate(supportedPermissions)) {
- if (compositionType == AND) {
- isGranted =
aggregatedPermissionProvider.isGranted(immParent, property,
supportedPermissions);
- if (!isGranted) {
- return false;
- }
- coveredPermissions |= supportedPermissions;
- } else {
- for (long p : Permissions.aggregates(permissions)) {
- if (aggregatedPermissionProvider.isGranted(immParent,
property, p)) {
- coveredPermissions |= p;
- isGranted = true;
- }
- }
- }
- }
- }
- return isGranted && coveredPermissions == permissions;
- }
-
- @Override
public boolean isGranted(@NotNull String oakPath, @NotNull String
jcrActions) {
TreeLocation location = TreeLocation.create(immutableRoot, oakPath);
boolean isAcContent = ctx.definesLocation(location);
@@ -216,61 +145,6 @@ class CompositePermissionProvider implem
return isGranted(location, permissions);
}
- //------------------------------------------------------------< private
>---
-
- private static boolean doEvaluate(long supportedPermissions) {
- return supportedPermissions != Permissions.NO_PERMISSION;
- }
-
- private static boolean doEvaluate(PrivilegeBits supportedPrivileges) {
- return !supportedPrivileges.isEmpty();
- }
-
- //-----------------------------------------------< RepositoryPermission
>---
- /**
- * {@code RepositoryPermission} implementation that wraps multiple
implementations.
- */
- private final static class CompositeRepositoryPermission implements
RepositoryPermission {
-
- private final AggregatedPermissionProvider[] pps;
-
- private final CompositionType compositionType;
-
- CompositeRepositoryPermission(@NotNull AggregatedPermissionProvider[]
pps,
- @NotNull CompositionType
compositionType) {
- this.pps = pps;
- this.compositionType = compositionType;
- }
-
- @Override
- public boolean isGranted(long repositoryPermissions) {
- boolean isGranted = false;
- long coveredPermissions = Permissions.NO_PERMISSION;
-
- for (AggregatedPermissionProvider aggregatedPermissionProvider :
pps) {
- long supportedPermissions =
aggregatedPermissionProvider.supportedPermissions((Tree) null, null,
repositoryPermissions);
- if (doEvaluate(supportedPermissions)) {
- RepositoryPermission rp =
aggregatedPermissionProvider.getRepositoryPermission();
- if (compositionType == AND) {
- isGranted = rp.isGranted(supportedPermissions);
- if (!isGranted) {
- return false;
- }
- coveredPermissions |= supportedPermissions;
- } else {
- for (long p :
Permissions.aggregates(repositoryPermissions)) {
- if (rp.isGranted(p)) {
- coveredPermissions |= p;
- isGranted = true;
- }
- }
- }
- }
- }
- return isGranted && coveredPermissions == repositoryPermissions;
- }
- }
-
//---------------------------------------< AggregatedPermissionProvider
>---
@NotNull
@@ -311,47 +185,13 @@ class CompositePermissionProvider implem
return coveredPermissions;
}
- @Override
- public boolean isGranted(@NotNull TreeLocation location, long permissions)
{
- PropertyState property = location.getProperty();
- Tree tree = (property == null) ? location.getTree() :
location.getParent().getTree();
-
- if (tree != null) {
- return isGranted(tree, property, permissions);
- } else {
- boolean isGranted = false;
- long coveredPermissions = Permissions.NO_PERMISSION;
-
- for (AggregatedPermissionProvider aggregatedPermissionProvider :
pps) {
- long supportedPermissions =
aggregatedPermissionProvider.supportedPermissions(location, permissions);
- if (doEvaluate(supportedPermissions)) {
- if (compositionType == AND) {
- isGranted =
aggregatedPermissionProvider.isGranted(location, supportedPermissions);
- if (!isGranted) {
- return false;
- }
- coveredPermissions |= supportedPermissions;
- } else {
- for (long p : Permissions.aggregates(permissions)) {
- if
(aggregatedPermissionProvider.isGranted(location, p)) {
- coveredPermissions |= p;
- isGranted = true;
- }
- }
- }
- }
- }
- return isGranted && coveredPermissions == permissions;
- }
- }
-
@NotNull
@Override
public TreePermission getTreePermission(@NotNull Tree tree, @NotNull
TreeType type,
@NotNull TreePermission parentPermission) {
Tree immutableTree = PermissionUtil.getReadOnlyTree(tree,
immutableRoot);
if (tree.isRoot()) {
- return CompositeTreePermission.create(immutableTree, treeProvider,
typeProvider, pps, compositionType);
+ return CompositeTreePermission.create(immutableTree, treeProvider,
typeProvider, pps, getCompositeType());
} else if (parentPermission instanceof CompositeTreePermission) {
return CompositeTreePermission.create(immutableTree, treeProvider,
((CompositeTreePermission) parentPermission), type);
} else {
Copied:
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProviderAnd.java
(from r1858013,
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java)
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProviderAnd.java?p2=jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProviderAnd.java&p1=jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java&r1=1858013&r2=1858410&rev=1858410&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProviderAnd.java
Tue Apr 30 08:36:03 2019
@@ -16,115 +16,90 @@
*/
package org.apache.jackrabbit.oak.security.authorization.composite;
-import java.util.List;
-import java.util.Set;
-import java.util.function.Function;
import org.apache.jackrabbit.oak.api.PropertyState;
import org.apache.jackrabbit.oak.api.Root;
import org.apache.jackrabbit.oak.api.Tree;
import org.apache.jackrabbit.oak.plugins.tree.RootProvider;
import org.apache.jackrabbit.oak.plugins.tree.TreeLocation;
import org.apache.jackrabbit.oak.plugins.tree.TreeProvider;
-import org.apache.jackrabbit.oak.plugins.tree.TreeType;
-import org.apache.jackrabbit.oak.plugins.tree.TreeTypeProvider;
import
org.apache.jackrabbit.oak.security.authorization.composite.CompositeAuthorizationConfiguration.CompositionType;
import
org.apache.jackrabbit.oak.security.authorization.permission.PermissionUtil;
import org.apache.jackrabbit.oak.spi.security.Context;
import
org.apache.jackrabbit.oak.spi.security.authorization.permission.AggregatedPermissionProvider;
-import
org.apache.jackrabbit.oak.spi.security.authorization.permission.PermissionProvider;
import
org.apache.jackrabbit.oak.spi.security.authorization.permission.Permissions;
import
org.apache.jackrabbit.oak.spi.security.authorization.permission.RepositoryPermission;
-import
org.apache.jackrabbit.oak.spi.security.authorization.permission.TreePermission;
import org.apache.jackrabbit.oak.spi.security.privilege.PrivilegeBits;
import org.apache.jackrabbit.oak.spi.security.privilege.PrivilegeBitsProvider;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
+import java.util.List;
+import java.util.Set;
+
import static
org.apache.jackrabbit.oak.security.authorization.composite.CompositeAuthorizationConfiguration.CompositionType.AND;
/**
* Permission provider implementation that aggregates a list of different
* provider implementations. Note, that the aggregated provider implementations
* *must* implement the
- * {@link
org.apache.jackrabbit.oak.spi.security.authorization.permission.AggregatedPermissionProvider}
+ * {@link AggregatedPermissionProvider}
* interface.
*/
-class CompositePermissionProvider implements AggregatedPermissionProvider {
+final class CompositePermissionProviderAnd extends CompositePermissionProvider
{
- private final Root root;
- private final AggregatedPermissionProvider[] pps;
- private final Context ctx;
- private final CompositionType compositionType;
- private final RootProvider rootProvider;
- private final TreeProvider treeProvider;
-
- private final RepositoryPermission repositoryPermission;
-
- private Root immutableRoot;
- private PrivilegeBitsProvider privilegeBitsProvider;
- private TreeTypeProvider typeProvider;
-
- CompositePermissionProvider(@NotNull Root root, @NotNull
List<AggregatedPermissionProvider> pps,
- @NotNull Context acContext, @NotNull
CompositionType compositionType,
- @NotNull RootProvider rootProvider, @NotNull
TreeProvider treeProvider) {
- this.root = root;
- this.pps = pps.toArray(new AggregatedPermissionProvider[0]);
- this.ctx = acContext;
- this.compositionType = compositionType;
- this.rootProvider = rootProvider;
- this.treeProvider = treeProvider;
-
- repositoryPermission = new CompositeRepositoryPermission(this.pps,
this.compositionType);
- immutableRoot = rootProvider.createReadOnlyRoot(root);
- privilegeBitsProvider = new PrivilegeBitsProvider(immutableRoot);
- typeProvider = new TreeTypeProvider(ctx);
+ CompositePermissionProviderAnd(@NotNull Root root, @NotNull
List<AggregatedPermissionProvider> pps,
+ @NotNull Context acContext,
+ @NotNull RootProvider rootProvider,
@NotNull TreeProvider treeProvider) {
+ super(root, pps, acContext, rootProvider, treeProvider);
}
- //-------------------------------------------------< PermissionProvider
>---
- @Override
- public void refresh() {
- immutableRoot = rootProvider.createReadOnlyRoot(root);
- privilegeBitsProvider = new PrivilegeBitsProvider(immutableRoot);
+ @NotNull
+ CompositionType getCompositeType() {
+ return AND;
+ }
- for (PermissionProvider pp : pps) {
- pp.refresh();
- }
+ @NotNull
+ RepositoryPermission createRepositoryPermission() {
+ return new CompositeRepositoryPermission();
}
+ //-------------------------------------------------< PermissionProvider
>---
+
@NotNull
@Override
public Set<String> getPrivileges(@Nullable Tree tree) {
- Tree immutableTree = PermissionUtil.getReadOnlyTree(tree,
immutableRoot);
+ Tree immutableTree = PermissionUtil.getReadOnlyTreeOrNull(tree,
getImmutableRoot());
PrivilegeBits result = PrivilegeBits.getInstance();
PrivilegeBits denied = PrivilegeBits.getInstance();
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
+ PrivilegeBitsProvider bitsProvider = getBitsProvider();
+ for (AggregatedPermissionProvider aggregatedPermissionProvider :
getPermissionProviders()) {
PrivilegeBits supported =
aggregatedPermissionProvider.supportedPrivileges(immutableTree,
null).modifiable();
- if (doEvaluate(supported)) {
- PrivilegeBits granted =
privilegeBitsProvider.getBits(aggregatedPermissionProvider.getPrivileges(immutableTree));
+ if (Util.doEvaluate(supported)) {
+ PrivilegeBits granted =
bitsProvider.getBits(aggregatedPermissionProvider.getPrivileges(immutableTree));
// add the granted privileges to the result
if (!granted.isEmpty()) {
result.add(granted);
}
- if (compositionType == AND) {
- // update the set of denied privs by comparing the granted
privs
- // with the complete set of supported privileges
- denied.add(supported.diff(granted));
- }
+ // update the set of denied privs by comparing the granted
privs
+ // with the complete set of supported privileges
+ denied.add(supported.diff(granted));
}
}
// subtract all denied privileges from the result
if (!denied.isEmpty()) {
result.diff(denied);
}
- return privilegeBitsProvider.getPrivilegeNames(result);
+ return bitsProvider.getPrivilegeNames(result);
}
@Override
public boolean hasPrivileges(@Nullable Tree tree, @NotNull String...
privilegeNames) {
- Tree immutableTree = PermissionUtil.getReadOnlyTree(tree,
immutableRoot);
- PrivilegeBits privilegeBits =
privilegeBitsProvider.getBits(privilegeNames);
+ Tree immutableTree = PermissionUtil.getReadOnlyTreeOrNull(tree,
getImmutableRoot());
+ PrivilegeBitsProvider bitsProvider = getBitsProvider();
+
+ PrivilegeBits privilegeBits = bitsProvider.getBits(privilegeNames);
if (privilegeBits.isEmpty()) {
return true;
}
@@ -132,185 +107,42 @@ class CompositePermissionProvider implem
boolean hasPrivileges = false;
PrivilegeBits coveredPrivs = PrivilegeBits.getInstance();
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
+ for (AggregatedPermissionProvider aggregatedPermissionProvider :
getPermissionProviders()) {
PrivilegeBits supported =
aggregatedPermissionProvider.supportedPrivileges(immutableTree, privilegeBits);
- if (doEvaluate(supported)) {
- Set<String> supportedNames =
privilegeBitsProvider.getPrivilegeNames(supported);
- if (compositionType == AND) {
- hasPrivileges =
aggregatedPermissionProvider.hasPrivileges(immutableTree,
- supportedNames.toArray(new String[0]));
- if (!hasPrivileges) {
- return false;
- }
- coveredPrivs.add(supported);
-
- } else {
- // evaluate one by one so we can aggregate fragments of
- // supported privileges
- for (String p : supportedNames) {
- if
(aggregatedPermissionProvider.hasPrivileges(immutableTree, p)) {
- PrivilegeBits granted =
privilegeBitsProvider.getBits(p);
- coveredPrivs.add(granted);
- hasPrivileges = true;
- }
- }
+ if (Util.doEvaluate(supported)) {
+ Set<String> supportedNames =
bitsProvider.getPrivilegeNames(supported);
+ hasPrivileges =
aggregatedPermissionProvider.hasPrivileges(immutableTree,
+ supportedNames.toArray(new String[0]));
+ if (!hasPrivileges) {
+ return false;
}
+ coveredPrivs.add(supported);
}
}
return hasPrivileges && coveredPrivs.includes(privilegeBits);
}
- @NotNull
- @Override
- public RepositoryPermission getRepositoryPermission() {
- return repositoryPermission;
- }
-
- @NotNull
- @Override
- public TreePermission getTreePermission(@NotNull Tree tree, @NotNull
TreePermission parentPermission) {
- Tree readOnlyTree = PermissionUtil.getReadOnlyTree(tree,
immutableRoot);
- if (tree.isRoot()) {
- return CompositeTreePermission.create(readOnlyTree, treeProvider,
typeProvider, pps, compositionType);
- } else if (parentPermission instanceof CompositeTreePermission) {
- return CompositeTreePermission.create(readOnlyTree, treeProvider,
((CompositeTreePermission) parentPermission));
- } else {
- return parentPermission.getChildPermission(readOnlyTree.getName(),
treeProvider.asNodeState(readOnlyTree));
- }
- }
-
@Override
public boolean isGranted(@NotNull Tree parent, @Nullable PropertyState
property, long permissions) {
- Tree immParent = PermissionUtil.getReadOnlyTree(parent, immutableRoot);
+ Tree immParent = PermissionUtil.getReadOnlyTree(parent,
getImmutableRoot());
boolean isGranted = false;
long coveredPermissions = Permissions.NO_PERMISSION;
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
+ for (AggregatedPermissionProvider aggregatedPermissionProvider :
getPermissionProviders()) {
long supportedPermissions =
aggregatedPermissionProvider.supportedPermissions(immParent, property,
permissions);
- if (doEvaluate(supportedPermissions)) {
- if (compositionType == AND) {
- isGranted =
aggregatedPermissionProvider.isGranted(immParent, property,
supportedPermissions);
- if (!isGranted) {
- return false;
- }
- coveredPermissions |= supportedPermissions;
- } else {
- for (long p : Permissions.aggregates(permissions)) {
- if (aggregatedPermissionProvider.isGranted(immParent,
property, p)) {
- coveredPermissions |= p;
- isGranted = true;
- }
- }
+ if (Util.doEvaluate(supportedPermissions)) {
+ isGranted = aggregatedPermissionProvider.isGranted(immParent,
property, supportedPermissions);
+ if (!isGranted) {
+ return false;
}
+ coveredPermissions |= supportedPermissions;
}
}
return isGranted && coveredPermissions == permissions;
}
- @Override
- public boolean isGranted(@NotNull String oakPath, @NotNull String
jcrActions) {
- TreeLocation location = TreeLocation.create(immutableRoot, oakPath);
- boolean isAcContent = ctx.definesLocation(location);
-
- long permissions = Permissions.getPermissions(jcrActions, location,
isAcContent);
- return isGranted(location, permissions);
- }
-
- //------------------------------------------------------------< private
>---
-
- private static boolean doEvaluate(long supportedPermissions) {
- return supportedPermissions != Permissions.NO_PERMISSION;
- }
-
- private static boolean doEvaluate(PrivilegeBits supportedPrivileges) {
- return !supportedPrivileges.isEmpty();
- }
-
- //-----------------------------------------------< RepositoryPermission
>---
- /**
- * {@code RepositoryPermission} implementation that wraps multiple
implementations.
- */
- private final static class CompositeRepositoryPermission implements
RepositoryPermission {
-
- private final AggregatedPermissionProvider[] pps;
-
- private final CompositionType compositionType;
-
- CompositeRepositoryPermission(@NotNull AggregatedPermissionProvider[]
pps,
- @NotNull CompositionType
compositionType) {
- this.pps = pps;
- this.compositionType = compositionType;
- }
-
- @Override
- public boolean isGranted(long repositoryPermissions) {
- boolean isGranted = false;
- long coveredPermissions = Permissions.NO_PERMISSION;
-
- for (AggregatedPermissionProvider aggregatedPermissionProvider :
pps) {
- long supportedPermissions =
aggregatedPermissionProvider.supportedPermissions((Tree) null, null,
repositoryPermissions);
- if (doEvaluate(supportedPermissions)) {
- RepositoryPermission rp =
aggregatedPermissionProvider.getRepositoryPermission();
- if (compositionType == AND) {
- isGranted = rp.isGranted(supportedPermissions);
- if (!isGranted) {
- return false;
- }
- coveredPermissions |= supportedPermissions;
- } else {
- for (long p :
Permissions.aggregates(repositoryPermissions)) {
- if (rp.isGranted(p)) {
- coveredPermissions |= p;
- isGranted = true;
- }
- }
- }
- }
- }
- return isGranted && coveredPermissions == repositoryPermissions;
- }
- }
-
//---------------------------------------< AggregatedPermissionProvider
>---
- @NotNull
- @Override
- public PrivilegeBits supportedPrivileges(@Nullable Tree tree, @Nullable
PrivilegeBits privilegeBits) {
- PrivilegeBits result = PrivilegeBits.getInstance();
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
- PrivilegeBits supported =
aggregatedPermissionProvider.supportedPrivileges(tree, privilegeBits);
- result.add(supported);
- }
- return result;
- }
-
- @Override
- public long supportedPermissions(@Nullable Tree tree, @Nullable
PropertyState property, long permissions) {
- return supportedPermissions((aggregatedPermissionProvider) ->
aggregatedPermissionProvider
- .supportedPermissions(tree, property, permissions));
- }
-
- @Override
- public long supportedPermissions(@NotNull TreeLocation location, long
permissions) {
- return supportedPermissions((aggregatedPermissionProvider) ->
aggregatedPermissionProvider
- .supportedPermissions(location, permissions));
- }
-
- @Override
- public long supportedPermissions(@NotNull TreePermission treePermission,
@Nullable PropertyState property, long permissions) {
- return supportedPermissions((aggregatedPermissionProvider) ->
aggregatedPermissionProvider
- .supportedPermissions(treePermission, property, permissions));
- }
-
- private long supportedPermissions(Function<AggregatedPermissionProvider,
Long> supported) {
- long coveredPermissions = Permissions.NO_PERMISSION;
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
- long supportedPermissions =
supported.apply(aggregatedPermissionProvider);
- coveredPermissions |= supportedPermissions;
- }
- return coveredPermissions;
- }
-
@Override
public boolean isGranted(@NotNull TreeLocation location, long permissions)
{
PropertyState property = location.getProperty();
@@ -322,40 +154,43 @@ class CompositePermissionProvider implem
boolean isGranted = false;
long coveredPermissions = Permissions.NO_PERMISSION;
- for (AggregatedPermissionProvider aggregatedPermissionProvider :
pps) {
+ for (AggregatedPermissionProvider aggregatedPermissionProvider :
getPermissionProviders()) {
long supportedPermissions =
aggregatedPermissionProvider.supportedPermissions(location, permissions);
- if (doEvaluate(supportedPermissions)) {
- if (compositionType == AND) {
- isGranted =
aggregatedPermissionProvider.isGranted(location, supportedPermissions);
- if (!isGranted) {
- return false;
- }
- coveredPermissions |= supportedPermissions;
- } else {
- for (long p : Permissions.aggregates(permissions)) {
- if
(aggregatedPermissionProvider.isGranted(location, p)) {
- coveredPermissions |= p;
- isGranted = true;
- }
- }
+ if (Util.doEvaluate(supportedPermissions)) {
+ isGranted =
aggregatedPermissionProvider.isGranted(location, supportedPermissions);
+ if (!isGranted) {
+ return false;
}
+ coveredPermissions |= supportedPermissions;
}
}
return isGranted && coveredPermissions == permissions;
}
}
- @NotNull
- @Override
- public TreePermission getTreePermission(@NotNull Tree tree, @NotNull
TreeType type,
- @NotNull TreePermission parentPermission) {
- Tree immutableTree = PermissionUtil.getReadOnlyTree(tree,
immutableRoot);
- if (tree.isRoot()) {
- return CompositeTreePermission.create(immutableTree, treeProvider,
typeProvider, pps, compositionType);
- } else if (parentPermission instanceof CompositeTreePermission) {
- return CompositeTreePermission.create(immutableTree, treeProvider,
((CompositeTreePermission) parentPermission), type);
- } else {
- return
parentPermission.getChildPermission(immutableTree.getName(),
treeProvider.asNodeState(immutableTree));
+ //-----------------------------------------------< RepositoryPermission
>---
+ /**
+ * {@code RepositoryPermission} implementation that wraps multiple
implementations.
+ */
+ private final class CompositeRepositoryPermission implements
RepositoryPermission {
+
+ @Override
+ public boolean isGranted(long repositoryPermissions) {
+ boolean isGranted = false;
+ long coveredPermissions = Permissions.NO_PERMISSION;
+
+ for (AggregatedPermissionProvider aggregatedPermissionProvider :
getPermissionProviders()) {
+ long supportedPermissions =
aggregatedPermissionProvider.supportedPermissions((Tree) null, null,
repositoryPermissions);
+ if (Util.doEvaluate(supportedPermissions)) {
+ RepositoryPermission rp =
aggregatedPermissionProvider.getRepositoryPermission();
+ isGranted = rp.isGranted(supportedPermissions);
+ if (!isGranted) {
+ return false;
+ }
+ coveredPermissions |= supportedPermissions;
+ }
+ }
+ return isGranted && coveredPermissions == repositoryPermissions;
}
}
}
Copied:
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProviderOr.java
(from r1858013,
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java)
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProviderOr.java?p2=jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProviderOr.java&p1=jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java&r1=1858013&r2=1858410&rev=1858410&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProvider.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositePermissionProviderOr.java
Tue Apr 30 08:36:03 2019
@@ -16,115 +16,89 @@
*/
package org.apache.jackrabbit.oak.security.authorization.composite;
-import java.util.List;
-import java.util.Set;
-import java.util.function.Function;
import org.apache.jackrabbit.oak.api.PropertyState;
import org.apache.jackrabbit.oak.api.Root;
import org.apache.jackrabbit.oak.api.Tree;
import org.apache.jackrabbit.oak.plugins.tree.RootProvider;
import org.apache.jackrabbit.oak.plugins.tree.TreeLocation;
import org.apache.jackrabbit.oak.plugins.tree.TreeProvider;
-import org.apache.jackrabbit.oak.plugins.tree.TreeType;
-import org.apache.jackrabbit.oak.plugins.tree.TreeTypeProvider;
import
org.apache.jackrabbit.oak.security.authorization.composite.CompositeAuthorizationConfiguration.CompositionType;
import
org.apache.jackrabbit.oak.security.authorization.permission.PermissionUtil;
import org.apache.jackrabbit.oak.spi.security.Context;
import
org.apache.jackrabbit.oak.spi.security.authorization.permission.AggregatedPermissionProvider;
-import
org.apache.jackrabbit.oak.spi.security.authorization.permission.PermissionProvider;
import
org.apache.jackrabbit.oak.spi.security.authorization.permission.Permissions;
import
org.apache.jackrabbit.oak.spi.security.authorization.permission.RepositoryPermission;
-import
org.apache.jackrabbit.oak.spi.security.authorization.permission.TreePermission;
import org.apache.jackrabbit.oak.spi.security.privilege.PrivilegeBits;
import org.apache.jackrabbit.oak.spi.security.privilege.PrivilegeBitsProvider;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
-import static
org.apache.jackrabbit.oak.security.authorization.composite.CompositeAuthorizationConfiguration.CompositionType.AND;
+import java.util.List;
+import java.util.Set;
+
+import static
org.apache.jackrabbit.oak.security.authorization.composite.CompositeAuthorizationConfiguration.CompositionType.OR;
/**
* Permission provider implementation that aggregates a list of different
* provider implementations. Note, that the aggregated provider implementations
* *must* implement the
- * {@link
org.apache.jackrabbit.oak.spi.security.authorization.permission.AggregatedPermissionProvider}
+ * {@link AggregatedPermissionProvider}
* interface.
*/
-class CompositePermissionProvider implements AggregatedPermissionProvider {
+final class CompositePermissionProviderOr extends CompositePermissionProvider {
- private final Root root;
- private final AggregatedPermissionProvider[] pps;
- private final Context ctx;
- private final CompositionType compositionType;
- private final RootProvider rootProvider;
- private final TreeProvider treeProvider;
-
- private final RepositoryPermission repositoryPermission;
-
- private Root immutableRoot;
- private PrivilegeBitsProvider privilegeBitsProvider;
- private TreeTypeProvider typeProvider;
-
- CompositePermissionProvider(@NotNull Root root, @NotNull
List<AggregatedPermissionProvider> pps,
- @NotNull Context acContext, @NotNull
CompositionType compositionType,
- @NotNull RootProvider rootProvider, @NotNull
TreeProvider treeProvider) {
- this.root = root;
- this.pps = pps.toArray(new AggregatedPermissionProvider[0]);
- this.ctx = acContext;
- this.compositionType = compositionType;
- this.rootProvider = rootProvider;
- this.treeProvider = treeProvider;
-
- repositoryPermission = new CompositeRepositoryPermission(this.pps,
this.compositionType);
- immutableRoot = rootProvider.createReadOnlyRoot(root);
- privilegeBitsProvider = new PrivilegeBitsProvider(immutableRoot);
- typeProvider = new TreeTypeProvider(ctx);
+ CompositePermissionProviderOr(@NotNull Root root, @NotNull
List<AggregatedPermissionProvider> pps,
+ @NotNull Context acContext, @NotNull
RootProvider rootProvider,
+ @NotNull TreeProvider treeProvider) {
+ super(root, pps, acContext, rootProvider, treeProvider);
}
- //-------------------------------------------------< PermissionProvider
>---
+ @NotNull
@Override
- public void refresh() {
- immutableRoot = rootProvider.createReadOnlyRoot(root);
- privilegeBitsProvider = new PrivilegeBitsProvider(immutableRoot);
+ CompositionType getCompositeType() {
+ return OR;
+ }
- for (PermissionProvider pp : pps) {
- pp.refresh();
- }
+ @NotNull
+ @Override
+ RepositoryPermission createRepositoryPermission() {
+ return new CompositeRepositoryPermission();
}
+ //-------------------------------------------------< PermissionProvider
>---
+
@NotNull
@Override
public Set<String> getPrivileges(@Nullable Tree tree) {
- Tree immutableTree = PermissionUtil.getReadOnlyTree(tree,
immutableRoot);
+ Tree immutableTree = PermissionUtil.getReadOnlyTreeOrNull(tree,
getImmutableRoot());
PrivilegeBits result = PrivilegeBits.getInstance();
PrivilegeBits denied = PrivilegeBits.getInstance();
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
+ PrivilegeBitsProvider bitsProvider = getBitsProvider();
+ for (AggregatedPermissionProvider aggregatedPermissionProvider :
getPermissionProviders()) {
PrivilegeBits supported =
aggregatedPermissionProvider.supportedPrivileges(immutableTree,
null).modifiable();
- if (doEvaluate(supported)) {
- PrivilegeBits granted =
privilegeBitsProvider.getBits(aggregatedPermissionProvider.getPrivileges(immutableTree));
+ if (Util.doEvaluate(supported)) {
+ PrivilegeBits granted =
bitsProvider.getBits(aggregatedPermissionProvider.getPrivileges(immutableTree));
// add the granted privileges to the result
if (!granted.isEmpty()) {
result.add(granted);
}
- if (compositionType == AND) {
- // update the set of denied privs by comparing the granted
privs
- // with the complete set of supported privileges
- denied.add(supported.diff(granted));
- }
}
}
// subtract all denied privileges from the result
if (!denied.isEmpty()) {
result.diff(denied);
}
- return privilegeBitsProvider.getPrivilegeNames(result);
+ return getBitsProvider().getPrivilegeNames(result);
}
@Override
public boolean hasPrivileges(@Nullable Tree tree, @NotNull String...
privilegeNames) {
- Tree immutableTree = PermissionUtil.getReadOnlyTree(tree,
immutableRoot);
- PrivilegeBits privilegeBits =
privilegeBitsProvider.getBits(privilegeNames);
+ Tree immutableTree = PermissionUtil.getReadOnlyTreeOrNull(tree,
getImmutableRoot());
+ PrivilegeBitsProvider bitsProvider = getBitsProvider();
+
+ PrivilegeBits privilegeBits = bitsProvider.getBits(privilegeNames);
if (privilegeBits.isEmpty()) {
return true;
}
@@ -132,27 +106,17 @@ class CompositePermissionProvider implem
boolean hasPrivileges = false;
PrivilegeBits coveredPrivs = PrivilegeBits.getInstance();
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
+ for (AggregatedPermissionProvider aggregatedPermissionProvider :
getPermissionProviders()) {
PrivilegeBits supported =
aggregatedPermissionProvider.supportedPrivileges(immutableTree, privilegeBits);
- if (doEvaluate(supported)) {
- Set<String> supportedNames =
privilegeBitsProvider.getPrivilegeNames(supported);
- if (compositionType == AND) {
- hasPrivileges =
aggregatedPermissionProvider.hasPrivileges(immutableTree,
- supportedNames.toArray(new String[0]));
- if (!hasPrivileges) {
- return false;
- }
- coveredPrivs.add(supported);
-
- } else {
- // evaluate one by one so we can aggregate fragments of
- // supported privileges
- for (String p : supportedNames) {
- if
(aggregatedPermissionProvider.hasPrivileges(immutableTree, p)) {
- PrivilegeBits granted =
privilegeBitsProvider.getBits(p);
- coveredPrivs.add(granted);
- hasPrivileges = true;
- }
+ if (Util.doEvaluate(supported)) {
+ Set<String> supportedNames =
bitsProvider.getPrivilegeNames(supported);
+ // evaluate one by one so we can aggregate fragments of
+ // supported privileges
+ for (String p : supportedNames) {
+ if
(aggregatedPermissionProvider.hasPrivileges(immutableTree, p)) {
+ PrivilegeBits granted = bitsProvider.getBits(p);
+ coveredPrivs.add(granted);
+ hasPrivileges = true;
}
}
}
@@ -160,46 +124,19 @@ class CompositePermissionProvider implem
return hasPrivileges && coveredPrivs.includes(privilegeBits);
}
- @NotNull
- @Override
- public RepositoryPermission getRepositoryPermission() {
- return repositoryPermission;
- }
-
- @NotNull
- @Override
- public TreePermission getTreePermission(@NotNull Tree tree, @NotNull
TreePermission parentPermission) {
- Tree readOnlyTree = PermissionUtil.getReadOnlyTree(tree,
immutableRoot);
- if (tree.isRoot()) {
- return CompositeTreePermission.create(readOnlyTree, treeProvider,
typeProvider, pps, compositionType);
- } else if (parentPermission instanceof CompositeTreePermission) {
- return CompositeTreePermission.create(readOnlyTree, treeProvider,
((CompositeTreePermission) parentPermission));
- } else {
- return parentPermission.getChildPermission(readOnlyTree.getName(),
treeProvider.asNodeState(readOnlyTree));
- }
- }
-
@Override
public boolean isGranted(@NotNull Tree parent, @Nullable PropertyState
property, long permissions) {
- Tree immParent = PermissionUtil.getReadOnlyTree(parent, immutableRoot);
+ Tree immParent = PermissionUtil.getReadOnlyTree(parent,
getImmutableRoot());
boolean isGranted = false;
long coveredPermissions = Permissions.NO_PERMISSION;
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
+ for (AggregatedPermissionProvider aggregatedPermissionProvider :
getPermissionProviders()) {
long supportedPermissions =
aggregatedPermissionProvider.supportedPermissions(immParent, property,
permissions);
- if (doEvaluate(supportedPermissions)) {
- if (compositionType == AND) {
- isGranted =
aggregatedPermissionProvider.isGranted(immParent, property,
supportedPermissions);
- if (!isGranted) {
- return false;
- }
- coveredPermissions |= supportedPermissions;
- } else {
- for (long p : Permissions.aggregates(permissions)) {
- if (aggregatedPermissionProvider.isGranted(immParent,
property, p)) {
- coveredPermissions |= p;
- isGranted = true;
- }
+ if (Util.doEvaluate(supportedPermissions)) {
+ for (long p : Permissions.aggregates(permissions)) {
+ if (aggregatedPermissionProvider.isGranted(immParent,
property, p)) {
+ coveredPermissions |= p;
+ isGranted = true;
}
}
}
@@ -207,110 +144,8 @@ class CompositePermissionProvider implem
return isGranted && coveredPermissions == permissions;
}
- @Override
- public boolean isGranted(@NotNull String oakPath, @NotNull String
jcrActions) {
- TreeLocation location = TreeLocation.create(immutableRoot, oakPath);
- boolean isAcContent = ctx.definesLocation(location);
-
- long permissions = Permissions.getPermissions(jcrActions, location,
isAcContent);
- return isGranted(location, permissions);
- }
-
- //------------------------------------------------------------< private
>---
-
- private static boolean doEvaluate(long supportedPermissions) {
- return supportedPermissions != Permissions.NO_PERMISSION;
- }
-
- private static boolean doEvaluate(PrivilegeBits supportedPrivileges) {
- return !supportedPrivileges.isEmpty();
- }
-
- //-----------------------------------------------< RepositoryPermission
>---
- /**
- * {@code RepositoryPermission} implementation that wraps multiple
implementations.
- */
- private final static class CompositeRepositoryPermission implements
RepositoryPermission {
-
- private final AggregatedPermissionProvider[] pps;
-
- private final CompositionType compositionType;
-
- CompositeRepositoryPermission(@NotNull AggregatedPermissionProvider[]
pps,
- @NotNull CompositionType
compositionType) {
- this.pps = pps;
- this.compositionType = compositionType;
- }
-
- @Override
- public boolean isGranted(long repositoryPermissions) {
- boolean isGranted = false;
- long coveredPermissions = Permissions.NO_PERMISSION;
-
- for (AggregatedPermissionProvider aggregatedPermissionProvider :
pps) {
- long supportedPermissions =
aggregatedPermissionProvider.supportedPermissions((Tree) null, null,
repositoryPermissions);
- if (doEvaluate(supportedPermissions)) {
- RepositoryPermission rp =
aggregatedPermissionProvider.getRepositoryPermission();
- if (compositionType == AND) {
- isGranted = rp.isGranted(supportedPermissions);
- if (!isGranted) {
- return false;
- }
- coveredPermissions |= supportedPermissions;
- } else {
- for (long p :
Permissions.aggregates(repositoryPermissions)) {
- if (rp.isGranted(p)) {
- coveredPermissions |= p;
- isGranted = true;
- }
- }
- }
- }
- }
- return isGranted && coveredPermissions == repositoryPermissions;
- }
- }
-
//---------------------------------------< AggregatedPermissionProvider
>---
- @NotNull
- @Override
- public PrivilegeBits supportedPrivileges(@Nullable Tree tree, @Nullable
PrivilegeBits privilegeBits) {
- PrivilegeBits result = PrivilegeBits.getInstance();
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
- PrivilegeBits supported =
aggregatedPermissionProvider.supportedPrivileges(tree, privilegeBits);
- result.add(supported);
- }
- return result;
- }
-
- @Override
- public long supportedPermissions(@Nullable Tree tree, @Nullable
PropertyState property, long permissions) {
- return supportedPermissions((aggregatedPermissionProvider) ->
aggregatedPermissionProvider
- .supportedPermissions(tree, property, permissions));
- }
-
- @Override
- public long supportedPermissions(@NotNull TreeLocation location, long
permissions) {
- return supportedPermissions((aggregatedPermissionProvider) ->
aggregatedPermissionProvider
- .supportedPermissions(location, permissions));
- }
-
- @Override
- public long supportedPermissions(@NotNull TreePermission treePermission,
@Nullable PropertyState property, long permissions) {
- return supportedPermissions((aggregatedPermissionProvider) ->
aggregatedPermissionProvider
- .supportedPermissions(treePermission, property, permissions));
- }
-
- private long supportedPermissions(Function<AggregatedPermissionProvider,
Long> supported) {
- long coveredPermissions = Permissions.NO_PERMISSION;
- for (AggregatedPermissionProvider aggregatedPermissionProvider : pps) {
- long supportedPermissions =
supported.apply(aggregatedPermissionProvider);
- coveredPermissions |= supportedPermissions;
- }
- return coveredPermissions;
- }
-
@Override
public boolean isGranted(@NotNull TreeLocation location, long permissions)
{
PropertyState property = location.getProperty();
@@ -322,21 +157,13 @@ class CompositePermissionProvider implem
boolean isGranted = false;
long coveredPermissions = Permissions.NO_PERMISSION;
- for (AggregatedPermissionProvider aggregatedPermissionProvider :
pps) {
+ for (AggregatedPermissionProvider aggregatedPermissionProvider :
getPermissionProviders()) {
long supportedPermissions =
aggregatedPermissionProvider.supportedPermissions(location, permissions);
- if (doEvaluate(supportedPermissions)) {
- if (compositionType == AND) {
- isGranted =
aggregatedPermissionProvider.isGranted(location, supportedPermissions);
- if (!isGranted) {
- return false;
- }
- coveredPermissions |= supportedPermissions;
- } else {
- for (long p : Permissions.aggregates(permissions)) {
- if
(aggregatedPermissionProvider.isGranted(location, p)) {
- coveredPermissions |= p;
- isGranted = true;
- }
+ if (Util.doEvaluate(supportedPermissions)) {
+ for (long p : Permissions.aggregates(permissions)) {
+ if (aggregatedPermissionProvider.isGranted(location,
p)) {
+ coveredPermissions |= p;
+ isGranted = true;
}
}
}
@@ -345,17 +172,30 @@ class CompositePermissionProvider implem
}
}
- @NotNull
- @Override
- public TreePermission getTreePermission(@NotNull Tree tree, @NotNull
TreeType type,
- @NotNull TreePermission parentPermission) {
- Tree immutableTree = PermissionUtil.getReadOnlyTree(tree,
immutableRoot);
- if (tree.isRoot()) {
- return CompositeTreePermission.create(immutableTree, treeProvider,
typeProvider, pps, compositionType);
- } else if (parentPermission instanceof CompositeTreePermission) {
- return CompositeTreePermission.create(immutableTree, treeProvider,
((CompositeTreePermission) parentPermission), type);
- } else {
- return
parentPermission.getChildPermission(immutableTree.getName(),
treeProvider.asNodeState(immutableTree));
+ //-----------------------------------------------< RepositoryPermission
>---
+ /**
+ * {@code RepositoryPermission} implementation that wraps multiple
implementations.
+ */
+ private final class CompositeRepositoryPermission implements
RepositoryPermission {
+
+ @Override
+ public boolean isGranted(long repositoryPermissions) {
+ boolean isGranted = false;
+ long coveredPermissions = Permissions.NO_PERMISSION;
+
+ for (AggregatedPermissionProvider aggregatedPermissionProvider :
getPermissionProviders()) {
+ long supportedPermissions =
aggregatedPermissionProvider.supportedPermissions((Tree) null, null,
repositoryPermissions);
+ if (Util.doEvaluate(supportedPermissions)) {
+ RepositoryPermission rp =
aggregatedPermissionProvider.getRepositoryPermission();
+ for (long p :
Permissions.aggregates(repositoryPermissions)) {
+ if (rp.isGranted(p)) {
+ coveredPermissions |= p;
+ isGranted = true;
+ }
+ }
+ }
+ }
+ return isGranted && coveredPermissions == repositoryPermissions;
}
}
}
Modified:
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeTreePermission.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeTreePermission.java?rev=1858410&r1=1858409&r2=1858410&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeTreePermission.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeTreePermission.java
Tue Apr 30 08:36:03 2019
@@ -32,16 +32,16 @@ import org.jetbrains.annotations.Nullabl
import static
org.apache.jackrabbit.oak.security.authorization.composite.CompositeAuthorizationConfiguration.CompositionType.AND;
import static
org.apache.jackrabbit.oak.security.authorization.composite.CompositeAuthorizationConfiguration.CompositionType.OR;
+import static
org.apache.jackrabbit.oak.security.authorization.composite.Util.doEvaluate;
/**
* {@code TreePermission} implementation that combines multiple {@code
TreePermission}
* implementations.
*/
-final class CompositeTreePermission implements TreePermission {
+abstract class CompositeTreePermission implements TreePermission {
private final Tree tree;
private final TreeType type;
- private final CompositionType compositionType;
private final TreeProvider treeProvider;
private final TreeTypeProvider typeProvider;
@@ -53,9 +53,10 @@ final class CompositeTreePermission impl
private Boolean canReadProperties;
private CompositeTreePermission(@NotNull Tree tree, @NotNull TreeType type,
- @NotNull TreeProvider treeProvider,
- @NotNull TreeTypeProvider typeProvider, @NotNull
AggregatedPermissionProvider[] providers,
- @NotNull TreePermission[] treePermissions, int cnt, @NotNull
CompositionType compositionType) {
+ @NotNull TreeProvider treeProvider,
+ @NotNull TreeTypeProvider typeProvider,
+ @NotNull AggregatedPermissionProvider[]
providers,
+ @NotNull TreePermission[] treePermissions,
int cnt) {
this.tree = tree;
this.type = type;
@@ -64,7 +65,6 @@ final class CompositeTreePermission impl
this.providers = providers;
this.treePermissions = treePermissions;
this.childSize = providers.length - cnt;
- this.compositionType = compositionType;
}
static TreePermission create(@NotNull Tree rootTree,
@@ -85,8 +85,11 @@ final class CompositeTreePermission impl
}
treePermissions[i] = tp;
}
- return new CompositeTreePermission(rootTree, TreeType.DEFAULT,
treeProvider, typeProvider, providers, treePermissions,
- cnt, compositionType);
+ if (compositionType == AND) {
+ return new CompositeTreePermissionAnd(rootTree,
TreeType.DEFAULT, treeProvider, typeProvider, providers, treePermissions, cnt);
+ } else {
+ return new CompositeTreePermissionOr(rootTree,
TreeType.DEFAULT, treeProvider, typeProvider, providers, treePermissions, cnt);
+ }
}
}
@@ -108,11 +111,11 @@ final class CompositeTreePermission impl
case 1:
TreePermission parent = null;
for (TreePermission tp : parentPermission.treePermissions) {
- if (isValid(tp)) {
- parent = tp;
- break;
- }
+ if (isValid(tp)) {
+ parent = tp;
+ break;
}
+ }
return (parent == null) ? TreePermission.EMPTY :
parent.getChildPermission(childName, childState);
default:
Tree tree = lazyTree.get();
@@ -139,8 +142,11 @@ final class CompositeTreePermission impl
j++;
}
}
- return new CompositeTreePermission(tree, type,
parentPermission.treeProvider, parentPermission.typeProvider, pvds, tps, cnt,
- parentPermission.compositionType);
+ if (parentPermission.getCompositionType() == AND) {
+ return new CompositeTreePermissionAnd(tree, type,
parentPermission.treeProvider, parentPermission.typeProvider, pvds, tps, cnt);
+ } else {
+ return new CompositeTreePermissionOr(tree, type,
parentPermission.treeProvider, parentPermission.typeProvider, pvds, tps, cnt);
+ }
}
}
@@ -172,21 +178,7 @@ final class CompositeTreePermission impl
@Override
public boolean canReadProperties() {
if (canReadProperties == null) {
- boolean readable = false;
- for (int i = 0; i < providers.length; i++) {
- TreePermission tp = treePermissions[i];
- long supported = providers[i].supportedPermissions(tp, null,
Permissions.READ_PROPERTY);
- if (doEvaluate(supported)) {
- readable = tp.canReadProperties();
- if (!readable && compositionType == AND) {
- break;
- }
- if (readable && compositionType == OR) {
- break;
- }
- }
- }
- canReadProperties = readable;
+ canReadProperties = grantsReadProperties();
}
return canReadProperties;
}
@@ -201,23 +193,65 @@ final class CompositeTreePermission impl
return grantsPermission(permissions, property);
}
+
//---------------------------------------------------------------------------
+ @NotNull
+ abstract CompositionType getCompositionType();
+
+ abstract boolean grantsPermission(long permissions, @Nullable
PropertyState property);
+
+ abstract boolean grantsRead(@Nullable PropertyState property);
+
+ abstract boolean grantsReadProperties();
+
+
//---------------------------------------------------------------------------
+
+ int length() {
+ return providers.length;
+ }
+
+ @NotNull
+ AggregatedPermissionProvider provider(int index) {
+ return providers[index];
+ }
+
+ @NotNull
+ TreePermission treePermission(int index) {
+ return treePermissions[index];
+ }
+
//------------------------------------------------------------< private
>---
- private boolean grantsPermission(long permissions, @Nullable PropertyState
property) {
- boolean isGranted = false;
- long coveredPermissions = Permissions.NO_PERMISSION;
-
- for (int i = 0; i < providers.length; i++) {
- TreePermission tp = treePermissions[i];
- long supported = providers[i].supportedPermissions(tp, property,
permissions);
- if (doEvaluate(supported)) {
- if (compositionType == AND) {
- isGranted = (property == null) ? tp.isGranted(supported) :
tp.isGranted(supported, property);
- if (!isGranted) {
- return false;
- }
- coveredPermissions |= supported;
- } else {
+ private static boolean isValid(@NotNull TreePermission tp) {
+ return NO_RECOURSE != tp;
+ }
+
+ private static TreeType getType(@NotNull Tree tree, @NotNull
CompositeTreePermission parent) {
+ return parent.typeProvider.getType(tree, parent.type);
+ }
+
+ //---< OR
>-----------------------------------------------------------------
+
+ private static final class CompositeTreePermissionOr extends
CompositeTreePermission {
+
+ private CompositeTreePermissionOr(@NotNull Tree tree, @NotNull
TreeType type, @NotNull TreeProvider treeProvider, @NotNull TreeTypeProvider
typeProvider, @NotNull AggregatedPermissionProvider[] providers, @NotNull
TreePermission[] treePermissions, int cnt) {
+ super(tree, type, treeProvider, typeProvider, providers,
treePermissions, cnt);
+ }
+
+ @NotNull
+ @Override
+ CompositionType getCompositionType() {
+ return OR;
+ }
+
+ @Override
+ boolean grantsPermission(long permissions, @Nullable PropertyState
property) {
+ boolean isGranted = false;
+ long coveredPermissions = Permissions.NO_PERMISSION;
+
+ for (int i = 0; i < length(); i++) {
+ TreePermission tp = treePermission(i);
+ long supported = provider(i).supportedPermissions(tp,
property, permissions);
+ if (doEvaluate(supported)) {
for (long p : Permissions.aggregates(supported)) {
boolean aGrant = (property == null) ? tp.isGranted(p)
: tp.isGranted(p, property);
if (aGrant) {
@@ -227,40 +261,110 @@ final class CompositeTreePermission impl
}
}
}
+ return isGranted && coveredPermissions == permissions;
}
- return isGranted && coveredPermissions == permissions;
- }
- private boolean grantsRead(@Nullable PropertyState property) {
- if (property != null && canReadProperties()) {
- return true;
- }
- boolean readable = false;
- for (int i = 0; i < providers.length; i++) {
- TreePermission tp = treePermissions[i];
- long supported = providers[i].supportedPermissions(tp, property,
(property == null) ? Permissions.READ_NODE : Permissions.READ_PROPERTY);
- if (doEvaluate(supported)) {
- readable = (property == null) ? tp.canRead() :
tp.canRead(property);
- if (!readable && compositionType == AND) {
- return false;
+ @Override
+ boolean grantsRead(@Nullable PropertyState property) {
+ if (property != null && canReadProperties()) {
+ return true;
+ }
+ boolean readable = false;
+ for (int i = 0; i < length(); i++) {
+ TreePermission tp = treePermission(i);
+ long supported = provider(i).supportedPermissions(tp,
property, (property == null) ? Permissions.READ_NODE :
Permissions.READ_PROPERTY);
+ if (doEvaluate(supported)) {
+ readable = (property == null) ? tp.canRead() :
tp.canRead(property);
+ if (readable) {
+ return true;
+ }
}
- if (readable && compositionType == OR) {
- return true;
+ }
+ return readable;
+ }
+
+ @Override
+ boolean grantsReadProperties() {
+ boolean readable = false;
+ for (int i = 0; i < length(); i++) {
+ TreePermission tp = treePermission(i);
+ long supported = provider(i).supportedPermissions(tp, null,
Permissions.READ_PROPERTY);
+ if (doEvaluate(supported)) {
+ readable = tp.canReadProperties();
+ if (readable) {
+ break;
+ }
}
}
+ return readable;
}
- return readable;
}
- private static boolean doEvaluate(long supportedPermissions) {
- return supportedPermissions != Permissions.NO_PERMISSION;
- }
+ //---< AND
>----------------------------------------------------------------
- private static boolean isValid(@NotNull TreePermission tp) {
- return NO_RECOURSE != tp;
- }
+ private static final class CompositeTreePermissionAnd extends
CompositeTreePermission {
- private static TreeType getType(@NotNull Tree tree, @NotNull
CompositeTreePermission parent) {
- return parent.typeProvider.getType(tree, parent.type);
+ private CompositeTreePermissionAnd(@NotNull Tree tree, @NotNull
TreeType type,
+ @NotNull TreeProvider treeProvider,
+ @NotNull TreeTypeProvider
typeProvider, @NotNull AggregatedPermissionProvider[] providers,
+ @NotNull TreePermission[]
treePermissions, int cnt) {
+ super(tree, type, treeProvider, typeProvider, providers,
treePermissions, cnt);
+ }
+
+ @NotNull
+ CompositeAuthorizationConfiguration.CompositionType
getCompositionType() {
+ return AND;
+ }
+
+ boolean grantsPermission(long permissions, @Nullable PropertyState
property) {
+ boolean isGranted = false;
+ long coveredPermissions = Permissions.NO_PERMISSION;
+
+ for (int i = 0; i < length(); i++) {
+ TreePermission tp = treePermission(i);
+ long supported = provider(i).supportedPermissions(tp,
property, permissions);
+ if (doEvaluate(supported)) {
+ isGranted = (property == null) ? tp.isGranted(supported) :
tp.isGranted(supported, property);
+ if (!isGranted) {
+ return false;
+ }
+ coveredPermissions |= supported;
+ }
+ }
+ return isGranted && coveredPermissions == permissions;
+ }
+
+ boolean grantsRead(@Nullable PropertyState property) {
+ if (property != null && canReadProperties()) {
+ return true;
+ }
+ boolean readable = false;
+ for (int i = 0; i < length(); i++) {
+ TreePermission tp = treePermission(i);
+ long supported = provider(i).supportedPermissions(tp,
property, (property == null) ? Permissions.READ_NODE :
Permissions.READ_PROPERTY);
+ if (doEvaluate(supported)) {
+ readable = (property == null) ? tp.canRead() :
tp.canRead(property);
+ if (!readable) {
+ return false;
+ }
+ }
+ }
+ return readable;
+ }
+
+ boolean grantsReadProperties() {
+ boolean readable = false;
+ for (int i = 0; i < length(); i++) {
+ TreePermission tp = treePermission(i);
+ long supported = provider(i).supportedPermissions(tp, null,
Permissions.READ_PROPERTY);
+ if (doEvaluate(supported)) {
+ readable = tp.canReadProperties();
+ if (!readable) {
+ break;
+ }
+ }
+ }
+ return readable;
+ }
}
}
Added:
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/Util.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/Util.java?rev=1858410&view=auto
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/Util.java
(added)
+++
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/Util.java
Tue Apr 30 08:36:03 2019
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.jackrabbit.oak.security.authorization.composite;
+
+import
org.apache.jackrabbit.oak.spi.security.authorization.permission.Permissions;
+import org.apache.jackrabbit.oak.spi.security.privilege.PrivilegeBits;
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+final class Util {
+
+ private static final Logger log = LoggerFactory.getLogger(Util.class);
+
+ private Util() {}
+
+ static boolean doEvaluate(long supportedPermissions) {
+ return supportedPermissions != Permissions.NO_PERMISSION;
+ }
+
+ static boolean doEvaluate(@NotNull PrivilegeBits supportedPrivileges) {
+ return !supportedPrivileges.isEmpty();
+ }
+}
\ No newline at end of file
Propchange:
jackrabbit/oak/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/security/authorization/composite/Util.java
------------------------------------------------------------------------------
svn:eol-style = native
Modified:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/AbstractCompositeProviderTest.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/AbstractCompositeProviderTest.java?rev=1858410&r1=1858409&r2=1858410&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/AbstractCompositeProviderTest.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/AbstractCompositeProviderTest.java
Tue Apr 30 08:36:03 2019
@@ -30,7 +30,6 @@ import org.apache.jackrabbit.oak.api.Tre
import org.apache.jackrabbit.oak.commons.PathUtils;
import org.apache.jackrabbit.oak.plugins.memory.PropertyStates;
import org.apache.jackrabbit.oak.plugins.tree.TreeUtil;
-import
org.apache.jackrabbit.oak.security.authorization.composite.CompositeAuthorizationConfiguration.CompositionType;
import org.apache.jackrabbit.oak.spi.nodetype.NodeTypeConstants;
import
org.apache.jackrabbit.oak.spi.security.authorization.AuthorizationConfiguration;
import
org.apache.jackrabbit.oak.spi.security.authorization.permission.AggregatedPermissionProvider;
@@ -252,8 +251,8 @@ public abstract class AbstractCompositeP
CompositePermissionProvider createPermissionProvider(Set<Principal>
principals) {
String workspaceName = root.getContentSession().getWorkspaceName();
AuthorizationConfiguration config =
getConfig(AuthorizationConfiguration.class);
- return new CompositePermissionProvider(root,
getAggregatedProviders(workspaceName, config, principals),
- config.getContext(), CompositionType.AND, getRootProvider(),
getTreeProvider());
+ return new CompositePermissionProviderAnd(root,
getAggregatedProviders(workspaceName, config, principals),
+ config.getContext(), getRootProvider(), getTreeProvider());
}
CompositePermissionProvider createPermissionProviderOR(Principal...
principals) {
@@ -263,8 +262,8 @@ public abstract class AbstractCompositeP
CompositePermissionProvider createPermissionProviderOR(Set<Principal>
principals) {
String workspaceName = root.getContentSession().getWorkspaceName();
AuthorizationConfiguration config =
getConfig(AuthorizationConfiguration.class);
- return new CompositePermissionProvider(root,
getAggregatedProviders(workspaceName, config, principals),
- config.getContext(), CompositionType.OR, getRootProvider(),
getTreeProvider());
+ return new CompositePermissionProviderOr(root,
getAggregatedProviders(workspaceName, config, principals),
+ config.getContext(), getRootProvider(), getTreeProvider());
}
@Test
Modified:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderCustomMixTest.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderCustomMixTest.java?rev=1858410&r1=1858409&r2=1858410&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderCustomMixTest.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderCustomMixTest.java
Tue Apr 30 08:36:03 2019
@@ -234,7 +234,7 @@ public class CompositeProviderCustomMixT
AuthorizationConfiguration config =
getConfig(AuthorizationConfiguration.class);
List<AggregatedPermissionProvider> composite = ImmutableList.of(a1,
a2);
- return new CompositePermissionProvider(root, composite,
config.getContext(), type, getRootProvider(), getTreeProvider());
+ return CompositePermissionProvider.create(root, composite,
config.getContext(), type, getRootProvider(), getTreeProvider());
}
private static class CustomProvider implements
AggregatedPermissionProvider {
Modified:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderGetTreePermissionTest.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderGetTreePermissionTest.java?rev=1858410&r1=1858409&r2=1858410&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderGetTreePermissionTest.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderGetTreePermissionTest.java
Tue Apr 30 08:36:03 2019
@@ -47,7 +47,7 @@ public class CompositeProviderGetTreePer
private CompositePermissionProvider createProvider(@NotNull
CompositeAuthorizationConfiguration.CompositionType compositionType,
@NotNull
AggregatedPermissionProvider... providers) {
- return new CompositePermissionProvider(root,
ImmutableList.copyOf(providers), Context.DEFAULT, compositionType,
getRootProvider(), getTreeProvider());
+ return CompositePermissionProvider.create(root,
ImmutableList.copyOf(providers), Context.DEFAULT, compositionType,
getRootProvider(), getTreeProvider());
}
@Test
Modified:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderSupportedTest.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderSupportedTest.java?rev=1858410&r1=1858409&r2=1858410&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderSupportedTest.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/authorization/composite/CompositeProviderSupportedTest.java
Tue Apr 30 08:36:03 2019
@@ -89,7 +89,7 @@ public class CompositeProviderSupportedT
}
private CompositePermissionProvider createProvider(@NotNull
CompositeAuthorizationConfiguration.CompositionType compositionType, @NotNull
AggregatedPermissionProvider... aggregated) {
- return new CompositePermissionProvider(root,
ImmutableList.copyOf(aggregated), Context.DEFAULT, compositionType,
getRootProvider(), getTreeProvider());
+ return CompositePermissionProvider.create(root,
ImmutableList.copyOf(aggregated), Context.DEFAULT, compositionType,
getRootProvider(), getTreeProvider());
}
@Test
