You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@servicecomb.apache.org by GitBox <gi...@apache.org> on 2018/06/11 08:06:25 UTC
[GitHub] liubao68 closed pull request #757: [SCB-652] Fix schema register
logic
liubao68 closed pull request #757: [SCB-652] Fix schema register logic
URL: https://github.com/apache/incubator-servicecomb-java-chassis/pull/757
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/foundations/foundation-common/src/main/java/org/apache/servicecomb/foundation/common/base/ServiceCombConstants.java b/foundations/foundation-common/src/main/java/org/apache/servicecomb/foundation/common/base/ServiceCombConstants.java
index 22e4709cc..216167814 100644
--- a/foundations/foundation-common/src/main/java/org/apache/servicecomb/foundation/common/base/ServiceCombConstants.java
+++ b/foundations/foundation-common/src/main/java/org/apache/servicecomb/foundation/common/base/ServiceCombConstants.java
@@ -64,4 +64,8 @@
String SERVICECOMB_ENV = "SERVICECOMB_ENV";
String DEFAULT_SERVICECOMB_ENV = "";
+
+ String DEVELOPMENT_SERVICECOMB_ENV = "development";
+
+ String PRODUCTION_SERVICECOMB_ENV = "production";
}
diff --git a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/RegistryUtils.java b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/RegistryUtils.java
index 321ff24a5..20306787a 100644
--- a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/RegistryUtils.java
+++ b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/RegistryUtils.java
@@ -40,6 +40,8 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.base.Charsets;
+import com.google.common.hash.Hashing;
import com.netflix.config.DynamicPropertyFactory;
public final class RegistryUtils {
@@ -221,4 +223,8 @@ public static MicroserviceInstances findServiceInstances(String appId, String se
String versionRule, String revision) {
return serviceRegistry.findServiceInstances(appId, serviceName, versionRule, revision);
}
+
+ public static String calcSchemaSummary(String schemaContent) {
+ return Hashing.sha256().newHasher().putString(schemaContent, Charsets.UTF_8).hash().toString();
+ }
}
diff --git a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/api/registry/MicroserviceInstance.java b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/api/registry/MicroserviceInstance.java
index 184aac3ca..4ce3fb2ff 100644
--- a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/api/registry/MicroserviceInstance.java
+++ b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/api/registry/MicroserviceInstance.java
@@ -55,6 +55,10 @@
private HealthCheck healthCheck;
+ /**
+ * Will be abandoned, use {@link Microservice#environment} instead
+ */
+ @Deprecated
private String environment;
private String stage;
diff --git a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/LocalServiceRegistryClientImpl.java b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/LocalServiceRegistryClientImpl.java
index 5e78abcd8..84c15169d 100644
--- a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/LocalServiceRegistryClientImpl.java
+++ b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/LocalServiceRegistryClientImpl.java
@@ -31,6 +31,8 @@
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
+import javax.ws.rs.core.Response.Status;
+
import org.apache.servicecomb.foundation.vertx.AsyncResultCallback;
import org.apache.servicecomb.serviceregistry.api.registry.Microservice;
import org.apache.servicecomb.serviceregistry.api.registry.MicroserviceInstance;
@@ -40,6 +42,7 @@
import org.apache.servicecomb.serviceregistry.api.response.GetSchemaResponse;
import org.apache.servicecomb.serviceregistry.api.response.HeartbeatResponse;
import org.apache.servicecomb.serviceregistry.api.response.MicroserviceInstanceChangedEvent;
+import org.apache.servicecomb.serviceregistry.client.http.Holder;
import org.apache.servicecomb.serviceregistry.client.http.MicroserviceInstances;
import org.apache.servicecomb.serviceregistry.version.Version;
import org.apache.servicecomb.serviceregistry.version.VersionRule;
@@ -342,7 +345,7 @@ public String getSchema(String microserviceId, String schemaId) {
}
@Override
- public List<GetSchemaResponse> getSchemas(String microserviceId) {
+ public Holder<List<GetSchemaResponse>> getSchemas(String microserviceId) {
Microservice microservice = microserviceIdMap.get(microserviceId);
if (microservice == null) {
throw new IllegalArgumentException("Invalid serviceId, serviceId=" + microserviceId);
@@ -355,7 +358,9 @@ public String getSchema(String microserviceId, String schemaId) {
schema.setSummary(Hashing.sha256().newHasher().putString(val, Charsets.UTF_8).hash().toString());
schemas.add(schema);
});
- return schemas;
+ Holder<List<GetSchemaResponse>> resultHolder = new Holder<>();
+ resultHolder.setStatusCode(Status.OK.getStatusCode()).setValue(schemas);
+ return resultHolder;
}
@Override
diff --git a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/ServiceRegistryClient.java b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/ServiceRegistryClient.java
index 9b2e1001e..4af6d7087 100644
--- a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/ServiceRegistryClient.java
+++ b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/ServiceRegistryClient.java
@@ -27,6 +27,7 @@
import org.apache.servicecomb.serviceregistry.api.response.GetSchemaResponse;
import org.apache.servicecomb.serviceregistry.api.response.HeartbeatResponse;
import org.apache.servicecomb.serviceregistry.api.response.MicroserviceInstanceChangedEvent;
+import org.apache.servicecomb.serviceregistry.client.http.Holder;
import org.apache.servicecomb.serviceregistry.client.http.MicroserviceInstances;
public interface ServiceRegistryClient {
@@ -82,7 +83,7 @@
*
* 批量获取schemas内容
*/
- List<GetSchemaResponse> getSchemas(String microserviceId);
+ Holder<List<GetSchemaResponse>> getSchemas(String microserviceId);
/**
*
diff --git a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/http/Holder.java b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/http/Holder.java
new file mode 100644
index 000000000..e63911a93
--- /dev/null
+++ b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/http/Holder.java
@@ -0,0 +1,67 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.servicecomb.serviceregistry.client.http;
+
+/**
+ * To carry the rest response information.
+ * @param <T> Type of response body
+ */
+public class Holder<T> {
+ T value;
+
+ int statusCode;
+
+ Throwable throwable;
+
+ public T getValue() {
+ return value;
+ }
+
+ public Holder<T> setValue(T value) {
+ this.value = value;
+ return this;
+ }
+
+ public int getStatusCode() {
+ return statusCode;
+ }
+
+ public Holder<T> setStatusCode(int statusCode) {
+ this.statusCode = statusCode;
+ return this;
+ }
+
+ public Throwable getThrowable() {
+ return throwable;
+ }
+
+ public Holder<T> setThrowable(Throwable throwable) {
+ this.throwable = throwable;
+ return this;
+ }
+
+ @Override
+ public String toString() {
+ final StringBuilder sb = new StringBuilder("Holder{");
+ sb.append("value=").append(value);
+ sb.append(", statusCode=").append(statusCode);
+ sb.append(", throwable=").append(throwable);
+ sb.append('}');
+ return sb.toString();
+ }
+}
diff --git a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/http/ServiceRegistryClientImpl.java b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/http/ServiceRegistryClientImpl.java
index f379d9318..30f420072 100644
--- a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/http/ServiceRegistryClientImpl.java
+++ b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/client/http/ServiceRegistryClientImpl.java
@@ -27,11 +27,11 @@
import java.util.concurrent.CountDownLatch;
import javax.ws.rs.core.Response.Status;
-import javax.xml.ws.Holder;
import org.apache.servicecomb.foundation.common.net.IpPort;
import org.apache.servicecomb.foundation.common.utils.JsonUtils;
import org.apache.servicecomb.foundation.vertx.AsyncResultCallback;
+import org.apache.servicecomb.serviceregistry.RegistryUtils;
import org.apache.servicecomb.serviceregistry.api.Const;
import org.apache.servicecomb.serviceregistry.api.registry.Microservice;
import org.apache.servicecomb.serviceregistry.api.registry.MicroserviceInstance;
@@ -60,8 +60,6 @@
import org.slf4j.LoggerFactory;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Charsets;
-import com.google.common.hash.Hashing;
import io.netty.handler.codec.http.HttpStatusClass;
import io.vertx.core.Handler;
@@ -108,6 +106,7 @@ private void retry(RequestContext requestContext, Handler<RestResponse> response
}
return;
}
+ holder.setStatusCode(response.statusCode());
response.bodyHandler(
bodyBuffer -> {
if (cls.getName().equals(HttpClientResponse.class.getName())) {
@@ -115,6 +114,11 @@ private void retry(RequestContext requestContext, Handler<RestResponse> response
countDownLatch.countDown();
return;
}
+ if (cls.equals(String.class)) {
+ holder.setValue((T) bodyBuffer.toString());
+ countDownLatch.countDown();
+ return;
+ }
// no need to support 304 in this place
if (!HttpStatusClass.SUCCESS.equals(HttpStatusClass.valueOf(response.statusCode()))) {
@@ -131,6 +135,7 @@ private void retry(RequestContext requestContext, Handler<RestResponse> response
holder.value =
JsonUtils.readValue(bodyBuffer.getBytes(), cls);
} catch (Exception e) {
+ holder.setStatusCode(0).setThrowable(e);
LOGGER.warn("read value failed and response message is {}",
bodyBuffer.toString());
}
@@ -291,7 +296,7 @@ public boolean registerSchema(String microserviceId, String schemaId, String sch
try {
CreateSchemaRequest request = new CreateSchemaRequest();
request.setSchema(schemaContent);
- request.setSummary(Hashing.sha256().newHasher().putString(schemaContent, Charsets.UTF_8).hash().toString());
+ request.setSummary(RegistryUtils.calcSchemaSummary(schemaContent));
byte[] body = JsonUtils.writeValueAsBytes(request);
CountDownLatch countDownLatch = new CountDownLatch(1);
@@ -355,9 +360,10 @@ public String getSchema(String microserviceId, String schemaId) {
}
@Override
- public List<GetSchemaResponse> getSchemas(String microserviceId) {
+ public Holder<List<GetSchemaResponse>> getSchemas(String microserviceId) {
Holder<GetSchemasResponse> holder = new Holder<>();
IpPort ipPort = ipPortManager.getAvailableAddress();
+ Holder<List<GetSchemaResponse>> resultHolder = new Holder<>();
CountDownLatch countDownLatch = new CountDownLatch(1);
// default not return schema content, just return summary!
@@ -372,11 +378,15 @@ public String getSchema(String microserviceId, String schemaId) {
microserviceId,
e);
}
+ resultHolder.setStatusCode(holder.getStatusCode()).setThrowable(holder.getThrowable());
if (holder.value != null) {
- return holder.value.getSchema() != null ? holder.value.getSchema() : holder.value.getSchemas();
+ return resultHolder.setValue(
+ holder.value.getSchema() != null ?
+ holder.value.getSchema() :
+ holder.value.getSchemas());
}
- return null;
+ return resultHolder;
}
@Override
diff --git a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/task/MicroserviceRegisterTask.java b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/task/MicroserviceRegisterTask.java
index caa6141f1..9e7be8ae7 100644
--- a/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/task/MicroserviceRegisterTask.java
+++ b/service-registry/src/main/java/org/apache/servicecomb/serviceregistry/task/MicroserviceRegisterTask.java
@@ -16,22 +16,27 @@
*/
package org.apache.servicecomb.serviceregistry.task;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
+import javax.ws.rs.core.Response.Status;
+
+import org.apache.servicecomb.foundation.common.base.ServiceCombConstants;
+import org.apache.servicecomb.serviceregistry.RegistryUtils;
import org.apache.servicecomb.serviceregistry.api.registry.Microservice;
import org.apache.servicecomb.serviceregistry.api.response.GetSchemaResponse;
import org.apache.servicecomb.serviceregistry.client.ServiceRegistryClient;
+import org.apache.servicecomb.serviceregistry.client.http.Holder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;
-import com.google.common.base.Charsets;
import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
-import com.google.common.hash.Hashing;
public class MicroserviceRegisterTask extends AbstractRegisterTask {
private static final Logger LOGGER = LoggerFactory.getLogger(MicroserviceRegisterTask.class);
@@ -73,14 +78,15 @@ protected boolean doRegister() {
microservice.getVersion(),
microservice.getEnvironment());
if (!StringUtils.isEmpty(serviceId)) {
- // 已经注册过了，不需要重新注册
+ // This microservice has been registered, so we just use the serviceId gotten from service center
microservice.setServiceId(serviceId);
LOGGER.info(
- "Microservice exists in service center, no need to register. id={} appId={}, name={}, version={}",
+ "Microservice exists in service center, no need to register. id=[{}] appId=[{}], name=[{}], version=[{}], env=[{}]",
serviceId,
microservice.getAppId(),
microservice.getServiceName(),
- microservice.getVersion());
+ microservice.getVersion(),
+ microservice.getEnvironment());
if (!checkSchemaIdSet()) {
return false;
@@ -89,24 +95,25 @@ protected boolean doRegister() {
serviceId = srClient.registerMicroservice(microservice);
if (StringUtils.isEmpty(serviceId)) {
LOGGER.error(
- "Registry microservice failed. appId={}, name={}, version={}",
+ "Registry microservice failed. appId=[{}], name=[{}], version=[{}], env=[{}]",
microservice.getAppId(),
microservice.getServiceName(),
- microservice.getVersion());
+ microservice.getVersion(),
+ microservice.getEnvironment());
return false;
}
- schemaIdSetMatch = true;
- // 重新注册服务场景下，instanceId不应该缓存
+ // In re-register microservice case, the old instanceId should not be cached
microservice.getInstance().setInstanceId(null);
LOGGER.info(
- "Registry Microservice successfully. id={} appId={}, name={}, version={}, schemaIds={}",
+ "Registry Microservice successfully. id=[{}] appId=[{}], name=[{}], version=[{}], schemaIds={}, env=[{}]",
serviceId,
microservice.getAppId(),
microservice.getServiceName(),
microservice.getVersion(),
- microservice.getSchemas());
+ microservice.getSchemas(),
+ microservice.getEnvironment());
}
microservice.setServiceId(serviceId);
@@ -126,74 +133,207 @@ private boolean checkSchemaIdSet() {
schemaIdSetMatch = existSchemas.equals(localSchemas);
if (!schemaIdSetMatch) {
- LOGGER.error(
- "SchemaIds is different between local and service center. Please change microservice version. "
- + "id={} appId={}, name={}, version={}, local schemaIds={}, service center schemaIds={}",
+ LOGGER.warn(
+ "SchemaIds is different between local and service center. "
+ + "serviceId=[{}] appId=[{}], name=[{}], version=[{}], env=[{}], local schemaIds={}, service center schemaIds={}",
microservice.getServiceId(),
microservice.getAppId(),
microservice.getServiceName(),
microservice.getVersion(),
+ microservice.getEnvironment(),
localSchemas,
existSchemas);
return true;
}
LOGGER.info(
- "SchemaIds is equals to service center. id={} appId={}, name={}, version={}, schemaIds={}",
+ "SchemaIds are equals to service center. serviceId=[{}], appId=[{}], name=[{}], version=[{}], env=[{}], schemaIds={}",
microservice.getServiceId(),
microservice.getAppId(),
microservice.getServiceName(),
microservice.getVersion(),
+ microservice.getEnvironment(),
localSchemas);
return true;
}
private boolean registerSchemas() {
- List<GetSchemaResponse> existSchemas = srClient.getSchemas(microservice.getServiceId());
- for (Entry<String, String> entry : microservice.getSchemaMap().entrySet()) {
- String schemaId = entry.getKey();
- String content = entry.getValue();
- GetSchemaResponse existSchema = extractSchema(schemaId, existSchemas);
- boolean exists = existSchema != null && existSchema.getSummary() != null;
- LOGGER.info("schemaId [{}] exists {}", schemaId, exists);
- if (!exists) {
- if (!srClient.registerSchema(microservice.getServiceId(), schemaId, content)) {
- return false;
- }
- } else {
- String curSchemaSumary = existSchema.getSummary();
- String schemaSummary = Hashing.sha256().newHasher().putString(content, Charsets.UTF_8).hash().toString();
- if (!schemaSummary.equals(curSchemaSumary)) {
- if (microservice.getInstance().getEnvironment().equalsIgnoreCase("development")) {
- LOGGER.info(
- "schemaId [{}]'s content changes and the current enviroment is development, so re-register it!",
- schemaId);
- if (!srClient.registerSchema(microservice.getServiceId(), schemaId, content)) {
- return false;
- }
- } else {
- throw new IllegalStateException("schemaId [" + schemaId
- + "] exists in service center, but the content does not match the local content that means there are interface change "
- + "and you need to increment microservice version before deploying. "
- + "Or you can configure instance_description.environment=development to work in development enviroment and ignore this error");
- }
- }
+ Holder<List<GetSchemaResponse>> scSchemaHolder = srClient.getSchemas(microservice.getServiceId());
+ if (Status.OK.getStatusCode() != scSchemaHolder.getStatusCode()) {
+ LOGGER.error("failed to get schemas from service center, statusCode = [{}]", scSchemaHolder.getStatusCode());
+ return false;
+ }
+
+ Map<String, GetSchemaResponse> scSchemaMap = convertScSchemaMap(scSchemaHolder);
+ // CHECK: local > sc, local != sc
+ for (Entry<String, String> localSchemaEntry : microservice.getSchemaMap().entrySet()) {
+ if (!registerSchema(scSchemaMap, localSchemaEntry)) {
+ return false;
+ }
+ }
+
+ // CHECK: local < sc
+ checkRemainingSchema(scSchemaMap);
+
+ schemaIdSetMatch = true;
+ return true;
+ }
+
+ /**
+ * Check whether a local schema is equal to a sc schema.
+ * @return true if the local schema is equal to a sc schema, or be registered to sc successfully;
+ * false if schema is registered to sc but failed.
+ * @throws IllegalStateException The environment is not modifiable, and the local schema is different from sc schema
+ * or not exist in sc.
+ */
+ private boolean registerSchema(Map<String, GetSchemaResponse> scSchemaMap,
+ Entry<String, String> localSchemaEntry) {
+ GetSchemaResponse scSchema = scSchemaMap.get(localSchemaEntry.getKey());
+
+ boolean onlineSchemaExists = scSchema != null;
+ LOGGER.info("schemaId [{}] exists [{}], summary exists [{}]", localSchemaEntry.getKey(), onlineSchemaExists,
+ scSchema != null && scSchema.getSummary() != null);
+ if (!onlineSchemaExists) {
+ // local > sc
+ return registerNewSchema(localSchemaEntry);
+ }
+
+ scSchemaMap.remove(localSchemaEntry.getKey());
+
+ // local != sc
+ return compareAndReRegisterSchema(localSchemaEntry, scSchema);
+ }
+
+ /**
+ * Try to register a new schema to service center, or throw exception if cannot register.
+ * @param localSchemaEntry local schema to be registered.
+ * @return whether local schema is registered successfully.
+ * @throws IllegalStateException The environment is unmodifiable.
+ */
+ private boolean registerNewSchema(Entry<String, String> localSchemaEntry) {
+ // The ids of schemas are contained by microservice registry request, which means once a microservice
+ // is registered in the service center, the schemas that it contains are determined.
+ // If we get a microservice but cannot find the given schemaId in it's schemaId list, this means that
+ // the schemas of this microservice has been changed, and we should decide whether to register this new
+ // schema according to it's environment configuration.
+ if (onlineSchemaIsModifiable()) {
+ return registerSingleSchema(localSchemaEntry.getKey(), localSchemaEntry.getValue());
+ }
+
+ throw new IllegalStateException(
+ "There is a schema only existing in local microservice: [" + localSchemaEntry.getKey()
+ + "], which means there are interfaces changed. "
+ + "You need to increment microservice version before deploying, "
+ + "or you can configure service_description.environment="
+ + ServiceCombConstants.DEVELOPMENT_SERVICECOMB_ENV
+ + " to work in development environment and ignore this error");
+ }
+
+ /**
+ * Compare schema summary and determine whether to re-register schema or throw exception.
+ * @param localSchemaEntry local schema
+ * @param scSchema schema in service center
+ * @return true if the two copies of schema are the same, or local schema is re-registered successfully,
+ * false if the local schema is re-registered to service center but failed.
+ * @throws IllegalStateException The two copies of schema are different and the environment is not modifiable.
+ */
+ private boolean compareAndReRegisterSchema(Entry<String, String> localSchemaEntry, GetSchemaResponse scSchema) {
+ String scSchemaSummary = getScSchemaSummary(scSchema);
+
+ if (null == scSchemaSummary) {
+ // cannot get scSchemaSummary, which means there is no schema content in sc, register schema directly
+ return registerSingleSchema(localSchemaEntry.getKey(), localSchemaEntry.getValue());
+ }
+
+ String localSchemaSummary = RegistryUtils.calcSchemaSummary(localSchemaEntry.getValue());
+ if (!localSchemaSummary.equals(scSchemaSummary)) {
+ if (onlineSchemaIsModifiable()) {
+ LOGGER.info(
+ "schema[{}]'s content is changed and the current environment is [{}], so re-register it!",
+ localSchemaEntry.getKey(), ServiceCombConstants.DEVELOPMENT_SERVICECOMB_ENV);
+ return registerSingleSchema(localSchemaEntry.getKey(), localSchemaEntry.getValue());
}
+
+ // env is not development, throw an exception and break the init procedure
+ throw new IllegalStateException(
+ "The schema(id=[" + localSchemaEntry.getKey()
+ + "]) content held by this instance and the service center is different. "
+ + "You need to increment microservice version before deploying. "
+ + "Or you can configure service_description.environment="
+ + ServiceCombConstants.DEVELOPMENT_SERVICECOMB_ENV
+ + " to work in development environment and ignore this error");
}
+
+ // summaries are the same
return true;
}
- private GetSchemaResponse extractSchema(String schemaId, List<GetSchemaResponse> schemas) {
- if (schemas == null || schemas.isEmpty()) {
- return null;
+ /**
+ * Try to get or calculate scSchema summary.
+ * @return summary of scSchema,
+ * or null if there is no schema content in service center
+ */
+ private String getScSchemaSummary(GetSchemaResponse scSchema) {
+ String scSchemaSummary = scSchema.getSummary();
+ if (null != scSchemaSummary) {
+ return scSchemaSummary;
}
- GetSchemaResponse schema = null;
- for (GetSchemaResponse tempSchema : schemas) {
- if (tempSchema.getSchemaId().equals(schemaId)) {
- schema = tempSchema;
- break;
+
+ // if there is no online summery, query online schema content directly and calculate summary
+ String onlineSchemaContent = srClient.getSchema(microservice.getServiceId(), scSchema.getSchemaId());
+ if (null != onlineSchemaContent) {
+ scSchemaSummary = RegistryUtils.calcSchemaSummary(onlineSchemaContent);
+ }
+
+ return scSchemaSummary;
+ }
+
+ /**
+ * Check whether there are schemas remaining in service center but not exist in local microservice.
+ * @throws IllegalStateException There are schemas only existing in service center, and the environment is unmodifiable.
+ */
+ private void checkRemainingSchema(Map<String, GetSchemaResponse> scSchemaMap) {
+ if (!scSchemaMap.isEmpty()) {
+ // there are some schemas only exist in service center
+ if (!onlineSchemaIsModifiable()) {
+ // env is not development, throw an exception and break the init procedure
+ throw new IllegalStateException("There are schemas only existing in service center: " + scSchemaMap.keySet()
+ + ", which means there are interfaces changed. "
+ + "You need to increment microservice version before deploying, "
+ + "or if service_description.environment="
+ + ServiceCombConstants.DEVELOPMENT_SERVICECOMB_ENV
+ + ", you can delete microservice information in service center and restart this instance.");
}
+
+ // Currently nothing to do but print a warning
+ LOGGER.warn("There are schemas only existing in service center: {}, which means there are interfaces changed. "
+ + "It's recommended to increment microservice version before deploying.", scSchemaMap.keySet());
}
- return schema;
+ }
+
+ private boolean onlineSchemaIsModifiable() {
+ return ServiceCombConstants.DEVELOPMENT_SERVICECOMB_ENV.equalsIgnoreCase(microservice.getEnvironment());
+ }
+
+ /**
+ * Register a schema directly.
+ * @return true if register success, otherwise false
+ */
+ private boolean registerSingleSchema(String schemaId, String content) {
+ return srClient.registerSchema(microservice.getServiceId(), schemaId, content);
+ }
+
+ private Map<String, GetSchemaResponse> convertScSchemaMap(Holder<List<GetSchemaResponse>> scSchemaHolder) {
+ Map<String, GetSchemaResponse> scSchemaMap = new HashMap<>();
+ List<GetSchemaResponse> scSchemaList = scSchemaHolder.getValue();
+ if (null == scSchemaList) {
+ return scSchemaMap;
+ }
+
+ for (GetSchemaResponse scSchema : scSchemaList) {
+ scSchemaMap.put(scSchema.getSchemaId(), scSchema);
+ }
+
+ return scSchemaMap;
}
}
diff --git a/service-registry/src/test/java/org/apache/servicecomb/serviceregistry/client/LocalServiceRegistryClientImplTest.java b/service-registry/src/test/java/org/apache/servicecomb/serviceregistry/client/LocalServiceRegistryClientImplTest.java
index 88ba8bfcb..095aa8b2e 100644
--- a/service-registry/src/test/java/org/apache/servicecomb/serviceregistry/client/LocalServiceRegistryClientImplTest.java
+++ b/service-registry/src/test/java/org/apache/servicecomb/serviceregistry/client/LocalServiceRegistryClientImplTest.java
@@ -23,6 +23,8 @@
import org.apache.servicecomb.serviceregistry.api.registry.Microservice;
import org.apache.servicecomb.serviceregistry.api.registry.MicroserviceInstance;
import org.apache.servicecomb.serviceregistry.api.registry.ServiceCenterInfo;
+import org.apache.servicecomb.serviceregistry.api.response.GetSchemaResponse;
+import org.apache.servicecomb.serviceregistry.client.http.Holder;
import org.apache.servicecomb.serviceregistry.client.http.MicroserviceInstances;
import org.apache.servicecomb.serviceregistry.definition.DefinitionConst;
import org.hamcrest.Matchers;
@@ -181,4 +183,12 @@ public void testGetServiceCenterInfo() {
ServiceCenterInfo serviceCenterInfo = registryClient.getServiceCenterInfo();
Assert.assertEquals("1.0.0", serviceCenterInfo.getVersion());
}
+
+ @Test
+ public void testGetSchemas() {
+ Holder<List<GetSchemaResponse>> schemasHolder = registryClient.getSchemas("001");
+ Assert.assertEquals(200, schemasHolder.getStatusCode());
+ Assert.assertTrue(schemasHolder.getValue().isEmpty());
+ }
}
+
diff --git a/service-registry/src/test/java/org/apache/servicecomb/serviceregistry/client/http/TestServiceRegistryClientImpl.java b/service-registry/src/test/java/org/apache/servicecomb/serviceregistry/client/http/TestServiceRegistryClientImpl.java
index dd370e7cb..cd796fdd2 100644
--- a/service-registry/src/test/java/org/apache/servicecomb/serviceregistry/client/http/TestServiceRegistryClientImpl.java
+++ b/service-registry/src/test/java/org/apache/servicecomb/serviceregistry/client/http/TestServiceRegistryClientImpl.java
@@ -24,7 +24,6 @@
import java.util.concurrent.CountDownLatch;
import javax.ws.rs.core.Response.Status;
-import javax.xml.ws.Holder;
import org.apache.log4j.Appender;
import org.apache.log4j.Logger;
@@ -75,7 +74,7 @@ void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler
new MockUp<CountDownLatch>() {
@Mock
- public void await() throws InterruptedException {
+ public void await() {
}
};
}
@@ -310,12 +309,15 @@ void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler
"{\"schema\":[{\"schemaId\":\"metricsEndpoint\",\"summary\":\"c1188d709631a9038874f9efc6eb894f\"},{\"schemaId\":\"comment\",\"summary\":\"bfa81d625cfbd3a57f38745323e16824\"},"
+ "{\"schemaId\":\"healthEndpoint\",\"summary\":\"96a0aaaaa454cfa0c716e70c0017fe27\"}]}",
GetSchemasResponse.class);
+ holder.statusCode = 200;
holder.value = schemasResp;
}
};
- List<GetSchemaResponse> abc = oClient.getSchemas(microserviceId);
- Assert.assertEquals(3, abc.size());
- Assert.assertEquals("bfa81d625cfbd3a57f38745323e16824", abc.get(1).getSummary());
+ Holder<List<GetSchemaResponse>> schemasHolder = oClient.getSchemas(microserviceId);
+ List<GetSchemaResponse> schemaResponses = schemasHolder.getValue();
+ Assert.assertEquals(200, schemasHolder.getStatusCode());
+ Assert.assertEquals(3, schemaResponses.size());
+ Assert.assertEquals("bfa81d625cfbd3a57f38745323e16824", schemaResponses.get(1).getSummary());
}
@Test
@@ -330,12 +332,32 @@ void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler
"{\"schemas\":[{\"schemaId\":\"metricsEndpoint\",\"summary\":\"c1188d709631a9038874f9efc6eb894f\"},{\"schemaId\":\"comment\",\"summary\":\"bfa81d625cfbd3a57f38745323e16824\"},"
+ "{\"schemaId\":\"healthEndpoint\",\"summary\":\"96a0aaaaa454cfa0c716e70c0017fe27\"}]}",
GetSchemasResponse.class);
+ holder.statusCode = 200;
holder.value = schemasResp;
}
};
- List<GetSchemaResponse> abc = oClient.getSchemas(microserviceId);
- Assert.assertEquals(3, abc.size());
- Assert.assertEquals("bfa81d625cfbd3a57f38745323e16824", abc.get(1).getSummary());
+ Holder<List<GetSchemaResponse>> schemasHolder = oClient.getSchemas(microserviceId);
+ List<GetSchemaResponse> schemas = schemasHolder.getValue();
+ Assert.assertEquals(200, schemasHolder.getStatusCode());
+ Assert.assertEquals(3, schemas.size());
+ Assert.assertEquals("bfa81d625cfbd3a57f38745323e16824", schemas.get(1).getSummary());
+ }
+
+ @Test
+ public void getSchemasFailed() {
+ String microserviceId = "msId";
+
+ new MockUp<RestUtils>() {
+ @Mock
+ void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) {
+ Holder<GetSchemasResponse> holder = Deencapsulation.getField(responseHandler, "arg$4");
+ holder.setStatusCode(Status.NOT_FOUND.getStatusCode());
+ }
+ };
+ Holder<List<GetSchemaResponse>> schemasHolder = oClient.getSchemas(microserviceId);
+ List<GetSchemaResponse> schemaResponses = schemasHolder.getValue();
+ Assert.assertEquals(404, schemasHolder.getStatusCode());
+ Assert.assertNull(schemaResponses);
}
@Test
diff --git a/service-registry/src/test/java/org/apache/servicecomb/serviceregistry/task/TestMicroserviceRegisterTask.java b/service-registry/src/test/java/org/apache/servicecomb/serviceregistry/task/TestMicroserviceRegisterTask.java
index 7932d6893..a7944c83a 100644
--- a/service-registry/src/test/java/org/apache/servicecomb/serviceregistry/task/TestMicroserviceRegisterTask.java
+++ b/service-registry/src/test/java/org/apache/servicecomb/serviceregistry/task/TestMicroserviceRegisterTask.java
@@ -24,6 +24,7 @@
import org.apache.servicecomb.serviceregistry.api.registry.MicroserviceInstance;
import org.apache.servicecomb.serviceregistry.api.response.GetSchemaResponse;
import org.apache.servicecomb.serviceregistry.client.ServiceRegistryClient;
+import org.apache.servicecomb.serviceregistry.client.http.Holder;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -82,12 +83,16 @@ public void testNewRegisterFailed(@Mocked ServiceRegistryClient srClient) {
@Test
public void testNewRegisterSuccess(@Mocked ServiceRegistryClient srClient) {
+ Holder<List<GetSchemaResponse>> onlineSchemasHolder = new Holder<>();
+ onlineSchemasHolder.setStatusCode(200);
new Expectations() {
{
srClient.getMicroserviceId(anyString, anyString, anyString, anyString);
result = null;
srClient.registerMicroservice((Microservice) any);
result = "serviceId";
+ srClient.getSchemas("serviceId");
+ this.result = onlineSchemasHolder;
}
};
@@ -104,10 +109,23 @@ public void testNewRegisterSuccess(@Mocked ServiceRegistryClient srClient) {
Assert.assertEquals(1, taskList.size());
}
+ /**
+ * Local schemaId set is consistent with online schemaId set, and schema contents are not registered.
+ * This service instance try to register schema content but failed.
+ */
@Test
public void testRegisterSchemaFailed(@Mocked ServiceRegistryClient srClient) {
microservice.addSchema("s1", "");
microservice.addSchema("exist", "");
+ Holder<List<GetSchemaResponse>> onlineSchemasHolder = new Holder<>();
+ onlineSchemasHolder.setStatusCode(200);
+ ArrayList<GetSchemaResponse> schemaResponses = new ArrayList<>();
+ onlineSchemasHolder.setValue(schemaResponses);
+ GetSchemaResponse schemaResponse = new GetSchemaResponse();
+ schemaResponse.setSchemaId("s1");
+ schemaResponses.add(schemaResponse);
+ schemaResponse.setSchemaId("exist");
+ schemaResponses.add(schemaResponse);
new Expectations() {
{
srClient.getMicroserviceId(anyString, anyString, anyString, anyString);
@@ -116,6 +134,8 @@ public void testRegisterSchemaFailed(@Mocked ServiceRegistryClient srClient) {
result = "serviceId";
srClient.registerSchema(anyString, anyString, anyString);
result = false;
+ srClient.getSchemas("serviceId");
+ this.result = onlineSchemasHolder;
}
};
@@ -123,23 +143,35 @@ public void testRegisterSchemaFailed(@Mocked ServiceRegistryClient srClient) {
registerTask.run();
Assert.assertEquals(false, registerTask.isRegistered());
- Assert.assertEquals(true, registerTask.isSchemaIdSetMatch());
+ Assert.assertEquals(false, registerTask.isSchemaIdSetMatch());
Assert.assertEquals("serviceId", microservice.getServiceId());
Assert.assertEquals("serviceId", microservice.getInstance().getServiceId());
Assert.assertEquals(1, taskList.size());
}
+ /**
+ * There is no microservice information in service center.
+ */
@Test
public void testRegisterSchemaSuccess(@Mocked ServiceRegistryClient srClient) {
- microservice.addSchema("s1", "");
+ microservice.addSchema("s1", "s1Content");
+ Holder<List<GetSchemaResponse>> onlineSchemasHolder = new Holder<>();
+ onlineSchemasHolder.setStatusCode(200);
+ ArrayList<GetSchemaResponse> schemaResponseList = new ArrayList<>();
+ onlineSchemasHolder.setValue(schemaResponseList);
+ GetSchemaResponse schemaResponse = new GetSchemaResponse();
+ schemaResponseList.add(schemaResponse);
+ schemaResponse.setSchemaId("s1");
new Expectations() {
{
srClient.getMicroserviceId(anyString, anyString, anyString, anyString);
result = null;
srClient.registerMicroservice((Microservice) any);
result = "serviceId";
- srClient.registerSchema(anyString, anyString, anyString);
- result = true;
+ srClient.getSchema("serviceId", "s1");
+ result = "s1Content";
+ srClient.getSchemas("serviceId");
+ result = onlineSchemasHolder;
}
};
@@ -155,12 +187,16 @@ public void testRegisterSchemaSuccess(@Mocked ServiceRegistryClient srClient) {
@Test
public void testAlreadyRegisteredSchemaIdSetMatch(@Mocked ServiceRegistryClient srClient) {
+ Holder<List<GetSchemaResponse>> onlineSchemasHolder = new Holder<>();
+ onlineSchemasHolder.setStatusCode(200);
new Expectations() {
{
srClient.getMicroserviceId(anyString, anyString, anyString, anyString);
result = "serviceId";
srClient.getMicroservice(anyString);
result = microservice;
+ srClient.getSchemas("serviceId");
+ result = onlineSchemasHolder;
}
};
@@ -175,30 +211,33 @@ public void testAlreadyRegisteredSchemaIdSetMatch(@Mocked ServiceRegistryClient
Assert.assertEquals(1, taskList.size());
}
- @Test
+ @Test(expected = IllegalStateException.class)
public void testAlreadyRegisteredSchemaIdSetNotMatch(@Mocked ServiceRegistryClient srClient) {
Microservice otherMicroservice = new Microservice();
otherMicroservice.setAppId(microservice.getAppId());
otherMicroservice.setServiceName("ms1");
otherMicroservice.addSchema("s1", "");
-
+ Holder<List<GetSchemaResponse>> onlineSchemasHolder = new Holder<>();
+ onlineSchemasHolder.setStatusCode(200);
+ ArrayList<GetSchemaResponse> schemaResponseList = new ArrayList<>();
+ onlineSchemasHolder.setValue(schemaResponseList);
+ GetSchemaResponse schemaResponse = new GetSchemaResponse();
+
+ schemaResponseList.add(schemaResponse);
+ schemaResponse.setSchemaId("s1");
new Expectations() {
{
srClient.getMicroserviceId(anyString, anyString, anyString, anyString);
result = "serviceId";
srClient.getMicroservice(anyString);
result = otherMicroservice;
+ srClient.getSchemas("serviceId");
+ result = onlineSchemasHolder;
}
};
MicroserviceRegisterTask registerTask = new MicroserviceRegisterTask(eventBus, srClient, microservice);
registerTask.run();
-
- Assert.assertEquals(true, registerTask.isRegistered());
- Assert.assertEquals(false, registerTask.isSchemaIdSetMatch());
- Assert.assertEquals("serviceId", microservice.getServiceId());
- Assert.assertEquals("serviceId", microservice.getInstance().getServiceId());
- Assert.assertEquals(1, taskList.size());
}
@Test
@@ -229,7 +268,7 @@ public void testAlreadyRegisteredGetSchemaIdSetFailed(@Mocked ServiceRegistryCli
@Test
public void testReRegisteredSetForDev(@Mocked ServiceRegistryClient srClient) {
ArchaiusUtils.resetConfig();
- ArchaiusUtils.setProperty("instance_description.environment", "development");
+ ArchaiusUtils.setProperty("service_description.environment", "development");
Microservice otherMicroservice = new Microservice();
otherMicroservice.setAppId(microservice.getAppId());
otherMicroservice.setServiceName("ms1");
@@ -240,6 +279,8 @@ public void testReRegisteredSetForDev(@Mocked ServiceRegistryClient srClient) {
resp.setSchemaId("s1");
resp.setSummary("c1188d709631a9038874f9efc6eb894f");
list.add(resp);
+ Holder<List<GetSchemaResponse>> onlineSchemasHolder = new Holder<>();
+ onlineSchemasHolder.setStatusCode(200).setValue(list);
new Expectations() {
{
@@ -248,14 +289,14 @@ public void testReRegisteredSetForDev(@Mocked ServiceRegistryClient srClient) {
srClient.getMicroservice(anyString);
result = otherMicroservice;
srClient.getSchemas(anyString);
- result = list;
+ result = onlineSchemasHolder;
srClient.registerSchema(microservice.getServiceId(), anyString, anyString);
result = true;
}
};
microservice.addSchema("s1", "");
- microservice.getInstance().setEnvironment("development");
+ microservice.setEnvironment("development");
MicroserviceRegisterTask registerTask = new MicroserviceRegisterTask(eventBus, srClient, microservice);
registerTask.run();
@@ -265,18 +306,22 @@ public void testReRegisteredSetForDev(@Mocked ServiceRegistryClient srClient) {
Assert.assertEquals(1, taskList.size());
}
+ /**
+ * There is microservice information but no schema in service center.
+ */
@Test
public void testFirstRegisterForProd(@Mocked ServiceRegistryClient srClient) {
Microservice otherMicroservice = new Microservice();
otherMicroservice.setAppId(microservice.getAppId());
otherMicroservice.setServiceName("ms1");
- otherMicroservice.addSchema("s1", "");
+ otherMicroservice.addSchema("s1", null);
List<GetSchemaResponse> list = new ArrayList<>();
GetSchemaResponse resp = new GetSchemaResponse();
resp.setSchemaId("s1");
- resp.setSummary(null);
list.add(resp);
+ Holder<List<GetSchemaResponse>> onlineSchemasHolder = new Holder<>();
+ onlineSchemasHolder.setValue(list).setStatusCode(200);
new Expectations() {
{
@@ -285,14 +330,16 @@ public void testFirstRegisterForProd(@Mocked ServiceRegistryClient srClient) {
srClient.getMicroservice(anyString);
result = otherMicroservice;
srClient.getSchemas(anyString);
- result = list;
- srClient.registerSchema(microservice.getServiceId(), anyString, anyString);
+ result = onlineSchemasHolder;
+ srClient.getSchema("serviceId", "s1");
+ result = null;
+ srClient.registerSchema("serviceId", "s1", "s1Content");
result = true;
}
};
- microservice.addSchema("s1", "");
- microservice.getInstance().setEnvironment("production");
+ microservice.addSchema("s1", "s1Content");
+ microservice.setEnvironment("production");
MicroserviceRegisterTask registerTask = new MicroserviceRegisterTask(eventBus, srClient, microservice);
registerTask.run();
@@ -302,6 +349,9 @@ public void testFirstRegisterForProd(@Mocked ServiceRegistryClient srClient) {
Assert.assertEquals(1, taskList.size());
}
+ /**
+ * There is schema in service center which is different from local schema.
+ */
@Test(expected = IllegalStateException.class)
public void testReRegisteredSetForProd(@Mocked ServiceRegistryClient srClient) {
Microservice otherMicroservice = new Microservice();
@@ -314,6 +364,8 @@ public void testReRegisteredSetForProd(@Mocked ServiceRegistryClient srClient) {
resp.setSchemaId("s1");
resp.setSummary("c1188d709631a9038874f9efc6eb894f");
list.add(resp);
+ Holder<List<GetSchemaResponse>> onlineSchemasHolder = new Holder<>();
+ onlineSchemasHolder.setValue(list).setStatusCode(200);
new Expectations() {
{
@@ -322,13 +374,101 @@ public void testReRegisteredSetForProd(@Mocked ServiceRegistryClient srClient) {
srClient.getMicroservice(anyString);
result = otherMicroservice;
srClient.getSchemas(anyString);
- result = list;
+ result = onlineSchemasHolder;
}
};
microservice.addSchema("s1", "");
- microservice.getInstance().setEnvironment("prod");
+ microservice.setEnvironment("prod");
MicroserviceRegisterTask registerTask = new MicroserviceRegisterTask(eventBus, srClient, microservice);
registerTask.run();
}
+
+ /**
+ * env = production and there are schemas only existing in service center
+ */
+ @Test(expected = IllegalStateException.class)
+ public void testReRegisterForProductAndLocalSchemasAreLess(@Mocked ServiceRegistryClient srClient) {
+ Microservice otherMicroservice = new Microservice();
+ otherMicroservice.setAppId(microservice.getAppId());
+ otherMicroservice.setServiceName("ms1");
+ otherMicroservice.addSchema("s1", null);
+ otherMicroservice.addSchema("s2", null);
+
+ List<GetSchemaResponse> list = new ArrayList<>();
+ GetSchemaResponse resp = new GetSchemaResponse();
+ resp.setSchemaId("s1");
+ list.add(resp);
+ resp = new GetSchemaResponse();
+ resp.setSchemaId("s2");
+ list.add(resp);
+ Holder<List<GetSchemaResponse>> onlineSchemasHolder = new Holder<>();
+ onlineSchemasHolder.setValue(list).setStatusCode(200);
+
+ new Expectations() {
+ {
+ srClient.getMicroserviceId(anyString, anyString, anyString, anyString);
+ result = "serviceId";
+ srClient.getMicroservice(anyString);
+ result = otherMicroservice;
+ srClient.getSchemas(anyString);
+ result = onlineSchemasHolder;
+ srClient.getSchema("serviceId", "s1");
+ result = null;
+ srClient.registerSchema("serviceId", "s1", "s1Content");
+ result = true;
+ }
+ };
+
+ microservice.addSchema("s1", "s1Content");
+ microservice.setEnvironment("production");
+ MicroserviceRegisterTask registerTask = new MicroserviceRegisterTask(eventBus, srClient, microservice);
+ registerTask.run();
+ }
+
+ @Test
+ public void testReRegisterForDevAndLocalSchemasAreLess(@Mocked ServiceRegistryClient srClient) {
+ Microservice otherMicroservice = new Microservice();
+ otherMicroservice.setAppId(microservice.getAppId());
+ otherMicroservice.setServiceName("ms1");
+ otherMicroservice.addSchema("s1", null);
+ otherMicroservice.addSchema("s2", null);
+
+ List<GetSchemaResponse> list = new ArrayList<>();
+ GetSchemaResponse resp = new GetSchemaResponse();
+ resp.setSchemaId("s1");
+ list.add(resp);
+ resp = new GetSchemaResponse();
+ resp.setSchemaId("s2");
+ list.add(resp);
+ Holder<List<GetSchemaResponse>> onlineSchemasHolder = new Holder<>();
+ onlineSchemasHolder.setValue(list).setStatusCode(200);
+ Holder<String> removeSchemaResult = new Holder<>();
+ removeSchemaResult.setStatusCode(200);
+
+ new Expectations() {
+ {
+ srClient.getMicroserviceId(anyString, anyString, anyString, anyString);
+ result = "serviceId";
+ srClient.getMicroservice(anyString);
+ result = otherMicroservice;
+ srClient.getSchemas(anyString);
+ result = onlineSchemasHolder;
+ srClient.getSchema("serviceId", "s1");
+ result = null;
+ srClient.registerSchema("serviceId", "s1", "s1Content");
+ result = true;
+ }
+ };
+
+ microservice.addSchema("s1", "s1Content");
+ microservice.setEnvironment("development");
+ MicroserviceRegisterTask registerTask = new MicroserviceRegisterTask(eventBus, srClient, microservice);
+ registerTask.run();
+
+ Assert.assertEquals(true, registerTask.isRegistered());
+ Assert.assertEquals(true, registerTask.isSchemaIdSetMatch());
+ Assert.assertEquals("serviceId", microservice.getServiceId());
+ Assert.assertEquals(1, taskList.size());
+ }
}
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
With regards,
Apache Git Services