예제 #1
0
  @Deprecated
  public TenantAxisConfigurator(
      AxisConfiguration mainAxisConfig, String tenantDomain, int tenantId, UserRegistry registry)
      throws AxisFault {
    this.tenantDomain = tenantDomain;
    this.tenantId = tenantId;
    this.mainAxisConfig = mainAxisConfig;
    this.registry = registry;
    this.bundleContext = CarbonCoreDataHolder.getInstance().getBundleContext();
    this.moduleBundles =
        ((CarbonAxisConfigurator) mainAxisConfig.getConfigurator())
            .getConfigItemHolder()
            .getModuleBundles();
    this.deployerBundles =
        ((CarbonAxisConfigurator) mainAxisConfig.getConfigurator())
            .getConfigItemHolder()
            .getDeployerBundles();
    File tenantDir = new File(CarbonUtils.getCarbonTenantsDirPath() + File.separator + tenantId);
    if (!tenantDir.exists() && !tenantDir.mkdirs()) {
      log.warn("Could not create directory " + tenantDir.getAbsolutePath());
    }
    this.repoLocation = tenantDir.getAbsolutePath();

    // Use registry based deployer if necessary
    if (CarbonUtils.useRegistryBasedRepository()) {
      String registryPath = "/repository/deployment";
      new RegistryBasedRepository(registry, registryPath, repoLocation)
          .updateFileSystemFromRegistry();
      RegistryBasedRepositoryUpdater.scheduleAtFixedRate(
          registry, registryPath, repoLocation, 0, 10);
    }
  }
예제 #2
0
 private static void setHostName(AxisConfiguration axisConfig) throws DeploymentException {
   try {
     String hostName =
         CarbonCoreDataHolder.getInstance()
             .getServerConfigurationService()
             .getFirstProperty("HostName");
     if (hostName != null) {
       Parameter param = ParameterUtil.createParameter(HOST_ADDRESS, hostName);
       axisConfig.addParameter(param);
     }
   } catch (AxisFault axisFault) {
     throw new DeploymentException(axisFault.getMessage(), axisFault);
   }
 }
예제 #3
0
 private static void doPreConfigContextCreation(int tenantId) {
   BundleContext bundleContext = CarbonCoreDataHolder.getInstance().getBundleContext();
   if (bundleContext != null) {
     ServiceTracker tracker =
         new ServiceTracker(
             bundleContext, Axis2ConfigurationContextObserver.class.getName(), null);
     tracker.open();
     Object[] services = tracker.getServices();
     if (services != null) {
       for (Object service : services) {
         ((Axis2ConfigurationContextObserver) service).creatingConfigurationContext(tenantId);
       }
     }
     tracker.close();
   }
 }
예제 #4
0
  public static ConfigurationContext getTenantConfigurationContext(
      String tenantDomain, ConfigurationContext mainConfigCtx) {
    ConfigurationContext tenantConfigCtx;

    Boolean isTenantActive;
    try {
      isTenantActive =
          CarbonCoreDataHolder.getInstance()
              .getRealmService()
              .getTenantManager()
              .isTenantActive(getTenantId(tenantDomain));
    } catch (Exception e) {
      throw new RuntimeException("Error while getting tenant activation status.", e);
    }

    if (!isTenantActive) {
      throw new RuntimeException("Trying to access inactive tenant domain : " + tenantDomain);
    }

    if (tenantReadWriteLocks.get(tenantDomain) == null) {
      synchronized (tenantDomain.intern()) {
        if (tenantReadWriteLocks.get(tenantDomain) == null) {
          tenantReadWriteLocks.put(tenantDomain, new ReentrantReadWriteLock());
        }
      }
    }
    Lock tenantReadLock = tenantReadWriteLocks.get(tenantDomain).readLock();
    try {
      tenantReadLock.lock();
      Map<String, ConfigurationContext> tenantConfigContexts =
          getTenantConfigurationContexts(mainConfigCtx);
      tenantConfigCtx = tenantConfigContexts.get(tenantDomain);
      if (tenantConfigCtx == null) {
        try {
          tenantConfigCtx = createTenantConfigurationContext(mainConfigCtx, tenantDomain);
        } catch (Exception e) {
          throw new RuntimeException(
              "Cannot create tenant ConfigurationContext for tenant " + tenantDomain, e);
        }
      }
      tenantConfigCtx.setProperty(MultitenantConstants.LAST_ACCESSED, System.currentTimeMillis());
    } finally {
      tenantReadLock.unlock();
    }
    return tenantConfigCtx;
  }
예제 #5
0
 @Override
 protected void startSearch(RepositoryListener listener) {
   schedulerTask =
       new CarbonDeploymentSchedulerTask(
           listener, axisConfig,
           tenantId, tenantDomain);
   scheduler = Executors.newScheduledThreadPool(1);
   String deploymentInterval =
       CarbonCoreDataHolder.getInstance()
           .getServerConfigurationService()
           .getFirstProperty("Axis2Config.DeploymentUpdateInterval");
   int deploymentIntervalInt = 15;
   if (deploymentInterval != null) {
     deploymentIntervalInt = Integer.parseInt(deploymentInterval);
   }
   scheduler.scheduleWithFixedDelay(schedulerTask, 0, deploymentIntervalInt, TimeUnit.SECONDS);
 }
예제 #6
0
 /**
  * Terminate the provided Tenant ConfigurationContext
  *
  * @param tenantCfgCtx The tenant ConfigurationContext which needs to be terminated
  */
 public static void terminateTenantConfigContext(ConfigurationContext tenantCfgCtx) {
   ConfigurationContext mainServerConfigContext =
       CarbonCoreDataHolder.getInstance().getMainServerConfigContext();
   Map<String, ConfigurationContext> tenantConfigContexts =
       getTenantConfigurationContexts(mainServerConfigContext);
   String tenantDomain = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantDomain();
   log.info("Starting to clean tenant : " + tenantDomain);
   tenantCfgCtx.getAxisConfiguration().getConfigurator().cleanup();
   try {
     doPreConfigContextTermination(tenantCfgCtx);
     tenantCfgCtx.terminate();
     doPostConfigContextTermination(tenantCfgCtx);
     tenantConfigContexts.remove(tenantDomain);
     log.info("Cleaned up tenant " + tenantDomain);
   } catch (AxisFault e) {
     log.error("Cannot cleanup ConfigurationContext of tenant " + tenantDomain, e);
   }
 }
예제 #7
0
  /**
   * Traverse the list of tenants and cleanup tenants which have been idling for longer than <code>
   * tenantIdleTimeMillis</code>
   *
   * @param tenantIdleTimeMillis The maximum tenant idle time in milliseconds
   */
  public static void cleanupTenants(long tenantIdleTimeMillis) {
    ConfigurationContext mainServerConfigContext =
        CarbonCoreDataHolder.getInstance().getMainServerConfigContext();
    if (mainServerConfigContext == null) {
      return;
    }
    Map<String, ConfigurationContext> tenantConfigContexts =
        getTenantConfigurationContexts(mainServerConfigContext);
    for (Map.Entry<String, ConfigurationContext> entry : tenantConfigContexts.entrySet()) {
      String tenantDomain = entry.getKey();
      synchronized (tenantDomain.intern()) {
        ConfigurationContext tenantCfgCtx = entry.getValue();
        Long lastAccessed = (Long) tenantCfgCtx.getProperty(MultitenantConstants.LAST_ACCESSED);
        if (System.currentTimeMillis() - lastAccessed >= tenantIdleTimeMillis) {
          // Get the write lock.
          Lock tenantWriteLock = tenantReadWriteLocks.get(tenantDomain).writeLock();
          tenantWriteLock.lock();
          try {
            lastAccessed = (Long) tenantCfgCtx.getProperty(MultitenantConstants.LAST_ACCESSED);
            if (System.currentTimeMillis() - lastAccessed >= tenantIdleTimeMillis) {
              try {
                PrivilegedCarbonContext.startTenantFlow();
                // Creating CarbonContext object for these threads.
                PrivilegedCarbonContext carbonContext =
                    PrivilegedCarbonContext.getThreadLocalCarbonContext();
                carbonContext.setTenantDomain(tenantDomain, true);

                // Terminating idle tenant configuration contexts.
                terminateTenantConfigContext(tenantCfgCtx);
                tenantConfigContexts.remove(tenantDomain);
              } finally {
                PrivilegedCarbonContext.endTenantFlow();
              }
            }
          } finally {
            tenantWriteLock.unlock();
          }
        }
      }
    }
  }
예제 #8
0
/** Utility methods for Tenant Operations at Axis2-level. */
@SuppressWarnings("unused")
public final class TenantAxisUtils {

  private static final Log log = LogFactory.getLog(TenantAxisUtils.class);
  private static final String TENANT_CONFIGURATION_CONTEXTS = "tenant.config.contexts";
  private static final String TENANT_CONFIGURATION_CONTEXTS_CREATED =
      "tenant.config.contexts.created";
  private static CarbonCoreDataHolder dataHolder = CarbonCoreDataHolder.getInstance();
  private static Map<String, ReentrantReadWriteLock> tenantReadWriteLocks =
      new ConcurrentHashMap<String, ReentrantReadWriteLock>();

  private TenantAxisUtils() {}

  /**
   * Get tenant ID from config context
   *
   * @param configCtx The config context
   * @return The tenant ID
   * @deprecated use {@link MultitenantUtils#getTenantId(ConfigurationContext)}
   */
  public static int getTenantId(ConfigurationContext configCtx) {
    return MultitenantUtils.getTenantId(configCtx);
  }

  public static AxisConfiguration getTenantAxisConfiguration(
      String tenant, ConfigurationContext mainConfigCtx) {
    ConfigurationContext tenantConfigCtx = getTenantConfigurationContext(tenant, mainConfigCtx);
    if (tenantConfigCtx != null) {
      return tenantConfigCtx.getAxisConfiguration();
    }
    return null;
  }

  public static ConfigurationContext getTenantConfigurationContextFromUrl(
      String url, ConfigurationContext mainConfigCtx) {
    String tenantDomain = MultitenantUtils.getTenantDomainFromUrl(url);
    return getTenantConfigurationContext(tenantDomain, mainConfigCtx);
  }

  public static ConfigurationContext getTenantConfigurationContext(
      String tenantDomain, ConfigurationContext mainConfigCtx) {
    ConfigurationContext tenantConfigCtx;

    Boolean isTenantActive;
    try {
      isTenantActive =
          CarbonCoreDataHolder.getInstance()
              .getRealmService()
              .getTenantManager()
              .isTenantActive(getTenantId(tenantDomain));
    } catch (Exception e) {
      throw new RuntimeException("Error while getting tenant activation status.", e);
    }

    if (!isTenantActive) {
      throw new RuntimeException("Trying to access inactive tenant domain : " + tenantDomain);
    }

    if (tenantReadWriteLocks.get(tenantDomain) == null) {
      synchronized (tenantDomain.intern()) {
        if (tenantReadWriteLocks.get(tenantDomain) == null) {
          tenantReadWriteLocks.put(tenantDomain, new ReentrantReadWriteLock());
        }
      }
    }
    Lock tenantReadLock = tenantReadWriteLocks.get(tenantDomain).readLock();
    try {
      tenantReadLock.lock();
      Map<String, ConfigurationContext> tenantConfigContexts =
          getTenantConfigurationContexts(mainConfigCtx);
      tenantConfigCtx = tenantConfigContexts.get(tenantDomain);
      if (tenantConfigCtx == null) {
        try {
          tenantConfigCtx = createTenantConfigurationContext(mainConfigCtx, tenantDomain);
        } catch (Exception e) {
          throw new RuntimeException(
              "Cannot create tenant ConfigurationContext for tenant " + tenantDomain, e);
        }
      }
      tenantConfigCtx.setProperty(MultitenantConstants.LAST_ACCESSED, System.currentTimeMillis());
    } finally {
      tenantReadLock.unlock();
    }
    return tenantConfigCtx;
  }

  public static long getLastAccessed(String tenantDomain, ConfigurationContext mainConfigCtx) {
    Map<String, ConfigurationContext> tenantConfigContexts =
        getTenantConfigurationContexts(mainConfigCtx);
    ConfigurationContext tenantConfigCtx = tenantConfigContexts.get(tenantDomain);
    if (tenantConfigCtx != null) {
      Long lastAccessed = (Long) tenantConfigCtx.getProperty(MultitenantConstants.LAST_ACCESSED);
      return lastAccessed == null ? -1 : lastAccessed;
    }
    return -1;
  }

  public static void setTenantAccessed(String tenantDomain, ConfigurationContext mainConfigCtx) {
    getTenantConfigurationContext(tenantDomain, mainConfigCtx);
  }

  /**
   * @param url will have pattern <some-string>/t/<tenant>/<service>?<some-params>
   * @param mainConfigContext The main ConfigurationContext from the server
   * @return The tenant's AxisService
   * @throws org.apache.axis2.AxisFault If an error occurs while retrieving the AxisService
   */
  public static AxisService getAxisService(String url, ConfigurationContext mainConfigContext)
      throws AxisFault {
    String[] strings = url.split("/");
    boolean foundTenantDelimiter = false;
    String tenant = null;
    String service = null;
    for (String str : strings) {
      if (!foundTenantDelimiter && str.equals("t")) {
        foundTenantDelimiter = true;
        continue;
      }
      if (foundTenantDelimiter & tenant == null) {
        tenant = str;
        continue;
      }
      if (tenant != null) {
        if (service == null) {
          service = str;
        } else {
          service += "/" + str;
        }
      }
    }
    if (service != null) {
      service = service.split("\\?")[0];
      AxisConfiguration tenantAxisConfig = getTenantAxisConfiguration(tenant, mainConfigContext);
      if (tenantAxisConfig != null) {
        return tenantAxisConfig.getServiceForActivation(service);
      }
    }
    return null;
  }

  /**
   * Get all the tenant ConfigurationContexts
   *
   * @param mainConfigCtx Super-tenant Axis2 ConfigurationContext
   * @return the tenant ConfigurationContexts as a Map of "tenant domain -> ConfigurationContext"
   */
  @SuppressWarnings("unchecked")
  public static Map<String, ConfigurationContext> getTenantConfigurationContexts(
      ConfigurationContext mainConfigCtx) {
    Map<String, ConfigurationContext> tenantConfigContexts =
        (Map<String, ConfigurationContext>)
            mainConfigCtx.getProperty(TENANT_CONFIGURATION_CONTEXTS);
    if (tenantConfigContexts == null) {
      tenantConfigContexts = new ConcurrentHashMap<String, ConfigurationContext>();
      mainConfigCtx.setProperty(TENANT_CONFIGURATION_CONTEXTS, tenantConfigContexts);
    }
    return tenantConfigContexts;
  }

  /**
   * Set the transports for the tenants
   *
   * @param mainConfigCtx The main config context
   * @throws AxisFault If an error occurs while initializing tenant transports
   */
  @SuppressWarnings("unchecked")
  public static void initializeTenantTransports(ConfigurationContext mainConfigCtx)
      throws AxisFault {
    AxisConfiguration mainAxisConfig = mainConfigCtx.getAxisConfiguration();
    Map<String, ConfigurationContext> tenantConfigContexts =
        getTenantConfigurationContexts(mainConfigCtx);
    if (tenantConfigContexts != null) {
      for (Map.Entry<String, ConfigurationContext> entry : tenantConfigContexts.entrySet()) {
        String tenantDomain = entry.getKey();
        ConfigurationContext tenantConfigCtx = entry.getValue();
        AxisConfiguration tenantAxisConfig = tenantConfigCtx.getAxisConfiguration();
        // Add the transports that are made available in the main axis2.xml file
        setTenantTransports(mainAxisConfig, tenantDomain, tenantAxisConfig);
      }
    }
  }

  public static void setTenantTransports(
      AxisConfiguration mainAxisConfig, String tenantDomain, AxisConfiguration tenantAxisConfig)
      throws AxisFault {
    for (String transport : mainAxisConfig.getTransportsIn().keySet()) {
      TenantTransportInDescription tenantTransportIn = new TenantTransportInDescription(transport);
      tenantTransportIn.setMainTransportInDescription(
          mainAxisConfig.getTransportsIn().get(transport));
      TransportListener mainTransportListener =
          mainAxisConfig.getTransportIn(transport).getReceiver();
      tenantTransportIn.setReceiver(
          new DummyTransportListener(mainTransportListener, tenantDomain));
      tenantAxisConfig.addTransportIn(tenantTransportIn);
    }
  }

  /**
   * Create Tenant Axis2 ConfigurationContexts & add them to the main Axis2 ConfigurationContext
   *
   * @param mainConfigCtx Super-tenant Axis2 ConfigurationContext
   * @param tenantDomain Tenant domain (e.g. foo.com)
   * @return The newly created Tenant ConfigurationContext
   * @throws Exception If an error occurs while creating tenant ConfigurationContext
   */
  private static ConfigurationContext createTenantConfigurationContext(
      ConfigurationContext mainConfigCtx, String tenantDomain) throws Exception {
    synchronized (tenantDomain.intern()) { // lock based on tenant domain
      Map<String, ConfigurationContext> tenantConfigContexts =
          getTenantConfigurationContexts(mainConfigCtx);
      ConfigurationContext tenantConfigCtx = tenantConfigContexts.get(tenantDomain);
      if (tenantConfigCtx != null) {
        return tenantConfigCtx;
      }
      long tenantLoadingStartTime = System.currentTimeMillis();
      int tenantId = getTenantId(tenantDomain);
      if (tenantId == MultitenantConstants.SUPER_TENANT_ID
          || tenantId == MultitenantConstants.INVALID_TENANT_ID) {
        throw new Exception("Tenant " + tenantDomain + " does not exist");
      }
      PrivilegedCarbonContext carbonContext = PrivilegedCarbonContext.getThreadLocalCarbonContext();
      carbonContext.setTenantId(tenantId);
      carbonContext.setTenantDomain(tenantDomain);

      tenantConfigCtx = tenantConfigContexts.get(tenantDomain);
      if (tenantConfigCtx != null) {
        return tenantConfigCtx;
      }

      AxisConfiguration mainAxisConfig = mainConfigCtx.getAxisConfiguration();

      dataHolder.getTenantRegistryLoader().loadTenantRegistry(tenantId);

      try {
        UserRegistry tenantConfigRegistry =
            dataHolder.getRegistryService().getConfigSystemRegistry(tenantId);
        UserRegistry tenantLocalUserRegistry =
            dataHolder.getRegistryService().getLocalRepository(tenantId);
        TenantAxisConfigurator tenantAxisConfigurator =
            new TenantAxisConfigurator(
                mainAxisConfig,
                tenantDomain,
                tenantId,
                tenantConfigRegistry,
                tenantLocalUserRegistry);
        doPreConfigContextCreation(tenantId);
        tenantConfigCtx =
            ConfigurationContextFactory.createConfigurationContext(tenantAxisConfigurator);

        AxisConfiguration tenantAxisConfig = tenantConfigCtx.getAxisConfiguration();

        tenantConfigCtx.setServicePath(CarbonUtils.getAxis2ServicesDir(tenantAxisConfig));
        tenantConfigCtx.setContextRoot("local:/");

        TenantTransportSender transportSender = new TenantTransportSender(mainConfigCtx);
        // Adding transport senders
        HashMap<String, TransportOutDescription> transportSenders =
            mainAxisConfig.getTransportsOut();
        if (transportSenders != null && !transportSenders.isEmpty()) {
          for (String strTransport : transportSenders.keySet()) {
            TransportOutDescription outDescription = new TransportOutDescription(strTransport);
            outDescription.setSender(transportSender);
            tenantAxisConfig.addTransportOut(outDescription);
          }
        }

        // Set the work directory
        tenantConfigCtx.setProperty(
            ServerConstants.WORK_DIR, mainConfigCtx.getProperty(ServerConstants.WORK_DIR));
        PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantId(tenantId);
        new TransportPersistenceManager(tenantAxisConfig)
            .updateEnabledTransports(
                tenantAxisConfig.getTransportsIn().values(),
                tenantAxisConfig.getTransportsOut().values());

        // Notify all observers
        BundleContext bundleContext = dataHolder.getBundleContext();
        if (bundleContext != null) {
          ServiceTracker tracker =
              new ServiceTracker(
                  bundleContext, Axis2ConfigurationContextObserver.class.getName(), null);
          tracker.open();
          Object[] services = tracker.getServices();
          if (services != null) {
            for (Object service : services) {
              ((Axis2ConfigurationContextObserver) service)
                  .createdConfigurationContext(tenantConfigCtx);
            }
          }
          tracker.close();
        }
        tenantConfigCtx.setProperty(MultitenantConstants.LAST_ACCESSED, System.currentTimeMillis());

        // Register Capp deployer for this tenant
        Utils.addCAppDeployer(tenantAxisConfig);

        // deploy the services since all the deployers are initialized by now.
        tenantAxisConfigurator.deployServices();

        // tenant config context must only be made after the tenant is fully loaded, and all its
        // artifacts
        // are deployed.
        // -- THIS SHOULD BE THE LAST OPERATION OF THIS METHOD --
        tenantConfigContexts.put(tenantDomain, tenantConfigCtx);

        log.info(
            "Loaded tenant "
                + tenantDomain
                + " in "
                + (System.currentTimeMillis() - tenantLoadingStartTime)
                + " ms");

        return tenantConfigCtx;
      } catch (Exception e) {
        String msg = "Error occurred while running deployment for tenant ";
        log.error(msg + tenantDomain, e);
        throw new Exception(msg, e);
      }
    }
  }

  /**
   * Get the list of all active tenants in the system
   *
   * @param mainConfigCtx The main super-tenant ConfigurationContext
   * @return The list of active tenants
   * @throws Exception If an error occurs while retrieving tenants
   */
  public static List<Tenant> getActiveTenants(ConfigurationContext mainConfigCtx) throws Exception {
    Map<String, ConfigurationContext> tenantConfigContexts =
        getTenantConfigurationContexts(mainConfigCtx);
    List<Tenant> tenants = new ArrayList<Tenant>();
    try {
      TenantManager tenantManager = dataHolder.getRealmService().getTenantManager();
      for (ConfigurationContext tenantCfgCtx : tenantConfigContexts.values()) {
        Tenant tenant =
            (Tenant) tenantManager.getTenant(MultitenantUtils.getTenantId(tenantCfgCtx));
        tenants.add(tenant);
      }
    } catch (Exception e) {
      String msg = "Error occurred while getting active tenant list";
      log.error(msg, e);
      throw new Exception(msg, e);
    }
    return tenants;
  }

  /**
   * Get the tenantID given the domain
   *
   * @param tenantDomain The tenant domain
   * @return The tenant ID
   * @throws Exception If an error occurs while retrieving tenant ID
   */
  private static int getTenantId(String tenantDomain) throws Exception {
    return dataHolder.getRealmService().getTenantManager().getTenantId(tenantDomain);
  }

  /**
   * Traverse the list of tenants and cleanup tenants which have been idling for longer than <code>
   * tenantIdleTimeMillis</code>
   *
   * @param tenantIdleTimeMillis The maximum tenant idle time in milliseconds
   */
  public static void cleanupTenants(long tenantIdleTimeMillis) {
    ConfigurationContext mainServerConfigContext =
        CarbonCoreDataHolder.getInstance().getMainServerConfigContext();
    if (mainServerConfigContext == null) {
      return;
    }
    Map<String, ConfigurationContext> tenantConfigContexts =
        getTenantConfigurationContexts(mainServerConfigContext);
    for (Map.Entry<String, ConfigurationContext> entry : tenantConfigContexts.entrySet()) {
      String tenantDomain = entry.getKey();
      synchronized (tenantDomain.intern()) {
        ConfigurationContext tenantCfgCtx = entry.getValue();
        Long lastAccessed = (Long) tenantCfgCtx.getProperty(MultitenantConstants.LAST_ACCESSED);
        if (System.currentTimeMillis() - lastAccessed >= tenantIdleTimeMillis) {
          // Get the write lock.
          Lock tenantWriteLock = tenantReadWriteLocks.get(tenantDomain).writeLock();
          tenantWriteLock.lock();
          try {
            lastAccessed = (Long) tenantCfgCtx.getProperty(MultitenantConstants.LAST_ACCESSED);
            if (System.currentTimeMillis() - lastAccessed >= tenantIdleTimeMillis) {
              try {
                PrivilegedCarbonContext.startTenantFlow();
                // Creating CarbonContext object for these threads.
                PrivilegedCarbonContext carbonContext =
                    PrivilegedCarbonContext.getThreadLocalCarbonContext();
                carbonContext.setTenantDomain(tenantDomain, true);

                // Terminating idle tenant configuration contexts.
                terminateTenantConfigContext(tenantCfgCtx);
                tenantConfigContexts.remove(tenantDomain);
              } finally {
                PrivilegedCarbonContext.endTenantFlow();
              }
            }
          } finally {
            tenantWriteLock.unlock();
          }
        }
      }
    }
  }

  /**
   * Calculate the tenant domain from the complete URL
   *
   * @param url - incoming URL
   * @return - Tenant domain
   */
  public static String getTenantDomain(String url) {
    String[] strings = url.split("/");
    boolean foundTenantDelimiter = false;
    String tenant = null;
    for (String str : strings) {
      if (!foundTenantDelimiter && str.equals("t")) {
        foundTenantDelimiter = true;
        continue;
      }
      if (foundTenantDelimiter) {
        tenant = str;
        break;
      }
    }
    return tenant;
  }

  /**
   * Terminate the provided Tenant ConfigurationContext
   *
   * @param tenantCfgCtx The tenant ConfigurationContext which needs to be terminated
   */
  public static void terminateTenantConfigContext(ConfigurationContext tenantCfgCtx) {
    ConfigurationContext mainServerConfigContext =
        CarbonCoreDataHolder.getInstance().getMainServerConfigContext();
    Map<String, ConfigurationContext> tenantConfigContexts =
        getTenantConfigurationContexts(mainServerConfigContext);
    String tenantDomain = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantDomain();
    log.info("Starting to clean tenant : " + tenantDomain);
    tenantCfgCtx.getAxisConfiguration().getConfigurator().cleanup();
    try {
      doPreConfigContextTermination(tenantCfgCtx);
      tenantCfgCtx.terminate();
      doPostConfigContextTermination(tenantCfgCtx);
      tenantConfigContexts.remove(tenantDomain);
      log.info("Cleaned up tenant " + tenantDomain);
    } catch (AxisFault e) {
      log.error("Cannot cleanup ConfigurationContext of tenant " + tenantDomain, e);
    }
  }

  private static void doPreConfigContextCreation(int tenantId) {
    BundleContext bundleContext = CarbonCoreDataHolder.getInstance().getBundleContext();
    if (bundleContext != null) {
      ServiceTracker tracker =
          new ServiceTracker(
              bundleContext, Axis2ConfigurationContextObserver.class.getName(), null);
      tracker.open();
      Object[] services = tracker.getServices();
      if (services != null) {
        for (Object service : services) {
          ((Axis2ConfigurationContextObserver) service).creatingConfigurationContext(tenantId);
        }
      }
      tracker.close();
    }
  }

  private static void doPreConfigContextTermination(ConfigurationContext tenantCfgCtx) {
    BundleContext bundleContext = CarbonCoreDataHolder.getInstance().getBundleContext();
    if (bundleContext != null) {
      ServiceTracker tracker =
          new ServiceTracker(
              bundleContext, Axis2ConfigurationContextObserver.class.getName(), null);
      tracker.open();
      Object[] services = tracker.getServices();
      if (services != null) {
        for (Object service : services) {
          ((Axis2ConfigurationContextObserver) service)
              .terminatingConfigurationContext(tenantCfgCtx);
        }
      }
      tracker.close();
    }
  }

  private static void doPostConfigContextTermination(ConfigurationContext tenantCfgCtx) {
    BundleContext bundleContext = CarbonCoreDataHolder.getInstance().getBundleContext();
    if (bundleContext != null) {
      ServiceTracker tracker =
          new ServiceTracker(
              bundleContext, Axis2ConfigurationContextObserver.class.getName(), null);
      tracker.open();
      Object[] services = tracker.getServices();
      if (services != null) {
        for (Object service : services) {
          ((Axis2ConfigurationContextObserver) service)
              .terminatedConfigurationContext(tenantCfgCtx);
        }
      }
      tracker.close();
    }
  }
}
예제 #9
0
  public AxisConfiguration populateAxisConfiguration(InputStream in) throws DeploymentException {
    axisConfig = TenantAxisConfiguration.createInstance();
    PrivilegedCarbonContext carbonContext = PrivilegedCarbonContext.getCurrentContext(axisConfig);
    carbonContext.setTenantId(tenantId);
    carbonContext.setTenantDomain(tenantDomain);

    boolean isUrlRepo = CarbonUtils.isURL(repoLocation);
    if (repoLocation != null && repoLocation.trim().length() != 0) {
      try {
        if (isUrlRepo) {
          URL axis2Repository = new URL(repoLocation);
          axisConfig.setRepository(axis2Repository);
        } else {
          axisConfig.setRepository(new URL("file://" + repoLocation));
        }
      } catch (MalformedURLException e) {
        throw new DeploymentException("Invalid URL " + repoLocation, e);
      }
    }

    // Notify all observers
    if (bundleContext != null) {
      ServiceTracker tracker =
          new ServiceTracker(
              bundleContext, PreAxisConfigurationPopulationObserver.class.getName(), null);
      tracker.open();
      Object[] services = tracker.getServices();
      if (services != null) {
        for (Object service : services) {
          ((PreAxisConfigurationPopulationObserver) service).createdAxisConfiguration(axisConfig);
        }
      }
      tracker.close();
    }
    try {
      // Add the relevant AxisObservers to the tenantAxisConfig
      if (bundleContext != null) {
        ServiceTracker tracker =
            new ServiceTracker(bundleContext, AxisObserver.class.getName(), null);
        tracker.open();
        ServiceReference[] serviceRefs = tracker.getServiceReferences();
        if (serviceRefs != null) {
          for (ServiceReference serviceRef : serviceRefs) {
            if (serviceRef.getProperty(MultitenantConstants.TENANT_ID) != null
                && tenantId == (Integer) serviceRef.getProperty(MultitenantConstants.TENANT_ID)) {
              axisConfig.addObservers((AxisObserver) bundleContext.getService(serviceRef));
            }
          }
        }
        tracker.close();
      }

      // Set services dir
      File servicesDir =
          new File(repoLocation + File.separator + CarbonUtils.getAxis2ServicesDir(axisConfig));
      if (!servicesDir.exists() && !servicesDir.mkdirs()) {
        throw new DeploymentException(
            "Could not create services directory " + servicesDir.getAbsolutePath());
      }

      // Set modules dir
      String modulesDirName = "axis2modules";
      File modulesDir = new File(repoLocation + File.separator + modulesDirName);
      if (!modulesDir.exists() && !modulesDir.mkdirs()) {
        throw new DeploymentException(
            "Could not create modules directory " + modulesDir.getAbsolutePath());
      }
      axisConfig.addParameter(new Parameter(DeploymentConstants.MODULE_DRI_PATH, modulesDirName));
    } catch (AxisFault e) {
      String msg =
          "Cannot add DeploymentConstants.SERVICE_DIR_PATH or "
              + "DeploymentConstants.MODULE_DIR_PATH parameters";
      log.error(msg, e);
      throw new DeploymentException(msg, e);
    }

    carbonContext.setRegistry(RegistryType.SYSTEM_CONFIGURATION, registry);
    try {
      // TODO: The governance system registry should be passed into the tenant axis
      // configurator like the config system registry - Senaka.
      carbonContext.setRegistry(
          RegistryType.SYSTEM_GOVERNANCE,
          CarbonCoreDataHolder.getInstance()
              .getRegistryService()
              .getGovernanceSystemRegistry(tenantId));
      carbonContext.setRegistry(
          RegistryType.LOCAL_REPOSITORY,
          CarbonCoreDataHolder.getInstance().getRegistryService().getLocalRepository(tenantId));
    } catch (Exception ignored) {
      // We are not worried about the exception in here.
    }

    // The following two lines of code are kept for backward compatibility. Remove this once we
    // are certain that this is not required. -- Senaka.
    // Please also note that we no longer need to set the user realm to the configuration
    // explicitly.
    setRegistry();
    setUserRealm();

    // Add the DeploymentInterceptor for the tenant AxisConfigurations
    DeploymentInterceptor interceptor = new DeploymentInterceptor();
    interceptor.setRegistry(registry);
    interceptor.init(axisConfig);
    axisConfig.addObservers(interceptor);

    setHostName(axisConfig);

    // TCCL will be based on OSGi
    AxisConfigBuilder builder = new AxisConfigBuilder(in, axisConfig, this);
    builder.populateConfig();
    try {
      if (in != null) {
        in.close();
      }
    } catch (IOException e) {
      String msg = "error in closing input stream";
      log.error(msg, e);
    }
    axisConfig.setConfigurator(this);
    Parameter disableArtifactLoading = axisConfig.getParameter("DisableArtifactLoading");
    if (disableArtifactLoading == null || "false".equals(disableArtifactLoading.getValue())) {
      moduleDeployer = new ModuleDeployer(axisConfig);
      new Axis2ModuleRegistry(axisConfig).register(moduleBundles);
      // Add Ghost deployer registry only if ghost is on
      if (GhostDeployerUtils.isGhostOn()) {
        new GhostDeployerRegistry(axisConfig).register(deployerBundles);
      } else {
        new Axis2DeployerRegistry(axisConfig).register(deployerBundles);
      }
    }
    return axisConfig;
  }