How to use org.apache.shardingsphere.orchestration.internal.registry.config.service

private void persistRuleConfiguration(final String shardingSchemaName, final RuleConfiguration ruleConfig, final boolean isOverwrite) {
  if (isOverwrite || !hasRuleConfiguration(shardingSchemaName)) {
    if (ruleConfig instanceof ShardingRuleConfiguration) {
      persistShardingRuleConfiguration(shardingSchemaName, (ShardingRuleConfiguration) ruleConfig);
    } else {
      persistMasterSlaveRuleConfiguration(shardingSchemaName, (MasterSlaveRuleConfiguration) ruleConfig);
    }
  }
}

private RuleConfiguration createRuleConfiguration(final String shardingSchemaName) {
  return configurationService.isShardingRule(shardingSchemaName) 
      ? configurationService.loadShardingRuleConfiguration(shardingSchemaName) : configurationService.loadMasterSlaveRuleConfiguration(shardingSchemaName);
}

private boolean isOwnCompleteConfigurations(final String shardingSchemaName) {
  return configurationService.hasDataSourceConfiguration(shardingSchemaName) && configurationService.hasRuleConfiguration(shardingSchemaName);
}

private static Map<String, RuleConfiguration> getSchemaRules(final ShardingOrchestrationFacade shardingOrchestrationFacade) {
  Map<String, RuleConfiguration> result = new LinkedHashMap<>();
  for (String each : shardingOrchestrationFacade.getConfigService().getAllShardingSchemaNames()) {
    if (shardingOrchestrationFacade.getConfigService().isShardingRule(each)) {
      result.put(each, shardingOrchestrationFacade.getConfigService().loadShardingRuleConfiguration(each));
    } else {
      result.put(each, shardingOrchestrationFacade.getConfigService().loadMasterSlaveRuleConfiguration(each));
    }
  }
  return result;
}

public OrchestrationShardingDataSource(final OrchestrationConfiguration orchestrationConfig) throws SQLException {
  super(new ShardingOrchestrationFacade(orchestrationConfig, Collections.singletonList(ShardingConstant.LOGIC_SCHEMA_NAME)));
  ConfigurationService configService = getShardingOrchestrationFacade().getConfigService();
  ShardingRuleConfiguration shardingRuleConfig = configService.loadShardingRuleConfiguration(ShardingConstant.LOGIC_SCHEMA_NAME);
  Preconditions.checkState(null != shardingRuleConfig && !shardingRuleConfig.getTableRuleConfigs().isEmpty(), "Missing the sharding rule configuration on registry center");
  dataSource = new ShardingDataSource(DataSourceConverter.getDataSourceMap(configService.loadDataSourceConfigurations(ShardingConstant.LOGIC_SCHEMA_NAME)),
      new OrchestrationShardingRule(shardingRuleConfig, configService.loadDataSourceConfigurations(ShardingConstant.LOGIC_SCHEMA_NAME).keySet()),
      configService.loadConfigMap(), configService.loadProperties());
  getShardingOrchestrationFacade().init();
}

public OrchestrationMasterSlaveDataSource(final OrchestrationConfiguration orchestrationConfig) throws SQLException {
  super(new ShardingOrchestrationFacade(orchestrationConfig, Collections.singletonList(ShardingConstant.LOGIC_SCHEMA_NAME)));
  ConfigurationService configService = getShardingOrchestrationFacade().getConfigService();
  MasterSlaveRuleConfiguration masterSlaveRuleConfig = configService.loadMasterSlaveRuleConfiguration(ShardingConstant.LOGIC_SCHEMA_NAME);
  Preconditions.checkState(null != masterSlaveRuleConfig && !Strings.isNullOrEmpty(masterSlaveRuleConfig.getMasterDataSourceName()), "No available master slave rule configuration to load.");
  dataSource = new MasterSlaveDataSource(DataSourceConverter.getDataSourceMap(configService.loadDataSourceConfigurations(ShardingConstant.LOGIC_SCHEMA_NAME)),
      new OrchestrationMasterSlaveRule(masterSlaveRuleConfig), configService.loadConfigMap(), configService.loadProperties());
  getShardingOrchestrationFacade().init();
}

private static void startWithRegistryCenter(final YamlProxyServerConfiguration serverConfig,
                      final Collection<String> shardingSchemaNames, final Map<String, YamlProxyRuleConfiguration> ruleConfigs, final int port) throws InterruptedException {
  try (ShardingOrchestrationFacade shardingOrchestrationFacade = new ShardingOrchestrationFacade(serverConfig.getOrchestration().getOrchestrationConfiguration(), shardingSchemaNames)) {
    initShardingOrchestrationFacade(serverConfig, ruleConfigs, shardingOrchestrationFacade);
    GlobalRegistry.getInstance().init(getSchemaDataSourceParameterMap(shardingOrchestrationFacade), getSchemaRules(shardingOrchestrationFacade),
        shardingOrchestrationFacade.getConfigService().loadAuthentication(), shardingOrchestrationFacade.getConfigService().loadConfigMap(),
        shardingOrchestrationFacade.getConfigService().loadProperties(), true);
    initOpenTracing();
    ShardingProxy.getInstance().start(port);
  }
}

private static Map<String, Map<String, YamlDataSourceParameter>> getSchemaDataSourceParameterMap(final ShardingOrchestrationFacade shardingOrchestrationFacade) {
  Map<String, Map<String, YamlDataSourceParameter>> result = new LinkedHashMap<>();
  for (String each : shardingOrchestrationFacade.getConfigService().getAllShardingSchemaNames()) {
    result.put(each, DataSourceConverter.getDataSourceParameterMap(shardingOrchestrationFacade.getConfigService().loadDataSourceConfigurations(each)));
  }
  return result;
}

/**
 * Persist rule configuration.
 *
 * @param shardingSchemaName sharding schema name
 * @param dataSourceConfigs data source configuration map
 * @param ruleConfig rule configuration
 * @param authentication authentication
 * @param configMap config map
 * @param props sharding properties
 * @param isOverwrite is overwrite registry center's configuration
 */
public void persistConfiguration(final String shardingSchemaName, final Map<String, DataSourceConfiguration> dataSourceConfigs, final RuleConfiguration ruleConfig,
                 final Authentication authentication, final Map<String, Object> configMap, final Properties props, final boolean isOverwrite) {
  persistDataSourceConfiguration(shardingSchemaName, dataSourceConfigs, isOverwrite);
  persistRuleConfiguration(shardingSchemaName, ruleConfig, isOverwrite);
  persistAuthentication(authentication, isOverwrite);
  persistConfigMap(configMap, isOverwrite);
  persistProperties(props, isOverwrite);
}

private SchemaAddedEvent createSchemaAddedEvent(final String shardingSchemaName) {
  existedSchemaNames.add(shardingSchemaName);
  return new SchemaAddedEvent(shardingSchemaName, configurationService.loadDataSourceConfigurations(shardingSchemaName), createRuleConfiguration(shardingSchemaName));
}

public ShardingOrchestrationFacade(final OrchestrationConfiguration orchestrationConfig, final Collection<String> shardingSchemaNames) {
  regCenter = RegistryCenterLoader.load(orchestrationConfig.getRegCenterConfig());
  isOverwrite = orchestrationConfig.isOverwrite();
  configService = new ConfigurationService(orchestrationConfig.getName(), regCenter);
  stateService = new StateService(orchestrationConfig.getName(), regCenter);
  listenerManager = shardingSchemaNames.isEmpty() ? new ShardingOrchestrationListenerManager(orchestrationConfig.getName(), regCenter, configService.getAllShardingSchemaNames())
      : new ShardingOrchestrationListenerManager(orchestrationConfig.getName(), regCenter, shardingSchemaNames);
}

public SchemaChangedListener(final String name, final RegistryCenter regCenter, final Collection<String> shardingSchemaNames) {
  super(regCenter, new ConfigurationNode(name).getSchemaPath());
  configurationService = new ConfigurationService(name, regCenter);
  configurationNode = new ConfigurationNode(name);
  existedSchemaNames.addAll(shardingSchemaNames);
}

/**
 * Initialize for orchestration.
 *
 * @param dataSourceConfigurationMap schema data source configuration map
 * @param schemaRuleMap schema rule map
 * @param authentication authentication
 * @param configMap config Map
 * @param props properties
 */
public void init(final Map<String, Map<String, DataSourceConfiguration>> dataSourceConfigurationMap,
         final Map<String, RuleConfiguration> schemaRuleMap, final Authentication authentication, final Map<String, Object> configMap, final Properties props) {
  for (Entry<String, Map<String, DataSourceConfiguration>> entry : dataSourceConfigurationMap.entrySet()) {
    configService.persistConfiguration(entry.getKey(), dataSourceConfigurationMap.get(entry.getKey()), schemaRuleMap.get(entry.getKey()), authentication, configMap, props, isOverwrite);
  }
  stateService.persistInstanceOnline();
  stateService.persistDataSourcesNode();
  listenerManager.initListeners();
}

private void persistDataSourceConfiguration(final String shardingSchemaName, final Map<String, DataSourceConfiguration> dataSourceConfigs, final boolean isOverwrite) {
  if (isOverwrite || !hasDataSourceConfiguration(shardingSchemaName)) {
    Preconditions.checkState(null != dataSourceConfigs && !dataSourceConfigs.isEmpty(), "No available data source in `%s` for orchestration.", shardingSchemaName);
    regCenter.persist(configNode.getDataSourcePath(shardingSchemaName), new DataSourceConfigurationsYamlDumper().dump(dataSourceConfigs));
  }
}

private void persistAuthentication(final Authentication authentication, final boolean isOverwrite) {
  if (null != authentication && (isOverwrite || !hasAuthentication())) {
    regCenter.persist(configNode.getAuthenticationPath(), new AuthenticationYamlDumper().dump(authentication));
  }
}

private void persistProperties(final Properties props, final boolean isOverwrite) {
  if (isOverwrite || !hasProperties()) {
    regCenter.persist(configNode.getPropsPath(), new PropertiesYamlDumper().dump(props));
  }
}

private void persistConfigMap(final Map<String, Object> configMap, final boolean isOverwrite) {
  if (isOverwrite || !hasConfigMap()) {
    regCenter.persist(configNode.getConfigMapPath(), new ConfigMapYamlDumper().dump(configMap));
  }
}

private static Map<String, RuleConfiguration> getSchemaRules(final ShardingOrchestrationFacade shardingOrchestrationFacade) {
  Map<String, RuleConfiguration> result = new LinkedHashMap<>();
  for (String each : shardingOrchestrationFacade.getConfigService().getAllShardingSchemaNames()) {
    if (shardingOrchestrationFacade.getConfigService().isShardingRule(each)) {
      result.put(each, shardingOrchestrationFacade.getConfigService().loadShardingRuleConfiguration(each));
    } else {
      result.put(each, shardingOrchestrationFacade.getConfigService().loadMasterSlaveRuleConfiguration(each));
    }
  }
  return result;
}

private static void startWithRegistryCenter(final YamlProxyServerConfiguration serverConfig,
                      final Collection<String> shardingSchemaNames, final Map<String, YamlProxyRuleConfiguration> ruleConfigs, final int port) throws InterruptedException {
  try (ShardingOrchestrationFacade shardingOrchestrationFacade = new ShardingOrchestrationFacade(serverConfig.getOrchestration().getOrchestrationConfiguration(), shardingSchemaNames)) {
    initShardingOrchestrationFacade(serverConfig, ruleConfigs, shardingOrchestrationFacade);
    GlobalRegistry.getInstance().init(getSchemaDataSourceParameterMap(shardingOrchestrationFacade), getSchemaRules(shardingOrchestrationFacade),
        shardingOrchestrationFacade.getConfigService().loadAuthentication(), shardingOrchestrationFacade.getConfigService().loadConfigMap(),
        shardingOrchestrationFacade.getConfigService().loadProperties(), true);
    initOpenTracing();
    ShardingProxy.getInstance().start(port);
  }
}

private static Map<String, Map<String, YamlDataSourceParameter>> getSchemaDataSourceParameterMap(final ShardingOrchestrationFacade shardingOrchestrationFacade) {
  Map<String, Map<String, YamlDataSourceParameter>> result = new LinkedHashMap<>();
  for (String each : shardingOrchestrationFacade.getConfigService().getAllShardingSchemaNames()) {
    result.put(each, DataSourceConverter.getDataSourceParameterMap(shardingOrchestrationFacade.getConfigService().loadDataSourceConfigurations(each)));
  }
  return result;
}