Examples with AlreadyClosedException org.apache.lucene.store.AlreadyClosedException used on opensource projects

Example 76 with AlreadyClosedException

use of org.apache.lucene.store.AlreadyClosedException in project crate by crate.

the class ReplicationOperationTests method testPrimaryFailureHandlingReplicaResponse.

@Test
public void testPrimaryFailureHandlingReplicaResponse() throws Exception {
    final String index = "test";
    final ShardId shardId = new ShardId(index, "_na_", 0);
    final Request request = new Request(shardId);
    final ClusterState state = stateWithActivePrimary(index, true, 1, 0);
    final IndexMetadata indexMetadata = state.getMetadata().index(index);
    final long primaryTerm = indexMetadata.primaryTerm(0);
    final ShardRouting primaryRouting = state.getRoutingTable().shardRoutingTable(shardId).primaryShard();
    final Set<String> inSyncAllocationIds = indexMetadata.inSyncAllocationIds(0);
    final IndexShardRoutingTable shardRoutingTable = state.routingTable().index(index).shard(shardId.id());
    final Set<String> trackedShards = shardRoutingTable.getAllAllocationIds();
    final ReplicationGroup initialReplicationGroup = new ReplicationGroup(shardRoutingTable, inSyncAllocationIds, trackedShards);
    final boolean fatal = randomBoolean();
    final AtomicBoolean primaryFailed = new AtomicBoolean();
    final ReplicationOperation.Primary<Request, Request, TestPrimary.Result> primary = new TestPrimary(primaryRouting, () -> initialReplicationGroup) {

        @Override
        public void failShard(String message, Exception exception) {
            primaryFailed.set(true);
        }

        @Override
        public void updateLocalCheckpointForShard(String allocationId, long checkpoint) {
            if (primaryRouting.allocationId().getId().equals(allocationId)) {
                super.updateLocalCheckpointForShard(allocationId, checkpoint);
            } else {
                if (fatal) {
                    throw new NullPointerException();
                } else {
                    throw new AlreadyClosedException("already closed");
                }
            }
        }
    };
    final PlainActionFuture<TestPrimary.Result> listener = new PlainActionFuture<>();
    final ReplicationOperation.Replicas<Request> replicas = new TestReplicaProxy(Collections.emptyMap());
    TestReplicationOperation operation = new TestReplicationOperation(request, primary, listener, replicas, primaryTerm);
    operation.execute();
    assertThat(primaryFailed.get(), equalTo(fatal));
    final ShardInfo shardInfo = listener.actionGet().getShardInfo();
    assertThat(shardInfo.getFailed(), equalTo(0));
    assertThat(shardInfo.getFailures(), arrayWithSize(0));
    assertThat(shardInfo.getSuccessful(), equalTo(1 + getExpectedReplicas(shardId, state, trackedShards).size()));
}

Example 77 with AlreadyClosedException

use of org.apache.lucene.store.AlreadyClosedException in project crate by crate.

the class PrimaryReplicaSyncerTests method testSyncerOnClosingShard.

public void testSyncerOnClosingShard() throws Exception {
    IndexShard shard = newStartedShard(true);
    AtomicBoolean syncActionCalled = new AtomicBoolean();
    PrimaryReplicaSyncer.SyncAction syncAction = (request, allocationId, primaryTerm, listener) -> {
        logger.info("Sending off {} operations", request.getOperations().length);
        syncActionCalled.set(true);
        threadPool.generic().execute(() -> listener.onResponse(new ReplicationResponse()));
    };
    PrimaryReplicaSyncer syncer = new PrimaryReplicaSyncer(syncAction);
    // every document is sent off separately
    syncer.setChunkSize(new ByteSizeValue(1));
    int numDocs = 10;
    for (int i = 0; i < numDocs; i++) {
        // Index doc but not advance local checkpoint.
        shard.applyIndexOperationOnPrimary(Versions.MATCH_ANY, VersionType.INTERNAL, new SourceToParse(shard.shardId().getIndexName(), Integer.toString(i), new BytesArray("{}"), XContentType.JSON), SequenceNumbers.UNASSIGNED_SEQ_NO, 0, -1L, false);
    }
    String allocationId = shard.routingEntry().allocationId().getId();
    shard.updateShardState(shard.routingEntry(), shard.getPendingPrimaryTerm(), null, 1000L, Collections.singleton(allocationId), new IndexShardRoutingTable.Builder(shard.shardId()).addShard(shard.routingEntry()).build());
    CountDownLatch syncCalledLatch = new CountDownLatch(1);
    PlainActionFuture<PrimaryReplicaSyncer.ResyncTask> fut = new PlainActionFuture<PrimaryReplicaSyncer.ResyncTask>() {

        @Override
        public void onFailure(Exception e) {
            try {
                super.onFailure(e);
            } finally {
                syncCalledLatch.countDown();
            }
        }

        @Override
        public void onResponse(PrimaryReplicaSyncer.ResyncTask result) {
            try {
                super.onResponse(result);
            } finally {
                syncCalledLatch.countDown();
            }
        }
    };
    threadPool.generic().execute(() -> {
        syncer.resync(shard, fut);
    });
    if (randomBoolean()) {
        syncCalledLatch.await();
    }
    closeShards(shard);
    try {
        fut.actionGet();
        assertTrue("Sync action was not called", syncActionCalled.get());
    } catch (AlreadyClosedException | IndexShardClosedException ignored) {
    // ignore
    }
}

Example 78 with AlreadyClosedException

use of org.apache.lucene.store.AlreadyClosedException in project crate by crate.

the class InternalEngineTests method testForceMergeAndClose.

@Test
public void testForceMergeAndClose() throws IOException, InterruptedException {
    int numIters = randomIntBetween(2, 10);
    for (int j = 0; j < numIters; j++) {
        try (Store store = createStore()) {
            final InternalEngine engine = createEngine(store, createTempDir());
            final CountDownLatch startGun = new CountDownLatch(1);
            final CountDownLatch indexed = new CountDownLatch(1);
            Thread thread = new Thread() {

                @Override
                public void run() {
                    try {
                        try {
                            startGun.await();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        int i = 0;
                        while (true) {
                            int numDocs = randomIntBetween(1, 20);
                            for (int j = 0; j < numDocs; j++) {
                                i++;
                                ParsedDocument doc = testParsedDocument(Integer.toString(i), null, testDocument(), B_1, null);
                                Engine.Index index = indexForDoc(doc);
                                engine.index(index);
                            }
                            engine.refresh("test");
                            indexed.countDown();
                            try {
                                engine.forceMerge(randomBoolean(), 1, false, randomBoolean(), randomBoolean(), UUIDs.randomBase64UUID());
                            } catch (IOException e) {
                                return;
                            }
                        }
                    } catch (AlreadyClosedException ex) {
                    // fine
                    } catch (IOException e) {
                        throw new AssertionError(e);
                    }
                }
            };
            thread.start();
            startGun.countDown();
            int someIters = randomIntBetween(1, 10);
            for (int i = 0; i < someIters; i++) {
                engine.forceMerge(randomBoolean(), 1, false, randomBoolean(), randomBoolean(), UUIDs.randomBase64UUID());
            }
            indexed.await();
            IOUtils.close(engine);
            thread.join();
        }
    }
}

Example 79 with AlreadyClosedException

use of org.apache.lucene.store.AlreadyClosedException in project crate by crate.

the class InternalEngineTests method testFailEngineOnRandomIO.

@Test
public void testFailEngineOnRandomIO() throws IOException, InterruptedException {
    MockDirectoryWrapper wrapper = newMockDirectory();
    final Path translogPath = createTempDir("testFailEngineOnRandomIO");
    try (Store store = createStore(wrapper)) {
        CyclicBarrier join = new CyclicBarrier(2);
        CountDownLatch start = new CountDownLatch(1);
        AtomicInteger controller = new AtomicInteger(0);
        EngineConfig config = config(defaultSettings, store, translogPath, newMergePolicy(), new ReferenceManager.RefreshListener() {

            @Override
            public void beforeRefresh() throws IOException {
            }

            @Override
            public void afterRefresh(boolean didRefresh) throws IOException {
                int i = controller.incrementAndGet();
                if (i == 1) {
                    throw new MockDirectoryWrapper.FakeIOException();
                } else if (i == 2) {
                    try {
                        start.await();
                    } catch (InterruptedException e) {
                        throw new AssertionError(e);
                    }
                    throw new ElasticsearchException("something completely different");
                }
            }
        });
        InternalEngine internalEngine = createEngine(config);
        int docId = 0;
        final ParsedDocument doc = testParsedDocument(Integer.toString(docId), null, testDocumentWithTextField(), new BytesArray("{}".getBytes(Charset.defaultCharset())), null);
        Engine.Index index = randomBoolean() ? indexForDoc(doc) : randomAppendOnly(doc, false, docId);
        internalEngine.index(index);
        Runnable r = () -> {
            try {
                join.await();
            } catch (Exception e) {
                throw new AssertionError(e);
            }
            try {
                internalEngine.refresh("test");
                fail();
            } catch (AlreadyClosedException ex) {
                if (ex.getCause() != null) {
                    assertTrue(ex.toString(), ex.getCause() instanceof MockDirectoryWrapper.FakeIOException);
                }
            } catch (RefreshFailedEngineException ex) {
            // fine
            } finally {
                start.countDown();
            }
        };
        Thread t = new Thread(r);
        Thread t1 = new Thread(r);
        t.start();
        t1.start();
        t.join();
        t1.join();
        assertTrue(internalEngine.isClosed.get());
        assertTrue(internalEngine.failedEngine.get() instanceof MockDirectoryWrapper.FakeIOException);
    }
}