org.apache.curator.x.discovery.ServiceInstance Java Examples

private int brokerRegisterToZK() throws Exception {
	int port = brokerPort.getAndIncrement();
	ServiceInstance<Void> thisInstance = ServiceInstance.<Void> builder()//
	      .name("default")//
	      .address(localhostIP)//
	      .port(port)//
	      .id(String.valueOf(port))//
	      .build();

	ServiceDiscovery<Void> m_serviceDiscovery = ServiceDiscoveryBuilder.builder(Void.class)//
	      .client(m_client.get())//
	      .basePath("brokers")//
	      .thisInstance(thisInstance)//
	      .build();
	m_serviceDiscovery.start();

	if (tempBrokers.containsKey(port)) {
		throw new RuntimeException("Already Existed in tempBrokers!!");
	} else {
		tempBrokers.put(port, m_serviceDiscovery);
		return port;
	}
}
 

@Test
public void testExpiration() throws Exception
{
    ServiceInstance<Void> instance1 = ServiceInstance.<Void>builder().name("hey").id("1").build();
    ServiceInstance<Void> instance2 = ServiceInstance.<Void>builder().name("hey").id("2").build();

    DownInstanceManager<Void> downInstanceManager = new DownInstanceManager<Void>(debugDownInstancePolicy);

    downInstanceManager.add(instance1);
    Assert.assertFalse(downInstanceManager.apply(instance1));
    Assert.assertTrue(downInstanceManager.apply(instance2));

    Thread.sleep(debugDownInstancePolicy.getTimeoutMs());

    Assert.assertTrue(downInstanceManager.apply(instance1));
    Assert.assertTrue(downInstanceManager.apply(instance2));
}
 

@Override
public InstanceProvider<NodeStatus> load(String name) throws Exception {
    return new InstanceProvider<NodeStatus>() {
        @Override
        public List<ServiceInstance<NodeStatus>> getInstances() throws Exception {
            return (List<ServiceInstance<NodeStatus>>) serviceDiscovery.queryForInstances(name);
        }

        @Override
        public ServiceInstance<NodeStatus> getInstance(String nodeId) {
            try {
                return serviceDiscovery.queryForInstance(name, nodeId);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    };
}
 

private static void listInstances(ServiceDiscovery<InstanceDetails> serviceDiscovery) throws Exception {
	// This shows how to query all the instances in service discovery
	try {
		Collection<String> serviceNames = serviceDiscovery.queryForNames();
		System.out.println(serviceNames.size() + " type(s)");
		for (String serviceName : serviceNames) {
			Collection<ServiceInstance<InstanceDetails>> instances = serviceDiscovery.queryForInstances(serviceName);
			System.out.println(serviceName);
			for (ServiceInstance<InstanceDetails> instance : instances) {
				outputInstance(instance);
			}
		}
	} finally {
		CloseableUtils.closeQuietly(serviceDiscovery);
	}
}
 

@Test
public void testHttpRecordCreation() throws Exception {
  UriSpec uriSpec = new UriSpec("{scheme}://example.com:{port}/foo");
  ServiceInstance<JsonObject> instance = ServiceInstance.<JsonObject>builder()
      .name("foo-service")
      .payload(new JsonObject().put("foo", "bar").put("service-type", "http-endpoint"))
      .port(8080)
      .uriSpec(uriSpec)
      .build();

  Record record = ZookeeperServiceImporter.createRecordForInstance(instance);
  assertThat(record.getName()).isEqualTo("foo-service");
  assertThat(record.getType()).isEqualTo("http-endpoint");
  assertThat(record.getMetadata().getString("foo")).isEqualTo("bar");
  assertThat(record.getMetadata().getString("zookeeper-id")).isNotEmpty();
  assertThat(record.getLocation())
      .contains(entry("endpoint", "http://example.com:8080/foo"))
      .contains(entry("port", 8080));
}
 

/**
 * Return a service instance POJO
 *
 * @param name name of the service
 * @param id ID of the instance
 * @return the instance or <code>null</code> if not found
 * @throws Exception errors
 */
@Override
public ServiceInstance<T> queryForInstance(String name, String id) throws Exception
{
    String path = pathForInstance(name, id);
    try
    {
        byte[] bytes = client.getData().forPath(path);
        return serializer.deserialize(bytes);
    }
    catch ( KeeperException.NoNodeException ignore )
    {
        // ignore
    }
    return null;
}
 

@Override
public List<ApplicationInstance> all(String name) {
    List<ApplicationInstance> applicationInstanceList = new ArrayList<>();
    try {
        List<ServiceInstance<NodeStatus>> allInstances = serviceProviders.get(name).getAllInstances();
        if (allInstances.isEmpty()) {
            allInstances = nonCachedInstanceProviders.get(name).getInstances();
        }
        for (ServiceInstance<NodeStatus> serviceInstance : allInstances) {
            applicationInstanceList.add(ZkServiceInstanceAdaptor.applicationInstance(serviceInstance));
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return applicationInstanceList;
}
 

@Override
public Collection<DiscoveryInstance> getAllInstances(String serviceName)
{
    try
    {
        // TODO - validate service name
        ServiceProvider<Payload> provider = providers.get(serviceName);
        Collection<ServiceInstance<Payload>> allInstances = provider.getAllInstances();
        return Collections2.transform(allInstances, new Function<ServiceInstance<Payload>, DiscoveryInstance>()
        {
            @Nullable
            @Override
            public DiscoveryInstance apply(@Nullable ServiceInstance<Payload> instance)
            {
                return toSoaInstance(instance);
            }
        });
    }
    catch ( Exception e )
    {
        log.error("Could not get service: " + serviceName, e);
        throw new RuntimeException(e);
    }
}
 

@Override
public void setForcedState(String serviceName, String instanceId, ForcedState forcedState)
{
    try
    {
        ServiceInstance<Payload> foundInstance = discovery.queryForInstance(serviceName, instanceId);
        if ( foundInstance != null )
        {
            DiscoveryInstance soaInstance = toSoaInstance(foundInstance);
            Payload oldPayload = foundInstance.getPayload();
            Payload newPayload = new Payload(null, oldPayload.getAdminPort(), oldPayload.getMetaData(), forcedState, oldPayload.getHealthyState());
            ServiceInstance<Payload> updatedInstance = buildInstance(serviceName, HostAndPort.fromParts(soaInstance.getHost(), soaInstance.getPort()), newPayload, instanceId, soaInstance.getHost());
            discovery.updateService(updatedInstance);
        } // TODO else?
    }
    catch ( Exception e )
    {
        log.error("Could not update service: " + (serviceName + ":" + instanceId), e);
        throw new RuntimeException(e);
    }
}
 

private Response internalGet(String name, String id, boolean addDeprecationHeader)
{
    try
    {
        ServiceInstance<T> instance = context.getServiceDiscovery().queryForInstance(name, id);
        if ( instance == null )
        {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
        Response.ResponseBuilder builder = Response.ok(instance);
        if ( addDeprecationHeader )
        {
            builder = builder.header("Warning", "This API has been deprecated. Please see the updated spec for the replacement API.");
        }
        return builder.build();
    }
    catch ( Exception e )
    {
        ThreadUtils.checkInterrupted(e);
        log.error(String.format("Trying to get instance (%s) from service (%s)", id, name), e);
        return Response.serverError().build();
    }
}
 

@Test
public void testThreshold() throws Exception
{
    ServiceInstance<Void> instance1 = ServiceInstance.<Void>builder().name("hey").id("1").build();
    ServiceInstance<Void> instance2 = ServiceInstance.<Void>builder().name("hey").id("2").build();

    DownInstanceManager<Void> downInstanceManager = new DownInstanceManager<Void>(debugMultiDownInstancePolicy);
    Assert.assertTrue(downInstanceManager.apply(instance1));
    Assert.assertTrue(downInstanceManager.apply(instance2));

    downInstanceManager.add(instance1);
    Assert.assertTrue(downInstanceManager.apply(instance1));
    Assert.assertTrue(downInstanceManager.apply(instance2));

    downInstanceManager.add(instance1);
    Assert.assertFalse(downInstanceManager.apply(instance1));
    Assert.assertTrue(downInstanceManager.apply(instance2));
}
 

@Override
public InstanceProvider<UnitProxy> load(String unitFullName) throws Exception {
    return new InstanceProvider<UnitProxy>() {
        @Override
        public List<ServiceInstance<UnitProxy>> getInstances() throws Exception {
            return (List<ServiceInstance<UnitProxy>>) serviceDiscovery.queryForInstances(unitFullName);
        }

        @Override
        public ServiceInstance<UnitProxy> getInstance(String id) {
            try {
                return serviceDiscovery.queryForInstance(unitFullName, id);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    };
}
 

public void regService(String host, int port) throws Exception {

    haContext.startCuratorFramework();
    ServiceInstance<Void> serviceInstance = ServiceInstance.<Void>builder()
        .address(host)
        .port(port)
        .name(HAContext.SENTRY_SERVICE_REGISTER_NAMESPACE)
        .build();

    InstanceSerializer<Void> instanceSerializer = new FixedJsonInstanceSerializer<Void>(Void.class);
    ServiceDiscoveryBuilder.builder(Void.class)
        .basePath(HAContext.SENTRY_SERVICE_REGISTER_NAMESPACE)
        .client(haContext.getCuratorFramework())
        .serializer(instanceSerializer)
        .thisInstance(serviceInstance)
        .build()
        .start();
  }
 

public static void unregisterService(String serviceName, String clientId) {
    try {
        if (registry != null) {
            synchronized (lock) {
                ServiceInstance<NodeStatus> instance = registry.serviceDiscovery.queryForInstance(serviceName, clientId);
                if (instance != null) {
                    registry.serviceDiscovery.unregisterService(instance);
                } else {
                    LOG.warn("你要注销的服务不存在或已经被注销了,服务id:" + clientId);
                }
            }
        } else {
            LOG.error("服务注册机已经停止，说明本机所有服务已经全部注销，所以没必要再单独注销服务了。", new Throwable());
        }
    } catch (Throwable e) {
        LOG.error(e);
    }
}
 

static<T> ObjectNode writeInstance(ObjectMapper mapper, ServiceInstance<T> instance, DiscoveryContext<T> context)
{
    ObjectNode  node = mapper.createObjectNode();
    node.put("name", instance.getName());
    node.put("id", instance.getId());
    node.put("address", instance.getAddress());
    putInteger(node, "port", instance.getPort());
    putInteger(node, "sslPort", instance.getSslPort());
    node.put("registrationTimeUTC", instance.getRegistrationTimeUTC());
    node.put("serviceType", instance.getServiceType().name());
    try
    {
        context.marshallJson(node, "payload", instance.getPayload());
    }
    catch ( Exception e )
    {
        ThreadUtils.checkInterrupted(e);
        throw new WebApplicationException(e);
    }

    return node;
}
 

@Test
public void testThreshold() throws Exception
{
    ServiceInstance<Void> instance1 = ServiceInstance.<Void>builder().name("hey").id("1").build();
    ServiceInstance<Void> instance2 = ServiceInstance.<Void>builder().name("hey").id("2").build();

    DownInstanceManager<Void> downInstanceManager = new DownInstanceManager<Void>(debugMultiDownInstancePolicy);
    Assert.assertTrue(downInstanceManager.apply(instance1));
    Assert.assertTrue(downInstanceManager.apply(instance2));

    downInstanceManager.add(instance1);
    Assert.assertTrue(downInstanceManager.apply(instance1));
    Assert.assertTrue(downInstanceManager.apply(instance2));

    downInstanceManager.add(instance1);
    Assert.assertFalse(downInstanceManager.apply(instance1));
    Assert.assertTrue(downInstanceManager.apply(instance2));
}
 

@Override
public TTransport create(ServiceInstance<RpcPayload> instance)
        throws Exception {
    TTransport transport = this.createNativeTransport(instance);
    try {
        transport.open();
    } catch (TException ex) {
        LOG.warn(
                "Error when creating new transport on server: "
                        + instance.getAddress() + ":" + instance.getPort(),
                ex);
        markError(instance);
        throw ex;
    }
    return new ManagedTransport(transport, instance);
}
 

private static void listInstances(ServiceDiscovery<InstanceDetails> serviceDiscovery) throws Exception
{
    // This shows how to query all the instances in group discovery

    try
    {
        Collection<String>  serviceNames = serviceDiscovery.queryForNames();
        System.out.println(serviceNames.size() + " type(s)");
        for ( String serviceName : serviceNames )
        {
            Collection<ServiceInstance<InstanceDetails>> instances = serviceDiscovery.queryForInstances(serviceName);
            System.out.println(serviceName);
            for ( ServiceInstance<InstanceDetails> instance : instances )
            {
                outputInstance(instance);
            }
        }
    }
    finally
    {
        CloseableUtils.closeQuietly(serviceDiscovery);
    }
}
 

@Override
public UnitInstance firstInstance(String unitFullName) {
    try {
        Collection<ServiceInstance<UnitProxy>> instances = serviceProviders.getUnchecked(unitFullName).getAllInstances();
        if (instances.isEmpty())
            instances = nonCachedInstanceProviders.get(unitFullName).getInstances();
        if (instances.isEmpty()) return null;
        ServiceInstance<UnitProxy> zkServiceInstance = instances.iterator().next();
        return ZkServiceInstanceAdaptor.unitInstance(zkServiceInstance);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

@Override
public ServiceInstance<T> getInstance(InstanceProvider<T> instanceProvider) throws Exception
{
    List<ServiceInstance<T>>    instances = instanceProvider.getInstances();
    if ( instances.size() == 0 )
    {
        return null;
    }
    int                         thisIndex = Math.abs(index.getAndIncrement());
    return instances.get(thisIndex % instances.size());
}
 

private DiscoveryInstance toSoaInstance(ServiceInstance<Payload> instance)
{
    if ( instance == null )
    {
        return null;
    }

    Payload payload = instance.getPayload();
    int port = Objects.firstNonNull(instance.getPort(), Objects.firstNonNull(instance.getSslPort(), 0));
    return new DiscoveryInstanceImpl(instance.getId(), instance.getAddress(), port, instance.getSslPort() != null, payload);
}
 

public static ServiceInstance<UnitProxy> thisCuratorServiceInstance(Unit unit) throws Exception {
    String fullUnitName = Unit.fullName(unit);
    return ServiceInstance.<UnitProxy>builder()
            .address(EnvUtil.getLocalIp())
            .enabled(true)
            .id(new UnitInstanceIdBean(fullUnitName, LocalNodeManager.LOCAL_NODE_ID).getUnitInstanceId())
            .name(fullUnitName)
            .port(Node.RPC_PORT)
            .payload(UnitProxy.create(unit))
            .serviceType(ServiceType.DYNAMIC)
            .build();
}
 

@Test
public void     testRegisterService() throws Exception
{
    RestEasySingletons  restEasySingletons = RestEasyApplication.singletonsRef.get();

    ServiceInstance<String> service = ServiceInstance.<String>builder()
        .name("test")
        .payload("From Test")
        .serviceType(ServiceType.STATIC)
        .build();

    ByteArrayOutputStream           out = new ByteArrayOutputStream();
    restEasySingletons.serviceInstanceMarshallerSingleton.writeTo(service, null, null, null, null, null, out);

    getJson("http://localhost:" + port + "/v1/service/test/" + service.getId(), new String(out.toByteArray()));

    String json = getJson("http://localhost:" + port + "/v1/service", null);
    ServiceNames names = restEasySingletons.serviceNamesMarshallerSingleton.readFrom(ServiceNames.class, null, null, MediaType.APPLICATION_JSON_TYPE, null, new ByteArrayInputStream(json.getBytes()));
    Assert.assertEquals(names.getNames(), Lists.newArrayList("test"));

    json = getJson("http://localhost:" + port + "/v1/service/test", null);
    ServiceInstances<String> instances = restEasySingletons.serviceInstancesMarshallerSingleton.readFrom(null, null, null, null, null, new ByteArrayInputStream(json.getBytes()));
    Assert.assertEquals(instances.getServices().size(), 1);
    Assert.assertEquals(instances.getServices().get(0), service);

    // Retrieve single instance
    json = getJson("http://localhost:" + port + "/v1/service/test/" + service.getId(), null);
    ServiceInstance<String> instance = restEasySingletons.serviceInstanceMarshallerSingleton.readFrom(null, null, null, null, null, new ByteArrayInputStream(json.getBytes()));
    Assert.assertEquals(instance, service);

}
 

public void doAdvertise(Service<byte[]> service, boolean flag)
{
  try {
    new EnsurePath(basePath).ensure(curatorFramework.getZookeeperClient());

    ServiceInstance<byte[]> instance = getInstance(service);
    if (flag) {
      discovery.registerService(instance);
    } else {
      discovery.unregisterService(instance);
    }
  } catch (Exception e) {
    throw Throwables.propagate(e);
  }
}
 

public ServiceInstance serviceInstance() {
	try {
		return ServiceInstance.builder()
				.uriSpec(new UriSpec("{scheme}://{address}:{port}/"))
				.address("localhost").port(this.serverPort).name("testInstance")
				.build();
	}
	catch (Exception e) {
		throw new RuntimeException(e);
	}
}
 

public static ServiceInstance<UnitProxy> curatorServiceInstance(UnitInstance unitInstance) {
    try {
        return ServiceInstance.<UnitProxy>builder()
                .address(unitInstance.getAddress())
                .enabled(true)
                .id(unitInstance.getId())
                .name(unitInstance.getName())
                .port(unitInstance.getPort())
                .payload(unitInstance.getPayload())
                .build();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

public static ServiceInstance<NodeStatus> curatorServiceInstance(ApplicationInstance applicationInstance) {
    try {
        return ServiceInstance.<NodeStatus>builder()
                .address(/*applicationInstance.getPayload().getHost()*/applicationInstance.getAddress())
                .enabled(true)
                .id(applicationInstance.getId())
                .name(applicationInstance.getName())
                .port(applicationInstance.getPort())
                .payload(applicationInstance.getPayload())
                .build();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

@Override
public ServiceInstance<T> queryForInstance(String name, String id) throws Exception
{
    Collection<ServiceInstance<T>> instances = services.get(name);
    for ( ServiceInstance<T> instance : instances )
    {
        if ( instance.getId().equals(id) )
        {
            return instance;
        }
    }
    return null;
}
 

private static NetworkService toNetworkService(
    final NetworkService.Type serviceType,
    final ServiceInstance<Void> serviceInstance) {

    NetworkService ns = new NetworkService();
    ns.setType(serviceType);
    ns.setAddress(serviceInstance.getAddress());
    return ns;
}
 

JacksonInstanceSerializer(ObjectReader objectReader, ObjectWriter objectWriter,
    TypeReference<ServiceInstance<T>> typeRef)
{
  this.objectReader = objectReader;
  this.objectWriter = objectWriter;
  this.typeRef = typeRef;
}