Java ImmutableRegistration类代码示例

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
private void tryRegisterConsulService(ClusterNodeAddress ownAddress) {

        if (!consul.agentClient().isRegistered(configuration.getConsulServiceId())) {
            log.debug("service {} not registered, will try to do so", configuration.getConsulServiceName());

            Registration.RegCheck ttlCheck = Registration.RegCheck.ttl(configuration.getConsulCheckTTL());
            Registration serviceRegistration = ImmutableRegistration.builder()
                    .name(getServiceName())
                    .address(getNodeAddress(ownAddress))
                    .port(ownAddress.getPort())
                    .id(getServiceId())
                    .addChecks(ttlCheck).build();
            consul.agentClient().register(serviceRegistration, getQueryOptions());

            log.info("registered service {}, registration status now is {}", configuration.getConsulServiceName(), consul.agentClient().isRegistered(configuration.getConsulServiceId()));
        } else {
            log.debug("service {} already registered", configuration.getConsulServiceName());
        }
    }
 

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
private void registerSelf() throws MalformedURLException {
  if (clientOnly) {
    LOG.debug("Client only. Not registering self with consul");
    return;
  }
  LOG.info("Registering self with Consul");
  Registration.RegCheck ttlCheck = ImmutableRegCheck.builder().ttl("60s").deregisterCriticalServiceAfter("1m").build();
  Registration registration =
    ImmutableRegistration.builder().address(consulServiceAddress).port(Integer.parseInt(consulServicePort))
      .name(consulServiceName).id(consulServiceId).check(ttlCheck).build();
  if (CONSUL_HOLDER != null && CONSUL_HOLDER.hasInstance()) {
    CONSUL_HOLDER.registerSelf(registration);
  } else {
    CONSUL_HOLDER = ConsulHolder.initialize(Consul.builder().withUrl(basePath.toURL()).build(), this);
    CONSUL_HOLDER.registerSelf(registration);
  }
  Runtime.getRuntime().removeShutdownHook(shutdownHook);
  Runtime.getRuntime().addShutdownHook(shutdownHook);
}
 

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
public void advertise(Registration registration) {
    if (this.advertisements.contains(registration)) {
        return;
    }

    AgentClient client = this.agentClientInjector.getValue();

    com.orbitz.consul.model.agent.Registration consulReg = ImmutableRegistration.builder()
            .address(registration.getAddress())
            .port(registration.getPort())
            .id(serviceId(registration))
            .name(registration.getName())
            .addTags(registration.getTags().toArray(new String[]{}))
            .check(com.orbitz.consul.model.agent.Registration.RegCheck.ttl(3L))
            .build();
    client.register(consulReg);

    this.advertisements.add(registration);

    log.info("Registered service " + consulReg.getId());
}
 

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
@Test
public void testHostFromConfig() {
    factory.setServicePort(8888);
    factory.setServiceAddress("127.0.0.1");

    when(agent.isRegistered(anyString())).thenReturn(false);
    final ConsulAdvertiser advertiser = new ConsulAdvertiser(environment,
            factory, consul, serviceId);
    advertiser.register(8080, 8081);

    final ImmutableRegistration registration = ImmutableRegistration
            .builder().id(serviceId).port(8888).address("127.0.0.1")
            .check(ImmutableRegCheck.builder()
                    .http("http://127.0.0.1:8081/admin/healthcheck")
                    .interval("1s").deregisterCriticalServiceAfter("1m")
                    .build())
            .name("test").build();

    verify(agent).register(registration);
}
 

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
@Test
public void testTagsFromConfig() {
    final List<String> tags = Arrays.asList("test", "second-test");
    factory.setTags(tags);

    when(agent.isRegistered(serviceId)).thenReturn(false);
    final ConsulAdvertiser advertiser = new ConsulAdvertiser(environment,
            factory, consul, serviceId);
    advertiser.register(8080, 8081);

    final ImmutableRegistration registration = ImmutableRegistration
            .builder().tags(tags)
            .check(ImmutableRegCheck.builder()
                    .http("http://127.0.0.1:8081/admin/healthcheck")
                    .interval("1s").deregisterCriticalServiceAfter("1m")
                    .build())
            .name("test").port(8080).id(serviceId).build();

    verify(agent).register(registration);
}
 

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
@Override
protected void doPreSetup() throws Exception {
    client = getConsul().agentClient();

    registrations = new ArrayList<>(SERVICE_COUNT);
    expectedBodies = new ArrayList<>(SERVICE_COUNT);

    for (int i = 0; i < SERVICE_COUNT; i++) {
        Registration r = ImmutableRegistration.builder()
            .id("service-" + i)
            .name(SERVICE_NAME)
            .address("127.0.0.1")
            .port(SERVICE_PORT_BASE + i)
            .build();

        client.register(r);

        registrations.add(r);
        expectedBodies.add("ping on " + r.getPort().get());
    }
}
 

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
public void advertise(Registration registration) {
    if (this.advertisements.contains(registration)) {
        return;
    }

    AgentClient client = this.agentClientInjector.getValue();

    com.orbitz.consul.model.agent.Registration consulReg = ImmutableRegistration.builder()
            .address(registration.getAddress())
            .port(registration.getPort())
            .id(serviceId(registration))
            .name(registration.getName())
            .addTags(registration.getTags().toArray(new String[]{}))
            .check(com.orbitz.consul.model.agent.Registration.RegCheck.ttl(3L))
            .build();
    client.register(consulReg);

    this.advertisements.add(registration);
}
 

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
private static void register() {
    AgentClient agentClient = consul.agentClient();

    List<Registration.RegCheck> checks = new ArrayList<Registration.RegCheck>();

    HostAndPort serviceHostAndPort = HostAndPort.fromParts(visibleHost, visiblePort);

    Registration.RegCheck mainCheck = Registration.RegCheck.tcp(serviceHostAndPort.toString(), 30);

    checks.add(mainCheck);

    Registration registration = ImmutableRegistration
            .builder()
            .port(visiblePort)
            .address(visibleHost)
            .checks(checks)
            .name(serviceName)
            .id(serviceId)
            .addTags(tsdMode)
            .build();

    agentClient.register(registration);

    if (agentClient.isRegistered(serviceId)) {
        LOGGER.info("Registered this instance with Consul");
    } else {
        LOGGER.warn("Consul reports that this instance is not registered");
    }
}
 

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
@Test
public void testRegister() {
    when(agent.isRegistered(serviceId)).thenReturn(false);
    advertiser.register(8080, 8081);

    final ImmutableRegistration registration = ImmutableRegistration
            .builder().port(8080)
            .check(ImmutableRegCheck.builder()
                    .http("http://127.0.0.1:8081/admin/healthcheck")
                    .interval("1s").deregisterCriticalServiceAfter("1m")
                    .build())
            .name("test").id(serviceId).build();

    verify(agent).register(registration);
}
 

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
@Override
public void register() throws Exception {
	
	try {
		this.myServiceId = this.consulServiceName + "-" + 
						   this.myLocalAddress.getInetAddress().getHostAddress() +"-" + 
						   this.myLocalAddress.getHost() + "-" + 
						   this.myLocalAddress.getPort();
		
		
		ImmutableRegistration.Builder builder = ImmutableRegistration.builder()
									.name(this.consulServiceName)
									.id(myServiceId)
									.address(this.myLocalAddress.getInetAddress().getHostAddress())
									.port(this.myLocalAddress.getPort())
									.tags(Arrays.asList(tags));
		
		
		String healthCheckProvider = getHealthCheckProvider( (String)registratorConfig.get(CONFIG_PROP_HEALTH_CHECK_PROVIDER) );
		
		HealthCheckBuilder healthBuilder = (HealthCheckBuilder)Class.forName(healthCheckProvider).newInstance();
		RegCheck regCheck =healthBuilder.buildRegistrationCheck(registratorConfig, this.myLocalAddress);
	
		if (regCheck != null) {
			builder.check(regCheck);
		}
		
		// register...
		this.consulAgentClient.register(builder.build(), ConsulUtility.getAclToken(this.consulAclToken));
		
		this.logger.info("Registered with Consul["+this.consulHost+":"+this.consulPort+"] serviceId:"+myServiceId);
		
	} catch(Exception e) {
		String msg = "Unexpected error in register(serviceId:"+myServiceId+"): " + e.getMessage();
		logger.severe(msg,e);
		throw new Exception(msg,e);
	}
}
 

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
@Override
public void configure(final Env env, final Config config, final Binder binder) throws Throwable {

  Config consulConfig = config.getConfig("consul.default");
  if (!name.equals("default") && config.hasPath("consul." + name)) {
    consulConfig = config.getConfig("consul." + name).withFallback(consulConfig);
  }

  Consul.Builder consulBuilder = Consul.builder()
      .withUrl(consulConfig.getString("url"));

  if (consulBuilderConsumer != null) {
    consulBuilderConsumer.accept(consulBuilder);
  }

  Consul consul = consulBuilder.build();

  env.onStop(consul::destroy);

  env.serviceKey().generate(Consul.class, name, k -> binder.bind(k).toInstance(consul));

  if (consulConfig.hasPath("register")) {

    Config registerConfig = consulConfig.getConfig("register");

    ImmutableRegistration.Builder registrationBuilder = ImmutableRegistration.builder()
        .name(registerConfig.getString("name"))
        .address(registerConfig.getString("host"))
        .port(registerConfig.getInt("port"))
        .tags(registerConfig.getStringList("tags"))
        .id(UUID.randomUUID().toString());

    if (registerConfig.hasPath("check")) {

      Config checkConfig = registerConfig.getConfig("check");

      String http = MessageFormat.format("http://{0}:{1,number,####}{2}",
          registerConfig.getString("host"),
          registerConfig.getInt("port"),
          checkConfig.getString("path"));

      Registration.RegCheck check = Registration.RegCheck.http(http,
          checkConfig.getDuration("interval", TimeUnit.SECONDS),
          checkConfig.getDuration("timeout", TimeUnit.SECONDS));

      registrationBuilder.check(check);

      String response = checkConfig.getString("response");
      env.router().get(checkConfig.getString("path"), () -> response);
    }

    if (registrationBuilderConsumer != null) {
      registrationBuilderConsumer.accept(registrationBuilder);
    }

    Registration registration = registrationBuilder.build();

    AgentClient agentClient = consul.agentClient();
    env.onStarted(() -> agentClient.register(registration));
    env.onStop(() -> agentClient.deregister(registration.getId()));
  }
}
 

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
@Test
public void testServiceDiscovery() throws Exception {
    final AgentClient client = getConsul().agentClient();
    try {
        registrations = new ArrayList<>(3);

        for (int i = 0; i < 3; i++) {
            Registration r = ImmutableRegistration.builder()
                .id("service-" + i)
                .name("my-service")
                .address("127.0.0.1")
                .addTags("a-tag")
                .addTags("key1=value1")
                .addTags("key2=value2")
                .port(9000 + i)
                .build();

            client.register(r);
            registrations.add(r);
        }

        ConsulConfiguration configuration = new ConsulConfiguration();
        configuration.setUrl(consulUrl);
        ServiceDiscovery discovery = new ConsulServiceDiscovery(configuration);

        List<ServiceDefinition> services = discovery.getServices("my-service");
        assertNotNull(services);
        assertEquals(3, services.size());

        for (ServiceDefinition service : services) {
            assertFalse(service.getMetadata().isEmpty());
            assertTrue(service.getMetadata().containsKey("service_name"));
            assertTrue(service.getMetadata().containsKey("service_id"));
            assertTrue(service.getMetadata().containsKey("a-tag"));
            assertTrue(service.getMetadata().containsKey("key1"));
            assertTrue(service.getMetadata().containsKey("key2"));
        }
    } finally {
        if (registrations != null && client != null) {
            registrations.forEach(r -> client.deregister(r.getId()));
        }
    }
}
 

import com.orbitz.consul.model.agent.ImmutableRegistration; //导入依赖的package包/类
/**
 * <p>
 * {@link Registration} object can be configured programmatically:
 * </p>
 *
 * <pre>{@code
 * {
 *   use(new Consulby()
 *     .withRegistrationBuilder(registrationBuilder -> {
 *       registrationBuilder.enableTagOverride(true);
 *       registrationBuilder.id("custom-service-id");
 *     }));
 * }
 * }</pre>
 *
 * @param registrationBuilderConsumer A {@link Consumer} that accepts
 *        {@link ImmutableRegistration.Builder}
 * @return This {@link Consulby} to allow chaining
 */
public Consulby withRegistrationBuilder(
    final Consumer<ImmutableRegistration.Builder> registrationBuilderConsumer) {
  this.registrationBuilderConsumer = registrationBuilderConsumer;
  return this;
}