Java ParameterizedMessage类代码示例

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
@Override
@SuppressForbidden(reason = "debug")
protected void stopInternal() {
    Releasables.close(serverOpenChannels, () -> {
        final List<Tuple<String, Future<?>>> serverBootstrapCloseFutures = new ArrayList<>(serverBootstraps.size());
        for (final Map.Entry<String, ServerBootstrap> entry : serverBootstraps.entrySet()) {
            serverBootstrapCloseFutures.add(
                Tuple.tuple(entry.getKey(), entry.getValue().config().group().shutdownGracefully(0, 5, TimeUnit.SECONDS)));
        }
        for (final Tuple<String, Future<?>> future : serverBootstrapCloseFutures) {
            future.v2().awaitUninterruptibly();
            if (!future.v2().isSuccess()) {
                logger.debug(
                    (Supplier<?>) () -> new ParameterizedMessage(
                        "Error closing server bootstrap for profile [{}]", future.v1()), future.v2().cause());
            }
        }
        serverBootstraps.clear();

        if (bootstrap != null) {
            bootstrap.config().group().shutdownGracefully(0, 5, TimeUnit.SECONDS).awaitUninterruptibly();
            bootstrap = null;
        }
    });
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
void onQueryPhaseFailure(final int shardIndex, final AtomicInteger counter, final long searchId, Exception failure) {
    if (logger.isDebugEnabled()) {
        logger.debug((Supplier<?>) () -> new ParameterizedMessage("[{}] Failed to execute query phase", searchId), failure);
    }
    addShardFailure(shardIndex, new ShardSearchFailure(failure));
    successfulOps.decrementAndGet();
    if (counter.decrementAndGet() == 0) {
        if (successfulOps.get() == 0) {
            listener.onFailure(new SearchPhaseExecutionException("query", "all shards failed", failure, buildShardFailures()));
        } else {
            try {
                executeFetchPhase();
            } catch (Exception e) {
                e.addSuppressed(failure);
                listener.onFailure(new SearchPhaseExecutionException("query", "Fetch failed", e, ShardSearchFailure.EMPTY_ARRAY));
            }
        }
    }
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
/**
 * Scans the hunspell directory and loads all found dictionaries
 */
private void scanAndLoadDictionaries() throws IOException {
    if (Files.isDirectory(hunspellDir)) {
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(hunspellDir)) {
            for (Path file : stream) {
                if (Files.isDirectory(file)) {
                    try (DirectoryStream<Path> inner = Files.newDirectoryStream(hunspellDir.resolve(file), "*.dic")) {
                        if (inner.iterator().hasNext()) { // just making sure it's indeed a dictionary dir
                            try {
                                getDictionary(file.getFileName().toString());
                            } catch (Exception e) {
                                // The cache loader throws unchecked exception (see #loadDictionary()),
                                // here we simply report the exception and continue loading the dictionaries
                                logger.error(
                                    (Supplier<?>) () -> new ParameterizedMessage(
                                        "exception while loading dictionary {}", file.getFileName()), e);
                            }
                        }
                    }
                }
            }
        }
    }
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
private void failAndRemoveShard(ShardRouting shardRouting, boolean sendShardFailure, String message, @Nullable Exception failure,
                                ClusterState state) {
    try {
        AllocatedIndex<? extends Shard> indexService = indicesService.indexService(shardRouting.shardId().getIndex());
        if (indexService != null) {
            indexService.removeShard(shardRouting.shardId().id(), message);
        }
    } catch (ShardNotFoundException e) {
        // the node got closed on us, ignore it
    } catch (Exception inner) {
        inner.addSuppressed(failure);
        logger.warn(
            (Supplier<?>) () -> new ParameterizedMessage(
                "[{}][{}] failed to remove shard after failure ([{}])",
                shardRouting.getIndexName(),
                shardRouting.getId(),
                message),
            inner);
    }
    if (sendShardFailure) {
        sendFailShard(shardRouting, message, failure, state);
    }
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
private void sendFailShard(ShardRouting shardRouting, String message, @Nullable Exception failure, ClusterState state) {
    try {
        logger.warn(
            (Supplier<?>) () -> new ParameterizedMessage(
                "[{}] marking and sending shard failed due to [{}]", shardRouting.shardId(), message), failure);
        failedShardsCache.put(shardRouting.shardId(), shardRouting);
        shardStateAction.localShardFailed(shardRouting, message, failure, SHARD_STATE_ACTION_LISTENER, state);
    } catch (Exception inner) {
        if (failure != null) inner.addSuppressed(failure);
        logger.warn(
            (Supplier<?>) () -> new ParameterizedMessage(
                "[{}][{}] failed to mark shard as failed (because of [{}])",
                shardRouting.getIndexName(),
                shardRouting.getId(),
                message),
            inner);
    }
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
/**
 * Deletes an index that is not assigned to this node. This method cleans up all disk folders relating to the index
 * but does not deal with in-memory structures. For those call {@link #removeIndex(Index, IndexRemovalReason, String)}
 */
@Override
public void deleteUnassignedIndex(String reason, IndexMetaData metaData, ClusterState clusterState) {
    if (nodeEnv.hasNodeFile()) {
        String indexName = metaData.getIndex().getName();
        try {
            if (clusterState.metaData().hasIndex(indexName)) {
                final IndexMetaData index = clusterState.metaData().index(indexName);
                throw new IllegalStateException("Can't delete unassigned index store for [" + indexName + "] - it's still part of " +
                                                "the cluster state [" + index.getIndexUUID() + "] [" + metaData.getIndexUUID() + "]");
            }
            deleteIndexStore(reason, metaData, clusterState);
        } catch (Exception e) {
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("[{}] failed to delete unassigned index (reason [{}])", metaData.getIndex(), reason), e);
        }
    }
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
protected void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    if (cause instanceof ReadTimeoutException) {
        if (logger.isTraceEnabled()) {
            logger.trace("Connection timeout [{}]", ctx.channel().remoteAddress());
        }
        ctx.channel().close();
    } else {
        if (!lifecycle.started()) {
            // ignore
            return;
        }
        if (!NetworkExceptionHelper.isCloseConnectionException(cause)) {
            logger.warn(
                (Supplier<?>) () -> new ParameterizedMessage(
                    "caught exception while handling client http traffic, closing connection {}", ctx.channel()),
                cause);
            ctx.channel().close();
        } else {
            logger.debug(
                (Supplier<?>) () -> new ParameterizedMessage(
                    "caught exception while handling client http traffic, closing connection {}", ctx.channel()),
                cause);
            ctx.channel().close();
        }
    }
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
@Override
protected void masterOperation(final CloseIndexRequest request, final ClusterState state, final ActionListener<CloseIndexResponse> listener) {
    final Index[] concreteIndices = indexNameExpressionResolver.concreteIndices(state, request);
    CloseIndexClusterStateUpdateRequest updateRequest = new CloseIndexClusterStateUpdateRequest()
            .ackTimeout(request.timeout()).masterNodeTimeout(request.masterNodeTimeout())
            .indices(concreteIndices);

    indexStateService.closeIndex(updateRequest, new ActionListener<ClusterStateUpdateResponse>() {

        @Override
        public void onResponse(ClusterStateUpdateResponse response) {
            listener.onResponse(new CloseIndexResponse(response.isAcknowledged()));
        }

        @Override
        public void onFailure(Exception t) {
            logger.debug((Supplier<?>) () -> new ParameterizedMessage("failed to close indices [{}]", (Object) concreteIndices), t);
            listener.onFailure(t);
        }
    });
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
@Override
public void onFailure(Exception e) {
    try (RecoveryRef recoveryRef = onGoingRecoveries.getRecovery(recoveryId)) {
        if (recoveryRef != null) {
            logger.error(
                (Supplier<?>) () -> new ParameterizedMessage(
                    "unexpected error during recovery [{}], failing shard", recoveryId), e);
            onGoingRecoveries.failRecovery(recoveryId,
                    new RecoveryFailedException(recoveryRef.target().state(), "unexpected error", e),
                    true // be safe
            );
        } else {
            logger.debug(
                (Supplier<?>) () -> new ParameterizedMessage(
                    "unexpected error during recovery, but recovery id [{}] is finished", recoveryId), e);
        }
    }
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
/**
 * Validates the given settings by running it through all update listeners without applying it. This
 * method will not change any settings but will fail if any of the settings can't be applied.
 */
public synchronized Settings validateUpdate(Settings settings) {
    final Settings current = Settings.builder().put(this.settings).put(settings).build();
    final Settings previous = Settings.builder().put(this.settings).put(this.lastSettingsApplied).build();
    List<RuntimeException> exceptions = new ArrayList<>();
    for (SettingUpdater<?> settingUpdater : settingUpdaters) {
        try {
            // ensure running this through the updater / dynamic validator
            // don't check if the value has changed we wanna test this anyways
            settingUpdater.getValue(current, previous);
        } catch (RuntimeException ex) {
            exceptions.add(ex);
            logger.debug((Supplier<?>) () -> new ParameterizedMessage("failed to prepareCommit settings for [{}]", settingUpdater), ex);
        }
    }
    // here we are exhaustive and record all settings that failed.
    ExceptionsHelper.rethrowAndSuppress(exceptions);
    return current;
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
void handleJoinRequest(final DiscoveryNode node, final ClusterState state, final MembershipAction.JoinCallback callback) {
    if (nodeJoinController == null) {
        throw new IllegalStateException("discovery module is not yet started");
    } else {
        // we do this in a couple of places including the cluster update thread. This one here is really just best effort
        // to ensure we fail as fast as possible.
        MembershipAction.ensureIndexCompatibility(node.getVersion().minimumIndexCompatibilityVersion(), state.getMetaData());
        // try and connect to the node, if it fails, we can raise an exception back to the client...
        transportService.connectToNode(node);

        // validate the join request, will throw a failure if it fails, which will get back to the
        // node calling the join request
        try {
            membership.sendValidateJoinRequestBlocking(node, state, joinTimeout);
        } catch (Exception e) {
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("failed to validate incoming join request from node [{}]", node), e);
            callback.onFailure(new IllegalStateException("failure when sending a validation request to node", e));
            return;
        }
        nodeJoinController.handleJoinRequest(node, callback);
    }
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
/**
 * Creates repository holder
 */
private Repository createRepository(RepositoryMetaData repositoryMetaData) {
    logger.debug("creating repository [{}][{}]", repositoryMetaData.type(), repositoryMetaData.name());
    Repository.Factory factory = typesRegistry.get(repositoryMetaData.type());
    if (factory == null) {
        throw new RepositoryException(repositoryMetaData.name(),
            "repository type [" + repositoryMetaData.type() + "] does not exist");
    }
    try {
        Repository repository = factory.create(repositoryMetaData);
        repository.start();
        return repository;
    } catch (Exception e) {
        logger.warn((Supplier<?>) () -> new ParameterizedMessage("failed to create repository [{}][{}]", repositoryMetaData.type(), repositoryMetaData.name()), e);
        throw new RepositoryException(repositoryMetaData.name(), "failed to create repository", e);
    }
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
@Override
protected void masterOperation(final DeleteIndexRequest request, final ClusterState state, final ActionListener<DeleteIndexResponse> listener) {
    final Set<Index> concreteIndices = new HashSet<>(Arrays.asList(indexNameExpressionResolver.concreteIndices(state, request)));
    if (concreteIndices.isEmpty()) {
        listener.onResponse(new DeleteIndexResponse(true));
        return;
    }

    DeleteIndexClusterStateUpdateRequest deleteRequest = new DeleteIndexClusterStateUpdateRequest()
        .ackTimeout(request.timeout()).masterNodeTimeout(request.masterNodeTimeout())
        .indices(concreteIndices.toArray(new Index[concreteIndices.size()]));

    deleteIndexService.deleteIndices(deleteRequest, new ActionListener<ClusterStateUpdateResponse>() {

        @Override
        public void onResponse(ClusterStateUpdateResponse response) {
            listener.onResponse(new DeleteIndexResponse(response.isAcknowledged()));
        }

        @Override
        public void onFailure(Exception t) {
            logger.debug((Supplier<?>) () -> new ParameterizedMessage("failed to delete indices [{}]", concreteIndices), t);
            listener.onFailure(t);
        }
    });
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
private void cleanupAfterError(Exception exception) {
    if(snapshotCreated) {
        try {
            repositoriesService.repository(snapshot.snapshot().getRepository())
                               .finalizeSnapshot(snapshot.snapshot().getSnapshotId(),
                                                 snapshot.indices(),
                                                 snapshot.startTime(),
                                                 ExceptionsHelper.detailedMessage(exception),
                                                 0,
                                                 Collections.emptyList(),
                                                 snapshot.getRepositoryStateId());
        } catch (Exception inner) {
            inner.addSuppressed(exception);
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("[{}] failed to close snapshot in repository", snapshot.snapshot()), inner);
        }
    }
    userCreateSnapshotListener.onFailure(e);
}
 

import org.apache.logging.log4j.message.ParameterizedMessage; //导入依赖的package包/类
private void onShardClose(ShardLock lock, boolean ownsShard) {
    if (deleted.get()) { // we remove that shards content if this index has been deleted
        try {
            if (ownsShard) {
                try {
                    eventListener.beforeIndexShardDeleted(lock.getShardId(), indexSettings.getSettings());
                } finally {
                    shardStoreDeleter.deleteShardStore("delete index", lock, indexSettings);
                    eventListener.afterIndexShardDeleted(lock.getShardId(), indexSettings.getSettings());
                }
            }
        } catch (IOException e) {
            shardStoreDeleter.addPendingDelete(lock.getShardId(), indexSettings);
            logger.debug(
                (Supplier<?>) () -> new ParameterizedMessage(
                    "[{}] failed to delete shard content - scheduled a retry", lock.getShardId().id()), e);
        }
    }
}