Java LifeCycleManager类代码示例

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
public ExampleHttpServer()
        throws Exception
{
    Bootstrap app = new Bootstrap(
            new TestingNodeModule(),
            new TestingHttpServerModule(),
            new ExampleHttpServerModule());

    Injector injector = app
            .strictConfig()
            .doNotInitializeLogging()
            .initialize();

    lifeCycleManager = injector.getInstance(LifeCycleManager.class);
    baseUri = injector.getInstance(TestingHttpServer.class).getBaseUrl();
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Inject
public RaptorConnector(
        LifeCycleManager lifeCycleManager,
        RaptorMetadataFactory metadataFactory,
        RaptorSplitManager splitManager,
        RaptorPageSourceProvider pageSourceProvider,
        RaptorPageSinkProvider pageSinkProvider,
        RaptorSessionProperties sessionProperties,
        RaptorTableProperties tableProperties,
        Set<SystemTable> systemTables)
{
    this.lifeCycleManager = requireNonNull(lifeCycleManager, "lifeCycleManager is null");
    this.metadataFactory = requireNonNull(metadataFactory, "metadataFactory is null");
    this.splitManager = requireNonNull(splitManager, "splitManager is null");
    this.pageSourceProvider = requireNonNull(pageSourceProvider, "pageSourceProvider is null");
    this.pageSinkProvider = requireNonNull(pageSinkProvider, "pageSinkProvider is null");
    this.sessionProperties = requireNonNull(sessionProperties, "sessionProperties is null").getSessionProperties();
    this.tableProperties = requireNonNull(tableProperties, "tableProperties is null").getTableProperties();
    this.systemTables = requireNonNull(systemTables, "systemTables is null");
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Provides
@Singleton
private static Optional<BackupStore> createBackupStore(
        @Nullable BackupStore store,
        LifeCycleManager lifeCycleManager,
        RaptorConnectorId connectorId,
        BackupConfig config)
        throws Exception
{
    if (store == null) {
        return Optional.empty();
    }

    BackupStore proxy = new TimeoutBackupStore(store, connectorId.toString(), config.getTimeout());
    lifeCycleManager.addInstance(proxy);
    return Optional.of(proxy);
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
public HiveConnector(
        LifeCycleManager lifeCycleManager,
        ConnectorMetadata metadata,
        ConnectorSplitManager splitManager,
        ConnectorPageSourceProvider pageSourceProvider,
        ConnectorPageSinkProvider pageSinkProvider,
        Set<SystemTable> systemTables,
        List<PropertyMetadata<?>> sessionProperties,
        List<PropertyMetadata<?>> tableProperties,
        ConnectorAccessControl accessControl)
{
    this.lifeCycleManager = requireNonNull(lifeCycleManager, "lifeCycleManager is null");
    this.metadata = requireNonNull(metadata, "metadata is null");
    this.splitManager = requireNonNull(splitManager, "splitManager is null");
    this.pageSourceProvider = requireNonNull(pageSourceProvider, "pageSourceProvider is null");
    this.pageSinkProvider = requireNonNull(pageSinkProvider, "pageSinkProvider is null");
    this.systemTables = ImmutableSet.copyOf(requireNonNull(systemTables, "systemTables is null"));
    this.sessionProperties = ImmutableList.copyOf(requireNonNull(sessionProperties, "sessionProperties is null"));
    this.tableProperties = ImmutableList.copyOf(requireNonNull(tableProperties, "tableProperties is null"));
    this.accessControl = requireNonNull(accessControl, "accessControl is null");
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
private static void testAddressSelector(
        AddressSelectorBinder addressSelectorBinder,
        Map<String, String> configurationProperties,
        List<HostAndPort> expected)
        throws Exception
{
    Bootstrap app = new Bootstrap(
            new ThriftCodecModule(),
            binder -> addressSelectorBinder.bind(binder, THRIFT_SERVICE_ANNOTATION, "testService"));

    LifeCycleManager lifeCycleManager = null;
    try {
        Injector injector = app
                .setRequiredConfigurationProperties(configurationProperties)
                .strictConfig()
                .doNotInitializeLogging()
                .initialize();
        lifeCycleManager = injector.getInstance(LifeCycleManager.class);

        AddressSelector<?> addressSelector = injector.getInstance(Key.get(AddressSelector.class, THRIFT_SERVICE_ANNOTATION));
        assertInstanceOf(addressSelector, SimpleAddressSelector.class);
        SimpleAddressSelector simpleAddressSelector = (SimpleAddressSelector) addressSelector;
        assertEquals(simpleAddressSelector.getAddresses(), expected);
    }
    finally {
        if (lifeCycleManager != null) {
            try {
                lifeCycleManager.stop();
            }
            catch (Exception ignored) {
            }
        }
    }
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Inject
    public HDFSConnector(
            LifeCycleManager lifeCycleManager,
            HDFSMetadataFactory hdfsMetadataFactory,
            HDFSSplitManager hdfsSplitManager,
            HDFSPageSourceProvider hdfsPageSourceProvider)
    {
        this.lifeCycleManager = requireNonNull(lifeCycleManager, "lifeCycleManager is null");
        this.hdfsMetadataFactory = requireNonNull(hdfsMetadataFactory, "hdfsMetadataFactory is null");
        this.hdfsSplitManager = requireNonNull(hdfsSplitManager, "hdfsSplitManager is null");
        this.hdfsPageSourceProvider = requireNonNull(hdfsPageSourceProvider, "hdfsPageSourceProvider is null");
//        this.nodePartitioningProvider = requireNonNull(nodePartitioningProvider, "nodePartitioningProvider is null");
    }
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Inject
public EthereumConnector(
        LifeCycleManager lifeCycleManager,
        EthereumMetadata metadata,
        EthereumSplitManager splitManager,
        EthereumRecordSetProvider recordSetProvider
) {
    this.lifeCycleManager = requireNonNull(lifeCycleManager, "lifeCycleManager is null");
    this.metadata = requireNonNull(metadata, "metadata is null");
    this.splitManager = requireNonNull(splitManager, "splitManager is null");
    this.recordSetProvider = requireNonNull(recordSetProvider, "recordSetProvider is null");
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Inject
public AmpoolConnector(
        LifeCycleManager lifeCycleManager,
        AmpoolMetadata metadata,
        AmpoolSplitManager splitManager,
        AmpoolRecordSetProvider recordSetProvider)
{
    this.lifeCycleManager = requireNonNull(lifeCycleManager, "lifeCycleManager is null");
    this.metadata = requireNonNull(metadata, "metadata is null");
    this.splitManager = requireNonNull(splitManager, "splitManager is null");
    this.recordSetProvider = requireNonNull(recordSetProvider, "recordSetProvider is null");
    log.info("INFORMATION: AmpoolConnector created.");
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Inject
public KuduConnector(
        LifeCycleManager lifeCycleManager,
        KuduMetadata metadata,
        KuduSplitManager splitManager,
        KuduRecordSetProvider recordSetProvider)
{
    this.recordSetProvider = recordSetProvider;
    this.lifeCycleManager = requireNonNull(lifeCycleManager, "lifeCycleManager is null");
    this.metadata = requireNonNull(metadata, "metadata is null");
    this.splitManager = requireNonNull(splitManager, "splitManager is null");
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Inject
public KafkaConnector(
        LifeCycleManager lifeCycleManager,
        KafkaMetadata metadata,
        KafkaSplitManager splitManager,
        KafkaRecordSetProvider recordSetProvider)
{
    this.lifeCycleManager = requireNonNull(lifeCycleManager, "lifeCycleManager is null");
    this.metadata = requireNonNull(metadata, "metadata is null");
    this.splitManager = requireNonNull(splitManager, "splitManager is null");
    this.recordSetProvider = requireNonNull(recordSetProvider, "recordSetProvider is null");
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Inject
public ExampleConnector(
        LifeCycleManager lifeCycleManager,
        ExampleMetadata metadata,
        ExampleSplitManager splitManager,
        ExampleRecordSetProvider recordSetProvider)
{
    this.lifeCycleManager = requireNonNull(lifeCycleManager, "lifeCycleManager is null");
    this.metadata = requireNonNull(metadata, "metadata is null");
    this.splitManager = requireNonNull(splitManager, "splitManager is null");
    this.recordSetProvider = requireNonNull(recordSetProvider, "recordSetProvider is null");
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
public TestingDiscoveryServer(String environment)
        throws Exception
{
    tempDir = Files.createTempDir();

    Map<String, String> serverProperties = ImmutableMap.<String, String>builder()
            .put("static.db.location", tempDir.getAbsolutePath())
            .put("discovery.store-cache-ttl", "0ms")
            .build();

    Bootstrap app = new Bootstrap(
            new MBeanModule(),
            new TestingNodeModule(environment),
            new TestingHttpServerModule(),
            new JsonModule(),
            new JaxrsModule(true),
            new DiscoveryServerModule(),
            new DiscoveryModule(),
            new TestingJmxModule());

    Injector injector = app
            .strictConfig()
            .doNotInitializeLogging()
            .setRequiredConfigurationProperties(serverProperties)
            .initialize();

    lifeCycleManager = injector.getInstance(LifeCycleManager.class);

    server = injector.getInstance(TestingHttpServer.class);
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Inject
public JdbcConnector(
        LifeCycleManager lifeCycleManager,
        JdbcMetadata jdbcMetadata,
        JdbcSplitManager jdbcSplitManager,
        JdbcRecordSetProvider jdbcRecordSetProvider,
        JdbcRecordSinkProvider jdbcRecordSinkProvider)
{
    this.lifeCycleManager = requireNonNull(lifeCycleManager, "lifeCycleManager is null");
    this.jdbcMetadata = requireNonNull(jdbcMetadata, "jdbcMetadata is null");
    this.jdbcSplitManager = requireNonNull(jdbcSplitManager, "jdbcSplitManager is null");
    this.jdbcRecordSetProvider = requireNonNull(jdbcRecordSetProvider, "jdbcRecordSetProvider is null");
    this.jdbcRecordSinkProvider = requireNonNull(jdbcRecordSinkProvider, "jdbcRecordSinkProvider is null");
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Inject
public GracefulShutdownHandler(
        TaskManager sqlTaskManager,
        ServerConfig serverConfig,
        ShutdownAction shutdownAction,
        LifeCycleManager lifeCycleManager)
{
    this.sqlTaskManager = requireNonNull(sqlTaskManager, "sqlTaskManager is null");
    this.shutdownAction = requireNonNull(shutdownAction, "shutdownAction is null");
    this.lifeCycleManager = requireNonNull(lifeCycleManager, "lifeCycleManager is null");
    this.isCoordinator = requireNonNull(serverConfig, "serverConfig is null").isCoordinator();
    this.gracePeriod = serverConfig.getGracePeriod();
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Inject
public CassandraConnector(
        LifeCycleManager lifeCycleManager,
        CassandraMetadata metadata,
        CassandraSplitManager splitManager,
        CassandraRecordSetProvider recordSetProvider,
        CassandraConnectorRecordSinkProvider recordSinkProvider)
{
    this.lifeCycleManager = requireNonNull(lifeCycleManager, "lifeCycleManager is null");
    this.metadata = requireNonNull(metadata, "metadata is null");
    this.splitManager = requireNonNull(splitManager, "splitManager is null");
    this.recordSetProvider = requireNonNull(recordSetProvider, "recordSetProvider is null");
    this.recordSinkProvider = requireNonNull(recordSinkProvider, "recordSinkProvider is null");
}