Examples with NetworkService org.opensearch.common.network.NetworkService used on opensource projects

Example 16 with NetworkService

use of org.opensearch.common.network.NetworkService in project OpenSearch by opensearch-project.

the class Ec2NetworkTests method resolveEc2.

private InetAddress[] resolveEc2(String host, InetAddress... expected) throws IOException {
    Settings nodeSettings = Settings.builder().put("network.host", host).build();
    NetworkService networkService = new NetworkService(Collections.singletonList(new Ec2NameResolver()));
    InetAddress[] addresses = networkService.resolveBindHostAddresses(NetworkService.GLOBAL_NETWORK_BIND_HOST_SETTING.get(nodeSettings).toArray(Strings.EMPTY_ARRAY));
    if (expected == null) {
        fail("We should get an IOException, resolved addressed:" + Arrays.toString(addresses));
    }
    assertThat(addresses, arrayContaining(expected));
    return addresses;
}

Example 17 with NetworkService

use of org.opensearch.common.network.NetworkService in project OpenSearch by opensearch-project.

the class GceNetworkTests method resolveGce.

/**
 * Utility test method to test different settings
 * @param gceNetworkSetting tested network.host property
 * @param expected expected InetAddress, null if we expect an exception
 * @throws IOException Well... If something goes wrong :)
 */
private void resolveGce(String gceNetworkSetting, InetAddress[] expected) throws IOException {
    Settings nodeSettings = Settings.builder().put("network.host", gceNetworkSetting).build();
    GceMetadataServiceMock mock = new GceMetadataServiceMock(nodeSettings);
    NetworkService networkService = new NetworkService(Collections.singletonList(new GceNameResolver(mock)));
    try {
        InetAddress[] addresses = networkService.resolveBindHostAddresses(NetworkService.GLOBAL_NETWORK_BIND_HOST_SETTING.get(nodeSettings).toArray(Strings.EMPTY_ARRAY));
        if (expected == null) {
            fail("We should get a IllegalArgumentException when setting network.host: _gce:doesnotexist_");
        }
        assertThat(addresses, arrayContaining(expected));
    } catch (IllegalArgumentException e) {
        if (expected != null) {
            // We were expecting something and not an exception
            throw e;
        }
        // We check that we get the expected exception
        assertThat(e.getMessage(), containsString("is not one of the supported GCE network.host setting"));
    }
}

Example 18 with NetworkService

use of org.opensearch.common.network.NetworkService in project OpenSearch by opensearch-project.

the class NioHttpServerTransportTests method setup.

@Before
public void setup() throws Exception {
    networkService = new NetworkService(Collections.emptyList());
    threadPool = new TestThreadPool("test");
    pageRecycler = new MockPageCacheRecycler(Settings.EMPTY);
    bigArrays = new MockBigArrays(pageRecycler, new NoneCircuitBreakerService());
}

Example 19 with NetworkService

use of org.opensearch.common.network.NetworkService in project OpenSearch by opensearch-project.

the class TransportResyncReplicationActionTests method testResyncDoesNotBlockOnPrimaryAction.

public void testResyncDoesNotBlockOnPrimaryAction() throws Exception {
    try (ClusterService clusterService = createClusterService(threadPool)) {
        final String indexName = randomAlphaOfLength(5);
        setState(clusterService, state(indexName, true, ShardRoutingState.STARTED));
        setState(clusterService, ClusterState.builder(clusterService.state()).blocks(ClusterBlocks.builder().addGlobalBlock(NoMasterBlockService.NO_MASTER_BLOCK_ALL).addIndexBlock(indexName, IndexMetadata.INDEX_WRITE_BLOCK)));
        try (MockNioTransport transport = new MockNioTransport(Settings.EMPTY, Version.CURRENT, threadPool, new NetworkService(emptyList()), PageCacheRecycler.NON_RECYCLING_INSTANCE, new NamedWriteableRegistry(emptyList()), new NoneCircuitBreakerService())) {
            final MockTransportService transportService = new MockTransportService(Settings.EMPTY, transport, threadPool, NOOP_TRANSPORT_INTERCEPTOR, x -> clusterService.localNode(), null, Collections.emptySet());
            transportService.start();
            transportService.acceptIncomingRequests();
            final ShardStateAction shardStateAction = new ShardStateAction(clusterService, transportService, null, null, threadPool);
            final IndexMetadata indexMetadata = clusterService.state().metadata().index(indexName);
            final Index index = indexMetadata.getIndex();
            final ShardId shardId = new ShardId(index, 0);
            final IndexShardRoutingTable shardRoutingTable = clusterService.state().routingTable().shardRoutingTable(shardId);
            final ShardRouting primaryShardRouting = clusterService.state().routingTable().shardRoutingTable(shardId).primaryShard();
            final String allocationId = primaryShardRouting.allocationId().getId();
            final long primaryTerm = indexMetadata.primaryTerm(shardId.id());
            final AtomicInteger acquiredPermits = new AtomicInteger();
            final IndexShard indexShard = mock(IndexShard.class);
            when(indexShard.indexSettings()).thenReturn(new IndexSettings(indexMetadata, Settings.EMPTY));
            when(indexShard.shardId()).thenReturn(shardId);
            when(indexShard.routingEntry()).thenReturn(primaryShardRouting);
            when(indexShard.getPendingPrimaryTerm()).thenReturn(primaryTerm);
            when(indexShard.getOperationPrimaryTerm()).thenReturn(primaryTerm);
            when(indexShard.getActiveOperationsCount()).then(i -> acquiredPermits.get());
            doAnswer(invocation -> {
                ActionListener<Releasable> callback = (ActionListener<Releasable>) invocation.getArguments()[0];
                acquiredPermits.incrementAndGet();
                callback.onResponse(acquiredPermits::decrementAndGet);
                return null;
            }).when(indexShard).acquirePrimaryOperationPermit(any(ActionListener.class), anyString(), any(), eq(true));
            when(indexShard.getReplicationGroup()).thenReturn(new ReplicationGroup(shardRoutingTable, clusterService.state().metadata().index(index).inSyncAllocationIds(shardId.id()), shardRoutingTable.getAllAllocationIds(), 0));
            final IndexService indexService = mock(IndexService.class);
            when(indexService.getShard(eq(shardId.id()))).thenReturn(indexShard);
            final IndicesService indexServices = mock(IndicesService.class);
            when(indexServices.indexServiceSafe(eq(index))).thenReturn(indexService);
            final TransportResyncReplicationAction action = new TransportResyncReplicationAction(Settings.EMPTY, transportService, clusterService, indexServices, threadPool, shardStateAction, new ActionFilters(new HashSet<>()), new IndexingPressureService(Settings.EMPTY, clusterService), new SystemIndices(emptyMap()));
            assertThat(action.globalBlockLevel(), nullValue());
            assertThat(action.indexBlockLevel(), nullValue());
            final Task task = mock(Task.class);
            when(task.getId()).thenReturn(randomNonNegativeLong());
            final byte[] bytes = "{}".getBytes(Charset.forName("UTF-8"));
            final ResyncReplicationRequest request = new ResyncReplicationRequest(shardId, 42L, 100, new Translog.Operation[] { new Translog.Index("type", "id", 0, primaryTerm, 0L, bytes, null, -1) });
            final PlainActionFuture<ResyncReplicationResponse> listener = new PlainActionFuture<>();
            action.sync(request, task, allocationId, primaryTerm, listener);
            assertThat(listener.get().getShardInfo().getFailed(), equalTo(0));
            assertThat(listener.isDone(), is(true));
        }
    }
}

Example 20 with NetworkService

use of org.opensearch.common.network.NetworkService in project OpenSearch by opensearch-project.

the class TransportReplicationActionTests method testRetryOnReplicaWithRealTransport.

public void testRetryOnReplicaWithRealTransport() throws Exception {
    final ShardId shardId = new ShardId("test", "_na_", 0);
    final ClusterState initialState = state(shardId.getIndexName(), true, ShardRoutingState.STARTED, ShardRoutingState.STARTED);
    final ShardRouting replica = initialState.getRoutingTable().shardRoutingTable(shardId).replicaShards().get(0);
    final long primaryTerm = initialState.metadata().index(shardId.getIndexName()).primaryTerm(shardId.id());
    // simulate execution of the node holding the replica
    final ClusterState stateWithNodes = ClusterState.builder(initialState).nodes(DiscoveryNodes.builder(initialState.nodes()).localNodeId(replica.currentNodeId())).build();
    setState(clusterService, stateWithNodes);
    AtomicBoolean throwException = new AtomicBoolean(true);
    final ReplicationTask task = maybeTask();
    NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(Collections.emptyList());
    final Transport transport = new MockNioTransport(Settings.EMPTY, Version.CURRENT, threadPool, new NetworkService(Collections.emptyList()), PageCacheRecycler.NON_RECYCLING_INSTANCE, namedWriteableRegistry, new NoneCircuitBreakerService());
    transportService = new MockTransportService(Settings.EMPTY, transport, threadPool, TransportService.NOOP_TRANSPORT_INTERCEPTOR, x -> clusterService.localNode(), null, Collections.emptySet());
    transportService.start();
    transportService.acceptIncomingRequests();
    AtomicBoolean calledSuccessfully = new AtomicBoolean(false);
    TestAction action = new TestAction(Settings.EMPTY, "internal:testActionWithExceptions", transportService, clusterService, shardStateAction, threadPool) {

        @Override
        protected void shardOperationOnReplica(Request shardRequest, IndexShard replica, ActionListener<ReplicaResult> listener) {
            ActionListener.completeWith(listener, () -> {
                assertPhase(task, "replica");
                if (throwException.get()) {
                    throw new RetryOnReplicaException(shardId, "simulation");
                }
                calledSuccessfully.set(true);
                return new ReplicaResult();
            });
        }
    };
    final PlainActionFuture<TransportResponse> listener = new PlainActionFuture<>();
    final Request request = new Request(shardId);
    final long checkpoint = randomNonNegativeLong();
    final long maxSeqNoOfUpdates = randomNonNegativeLong();
    action.handleReplicaRequest(new TransportReplicationAction.ConcreteReplicaRequest<>(request, replica.allocationId().getId(), primaryTerm, checkpoint, maxSeqNoOfUpdates), createTransportChannel(listener), task);
    if (listener.isDone()) {
        // fail with the exception if there
        listener.get();
        fail("listener shouldn't be done");
    }
    // release the waiting
    throwException.set(false);
    // publish a new state (same as the old state with the version incremented)
    setState(clusterService, stateWithNodes);
    // Assert that the request was retried, this time successful
    assertTrue("action should have been successfully called on retry but was not", calledSuccessfully.get());
    transportService.stop();
}