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");
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Test
public void testGuiceClient()
        throws Exception
{
    TestingMethodInvocationStatsFactory statsFactory = new TestingMethodInvocationStatsFactory();
    ResultsSupplier resultsSupplier = new ResultsSupplier();
    MockMethodInvokerFactory<Annotation> invokerFactory = new MockMethodInvokerFactory<>(resultsSupplier);

    TestingExceptionClassifier globalClassifierOne = new TestingExceptionClassifier();
    TestingExceptionClassifier globalClassifierTwo = new TestingExceptionClassifier();
    TestingExceptionClassifier clientClassifier = new TestingExceptionClassifier();
    TestingExceptionClassifier customClientClassifier = new TestingExceptionClassifier();
    Bootstrap app = new Bootstrap(
            new ThriftCodecModule(),
            binder -> newSetBinder(binder, ExceptionClassifier.class).addBinding()
                    .toInstance(globalClassifierOne),
            binder -> newSetBinder(binder, ExceptionClassifier.class).addBinding()
                    .toInstance(globalClassifierTwo),
            binder -> binder.bind(new TypeLiteral<MethodInvokerFactory<Annotation>>() {})
                    .toInstance(invokerFactory),
            binder -> newOptionalBinder(binder, MethodInvocationStatsFactory.class)
                    .setBinding()
                    .toInstance(statsFactory),
            binder -> driftClientBinder(binder)
                    .bindDriftClient(Client.class)
                    .withAddressSelector(new MockAddressSelector())
                    .withExceptionClassifier(clientClassifier),
            binder -> driftClientBinder(binder)
                    .bindDriftClient(Client.class, CustomClient.class)
                    .withAddressSelector(new MockAddressSelector())
                    .withExceptionClassifier(customClientClassifier));

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

        DriftClient<Client> driftClient = injector.getInstance(DEFAULT_CLIENT_KEY);
        assertSame(injector.getInstance(DEFAULT_CLIENT_KEY), driftClient);
        Client client = driftClient.get(ADDRESS_SELECTION_CONTEXT, HEADERS);
        testClient(resultsSupplier,
                ImmutableList.of(invokerFactory.getMethodInvoker()),
                ImmutableList.of(globalClassifierOne, globalClassifierTwo, clientClassifier),
                statsFactory,
                client,
                Optional.empty());

        DriftClient<Client> customDriftClient = injector.getInstance(CUSTOM_CLIENT_KEY);
        assertSame(injector.getInstance(CUSTOM_CLIENT_KEY), customDriftClient);
        assertNotSame(driftClient, customDriftClient);
        Client customClient = customDriftClient.get(ADDRESS_SELECTION_CONTEXT, HEADERS);
        testClient(resultsSupplier,
                ImmutableList.of(invokerFactory.getMethodInvoker()),
                ImmutableList.of(globalClassifierOne, globalClassifierTwo, customClientClassifier),
                statsFactory,
                customClient,
                Optional.of(CustomClient.class.getSimpleName()));
    }
    catch (Exception e) {
        throw new RuntimeException(e);
    }
    finally {
        if (lifeCycleManager != null) {
            try {
                lifeCycleManager.stop();
            }
            catch (Exception ignored) {
            }
        }
    }
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Test
public void testGuiceClientFilter()
        throws Exception
{
    TestingMethodInvocationStatsFactory statsFactory = new TestingMethodInvocationStatsFactory();
    ResultsSupplier resultsSupplier = new ResultsSupplier();
    PassThroughFilter passThroughFilter = new PassThroughFilter();
    ShortCircuitFilter shortCircuitFilter = new ShortCircuitFilter(resultsSupplier);
    MockMethodInvokerFactory<Annotation> invokerFactory = new MockMethodInvokerFactory<>(resultsSupplier);

    TestingExceptionClassifier globalClassifierOne = new TestingExceptionClassifier();
    TestingExceptionClassifier globalClassifierTwo = new TestingExceptionClassifier();
    TestingExceptionClassifier clientClassifier = new TestingExceptionClassifier();
    TestingExceptionClassifier customClientClassifier = new TestingExceptionClassifier();
    Bootstrap app = new Bootstrap(
            new ThriftCodecModule(),
            binder -> newSetBinder(binder, ExceptionClassifier.class).addBinding()
                    .toInstance(globalClassifierOne),
            binder -> newSetBinder(binder, ExceptionClassifier.class).addBinding()
                    .toInstance(globalClassifierTwo),
            binder -> binder.bind(new TypeLiteral<MethodInvokerFactory<Annotation>>() {})
                    .toInstance(invokerFactory),
            binder -> newOptionalBinder(binder, MethodInvocationStatsFactory.class)
                    .setBinding()
                    .toInstance(statsFactory),
            binder -> driftClientBinder(binder)
                    .bindDriftClient(Client.class)
                    .withAddressSelector(new MockAddressSelector())
                    .withMethodInvocationFilter(staticFilterBinder(passThroughFilter, shortCircuitFilter))
                    .withExceptionClassifier(clientClassifier),
            binder -> driftClientBinder(binder)
                    .bindDriftClient(Client.class, CustomClient.class)
                    .withAddressSelector(new MockAddressSelector())
                    .withMethodInvocationFilter(staticFilterBinder(passThroughFilter, shortCircuitFilter))
                    .withExceptionClassifier(customClientClassifier));

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

        DriftClient<Client> driftClient = injector.getInstance(DEFAULT_CLIENT_KEY);
        assertSame(injector.getInstance(DEFAULT_CLIENT_KEY), driftClient);
        Client client = driftClient.get(ADDRESS_SELECTION_CONTEXT, HEADERS);
        testClient(resultsSupplier,
                ImmutableList.of(passThroughFilter, shortCircuitFilter),
                ImmutableList.of(globalClassifierOne, globalClassifierTwo, clientClassifier),
                statsFactory,
                client,
                Optional.empty());

        DriftClient<Client> customDriftClient = injector.getInstance(CUSTOM_CLIENT_KEY);
        assertSame(injector.getInstance(CUSTOM_CLIENT_KEY), customDriftClient);
        assertNotSame(driftClient, customDriftClient);
        Client customClient = customDriftClient.get(ADDRESS_SELECTION_CONTEXT, HEADERS);
        testClient(resultsSupplier,
                ImmutableList.of(passThroughFilter, shortCircuitFilter),
                ImmutableList.of(globalClassifierOne, globalClassifierTwo, customClientClassifier),
                statsFactory,
                customClient,
                Optional.of(CustomClient.class.getSimpleName()));
    }
    catch (Exception e) {
        throw new RuntimeException(e);
    }
    finally {
        if (lifeCycleManager != null) {
            try {
                lifeCycleManager.stop();
            }
            catch (Exception ignored) {
            }
        }
    }
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
public int run(String[] args)
        throws Exception
{
    if (args.length > 0) {
        System.setProperty("config", args[0]);
    }

    ImmutableList.Builder<Module> builder = ImmutableList.<Module>builder()
            .add(new PrestoVerifierModule())
            .addAll(getAdditionalModules());

    Bootstrap app = new Bootstrap(builder.build());
    Injector injector = app.strictConfig().initialize();

    try {
        VerifierConfig config = injector.getInstance(VerifierConfig.class);
        injector.injectMembers(this);
        Set<String> supportedEventClients = injector.getInstance(Key.get(new TypeLiteral<Set<String>>() {}, Names.named(SUPPORTED_EVENT_CLIENTS)));
        for (String clientType : config.getEventClients()) {
            checkArgument(supportedEventClients.contains(clientType), "Unsupported event client: %s", clientType);
        }
        Set<EventClient> eventClients = injector.getInstance(Key.get(new TypeLiteral<Set<EventClient>>() {}));

        VerifierDao dao = new DBI(config.getQueryDatabase()).onDemand(VerifierDao.class);

        ImmutableList.Builder<QueryPair> queriesBuilder = ImmutableList.builder();
        for (String suite : config.getSuites()) {
            queriesBuilder.addAll(dao.getQueriesBySuite(suite, config.getMaxQueries()));
        }

        List<QueryPair> queries = queriesBuilder.build();
        queries = applyOverrides(config, queries);
        queries = filterQueries(queries);

        // Load jdbc drivers if needed
        if (config.getAdditionalJdbcDriverPath() != null) {
            List<URL> urlList = getUrls(config.getAdditionalJdbcDriverPath());
            URL[] urls = new URL[urlList.size()];
            urlList.toArray(urls);
            if (config.getTestJdbcDriverName() != null) {
                loadJdbcDriver(urls, config.getTestJdbcDriverName());
            }
            if (config.getControlJdbcDriverName() != null) {
                loadJdbcDriver(urls, config.getControlJdbcDriverName());
            }
        }

        // TODO: construct this with Guice
        Verifier verifier = new Verifier(System.out, config, eventClients);
        return verifier.run(queries);
    }
    finally {
        injector.getInstance(LifeCycleManager.class).stop();
    }
}
 

import io.airlift.bootstrap.LifeCycleManager; //导入依赖的package包/类
@Override
public Connector create(String connectorId, Map<String, String> config)
{
    requireNonNull(config, "config is null");

    try (ThreadContextClassLoader ignored = new ThreadContextClassLoader(classLoader)) {
        Bootstrap app = new Bootstrap(
                new NodeModule(),
                new MBeanModule(),
                new JsonModule(),
                new HiveClientModule(connectorId, metastore, typeManager, pageIndexerFactory),
                installModuleIf(
                        SecurityConfig.class,
                        security -> ALLOW_ALL_ACCESS_CONTROL.equalsIgnoreCase(security.getSecuritySystem()),
                        new NoSecurityModule()),
                installModuleIf(
                        SecurityConfig.class,
                        security -> "read-only".equalsIgnoreCase(security.getSecuritySystem()),
                        new ReadOnlySecurityModule()),
                installModuleIf(
                        SecurityConfig.class,
                        security -> "sql-standard".equalsIgnoreCase(security.getSecuritySystem()),
                        new SqlStandardSecurityModule()),
                binder -> {
                    MBeanServer platformMBeanServer = ManagementFactory.getPlatformMBeanServer();
                    binder.bind(MBeanServer.class).toInstance(new RebindSafeMBeanServer(platformMBeanServer));
                }
        );

        Injector injector = app
                .strictConfig()
                .doNotInitializeLogging()
                .setRequiredConfigurationProperties(config)
                .setOptionalConfigurationProperties(optionalConfig)
                .initialize();

        LifeCycleManager lifeCycleManager = injector.getInstance(LifeCycleManager.class);
        ConnectorMetadata metadata = injector.getInstance(ConnectorMetadata.class);
        ConnectorSplitManager splitManager = injector.getInstance(ConnectorSplitManager.class);
        ConnectorPageSourceProvider connectorPageSource = injector.getInstance(ConnectorPageSourceProvider.class);
        ConnectorPageSinkProvider pageSinkProvider = injector.getInstance(ConnectorPageSinkProvider.class);
        HiveSessionProperties hiveSessionProperties = injector.getInstance(HiveSessionProperties.class);
        HiveTableProperties hiveTableProperties = injector.getInstance(HiveTableProperties.class);
        ConnectorAccessControl accessControl = injector.getInstance(ConnectorAccessControl.class);

        return new HiveConnector(
                lifeCycleManager,
                new ClassLoaderSafeConnectorMetadata(metadata, classLoader),
                new ClassLoaderSafeConnectorSplitManager(splitManager, classLoader),
                new ClassLoaderSafeConnectorPageSourceProvider(connectorPageSource, classLoader),
                new ClassLoaderSafeConnectorPageSinkProvider(pageSinkProvider, classLoader),
                ImmutableSet.of(),
                hiveSessionProperties.getSessionProperties(),
                hiveTableProperties.getTableProperties(),
                accessControl);
    }
    catch (Exception e) {
        throw Throwables.propagate(e);
    }
}