com.facebook.presto.spi.connector.ConnectorFactory Java Examples

@Test
public ConnectorFactory testConnectorExists()
{
    KinesisPlugin plugin = TestUtils.createPluginInstance();

    // Create factory manually to double check everything is done right
    Iterable<ConnectorFactory> iter = plugin.getConnectorFactories();

    List<ConnectorFactory> factories = new ArrayList<>();
    for (ConnectorFactory cf : iter) {
        factories.add(cf);
    }
    assertNotNull(factories);
    assertEquals(factories.size(), 1);
    ConnectorFactory factory = factories.get(0);
    assertNotNull(factory);
    return factory;
}
 

/**
 * Build a connector instance from the plug in, supplying the given properties.
 *
 * This can build a connector with the mock client which is normally done in testing.
 * The plug in is created first with createPluginInstance.
 *
 * @param plugin
 * @param properties
 * @param withMockClient
 * @return
 */
public static KinesisConnector createConnector(KinesisPlugin plugin, Map<String, String> properties, boolean withMockClient)
{
    requireNonNull(plugin, "Plugin instance should not be null");
    requireNonNull(properties, "Properties map should not be null (can be empty)");

    if (withMockClient) {
        plugin.setAltProviderClass(KinesisTestClientManager.class);
    }

    ConnectorFactory factory = plugin.getConnectorFactories().iterator().next();
    assertNotNull(factory);

    Connector connector = factory.create("kinesis", properties, new TestingConnectorContext() {});
    assertTrue(connector instanceof KinesisConnector);
    return (KinesisConnector) connector;
}
 

@Test
public void testCreateConnector()
        throws Exception {
    Plugin plugin = new KuduPlugin();
    ConnectorFactory factory = getOnlyElement(plugin.getConnectorFactories());
    factory.create("test", ImmutableMap.of("kudu.client.master-addresses", "localhost:8050"), new TestingConnectorContext());
}
 

@Override
public synchronized Iterable<ConnectorFactory> getConnectorFactories()
{
    if(factory == null) {
        this.factory = new KinesisConnectorFactory(getClassLoader(), tableDescriptionSupplier, optionalConfig, altProviderClass);
    }
    return ImmutableList.of(this.factory);
}
 

@Parameters({
        "kinesis.awsAccessKey",
        "kinesis.awsSecretKey"
})
@Test
public void testSpinUp(String awsAccessKey, String awsSecretKey)
{
    ConnectorFactory factory = testConnectorExists();
    // Important: this has to be created before we setup the injector in the factory:
    assertNotNull(factory.getHandleResolver());

    Connector c = factory.create("kinesis.test-connector", ImmutableMap.<String, String>builder()
            .put("kinesis.hide-internal-columns", "false")
            .put("kinesis.access-key", TestUtils.noneToBlank(awsAccessKey))
            .put("kinesis.secret-key", TestUtils.noneToBlank(awsSecretKey))
            .build(), new TestingConnectorContext() {});
    assertNotNull(c);

    // Verify that the key objects have been created on the connector
    assertNotNull(c.getRecordSetProvider());
    assertNotNull(c.getSplitManager());
    ConnectorMetadata md = c.getMetadata(KinesisTransactionHandle.INSTANCE);
    assertNotNull(md);

    ConnectorTransactionHandle handle = c.beginTransaction(READ_COMMITTED, true);
    assertTrue(handle != null && handle instanceof KinesisTransactionHandle);
}
 

@Override
public Iterable<ConnectorFactory> getConnectorFactories()
{
    return ImmutableList.of(new KubeConnectorFactory());
}
 

@Override
public Iterable<ConnectorFactory> getConnectorFactories()
{
    return ImmutableList.of(new ElasticsearchConnectorFactory(name, module, getClassLoader()));
}
 

@Override
public Iterable<ConnectorFactory> getConnectorFactories()
{
    return ImmutableList.of(new HbaseConnectorFactory("hbase"));
}
 

@Override
public Iterable<ConnectorFactory> getConnectorFactories()
{
    return ImmutableList.of(new ParaflowConnectorFactory());
}
 

@Override
public Iterable<ConnectorFactory> getConnectorFactories() {
    return ImmutableList.of(new EthereumConnectorFactory());
}
 

@Override public Iterable<ConnectorFactory> getConnectorFactories() {
  return ImmutableList.of(new KuduConnectorFactory("kudu"));
}