Java Service类代码示例

import org.apache.hadoop.service.Service; //导入依赖的package包/类
/**
 * Test that the {@link BreakableStateChangeListener} is picking up
 * the state changes and that its last event field is as expected.
 */
@Test
public void testEventHistory() {
  register();
  BreakableService service = new BreakableService();
  assertListenerState(listener, Service.STATE.NOTINITED);
  assertEquals(0, listener.getEventCount());
  service.init(new Configuration());
  assertListenerState(listener, Service.STATE.INITED);
  assertSame(service, listener.getLastService());
  assertListenerEventCount(listener, 1);

  service.start();
  assertListenerState(listener, Service.STATE.STARTED);
  assertListenerEventCount(listener, 2);

  service.stop();
  assertListenerState(listener, Service.STATE.STOPPED);
  assertListenerEventCount(listener, 3);
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
/**
 * This test triggers a failure in the listener - the expectation is that the
 * service has already reached it's desired state, purely because the
 * notifications take place afterwards.
 *
 */
@Test
public void testListenerFailure() {
  listener.setFailingState(Service.STATE.INITED);
  register();
  BreakableStateChangeListener l2 = new BreakableStateChangeListener();
  register(l2);
  BreakableService service = new BreakableService();
  service.init(new Configuration());
  //expected notifications to fail

  //still should record its invocation
  assertListenerState(listener, Service.STATE.INITED);
  assertListenerEventCount(listener, 1);

  //and second listener didn't get notified of anything
  assertListenerEventCount(l2, 0);

  //service should still consider itself started
  assertServiceStateInited(service);
  service.start();
  service.stop();
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
/**
 * Walk the {@link BreakableService} through it's lifecycle, 
 * more to verify that service's counters work than anything else
 * @throws Throwable if necessary
 */
@Test
public void testWalkthrough() throws Throwable {

  BreakableService svc = new BreakableService();
  assertServiceStateCreated(svc);
  assertStateCount(svc, Service.STATE.NOTINITED, 1);
  assertStateCount(svc, Service.STATE.INITED, 0);
  assertStateCount(svc, Service.STATE.STARTED, 0);
  assertStateCount(svc, Service.STATE.STOPPED, 0);
  svc.init(new Configuration());
  assertServiceStateInited(svc);
  assertStateCount(svc, Service.STATE.INITED, 1);
  svc.start();
  assertServiceStateStarted(svc);
  assertStateCount(svc, Service.STATE.STARTED, 1);
  svc.stop();
  assertServiceStateStopped(svc);
  assertStateCount(svc, Service.STATE.STOPPED, 1);
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
/**
 * Show that if the service failed during an init
 * operation, it stays in the created state, even after stopping it
 * @throws Throwable if necessary
 */

@Test
public void testStopFailedInit() throws Throwable {
  BreakableService svc = new BreakableService(true, false, false);
  assertServiceStateCreated(svc);
  try {
    svc.init(new Configuration());
    fail("Expected a failure, got " + svc);
  } catch (BreakableService.BrokenLifecycleEvent e) {
    //expected
  }
  //the service state wasn't passed
  assertServiceStateStopped(svc);
  assertStateCount(svc, Service.STATE.INITED, 1);
  assertStateCount(svc, Service.STATE.STOPPED, 1);
  //now try to stop
  svc.stop();
  assertStateCount(svc, Service.STATE.STOPPED, 1);
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
/**
 * Show that if the service failed during an init
 * operation, stop was called.
 */

@Test
public void testStopFailingInitAndStop() throws Throwable {
  BreakableService svc = new BreakableService(true, false, true);
  svc.registerServiceListener(new LoggingStateChangeListener());
  try {
    svc.init(new Configuration());
    fail("Expected a failure, got " + svc);
  } catch (BreakableService.BrokenLifecycleEvent e) {
    assertEquals(Service.STATE.INITED, e.state);
  }
  //the service state is stopped
  assertServiceStateStopped(svc);
  assertEquals(Service.STATE.INITED, svc.getFailureState());

  Throwable failureCause = svc.getFailureCause();
  assertNotNull("Null failure cause in " + svc, failureCause);
  BreakableService.BrokenLifecycleEvent cause =
    (BreakableService.BrokenLifecycleEvent) failureCause;
  assertNotNull("null state in " + cause + " raised by " + svc, cause.state);
  assertEquals(Service.STATE.INITED, cause.state);
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
@Test
public void testServiceFailingNotifications() throws Throwable {
  BreakableService svc = new BreakableService(false, false, false);
  BreakableStateChangeListener listener = new BreakableStateChangeListener();
  listener.setFailingState(Service.STATE.STARTED);
  svc.registerServiceListener(listener);
  svc.init(new Configuration());
  assertEventCount(listener, 1);
  //start this; the listener failed but this won't show
  svc.start();
  //counter went up
  assertEventCount(listener, 2);
  assertEquals(1, listener.getFailureCount());
  //stop the service -this doesn't fail
  svc.stop();
  assertEventCount(listener, 3);
  assertEquals(1, listener.getFailureCount());
  svc.stop();
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
@Override
public void serviceStop() throws Exception {
  try {
    synchronized (serviceMap) {
      for (Service service : serviceMap.values()) {
        if (service.getServiceState() == Service.STATE.STARTED) {
          service.unregisterServiceListener(this);
          service.stop();
        }
      }
      serviceMap.clear();
      serviceMetaData.clear();
    }
  } finally {
    super.serviceStop();
  }
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
@Test
public void testAuxUnexpectedStop() {
  Configuration conf = new Configuration();
  conf.setStrings(YarnConfiguration.NM_AUX_SERVICES, new String[] { "Asrv", "Bsrv" });
  conf.setClass(String.format(YarnConfiguration.NM_AUX_SERVICE_FMT, "Asrv"),
      ServiceA.class, Service.class);
  conf.setClass(String.format(YarnConfiguration.NM_AUX_SERVICE_FMT, "Bsrv"),
      ServiceB.class, Service.class);
  final AuxServices aux = new AuxServices();
  aux.init(conf);
  aux.start();

  Service s = aux.getServices().iterator().next();
  s.stop();
  assertEquals("Auxiliary service stopped, but AuxService unaffected.",
      STOPPED, aux.getServiceState());
  assertTrue(aux.getServices().isEmpty());
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
@Test
public void testAuxServiceRecoverySetup() throws IOException {
  Configuration conf = new YarnConfiguration();
  conf.setBoolean(YarnConfiguration.NM_RECOVERY_ENABLED, true);
  conf.set(YarnConfiguration.NM_RECOVERY_DIR, TEST_DIR.toString());
  conf.setStrings(YarnConfiguration.NM_AUX_SERVICES,
      new String[] { "Asrv", "Bsrv" });
  conf.setClass(String.format(YarnConfiguration.NM_AUX_SERVICE_FMT, "Asrv"),
      RecoverableServiceA.class, Service.class);
  conf.setClass(String.format(YarnConfiguration.NM_AUX_SERVICE_FMT, "Bsrv"),
      RecoverableServiceB.class, Service.class);
  try {
    final AuxServices aux = new AuxServices();
    aux.init(conf);
    Assert.assertEquals(2, aux.getServices().size());
    File auxStorageDir = new File(TEST_DIR,
        AuxServices.STATE_STORE_ROOT_NAME);
    Assert.assertEquals(2, auxStorageDir.listFiles().length);
    aux.close();
  } finally {
    FileUtil.fullyDelete(TEST_DIR);
  }
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
@Test
public void testPolicyInitializeAfterSchedulerInitialized() {
  @SuppressWarnings("resource")
  MockRM rm = new MockRM(conf);
  rm.init(conf);
  
  // ProportionalCapacityPreemptionPolicy should be initialized after
  // CapacityScheduler initialized. We will 
  // 1) find SchedulingMonitor from RMActiveService's service list, 
  // 2) check if ResourceCalculator in policy is null or not. 
  // If it's not null, we can come to a conclusion that policy initialized
  // after scheduler got initialized
  for (Service service : rm.getRMActiveService().getServices()) {
    if (service instanceof SchedulingMonitor) {
      ProportionalCapacityPreemptionPolicy policy =
          (ProportionalCapacityPreemptionPolicy) ((SchedulingMonitor) service)
              .getSchedulingEditPolicy();
      assertNotNull(policy.getResourceCalculator());
      return;
    }
  }
  
  fail("Failed to find SchedulingMonitor service, please check what happened");
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
@Override
protected void serviceInit(Configuration conf) throws Exception {
  // init timeline services first
  timelineStore = createTimelineStore(conf);
  addIfService(timelineStore);
  secretManagerService = createTimelineDelegationTokenSecretManagerService(conf);
  addService(secretManagerService);
  timelineDataManager = createTimelineDataManager(conf);
  addService(timelineDataManager);

  // init generic history service afterwards
  aclsManager = createApplicationACLsManager(conf);
  historyManager = createApplicationHistoryManager(conf);
  ahsClientService = createApplicationHistoryClientService(historyManager);
  addService(ahsClientService);
  addService((Service) historyManager);

  DefaultMetricsSystem.initialize("ApplicationHistoryServer");
  JvmMetrics.initSingleton("ApplicationHistoryServer", null);
  super.serviceInit(conf);
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
public void waitForState(Service.STATE finalState) throws Exception {
  if (finalState == Service.STATE.STOPPED) {
     Assert.assertTrue("Timeout while waiting for MRApp to stop",
         waitForServiceToStop(20 * 1000));
  } else {
    int timeoutSecs = 0;
    while (!finalState.equals(getServiceState()) && timeoutSecs++ < 20) {
      System.out.println("MRApp State is : " + getServiceState()
          + " Waiting for state : " + finalState);
      Thread.sleep(500);
    }
    System.out.println("MRApp State is : " + getServiceState());
    Assert.assertEquals("MRApp state is not correct (timedout)", finalState,
        getServiceState());
  }
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
public void testDeletionofStagingOnKillLastTry() throws IOException {
  conf.set(MRJobConfig.MAPREDUCE_JOB_DIR, stagingJobDir);
  fs = mock(FileSystem.class);
  when(fs.delete(any(Path.class), anyBoolean())).thenReturn(true);
  //Staging Dir exists
  String user = UserGroupInformation.getCurrentUser().getShortUserName();
  Path stagingDir = MRApps.getStagingAreaDir(conf, user);
  when(fs.exists(stagingDir)).thenReturn(true);
  ApplicationId appId = ApplicationId.newInstance(System.currentTimeMillis(),
      0);
  ApplicationAttemptId attemptId = ApplicationAttemptId.newInstance(appId, 1);
  JobId jobid = recordFactory.newRecordInstance(JobId.class);
  jobid.setAppId(appId);
  ContainerAllocator mockAlloc = mock(ContainerAllocator.class);
  MRAppMaster appMaster = new TestMRApp(attemptId, mockAlloc); //no retry
  appMaster.init(conf);
  assertTrue("appMaster.isLastAMRetry() is false", appMaster.isLastAMRetry());
  //simulate the process being killed
  MRAppMaster.MRAppMasterShutdownHook hook = 
    new MRAppMaster.MRAppMasterShutdownHook(appMaster);
  hook.run();
  assertTrue("MRAppMaster isn't stopped",
             appMaster.isInState(Service.STATE.STOPPED));
  verify(fs).delete(stagingJobPath, true);
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
@Override
protected void serviceStart() throws Exception {
  hsManager.start();
  if (storage instanceof Service) {
    ((Service) storage).start();
  }

  scheduledExecutor = new ScheduledThreadPoolExecutor(2,
      new ThreadFactoryBuilder().setNameFormat("Log Scanner/Cleaner #%d")
          .build());

  scheduledExecutor.scheduleAtFixedRate(new MoveIntermediateToDoneRunnable(),
      moveThreadInterval, moveThreadInterval, TimeUnit.MILLISECONDS);

  // Start historyCleaner
  scheduleHistoryCleaner();
  super.serviceStart();
}
 

import org.apache.hadoop.service.Service; //导入依赖的package包/类
@Override
public void removeFromClusterNodeLabels(Collection<String> labelsToRemove)
    throws IOException {
  try {
    writeLock.lock();
    if (getServiceState() == Service.STATE.STARTED) {
      // We cannot remove node labels from collection when some queue(s) are
      // using any of them.
      // We will only do this check when service starting finished. Before
      // service starting, we will replay edit logs and recover state. It is
      // possible that a history operation removed some labels which were being
      // used by some queues in the past but not used by current queues.
      checkRemoveFromClusterNodeLabelsOfQueue(labelsToRemove);
    }
    // copy before NMs
    Map<String, Host> before = cloneNodeMap();

    super.removeFromClusterNodeLabels(labelsToRemove);

    updateResourceMappings(before, nodeCollections);
  } finally {
    writeLock.unlock();
  }
}