org.agrona.CloseHelper Java Examples

public void close()
{
    CloseHelper.close(errorHandler, publisherPos);
    CloseHelper.close(errorHandler, publisherLimit);
    CloseHelper.close(errorHandler, senderPosition);
    CloseHelper.close(errorHandler, senderLimit);
    CloseHelper.close(errorHandler, senderBpe);
    CloseHelper.closeAll(errorHandler, spyPositions);

    for (int i = 0, size = untetheredSubscriptions.size(); i < size; i++)
    {
        final UntetheredSubscription untetheredSubscription = untetheredSubscriptions.get(i);
        if (UntetheredSubscription.State.RESTING == untetheredSubscription.state)
        {
            CloseHelper.close(errorHandler, untetheredSubscription.position);
        }
    }

    CloseHelper.close(errorHandler, rawLog);
}
 

private void connectClient()
{
    while (true)
    {
        try
        {
            CloseHelper.close(aeronCluster);
            aeronCluster = AeronCluster.connect();
            return;
        }
        catch (final TimeoutException ex)
        {
            System.out.println("warning: " + ex.getMessage());
        }
    }
}
 

@AfterEach
public void after()
{
    final ConsensusModule consensusModule = null == clusteredMediaDriver ?
        null : clusteredMediaDriver.consensusModule();

    CloseHelper.closeAll(aeronCluster, consensusModule, container, clusteredMediaDriver);

    if (null != clusteredMediaDriver)
    {
        clusteredMediaDriver.consensusModule().context().deleteDirectory();
        clusteredMediaDriver.archive().context().deleteDirectory();
        clusteredMediaDriver.mediaDriver().context().deleteDirectory();
        container.context().deleteDirectory();
    }
}
 

void resetState()
{
    if (configuration.logAnyMessages())
    {
        createArchiver();
        try
        {
            truncateArchive();
            backupState();
        }
        finally
        {
            CloseHelper.close(archive);
            CloseHelper.close(aeron);
        }
    }
}
 

/**
 * Stop the server
 * @throws Exception
 */
@Override
public void close() throws Exception {
    if (subscriber != null) {
        for (int i = 0; i < subscriber.length; i++) {
            if (subscriber[i] != null) {
                subscriber[i].close();
            }
        }
    }
    if (server != null)
        server.stop();
    if (mediaDriver != null)
        CloseHelper.quietClose(mediaDriver);
    if (aeron != null)
        CloseHelper.quietClose(aeron);

}
 

/**
 * Launch a new {@link ArchivingMediaDriver} with provided contexts.
 *
 * @param driverCtx  for configuring the {@link MediaDriver}.
 * @param archiveCtx for configuring the {@link Archive}.
 * @return a new {@link ArchivingMediaDriver} with the provided contexts.
 */
public static ArchivingMediaDriver launch(final MediaDriver.Context driverCtx, final Archive.Context archiveCtx)
{
    MediaDriver driver = null;
    Archive archive = null;
    try
    {
        driver = MediaDriver.launch(driverCtx);

        final int errorCounterId = SystemCounterDescriptor.ERRORS.id();
        final AtomicCounter errorCounter = null == archiveCtx.errorCounter() ?
            new AtomicCounter(driverCtx.countersValuesBuffer(), errorCounterId) : archiveCtx.errorCounter();

        final ErrorHandler errorHandler = null == archiveCtx.errorHandler() ?
            driverCtx.errorHandler() : archiveCtx.errorHandler();

        archive = Archive.launch(archiveCtx
            .mediaDriverAgentInvoker(driver.sharedAgentInvoker())
            .aeronDirectoryName(driverCtx.aeronDirectoryName())
            .errorHandler(errorHandler)
            .errorCounter(errorCounter));

        return new ArchivingMediaDriver(driver, archive);
    }
    catch (final Exception ex)
    {
        CloseHelper.quietCloseAll(archive, driver);
        throw ex;
    }
}
 

public void migrate(
    final PrintStream stream,
    final ArchiveMarkFile markFile,
    final Catalog catalog,
    final File archiveDir)
{
    final FileChannel migrationTimestampFile = MigrationUtils.createMigrationTimestampFile(
        archiveDir, markFile.decoder().version(), minimumVersion());

    catalog.forEach(
        (headerEncoder, headerDecoder, encoder, decoder) ->
        {
            final String version1Prefix = decoder.recordingId() + "-";
            final String version1Suffix = ".rec";
            String[] segmentFiles = archiveDir.list(
                (dir, filename) -> filename.startsWith(version1Prefix) && filename.endsWith(version1Suffix));

            if (null == segmentFiles)
            {
                segmentFiles = ArrayUtil.EMPTY_STRING_ARRAY;
            }

            migrateRecording(
                stream,
                archiveDir,
                segmentFiles,
                version1Prefix,
                version1Suffix,
                headerEncoder,
                headerDecoder,
                encoder,
                decoder);
        });

    markFile.encoder().version(minimumVersion());
    catalog.updateVersion(minimumVersion());

    CloseHelper.close(migrationTimestampFile);
}
 

protected void closeSessionWorkers()
{
    CloseHelper.close(errorHandler, recorderAgentRunner);
    CloseHelper.close(errorHandler, replayerAgentRunner);

    while (processCloseQueue() > 0 || !closeQueue.isEmpty())
    {
        Thread.yield();
        if (Thread.currentThread().isInterrupted())
        {
            break;
        }
    }
}
 

/**
 * Add a {@link Publication} and set it up to be recorded. If this is not the first,
 * i.e. {@link Publication#isOriginal()} is true, then an {@link ArchiveException}
 * will be thrown and the recording not initiated.
 * <p>
 * This is a sessionId specific recording.
 *
 * @param channel  for the publication.
 * @param streamId for the publication.
 * @return the {@link Publication} ready for use.
 */
public Publication addRecordedPublication(final String channel, final int streamId)
{
    Publication publication = null;
    lock.lock();
    try
    {
        ensureOpen();
        ensureNotReentrant();

        publication = aeron.addPublication(channel, streamId);
        if (!publication.isOriginal())
        {
            throw new ArchiveException(
                "publication already added for channel=" + channel + " streamId=" + streamId);
        }

        startRecording(ChannelUri.addSessionId(channel, publication.sessionId()), streamId, SourceLocation.LOCAL);
    }
    catch (final RuntimeException ex)
    {
        CloseHelper.quietClose(publication);
        throw ex;
    }
    finally
    {
        lock.unlock();
    }

    return publication;
}
 

/**
 * Begin an attempt at creating a connection which can be completed by calling {@link AsyncConnect#poll()} until
 * it returns the client, before complete it will return null.
 *
 * @param ctx for the archive connection.
 * @return the {@link AsyncConnect} that can be polled for completion.
 */
public static AsyncConnect asyncConnect(final Context ctx)
{
    Subscription subscription = null;
    Publication publication = null;
    try
    {
        ctx.conclude();

        final Aeron aeron = ctx.aeron();
        final long messageTimeoutNs = ctx.messageTimeoutNs();
        final long deadlineNs = aeron.context().nanoClock().nanoTime() + messageTimeoutNs;

        subscription = aeron.addSubscription(ctx.controlResponseChannel(), ctx.controlResponseStreamId());
        final ControlResponsePoller controlResponsePoller = new ControlResponsePoller(subscription);

        publication = aeron.addExclusivePublication(ctx.controlRequestChannel(), ctx.controlRequestStreamId());
        final ArchiveProxy archiveProxy = new ArchiveProxy(
            publication,
            ctx.idleStrategy(),
            aeron.context().nanoClock(),
            messageTimeoutNs,
            DEFAULT_RETRY_ATTEMPTS,
            ctx.credentialsSupplier());

        return new AsyncConnect(ctx, controlResponsePoller, archiveProxy, deadlineNs);
    }
    catch (final Exception ex)
    {
        if (!ctx.ownsAeronClient())
        {
            CloseHelper.quietClose(subscription);
            CloseHelper.quietClose(publication);
        }

        ctx.close();

        throw ex;
    }
}
 

/**
 * Close transport, canceling any pending read operations and closing channel.
 */
public void close()
{
    if (!isClosed)
    {
        isClosed = true;
        if (null != selectionKey)
        {
            selectionKey.cancel();
        }

        if (null != transportPoller)
        {
            transportPoller.cancelRead(this);
            transportPoller.selectNowWithoutProcessing();
        }

        CloseHelper.close(errorHandler, sendDatagramChannel);

        if (receiveDatagramChannel != sendDatagramChannel && null != receiveDatagramChannel)
        {
            CloseHelper.close(errorHandler, receiveDatagramChannel);
        }

        if (null != transportPoller)
        {
            transportPoller.selectNowWithoutProcessing();
        }
    }
}
 

public void onClose()
{
    if (!ctx.ownsAeronClient())
    {
        CloseHelper.closeAll(consensusSubscription, consensusPublication);
    }

    if (NULL_VALUE != liveLogReplaySubscriptionId)
    {
        backupArchive.tryStopRecording(liveLogReplaySubscriptionId);
    }

    CloseHelper.closeAll(backupArchive, clusterArchiveAsyncConnect, clusterArchive, recordingLog);
    ctx.close();
}
 

protected void postSessionsClose()
{
    if (isAbort)
    {
        ctx.abortLatch().countDown();
    }
    else
    {
        aeron.removeCloseHandler(aeronCloseHandler);

        if (!ctx.ownsAeronClient())
        {
            aeron.removeUnavailableCounterHandler(this);

            for (final Subscription subscription : recordingSubscriptionMap.values())
            {
                subscription.close();
            }

            CloseHelper.close(localControlSubscription);
            CloseHelper.close(controlSubscription);
            CloseHelper.close(recordingEventsProxy);
        }
    }

    ctx.close();
}
 

@AfterEach
public void after()
{
    CloseHelper.closeAll(publishingClient, subscribingClient, driver);
    if (null != driver)
    {
        driver.context().deleteDirectory();
    }
}
 

AeronCluster connectClient()
{
    final String aeronDirName = CommonContext.getAeronDirectoryName();

    if (null == clientMediaDriver)
    {
        dataCollector.add(Paths.get(aeronDirName));

        clientMediaDriver = MediaDriver.launch(
            new MediaDriver.Context()
                .threadingMode(ThreadingMode.SHARED)
                .dirDeleteOnStart(true)
                .dirDeleteOnShutdown(false)
                .aeronDirectoryName(aeronDirName));
    }

    CloseHelper.close(client);
    client = AeronCluster.connect(
        new AeronCluster.Context()
            .aeronDirectoryName(aeronDirName)
            .egressListener(egressMessageListener)
            .ingressChannel("aeron:udp?term-length=64k")
            .egressChannel(CLUSTER_EGRESS_CHANNEL)
            .ingressEndpoints(staticClusterMemberEndpoints));

    return client;
}
 

public void close()
{
    try
    {
        logFile.force(true);
    }
    catch (final IOException ex)
    {
        errorHandler.onError(ex);
    }

    CloseHelper.close(logFile);
}
 

public void shutdown() throws InterruptedException {
  CloseHelper.quietClose(subscription);
  CloseHelper.quietClose(publication);
  CloseHelper.quietClose(aeron);
  CloseHelper.quietClose(ctx);
  CloseHelper.quietClose(driver);
}
 

@AfterEach
public void after()
{
    CloseHelper.closeAll(clusteredMediaDriver.consensusModule(), container, clusteredMediaDriver);
    AgentTests.afterAgent();

    if (testDir != null && testDir.exists())
    {
        IoUtil.delete(testDir, false);
    }
}
 

private void stopRecording(final CountedErrorHandler countedErrorHandler)
{
    if (null != recordingSubscription)
    {
        conductor.removeRecordingSubscription(recordingSubscription.registrationId());
        CloseHelper.close(countedErrorHandler, recordingSubscription);
        recordingSubscription = null;
    }
}
 

public void migrate(
    final PrintStream stream,
    final ArchiveMarkFile markFile,
    final Catalog catalog,
    final File archiveDir)
{
    final FileChannel migrationTimestampFile = MigrationUtils.createMigrationTimestampFile(
        archiveDir, markFile.decoder().version(), minimumVersion());

    catalog.forEach(
        (headerEncoder, headerDecoder, encoder, decoder) ->
        {
            final String version0Prefix = decoder.recordingId() + "-";
            final String version0Suffix = ".rec";
            String[] segmentFiles = archiveDir.list(
                (dir, filename) -> filename.startsWith(version0Prefix) && filename.endsWith(version0Suffix));

            if (null == segmentFiles)
            {
                segmentFiles = ArrayUtil.EMPTY_STRING_ARRAY;
            }

            migrateRecording(
                stream,
                archiveDir,
                segmentFiles,
                version0Prefix,
                version0Suffix,
                headerEncoder,
                headerDecoder,
                encoder,
                decoder);
        });

    markFile.encoder().version(minimumVersion());
    catalog.updateVersion(minimumVersion());

    CloseHelper.close(migrationTimestampFile);
}
 

@AfterEach
public void after()
{
    IoUtil.unmap(mockLogBufferMapped.byteBuffer());
    CloseHelper.close(mockLogBufferChannel);
    IoUtil.delete(archiveDir, false);
    IoUtil.delete(termFile, false);
}
 

public void close()
{
    final CountedErrorHandler countedErrorHandler = ctx.countedErrorHandler();
    CloseHelper.close(countedErrorHandler, consensusPublication);
    CloseHelper.close(countedErrorHandler, leaderArchive);
    CloseHelper.close(countedErrorHandler, leaderArchiveAsyncConnect);
}
 

protected void shutdownSilent() {
    log.info("Shutting down Aeron infrastructure...");
    CloseHelper.quietClose(publicationForClients);
    CloseHelper.quietClose(publicationForShards);
    CloseHelper.quietClose(subscriptionForShards);
    CloseHelper.quietClose(subscriptionForClients);
    CloseHelper.quietClose(aeron);
    CloseHelper.quietClose(context);
    CloseHelper.quietClose(driver);
}
 

@AfterEach
public void after()
{
    final ConsensusModule consensusModule = null == clusteredMediaDriver ?
        null : clusteredMediaDriver.consensusModule();

    CloseHelper.closeAll(aeronCluster, consensusModule, container, clusteredMediaDriver);

    if (null != clusteredMediaDriver)
    {
        clusteredMediaDriver.consensusModule().context().deleteDirectory();
        clusteredMediaDriver.archive().context().deleteDirectory();
        clusteredMediaDriver.mediaDriver().context().deleteDirectory();
    }
}
 

@AfterEach
public void after()
{
    CloseHelper.closeAll(aeronArchive, aeron, archive, archivingMediaDriver);

    archive.context().deleteDirectory();
    archivingMediaDriver.context().deleteDirectory();
}
 

@AfterEach
public void after()
{
    if (received.get() != MIN_MESSAGES_PER_TERM * 6)
    {
        System.out.println(
            "received " + received.get() + ", sent " + messagesPublished +
            ", total " + (MIN_MESSAGES_PER_TERM * 6));
    }

    CloseHelper.closeAll(aeronArchive, aeron, archive, mediaDriver);

    archive.context().deleteDirectory();
    mediaDriver.context().deleteDirectory();
}
 

@Override
public void close() {
    if (subscriber != null)
        CloseHelper.quietClose(subscriber);
    if (responder != null)
        CloseHelper.quietClose(responder);
    if (scheduledExecutorService != null)
        scheduledExecutorService.shutdown();
}
 

@AfterEach
public void after()
{
    CloseHelper.closeAll(clients.values());
    CloseHelper.closeAll(drivers.values());

    for (final TestMediaDriver driver : drivers.values())
    {
        driver.context().deleteDirectory();
    }
}
 

@AfterEach
public void after()
{
    CloseHelper.closeAll(clusteredMediaDriver.consensusModule(), aeronCluster, container, clusteredMediaDriver);

    if (null != clusteredMediaDriver)
    {
        clusteredMediaDriver.consensusModule().context().deleteDirectory();
        clusteredMediaDriver.archive().context().deleteDirectory();
        clusteredMediaDriver.mediaDriver().context().deleteDirectory();
        container.context().deleteDirectory();
    }
}
 

public void close()
{
    if (!isClosed)
    {
        isClosed = true;
        CloseHelper.closeAll(clusteredMediaDriver.consensusModule(), container, clusteredMediaDriver);
    }
}