com.ecwid.consul.v1.Response Java Examples

public void init() {
	if (!this.context.endsWith("/")) {
		this.context = this.context + "/";
	}

	Response<List<GetValue>> response = this.source.getKVValues(this.context,
			this.configProperties.getAclToken(), QueryParams.DEFAULT);

	this.initialIndex = response.getConsulIndex();

	final List<GetValue> values = response.getValue();
	ConsulConfigProperties.Format format = this.configProperties.getFormat();
	switch (format) {
	case KEY_VALUE:
		parsePropertiesInKeyValueFormat(values);
		break;
	case PROPERTIES:
	case YAML:
		parsePropertiesWithNonKeyValueFormat(values, format);
	}
}
 

@Test
@Ignore // FIXME: 3.0.0
public void contextLoads() {
	Response<Map<String, Service>> response = this.consul.getAgentServices();
	Map<String, Service> services = response.getValue();
	Service service = services.get("myTestService1-WithGroup");
	assertThat(service).as("service was null").isNotNull();
	assertThat(service.getPort().intValue()).as("service port is 0").isNotEqualTo(0);
	assertThat(service.getId()).as("service id was wrong")
			.isEqualTo("myTestService1-WithGroup");
	assertThat(service.getTags().contains("group=test")).as("service group was wrong")
			.isTrue();

	// ConsulServerList serverList = new ConsulServerList(this.consul,
	// this.properties);
	// DefaultClientConfigImpl config = new DefaultClientConfigImpl();
	// config.setClientName("myTestService-WithGroup");
	// serverList.initWithNiwsConfig(config);
	//
	// List<ConsulServer> servers = serverList.getInitialListOfServers();
	// assertThat(servers.size()).as("servers was wrong size").isEqualTo(1);
	// assertThat(servers.get(0).getMetaInfo().getServerGroup())
	// .as("service group was wrong").isEqualTo("test");
}
 

@Override
public List<ServiceInstance> lookup(SubscribeInfo subscribeInfo) {
    try {
        Response<List<HealthService>> consulServices = lookupHealthService(
                subscribeInfo.getServiceId(), -1);
        List<ServiceInstance> instances = convert(consulServices);
        log.info("lookup {} instances from consul", instances.size());
        return instances;
    } catch (Exception ex) {
        log.warn("lookup endpoint list failed from {}, msg={}",
                url, ex.getMessage());
        if (!subscribeInfo.isIgnoreFailOfNamingService()) {
            throw new RpcException("lookup endpoint list failed from consul failed", ex);
        } else {
            return new ArrayList<ServiceInstance>();
        }
    }
}
 

public void mockSync(TaskDO taskDO) throws Exception {
    Instance instance = mock(Instance.class);
    Map<String, String> metadata = Maps.newHashMap();
    metadata.put(SkyWalkerConstants.SOURCE_CLUSTERID_KEY, TEST_SOURCE_CLUSTER_ID);
    HealthService healthServiceUp = buildHealthService(TEST_INSTANCE_ADDRESS, 8080, Maps.newHashMap());
    HealthService healthServiceDown = buildHealthService(TEST_INSTANCE_ADDRESS, 8081, metadata);
    List<HealthService> healthServiceList = Lists.newArrayList(healthServiceUp,healthServiceDown);
    RawResponse rawResponse = new RawResponse(200,null,null,1000L,true,100L);
    Response<List<HealthService>> response = new Response<>(healthServiceList,rawResponse);
    when(taskDO.getTaskId()).thenReturn(TEST_TASK_ID);
    when(taskDO.getSourceClusterId()).thenReturn(TEST_SOURCE_CLUSTER_ID);
    when(taskDO.getDestClusterId()).thenReturn(TEST_DEST_CLUSTER_ID);
    doReturn(destNamingService).when(nacosServerHolder).get(anyString(), any());
    doReturn(consulClient).when(consulServerHolder).get(anyString(), any());
    doReturn(response).when(consulClient).getHealthServices(anyString(),anyBoolean(), any());
    List<Instance> allInstances = Lists.newArrayList(instance);
    doReturn(allInstances).when(destNamingService).getAllInstances(anyString());
    doReturn(ClusterTypeEnum.EUREKA).when(skyWalkerCacheServices).getClusterType(any());

}
 

/**
 * Update grpc port of consul tags after Conusl Registered
 * */
@EventListener
public void listenInstanceRegisteredEvent(InstanceRegisteredEvent instanceRegisteredEvent){
  if(alphaServerPort == 0){
    if(instanceRegisteredEvent.getConfig() instanceof ConsulDiscoveryProperties){
      ConsulDiscoveryProperties properties = (ConsulDiscoveryProperties)instanceRegisteredEvent.getConfig();
      this.consuleInstanceId = formatConsulInstanceId(properties.getInstanceId());
      Response<List<CatalogService>> services = consulClient.getCatalogService(serviceName,null);
      if(services.getValue() != null){
        services.getValue().stream().filter(service ->
            service.getServiceId().equalsIgnoreCase(this.consuleInstanceId)).forEach(service -> {

          NewService newservice =  new NewService();
          newservice.setName(service.getServiceName());
          newservice.setId(service.getServiceId());
          newservice.setAddress(service.getAddress());
          newservice.setPort(service.getServicePort());
          List<String> tags = service.getServiceTags();
          tags.remove("alpha-server-port=0");
          tags.add("alpha-server-port="+actualAlphaServerPort);
          newservice.setTags(tags);
          consulClient.agentServiceRegister(newservice);
        });
      }
    }
  }
}
 

@Override
public Response<Session> renewSession(String session, QueryParams queryParams, String token) {
	UrlParameters tokenParam = token != null ? new SingleUrlParameters("token", token) : null;
	HttpResponse httpResponse = rawClient.makePutRequest("/v1/session/renew/" + session, "", queryParams, tokenParam);

	if (httpResponse.getStatusCode() == 200) {
		List<Session> value = GsonFactory.getGson().fromJson(httpResponse.getContent(), new TypeToken<List<Session>>() {
		}.getType());

		if (value.size() == 1) {
			return new Response<Session>(value.get(0), httpResponse);
		} else {
			throw new ConsulException("Strange response (list size=" + value.size() + ")");
		}
	} else {
		throw new OperationException(httpResponse);
	}
}
 

@ReadOperation
public ConsulData invoke() {
	ConsulData data = new ConsulData();
	// data.setKeyValues(kvClient.getKeyValueRecurse());
	Response<Map<String, Service>> agentServices = this.consul.getAgentServices();
	data.setAgentServices(agentServices.getValue());

	Response<Map<String, List<String>>> catalogServices = this.consul
			.getCatalogServices(CatalogServicesRequest.newBuilder()
					.setQueryParams(QueryParams.DEFAULT).build());

	for (String serviceId : catalogServices.getValue().keySet()) {
		Response<List<CatalogService>> response = this.consul
				.getCatalogService(serviceId, CatalogServiceRequest.newBuilder()
						.setQueryParams(QueryParams.DEFAULT).build());
		data.getCatalogServices().put(serviceId, response.getValue());
	}

	Response<List<Node>> catalogNodes = this.consul
			.getCatalogNodes(CatalogNodesRequest.newBuilder()
					.setQueryParams(QueryParams.DEFAULT).build());
	data.setCatalogNodes(catalogNodes.getValue());

	return data;
}
 

@Override
public Response<String> sessionCreate(NewSession newSession, QueryParams queryParams, String token) {
	UrlParameters tokenParam = token != null ? new SingleUrlParameters("token", token) : null;

	String json = GsonFactory.getGson().toJson(newSession);
	HttpResponse httpResponse = rawClient.makePutRequest("/v1/session/create", json, queryParams, tokenParam);

	if (httpResponse.getStatusCode() == 200) {
		Map<String, String> value = GsonFactory.getGson().fromJson(httpResponse.getContent(), new TypeToken<Map<String, String>>() {
		}.getType());
		return new Response<String>(value.get("ID"), httpResponse);
	} else {
		throw new OperationException(httpResponse);
	}
}
 

@Test
public void contextLoads() {
	assertThat(this.autoServiceRegistration)
			.as("ConsulAutoServiceRegistration was created").isNotNull();

	Response<Map<String, Service>> response = this.consul.getAgentServices();
	Map<String, Service> services = response.getValue();
	Service service = services.get("consulNonWebTest");
	assertThat(service).as("service was registered").isNull(); // no port to listen,
																// hence no
	// registration
}
 

@Override
public Response<Void> agentJoin(String address, boolean wan) {
	UrlParameters wanParams = wan ? new SingleUrlParameters("wan", "1") : null;
	HttpResponse httpResponse = rawClient.makePutRequest("/v1/agent/join/" + address, "", wanParams);

	if (httpResponse.getStatusCode() == 200) {
		return new Response<Void>(null, httpResponse);
	} else {
		throw new OperationException(httpResponse);
	}
}
 

@Timed("consul.watch-catalog-services")
public void catalogServicesWatch() {
	try {
		long index = -1;
		if (this.catalogServicesIndex.get() != null) {
			index = this.catalogServicesIndex.get().longValue();
		}

		CatalogServicesRequest request = CatalogServicesRequest.newBuilder()
				.setQueryParams(new QueryParams(
						this.properties.getCatalogServicesWatchTimeout(), index))
				.setToken(this.properties.getAclToken()).build();
		Response<Map<String, List<String>>> response = this.consul
				.getCatalogServices(request);
		Long consulIndex = response.getConsulIndex();
		if (consulIndex != null) {
			this.catalogServicesIndex.set(BigInteger.valueOf(consulIndex));
		}

		if (log.isTraceEnabled()) {
			log.trace("Received services update from consul: " + response.getValue()
					+ ", index: " + consulIndex);
		}
		this.publisher.publishEvent(new HeartbeatEvent(this, consulIndex));
	}
	catch (Exception e) {
		log.error("Error watching Consul CatalogServices", e);
	}
}
 

@Override
public Response<Void> agentServiceDeregister(String serviceId, String token) {
	UrlParameters tokenParam = token != null ? new SingleUrlParameters("token", token) : null;

	HttpResponse httpResponse = rawClient.makePutRequest("/v1/agent/service/deregister/" + serviceId, "", tokenParam);

	if (httpResponse.getStatusCode() == 200) {
		return new Response<Void>(null, httpResponse);
	} else {
		throw new OperationException(httpResponse);
	}
}
 

@Override
public Response<List<Datacenter>> getDatacenters() {
	HttpResponse httpResponse = rawClient.makeGetRequest("/v1/coordinate/datacenters");

	if (httpResponse.getStatusCode() == 200) {
		List<Datacenter> value = GsonFactory.getGson().fromJson(httpResponse.getContent(), new TypeToken<List<Datacenter>>() {
		}.getType());
		return new Response<List<Datacenter>>(value, httpResponse);
	} else {
		throw new OperationException(httpResponse);
	}
}
 

@Override
public boolean delete(TaskDO taskDO) {
    try {

        NamingService sourceNamingService =
            nacosServerHolder.get(taskDO.getSourceClusterId(), taskDO.getGroupName());
        ConsulClient consulClient = consulServerHolder.get(taskDO.getDestClusterId(), taskDO.getGroupName());

        sourceNamingService.unsubscribe(taskDO.getServiceName(), nacosListenerMap.get(taskDO.getTaskId()));

        // 删除目标集群中同步的实例列表
        Response<List<HealthService>> serviceResponse =
            consulClient.getHealthServices(taskDO.getServiceName(), true, QueryParams.DEFAULT);
        List<HealthService> healthServices = serviceResponse.getValue();
        for (HealthService healthService : healthServices) {

            if (needDelete(ConsulUtils.transferMetadata(healthService.getService().getTags()), taskDO)) {
                consulClient.agentServiceDeregister(healthService.getService().getId());
            }
        }
    } catch (Exception e) {
        log.error("delete a task from nacos to nacos was failed, taskId:{}", taskDO.getTaskId(), e);
        metricsManager.recordError(MetricsStatisticsType.DELETE_ERROR);
        return false;
    }
    return true;
}
 

@Test
void testGetCatalogNodes() {
	CatalogNodesRequest request = CatalogNodesRequest.newBuilder().build();
	Response<List<Node>> response = consulClient.getCatalogNodes(request);

	// We should find only one node – this
	assertEquals(1, response.getValue().size());
}
 

@Override
public Response<List<Event>> eventList(EventListRequest eventListRequest) {
	HttpResponse httpResponse = rawClient.makeGetRequest("/v1/event/list", eventListRequest.asUrlParameters());

	if (httpResponse.getStatusCode() == 200) {
		List<Event> value = GsonFactory.getGson().fromJson(httpResponse.getContent(), new TypeToken<List<Event>>() {
		}.getType());
		return new Response<List<Event>>(value, httpResponse);
	} else {
		throw new OperationException(httpResponse);
	}
}
 

private Response<List<HealthService>> consulInstancesResponse() {
	HealthService healthService = mock(HealthService.class);
	HealthService.Service service = mock(HealthService.Service.class);

	when(healthService.getService()).thenReturn(service);
	when(service.getAddress()).thenReturn("localhost");
	when(service.getPort()).thenReturn(443);
	lenient().when(service.getTags()).thenReturn(singletonList("secure=true"));

	return new Response<>(singletonList(healthService), 0L, true,
			System.currentTimeMillis());
}
 

public ConsulServiceResp lookupHealthService(String serviceName, long lastConsulIndex) {
    QueryParams queryParams = new QueryParams(ConsulConstants.CONSUL_BLOCK_TIME_SECONDS, lastConsulIndex);
    Response<List<HealthService>> orgResponse = client.getHealthServices(serviceName, true, queryParams);
    if (orgResponse != null && orgResponse.getValue() != null && !orgResponse.getValue().isEmpty()) {
        List<HealthService> HealthServices = orgResponse.getValue();
        List<ConsulService> ConsulServcies = Lists.newArrayList();
        for (HealthService orgService : HealthServices) {
            Service org = orgService.getService();
            ConsulService newService = ConsulService.newSalukiService()//
                                                    .withAddress(org.getAddress())//
                                                    .withName(org.getService())//
                                                    .withId(org.getId())//
                                                    .withPort(org.getPort().toString())//
                                                    .withTags(org.getTags())//
                                                    .build();
            ConsulServcies.add(newService);
        }
        if (!ConsulServcies.isEmpty()) {
            ConsulServiceResp response = ConsulServiceResp.newResponse()//
                                                          .withValue(ConsulServcies)//
                                                          .withConsulIndex(orgResponse.getConsulIndex())//
                                                          .withConsulLastContact(orgResponse.getConsulLastContact())//
                                                          .withConsulKnowLeader(orgResponse.isConsulKnownLeader())//
                                                          .build();
            return response;
        }
    }
    return null;
}
 

@Override
public Response<Void> agentForceLeave(String node) {
	HttpResponse httpResponse = rawClient.makePutRequest("/v1/agent/force-leave/" + node, "");

	if (httpResponse.getStatusCode() == 200) {
		return new Response<Void>(null, httpResponse);
	} else {
		throw new OperationException(httpResponse);
	}
}
 

@Override
public Response<Map<String, Service>> getAgentServices() {
	HttpResponse httpResponse = rawClient.makeGetRequest("/v1/agent/services");

	if (httpResponse.getStatusCode() == 200) {
		Map<String, Service> agentServices = GsonFactory.getGson().fromJson(httpResponse.getContent(),
				new TypeToken<Map<String, Service>>() {
				}.getType());
		return new Response<Map<String, Service>>(agentServices, httpResponse);
	} else {
		throw new OperationException(httpResponse);
	}
}
 

@Override
public Response<List<Check>> getHealthChecksForService(String serviceName, HealthChecksForServiceRequest healthChecksForServiceRequest) {
	HttpResponse httpResponse = rawClient.makeGetRequest("/v1/health/checks/" + serviceName, healthChecksForServiceRequest.asUrlParameters());

	if (httpResponse.getStatusCode() == 200) {
		List<Check> value = GsonFactory.getGson().fromJson(httpResponse.getContent(), new TypeToken<List<Check>>() {
		}.getType());
		return new Response<List<Check>>(value, httpResponse);
	} else {
		throw new OperationException(httpResponse);
	}
}
 

public List<URL> getProviderUrls(String serviceName) {
    List<URL> urls = new ArrayList<>();
    Response<List<HealthService>> healthServices = consulClient.getHealthServices(serviceName, true, null);
    for (HealthService healthService : healthServices.getValue()) {
        urls.add(URL.valueOf(healthService.getService().getAddress()));
    }
    return urls;
}
 

@Override
public Response<List<Check>> getHealthChecksForService(String serviceName, QueryParams queryParams) {
	HealthChecksForServiceRequest request = HealthChecksForServiceRequest.newBuilder()
			.setQueryParams(queryParams)
			.build();

	return getHealthChecksForService(serviceName, request);
}
 

private Check getCheckForService(String serviceId) {
	Response<List<Check>> checkResponse = this.consul
			.getHealthChecksForService(serviceId, HealthChecksForServiceRequest
					.newBuilder().setQueryParams(QueryParams.DEFAULT).build());
	if (checkResponse.getValue().size() > 0) {
		return checkResponse.getValue().get(0);
	}
	return null;
}
 

@Override
public Response<Void> aclUpdate(UpdateAcl updateAcl, String token) {
	UrlParameters tokenParams = token != null ? new SingleUrlParameters("token", token) : null;
	String json = GsonFactory.getGson().toJson(updateAcl);
	HttpResponse httpResponse = rawClient.makePutRequest("/v1/acl/update", json, tokenParams);

	if (httpResponse.getStatusCode() == 200) {
		return new Response<Void>(null, httpResponse);
	} else {
		throw new OperationException(httpResponse);
	}
}
 

@Override
public Response<List<com.ecwid.consul.v1.health.model.HealthService>> getHealthServices(String serviceName, String[] tags, boolean onlyPassing, QueryParams queryParams, String token) {
	HealthServicesRequest request = HealthServicesRequest.newBuilder()
			.setTags(tags)
			.setPassing(onlyPassing)
			.setQueryParams(queryParams)
			.setToken(token)
			.build();

	return getHealthServices(serviceName, request);
}
 

@Override
public Response<Void> agentCheckFail(String checkId, String note, String token) {
	UrlParameters noteParameter = note != null ? new SingleUrlParameters("note", note) : null;
	UrlParameters tokenParameter = token != null ? new SingleUrlParameters("token", token) : null;

	HttpResponse httpResponse = rawClient.makePutRequest("/v1/agent/check/fail/" + checkId, "", noteParameter, tokenParameter);

	if (httpResponse.getStatusCode() == 200) {
		return new Response<Void>(null, httpResponse);
	} else {
		throw new OperationException(httpResponse);
	}
}
 

@Test
public void contextLoads() {
	Response<Map<String, Service>> response = this.consul.getAgentServices();
	Map<String, Service> services = response.getValue();
	Service service = services.get("myTestService2-DD");
	assertThat(service).as("service was null").isNotNull();
	assertThat(service.getPort().intValue()).as("service port is 0").isNotEqualTo(0);
}
 

public List<ServiceInstance> getAllInstances() {
	List<ServiceInstance> instances = new ArrayList<>();

	Response<Map<String, List<String>>> services = this.client
			.getCatalogServices(CatalogServicesRequest.newBuilder()
					.setQueryParams(QueryParams.DEFAULT).build());
	for (String serviceId : services.getValue().keySet()) {
		addInstancesToList(instances, serviceId, QueryParams.DEFAULT);
	}
	return instances;
}
 

@Override
protected void handleMessageInternal(Message<?> message) {
	if (this.logger.isTraceEnabled()) {
		this.logger.trace("Publishing message" + message);
	}

	Object payload = message.getPayload();
	// TODO: support headers
	// TODO: support consul event filters: NodeFilter, ServiceFilter, TagFilter
	Response<Event> event = this.consul.eventFire(this.eventName, (String) payload,
			new EventParams(), QueryParams.DEFAULT);
	// TODO: return event?
	// return null;
}