Disable OSGi configuration admin and LDIF-based deploy config.

[lgpl/argeo-commons.git] / org.argeo.util / src / org / argeo / osgi / useradmin / AggregatingUserAdmin.java

diff --git a/org.argeo.util/src/org/argeo/osgi/useradmin/AggregatingUserAdmin.java b/org.argeo.util/src/org/argeo/osgi/useradmin/AggregatingUserAdmin.java
index 5613c28484ac4dff444505d5b96f3e1ab6e74434..79d2bd3cbc2f21142f1801a1df5c5fbc307c2095 100644 (file)
--- a/org.argeo.util/src/org/argeo/osgi/useradmin/AggregatingUserAdmin.java
+++ b/org.argeo.util/src/org/argeo/osgi/useradmin/AggregatingUserAdmin.java
@@ -1,6 +1,6 @@
 package org.argeo.osgi.useradmin;
 
-import static org.argeo.osgi.useradmin.AbstractUserDirectory.toLdapName;
+import static org.argeo.osgi.useradmin.DirectoryUserAdmin.toLdapName;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -9,6 +9,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.TreeSet;
 
 import javax.naming.InvalidNameException;
 import javax.naming.ldap.LdapName;
@@ -29,9 +30,9 @@ public class AggregatingUserAdmin implements UserAdmin {
        private final LdapName tokensBaseDn;
 
        // DAOs
-       private AbstractUserDirectory systemRoles = null;
-       private AbstractUserDirectory tokens = null;
-       private Map<LdapName, AbstractUserDirectory> businessRoles = new HashMap<LdapName, AbstractUserDirectory>();
+       private DirectoryUserAdmin systemRoles = null;
+       private DirectoryUserAdmin tokens = null;
+       private Map<LdapName, DirectoryUserAdmin> businessRoles = new HashMap<LdapName, DirectoryUserAdmin>();
 
        // TODO rather use an empty constructor and an init method
        public AggregatingUserAdmin(String systemRolesBaseDn, String tokensBaseDn) {
@@ -42,7 +43,7 @@ public class AggregatingUserAdmin implements UserAdmin {
                        else
                                this.tokensBaseDn = null;
                } catch (InvalidNameException e) {
-                       throw new UserDirectoryException("Cannot initialize " + AggregatingUserAdmin.class, e);
+                       throw new IllegalStateException("Cannot initialize " + AggregatingUserAdmin.class, e);
                }
        }
 
@@ -90,7 +91,7 @@ public class AggregatingUserAdmin implements UserAdmin {
                if (user == null) {// anonymous
                        return systemRoles.getAuthorization(null);
                }
-               AbstractUserDirectory userReferentialOfThisUser = findUserAdmin(user.getName());
+               DirectoryUserAdmin userReferentialOfThisUser = findUserAdmin(user.getName());
                Authorization rawAuthorization = userReferentialOfThisUser.getAuthorization(user);
                String usernameToUse;
                String displayNameToUse;
@@ -112,11 +113,11 @@ public class AggregatingUserAdmin implements UserAdmin {
                }
 
                // gather roles from other referentials
-               final AbstractUserDirectory userAdminToUse;// possibly scoped when authenticating
+               final DirectoryUserAdmin userAdminToUse;// possibly scoped when authenticating
                if (user instanceof DirectoryUser) {
                        userAdminToUse = userReferentialOfThisUser;
                } else if (user instanceof AuthenticatingUser) {
-                       userAdminToUse = userReferentialOfThisUser.scope(user);
+                       userAdminToUse = (DirectoryUserAdmin) userReferentialOfThisUser.scope(user);
                } else {
                        throw new IllegalArgumentException("Unsupported user type " + user.getClass());
                }
@@ -156,10 +157,10 @@ public class AggregatingUserAdmin implements UserAdmin {
        // USER ADMIN AGGREGATOR
        //
        protected void addUserDirectory(UserDirectory ud) {
-               if (!(ud instanceof AbstractUserDirectory))
-                       throw new IllegalArgumentException("Only " + AbstractUserDirectory.class.getName() + " is supported");
-               AbstractUserDirectory userDirectory = (AbstractUserDirectory) ud;
-               String basePath = userDirectory.getBasePath();
+               if (!(ud instanceof DirectoryUserAdmin))
+                       throw new IllegalArgumentException("Only " + DirectoryUserAdmin.class.getName() + " is supported");
+               DirectoryUserAdmin userDirectory = (DirectoryUserAdmin) ud;
+               String basePath = userDirectory.getContext();
                if (isSystemRolesBaseDn(basePath)) {
                        this.systemRoles = userDirectory;
                        systemRoles.setExternalRoles(this);
@@ -169,7 +170,7 @@ public class AggregatingUserAdmin implements UserAdmin {
                } else {
                        LdapName baseDn = toLdapName(basePath);
                        if (businessRoles.containsKey(baseDn))
-                               throw new UserDirectoryException("There is already a user admin for " + baseDn);
+                               throw new IllegalStateException("There is already a user admin for " + baseDn);
                        businessRoles.put(baseDn, userDirectory);
                }
                userDirectory.init();
@@ -180,22 +181,22 @@ public class AggregatingUserAdmin implements UserAdmin {
        protected void postAdd(UserDirectory userDirectory) {
        }
 
-       private AbstractUserDirectory findUserAdmin(String name) {
+       private DirectoryUserAdmin findUserAdmin(String name) {
                try {
                        return findUserAdmin(new LdapName(name));
                } catch (InvalidNameException e) {
-                       throw new UserDirectoryException("Badly formatted name " + name, e);
+                       throw new IllegalArgumentException("Badly formatted name " + name, e);
                }
        }
 
-       private AbstractUserDirectory findUserAdmin(LdapName name) {
+       private DirectoryUserAdmin findUserAdmin(LdapName name) {
                if (name.startsWith(systemRolesBaseDn))
                        return systemRoles;
                if (tokensBaseDn != null && name.startsWith(tokensBaseDn))
                        return tokens;
-               List<AbstractUserDirectory> res = new ArrayList<>(1);
+               List<DirectoryUserAdmin> res = new ArrayList<>(1);
                userDirectories: for (LdapName baseDn : businessRoles.keySet()) {
-                       AbstractUserDirectory userDirectory = businessRoles.get(baseDn);
+                       DirectoryUserAdmin userDirectory = businessRoles.get(baseDn);
                        if (name.startsWith(baseDn)) {
                                if (userDirectory.isDisabled())
                                        continue userDirectories;
@@ -212,9 +213,9 @@ public class AggregatingUserAdmin implements UserAdmin {
                        }
                }
                if (res.size() == 0)
-                       throw new UserDirectoryException("Cannot find user admin for " + name);
+                       throw new IllegalStateException("Cannot find user admin for " + name);
                if (res.size() > 1)
-                       throw new UserDirectoryException("Multiple user admin found for " + name);
+                       throw new IllegalStateException("Multiple user admin found for " + name);
                return res.get(0);
        }
 
@@ -237,9 +238,13 @@ public class AggregatingUserAdmin implements UserAdmin {
 //             return res;
 //     }
 
-       public void destroy() {
+       public void start() {
+
+       }
+
+       public void stop() {
                for (LdapName name : businessRoles.keySet()) {
-                       AbstractUserDirectory userDirectory = businessRoles.get(name);
+                       DirectoryUserAdmin userDirectory = businessRoles.get(name);
                        destroy(userDirectory);
                }
                businessRoles.clear();
@@ -248,18 +253,26 @@ public class AggregatingUserAdmin implements UserAdmin {
                systemRoles = null;
        }
 
-       private void destroy(AbstractUserDirectory userDirectory) {
+       private void destroy(DirectoryUserAdmin userDirectory) {
                preDestroy(userDirectory);
                userDirectory.destroy();
        }
 
+//     protected void removeUserDirectory(UserDirectory userDirectory) {
+//             LdapName baseDn = toLdapName(userDirectory.getContext());
+//             businessRoles.remove(baseDn);
+//             if (userDirectory instanceof DirectoryUserAdmin)
+//                     destroy((DirectoryUserAdmin) userDirectory);
+//     }
+
+       @Deprecated
        protected void removeUserDirectory(String basePath) {
                if (isSystemRolesBaseDn(basePath))
-                       throw new UserDirectoryException("System roles cannot be removed ");
+                       throw new IllegalArgumentException("System roles cannot be removed ");
                LdapName baseDn = toLdapName(basePath);
                if (!businessRoles.containsKey(baseDn))
-                       throw new UserDirectoryException("No user directory registered for " + baseDn);
-               AbstractUserDirectory userDirectory = businessRoles.remove(baseDn);
+                       throw new IllegalStateException("No user directory registered for " + baseDn);
+               DirectoryUserAdmin userDirectory = businessRoles.remove(baseDn);
                destroy(userDirectory);
        }
 
@@ -270,4 +283,11 @@ public class AggregatingUserAdmin implements UserAdmin {
        protected void preDestroy(UserDirectory userDirectory) {
        }
 
+       public Set<UserDirectory> getUserDirectories() {
+               TreeSet<UserDirectory> res = new TreeSet<>((o1, o2) -> o1.getContext().compareTo(o2.getContext()));
+               res.addAll(businessRoles.values());
+               res.add(systemRoles);
+               return res;
+       }
+
 }