Java OutputEvent类代码示例

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
public void onOutput(OutputEvent event) {
    if (event instanceof LogLevelChangeEvent) {
        LogLevelChangeEvent changeEvent = (LogLevelChangeEvent) event;
        debugOutput = changeEvent.getNewLogLevel() == LogLevel.DEBUG;
    }
    if (event instanceof RenderableOutputEvent) {
        RenderableOutputEvent outputEvent = (RenderableOutputEvent) event;
        textOutput.style(outputEvent.getLogLevel() == LogLevel.ERROR ? Error : Normal);
        if (debugOutput && (textOutput.atEndOfLine || lastEvent == null || !lastEvent.getCategory().equals(outputEvent.getCategory()))) {
            if (!textOutput.atEndOfLine) {
                textOutput.println();
            }
            textOutput.text(dateFormat.format(new Date(outputEvent.getTimestamp())));
            textOutput.text(" [");
            textOutput.text(outputEvent.getLogLevel());
            textOutput.text("] [");
            textOutput.text(outputEvent.getCategory());
            textOutput.text("] ");
        }
        outputEvent.render(textOutput);
        lastEvent = outputEvent;
        textOutput.style(Normal);
    }
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
public void onOutput(OutputEvent event) {
    synchronized (lock) {
        if (event.getLogLevel() != null && event.getLogLevel().compareTo(logLevel) < 0) {
            return;
        }
        if (event instanceof LogLevelChangeEvent) {
            LogLevelChangeEvent changeEvent = (LogLevelChangeEvent) event;
            LogLevel newLogLevel = changeEvent.getNewLogLevel();
            if (newLogLevel == this.logLevel) {
                return;
            }
            this.logLevel = newLogLevel;
        }
        formatters.getSource().onOutput(event);
    }
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
@Override
public void run() {
    OutputEvent event;
    try {
        while (!shouldStop) {
            // we must not use interrupt() because it would automatically
            // close the connection (sending data from an interrupted thread
            // automatically closes the connection)
            event = eventQueue.poll(10, TimeUnit.MILLISECONDS);
            if (event != null) {
                dispatchAsync(event);
            }
        }
    } catch (InterruptedException ex) {
        shouldStop = true;
    }
    sendRemainingEvents();
    completionLock.countDown();
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
public void onOutput(OutputEvent newEvent) {
    synchronized (lock) {
        queue.add(newEvent);

        if (newEvent instanceof EndOutputEvent) {
            // Flush and clean up
            renderNow(timeProvider.getCurrentTime());
            executor.shutdown();
            return;
        }

        if (queue.size() > 1) {
            // Currently queuing events, a thread is scheduled to flush the queue later
            return;
        }

        long now = timeProvider.getCurrentTime();
        if (now - lastUpdate >= throttleMs) {
            // Has been long enough since last update - flush now
            renderNow(now);
            return;
        }

        // This is the first queued event - schedule a thread to flush later
        executor.schedule(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    renderNow(timeProvider.getCurrentTime());
                }
            }
        }, throttleMs, TimeUnit.MILLISECONDS);
    }
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
private void renderNow(long now) {
    if (queue.isEmpty()) {
        // Already rendered - don't update anything
        return;
    }

    ProgressOperation lastOp = mostRecentOperation;
    for (OutputEvent event : queue) {
        try {
            if (event instanceof ProgressStartEvent) {
                ProgressStartEvent startEvent = (ProgressStartEvent) event;
                lastOp = operations.start(startEvent.getShortDescription(), startEvent.getStatus(), startEvent.getOperationId(), startEvent.getParentId());
            } else if (event instanceof ProgressCompleteEvent) {
                ProgressOperation op = operations.complete(((ProgressCompleteEvent) event).getOperationId());
                lastOp = op.getParent();
            } else if (event instanceof ProgressEvent) {
                ProgressEvent progressEvent = (ProgressEvent) event;
                lastOp = operations.progress(progressEvent.getStatus(), progressEvent.getOperationId());
            }
            listener.onOutput(event);
        } catch (Exception e) {
            throw new RuntimeException("Unable to process incoming event '" + event + "' (" + event.getClass().getSimpleName() + ")", e);
        }
    }
    if (lastOp != null) {
        getStatusBar().setText(statusBarFormatter.format(lastOp));
    } else if (mostRecentOperation != null) {
        getStatusBar().setText("");
    }
    console.flush();
    mostRecentOperation = lastOp;
    queue.clear();
    lastUpdate = now;
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
public void onOutput(OutputEvent event) {
    if (event instanceof StyledTextOutputEvent) {
        onTextEvent((StyledTextOutputEvent) event);
    } else if (event instanceof LogLevelChangeEvent) {
        onLogLevelChange((LogLevelChangeEvent) event);
    } else {
        throw new IllegalArgumentException();
    }
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
private OutputEventListener onError(final OutputEventListener listener) {
    return new OutputEventListener() {
        public void onOutput(OutputEvent event) {
            if (event.getLogLevel() == LogLevel.ERROR || event.getLogLevel() == null) {
                listener.onOutput(event);
            }
        }
    };
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
private OutputEventListener onNonError(final OutputEventListener listener) {
    return new OutputEventListener() {
        public void onOutput(OutputEvent event) {
            if (event.getLogLevel() != LogLevel.ERROR || event.getLogLevel() == null) {
                listener.onOutput(event);
            }
        }
    };
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
public static Serializer<Message> create() {
    BaseSerializerFactory factory = new BaseSerializerFactory();
    Serializer<LogLevel> logLevelSerializer = factory.getSerializerFor(LogLevel.class);
    Serializer<Throwable> throwableSerializer = factory.getSerializerFor(Throwable.class);
    DefaultSerializerRegistry registry = new DefaultSerializerRegistry();

    registry.register(BuildEvent.class, new BuildEventSerializer());
    registry.register(Failure.class, new FailureSerializer(throwableSerializer));

    // Input events
    registry.register(ForwardInput.class, new ForwardInputSerializer());
    registry.register(CloseInput.class, new CloseInputSerializer());

    // Output events
    registry.register(LogEvent.class, new LogEventSerializer(logLevelSerializer, throwableSerializer));
    registry.register(StyledTextOutputEvent.class, new StyledTextOutputEventSerializer(logLevelSerializer, new ListSerializer<StyledTextOutputEvent.Span>(new SpanSerializer(factory.getSerializerFor(StyledTextOutput.Style.class)))));
    registry.register(ProgressStartEvent.class, new ProgressStartEventSerializer());
    registry.register(ProgressCompleteEvent.class, new ProgressCompleteEventSerializer());
    registry.register(ProgressEvent.class, new ProgressEventSerializer());
    registry.register(LogLevelChangeEvent.class, new LogLevelChangeEventSerializer(logLevelSerializer));
    registry.register(OutputMessage.class, new OutputMessageSerializer(registry.build(OutputEvent.class)));

    // Default for everything else
    registry.useJavaSerialization(Message.class);

    return registry.build(Message.class);
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
private AsynchronousLogDispatcher(DaemonConnection conn, final LogLevel buildLogLevel) {
    super("Asynchronous log dispatcher for " + conn);
    this.connection = conn;
    this.listener = new OutputEventListener() {
        public void onOutput(OutputEvent event) {
            if (event.getLogLevel() != null && event.getLogLevel().compareTo(buildLogLevel) >= 0) {
                dispatcher.submit(event);
            }
        }
    };
    LOGGER.debug(DaemonMessages.ABOUT_TO_START_RELAYING_LOGS);
    loggingOutput.addOutputEventListener(listener);
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
private void dispatchAsync(OutputEvent event) {
    if (unableToSend) {
        return;
    }
    try {
        connection.logEvent(event);
    } catch (Exception ex) {
        shouldStop = true;
        unableToSend = true;
        //Ignore. It means the client has disconnected so no point sending him any log output.
        //we should be checking if client still listens elsewhere anyway.
    }
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
public void onOutput(OutputEvent event) {
    if (event instanceof ProgressStartEvent) {
        ProgressStartEvent startEvent = (ProgressStartEvent) event;
        progressListener.onOperationStart(startEvent.getDescription());
    } else if (event instanceof ProgressCompleteEvent) {
        progressListener.onOperationEnd();
    }
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
@Override
public void onOutput(OutputEvent event) {
    if (event instanceof LogEvent) {
        workerLoggingProtocol.sendOutputEvent((LogEvent) event);
    } else if (event instanceof StyledTextOutputEvent) {
        workerLoggingProtocol.sendOutputEvent((StyledTextOutputEvent) event);
    }
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
@Override
public void onOutput(OutputEvent outputEvent) {
    checkNotNull(outputEvent);
    if (outputEvent instanceof LogEvent) {
        logEvents.add((LogEvent) outputEvent);
    }
}
 

import org.gradle.internal.logging.events.OutputEvent; //导入依赖的package包/类
public OutputMessageSerializer(Serializer<OutputEvent> eventSerializer) {
    this.eventSerializer = eventSerializer;
}