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

Example 91 with ParameterizedMessage

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

the class Engine method getSegmentFileSizes.

private ImmutableOpenMap<String, Long> getSegmentFileSizes(SegmentReader segmentReader) {
    Directory directory = null;
    SegmentCommitInfo segmentCommitInfo = segmentReader.getSegmentInfo();
    boolean useCompoundFile = segmentCommitInfo.info.getUseCompoundFile();
    if (useCompoundFile) {
        try {
            directory = engineConfig.getCodec().compoundFormat().getCompoundReader(segmentReader.directory(), segmentCommitInfo.info, IOContext.READ);
        } catch (IOException e) {
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("Error when opening compound reader for Directory [{}] and SegmentCommitInfo [{}]", segmentReader.directory(), segmentCommitInfo), e);
            return ImmutableOpenMap.of();
        }
    } else {
        directory = segmentReader.directory();
    }
    assert directory != null;
    String[] files;
    if (useCompoundFile) {
        try {
            files = directory.listAll();
        } catch (IOException e) {
            final Directory finalDirectory = directory;
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("Couldn't list Compound Reader Directory [{}]", finalDirectory), e);
            return ImmutableOpenMap.of();
        }
    } else {
        try {
            files = segmentReader.getSegmentInfo().files().toArray(new String[] {});
        } catch (IOException e) {
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("Couldn't list Directory from SegmentReader [{}] and SegmentInfo [{}]", segmentReader, segmentReader.getSegmentInfo()), e);
            return ImmutableOpenMap.of();
        }
    }
    ImmutableOpenMap.Builder<String, Long> map = ImmutableOpenMap.builder();
    for (String file : files) {
        String extension = IndexFileNames.getExtension(file);
        long length = 0L;
        try {
            length = directory.fileLength(file);
        } catch (NoSuchFileException | FileNotFoundException e) {
            final Directory finalDirectory = directory;
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("Tried to query fileLength but file is gone [{}] [{}]", finalDirectory, file), e);
        } catch (IOException e) {
            final Directory finalDirectory = directory;
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("Error when trying to query fileLength [{}] [{}]", finalDirectory, file), e);
        }
        if (length == 0L) {
            continue;
        }
        map.put(extension, length);
    }
    if (useCompoundFile && directory != null) {
        try {
            directory.close();
        } catch (IOException e) {
            final Directory finalDirectory = directory;
            logger.warn((Supplier<?>) () -> new ParameterizedMessage("Error when closing compound reader on Directory [{}]", finalDirectory), e);
        }
    }
    return map.build();
}

Example 92 with ParameterizedMessage

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

the class TransportPutMappingAction method masterOperation.

@Override
protected void masterOperation(final PutMappingRequest request, final ClusterState state, final ActionListener<PutMappingResponse> listener) {
    try {
        final Index[] concreteIndices = request.getConcreteIndex() == null ? indexNameExpressionResolver.concreteIndices(state, request) : new Index[] { request.getConcreteIndex() };
        PutMappingClusterStateUpdateRequest updateRequest = new PutMappingClusterStateUpdateRequest().ackTimeout(request.timeout()).masterNodeTimeout(request.masterNodeTimeout()).indices(concreteIndices).type(request.type()).updateAllTypes(request.updateAllTypes()).source(request.source());
        metaDataMappingService.putMapping(updateRequest, new ActionListener<ClusterStateUpdateResponse>() {

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

            @Override
            public void onFailure(Exception t) {
                logger.debug((Supplier<?>) () -> new ParameterizedMessage("failed to put mappings on indices [{}], type [{}]", concreteIndices, request.type()), t);
                listener.onFailure(t);
            }
        });
    } catch (IndexNotFoundException ex) {
        logger.debug((Supplier<?>) () -> new ParameterizedMessage("failed to put mappings on indices [{}], type [{}]", request.indices(), request.type()), ex);
        throw ex;
    }
}

Example 93 with ParameterizedMessage

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

the class TransportClusterUpdateSettingsAction method masterOperation.

@Override
protected void masterOperation(final ClusterUpdateSettingsRequest request, final ClusterState state, final ActionListener<ClusterUpdateSettingsResponse> listener) {
    final SettingsUpdater updater = new SettingsUpdater(clusterSettings);
    clusterService.submitStateUpdateTask("cluster_update_settings", new AckedClusterStateUpdateTask<ClusterUpdateSettingsResponse>(Priority.IMMEDIATE, request, listener) {

        private volatile boolean changed = false;

        @Override
        protected ClusterUpdateSettingsResponse newResponse(boolean acknowledged) {
            return new ClusterUpdateSettingsResponse(acknowledged, updater.getTransientUpdates(), updater.getPersistentUpdate());
        }

        @Override
        public void onAllNodesAcked(@Nullable Exception e) {
            if (changed) {
                reroute(true);
            } else {
                super.onAllNodesAcked(e);
            }
        }

        @Override
        public void onAckTimeout() {
            if (changed) {
                reroute(false);
            } else {
                super.onAckTimeout();
            }
        }

        private void reroute(final boolean updateSettingsAcked) {
            // so we should *not* execute the reroute.
            if (!clusterService.state().nodes().isLocalNodeElectedMaster()) {
                logger.debug("Skipping reroute after cluster update settings, because node is no longer master");
                listener.onResponse(new ClusterUpdateSettingsResponse(updateSettingsAcked, updater.getTransientUpdates(), updater.getPersistentUpdate()));
                return;
            }
            // The reason the reroute needs to be send as separate update task, is that all the *cluster* settings are encapsulate
            // in the components (e.g. FilterAllocationDecider), so the changes made by the first call aren't visible
            // to the components until the ClusterStateListener instances have been invoked, but are visible after
            // the first update task has been completed.
            clusterService.submitStateUpdateTask("reroute_after_cluster_update_settings", new AckedClusterStateUpdateTask<ClusterUpdateSettingsResponse>(Priority.URGENT, request, listener) {

                @Override
                public boolean mustAck(DiscoveryNode discoveryNode) {
                    //we wait for the reroute ack only if the update settings was acknowledged
                    return updateSettingsAcked;
                }

                @Override
                protected // update settings was acknowledged
                ClusterUpdateSettingsResponse newResponse(boolean acknowledged) {
                    return new ClusterUpdateSettingsResponse(updateSettingsAcked && acknowledged, updater.getTransientUpdates(), updater.getPersistentUpdate());
                }

                @Override
                public void onNoLongerMaster(String source) {
                    logger.debug("failed to preform reroute after cluster settings were updated - current node is no longer a master");
                    listener.onResponse(new ClusterUpdateSettingsResponse(updateSettingsAcked, updater.getTransientUpdates(), updater.getPersistentUpdate()));
                }

                @Override
                public void onFailure(String source, Exception e) {
                    //if the reroute fails we only log
                    logger.debug((Supplier<?>) () -> new ParameterizedMessage("failed to perform [{}]", source), e);
                    listener.onFailure(new ElasticsearchException("reroute after update settings failed", e));
                }

                @Override
                public ClusterState execute(final ClusterState currentState) {
                    // now, reroute in case things that require it changed (e.g. number of replicas)
                    return allocationService.reroute(currentState, "reroute after cluster update settings");
                }
            });
        }

        @Override
        public void onFailure(String source, Exception e) {
            logger.debug((Supplier<?>) () -> new ParameterizedMessage("failed to perform [{}]", source), e);
            super.onFailure(source, e);
        }

        @Override
        public ClusterState execute(final ClusterState currentState) {
            ClusterState clusterState = updater.updateSettings(currentState, request.transientSettings(), request.persistentSettings());
            changed = clusterState != currentState;
            return clusterState;
        }
    });
}

Example 94 with ParameterizedMessage

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

the class TransportUpdateSettingsAction method masterOperation.

@Override
protected void masterOperation(final UpdateSettingsRequest request, final ClusterState state, final ActionListener<UpdateSettingsResponse> listener) {
    final Index[] concreteIndices = indexNameExpressionResolver.concreteIndices(state, request);
    UpdateSettingsClusterStateUpdateRequest clusterStateUpdateRequest = new UpdateSettingsClusterStateUpdateRequest().indices(concreteIndices).settings(request.settings()).setPreserveExisting(request.isPreserveExisting()).ackTimeout(request.timeout()).masterNodeTimeout(request.masterNodeTimeout());
    updateSettingsService.updateSettings(clusterStateUpdateRequest, new ActionListener<ClusterStateUpdateResponse>() {

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

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

Example 95 with ParameterizedMessage

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

the class MapperService method updateMapping.

/**
     * Update mapping by only merging the metadata that is different between received and stored entries
     */
public boolean updateMapping(IndexMetaData indexMetaData) throws IOException {
    assert indexMetaData.getIndex().equals(index()) : "index mismatch: expected " + index() + " but was " + indexMetaData.getIndex();
    // go over and add the relevant mappings (or update them)
    final Set<String> existingMappers = new HashSet<>(mappers.keySet());
    final Map<String, DocumentMapper> updatedEntries;
    try {
        // only update entries if needed
        updatedEntries = internalMerge(indexMetaData, MergeReason.MAPPING_RECOVERY, true, true);
    } catch (Exception e) {
        logger.warn((org.apache.logging.log4j.util.Supplier<?>) () -> new ParameterizedMessage("[{}] failed to apply mappings", index()), e);
        throw e;
    }
    boolean requireRefresh = false;
    for (DocumentMapper documentMapper : updatedEntries.values()) {
        String mappingType = documentMapper.type();
        CompressedXContent incomingMappingSource = indexMetaData.mapping(mappingType).source();
        String op = existingMappers.contains(mappingType) ? "updated" : "added";
        if (logger.isDebugEnabled() && incomingMappingSource.compressed().length < 512) {
            logger.debug("[{}] {} mapping [{}], source [{}]", index(), op, mappingType, incomingMappingSource.string());
        } else if (logger.isTraceEnabled()) {
            logger.trace("[{}] {} mapping [{}], source [{}]", index(), op, mappingType, incomingMappingSource.string());
        } else {
            logger.debug("[{}] {} mapping [{}] (source suppressed due to length, use TRACE level if needed)", index(), op, mappingType);
        }
        // merge version of it, which it does when refreshing the mappings), and warn log it.
        if (documentMapper(mappingType).mappingSource().equals(incomingMappingSource) == false) {
            logger.debug("[{}] parsed mapping [{}], and got different sources\noriginal:\n{}\nparsed:\n{}", index(), mappingType, incomingMappingSource, documentMapper(mappingType).mappingSource());
            requireRefresh = true;
        }
    }
    return requireRefresh;
}