private void initPersistence(
      String configName,
      ConfigurationContext configurationContext,
      ServerContextInformation contextInfo)
      throws RegistryException, AxisFault {
    // Initialize the mediation persistence manager if required
    ServerConfiguration serverConf = ServerConfiguration.getInstance();
    String persistence = serverConf.getFirstProperty(ServiceBusConstants.PERSISTENCE);
    org.wso2.carbon.registry.core.Registry configRegistry =
        (org.wso2.carbon.registry.core.Registry)
            SuperTenantCarbonContext.getCurrentContext(configurationContext)
                .getRegistry(RegistryType.SYSTEM_CONFIGURATION);

    // Check whether persistence is disabled
    if (!ServiceBusConstants.DISABLED.equals(persistence)) {

      // Check registry persistence is disabled or not
      String regPersistence = serverConf.getFirstProperty(ServiceBusConstants.REGISTRY_PERSISTENCE);
      UserRegistry registry =
          ServiceBusConstants.DISABLED.equals(regPersistence)
              ? null
              : (UserRegistry) configRegistry;

      // Check the worker interval is set or not
      String interval = serverConf.getFirstProperty(ServiceBusConstants.WORKER_INTERVAL);
      long intervalInMillis = 5000L;
      if (interval != null && !"".equals(interval)) {
        try {
          intervalInMillis = Long.parseLong(interval);
        } catch (NumberFormatException e) {
          log.error(
              "Invalid value "
                  + interval
                  + " specified for the mediation "
                  + "persistence worker interval, Using defaults",
              e);
        }
      }

      MediationPersistenceManager pm =
          new MediationPersistenceManager(
              registry,
              contextInfo.getServerConfigurationInformation().getSynapseXMLLocation(),
              contextInfo.getSynapseConfiguration(),
              intervalInMillis,
              configName);

      configurationContext
          .getAxisConfiguration()
          .addParameter(new Parameter(ServiceBusConstants.PERSISTENCE_MANAGER, pm));
    } else {
      log.info("Persistence for mediation configuration is disabled");
    }
  }
  public void createdConfigurationContext(ConfigurationContext configurationContext) {
    ServerContextInformation contextInfo;
    String tenantDomain =
        SuperTenantCarbonContext.getCurrentContext(configurationContext).getTenantDomain();

    log.info("Intializing the ESB Configuration for the tenant domain : " + tenantDomain);

    try {
      // first check which configuration should be active
      org.wso2.carbon.registry.core.Registry registry =
          (org.wso2.carbon.registry.core.Registry)
              SuperTenantCarbonContext.getCurrentContext(configurationContext)
                  .getRegistry(RegistryType.SYSTEM_CONFIGURATION);

      AxisConfiguration axisConfig = configurationContext.getAxisConfiguration();

      // initialize the lock
      Lock lock = new ReentrantLock();
      axisConfig.addParameter(ServiceBusConstants.SYNAPSE_CONFIG_LOCK, lock);

      // creates the synapse configuration directory hierarchy if not exists
      // useful at the initial tenant creation
      File tenantAxis2Repo =
          new File(configurationContext.getAxisConfiguration().getRepository().getFile());
      File synapseConfigsDir = new File(tenantAxis2Repo, ServiceBusConstants.SYNAPSE_CONFIGS);
      if (!synapseConfigsDir.exists()) {
        if (!synapseConfigsDir.mkdir()) {
          log.fatal(
              "Couldn't create the synapse-config root on the file system "
                  + "for the tenant domain : "
                  + tenantDomain);
          return;
        }
      }

      String synapseConfigsDirLocation = synapseConfigsDir.getAbsolutePath();

      // set the required configuration parameters to initialize the ESB
      axisConfig.addParameter(
          SynapseConstants.Axis2Param.SYNAPSE_CONFIG_LOCATION, synapseConfigsDirLocation);

      // init the multiple configuration tracker
      ConfigurationManager manger =
          new ConfigurationManager((UserRegistry) registry, configurationContext);
      manger.init();

      File synapseConfigDir =
          new File(synapseConfigsDir, manger.getTracker().getCurrentConfigurationName());
      if (!synapseConfigDir.exists()) {
        createTenantSynapseConfigHierarchy(synapseConfigDir, tenantDomain);
      }

      axisConfig.addParameter(
          SynapseConstants.Axis2Param.SYNAPSE_HOME, tenantAxis2Repo.getAbsolutePath());
      axisConfig.addParameter(
          SynapseConstants.Axis2Param.SYNAPSE_SERVER_NAME, "synapse." + tenantDomain);
      axisConfig.addParameter(
          SynapseConstants.Axis2Param.SYNAPSE_RESOLVE_ROOT, tenantAxis2Repo.getAbsolutePath());

      // Initialize Synapse
      contextInfo =
          initESB(manger.getTracker().getCurrentConfigurationName(), configurationContext);

      if (contextInfo == null) {
        handleFatal("Failed to intilize the ESB for tenent:" + tenantDomain);
      }

      initPersistence(
          manger.getTracker().getCurrentConfigurationName(), configurationContext, contextInfo);

      configurationContext.setProperty(ConfigurationManager.CONFIGURATION_MANAGER, manger);

      int tenantId = SuperTenantCarbonContext.getCurrentContext(configurationContext).getTenantId();
      // populate the SynapseEnv service and SynapseConfig OSGI Services so that other
      // components get to know about the availability of the new synapse configuration
      Properties props = new Properties();
      SynapseConfigurationService synCfgSvc =
          new SynapseConfigurationServiceImpl(
              contextInfo.getSynapseConfiguration(), tenantId, configurationContext);

      ServiceRegistration confRegistration =
          ConfigurationHolder.getInstance()
              .getBundleContext()
              .registerService(SynapseConfigurationService.class.getName(), synCfgSvc, props);

      props = new Properties();
      SynapseEnvironmentService synEnvSvc =
          new SynapseEnvironmentServiceImpl(
              contextInfo.getSynapseEnvironment(), tenantId, configurationContext);
      ServiceRegistration envRegistration =
          ConfigurationHolder.getInstance()
              .getBundleContext()
              .registerService(SynapseEnvironmentService.class.getName(), synEnvSvc, props);

      props = new Properties();
      SynapseRegistrationsService synRegistrationsSvc =
          new SynapseRegistrationsServiceImpl(
              confRegistration, envRegistration, tenantId, configurationContext);
      ServiceRegistration synapseRegistration =
          ConfigurationHolder.getInstance()
              .getBundleContext()
              .registerService(
                  SynapseRegistrationsService.class.getName(), synRegistrationsSvc, props);

      ConfigurationTrackingService trackingService =
          ServiceBusInitializer.getConfigurationTrackingService();
      if (trackingService != null) {
        trackingService.setSynapseConfiguration(contextInfo.getSynapseConfiguration());
      }

      // set the event broker as a property for tenants
      EventBroker eventBroker = ServiceBusInitializer.getEventBroker();
      if (eventBroker != null) {
        configurationContext.setProperty("mediation.event.broker", eventBroker);
      }

      ConfigurationHolder.getInstance().addSynapseRegistration(tenantId, synapseRegistration);

    } catch (Exception e) {
      handleFatal("Couldn't initialize the ESB for tenant:" + tenantDomain, e);
    } catch (Throwable t) {
      log.fatal("Failed to initialize ESB for tenant:" + tenantDomain + "due to a fatal error", t);
    }
  }
  private ServerContextInformation initESB(
      String configurationName, ConfigurationContext configurationContext) throws AxisFault {
    ServerConfigurationInformation configurationInformation =
        ServerConfigurationInformationFactory.createServerConfigurationInformation(
            configurationContext.getAxisConfiguration());
    // ability to specify the SynapseServerName as a system property
    if (System.getProperty("SynapseServerName") != null) {
      configurationInformation.setServerName(System.getProperty("SynapseServerName"));
    }

    // for now we override the default configuration location with the value in registry
    String repoPath = configurationContext.getAxisConfiguration().getRepository().getPath();
    configurationInformation.setSynapseXMLLocation(
        repoPath
            + File.separator
            + ServiceBusConstants.SYNAPSE_CONFIGS
            + File.separator
            + configurationName);

    configurationInformation.setCreateNewInstance(false);
    configurationInformation.setServerControllerProvider(CarbonSynapseController.class.getName());
    if (isRunningSamplesMode()) {
      configurationInformation.setSynapseXMLLocation(
          "repository"
              + File.separator
              + "samples"
              + File.separator
              + "synapse_sample_"
              + System.getProperty(ServiceBusConstants.ESB_SAMPLE_SYSTEM_PROPERTY)
              + ".xml");
    }

    ServerManager serverManager = new ServerManager();
    ServerContextInformation contextInfo =
        new ServerContextInformation(configurationContext, configurationInformation);

    /*if (dataSourceInformationRepositoryService != null) {
        DataSourceInformationRepository repository =
                dataSourceInformationRepositoryService.getDataSourceInformationRepository();
        contextInfo.addProperty(DataSourceConstants.DATA_SOURCE_INFORMATION_REPOSITORY,
                repository);
    }*/

    TaskScheduler scheduler;
    if (configurationContext.getProperty(ServiceBusConstants.CARBON_TASK_SCHEDULER) == null) {
      scheduler = new TaskScheduler(TaskConstants.TASK_SCHEDULER);
      configurationContext.setProperty(ServiceBusConstants.CARBON_TASK_SCHEDULER, scheduler);
    } else {
      scheduler =
          (TaskScheduler)
              configurationContext.getProperty(ServiceBusConstants.CARBON_TASK_SCHEDULER);
    }
    contextInfo.addProperty(TaskConstants.TASK_SCHEDULER, scheduler);

    TaskDescriptionRepository repository;
    if (configurationContext.getProperty(ServiceBusConstants.CARBON_TASK_REPOSITORY) == null) {
      repository = new TaskDescriptionRepository();
      configurationContext.setProperty(ServiceBusConstants.CARBON_TASK_REPOSITORY, repository);
    } else {
      repository =
          (TaskDescriptionRepository)
              configurationContext.getProperty(ServiceBusConstants.CARBON_TASK_REPOSITORY);
    }
    contextInfo.addProperty(TaskConstants.TASK_DESCRIPTION_REPOSITORY, repository);

    /* if (secretCallbackHandlerService != null) {
        contextInfo.addProperty(SecurityConstants.PROP_SECRET_CALLBACK_HANDLER,
                secretCallbackHandlerService.getSecretCallbackHandler());
    }*/

    AxisConfiguration axisConf = configurationContext.getAxisConfiguration();
    axisConf.addParameter(
        new Parameter(ServiceBusConstants.SYNAPSE_CURRENT_CONFIGURATION, configurationName));

    serverManager.init(configurationInformation, contextInfo);
    serverManager.start();

    AxisServiceGroup serviceGroup = axisConf.getServiceGroup(SynapseConstants.SYNAPSE_SERVICE_NAME);
    serviceGroup.addParameter("hiddenService", "true");

    addDeployers(configurationContext);

    return contextInfo;
  }