Maintainer SDK

<!-- Supported in version 3.0.0 and later -->
<dependency>
    <groupId>com.alibaba.nacos</groupId>
    <artifactId>nacos-maintainer-client</artifactId>
    <version>${nacos.client.version}</version>
</dependency>

Properties properties = new Properties();
// Specify the Nacos Server address
properties.setProperty("serverAddr","localhost:8848");

// Set the Nacos administrator username and password
properties.setProperty("username","nacos");
properties.setProperty("password","{your_admin_password}");

// Initialize the Nacos Maintainer Service for the config center
ConfigMaintainerService configMaintainerService = ConfigMaintainerFactory.createConfigMaintainerService(properties);

// Initialize the Nacos Maintainer Service for the service registry
NamingMaintainerService maintainService = NamingMaintainerFactory.createNamingMaintainerService(properties);

ConfigDetailInfo getConfig(String dataId) throws NacosException;

ConfigDetailInfo getConfig(String dataId, String groupName) throws NacosException;

ConfigDetailInfo getConfig(String dataId, String groupName, String namespaceId) throws NacosException;

try {
    // The following three calls all obtain config information for dataId `maintain.client.test` and groupName `DEFAULT_GROUP` under the `public` namespace.
    ConfigDetailInfo configDetailInfo = configMaintainerService.getConfig("maintain.client.test");
    configDetailInfo = configMaintainerService.getConfig("maintain.client.test", Constants.DEFAULT_GROUP);
    configDetailInfo = configMaintainerService.getConfig("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID);
} catch (NacosException e) {
    e.printStackTrace();
}

boolean publishConfig(String dataId, String content) throws NacosException;

boolean publishConfig(String dataId, String groupName, String content) throws NacosException;

boolean publishConfig(String dataId, String groupName, String namespaceId, String content) throws NacosException;

boolean publishConfig(String dataId, String groupName, String namespaceId, String content, String desc) throws NacosException;

boolean publishConfig(String dataId, String groupName, String namespaceId, String content, String desc, String type) throws NacosException;

boolean publishConfig(String dataId, String groupName, String namespaceId, String content, String appName, String srcUser, String configTags, String desc, String type) throws NacosException;

try {
    // The following calls all create a config with groupName `DEFAULT_GROUP`, dataId `maintain.client.test`, and content `testContent` under the `public` namespace.
    boolean result = configMaintainerService.publishConfig("maintain.client.test", "testContent");
    result = configMaintainerService.publishConfig("maintain.client.test", Constants.DEFAULT_GROUP, "testContent");
    result = configMaintainerService.publishConfig("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, "testContent");
    result = configMaintainerService.publishConfig("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, "testContent", "test");
    result = configMaintainerService.publishConfig("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, "testContent", "test", "TEXT");
    result = configMaintainerService.publishConfig("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, "testContent", "testApp", null, "testTag", "test", "TEXT");
} catch (NacosException e) {
    e.printStackTrace();
}

boolean deleteConfig(String dataId) throws NacosException;

boolean deleteConfig(String dataId, String groupName) throws NacosException;

boolean deleteConfig(String dataId, String groupName, String namespaceId) throws NacosException;

try {
    // The following three calls all delete the config with groupName `DEFAULT_GROUP` and dataId `maintain.client.test` under the `public` namespace.
    boolean result =  configMaintainerService.deleteConfig("maintain.client.test");
    result = configMaintainerService.deleteConfig("maintain.client.test", Constants.DEFAULT_GROUP);
    result = configMaintainerService.deleteConfig("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID);
} catch (NacosException e) {
    e.printStackTrace();
}

boolean deleteConfigs(List<Long> ids) throws NacosException;

try {
    ConfigDetailInfo configDetailInfo = configMaintainerService.getConfig("maintain.client.test");
    boolean result = configMaintainerService.deleteConfigs(Collections.singletonList(configDetailInfo.getId()));
} catch (NacosException e) {
    e.printStackTrace();
}

Page<ConfigBasicInfo> listConfigs(String namespaceId) throws NacosException;

Page<ConfigBasicInfo> listConfigs(String dataId, String groupName, String namespaceId) throws NacosException;

Page<ConfigBasicInfo> listConfigs(String dataId, String groupName, String namespaceId, String type) throws NacosException;

Page<ConfigBasicInfo> listConfigs(String dataId, String groupName, String namespaceId, String type, String configTags, String appName) throws NacosException;

Page<ConfigBasicInfo> listConfigs(String dataId, String groupName, String namespaceId, String type, String configTags, String appName, int pageNo, int pageSize) throws NacosException;

try {
    // Gets the first page of all configs under the `public` namespace (up to 100 configs).
    Page<ConfigBasicInfo> result = configMaintainerService.listConfigs(Constants.DEFAULT_NAMESPACE_ID);
    // Gets the first page of all configs whose config group is `DEFAULT_GROUP` under the `public` namespace (up to 100 configs).
    result = configMaintainerService.listConfigs("", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID);
    // Gets the first page of all configs whose type is `JSON` under the `public` namespace (up to 100 configs).
    result = configMaintainerService.listConfigs("", "", Constants.DEFAULT_NAMESPACE_ID, "JSON");
    // Gets the first page of all configs under the `public` namespace whose tag is `testTag1` and application is `testApp` (up to 100 configs).
    result = configMaintainerService.listConfigs("", "", Constants.DEFAULT_NAMESPACE_ID, "", "testTag1", "testApp");
    // Gets the first page of all configs under the `public` namespace (up to 10 configs).
    result = configMaintainerService.listConfigs("", "", Constants.DEFAULT_NAMESPACE_ID, "", "", "", 1, 10);
} catch (NacosException e) {
    e.printStackTrace();
}

Page<ConfigBasicInfo> searchConfigs(String dataId, String groupName, String namespaceId) throws NacosException;

Page<ConfigBasicInfo> searchConfigs(String dataId, String groupName, String namespaceId, String type) throws NacosException;

Page<ConfigBasicInfo> searchConfigs(String dataId, String groupName, String namespaceId, String configDetail, String type) throws NacosException;

Page<ConfigBasicInfo> searchConfigs(String dataId, String groupName, String namespaceId, String configDetail, String type, String configTags, String appName) throws NacosException;

Page<ConfigBasicInfo> searchConfigs(String dataId, String groupName, String namespaceId, String configDetail, String type, String configTags, String appName, int pageNo, int pageSize) throws NacosException;

try {
    // Gets the first page of all configs under the `public` namespace whose config group contains `test` (up to 100 configs).
    Page<ConfigBasicInfo> result = configMaintainerService.searchConfigs("", "test", Constants.DEFAULT_NAMESPACE_ID);
    // Gets the first page of all configs whose type is `JSON` under the `public` namespace (up to 100 configs).
    result = configMaintainerService.searchConfigs("", "", Constants.DEFAULT_NAMESPACE_ID, "JSON");
    // Gets the first page of all configs under the `public` namespace whose content contains `test` (up to 100 configs).
    result = configMaintainerService.searchConfigs("", "", Constants.DEFAULT_NAMESPACE_ID, "test", "");
    // Gets the first page of all configs under the `public` namespace whose tag is `testTag1` and application is `testApp` (up to 100 configs).
    result = configMaintainerService.searchConfigs("", "", Constants.DEFAULT_NAMESPACE_ID, "", "", "testTag1", "testApp");
    // Gets the first page of all configs under the `public` namespace (up to 10 configs).
    result = configMaintainerService.searchConfigs("", "", Constants.DEFAULT_NAMESPACE_ID, "", "", "", "", 1, 10);
} catch (NacosException e) {
    e.printStackTrace();
}

Map<String, Object> cloneConfig(String namespaceId, List<ConfigCloneInfo> cloneInfos, String srcUser, SameConfigPolicy policy) throws NacosException;

try {
    // Clones the config whose ID is 1 to the `clone-test` namespace with the clone policy `ABORT`. If a config with the same name exists in the target namespace, the clone fails.
    ConfigCloneInfo configCloneInfo = new ConfigCloneInfo();
    configCloneInfo.setConfigId(1L);
    Map<String, Object> result = configMaintainerService.cloneConfig("clone-test", Collections.singletonList(configCloneInfo), "", SameConfigPolicy.ABORT);
} catch (NacosException e) {
    e.printStackTrace();
}

List<ConfigBasicInfo> getConfigListByNamespace(String namespaceId) throws NacosException;

try {
    List<ConfigBasicInfo> result = configMaintainerService.getConfigListByNamespace(Constants.DEFAULT_NAMESPACE_ID);
} catch (NacosException e) {
    e.printStackTrace();
}

ConfigListenerInfo getListeners(String dataId, String groupName) throws NacosException;

ConfigListenerInfo getListeners(String dataId, String groupName, String namespaceId, boolean aggregation) throws NacosException;

try {
    // The following two calls both obtain the cluster-wide subscriber list of config `maintain.client.test` in group `DEFAULT_GROUP` under namespace `public`.
    ConfigListenerInfo result = configMaintainerService.getListeners("maintain.client.test", Constants.DEFAULT_GROUP);
    result = configMaintainerService.getListeners("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, true);
} catch (NacosException e) {
    e.printStackTrace();
}

ConfigListenerInfo getAllSubClientConfigByIp(String ip, boolean all, String namespaceId, boolean aggregation) throws NacosException;

try {
    ConfigListenerInfo result = configMaintainerService.getAllSubClientConfigByIp("127.0.0.1", false, Constants.DEFAULT_NAMESPACE_ID, true);
} catch (NacosException e) {
    e.printStackTrace();
}

boolean publishBetaConfig(String dataId, String groupName, String namespaceId, String content, String appName, String srcUser, String configTags, String desc, String type, String betaIps) throws NacosException;

try {
    // Performs beta gray release of config `maintain.client.test` for IP `127.0.0.1`.
    boolean result = configMaintainerService.publishBetaConfig("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, "testBeta", "testApp", "", "testTag1", "test", "TEXT", "127.0.0.1");
} catch (NacosException e) {
    e.printStackTrace();
}

boolean stopBeta(String dataId, String groupName) throws NacosException;

boolean stopBeta(String dataId, String groupName, String namespaceId) throws NacosException;

try {
    // Performs beta gray release of config `maintain.client.test` for IP `127.0.0.1`.
    boolean result = configMaintainerService.publishBetaConfig("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, "testBeta", "testApp", "", "testTag1", "test", "TEXT", "127.0.0.1");
    // Stops the beta gray release of config `maintain.client.test`.
    result = configMaintainerService.stopBeta("maintain.client.test", Constants.DEFAULT_GROUP);
    result = configMaintainerService.stopBeta("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID);
} catch (NacosException e) {
    e.printStackTrace();
}

ConfigGrayInfo queryBeta(String dataId, String groupName) throws NacosException;

ConfigGrayInfo queryBeta(String dataId, String groupName, String namespaceId) throws NacosException;

try {
    // Performs beta gray release of config `maintain.client.test` for IP `127.0.0.1`.
    boolean publishResult = configMaintainerService.publishBetaConfig("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, "testBeta", "testApp", "", "testTag1", "test", "TEXT", "127.0.0.1");
    // Queries the beta gray release of config `maintain.client.test`.
    ConfigGrayInfo result = configMaintainerService.queryBeta("maintain.client.test", Constants.DEFAULT_GROUP);
    result = configMaintainerService.queryBeta("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID);}
catch (NacosException e) {
    e.printStackTrace();
}

Page<ConfigHistoryBasicInfo> listConfigHistory(String dataId, String group, String namespaceId, Integer pageNo, Integer pageSize) throws NacosException;

try {
    // Queries the historical version list of config `maintain.client.test`.
    Page<ConfigHistoryBasicInfo> configHistoryBasicInfoPage = configMaintainerService.listConfigHistory("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, 1, 10);
} catch (NacosException e) {
    e.printStackTrace();
}

ConfigHistoryDetailInfo getConfigHistoryInfo(String dataId, String groupName, String namespaceId, Long nid) throws NacosException;

try {
    // Queries the historical version list of config `maintain.client.test`.
    Page<ConfigHistoryBasicInfo> configHistoryBasicInfoPage = configMaintainerService.listConfigHistory("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, 1, 10);
    int nid = configHistoryBasicInfoPage.getPageItems().get(0).getId();
    // Queries the details of the first historical version in the historical version list of config `maintain.client.test`.
    ConfigHistoryDetailInfo result = configMaintainerService.getConfigHistoryInfo("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, nid);
} catch (NacosException e) {
    e.printStackTrace();
}

ConfigHistoryDetailInfo getPreviousConfigHistoryInfo(String dataId, String groupName, String namespaceId, Long id) throws NacosException;

try {
    // Gets the ID of config `maintain.client.test`.
    int id = configMaintainerService.getConfig("maintain.client.test").getId();
    // Gets the details of the previous historical version of config `maintain.client.test`.
    ConfigHistoryDetailInfo result = configMaintainerService.getPreviousConfigHistoryInfo("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, id);
} catch (NacosException e) {
    e.printStackTrace();
}

String updateLocalCacheFromStore() throws NacosException;

try {
    configMaintainerService.updateLocalCacheFromStore();
} catch (NacosException e) {
    e.printStackTrace();
}

String setLogLevel(String logName, String logLevel) throws NacosException;

try {
    configMaintainerService.setLogLevel("config-server", "DEBUG");
} catch (NacosException e) {
    e.printStackTrace();
}

boolean updateConfigMetadata(String dataId, String groupName, String namespaceId, String description, String configTags) throws NacosException;

try {
    configMaintainerService.updateConfigMetadata("maintain.client.test", "DEFAULT_GROUP", "public", "this is a description", "tag1,tag2");
} catch (NacosException e) {
    e.printStackTrace();
}

Page<ConfigBasicInfo> searchConfigByDetails(String dataId, String groupName, String namespaceId, String search,
        String configDetail, String type, String configTags, String appName, int pageNo, int pageSize) throws NacosException;

try {
    Page<ConfigBasicInfo> result = configMaintainerService.searchConfigByDetails(
            "maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID,
            "blur", null, null, null, null, 1, 100);
} catch (NacosException e) {
    e.printStackTrace();
}

String createService(String serviceName) throws NacosException;

String createService(String groupName, String serviceName) throws NacosException;

String createService(String namespaceId, String groupName, String serviceName) throws NacosException;

String createService(String namespaceId, String groupName, String serviceName, boolean ephemeral) throws NacosException;

String createService(String namespaceId, String groupName, String serviceName, boolean ephemeral, float protectThreshold) throws NacosException;

String createService(Service service) throws NacosException;

try {
    // The following requests all create a persistent service named `maintain.client.test`.
    String result = namingMaintainerService.createService("maintain.client.test");
    result = namingMaintainerService.createService("maintain.client.test", Constants.DEFAULT_GROUP);
    result = namingMaintainerService.createService("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID);
    result = namingMaintainerService.createService("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, false);
    result = namingMaintainerService.createService("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, false, 0.0f);
    Service service = new Service();
    service.setName("maintain.client.test");
    service.setGroupName(Constants.DEFAULT_GROUP);
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    result = namingMaintainerService.createService(service);
} catch (NacosException e) {
    e.printStackTrace();
}

String updateService(String serviceName, Map<String, String> newMetadata, float newProtectThreshold, Selector newSelector) throws NacosException;

String updateService(String groupName, String serviceName, Map<String, String> newMetadata, float newProtectThreshold, Selector newSelector) throws NacosException;

String updateService(String namespaceId, String groupName, String serviceName, Map<String, String> newMetadata, float newProtectThreshold, Selector newSelector) throws NacosException;

String updateService(String namespaceId, String groupName, String serviceName, boolean ephemeral, Map<String, String> newMetadata, float newProtectThreshold, Selector newSelector) throws NacosException;

String updateService(Service service) throws NacosException;

try {
    // The following requests all update the persistent service named `maintain.client.test`.
    String result = namingMaintainerService.updateService("maintain.client.test", new HashMap<>(), 0.0f, new NoneSelector());
    result = namingMaintainerService.updateService("maintain.client.test", Constants.DEFAULT_GROUP, new HashMap<>(), 0.0f, new NoneSelector());
    result = namingMaintainerService.updateService("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, new HashMap<>(), 0.0f, new NoneSelector());
    result = namingMaintainerService.updateService("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID, false, new HashMap<>(), 0.0f, new NoneSelector());
    Service service = new Service();
    service.setName("maintain.client.test");
    service.setGroupName(Constants.DEFAULT_GROUP);
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    result = namingMaintainerService.updateService(service);
} catch (NacosException e) {
    e.printStackTrace();
}

String removeService(String serviceName) throws NacosException;

String removeService(String groupName, String serviceName) throws NacosException;

String removeService(String namespaceId, String groupName, String serviceName) throws NacosException;

String removeService(Service service) throws NacosException;

try {
    // The following requests all delete a service named `maintain.client.test`.
    String result = namingMaintainerService.removeService("maintain.client.test");
    result = namingMaintainerService.removeService("maintain.client.test", Constants.DEFAULT_GROUP);
    result = namingMaintainerService.removeService("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID);
    Service service = new Service();
    service.setName("maintain.client.test");
    service.setGroupName(Constants.DEFAULT_GROUP);
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    result = namingMaintainerService.removeService(service);
} catch (NacosException e) {
    e.printStackTrace();
}

ServiceDetailInfo getServiceDetail(String serviceName) throws NacosException;

ServiceDetailInfo getServiceDetail(String groupName, String serviceName) throws NacosException;

ServiceDetailInfo getServiceDetail(String namespaceId, String groupName, String serviceName) throws NacosException;

ServiceDetailInfo getServiceDetail(Service service) throws NacosException;

try {
    // The following requests all obtain details of a service named `maintain.client.test`.
    ServiceDetailInfo result = namingMaintainService.getServiceDetail("maintain.client.test");
    result = namingMaintainService.getServiceDetail("maintain.client.test", Constants.DEFAULT_GROUP);
    result = namingMaintainService.getServiceDetail("maintain.client.test", Constants.DEFAULT_GROUP, Constants.DEFAULT_NAMESPACE_ID);
    Service service = new Service();
    service.setName("maintain.client.test");
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    service.setGroupName(Constants.DEFAULT_GROUP);
result = namingMaintainService.getServiceDetail(service);
} catch (NacosException e) {
    e.printStackTrace();
}

Page<ServiceView> listServices(String namespaceId) throws NacosException;

Page<ServiceView> listServices(String namespaceId, String groupNameParam, String serviceNameParam) throws NacosException;

Page<ServiceView> listServices(String namespaceId, String groupNameParam, String serviceNameParam, boolean ignoreEmptyService, int pageNo, int pageSize) throws NacosException;

try {
    // The following requests all obtain the service list (up to the first 100 services).
    Page<ServiceView> result = namingMaintainService.listServices(Constants.DEFAULT_NAMESPACE_ID);
    result = namingMaintainService.listServices(Constants.DEFAULT_NAMESPACE_ID, "", "");
    result = namingMaintainService.listServices(Constants.DEFAULT_NAMESPACE_ID, "", "", true, 1, 100);
} catch (NacosException e) {
    e.printStackTrace();
}

Page<ServiceDetailInfo> listServicesWithDetail(String namespaceId) throws NacosException;

Page<ServiceDetailInfo> listServicesWithDetail(String namespaceId, String groupNameParam, String serviceNameParam) throws NacosException;

Page<ServiceDetailInfo> listServicesWithDetail(String namespaceId, String groupNameParam, String serviceNameParam, int pageNo, int pageSize) throws NacosException;

try {
    // The following requests all obtain the service list (up to the first 100 services).
    Page<ServiceDetailInfo> result = namingMaintainService.listServicesWithDetail(Constants.DEFAULT_NAMESPACE_ID);
    result = namingMaintainService.listServicesWithDetail(Constants.DEFAULT_NAMESPACE_ID, "", "");
    result = namingMaintainService.listServicesWithDetail(Constants.DEFAULT_NAMESPACE_ID, "", "", 1, 10);
} catch (NacosException e) {
    e.printStackTrace();
}

Page<SubscriberInfo> getSubscribers(String serviceName) throws NacosException;

Page<SubscriberInfo> getSubscribers(String groupName, String serviceName) throws NacosException;

Page<SubscriberInfo> getSubscribers(String namespaceId, String groupName, String serviceName) throws NacosException;

Page<SubscriberInfo> getSubscribers(String namespaceId, String groupName, String serviceName, int pageNo, int pageSize) throws NacosException;

Page<SubscriberInfo> getSubscribers(String namespaceId, String groupName, String serviceName, int pageNo, int pageSize, boolean aggregation) throws NacosException;

Page<SubscriberInfo> getSubscribers(Service service, int pageNo, int pageSize, boolean aggregation) throws NacosException;

try {
    // The following requests all obtain the subscriber list of service `maintain.client.test` (up to the first 100 subscribers).
    Page<SubscriberInfo> result = namingMaintainService.getSubscribers("maintain.client.test");
    result = namingMaintainService.getSubscribers(Constants.DEFAULT_GROUP, "maintain.client.test");
    result = namingMaintainService.getSubscribers(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test");
    result = namingMaintainService.getSubscribers(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", 1, 100);
    result = namingMaintainService.getSubscribers(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", 1, 100, false);
} catch (NacosException e) {
    e.printStackTrace();
}

List<String> listSelectorTypes() throws NacosException;

try {
    List<String> result = namingMaintainService.listSelectorTypes();
} catch (NacosException e) {
    e.printStackTrace();
}

String registerInstance(String serviceName, String ip, int port) throws NacosException;

String registerInstance(String groupName, String serviceName, String ip, int port) throws NacosException;

String registerInstance(String namespaceId, String groupName, String serviceName, String ip, int port) throws NacosException;

String registerInstance(String serviceName, String ip, int port, String clusterName) throws NacosException;

String registerInstance(String groupName, String serviceName, String ip, int port, String clusterName) throws NacosException;

String registerInstance(String namespaceId, String groupName, String serviceName, String ip, int port, String clusterName) throws NacosException;

String registerInstance(String serviceName, instance instance) throws NacosException;

String registerInstance(String groupName, String serviceName, instance instance) throws NacosException;

String registerInstance(String namespaceId, String groupName, String serviceName, instance instance);

String registerInstance(Service service, instance instance) throws NacosException;

try {
    // The following requests all register an instance with IP `127.0.0.1` and port `8080` for service `maintain.client.test`.
    String result = namingMaintainService.registerInstance("maintain.client.test", "127.0.0.1", 8080);
    result = namingMaintainService.registerInstance(Constants.DEFAULT_GROUP, "maintain.client.test", "127.0.0.1", 8080);
    result = namingMaintainService.registerInstance(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", "127.0.0.1", 8080);
    result = namingMaintainService.registerInstance(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", "127.0.0.1", 8080);
    result = namingMaintainService.registerInstance("maintain.client.test", "127.0.0.1", 8080, Constants.DEFAULT_CLUSTER_NAME);
    result = namingMaintainService.registerInstance(Constants.DEFAULT_GROUP,"maintain.client.test", "127.0.0.1", 8080, Constants.DEFAULT_CLUSTER_NAME);
    result = namingMaintainService.registerInstance(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP,"maintain.client.test", "127.0.0.1", 8080, Constants.DEFAULT_CLUSTER_NAME);
    instance instance = new Instance();
    instance.setIp("127.0.0.1");
    instance.setPort(8080);
    instance.setEphemeral(false);
    result = namingMaintainService.registerInstance("maintain.client.test", instance);
    result = namingMaintainService.registerInstance(Constants.DEFAULT_GROUP,"maintain.client.test", instance);
    result = namingMaintainService.registerInstance(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", instance);
    Service service = new Service();
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    service.setGroupName(Constants.DEFAULT_GROUP);
    service.setName("maintain.client.test");
    result = namingMaintainService.registerInstance(service, instance);
} catch (NacosException e) {
    e.printStackTrace();
}

String deregisterInstance(String serviceName, String ip, int port) throws NacosException;

String deregisterInstance(String groupName, String serviceName, String ip, int port) throws NacosException;

String deregisterInstance(String namespaceId, String groupName, String serviceName, String ip, int port) throws NacosException;

String deregisterInstance(String serviceName, String ip, int port, String clusterName) throws NacosException;

String deregisterInstance(String groupName, String serviceName, String ip, int port, String clusterName) throws NacosException;

String deregisterInstance(String namespaceId, String groupName, String serviceName, String ip, int port, String clusterName) throws NacosException;

String deregisterInstance(String serviceName, instance instance) throws NacosException;

String deregisterInstance(String groupName, String serviceName, instance instance) throws NacosException;

String deregisterInstance(String namespaceId, String groupName, String serviceName, instance instance) throws NacosException;

String deregisterInstance(Service service, instance instance) throws NacosException;

try {
    // The following requests all deregister an instance whose IP is `127.0.0.1` and port is `8080` from service `maintain.client.test`.
    String result = namingMaintainService.registerInstance("maintain.client.test", "127.0.0.1", 8080);
    result = namingMaintainService.deregisterInstance(Constants.DEFAULT_GROUP, "maintain.client.test", "127.0.0.1", 8080);
    result = namingMaintainService.deregisterInstance(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", "127.0.0.1", 8080);
    result = namingMaintainService.deregisterInstance(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", "127.0.0.1", 8080);
    result = namingMaintainService.deregisterInstance("maintain.client.test", "127.0.0.1", 8080, Constants.DEFAULT_CLUSTER_NAME);
    result = namingMaintainService.deregisterInstance(Constants.DEFAULT_GROUP,"maintain.client.test", "127.0.0.1", 8080, Constants.DEFAULT_CLUSTER_NAME);
    result = namingMaintainService.deregisterInstance(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP,"maintain.client.test", "127.0.0.1", 8080, Constants.DEFAULT_CLUSTER_NAME);
    instance instance = new Instance();
    instance.setIp("127.0.0.1");
    instance.setPort(8080);
    instance.setEphemeral(false);
    result = namingMaintainService.deregisterInstance("maintain.client.test", instance);
    result = namingMaintainService.deregisterInstance(Constants.DEFAULT_GROUP,"maintain.client.test", instance);
    result = namingMaintainService.deregisterInstance(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", instance);
    Service service = new Service();
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    service.setGroupName(Constants.DEFAULT_GROUP);
    service.setName("maintain.client.test");
    result = namingMaintainService.deregisterInstance(service, instance);
} catch (NacosException e) {
    e.printStackTrace();
}

String updateInstance(String serviceName, instance instance) throws NacosException;

String updateInstance(String groupName, String serviceName, instance instance) throws NacosException;

String updateInstance(String namespaceId, String groupName, String serviceName, instance instance) throws NacosException;

String updateInstance(Service service, instance instance) throws NacosException;

try {
    instance instance = new Instance();
    instance.setIp("127.0.0.1");
    instance.setPort(8080);
    instance.setEphemeral(false);
    instance.setEnabled(false);
    // The following requests all update an instance whose IP is `127.0.0.1` and port is `8080` under service `maintain.client.test`, and change the instance `enabled` value to `false`.
    String result = namingMaintainService.registerInstance("maintain.client.test", instance);
    result = namingMaintainService.registerInstance(Constants.DEFAULT_GROUP,"maintain.client.test", instance);
    result = namingMaintainService.registerInstance(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", instance);
    Service service = new Service();
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    service.setGroupName(Constants.DEFAULT_GROUP);
    service.setName("maintain.client.test");
    result = namingMaintainService.registerInstance(service, instance);
} catch (NacosException e) {
    e.printStackTrace();
}

InstanceMetadataBatchResult batchUpdateInstanceMetadata(Service service, List<Instance> instances, Map<String, String> newMetadata) throws NacosException;

try {
    Service service = new Service();
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    service.setGroupName(Constants.DEFAULT_GROUP);
    service.setName("maintain.client.test");
    instance instance = new Instance();
    instance.setIp("127.0.0.1");
    instance.setPort(8080);
    Map<String, String> newMetadata = Collections.singletonMap("testK", "testV");
    InstanceMetadataBatchResult result = namingMaintainService.batchUpdateInstanceMetadata(service, Collections.singletonList(instance), newMetadata);
} catch (NacosException e) {
    e.printStackTrace();
}

InstanceMetadataBatchResult batchDeleteInstanceMetadata(Service service, List<Instance> instances, Map<String, String> newMetadata) throws NacosException;

try {
    Service service = new Service();
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    service.setGroupName(Constants.DEFAULT_GROUP);
    service.setName("maintain.client.test");
    instance instance = new Instance();
    instance.setIp("127.0.0.1");
    instance.setPort(8080);
    Map<String, String> newMetadata = Collections.singletonMap("testK", "testV");
    InstanceMetadataBatchResult result = namingMaintainService.batchDeleteInstanceMetadata(service, Collections.singletonList(instance), newMetadata);
} catch (NacosException e) {
    e.printStackTrace();
}

String partialUpdateInstance(Service service, instance instance) throws NacosException;

try {

} catch (NacosException e) {
    e.printStackTrace();
}

List<Instance> listInstances(String serviceName, String clusterName, boolean healthyOnly) throws NacosException;

List<Instance> listInstances(String groupName, String serviceName, String clusterName, boolean healthyOnly) throws NacosException;

List<Instance> listInstances(String namespaceId, String groupName, String serviceName, String clusterName, boolean healthyOnly) throws NacosException;

List<Instance> listInstances(Service service, String clusterName, boolean healthyOnly) throws NacosException;

try {
    List<Instance> result = namingMaintainService.listInstances("maintain.client.test", "", false);
    result = namingMaintainService.listInstances(Constants.DEFAULT_GROUP, "maintain.client.test", "", false);
    result = namingMaintainService.listInstances(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", "", false);
    Service service = new Service();
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    service.setGroupName(Constants.DEFAULT_GROUP);
    service.setName("maintain.client.test");
    result = namingMaintainService.listInstances(service, "", false);
} catch (NacosException e) {
    e.printStackTrace();
}

instance getInstanceDetail(String serviceName, String ip, int port) throws NacosException;

instance getInstanceDetail(String groupName, String serviceName, String ip, int port) throws NacosException;

instance getInstanceDetail(String namespaceId, String groupName, String serviceName, String ip, int port) throws NacosException;

instance getInstanceDetail(String serviceName, String ip, int port, String clusterName) throws NacosException;

instance getInstanceDetail(String groupName, String serviceName, String ip, int port, String clusterName) throws NacosException;

instance getInstanceDetail(String namespaceId, String groupName, String serviceName, String ip, int port, String clusterName) throws NacosException;

instance getInstanceDetail(Service service, instance instance) throws NacosException;

try {
    instance result = namingMaintainService.getInstanceDetail("maintain.client.test", "127.0.0.1", 8080);
    result = namingMaintainService.getInstanceDetail(Constants.DEFAULT_GROUP, "maintain.client.test", "127.0.0.1", 8080);
    result = namingMaintainService.getInstanceDetail(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", "127.0.0.1", 8080);
    result = namingMaintainService.getInstanceDetail("maintain.client.test", "127.0.0.1", 8080, Constants.DEFAULT_CLUSTER_NAME);
    result = namingMaintainService.getInstanceDetail(Constants.DEFAULT_GROUP,"maintain.client.test", "127.0.0.1", 8080, Constants.DEFAULT_CLUSTER_NAME);
    result = namingMaintainService.getInstanceDetail(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP,"maintain.client.test", "127.0.0.1", 8080, Constants.DEFAULT_CLUSTER_NAME);
    Service service = new Service();
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    service.setGroupName(Constants.DEFAULT_GROUP);
    service.setName("maintain.client.test");
    instance instance = new Instance();
    instance.setIp("127.0.0.1");
    instance.setPort(8080);
    instance.setClusterName(Constants.DEFAULT_CLUSTER_NAME);
    result = namingMaintainService.getInstanceDetail(service, instance);
} catch (NacosException e) {
    e.printStackTrace();
}

MetricsInfo getMetrics(boolean onlyStatus) throws NacosException;

try {
    MetricsInfo metricsInfo = namingMaintainService.getMetrics(false);
} catch (NacosException e) {
    e.printStackTrace();
}

String setLogLevel(String logName, String logLevel) throws NacosException;

try {
    String result = namingMaintainService.setLogLevel("naming-server", "DEBUG");
} catch (NacosException e) {
    e.printStackTrace();
}

String updateInstanceHealthStatus(Service service, instance instance) throws NacosException;

try {
    // Updates the health status of instance `127.0.0.1:8080` under `maintain.client.test` to false.
    Service service = new Service();
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    service.setGroupName(Constants.DEFAULT_GROUP);
    service.setName("maintain.client.test");
    instance instance = new Instance();
    instance.setIp("127.0.0.1");
    instance.setPort(8080);
    instance.setClusterName(Constants.DEFAULT_CLUSTER_NAME);
    instance.setEphemeral(false)
    instance.setHealthy(false);
    String result = namingMaintainService.updateInstanceHealthStatus(service, instance);
} catch (NacosException e) {
    e.printStackTrace();
}

Map<String, AbstractHealthChecker> getHealthCheckers() throws NacosException;

try {
    Map<String, AbstractHealthChecker> result = namingMaintainService.getHealthCheckers();
} catch (NacosException e) {
    e.printStackTrace();
}

String updateCluster(Service service, ClusterInfo cluster) throws NacosException;

try {
    Service service = new Service();
    service.setNamespaceId(Constants.DEFAULT_NAMESPACE_ID);
    service.setGroupName(Constants.DEFAULT_GROUP);
    service.setName("maintain.client.test");
    ClusterInfo clusterInfo = new ClusterInfo();
    clusterInfo.setClusterName(Constants.DEFAULT_CLUSTER_NAME);
    clusterInfo.setHealthChecker(new AbstractHealthChecker.None());
    clusterInfo.setUseInstancePortForCheck(true);
    clusterInfo.setMetadata(Collections.singletonMap("testK", "testV"));
    String result = namingMaintainService.updateCluster(service, clusterInfo);
} catch (NacosException e) {
    e.printStackTrace();
}

List<String> getClientList() throws NacosException;

try {
    List<String> result = namingMaintainService.getClientList();
} catch (NacosException e) {
    e.printStackTrace();
}

ClientSummaryInfo getClientDetail(String clientId) throws NacosException;

try {
    ClientSummaryInfo result = namingMaintainService.getClientDetail("127.0.0.1:8080#true");
} catch (NacosException e) {
    e.printStackTrace();
}

List<ClientServiceInfo> getPublishedServiceList(String clientId) throws NacosException;

try {
    List<ClientServiceInfo> result = namingMaintainService.getPublishedServiceList("127.0.0.1:8080#true");
} catch (NacosException e) {
    e.printStackTrace();
}

List<ClientServiceInfo> getSubscribeServiceList(String clientId) throws NacosException;

try {
    List<ClientServiceInfo> result = namingMaintainService.getSubscribeServiceList("127.0.0.1:8080#true");
} catch (NacosException e) {
    e.printStackTrace();
}

List<ClientPublisherInfo> getPublishedClientList(String namespaceId, String groupName, String serviceName, String ip, Integer port) throws NacosException;

try {
    List<ClientPublisherInfo> result = namingMaintainService.getPublishedClientList(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", "", "");
} catch (NacosException e) {
    e.printStackTrace();
}

List<ClientSubscriberInfo> getSubscribeClientList(String namespaceId, String groupName, String serviceName, String ip, Integer port) throws NacosException;

try {
    List<ClientSubscriberInfo> result = namingMaintainService.getSubscribeClientList(Constants.DEFAULT_NAMESPACE_ID, Constants.DEFAULT_GROUP, "maintain.client.test", "", "");
} catch (NacosException e) {
    e.printStackTrace();
}

Map<String, String> getServerState() throws NacosException;

try {
    Map<String,String> result = namingMaintainService.getServerState();
} catch (NacosException e) {
    e.printStackTrace();
}

Boolean liveness() throws NacosException;

try {
    boolean result = namingMaintainService.liveness();
} catch (NacosException e) {
    e.printStackTrace();
}

Boolean readiness() throws NacosException;

try {
    boolean result = namingMaintainService.readiness();
} catch (NacosException e) {
    e.printStackTrace();
}

String raftOps(String command, String value, String groupId) throws NacosException;