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
  52 /**
  53  * AuthorizationGen generates authorizations (permissions and roles)
  54  * for tenant services
  55  * @author
  56  */
  57 public class AuthorizationGen {
  58
  59     final public static String ROLE_ADMINISTRATOR = "ROLE_ADMINISTRATOR";
  60     final public static String ROLE_TENANT_ADMINISTRATOR = "ROLE_TENANT_ADMINISTRATOR";
  61     final public static String ROLE_TENANT_READER = "ROLE_TENANT_READER";
  62     final public static String ROLE_ADMINISTRATOR_ID = "0";
  63     final Logger logger = LoggerFactory.getLogger(AuthorizationGen.class);
  64     private List<Permission> adminPermList = new ArrayList<Permission>();
  65     private List<PermissionRole> adminPermRoleList = new ArrayList<PermissionRole>();
  66     private List<Permission> readerPermList = new ArrayList<Permission>();
  67     private List<PermissionRole> readerPermRoleList = new ArrayList<PermissionRole>();
  68     private List<Role> adminRoles = new ArrayList<Role>();
  69     private List<Role> readerRoles = new ArrayList<Role>();
  70     private Role cspaceAdminRole;
  71     private Hashtable<String, TenantBindingType> tenantBindings =
  72             new Hashtable<String, TenantBindingType>();
  73
  74     public void initialize(String tenantBindingFileName) throws Exception {
  75         TenantBindingConfigReaderImpl tenantBindingConfigReader =
  76                 new TenantBindingConfigReaderImpl(null);
  77         tenantBindingConfigReader.read(tenantBindingFileName);
  78         tenantBindings = tenantBindingConfigReader.getTenantBindings();
  79         cspaceAdminRole = buildCSpaceAdminRole();
  80
  81         if (logger.isDebugEnabled()) {
  82             logger.debug("initialized with tenant bindings from " + tenantBindingFileName);
  83         }
  84     }
  85
  86     /**
  87      * createDefaultPermissions creates default admin and reader permissions
  88      * for each tenant found in the given tenant binding file
  89      * @see initialize
  90      * @return
  91      */
  92     public void createDefaultPermissions() {
  93         for (String tenantId : tenantBindings.keySet()) {
  94             List<Permission> adminPerms = createDefaultAdminPermissions(tenantId);
  95             adminPermList.addAll(adminPerms);
  96
  97             List<Permission> readerPerms = createDefaultReaderPermissions(tenantId);
  98             readerPermList.addAll(readerPerms);
  99         }
 100     }
 101
 102     /**
 103      * createDefaultAdminPermissions creates default admin permissions for all services
 104      * used by the given tenant
 105      * @param tenantId
 106      * @return
 107      */
 108     public List<Permission> createDefaultAdminPermissions(String tenantId) {
 109         ArrayList<Permission> apcList = new ArrayList<Permission>();
 110         TenantBindingType tbinding = tenantBindings.get(tenantId);
 111         for (ServiceBindingType sbinding : tbinding.getServiceBindings()) {
 112
 113             //add permissions for the main path
 114             Permission perm = buildAdminPermission(tbinding.getId(),
 115                     sbinding.getName().toLowerCase());
 116             apcList.add(perm);
 117
 118             //add permissions for alternate paths
 119             List<String> uriPaths = sbinding.getUriPath();
 120             for (String uriPath : uriPaths) {
 121                 perm = buildAdminPermission(tbinding.getId(),
 122                         uriPath.toLowerCase());
 123                 apcList.add(perm);
 124             }
 125
 126         }
 127         return apcList;
 128
 129     }
 130
 131     private Permission buildAdminPermission(String tenantId, String resourceName) {
 132         String id = UUID.randomUUID().toString();
 133         Permission perm = new Permission();
 134         perm.setCsid(id);
 135         perm.setDescription("generated admin permission");
 136         perm.setCreatedAtItem(new Date());
 137         perm.setResourceName(resourceName.toLowerCase());
 138         perm.setEffect(EffectType.PERMIT);
 139         perm.setTenantId(tenantId);
 140         ArrayList<PermissionAction> pas = new ArrayList<PermissionAction>();
 141         perm.setActions(pas);
 142
 143         PermissionAction pa = new PermissionAction();
 144         pa.setName(ActionType.CREATE);
 145         pas.add(pa);
 146         PermissionAction pa1 = new PermissionAction();
 147         pa1.setName(ActionType.READ);
 148         pas.add(pa1);
 149         PermissionAction pa2 = new PermissionAction();
 150         pa2.setName(ActionType.UPDATE);
 151         pas.add(pa2);
 152         PermissionAction pa3 = new PermissionAction();
 153         pa3.setName(ActionType.DELETE);
 154         pas.add(pa3);
 155         PermissionAction pa4 = new PermissionAction();
 156         pa4.setName(ActionType.SEARCH);
 157         pas.add(pa4);
 158         return perm;
 159     }
 160
 161     /**
 162      * createDefaultReaderPermissions creates read only permissions for all services
 163      * used by the given tenant
 164      * @param tenantId
 165      * @return
 166      */
 167     public List<Permission> createDefaultReaderPermissions(String tenantId) {
 168         ArrayList<Permission> apcList = new ArrayList<Permission>();
 169         TenantBindingType tbinding = tenantBindings.get(tenantId);
 170         for (ServiceBindingType sbinding : tbinding.getServiceBindings()) {
 171
 172             //add permissions for the main path
 173             Permission perm = buildReaderPermission(tbinding.getId(),
 174                     sbinding.getName().toLowerCase());
 175             apcList.add(perm);
 176
 177             //add permissions for alternate paths
 178             List<String> uriPaths = sbinding.getUriPath();
 179             for (String uriPath : uriPaths) {
 180                 perm = buildReaderPermission(tbinding.getId(),
 181                         uriPath.toLowerCase());
 182                 apcList.add(perm);
 183             }
 184
 185         }
 186         return apcList;
 187
 188     }
 189
 190     private Permission buildReaderPermission(String tenantId, String resourceName) {
 191         String id = UUID.randomUUID().toString();
 192         Permission perm = new Permission();
 193         perm.setCsid(id);
 194         perm.setCreatedAtItem(new Date());
 195         perm.setDescription("generated readonly permission");
 196         perm.setResourceName(resourceName.toLowerCase());
 197         perm.setEffect(EffectType.PERMIT);
 198         perm.setTenantId(tenantId);
 199         ArrayList<PermissionAction> pas = new ArrayList<PermissionAction>();
 200         perm.setActions(pas);
 201
 202         PermissionAction pa1 = new PermissionAction();
 203         pa1.setName(ActionType.READ);
 204         pas.add(pa1);
 205
 206         PermissionAction pa4 = new PermissionAction();
 207         pa4.setName(ActionType.SEARCH);
 208         pas.add(pa4);
 209         return perm;
 210     }
 211
 212     public List<Permission> getDefaultPermissions() {
 213         List<Permission> allPermList = new ArrayList<Permission>();
 214         allPermList.addAll(adminPermList);
 215         allPermList.addAll(readerPermList);
 216         return allPermList;
 217     }
 218
 219     public List<Permission> getDefaultAdminPermissions() {
 220         return adminPermList;
 221     }
 222
 223     public List<Permission> getDefaultReaderPermissions() {
 224         return readerPermList;
 225     }
 226
 227     /**
 228      * createDefaultRoles creates default admin and reader roles
 229      * for each tenant found in the given tenant binding file
 230      */
 231     public void createDefaultRoles() {
 232         for (String tenantId : tenantBindings.keySet()) {
 233
 234             Role arole = buildTenantAdminRole(tenantId);
 235             adminRoles.add(arole);
 236
 237             Role rrole = buildTenantReaderRole(tenantId);
 238             readerRoles.add(rrole);
 239
 240         }
 241     }
 242
 243     private Role buildTenantAdminRole(String tenantId) {
 244         Role role = new Role();
 245         role.setCreatedAtItem(new Date());
 246         role.setRoleName(ROLE_TENANT_ADMINISTRATOR);
 247         String id = UUID.randomUUID().toString();
 248         role.setCsid(id);
 249         role.setDescription("generated tenant admin role");
 250         role.setTenantId(tenantId);
 251         return role;
 252     }
 253
 254     private Role buildTenantReaderRole(String tenantId) {
 255         Role role = new Role();
 256         role.setCreatedAtItem(new Date());
 257         role.setRoleName(ROLE_TENANT_READER);
 258         String id = UUID.randomUUID().toString();
 259         role.setCsid(id);
 260         role.setDescription("generated tenant read only role");
 261         role.setTenantId(tenantId);
 262         return role;
 263     }
 264
 265     public List<Role> getDefaultRoles() {
 266         List<Role> allRoleList = new ArrayList<Role>();
 267         allRoleList.addAll(adminRoles);
 268         allRoleList.addAll(readerRoles);
 269         return allRoleList;
 270     }
 271
 272     public void associateDefaultPermissionsRoles() {
 273         List<Role> roles = new ArrayList<Role>();
 274         roles.add(cspaceAdminRole);
 275         for (Permission p : adminPermList) {
 276             PermissionRole permAdmRole = associatePermissionRoles(p, adminRoles);
 277             adminPermRoleList.add(permAdmRole);
 278
 279             //CSpace Administrator has all access
 280             PermissionRole permCAdmRole = associatePermissionRoles(p, roles);
 281             adminPermRoleList.add(permCAdmRole);
 282         }
 283
 284         for (Permission p : readerPermList) {
 285             PermissionRole permRdrRole = associatePermissionRoles(p, readerRoles);
 286             readerPermRoleList.add(permRdrRole);
 287         }
 288     }
 289
 290     public List<PermissionRole> associatePermissionsRoles(List<Permission> perms, List<Role> roles) {
 291         List<PermissionRole> permRoles = new ArrayList<PermissionRole>();
 292         for (Permission perm : perms) {
 293             PermissionRole permRole = associatePermissionRoles(perm, roles);
 294             permRoles.add(permRole);
 295         }
 296         return permRoles;
 297     }
 298
 299     private PermissionRole associatePermissionRoles(Permission perm,
 300             List<Role> roles) {
 301
 302         PermissionRole pr = new PermissionRole();
 303         pr.setSubject(SubjectType.ROLE);
 304         List<PermissionValue> permValues = new ArrayList<PermissionValue>();
 305         pr.setPermissions(permValues);
 306         PermissionValue permValue = new PermissionValue();
 307         permValue.setPermissionId(perm.getCsid());
 308         permValue.setResourceName(perm.getResourceName().toLowerCase());
 309         permValues.add(permValue);
 310
 311         List<RoleValue> roleValues = new ArrayList<RoleValue>();
 312         for (Role role : roles) {
 313             RoleValue rv = new RoleValue();
 314             rv.setRoleName(role.getRoleName().toUpperCase());
 315             rv.setRoleId(role.getCsid());
 316             roleValues.add(rv);
 317         }
 318         pr.setRoles(roleValues);
 319
 320         return pr;
 321     }
 322
 323     public List<PermissionRole> getDefaultPermissionRoles() {
 324         List<PermissionRole> allPermRoleList = new ArrayList<PermissionRole>();
 325         allPermRoleList.addAll(adminPermRoleList);
 326         allPermRoleList.addAll(readerPermRoleList);
 327         return allPermRoleList;
 328     }
 329
 330     public List<PermissionRole> getDefaultAdminPermissionRoles() {
 331         return adminPermRoleList;
 332     }
 333
 334     public List<PermissionRole> getDefaultReaderPermissionRoles() {
 335         return readerPermRoleList;
 336     }
 337
 338     private Role buildCSpaceAdminRole() {
 339         Role role = new Role();
 340         role.setRoleName(ROLE_ADMINISTRATOR);
 341         role.setCsid(ROLE_ADMINISTRATOR_ID);
 342         return role;
 343     }
 344
 345     public void exportDefaultRoles(String fileName) {
 346         RolesList rList = new RolesList();
 347         List<Role> allRoleList = new ArrayList<Role>();
 348         allRoleList.addAll(adminRoles);
 349         allRoleList.addAll(readerRoles);
 350         rList.setRoles(allRoleList);
 351         toFile(rList, RolesList.class,
 352                 fileName);
 353         if (logger.isDebugEnabled()) {
 354             logger.debug("exported roles to " + fileName);
 355         }
 356     }
 357
 358     public void exportDefaultPermissions(String fileName) {
 359         PermissionsList pcList = new PermissionsList();
 360         List<Permission> allPermList = new ArrayList<Permission>();
 361         allPermList.addAll(adminPermList);
 362         allPermList.addAll(readerPermList);
 363         pcList.setPermissions(allPermList);
 364         toFile(pcList, PermissionsList.class,
 365                 fileName);
 366         if (logger.isDebugEnabled()) {
 367             logger.debug("exported permissions to " + fileName);
 368         }
 369     }
 370
 371     public void exportDefaultPermissionRoles(String fileName) {
 372         PermissionsRolesList psrsl = new PermissionsRolesList();
 373         List<PermissionRole> allPermRoleList = new ArrayList<PermissionRole>();
 374         allPermRoleList.addAll(adminPermRoleList);
 375         allPermRoleList.addAll(readerPermRoleList);
 376         psrsl.setPermissionRoles(allPermRoleList);
 377         toFile(psrsl, PermissionsRolesList.class,
 378                 fileName);
 379         if (logger.isDebugEnabled()) {
 380             logger.debug("exported permissions-roles to " + fileName);
 381         }
 382     }
 383
 384     private void toFile(Object o, Class jaxbClass, String fileName) {
 385         File f = new File(fileName);
 386         try {
 387             JAXBContext jc = JAXBContext.newInstance(jaxbClass);
 388             Marshaller m = jc.createMarshaller();
 389             m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
 390                     Boolean.TRUE);
 391             m.marshal(o, f);
 392         } catch (Exception e) {
 393             e.printStackTrace();
 394         }
 395     }
 396 }