git.aero2k.de Git - tmp/jakarta-migration.git/blob

   1 /**
   2  *  This document is a part of the source code and related artifacts
   3  *  for CollectionSpace, an open source collections management system
   4  *  for museums and related institutions:
   5
   6  *  http://www.collectionspace.org
   7  *  http://wiki.collectionspace.org
   8
   9  *  Copyright 2009 University of California at Berkeley
  10
  11  *  Licensed under the Educational Community License (ECL), Version 2.0.
  12  *  You may not use this file except in compliance with this License.
  13
  14  *  You may obtain a copy of the ECL 2.0 License at
  15
  16  *  https://source.collectionspace.org/collection-space/LICENSE.txt
  17
  18  *  Unless required by applicable law or agreed to in writing, software
  19  *  distributed under the License is distributed on an "AS IS" BASIS,
  20  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  21  *  See the License for the specific language governing permissions and
  22  *  limitations under the License.
  23  */
  24 package org.collectionspace.services.authorization.importer;
  25
  26 import java.io.File;
  27 import org.slf4j.Logger;
  28 import org.slf4j.LoggerFactory;
  29 import java.util.ArrayList;
  30 import java.util.Date;
  31 import java.util.Hashtable;
  32 import java.util.List;
  33 import java.util.UUID;
  34 import javax.xml.bind.JAXBContext;
  35 import javax.xml.bind.Marshaller;
  36 import org.collectionspace.services.authorization.ActionType;
  37 import org.collectionspace.services.authorization.Permission;
  38 import org.collectionspace.services.authorization.EffectType;
  39 import org.collectionspace.services.authorization.PermissionAction;
  40 import org.collectionspace.services.authorization.PermissionRole;
  41 import org.collectionspace.services.authorization.PermissionValue;
  42 import org.collectionspace.services.authorization.PermissionsList;
  43 import org.collectionspace.services.authorization.PermissionsRolesList;
  44 import org.collectionspace.services.authorization.Role;
  45 import org.collectionspace.services.authorization.RoleValue;
  46 import org.collectionspace.services.authorization.RolesList;
  47 import org.collectionspace.services.authorization.SubjectType;
  48 import org.collectionspace.services.common.config.TenantBindingConfigReaderImpl;
  49 import org.collectionspace.services.common.service.ServiceBindingType;
  50 import org.collectionspace.services.common.tenant.TenantBindingType;
  51 import org.collectionspace.services.common.security.SecurityUtils;
  52
  53 /**
  54  * AuthorizationGen generates authorizations (permissions and roles)
  55  * for tenant services
  56  * @author
  57  */
  58 public class AuthorizationGen {
  59
  60     final public static String ROLE_ADMINISTRATOR = "ROLE_ADMINISTRATOR";
  61     final public static String ROLE_TENANT_ADMINISTRATOR = "ROLE_TENANT_ADMINISTRATOR";
  62     final public static String ROLE_TENANT_READER = "ROLE_TENANT_READER";
  63     final public static String ROLE_ADMINISTRATOR_ID = "0";
  64     final Logger logger = LoggerFactory.getLogger(AuthorizationGen.class);
  65     private List<Permission> adminPermList = new ArrayList<Permission>();
  66     private List<PermissionRole> adminPermRoleList = new ArrayList<PermissionRole>();
  67     private List<Permission> readerPermList = new ArrayList<Permission>();
  68     private List<PermissionRole> readerPermRoleList = new ArrayList<PermissionRole>();
  69     private List<Role> adminRoles = new ArrayList<Role>();
  70     private List<Role> readerRoles = new ArrayList<Role>();
  71     private Role cspaceAdminRole;
  72     private Hashtable<String, TenantBindingType> tenantBindings =
  73             new Hashtable<String, TenantBindingType>();
  74
  75     public void initialize(String tenantBindingFileName) throws Exception {
  76         TenantBindingConfigReaderImpl tenantBindingConfigReader =
  77                 new TenantBindingConfigReaderImpl(null);
  78         tenantBindingConfigReader.read(tenantBindingFileName);
  79         tenantBindings = tenantBindingConfigReader.getTenantBindings();
  80         cspaceAdminRole = buildCSpaceAdminRole();
  81
  82         if (logger.isDebugEnabled()) {
  83             logger.debug("initialized with tenant bindings from " + tenantBindingFileName);
  84         }
  85     }
  86
  87     /**
  88      * createDefaultPermissions creates default admin and reader permissions
  89      * for each tenant found in the given tenant binding file
  90      * @see initialize
  91      * @return
  92      */
  93     public void createDefaultPermissions() {
  94         for (String tenantId : tenantBindings.keySet()) {
  95             List<Permission> adminPerms = createDefaultAdminPermissions(tenantId);
  96             adminPermList.addAll(adminPerms);
  97
  98             List<Permission> readerPerms = createDefaultReaderPermissions(tenantId);
  99             readerPermList.addAll(readerPerms);
 100         }
 101     }
 102
 103     /**
 104      * createDefaultAdminPermissions creates default admin permissions for all services
 105      * used by the given tenant
 106      * @param tenantId
 107      * @return
 108      */
 109     public List<Permission> createDefaultAdminPermissions(String tenantId) {
 110         ArrayList<Permission> apcList = new ArrayList<Permission>();
 111         TenantBindingType tbinding = tenantBindings.get(tenantId);
 112         for (ServiceBindingType sbinding : tbinding.getServiceBindings()) {
 113
 114             //add permissions for the main path
 115                 String resourceName = sbinding.getName().toLowerCase().trim();
 116                 if (SecurityUtils.isEntityProxy() == true) {
 117                         resourceName = SecurityUtils.getResourceEntity(resourceName);
 118                 }
 119             Permission perm = buildAdminPermission(tbinding.getId(),
 120                     resourceName);
 121             apcList.add(perm);
 122
 123             //add permissions for alternate paths
 124             if (SecurityUtils.isEntityProxy() == false) {
 125                     List<String> uriPaths = sbinding.getUriPath();
 126                     for (String uriPath : uriPaths) {
 127                         perm = buildAdminPermission(tbinding.getId(),
 128                                 uriPath.toLowerCase());
 129                         apcList.add(perm);
 130                     }
 131             }
 132         }
 133
 134         return apcList;
 135     }
 136
 137     private Permission buildAdminPermission(String tenantId, String resourceName) {
 138         String id = UUID.randomUUID().toString();
 139         Permission perm = new Permission();
 140         perm.setCsid(id);
 141         perm.setDescription("generated admin permission");
 142         perm.setCreatedAtItem(new Date());
 143         perm.setResourceName(resourceName.toLowerCase().trim());
 144         perm.setEffect(EffectType.PERMIT);
 145         perm.setTenantId(tenantId);
 146         ArrayList<PermissionAction> pas = new ArrayList<PermissionAction>();
 147         perm.setActions(pas);
 148
 149         PermissionAction pa = new PermissionAction();
 150         pa.setName(ActionType.CREATE);
 151         pas.add(pa);
 152         PermissionAction pa1 = new PermissionAction();
 153         pa1.setName(ActionType.READ);
 154         pas.add(pa1);
 155         PermissionAction pa2 = new PermissionAction();
 156         pa2.setName(ActionType.UPDATE);
 157         pas.add(pa2);
 158         PermissionAction pa3 = new PermissionAction();
 159         pa3.setName(ActionType.DELETE);
 160         pas.add(pa3);
 161         PermissionAction pa4 = new PermissionAction();
 162         pa4.setName(ActionType.SEARCH);
 163         pas.add(pa4);
 164         return perm;
 165     }
 166
 167     /**
 168      * createDefaultReaderPermissions creates read only permissions for all services
 169      * used by the given tenant
 170      * @param tenantId
 171      * @return
 172      */
 173     public List<Permission> createDefaultReaderPermissions(String tenantId) {
 174         ArrayList<Permission> apcList = new ArrayList<Permission>();
 175         TenantBindingType tbinding = tenantBindings.get(tenantId);
 176         for (ServiceBindingType sbinding : tbinding.getServiceBindings()) {
 177             //add permissions for the main path
 178                 String resourceName = sbinding.getName().toLowerCase().trim();
 179                 if (SecurityUtils.isEntityProxy() == true) {
 180                         resourceName = SecurityUtils.getResourceEntity(resourceName);
 181                 }
 182             Permission perm = buildReaderPermission(tbinding.getId(),
 183                     resourceName);
 184             apcList.add(perm);
 185
 186             //add permissions for alternate paths
 187             if (SecurityUtils.isEntityProxy() == false) {
 188                     List<String> uriPaths = sbinding.getUriPath();
 189                     for (String uriPath : uriPaths) {
 190                         perm = buildReaderPermission(tbinding.getId(),
 191                                 uriPath.toLowerCase());
 192                         apcList.add(perm);
 193                     }
 194             }
 195         }
 196         return apcList;
 197
 198     }
 199
 200     private Permission buildReaderPermission(String tenantId, String resourceName) {
 201         String id = UUID.randomUUID().toString();
 202         Permission perm = new Permission();
 203         perm.setCsid(id);
 204         perm.setCreatedAtItem(new Date());
 205         perm.setDescription("generated readonly permission");
 206         perm.setResourceName(resourceName.toLowerCase().trim());
 207         perm.setEffect(EffectType.PERMIT);
 208         perm.setTenantId(tenantId);
 209         ArrayList<PermissionAction> pas = new ArrayList<PermissionAction>();
 210         perm.setActions(pas);
 211
 212         PermissionAction pa1 = new PermissionAction();
 213         pa1.setName(ActionType.READ);
 214         pas.add(pa1);
 215
 216         PermissionAction pa4 = new PermissionAction();
 217         pa4.setName(ActionType.SEARCH);
 218         pas.add(pa4);
 219         return perm;
 220     }
 221
 222     public List<Permission> getDefaultPermissions() {
 223         List<Permission> allPermList = new ArrayList<Permission>();
 224         allPermList.addAll(adminPermList);
 225         allPermList.addAll(readerPermList);
 226         return allPermList;
 227     }
 228
 229     public List<Permission> getDefaultAdminPermissions() {
 230         return adminPermList;
 231     }
 232
 233     public List<Permission> getDefaultReaderPermissions() {
 234         return readerPermList;
 235     }
 236
 237     /**
 238      * createDefaultRoles creates default admin and reader roles
 239      * for each tenant found in the given tenant binding file
 240      */
 241     public void createDefaultRoles() {
 242         for (String tenantId : tenantBindings.keySet()) {
 243
 244             Role arole = buildTenantAdminRole(tenantId);
 245             adminRoles.add(arole);
 246
 247             Role rrole = buildTenantReaderRole(tenantId);
 248             readerRoles.add(rrole);
 249
 250         }
 251     }
 252
 253     private Role buildTenantAdminRole(String tenantId) {
 254         Role role = new Role();
 255         role.setCreatedAtItem(new Date());
 256         role.setRoleName(ROLE_TENANT_ADMINISTRATOR);
 257         String id = UUID.randomUUID().toString();
 258         role.setCsid(id);
 259         role.setDescription("generated tenant admin role");
 260         role.setTenantId(tenantId);
 261         return role;
 262     }
 263
 264     private Role buildTenantReaderRole(String tenantId) {
 265         Role role = new Role();
 266         role.setCreatedAtItem(new Date());
 267         role.setRoleName(ROLE_TENANT_READER);
 268         String id = UUID.randomUUID().toString();
 269         role.setCsid(id);
 270         role.setDescription("generated tenant read only role");
 271         role.setTenantId(tenantId);
 272         return role;
 273     }
 274
 275     public List<Role> getDefaultRoles() {
 276         List<Role> allRoleList = new ArrayList<Role>();
 277         allRoleList.addAll(adminRoles);
 278         allRoleList.addAll(readerRoles);
 279         return allRoleList;
 280     }
 281
 282     public void associateDefaultPermissionsRoles() {
 283         List<Role> roles = new ArrayList<Role>();
 284         roles.add(cspaceAdminRole);
 285         for (Permission p : adminPermList) {
 286             PermissionRole permAdmRole = associatePermissionRoles(p, adminRoles);
 287             adminPermRoleList.add(permAdmRole);
 288
 289             //CSpace Administrator has all access
 290             PermissionRole permCAdmRole = associatePermissionRoles(p, roles);
 291             adminPermRoleList.add(permCAdmRole);
 292         }
 293
 294         for (Permission p : readerPermList) {
 295             PermissionRole permRdrRole = associatePermissionRoles(p, readerRoles);
 296             readerPermRoleList.add(permRdrRole);
 297         }
 298     }
 299
 300     public List<PermissionRole> associatePermissionsRoles(List<Permission> perms, List<Role> roles) {
 301         List<PermissionRole> permRoles = new ArrayList<PermissionRole>();
 302         for (Permission perm : perms) {
 303             PermissionRole permRole = associatePermissionRoles(perm, roles);
 304             permRoles.add(permRole);
 305         }
 306         return permRoles;
 307     }
 308
 309     private PermissionRole associatePermissionRoles(Permission perm,
 310             List<Role> roles) {
 311
 312         PermissionRole pr = new PermissionRole();
 313         pr.setSubject(SubjectType.ROLE);
 314         List<PermissionValue> permValues = new ArrayList<PermissionValue>();
 315         pr.setPermissions(permValues);
 316         PermissionValue permValue = new PermissionValue();
 317         permValue.setPermissionId(perm.getCsid());
 318         permValue.setResourceName(perm.getResourceName().toLowerCase());
 319         permValues.add(permValue);
 320
 321         List<RoleValue> roleValues = new ArrayList<RoleValue>();
 322         for (Role role : roles) {
 323             RoleValue rv = new RoleValue();
 324             rv.setRoleName(role.getRoleName().toUpperCase());
 325             rv.setRoleId(role.getCsid());
 326             roleValues.add(rv);
 327         }
 328         pr.setRoles(roleValues);
 329
 330         return pr;
 331     }
 332
 333     public List<PermissionRole> getDefaultPermissionRoles() {
 334         List<PermissionRole> allPermRoleList = new ArrayList<PermissionRole>();
 335         allPermRoleList.addAll(adminPermRoleList);
 336         allPermRoleList.addAll(readerPermRoleList);
 337         return allPermRoleList;
 338     }
 339
 340     public List<PermissionRole> getDefaultAdminPermissionRoles() {
 341         return adminPermRoleList;
 342     }
 343
 344     public List<PermissionRole> getDefaultReaderPermissionRoles() {
 345         return readerPermRoleList;
 346     }
 347
 348     private Role buildCSpaceAdminRole() {
 349         Role role = new Role();
 350         role.setRoleName(ROLE_ADMINISTRATOR);
 351         role.setCsid(ROLE_ADMINISTRATOR_ID);
 352         return role;
 353     }
 354
 355     public void exportDefaultRoles(String fileName) {
 356         RolesList rList = new RolesList();
 357         List<Role> allRoleList = new ArrayList<Role>();
 358         allRoleList.addAll(adminRoles);
 359         allRoleList.addAll(readerRoles);
 360         rList.setRoles(allRoleList);
 361         toFile(rList, RolesList.class,
 362                 fileName);
 363         if (logger.isDebugEnabled()) {
 364             logger.debug("exported roles to " + fileName);
 365         }
 366     }
 367
 368     public void exportDefaultPermissions(String fileName) {
 369         PermissionsList pcList = new PermissionsList();
 370         List<Permission> allPermList = new ArrayList<Permission>();
 371         allPermList.addAll(adminPermList);
 372         allPermList.addAll(readerPermList);
 373         pcList.setPermissions(allPermList);
 374         toFile(pcList, PermissionsList.class,
 375                 fileName);
 376         if (logger.isDebugEnabled()) {
 377             logger.debug("exported permissions to " + fileName);
 378         }
 379     }
 380
 381     public void exportDefaultPermissionRoles(String fileName) {
 382         PermissionsRolesList psrsl = new PermissionsRolesList();
 383         List<PermissionRole> allPermRoleList = new ArrayList<PermissionRole>();
 384         allPermRoleList.addAll(adminPermRoleList);
 385         allPermRoleList.addAll(readerPermRoleList);
 386         psrsl.setPermissionRoles(allPermRoleList);
 387         toFile(psrsl, PermissionsRolesList.class,
 388                 fileName);
 389         if (logger.isDebugEnabled()) {
 390             logger.debug("exported permissions-roles to " + fileName);
 391         }
 392     }
 393
 394     private void toFile(Object o, Class jaxbClass, String fileName) {
 395         File f = new File(fileName);
 396         try {
 397             JAXBContext jc = JAXBContext.newInstance(jaxbClass);
 398             Marshaller m = jc.createMarshaller();
 399             m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
 400                     Boolean.TRUE);
 401             m.marshal(o, f);
 402         } catch (Exception e) {
 403             e.printStackTrace();
 404         }
 405     }
 406 }