Java NodeEngine.getLogger方法代码示例

import com.hazelcast.spi.NodeEngine; //导入方法依赖的package包/类
@Override
public void init(@Nonnull Outbox outbox, @Nonnull Context context) {
    logger = context.logger();
    outbox = new LoggingOutbox(outbox, peekOutput, peekSnapshot);

    // Fix issue #595: pass a logger with real class name to processor
    // We do this only if context is ProcCtx (that is, not for tests where TestProcessorContext can be used
    // and also other objects could be mocked or null, such as jetInstance())
    if (context instanceof ProcCtx) {
        ProcCtx c = (ProcCtx) context;
        NodeEngine nodeEngine = ((HazelcastInstanceImpl) c.jetInstance().getHazelcastInstance()).node.nodeEngine;
        ILogger newLogger = nodeEngine.getLogger(
                createLoggerName(wrappedProcessor.getClass().getName(), c.vertexName(), c.globalProcessorIndex()));
        context = new ProcCtx(c.jetInstance(), c.getSerializationService(), newLogger, c.vertexName(),
                c.globalProcessorIndex(), c.processingGuarantee());
    }

    wrappedProcessor.init(outbox, context);
}
 

import com.hazelcast.spi.NodeEngine; //导入方法依赖的package包/类
Networking(NodeEngine nodeEngine, JobExecutionService jobExecutionService, int flowControlPeriodMs) {
    this.nodeEngine = (NodeEngineImpl) nodeEngine;
    this.logger = nodeEngine.getLogger(getClass());
    this.jobExecutionService = jobExecutionService;
    this.flowControlSender = nodeEngine.getExecutionService().scheduleWithRepetition(
            this::broadcastFlowControlPacket, 0, flowControlPeriodMs, MILLISECONDS);
}
 

import com.hazelcast.spi.NodeEngine; //导入方法依赖的package包/类
public StoreSnapshotTasklet(SnapshotContext snapshotContext, long jobId, InboundEdgeStream inboundEdgeStream,
                            NodeEngine nodeEngine, String vertexName, boolean isHigherPrioritySource) {
    this.snapshotContext = snapshotContext;
    this.jobId = jobId;
    this.inboundEdgeStream = inboundEdgeStream;
    this.vertexName = vertexName;
    this.isHigherPrioritySource = isHigherPrioritySource;

    this.mapWriter = new AsyncMapWriter(nodeEngine);
    this.pendingSnapshotId = snapshotContext.lastSnapshotId() + 1;
    this.mapWriter.setMapName(currMapName());
    this.logger = nodeEngine.getLogger(StoreSnapshotTasklet.class + "." + vertexName + "#snapshot");
}
 

import com.hazelcast.spi.NodeEngine; //导入方法依赖的package包/类
public ExecutionContext(NodeEngine nodeEngine, TaskletExecutionService execService,
                        long jobId, long executionId, Address coordinator, Set<Address> participants) {
    this.jobId = jobId;
    this.executionId = executionId;
    this.coordinator = coordinator;
    this.participants = new HashSet<>(participants);
    this.execService = execService;
    this.nodeEngine = nodeEngine;

    logger = nodeEngine.getLogger(getClass());
}
 

import com.hazelcast.spi.NodeEngine; //导入方法依赖的package包/类
public AsyncMapWriter(NodeEngine nodeEngine) {
    this.partitionService = nodeEngine.getPartitionService();
    this.operationService = nodeEngine.getOperationService();
    this.mapService = nodeEngine.getService(MapService.SERVICE_NAME);
    this.outputBuffers = new MapEntries[partitionService.getPartitionCount()];
    this.serializationService = nodeEngine.getSerializationService();
    this.executionService = nodeEngine.getExecutionService();
    this.logger = nodeEngine.getLogger(AsyncMapWriter.class);
    JetService jetService = nodeEngine.getService(JetService.SERVICE_NAME);
    this.numConcurrentOps = jetService.numConcurrentPutAllOps();
}
 

import com.hazelcast.spi.NodeEngine; //导入方法依赖的package包/类
public void initialize(NodeEngine nodeEngine, long jobId, long executionId, SnapshotContext snapshotContext) {
    this.nodeEngine = nodeEngine;
    this.executionId = executionId;
    initProcSuppliers();
    initDag();

    this.ptionArrgmt = new PartitionArrangement(partitionOwners, nodeEngine.getThisAddress());
    JetInstance instance = getJetInstance(nodeEngine);
    for (VertexDef srcVertex : vertices) {
        Collection<? extends Processor> processors = createProcessors(srcVertex, srcVertex.parallelism());

        // create StoreSnapshotTasklet and the queues to it
        QueuedPipe<Object>[] snapshotQueues = new QueuedPipe[srcVertex.parallelism()];
        Arrays.setAll(snapshotQueues, i -> new OneToOneConcurrentArrayQueue<>(SNAPSHOT_QUEUE_SIZE));
        ConcurrentConveyor<Object> ssConveyor = ConcurrentConveyor.concurrentConveyor(null, snapshotQueues);
        StoreSnapshotTasklet ssTasklet = new StoreSnapshotTasklet(snapshotContext, jobId,
                new ConcurrentInboundEdgeStream(ssConveyor, 0, 0, lastSnapshotId, true, -1),
                nodeEngine, srcVertex.name(), srcVertex.isHigherPriorityUpstream());
        tasklets.add(ssTasklet);

        int localProcessorIdx = 0;
        for (Processor p : processors) {
            int globalProcessorIndex = srcVertex.getProcIdxOffset() + localProcessorIdx;
            String loggerName = createLoggerName(p.getClass().getName(), srcVertex.name(), globalProcessorIndex);
            ProcCtx context = new ProcCtx(
                    instance,
                    nodeEngine.getSerializationService(),
                    nodeEngine.getLogger(loggerName),
                    srcVertex.name(),
                    globalProcessorIndex,
                    jobConfig.getProcessingGuarantee());

             String probePrefix = String.format("jet.job.%s.%s#%d", idToString(executionId), srcVertex.name(),
                     localProcessorIdx);
             ((NodeEngineImpl) nodeEngine).getMetricsRegistry().scanAndRegister(p, probePrefix);

            // createOutboundEdgeStreams() populates localConveyorMap and edgeSenderConveyorMap.
            // Also populates instance fields: senderMap, receiverMap, tasklets.
            List<OutboundEdgeStream> outboundStreams = createOutboundEdgeStreams(srcVertex, localProcessorIdx);
            List<InboundEdgeStream> inboundStreams = createInboundEdgeStreams(srcVertex, localProcessorIdx);

            OutboundCollector snapshotCollector = new ConveyorCollector(ssConveyor, localProcessorIdx, null);

            ProcessorTasklet processorTasklet = new ProcessorTasklet(context, p, inboundStreams, outboundStreams,
                    snapshotContext, snapshotCollector, jobConfig.getMaxWatermarkRetainMillis());
            tasklets.add(processorTasklet);
            this.processors.add(p);
            localProcessorIdx++;
        }
    }
    List<ReceiverTasklet> allReceivers = receiverMap.values().stream()
                                                    .flatMap(o -> o.values().stream())
                                                    .flatMap(a -> a.values().stream())
                                                    .collect(toList());

    tasklets.addAll(allReceivers);
}
 

import com.hazelcast.spi.NodeEngine; //导入方法依赖的package包/类
public JetService(NodeEngine nodeEngine) {
    this.nodeEngine = (NodeEngineImpl) nodeEngine;
    this.logger = nodeEngine.getLogger(getClass());
    this.liveOperationRegistry = new LiveOperationRegistry();
}
 

import com.hazelcast.spi.NodeEngine; //导入方法依赖的package包/类
@Override
public void init(NodeEngine nodeEngine, Properties properties) {
    this.nodeEngine = nodeEngine;
    this.executionService = nodeEngine.getExecutionService();
    this.logger = nodeEngine.getLogger(ScheduledExecutorService.class);
}