server/runtime/org.argeo.server.jackrabbit/src/main/java/org/argeo/jackrabbit/remote/SimpleSessionProvider.java

   1 /*
   2  * Copyright (C) 2007-2012 Mathieu Baudier
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.argeo.jackrabbit.remote;
  17
  18 import java.io.Serializable;
  19 import java.util.ArrayList;
  20 import java.util.Collections;
  21 import java.util.HashMap;
  22 import java.util.Iterator;
  23 import java.util.List;
  24 import java.util.Map;
  25
  26 import javax.jcr.LoginException;
  27 import javax.jcr.Node;
  28 import javax.jcr.Repository;
  29 import javax.jcr.RepositoryException;
  30 import javax.jcr.Session;
  31 import javax.jcr.Value;
  32 import javax.servlet.ServletException;
  33 import javax.servlet.http.HttpServletRequest;
  34
  35 import org.apache.commons.logging.Log;
  36 import org.apache.commons.logging.LogFactory;
  37 import org.apache.jackrabbit.api.JackrabbitSession;
  38 import org.apache.jackrabbit.api.security.user.Group;
  39 import org.apache.jackrabbit.api.security.user.User;
  40 import org.apache.jackrabbit.api.security.user.UserManager;
  41 import org.apache.jackrabbit.server.SessionProvider;
  42 import org.argeo.ArgeoException;
  43 import org.argeo.jcr.ArgeoNames;
  44 import org.argeo.jcr.JcrUtils;
  45
  46 /**
  47  * Implements an open session in view patter: a new JCR session is created for
  48  * each request
  49  */
  50 public class SimpleSessionProvider implements SessionProvider, Serializable {
  51         private static final long serialVersionUID = 2270957712453841368L;
  52
  53         private final static Log log = LogFactory
  54                         .getLog(SimpleSessionProvider.class);
  55
  56         private transient Map<String, Session> sessions;
  57
  58         private Boolean openSessionInView = true;
  59
  60         private String securityWorkspace = "security";
  61
  62         public Session getSession(HttpServletRequest request, Repository rep,
  63                         String workspace) throws LoginException, ServletException,
  64                         RepositoryException {
  65
  66                 if (openSessionInView) {
  67                         JackrabbitSession session = (JackrabbitSession) rep
  68                                         .login(workspace);
  69                         if (session.getWorkspace().getName().equals(securityWorkspace))
  70                                 writeRemoteRoles(session);
  71                         return session;
  72                 } else {
  73                         // since sessions is transient it can't be restored from the session
  74                         if (sessions == null)
  75                                 sessions = Collections
  76                                                 .synchronizedMap(new HashMap<String, Session>());
  77
  78                         if (!sessions.containsKey(workspace)) {
  79                                 try {
  80                                         JackrabbitSession session = (JackrabbitSession) rep.login(
  81                                                         null, workspace);
  82                                         if (session.getWorkspace().getName()
  83                                                         .equals(securityWorkspace))
  84                                                 writeRemoteRoles(session);
  85                                         if (log.isTraceEnabled())
  86                                                 log.trace("User " + session.getUserID()
  87                                                                 + " logged into " + request.getServletPath());
  88                                         sessions.put(workspace, session);
  89                                         return session;
  90                                 } catch (Exception e) {
  91                                         throw new ArgeoException("Cannot open session", e);
  92                                 }
  93                         } else {
  94                                 Session session = sessions.get(workspace);
  95                                 if (!session.isLive()) {
  96                                         sessions.remove(workspace);
  97                                         session = rep.login(null, workspace);
  98                                         sessions.put(workspace, session);
  99                                 }
 100                                 return session;
 101                         }
 102                 }
 103         }
 104
 105         protected void writeRemoteRoles(JackrabbitSession session)
 106                         throws RepositoryException {
 107                 // retrieve roles
 108                 String userId = session.getUserID();
 109                 UserManager userManager = session.getUserManager();
 110                 User user = (User) userManager.getAuthorizable(userId);
 111                 if (user == null) {
 112                         // anonymous
 113                         return;
 114                 }
 115                 List<String> userGroupIds = new ArrayList<String>();
 116                 if (user != null)
 117                         for (Iterator<Group> it = user.memberOf(); it.hasNext();)
 118                                 userGroupIds.add(it.next().getID());
 119
 120                 // write roles if needed
 121                 Node userProfile = JcrUtils.getUserHome(session).getNode(
 122                                 ArgeoNames.ARGEO_PROFILE);
 123                 boolean writeRoles = false;
 124                 if (userProfile.hasProperty(ArgeoNames.ARGEO_REMOTE_ROLES)) {
 125                         Value[] roles = userProfile.getProperty(
 126                                         ArgeoNames.ARGEO_REMOTE_ROLES).getValues();
 127                         if (roles.length != userGroupIds.size())
 128                                 writeRoles = true;
 129                         else
 130                                 for (int i = 0; i < roles.length; i++)
 131                                         if (!roles[i].getString().equals(userGroupIds.get(i)))
 132                                                 writeRoles = true;
 133                 } else
 134                         writeRoles = true;
 135
 136                 if (writeRoles) {
 137                         session.getWorkspace().getVersionManager()
 138                                         .checkout(userProfile.getPath());
 139                         String[] roleIds = userGroupIds.toArray(new String[userGroupIds
 140                                         .size()]);
 141                         userProfile.setProperty(ArgeoNames.ARGEO_REMOTE_ROLES, roleIds);
 142                         JcrUtils.updateLastModified(userProfile);
 143                         session.save();
 144                         session.getWorkspace().getVersionManager()
 145                                         .checkin(userProfile.getPath());
 146                 }
 147
 148         }
 149
 150         public void releaseSession(Session session) {
 151                 if (log.isTraceEnabled())
 152                         log.trace("Releasing JCR session " + session);
 153                 if (openSessionInView) {
 154                         if (session.isLive()) {
 155                                 session.logout();
 156                                 if (log.isTraceEnabled())
 157                                         log.trace("Logged out remote JCR session " + session);
 158                         }
 159                 }
 160         }
 161
 162         public void init() {
 163         }
 164
 165         public void destroy() {
 166                 if (sessions != null)
 167                         for (String workspace : sessions.keySet()) {
 168                                 Session session = sessions.get(workspace);
 169                                 if (session.isLive()) {
 170                                         session.logout();
 171                                         if (log.isDebugEnabled())
 172                                                 log.debug("Logged out remote JCR session " + session);
 173                                 }
 174                         }
 175         }
 176
 177         /**
 178          * If set to true a new session will be created each time (the default),
 179          * otherwise a single session is cached by workspace and the object should
 180          * be of scope session (not supported)
 181          */
 182         public void setOpenSessionInView(Boolean openSessionInView) {
 183                 this.openSessionInView = openSessionInView;
 184         }
 185
 186         public void setSecurityWorkspace(String securityWorkspace) {
 187                 this.securityWorkspace = securityWorkspace;
 188         }
 189
 190 }