Java PluginExecutorService类代码示例

import com.hivemq.spi.services.PluginExecutorService; //导入依赖的package包/类
@Inject
public InfluxDbConfiguration(final PluginExecutorService pluginExecutorService,
                             final SystemInformation systemInformation) {
    super(pluginExecutorService, systemInformation);

    final ValueChangedCallback<String> callback = new ValueChangedCallback<String>() {
        @Override
        public void valueChanged(final String newValue) {
            if (listener != null) {
                listener.restart();
            }
        }
    };

    addCallback("mode", callback);
    addCallback("host", callback);
    addCallback("port", callback);
    addCallback("protocol", callback);
    addCallback("reportingInterval", callback);
    addCallback("prefix", callback);
    addCallback("database", callback);
    addCallback("auth", callback);
    addCallback("connectTimeout", callback);
    addCallback("tags", callback);
}
 

import com.hivemq.spi.services.PluginExecutorService; //导入依赖的package包/类
@Inject
public ConsulDiscoveryCallback(final Consul consul,
                               final Configuration configuration,
                               final PluginExecutorService pluginExecutorService) {
    this.consul = consul;
    this.configuration = configuration;
    this.pluginExecutorService = pluginExecutorService;
}
 

import com.hivemq.spi.services.PluginExecutorService; //导入依赖的package包/类
@Inject
public S3DiscoveryCallback(final AmazonS3 s3,
                           final Configuration configuration,
                           final PluginExecutorService pluginExecutorService) {
    this.s3 = s3;
    this.s3.setEndpoint(configuration.getEndpoint());
    this.s3.setS3ClientOptions(new S3ClientOptions().withPathStyleAccess(configuration.withPathStyleAccess()));
    this.configuration = configuration;
    this.pluginExecutorService = pluginExecutorService;
    this.bucketName = configuration.getBucketName();
}
 

import com.hivemq.spi.services.PluginExecutorService; //导入依赖的package包/类
@Inject
public Configuration(final PluginExecutorService pluginExecutorService, SystemInformation systemInformation) {
    super(pluginExecutorService, systemInformation);
    this.pluginExecutorService = pluginExecutorService;
    this.systemInformation = systemInformation;


    init();

    final ValueChangedCallback callback = new ValueChangedCallback() {
        @Override
        public void valueChanged(final Object newValue) {
            if (listener != null) {
                listener.restart();
            }
        }
    };

    addCallback("filename", callback);
    addCallback("reloadCredentialsInterval.seconds", callback);
    addCallback("passwordHashing.enabled", callback);
    addCallback("passwordHashing.iterations", callback);
    addCallback("passwordHashing.algorithm", callback);
    addCallback("passwordHashingSalt.separationChar", callback);
    addCallback("passwordHashingSalt.enabled", callback);
    addCallback("passwordHashingSalt.isFirst", callback);
    addCallback("cachingTime.seconds", callback);
    addCallback("cacheSize", callback);

}
 

import com.hivemq.spi.services.PluginExecutorService; //导入依赖的package包/类
@Inject
public CredentialsConfiguration(final PluginExecutorService pluginExecutorService, final String filename, final int reloadSeconds, final SystemInformation systemInformation) {
    super(pluginExecutorService, systemInformation);
    this.callbacks = new ArrayList<>();
    this.filename = filename;
    this.reloadSeconds = reloadSeconds;
}
 

import com.hivemq.spi.services.PluginExecutorService; //导入依赖的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.hivemq.spi.services.PluginExecutorService; //导入依赖的package包/类
ReloadingPropertiesReader(final PluginExecutorService pluginExecutorService,
                          final SystemInformation systemInformation) {
    this.pluginExecutorService = pluginExecutorService;
    this.systemInformation = systemInformation;
}
 

import com.hivemq.spi.services.PluginExecutorService; //导入依赖的package包/类
public TestReloadingPropertiesReader(final PluginExecutorService pluginExecutorService, final SystemInformation systemInformation, final String filename) {
    super(pluginExecutorService, systemInformation);
    this.filename = filename;
}
 

import com.hivemq.spi.services.PluginExecutorService; //导入依赖的package包/类
@Inject
public PersistMessagesCallback(final Provider<Connection> connectionProvider,
                               final PluginExecutorService pluginExecutorService) {
    this.connectionProvider = connectionProvider;
    this.pluginExecutorService = pluginExecutorService;
}
 

import com.hivemq.spi.services.PluginExecutorService; //导入依赖的package包/类
public ReloadingPropertiesReader(final PluginExecutorService pluginExecutorService, final SystemInformation systemInformation) {
    this.pluginExecutorService = pluginExecutorService;
    this.systemInformation = systemInformation;
}