LdifUserAdmin.java

   1 package org.argeo.osgi.useradmin;
   2
   3 import java.io.File;
   4 import java.io.FileOutputStream;
   5 import java.io.IOException;
   6 import java.io.InputStream;
   7 import java.io.OutputStream;
   8 import java.util.ArrayList;
   9 import java.util.Dictionary;
  10 import java.util.Hashtable;
  11 import java.util.LinkedHashMap;
  12 import java.util.List;
  13 import java.util.Map;
  14 import java.util.SortedMap;
  15 import java.util.TreeMap;
  16
  17 import javax.naming.InvalidNameException;
  18 import javax.naming.NamingEnumeration;
  19 import javax.naming.directory.Attributes;
  20 import javax.naming.ldap.LdapName;
  21
  22 import org.apache.commons.io.IOUtils;
  23 import org.osgi.framework.Filter;
  24 import org.osgi.service.useradmin.Role;
  25 import org.osgi.service.useradmin.User;
  26
  27 /** User admin implementation using LDIF file(s) as backend. */
  28 public class LdifUserAdmin extends AbstractUserDirectory {
  29         SortedMap<LdapName, DirectoryUser> users = new TreeMap<LdapName, DirectoryUser>();
  30         SortedMap<LdapName, DirectoryGroup> groups = new TreeMap<LdapName, DirectoryGroup>();
  31
  32         private Map<String, Map<String, DirectoryUser>> userIndexes = new LinkedHashMap<String, Map<String, DirectoryUser>>();
  33
  34         public LdifUserAdmin(String uri, String baseDn) {
  35                 this(fromUri(uri, baseDn));
  36         }
  37
  38         public LdifUserAdmin(Dictionary<String, ?> properties) {
  39                 super(properties);
  40         }
  41
  42         public LdifUserAdmin(InputStream in) {
  43                 super(new Hashtable<String, Object>());
  44                 load(in);
  45                 setReadOnly(true);
  46                 setUri(null);
  47         }
  48
  49         private static Dictionary<String, Object> fromUri(String uri, String baseDn) {
  50                 Hashtable<String, Object> res = new Hashtable<String, Object>();
  51                 res.put(LdapProperties.uri.getFullName(), uri);
  52                 res.put(LdapProperties.baseDn.getFullName(), baseDn);
  53                 return res;
  54         }
  55
  56         public void init() {
  57                 try {
  58                         if (getUri().getScheme().equals("file")) {
  59                                 File file = new File(getUri());
  60                                 if (!file.exists())
  61                                         return;
  62                         }
  63                         load(getUri().toURL().openStream());
  64                 } catch (Exception e) {
  65                         throw new UserDirectoryException("Cannot open URL " + getUri(), e);
  66                 }
  67         }
  68
  69         public void save() {
  70                 if (getUri() == null || isReadOnly())
  71                         throw new UserDirectoryException("Cannot save LDIF user admin");
  72                 try (FileOutputStream out = new FileOutputStream(new File(getUri()))) {
  73                         save(out);
  74                 } catch (IOException e) {
  75                         throw new UserDirectoryException("Cannot save user admin to "
  76                                         + getUri(), e);
  77                 }
  78         }
  79
  80         public void save(OutputStream out) throws IOException {
  81                 try {
  82                         LdifWriter ldifWriter = new LdifWriter(out);
  83                         for (LdapName name : groups.keySet())
  84                                 ldifWriter.writeEntry(name, groups.get(name).getAttributes());
  85                         for (LdapName name : users.keySet())
  86                                 ldifWriter.writeEntry(name, users.get(name).getAttributes());
  87                 } finally {
  88                         IOUtils.closeQuietly(out);
  89                 }
  90         }
  91
  92         protected void load(InputStream in) {
  93                 try {
  94                         users.clear();
  95                         groups.clear();
  96
  97                         LdifParser ldifParser = new LdifParser();
  98                         SortedMap<LdapName, Attributes> allEntries = ldifParser.read(in);
  99                         for (LdapName key : allEntries.keySet()) {
 100                                 Attributes attributes = allEntries.get(key);
 101                                 NamingEnumeration<?> objectClasses = attributes.get(
 102                                                 "objectClass").getAll();
 103                                 objectClasses: while (objectClasses.hasMore()) {
 104                                         String objectClass = objectClasses.next().toString();
 105                                         if (objectClass.equals("inetOrgPerson")) {
 106                                                 users.put(key, new LdifUser(this, key, attributes));
 107                                                 break objectClasses;
 108                                         } else if (objectClass.equals("groupOfNames")) {
 109                                                 groups.put(key, new LdifGroup(this, key, attributes));
 110                                                 break objectClasses;
 111                                         }
 112                                 }
 113                         }
 114
 115                         // optimise
 116                         // for (LdifGroup group : groups.values())
 117                         // loadMembers(group);
 118
 119                         // indexes
 120                         for (String attr : getIndexedUserProperties())
 121                                 userIndexes.put(attr, new TreeMap<String, DirectoryUser>());
 122
 123                         for (DirectoryUser user : users.values()) {
 124                                 Dictionary<String, Object> properties = user.getProperties();
 125                                 for (String attr : getIndexedUserProperties()) {
 126                                         Object value = properties.get(attr);
 127                                         if (value != null) {
 128                                                 DirectoryUser otherUser = userIndexes.get(attr).put(
 129                                                                 value.toString(), user);
 130                                                 if (otherUser != null)
 131                                                         throw new UserDirectoryException("User " + user
 132                                                                         + " and user " + otherUser
 133                                                                         + " both have property " + attr
 134                                                                         + " set to " + value);
 135                                         }
 136                                 }
 137                         }
 138                 } catch (Exception e) {
 139                         throw new UserDirectoryException(
 140                                         "Cannot load user admin service from LDIF", e);
 141                 }
 142         }
 143
 144         public void destroy() {
 145                 users.clear();
 146                 users = null;
 147                 groups.clear();
 148                 groups = null;
 149         }
 150
 151         protected DirectoryUser daoGetRole(LdapName key) {
 152                 if (groups.containsKey(key))
 153                         return groups.get(key);
 154                 if (users.containsKey(key))
 155                         return users.get(key);
 156                 return null;
 157         }
 158
 159         protected Boolean daoHasRole(LdapName dn) {
 160                 return users.containsKey(dn) || groups.containsKey(dn);
 161         }
 162
 163         // @Override
 164         // public boolean removeRole(String name) {
 165         // LdapName dn = toDn(name);
 166         // LdifUser role = null;
 167         // if (users.containsKey(dn))
 168         // role = users.remove(dn);
 169         // else if (groups.containsKey(dn))
 170         // role = groups.remove(dn);
 171         // else
 172         // throw new UserDirectoryException("There is no role " + name);
 173         // if (role == null)
 174         // return false;
 175         // for (LdifGroup group : getDirectGroups(role)) {
 176         // group.getAttributes().get(getMemberAttributeId())
 177         // .remove(dn.toString());
 178         // }
 179         // return true;
 180         // }
 181
 182         protected List<DirectoryUser> doGetRoles(Filter f) {
 183                 ArrayList<DirectoryUser> res = new ArrayList<DirectoryUser>();
 184                 if (f == null) {
 185                         res.addAll(users.values());
 186                         res.addAll(groups.values());
 187                 } else {
 188                         // Filter f = FrameworkUtil.createFilter(filter);
 189                         for (DirectoryUser user : users.values())
 190                                 if (f.match(user.getProperties()))
 191                                         res.add(user);
 192                         for (DirectoryUser group : groups.values())
 193                                 if (f.match(group.getProperties()))
 194                                         res.add(group);
 195                 }
 196                 return res;
 197         }
 198
 199         protected void doGetUser(String key, String value,
 200                         List<DirectoryUser> collectedUsers) {
 201                 assert key != null;
 202                 DirectoryUser user = userIndexes.get(key).get(value);
 203                 if (user != null)
 204                         collectedUsers.add(user);
 205         }
 206
 207         @Override
 208         protected List<DirectoryGroup> getDirectGroups(User user) {
 209                 LdapName dn;
 210                 if (user instanceof LdifUser)
 211                         dn = ((LdifUser) user).getDn();
 212                 else
 213                         try {
 214                                 dn = new LdapName(user.getName());
 215                         } catch (InvalidNameException e) {
 216                                 throw new UserDirectoryException("Badly formatted user name "
 217                                                 + user.getName(), e);
 218                         }
 219
 220                 List<DirectoryGroup> directGroups = new ArrayList<DirectoryGroup>();
 221                 for (LdapName name : groups.keySet()) {
 222                         DirectoryGroup group = groups.get(name);
 223                         if (group.getMemberNames().contains(dn))
 224                                 directGroups.add(group);
 225                 }
 226                 return directGroups;
 227         }
 228
 229         @Override
 230         protected void prepare(WorkingCopy wc) {
 231                 // delete
 232                 for (LdapName dn : wc.getDeletedUsers().keySet()) {
 233                         if (users.containsKey(dn))
 234                                 users.remove(dn);
 235                         else if (groups.containsKey(dn))
 236                                 groups.remove(dn);
 237                         else
 238                                 throw new UserDirectoryException("User to delete no found "
 239                                                 + dn);
 240                 }
 241                 // add
 242                 for (LdapName dn : wc.getNewUsers().keySet()) {
 243                         DirectoryUser user = wc.getNewUsers().get(dn);
 244                         if (Role.USER == user.getType())
 245                                 users.put(dn, user);
 246                         else if (Role.GROUP == user.getType())
 247                                 groups.put(dn, (DirectoryGroup) user);
 248                         else
 249                                 throw new UserDirectoryException("Unsupported role type "
 250                                                 + user.getType() + " for new user " + dn);
 251                 }
 252                 // modify
 253                 for (LdapName dn : wc.getModifiedUsers().keySet()) {
 254                         Attributes modifiedAttrs = wc.getModifiedUsers().get(dn);
 255                         DirectoryUser user;
 256                         if (users.containsKey(dn))
 257                                 user = users.get(dn);
 258                         else if (groups.containsKey(dn))
 259                                 user = groups.get(dn);
 260                         else
 261                                 throw new UserDirectoryException("User to modify no found "
 262                                                 + dn);
 263                         user.publishAttributes(modifiedAttrs);
 264                 }
 265         }
 266
 267         @Override
 268         protected void commit(WorkingCopy wc) {
 269                 save();
 270         }
 271
 272         @Override
 273         protected void rollback(WorkingCopy wc) {
 274                 init();
 275         }
 276
 277 }