Examples with ParameterizedMessage org.apache.logging.log4j.message.ParameterizedMessage used on opensource projects

Example 41 with ParameterizedMessage

use of org.apache.logging.log4j.message.ParameterizedMessage in project elasticsearch by elastic.

the class ElasticsearchUncaughtExceptionHandler method onFatalUncaught.

// visible for testing
void onFatalUncaught(final String threadName, final Throwable t) {
    final Logger logger = Loggers.getLogger(ElasticsearchUncaughtExceptionHandler.class, loggingPrefixSupplier.get());
    logger.error((org.apache.logging.log4j.util.Supplier<?>) () -> new ParameterizedMessage("fatal error in thread [{}], exiting", threadName), t);
}

Example 42 with ParameterizedMessage

use of org.apache.logging.log4j.message.ParameterizedMessage in project elasticsearch by elastic.

the class ZenDiscovery method processNextPendingClusterState.

void processNextPendingClusterState(String reason) {
    clusterService.submitStateUpdateTask("zen-disco-receive(from master [" + reason + "])", new LocalClusterUpdateTask(Priority.URGENT) {

        ClusterState newClusterState = null;

        @Override
        public ClusterTasksResult<LocalClusterUpdateTask> execute(ClusterState currentState) {
            newClusterState = publishClusterState.pendingStatesQueue().getNextClusterStateToProcess();
            // all pending states have been processed
            if (newClusterState == null) {
                return unchanged();
            }
            assert newClusterState.nodes().getMasterNode() != null : "received a cluster state without a master";
            assert !newClusterState.blocks().hasGlobalBlock(discoverySettings.getNoMasterBlock()) : "received a cluster state with a master block";
            if (currentState.nodes().isLocalNodeElectedMaster()) {
                return handleAnotherMaster(currentState, newClusterState.nodes().getMasterNode(), newClusterState.version(), "via a new cluster state");
            }
            if (shouldIgnoreOrRejectNewClusterState(logger, currentState, newClusterState)) {
                return unchanged();
            }
            if (currentState.blocks().hasGlobalBlock(discoverySettings.getNoMasterBlock())) {
                // its a fresh update from the master as we transition from a start of not having a master to having one
                logger.debug("got first state from fresh master [{}]", newClusterState.nodes().getMasterNodeId());
                return newState(newClusterState);
            }
            // some optimizations to make sure we keep old objects where possible
            ClusterState.Builder builder = ClusterState.builder(newClusterState);
            // if the routing table did not change, use the original one
            if (newClusterState.routingTable().version() == currentState.routingTable().version()) {
                builder.routingTable(currentState.routingTable());
            }
            // same for metadata
            if (newClusterState.metaData().version() == currentState.metaData().version()) {
                builder.metaData(currentState.metaData());
            } else {
                // if its not the same version, only copy over new indices or ones that changed the version
                MetaData.Builder metaDataBuilder = MetaData.builder(newClusterState.metaData()).removeAllIndices();
                for (IndexMetaData indexMetaData : newClusterState.metaData()) {
                    IndexMetaData currentIndexMetaData = currentState.metaData().index(indexMetaData.getIndex());
                    if (currentIndexMetaData != null && currentIndexMetaData.isSameUUID(indexMetaData.getIndexUUID()) && currentIndexMetaData.getVersion() == indexMetaData.getVersion()) {
                        // safe to reuse
                        metaDataBuilder.put(currentIndexMetaData, false);
                    } else {
                        metaDataBuilder.put(indexMetaData, false);
                    }
                }
                builder.metaData(metaDataBuilder);
            }
            return newState(builder.build());
        }

        @Override
        public void onFailure(String source, Exception e) {
            logger.error((Supplier<?>) () -> new ParameterizedMessage("unexpected failure during [{}]", source), e);
            if (newClusterState != null) {
                try {
                    publishClusterState.pendingStatesQueue().markAsFailed(newClusterState, e);
                } catch (Exception inner) {
                    inner.addSuppressed(e);
                    logger.error((Supplier<?>) () -> new ParameterizedMessage("unexpected exception while failing [{}]", source), inner);
                }
            }
        }

        @Override
        public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
            try {
                if (newClusterState != null) {
                    // check to see that we monitor the correct master of the cluster
                    if (masterFD.masterNode() == null || !masterFD.masterNode().equals(newClusterState.nodes().getMasterNode())) {
                        masterFD.restart(newClusterState.nodes().getMasterNode(), "new cluster state received and we are monitoring the wrong master [" + masterFD.masterNode() + "]");
                    }
                    publishClusterState.pendingStatesQueue().markAsProcessed(newClusterState);
                }
            } catch (Exception e) {
                onFailure(source, e);
            }
        }
    });
}

Example 43 with ParameterizedMessage

use of org.apache.logging.log4j.message.ParameterizedMessage in project elasticsearch by elastic.

the class ZenDiscovery method doStop.

@Override
protected void doStop() {
    joinThreadControl.stop();
    masterFD.stop("zen disco stop");
    nodesFD.stop();
    // stop any ongoing pinging
    Releasables.close(zenPing);
    DiscoveryNodes nodes = nodes();
    if (sendLeaveRequest) {
        if (nodes.getMasterNode() == null) {
        // if we don't know who the master is, nothing to do here
        } else if (!nodes.isLocalNodeElectedMaster()) {
            try {
                membership.sendLeaveRequestBlocking(nodes.getMasterNode(), nodes.getLocalNode(), TimeValue.timeValueSeconds(1));
            } catch (Exception e) {
                logger.debug((Supplier<?>) () -> new ParameterizedMessage("failed to send leave request to master [{}]", nodes.getMasterNode()), e);
            }
        } else {
            // we're master -> let other potential master we left and start a master election now rather then wait for masterFD
            DiscoveryNode[] possibleMasters = electMaster.nextPossibleMasters(nodes.getNodes().values(), 5);
            for (DiscoveryNode possibleMaster : possibleMasters) {
                if (nodes.getLocalNode().equals(possibleMaster)) {
                    continue;
                }
                try {
                    membership.sendLeaveRequest(nodes.getLocalNode(), possibleMaster);
                } catch (Exception e) {
                    logger.debug((Supplier<?>) () -> new ParameterizedMessage("failed to send leave request from master [{}] to possible master [{}]", nodes.getMasterNode(), possibleMaster), e);
                }
            }
        }
    }
}

Example 44 with ParameterizedMessage

use of org.apache.logging.log4j.message.ParameterizedMessage in project elasticsearch by elastic.

the class ZenDiscovery method handleAnotherMaster.

private ClusterStateTaskExecutor.ClusterTasksResult handleAnotherMaster(ClusterState localClusterState, final DiscoveryNode otherMaster, long otherClusterStateVersion, String reason) {
    assert localClusterState.nodes().isLocalNodeElectedMaster() : "handleAnotherMaster called but current node is not a master";
    assert Thread.currentThread().getName().contains(ClusterService.UPDATE_THREAD_NAME) : "not called from the cluster state update thread";
    if (otherClusterStateVersion > localClusterState.version()) {
        return rejoin(localClusterState, "zen-disco-discovered another master with a new cluster_state [" + otherMaster + "][" + reason + "]");
    } else {
        logger.warn("discovered [{}] which is also master but with an older cluster_state, telling [{}] to rejoin the cluster ([{}])", otherMaster, otherMaster, reason);
        // spawn to a background thread to not do blocking operations on the cluster state thread
        threadPool.generic().execute(new AbstractRunnable() {

            @Override
            public void onFailure(Exception e) {
                logger.warn((Supplier<?>) () -> new ParameterizedMessage("failed to send rejoin request to [{}]", otherMaster), e);
            }

            @Override
            protected void doRun() throws Exception {
                // make sure we're connected to this node (connect to node does nothing if we're already connected)
                // since the network connections are asymmetric, it may be that we received a state but have disconnected from the node
                // in the past (after a master failure, for example)
                transportService.connectToNode(otherMaster);
                transportService.sendRequest(otherMaster, DISCOVERY_REJOIN_ACTION_NAME, new RejoinClusterRequest(localNode().getId()), new EmptyTransportResponseHandler(ThreadPool.Names.SAME) {

                    @Override
                    public void handleException(TransportException exp) {
                        logger.warn((Supplier<?>) () -> new ParameterizedMessage("failed to send rejoin request to [{}]", otherMaster), exp);
                    }
                });
            }
        });
        return LocalClusterUpdateTask.unchanged();
    }
}

Example 45 with ParameterizedMessage

use of org.apache.logging.log4j.message.ParameterizedMessage in project elasticsearch by elastic.

the class PublishClusterStateAction method sendClusterStateToNode.

private void sendClusterStateToNode(final ClusterState clusterState, BytesReference bytes, final DiscoveryNode node, final TimeValue publishTimeout, final SendingController sendingController, final boolean sendDiffs, final Map<Version, BytesReference> serializedStates) {
    try {
        // -> no need to put a timeout on the options here, because we want the response to eventually be received
        //  and not log an error if it arrives after the timeout
        // -> no need to compress, we already compressed the bytes
        TransportRequestOptions options = TransportRequestOptions.builder().withType(TransportRequestOptions.Type.STATE).withCompress(false).build();
        transportService.sendRequest(node, SEND_ACTION_NAME, new BytesTransportRequest(bytes, node.getVersion()), options, new EmptyTransportResponseHandler(ThreadPool.Names.SAME) {

            @Override
            public void handleResponse(TransportResponse.Empty response) {
                if (sendingController.getPublishingTimedOut()) {
                    logger.debug("node {} responded for cluster state [{}] (took longer than [{}])", node, clusterState.version(), publishTimeout);
                }
                sendingController.onNodeSendAck(node);
            }

            @Override
            public void handleException(TransportException exp) {
                if (sendDiffs && exp.unwrapCause() instanceof IncompatibleClusterStateVersionException) {
                    logger.debug("resending full cluster state to node {} reason {}", node, exp.getDetailedMessage());
                    sendFullClusterState(clusterState, serializedStates, node, publishTimeout, sendingController);
                } else {
                    logger.debug((org.apache.logging.log4j.util.Supplier<?>) () -> new ParameterizedMessage("failed to send cluster state to {}", node), exp);
                    sendingController.onNodeSendFailed(node, exp);
                }
            }
        });
    } catch (Exception e) {
        logger.warn((org.apache.logging.log4j.util.Supplier<?>) () -> new ParameterizedMessage("error sending cluster state to {}", node), e);
        sendingController.onNodeSendFailed(node, e);
    }
}