Java LogHandler类代码示例

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
/**
 * Creates an instance with an existing {@link ApplicationMasterLiveNodeData}.
 */
YarnTwillController(String appName, RunId runId, ZKClient zkClient,
                    final ApplicationMasterLiveNodeData amLiveNodeData, final YarnAppClient yarnAppClient) {
  super(appName, runId, zkClient, amLiveNodeData.getKafkaZKConnect() != null, Collections.<LogHandler>emptyList());
  this.appName = appName;
  this.amLiveNodeData = amLiveNodeData;
  this.startUp = new Callable<ProcessController<YarnApplicationReport>>() {
    @Override
    public ProcessController<YarnApplicationReport> call() throws Exception {
      return yarnAppClient.createProcessController(
        YarnUtils.createApplicationId(amLiveNodeData.getAppIdClusterTime(), amLiveNodeData.getAppId()));
    }
  };
  this.startTimeout = Constants.APPLICATION_MAX_START_SECONDS;
  this.startTimeoutUnit = TimeUnit.SECONDS;
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
@Test
public void testInitFail() throws InterruptedException, ExecutionException, TimeoutException {
  TwillRunner runner = getTwillRunner();
  final CountDownLatch logLatch = new CountDownLatch(1);

  // Verify that it receives the exception log entry that thrown when runnable initialize
  LogHandler logVerifyHandler = new LogHandler() {
    @Override
    public void onLog(LogEntry logEntry) {
      if (logEntry.getMessage().endsWith("exited abnormally with state COMPLETE, exit code 10.")) {
        logLatch.countDown();
      }
    }
  };

  TwillController controller = runner
    .prepare(new InitFailRunnable())
    .addLogHandler(new PrinterLogHandler(new PrintWriter(System.out)))
    .addLogHandler(logVerifyHandler)
    .start();

  controller.awaitTerminated(2, TimeUnit.MINUTES);
  Assert.assertTrue(logLatch.await(10, TimeUnit.SECONDS));
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
private void maxRetriesRun(final int instances) throws TimeoutException, ExecutionException {
  TwillRunner runner = getTwillRunner();
  final int maxRetries = 3;
  final AtomicInteger retriesSeen = new AtomicInteger(0);

  ResourceSpecification resource = ResourceSpecification.Builder.with().setVirtualCores(1)
    .setMemory(512, ResourceSpecification.SizeUnit.MEGA).setInstances(instances).build();

  TwillController controller = runner.prepare(new FailingServer(), resource)
    .withMaxRetries(FailingServer.class.getSimpleName(), maxRetries)
    .addLogHandler(new PrinterLogHandler(new PrintWriter(System.out, true)))
    .addLogHandler(new LogHandler() {
      @Override
      public void onLog(LogEntry logEntry) {
        if (logEntry.getMessage().contains("retries for instance")) {
          retriesSeen.incrementAndGet();
        }
      }
    })
    .start();

  controller.awaitTerminated(2, TimeUnit.MINUTES);
  Assert.assertEquals(maxRetries * instances, retriesSeen.get());
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
public AbstractTwillController(String appName, RunId runId, ZKClient zkClient, boolean logCollectionEnabled,
                               Iterable<LogHandler> logHandlers) {
  super(runId, zkClient);
  this.appName = appName;
  this.runId = runId;
  this.logHandlers = new ConcurrentLinkedQueue<>();

  // When addressing TWILL-147, need to check if the given ZKClient is
  // actually used by the Kafka used for log collection
  if (logCollectionEnabled) {
    this.kafkaClient = new ZKKafkaClientService(ZKClients.namespace(zkClient, "/" + runId.getId() + "/kafka"));
    Iterables.addAll(this.logHandlers, logHandlers);
  } else {
    this.kafkaClient = null;
    if (!Iterables.isEmpty(logHandlers)) {
      LOG.warn("Log collection is disabled for application {} with runId {}. " +
                 "Adding log handler won't get any logs.", appName, runId);
    }
  }
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
@Override
public final synchronized void addLogHandler(LogHandler handler) {
  if (kafkaClient == null) {
    LOG.warn("Log collection is disabled for application {} with runId {}. " +
               "Adding log handler won't get any logs.", appName, runId);
    return;
  }

  logHandlers.add(handler);
  if (logHandlers.size() == 1) {
    kafkaClient.startAndWait();
    logCancellable = kafkaClient.getConsumer().prepare()
      .addFromBeginning(Constants.LOG_TOPIC, 0)
      .consume(new LogMessageCallback(logHandlers));
  }
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
@Override
public TwillPreparer prepare(TwillApplication application) {
  Preconditions.checkState(isRunning(), "Service not start. Please call start() first.");
  final TwillSpecification twillSpec = application.configure();
  final String appName = twillSpec.getName();

  return new YarnTwillPreparer(yarnConfig, twillSpec, yarnAppClient, zkClientService, locationFactory, jvmOptions,
                               new YarnTwillControllerFactory() {
    @Override
    public YarnTwillController create(RunId runId, Iterable<LogHandler> logHandlers,
                                      Callable<ProcessController<YarnApplicationReport>> startUp) {
      ZKClient zkClient = ZKClients.namespace(zkClientService, "/" + appName);
      YarnTwillController controller = listenController(new YarnTwillController(appName, runId, zkClient,
                                                                                logHandlers, startUp));
      synchronized (YarnTwillRunnerService.this) {
        Preconditions.checkArgument(!controllers.contains(appName, runId),
                                    "Application %s with runId %s is already running.", appName, runId);
        controllers.put(appName, runId, controller);
      }
      return controller;
    }
  });
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
@Test
public void testDisableLogCollection() throws Exception {
  final AtomicBoolean logReceived = new AtomicBoolean();

  // Start the LogRunnable by turning off log collection
  TwillRunner runner = getTwillRunner();
  TwillController controller = runner.prepare(new LogRunnable())
    .withConfiguration(Collections.singletonMap(Configs.Keys.LOG_COLLECTION_ENABLED, "false"))
    .addLogHandler(new LogHandler() {
      @Override
      public void onLog(LogEntry logEntry) {
        logReceived.set(true);
      }
    })
    .start();

  // Make sure the runnable gets executed
  try {
    final CountDownLatch latch = new CountDownLatch(1);
    controller.discoverService("log").watchChanges(new ServiceDiscovered.ChangeListener() {
      @Override
      public void onChange(ServiceDiscovered serviceDiscovered) {
        if (Iterables.size(serviceDiscovered) == 1) {
          latch.countDown();
        }
      }
    }, Threads.SAME_THREAD_EXECUTOR);
    Assert.assertTrue(latch.await(120, TimeUnit.SECONDS));
  } finally {
    controller.terminate().get(120, TimeUnit.SECONDS);
  }

  // Should receive no log
  Assert.assertFalse("Not expecting logs collected", logReceived.get());
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
private void invokeHandlers(LogEntry entry) {
  for (LogHandler handler : logHandlers) {
    try {
      handler.onLog(entry);
    } catch (Throwable t) {
      LOG.warn("Exception while calling LogHandler {}", handler, t);
    }
  }
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
private TwillController getController(ZKClient zkClient, String appName, RunId runId) {
  AbstractTwillController controller = new AbstractTwillController(appName, runId,
                                                                   zkClient, false, ImmutableList.<LogHandler>of()) {

    @Override
    public void kill() {
      // No-op
    }

    @Override
    protected void instanceNodeUpdated(NodeData nodeData) {
      // No-op
    }

    @Override
    protected void instanceNodeFailed(Throwable cause) {
      // Shutdown if the instance node goes away
      if (cause instanceof KeeperException.NoNodeException) {
        forceShutDown();
      }
    }

    @Override
    public ResourceReport getResourceReport() {
      return null;
    }
  };
  controller.startAndWait();
  return controller;
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
public AbstractTwillController(RunId runId, ZKClient zkClient, Iterable<LogHandler> logHandlers) {
  super(runId, zkClient);
  this.logHandlers = new ConcurrentLinkedQueue<LogHandler>();
  this.kafkaClient = new ZKKafkaClientService(ZKClients.namespace(zkClient, "/" + runId.getId() + "/kafka"));
  this.discoveryServiceClient = new ZKDiscoveryService(zkClient);
  Iterables.addAll(this.logHandlers, logHandlers);
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
@Override
public final synchronized void addLogHandler(LogHandler handler) {
  logHandlers.add(handler);
  if (logHandlers.size() == 1) {
    kafkaClient.startAndWait();
    logCancellable = kafkaClient.getConsumer().prepare()
      .addFromBeginning(Constants.LOG_TOPIC, 0)
      .consume(new LogMessageCallback(logHandlers));
  }
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
private TwillController getController(ZKClient zkClient, RunId runId) {
  TwillController controller = new AbstractTwillController(runId, zkClient, ImmutableList.<LogHandler>of()) {

    @Override
    public void kill() {
      // No-op
    }

    @Override
    protected void instanceNodeUpdated(NodeData nodeData) {
      // No-op
    }

    @Override
    protected void instanceNodeFailed(Throwable cause) {
      // Shutdown if the instance node goes away
      if (cause instanceof KeeperException.NoNodeException) {
        forceShutDown();
      }
    }

    @Override
    public ResourceReport getResourceReport() {
      return null;
    }
  };
  controller.startAndWait();
  return controller;
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
@Override
public TwillPreparer addLogHandler(LogHandler handler) {
  logHandlers.add(handler);
  return this;
}
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
YarnTwillController create(RunId runId, boolean logCollectionEnabled, Iterable<LogHandler> logHandlers,
Callable<ProcessController<YarnApplicationReport>> startUp,
long startTimeout, TimeUnit startTimeoutUnit);
 

import org.apache.twill.api.logging.LogHandler; //导入依赖的package包/类
@Test
public void testLogHandler() throws ExecutionException, InterruptedException, TimeoutException {
  final CountDownLatch latch = new CountDownLatch(3);
  final Queue<LogThrowable> throwables = new ConcurrentLinkedQueue<LogThrowable>();
  final Queue<String> runnables = new ConcurrentLinkedQueue<String>();

  LogHandler logHandler = new LogHandler() {
    @Override
    public void onLog(LogEntry logEntry) {
      // Would expect logs from AM and the runnable.
      if (logEntry.getSourceClassName().contains("LogHandlerTestRun")) {
        runnables.add(logEntry.getRunnableName());
      }
      // Runnable name for AM should be null
      if (logEntry.getSourceClassName().contains("ApplicationMasterService")) {
        Assert.assertNull(logEntry.getRunnableName());
      }
      if (logEntry.getMessage().startsWith("Starting runnable " + LogRunnable.class.getSimpleName())) {
        latch.countDown();
      } else if (logEntry.getMessage().equals("Running")) {
        latch.countDown();
      } else if (logEntry.getMessage().equals("Got exception") && logEntry.getThrowable() != null) {
        throwables.add(logEntry.getThrowable());
        latch.countDown();
      }
    }
  };

  TwillRunner runner = getTwillRunner();
  TwillController controller = runner.prepare(new LogRunnable())
                                     .addLogHandler(new PrinterLogHandler(new PrintWriter(System.out, true)))
                                     .addLogHandler(logHandler)
                                     .start();

  try {
    Assert.assertTrue(latch.await(100, TimeUnit.SECONDS));
  } finally {
    controller.terminate().get(120, TimeUnit.SECONDS);
  }

  // Verify the runnable names
  Assert.assertEquals(2, runnables.size());
  Assert.assertArrayEquals(new String[] {"LogRunnable", "LogRunnable"}, runnables.toArray());

  // Verify the log throwable
  Assert.assertEquals(1, throwables.size());

  LogThrowable t = throwables.poll();
  Assert.assertEquals(RuntimeException.class.getName(), t.getClassName());
  Assert.assertNotNull(t.getCause());
  Assert.assertEquals(5, t.getStackTraces().length);

  t = t.getCause();
  Assert.assertEquals(Exception.class.getName(), t.getClassName());
  Assert.assertEquals("Exception", t.getMessage());
}