Java TransportClient.addTransportAddress方法代码示例

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
private TransportClient createClient() {
    Config cfg = getTypeCfg();
    Settings settings = Settings.builder().put("cluster.name", cfg.getString("elastic.cluster-name")).build();
    TransportClient client = new PreBuiltTransportClient(settings);

    List<String> servers = cfg.getStringList("elastic.servers");
    logger.debug(marker, "Elastic Servers: {}", servers);
    for (String addr : servers) {
        try {
            String[] a = addr.split(":");
            String host = a[0];
            int port = Integer.parseInt(a[1]);
            client.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(host), port));
        } catch (Exception e) {
            logger.error(marker, "Transport client creation failed for '{}'", addr, e);
        }
    }

    return client;
}
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
/**
 * create a elasticsearch transport client (remote elasticsearch)
 * @param addresses an array of host:port addresses
 * @param clusterName
 */
public ElasticsearchClient(final String[] addresses, final String clusterName) {
    // create default settings and add cluster name
    Settings.Builder settings = Settings.builder()
            .put("cluster.routing.allocation.enable", "all")
            .put("cluster.routing.allocation.allow_rebalance", "always");
    if (clusterName != null) settings.put("cluster.name", clusterName);
    
    // create a client
    TransportClient tc = new PreBuiltTransportClient(settings.build());

    for (String address: addresses) {
        String a = address.trim();
        int p = a.indexOf(':');
        if (p >= 0) try {
            InetAddress i = InetAddress.getByName(a.substring(0, p));
            int port = Integer.parseInt(a.substring(p + 1));
            tc.addTransportAddress(new InetSocketTransportAddress(i, port));
        } catch (UnknownHostException e) {
            Data.logger.warn("", e);
        }
    }
    this.elasticsearchClient = tc;
}
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
public ElasticSearchConnection(String jdbcUrl) {


        Settings settings = Settings.builder().put("client.transport.ignore_cluster_name", true).build();
        try {
            TransportClient transportClient = new PreBuiltTransportClient(settings);

            String hostAndPortArrayStr = jdbcUrl.split("/")[2];
            String[] hostAndPortArray = hostAndPortArrayStr.split(",");

            for (String hostAndPort : hostAndPortArray) {
                String host = hostAndPort.split(":")[0];
                String port = hostAndPort.split(":")[1];
                transportClient.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(host), Integer.parseInt(port)));
            }
            client = transportClient;
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
private static TransportClient createTransportClient(ElasticsearchSearchIndexConfiguration config) {
    Settings settings = tryReadSettingsFromFile(config);
    if (settings == null) {
        Settings.Builder settingsBuilder = Settings.builder();
        if (config.getClusterName() != null) {
            settingsBuilder.put("cluster.name", config.getClusterName());
        }
        for (Map.Entry<String, String> esSetting : config.getEsSettings().entrySet()) {
            settingsBuilder.put(esSetting.getKey(), esSetting.getValue());
        }
        settings = settingsBuilder.build();
    }
    TransportClient transportClient = new PreBuiltTransportClient(settings);
    for (String esLocation : config.getEsLocations()) {
        String[] locationSocket = esLocation.split(":");
        String hostname;
        int port;
        if (locationSocket.length == 2) {
            hostname = locationSocket[0];
            port = Integer.parseInt(locationSocket[1]);
        } else if (locationSocket.length == 1) {
            hostname = locationSocket[0];
            port = config.getPort();
        } else {
            throw new MemgraphException("Invalid elastic search location: " + esLocation);
        }
        InetAddress host;
        try {
            host = InetAddress.getByName(hostname);
        } catch (UnknownHostException ex) {
            throw new MemgraphException("Could not resolve host: " + hostname, ex);
        }
        transportClient.addTransportAddress(new InetSocketTransportAddress(host, port));
    }
    return transportClient;
}
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
@Bean
public TransportClient initESClient() throws NumberFormatException, UnknownHostException{
	String ip = env.getProperty("spring.es.ip");
	String port = env.getProperty("spring.es.port");
	String clusterName = env.getProperty("spring.es.cluster_name");
	
	Builder builder = Settings.builder().put("cluster.name", clusterName).put("client.transport.sniff", true);
	Settings esSettings = builder.build();
	TransportClient client = new PreBuiltTransportClient(esSettings);
	client.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(ip), Integer.parseInt(port)));
	logger.info("ES Client 初始化成功, ip : {}, port : {}, cluster_name : {}", ip, port, clusterName);
	return client;
}
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
/**
 * Open client to elaticsearch cluster
 * 
 * @param clusterName
 */
private void openClient(String clusterName) {
  logger.info("Using ElasticSearch hostnames: {} ",
      Arrays.toString(serverAddresses));
  Settings settings = Settings.builder().put("cluster.name", clusterName).build();;

  TransportClient transportClient = TransportClient.builder().settings(settings).build();
  for (InetSocketTransportAddress host : serverAddresses) {
    transportClient.addTransportAddress(host);
  }
  if (client != null) {
    client.close();
  }
  client = transportClient;
}
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
/**
 * Generates a TransportClient or NodeClient
 *
 * @param props a populated {@link java.util.Properties} object
 * @return a constructed {@link org.elasticsearch.client.Client}
 * @throws IOException if there is an error building the
 *                     {@link org.elasticsearch.client.Client}
 */
protected Client makeClient(Properties props) throws IOException {
  String clusterName = props.getProperty(MudrodConstants.ES_CLUSTER);
  String hostsString = props.getProperty(MudrodConstants.ES_UNICAST_HOSTS);
  String[] hosts = hostsString.split(",");
  String portStr = props.getProperty(MudrodConstants.ES_TRANSPORT_TCP_PORT);
  int port = Integer.parseInt(portStr);

  Settings.Builder settingsBuilder = Settings.builder();

  // Set the cluster name and build the settings
  if (!clusterName.isEmpty())
    settingsBuilder.put("cluster.name", clusterName);

  settingsBuilder.put("http.type", "netty3");
  settingsBuilder.put("transport.type", "netty3");

  Settings settings = settingsBuilder.build();

  Client client = null;

  // Prefer TransportClient
  if (hosts != null && port > 1) {
    TransportClient transportClient = new ESTransportClient(settings);
    for (String host : hosts)
      transportClient.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(host), port));
    client = transportClient;
  } else if (clusterName != null) {
    node = new Node(settings);
    client = node.client();
  }

  return client;
}
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
@Bean
public TransportClient transportClient(Settings settings) {
    TransportClient client = TransportClient.builder().settings(settings).build();
    for (String ip : this.esProperties.getIps().split(Constants.COMMA)) {
        try {
            client.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(ip), this.esProperties.getPort()));
        } catch (UnknownHostException e) {
            LOGGER.error("es集群主机名错误, ip: {}", ip);
        }
    }
    return client;
}
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
@Test
    public void clientIsCalledWhenBatchItemIsAdded() {

        // given
        Builder builder = createTestObjectFactoryBuilder();
        ClientObjectFactory<TransportClient, BulkRequest> config = spy(builder.build());

//        Settings settings = Settings.builder().put("node.local", "true").build();
        Settings settings = Settings.builder().build();
        TransportClient client = spy(new PreBuiltTransportClient(settings));
        client.addTransportAddress(new LocalTransportAddress("1"));
        when(config.createClient()).thenReturn(client);

        FailoverPolicy failoverPolicy = spy(new NoopFailoverPolicy());

        BulkProcessorFactory bulkProcessorFactory = new BulkProcessorFactory();
        BatchEmitter batchEmitter = bulkProcessorFactory.createInstance(
                        1,
                        100,
                        config,
                        failoverPolicy);

        String payload1 = "test1";
        ActionRequest testRequest = createTestRequest(payload1);

        // when
        batchEmitter.add(testRequest);

        // then
        ArgumentCaptor<BulkRequest> captor = ArgumentCaptor.forClass(BulkRequest.class);
        verify(client, times(1)).bulk(captor.capture(), Mockito.any());

        assertEquals(payload1, new BulkRequestIntrospector().items(captor.getValue()).iterator().next());
    }
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
@Test
    public void failoverIsExecutedAfterNonSuccessfulRequest() {

        // given
        Builder builder = createTestObjectFactoryBuilder();
        ClientObjectFactory<TransportClient, BulkRequest> config = spy(builder.build());

        FailoverPolicy failoverPolicy = spy(new NoopFailoverPolicy());
        Function handler = spy(config.createFailureHandler(failoverPolicy));
        when(config.createFailureHandler(any())).thenReturn(handler);

//        Settings settings = Settings.builder().put("node.local", "true").build();
        Settings settings = Settings.builder().build();
        TransportClient client = spy(new PreBuiltTransportClient(settings));
        client.addTransportAddress(new LocalTransportAddress("1"));
        when(config.createClient()).thenReturn(client);

        BulkProcessorFactory bulkProcessorFactory = new BulkProcessorFactory();
        BatchEmitter batchEmitter = bulkProcessorFactory.createInstance(
                1,
                100,
                config,
                failoverPolicy);

        String payload1 = "test1";
        ActionRequest testRequest = createTestRequest(payload1);

        // when
        batchEmitter.add(testRequest);

        // then
        ArgumentCaptor<BulkRequest> captor = ArgumentCaptor.forClass(BulkRequest.class);
        verify(handler, times(1)).apply(captor.capture());

        assertEquals(payload1, new BulkRequestIntrospector().items(captor.getValue()).iterator().next());
    }
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
@Test
public void clientIsCalledWhenBatchItemIsAdded() {

    // given
    Builder builder = createTestObjectFactoryBuilder();
    ClientObjectFactory<TransportClient, BulkRequest> config = spy(builder.build());

    Settings settings = Settings.builder()
            .put("node.local", true)
            .build();

    TransportClient client = spy(TransportClient.builder().settings(settings).build());
    client.addTransportAddress(new LocalTransportAddress("1"));
    when(config.createClient()).thenReturn(client);

    FailoverPolicy failoverPolicy = spy(new NoopFailoverPolicy());

    BulkProcessorFactory bulkProcessorFactory = new BulkProcessorFactory();
    BatchEmitter batchEmitter = bulkProcessorFactory.createInstance(
                    1,
                    100,
                    config,
                    failoverPolicy);

    String payload1 = "test1";
    ActionRequest testRequest = createTestRequest(payload1);

    // when
    batchEmitter.add(testRequest);

    // then
    ArgumentCaptor<BulkRequest> captor = ArgumentCaptor.forClass(BulkRequest.class);
    verify(client, times(1)).bulk(captor.capture(), Mockito.any());

    assertEquals(payload1, new BulkRequestIntrospector().items(captor.getValue()).iterator().next());
}
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
@Test
public void failoverIsExecutedAfterNonSuccessfulRequest() {

    // given
    Builder builder = createTestObjectFactoryBuilder();
    ClientObjectFactory<TransportClient, BulkRequest> config = spy(builder.build());

    FailoverPolicy failoverPolicy = spy(new NoopFailoverPolicy());
    Function handler = spy(config.createFailureHandler(failoverPolicy));
    when(config.createFailureHandler(any())).thenReturn(handler);

    Settings settings = Settings.builder().put("node.local", "true").build();
    TransportClient client = spy(TransportClient.builder().settings(settings).build());
    client.addTransportAddress(new LocalTransportAddress("1"));
    when(config.createClient()).thenReturn(client);

    BulkProcessorFactory bulkProcessorFactory = new BulkProcessorFactory();
    BatchEmitter batchEmitter = bulkProcessorFactory.createInstance(
            1,
            100,
            config,
            failoverPolicy);

    String payload1 = "test1";
    ActionRequest testRequest = createTestRequest(payload1);

    // when
    batchEmitter.add(testRequest);

    // then
    ArgumentCaptor<BulkRequest> captor = ArgumentCaptor.forClass(BulkRequest.class);
    verify(handler, times(1)).apply(captor.capture());

    assertEquals(payload1, new BulkRequestIntrospector().items(captor.getValue()).iterator().next());
}
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
public static void main(String[] args) {

        TransportClient client = new PreBuiltTransportClient(Settings.EMPTY);

        client.addTransportAddress(new InetSocketTransportAddress(new InetSocketAddress("127.0.0.1", 9300)));

        IndexRequestBuilder irb = client.prepareIndex("uav_test_db", "uav_test_table");

        Map<String, Object> item = new HashMap<String, Object>();

        item.put("name", "zz");
        item.put("age", 1);

        irb.setSource(item);

        IndexResponse ir = irb.get();

        System.out.println(ir.status());

        client.close();
    }
 

import org.elasticsearch.client.transport.TransportClient; //导入方法依赖的package包/类
@Override
public void init() {
    this.writerSliceConfig = this.getPluginJobConf();
    this.esIndex = writerSliceConfig.getString(Key.INDEX);
    this.esType = writerSliceConfig.getString(Key.TYPE);
    int batchSize = writerSliceConfig.getInt(Key.BATCH_SIZE);
    if (batchSize > 0) {
        BATCH_SIZE = batchSize;
    }

    clusterName = writerSliceConfig.getString(Key.CLUSTER_NAME);
    String hostArray = writerSliceConfig.getString(Key.HOST);

    this.columnMeta = JSON.parseArray(writerSliceConfig.getString(Key.COLUMN));

    int port = writerSliceConfig.getInt(Key.PORT);
    try {

        String[] hosts = hostArray.split(",");

        if (null == hosts || hosts.length <= 0) {
            throw new UnknownHostException("host config error");
        }

        Settings settings = Settings.settingsBuilder().put("cluster.name", clusterName).build();

        TransportClient client = TransportClient.builder().settings(settings).build();

        for (int i = 0; i < hosts.length; i++) {
            String host = hosts[i];
            client.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(host), port));
        }

        this.client = client;


    } catch (UnknownHostException e) {
        logger.error("es host error", e);
        System.exit(1);
    }

}