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.common.config;
  25
  26 import java.io.File;
  27 import java.util.Hashtable;
  28 import org.collectionspace.services.common.ClientType;
  29 import org.collectionspace.services.common.RepositoryClientConfigType;
  30 import org.collectionspace.services.common.ServiceMain;
  31 import org.collectionspace.services.common.repository.RepositoryClient;
  32 import org.collectionspace.services.common.repository.RepositoryClientFactory;
  33 import org.collectionspace.services.common.service.ServiceBindingType;
  34 import org.collectionspace.services.common.tenant.TenantBindingType;
  35 import org.collectionspace.services.common.tenant.TenantBindingConfig;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 /**
  40  * ServicesConfigReader reads service layer specific configuration
  41  *
  42  * $LastChangedRevision: $
  43  * $LastChangedDate: $
  44  */
  45 public class TenantBindingConfigReader
  46         extends AbstractConfigReader<TenantBindingConfig> {
  47
  48     final private static String CONFIG_FILE_NAME = "tenant-bindings.xml";
  49     final Logger logger = LoggerFactory.getLogger(TenantBindingConfigReader.class);
  50     private TenantBindingConfig tenantBindingConfig;
  51     //tenant name, tenant binding
  52     private Hashtable<String, TenantBindingType> tenantBindings =
  53             new Hashtable<String, TenantBindingType>();
  54     //tenant-qualified servicename, service binding
  55     private Hashtable<String, ServiceBindingType> serviceBindings =
  56             new Hashtable<String, ServiceBindingType>();
  57     //tenant-qualified service, workspace
  58     private Hashtable<String, String> serviceWorkspaces = new Hashtable<String, String>();
  59
  60     public TenantBindingConfigReader(String serverRootDir) {
  61         super(serverRootDir);
  62     }
  63
  64     @Override
  65     public String getFileName() {
  66         return CONFIG_FILE_NAME;
  67     }
  68
  69     @Override
  70     public void read() throws Exception {
  71         String configFileName = getAbsoluteFileName(CONFIG_FILE_NAME);
  72         File configFile = new File(configFileName);
  73         if (!configFile.exists()) {
  74             String msg = "Could not find configuration file " + configFileName;
  75             logger.error(msg);
  76             throw new RuntimeException(msg);
  77         }
  78         tenantBindingConfig = (TenantBindingConfig) parse(configFile, TenantBindingConfig.class);
  79         for (TenantBindingType tenantBinding : tenantBindingConfig.getTenantBinding()) {
  80             tenantBindings.put(tenantBinding.getId(), tenantBinding);
  81             readServiceBindings(tenantBinding);
  82             if (logger.isDebugEnabled()) {
  83                 logger.debug("read() added tenant id=" + tenantBinding.getId() +
  84                         " name=" + tenantBinding.getName());
  85             }
  86         }
  87     }
  88
  89     private void readServiceBindings(TenantBindingType tenantBinding) throws Exception {
  90         for (ServiceBindingType serviceBinding : tenantBinding.getServiceBindings()) {
  91             String key = getTenantQualifiedServiceName(tenantBinding.getId(),
  92                     serviceBinding.getName());
  93             serviceBindings.put(key, serviceBinding);
  94             if (logger.isDebugEnabled()) {
  95                 logger.debug("readServiceBindings() added service " +
  96                         " name=" + key +
  97                         " workspace=" + serviceBinding.getName());
  98             }
  99         }
 100     }
 101
 102     /**
 103      * retrieveWorkspaceIds is called at initialization time to retrieve
 104      * workspace ids of all the tenants
 105      * @throws Exception
 106      */
 107     public void retrieveAllWorkspaceIds() throws Exception {
 108         for (TenantBindingType tenantBinding : tenantBindings.values()) {
 109             retrieveWorkspaceIds(tenantBinding);
 110         }
 111     }
 112
 113     /**
 114      * retrieveWorkspaceIds retrieves workspace ids for services used by
 115      * the given tenant
 116      * @param tenantBinding
 117      * @throws Exception
 118      */
 119     public void retrieveWorkspaceIds(TenantBindingType tenantBinding) throws Exception {
 120         Hashtable<String, String> workspaceIds = new Hashtable<String, String>();
 121         ServiceMain svcMain = ServiceMain.getInstance();
 122         RepositoryClientConfigType rclientConfig = svcMain.getServicesConfigReader().getConfiguration().getRepositoryClient();
 123         ClientType clientType = svcMain.getClientType();
 124         if (clientType.equals(ClientType.JAVA) &&
 125                 rclientConfig.getName().equalsIgnoreCase("nuxeo-java")) {
 126             //FIXME only one repository client is recognized
 127             workspaceIds = svcMain.getNuxeoConnector().retrieveWorkspaceIds(
 128                     tenantBinding.getRepositoryDomain());
 129         }
 130         //verify if workspace exists for each service in the tenant binding
 131         for (ServiceBindingType serviceBinding : tenantBinding.getServiceBindings()) {
 132             String serviceName = serviceBinding.getName();
 133             if (serviceBinding.getRepositoryClient() == null) {
 134                 //no repository needed for this service...skip
 135                 if (logger.isDebugEnabled()) {
 136                     logger.debug("No repository configured for service " + serviceName +
 137                             " skipping...");
 138                 }
 139                 continue;
 140             }
 141             RepositoryClient repositoryClient = getRepositoryClient(
 142                     serviceBinding.getRepositoryClient());
 143             String workspaceId = null;
 144             //workspace name is service name by convention
 145             String workspace = serviceBinding.getName().toLowerCase();
 146             if (clientType.equals(ClientType.JAVA)) {
 147                 workspaceId = workspaceIds.get(workspace);
 148                 if (workspaceId == null) {
 149                     logger.warn("Failed to retrieve workspace ID for " + workspace);
 150                     logger.warn("Trying to create a new workspace ...");
 151                     workspaceId = repositoryClient.createWorkspace(
 152                             tenantBinding.getRepositoryDomain(),
 153                             serviceBinding.getName());
 154                     if (workspaceId == null) {
 155                         logger.warn("Failed to create workspace for " + workspace);
 156                         continue;
 157                     }
 158                 }
 159             } else {
 160                 workspaceId = serviceBinding.getRepositoryWorkspaceId();
 161                 if (workspaceId == null || "".equals(workspaceId)) {
 162                     logger.error("Could not find workspace ID for " + workspace);
 163                     //FIXME: should we throw an exception here?
 164                     continue;
 165                 }
 166             }
 167             String tenantService = getTenantQualifiedServiceName(tenantBinding.getId(), serviceName);
 168             serviceWorkspaces.put(tenantService, workspaceId);
 169             if (logger.isDebugEnabled()) {
 170                 logger.debug("retrieved workspace id=" + workspaceId +
 171                         " service=" + serviceName +
 172                         " workspace=" + workspace);
 173             }
 174         }
 175     }
 176
 177     @Override
 178     public TenantBindingConfig getConfiguration() {
 179         return tenantBindingConfig;
 180     }
 181
 182     /**
 183      * getTenantBinding gets tenant binding for given tenant
 184      * @param tenantId
 185      * @return
 186      */
 187     public TenantBindingType getTenantBinding(
 188             String tenantId) {
 189         return tenantBindings.get(tenantId);
 190     }
 191
 192     /**
 193      * getServiceBinding gets service binding for given tenant for a given service
 194      * @param tenantId
 195      * @param serviceName
 196      * @return
 197      */
 198     public ServiceBindingType getServiceBinding(
 199             String tenantId, String serviceName) {
 200         String key = getTenantQualifiedServiceName(tenantId, serviceName);
 201         return serviceBindings.get(key);
 202     }
 203
 204     /**
 205      * getWorkspaceId retrieves workspace id for given tenant for given service
 206      * @param tenantId
 207      * @param serviceName
 208      * @return
 209      */
 210     public String getWorkspaceId(String tenantId, String serviceName) {
 211         String tenantService = getTenantQualifiedServiceName(tenantId, serviceName);
 212         return serviceWorkspaces.get(tenantService);
 213     }
 214
 215     public static String getTenantQualifiedServiceName(
 216             String tenantId, String serviceName) {
 217         return tenantId + "." + serviceName.toLowerCase();
 218     }
 219
 220     private RepositoryClient getRepositoryClient(String clientName) {
 221         return RepositoryClientFactory.getInstance().getClient(clientName);
 222     }
 223 }