import com.orbitz.consul.NotRegisteredException; //导入依赖的package包/类
private void registerMyself() throws NotRegisteredException, IOException {
    AgentClient agentClient = getConsul().agentClient();

    if (!agentClient.isRegistered(consulProperties.getServiceId())) {
        registerHeartbeat();
    }

    log.info("writing service access properties");
    KeyValueClient kvClient = getConsul().keyValueClient();
    Map<String, String> accessProperties = new HashMap<>();
    String serverName = InetAddress.getLocalHost().getHostName();
    accessProperties.put("hostname", serverName);
    accessProperties.put("ip", dnsResolver.readNonLoopbackLocalAddress());
    String port = String.valueOf(serverProperties.getPort());
    accessProperties.put("port", port);
    accessProperties.put("username", securityProperties.getUser().getName());
    accessProperties.put("password", securityProperties.getUser().getPassword());

    // read current access values and add ourselves
    String accessKey = consulProperties.getServiceName() + "/access/" + serverName + ":" + port;
    kvClient.putValue(accessKey, mapper.writeValueAsString(accessProperties));
}
 

import com.orbitz.consul.NotRegisteredException; //导入依赖的package包/类
/**
 * changes the heartbeat check to PASS in a configurable rate. The default rate is 15 minutes. The heartbeat check
 * is defined with a grace period of 2 heartbeats before it sets itself to FAIL.
 */
@Override
public void keepAlive() {
    try {
        AgentClient agentClient = getConsul().agentClient();
        // the heartbeat is the service itself, not a check - that's why we "pass" it and not "check" it
        agentClient.pass(toUniqueName("heartbeat"));
        log.info("[check heartbeat]: PASS");
    } catch (NotRegisteredException e) {
        log.error("[check heartbeat]: FAIL " + e.getMessage());
        log.error("can't mark heartbeat as PASS", e);
        registerHeartbeat();
    }
}
 

import com.orbitz.consul.NotRegisteredException; //导入依赖的package包/类
@Test
public void registerAndCheckServiceTest() throws NotRegisteredException {
    injects();
    final String serviceName = "MyService";
    final String serviceId = "1";
    agentClient.register(8080, 3L, serviceName, serviceId);
    agentClient.pass(serviceId);
    agentClient.deregister(serviceId);
}
 

import com.orbitz.consul.NotRegisteredException; //导入依赖的package包/类
@Test
public void fullPluginLifecycleWithDefaultConfiguration() throws ExecutionException, InterruptedException {

    // dummy consul client
    Consul consul = mock(Consul.class);
    AgentClient agentClient = mock(AgentClient.class);
    when(consul.agentClient()).thenReturn(agentClient);

    // empty config
    ConfigurationReader configurationReader = mock(ConfigurationReader.class);
    Properties properties = new Properties();
    when(configurationReader.getProperties()).thenReturn(properties);
    Configuration configuration = new Configuration(configurationReader);

    PluginExecutorService pluginExecutorService = mock(PluginExecutorService.class);

    ConsulDiscoveryCallback callback = new ConsulDiscoveryCallback(consul, configuration, pluginExecutorService);
    callback.init("clusternode1", new ClusterNodeAddress("clusternode1-hostname", 1234));

    // check if registration job gets scheduled
    ArgumentCaptor<Runnable> runnableArgument = ArgumentCaptor.forClass(Runnable.class);
    verify(pluginExecutorService, times(2)).scheduleAtFixedRate(runnableArgument.capture(), anyLong(), eq(60l), eq(TimeUnit.SECONDS));

    // run registration job
    Runnable registrationRunnable = runnableArgument.getAllValues().get(0);
    Runnable updateRunnable = runnableArgument.getAllValues().get(1);

    registrationRunnable.run();

    // verify service registration
    ArgumentCaptor<Registration> argument = ArgumentCaptor.forClass(Registration.class);
    verify(agentClient).register(argument.capture(), any());


    Registration registration = argument.getValue();
    assertEquals("cluster-discovery-hivemq", registration.getName());
    assertEquals("clusternode1-hostname", registration.getAddress().get());
    assertEquals(Integer.valueOf(1234), registration.getPort().get());
    assertEquals("cluster-discovery-hivemq", registration.getName());

    String registrationId = registration.getId();
    assertThat(registrationId).containsOnlyDigits();
    assertEquals(1, registration.getChecks().size());

    Registration.RegCheck regCheck = registration.getChecks().get(0);
    assertEquals("120s", regCheck.getTtl().get());

     // run updater job and check consul service pass call
    updateRunnable.run();
    try {
        verify(agentClient).pass(eq(registrationId));
    } catch (NotRegisteredException e) {
        throw new RuntimeException(e);
    }

    HealthClient healthClient = mock(HealthClient.class);
    List<ServiceHealth> nodes = new ArrayList<>();

    Service service = ImmutableService.builder()
            .address("host1")
            .id("not important")
            .service("doesnt matter")
            .port(5678).build();

    Node node = ImmutableNode.builder().node("node1").address("address1").build();
    ServiceHealth serviceHealth = ImmutableServiceHealth.builder().service(service).node(node).build();

    nodes.add(serviceHealth);
    ConsulResponse response = new ConsulResponse(nodes, 0, true, BigInteger.ZERO);
    when(healthClient.getHealthyServiceInstances(anyString(), ArgumentMatchers.<ImmutableQueryOptions>any())).thenReturn(response);
    when(consul.healthClient()).thenReturn(healthClient);

    List<ClusterNodeAddress> addresses = callback.getNodeAddresses().get();
    assertEquals(1, addresses.size());
    assertEquals("host1", addresses.get(0).getHost());
    assertEquals(5678, addresses.get(0).getPort());

    callback.destroy();
    verify(agentClient).deregister(eq(registrationId));
}
 

import com.orbitz.consul.NotRegisteredException; //导入依赖的package包/类
private void checkTtl() throws NotRegisteredException {
  if (!clientOnly) {
    CONSUL_HOLDER.checkTtl(consulServiceId);
  }
}