/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.hadoop.yarn.server.nodemanager.amrmproxy;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.security.Credentials;
import org.apache.hadoop.security.UserGroupInformation;
import org.apache.hadoop.security.token.Token;
import org.apache.hadoop.yarn.api.protocolrecords.AllocateRequest;
import org.apache.hadoop.yarn.api.protocolrecords.AllocateResponse;
import org.apache.hadoop.yarn.api.protocolrecords.FinishApplicationMasterRequest;
import org.apache.hadoop.yarn.api.protocolrecords.FinishApplicationMasterResponse;
import org.apache.hadoop.yarn.api.protocolrecords.RegisterApplicationMasterRequest;
import org.apache.hadoop.yarn.api.protocolrecords.RegisterApplicationMasterResponse;
import org.apache.hadoop.yarn.api.records.ApplicationAttemptId;
import org.apache.hadoop.yarn.api.records.ApplicationId;
import org.apache.hadoop.yarn.api.records.ContainerId;
import org.apache.hadoop.yarn.api.records.ContainerStatus;
import org.apache.hadoop.yarn.api.records.FinalApplicationStatus;
import org.apache.hadoop.yarn.api.records.NodeId;
import org.apache.hadoop.yarn.api.records.Priority;
import org.apache.hadoop.yarn.api.records.Resource;
import org.apache.hadoop.yarn.api.records.ResourceRequest;
import org.apache.hadoop.yarn.conf.YarnConfiguration;
import org.apache.hadoop.yarn.event.AsyncDispatcher;
import org.apache.hadoop.yarn.exceptions.YarnException;
import org.apache.hadoop.yarn.security.AMRMTokenIdentifier;
import org.apache.hadoop.yarn.server.api.protocolrecords.LogAggregationReport;
import org.apache.hadoop.yarn.server.api.records.AppCollectorData;
import org.apache.hadoop.yarn.server.api.records.NodeHealthStatus;
import org.apache.hadoop.yarn.server.nodemanager.ContainerExecutor;
import org.apache.hadoop.yarn.server.nodemanager.ContainerStateTransitionListener;
import org.apache.hadoop.yarn.server.nodemanager.Context;
import org.apache.hadoop.yarn.server.nodemanager.DeletionService;
import org.apache.hadoop.yarn.server.nodemanager.LocalDirsHandlerService;
import org.apache.hadoop.yarn.server.nodemanager.NodeManager.NMContext;
import org.apache.hadoop.yarn.server.nodemanager.NodeResourceMonitor;
import org.apache.hadoop.yarn.server.nodemanager.NodeStatusUpdater;
import org.apache.hadoop.yarn.server.nodemanager.containermanager.ContainerManager;
import org.apache.hadoop.yarn.server.nodemanager.containermanager.application.Application;
import org.apache.hadoop.yarn.server.nodemanager.containermanager.container.Container;
import org.apache.hadoop.yarn.server.nodemanager.containermanager.resourceplugin.ResourcePluginManager;
import org.apache.hadoop.yarn.server.nodemanager.logaggregation.tracker.NMLogAggregationStatusTracker;
import org.apache.hadoop.yarn.server.nodemanager.metrics.NodeManagerMetrics;
import org.apache.hadoop.yarn.server.nodemanager.recovery.NMMemoryStateStoreService;
import org.apache.hadoop.yarn.server.nodemanager.recovery.NMStateStoreService;
import org.apache.hadoop.yarn.server.nodemanager.recovery.NMStateStoreService.RecoveredAMRMProxyState;
import org.apache.hadoop.yarn.server.scheduler.OpportunisticContainerAllocator;
import org.apache.hadoop.yarn.server.nodemanager.security.NMContainerTokenSecretManager;
import org.apache.hadoop.yarn.server.nodemanager.security.NMTokenSecretManagerInNM;
import org.apache.hadoop.yarn.server.nodemanager.timelineservice.NMTimelinePublisher;
import org.apache.hadoop.yarn.server.security.ApplicationACLsManager;
import org.apache.hadoop.yarn.util.Records;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * Base class for all the AMRMProxyService test cases. It provides utility
 * methods that can be used by the concrete test case classes
 *
 */
public abstract class BaseAMRMProxyTest {
  private static final Logger LOG =
       LoggerFactory.getLogger(BaseAMRMProxyTest.class);
  // The AMRMProxyService instance that will be used by all the test cases
  private MockAMRMProxyService amrmProxyService;

  // Thread pool used for asynchronous operations
  private static ExecutorService threadpool = Executors
      .newCachedThreadPool();
  private Configuration conf;
  private AsyncDispatcher dispatcher;
  private Context nmContext;

  protected MockAMRMProxyService getAMRMProxyService() {
    Assert.assertNotNull(this.amrmProxyService);
    return this.amrmProxyService;
  }

  protected Context getNMContext() {
    Assert.assertNotNull(this.nmContext);
    return this.nmContext;
  }

  @Before
  public void setUp() throws IOException {
    this.conf = createConfiguration();
    this.dispatcher = new AsyncDispatcher();
    this.dispatcher.init(this.conf);
    this.dispatcher.start();
    createAndStartAMRMProxyService(this.conf);
  }

  protected YarnConfiguration createConfiguration() {
    YarnConfiguration config = new YarnConfiguration();
    config.setBoolean(YarnConfiguration.AMRM_PROXY_ENABLED, true);
    String mockPassThroughInterceptorClass =
        PassThroughRequestInterceptor.class.getName();

    // Create a request intercepter pipeline for testing. The last one in the
    // chain will call the mock resource manager. The others in the chain will
    // simply forward it to the next one in the chain
    config.set(YarnConfiguration.AMRM_PROXY_INTERCEPTOR_CLASS_PIPELINE,
        mockPassThroughInterceptorClass + "," + mockPassThroughInterceptorClass
            + "," + mockPassThroughInterceptorClass + ","
            + MockRequestInterceptor.class.getName());

    config.setBoolean(YarnConfiguration.NM_RECOVERY_ENABLED, true);
    return config;
  }

  @After
  public void tearDown() {
    this.amrmProxyService.stop();
    this.amrmProxyService = null;
    this.dispatcher.stop();
    if (this.nmContext.getNMStateStore() != null) {
      this.nmContext.getNMStateStore().stop();
    }
  }

  protected ExecutorService getThreadPool() {
    return threadpool;
  }

  protected Configuration getConf() {
    return this.conf;
  }

  protected AsyncDispatcher getDispatcher() {
    return this.dispatcher;
  }

  protected void createAndStartAMRMProxyService(Configuration config)
      throws IOException {
    // Stop the existing instance first if not null
    if (this.amrmProxyService != null) {
      this.amrmProxyService.stop();
    }
    if (this.nmContext == null) {
      this.nmContext = createContext();
    }
    this.amrmProxyService =
        new MockAMRMProxyService(this.nmContext, this.dispatcher);
    this.amrmProxyService.init(config);
    this.amrmProxyService.recover();
    this.amrmProxyService.start();
  }

  protected Context createContext() {
    NMMemoryStateStoreService stateStore = new NMMemoryStateStoreService();
    stateStore.init(this.conf);
    stateStore.start();
    return new NMContext(null, null, null, null, stateStore, false, this.conf);
  }

  // A utility method for intercepter recover unit test
  protected Map<String, byte[]> recoverDataMapForAppAttempt(
      NMStateStoreService nmStateStore, ApplicationAttemptId attemptId)
      throws IOException {
    RecoveredAMRMProxyState state = nmStateStore.loadAMRMProxyState();
    for (Map.Entry<ApplicationAttemptId, Map<String, byte[]>> entry : state
        .getAppContexts().entrySet()) {
      if (entry.getKey().equals(attemptId)) {
        return entry.getValue();
      }
    }
    return null;
  }

  protected List<ContainerId> getCompletedContainerIds(
      List<ContainerStatus> containerStatus) {
    List<ContainerId> ret = new ArrayList<>();
    for (ContainerStatus status : containerStatus) {
      ret.add(status.getContainerId());
    }
    return ret;
  }

  /**
   * This helper method will invoke the specified function in parallel for each
   * end point in the specified list using a thread pool and return the
   * responses received from the function. It implements the logic required for
   * dispatching requests in parallel and waiting for the responses. If any of
   * the function call fails or times out, it will ignore and proceed with the
   * rest. So the responses returned can be less than the number of end points
   * specified
   * 
   * @param testContexts
   * @param func
   * @return
   */
  protected <T, R> List<R> runInParallel(List<T> testContexts,
      final Function<T, R> func) {
    ExecutorCompletionService<R> completionService =
        new ExecutorCompletionService<R>(this.getThreadPool());
    LOG.info("Sending requests to endpoints asynchronously. Number of test contexts="
        + testContexts.size());
    for (int index = 0; index < testContexts.size(); index++) {
      final T testContext = testContexts.get(index);

      LOG.info("Adding request to threadpool for test context: "
          + testContext.toString());

      completionService.submit(new Callable<R>() {
        @Override
        public R call() throws Exception {
          LOG.info("Sending request. Test context:"
              + testContext.toString());

          R response = null;
          try {
            response = func.invoke(testContext);
            LOG.info("Successfully sent request for context: "
                + testContext.toString());
          } catch (Throwable ex) {
            LOG.error("Failed to process request for context: "
                + testContext);
            response = null;
          }

          return response;
        }
      });
    }

    ArrayList<R> responseList = new ArrayList<R>();
    LOG.info("Waiting for responses from endpoints. Number of contexts="
        + testContexts.size());
    for (int i = 0; i < testContexts.size(); ++i) {
      try {
        final Future<R> future = completionService.take();
        final R response = future.get(3000, TimeUnit.MILLISECONDS);
        responseList.add(response);
      } catch (Throwable e) {
        LOG.error("Failed to process request " + e.getMessage());
      }
    }

    return responseList;
  }

  /**
   * Helper method to register an application master using specified testAppId
   * as the application identifier and return the response
   * 
   * @param testAppId
   * @return
   * @throws Exception
   * @throws YarnException
   * @throws IOException
   */
  protected RegisterApplicationMasterResponse registerApplicationMaster(
      final int testAppId) throws Exception, YarnException, IOException {
    final ApplicationUserInfo ugi = getApplicationUserInfo(testAppId);

    return ugi
        .getUser()
        .doAs(
            new PrivilegedExceptionAction<RegisterApplicationMasterResponse>() {
              @Override
              public RegisterApplicationMasterResponse run()
                  throws Exception {
                getAMRMProxyService().initApp(
                    ugi.getAppAttemptId(),
                    ugi.getUser().getUserName());

                final RegisterApplicationMasterRequest req =
                    Records
                        .newRecord(RegisterApplicationMasterRequest.class);
                req.setHost(Integer.toString(testAppId));
                req.setRpcPort(testAppId);
                req.setTrackingUrl("");

                RegisterApplicationMasterResponse response =
                    getAMRMProxyService().registerApplicationMaster(req);
                return response;
              }
            });
  }

  /**
   * Helper method that can be used to register multiple application masters in
   * parallel to the specified RM end points
   * 
   * @param testContexts - used to identify the requests
   * @return
   */
  protected <T> List<RegisterApplicationMasterResponseInfo<T>> registerApplicationMastersInParallel(
      final ArrayList<T> testContexts) {
    List<RegisterApplicationMasterResponseInfo<T>> responses =
        runInParallel(testContexts,
            new Function<T, RegisterApplicationMasterResponseInfo<T>>() {
              @Override
              public RegisterApplicationMasterResponseInfo<T> invoke(
                  T testContext) {
                RegisterApplicationMasterResponseInfo<T> response = null;
                try {
                  int index = testContexts.indexOf(testContext);
                  response =
                      new RegisterApplicationMasterResponseInfo<T>(
                          registerApplicationMaster(index), testContext);
                  Assert.assertNotNull(response.getResponse());
                  Assert.assertEquals(Integer.toString(index), response
                      .getResponse().getQueue());

                  LOG.info("Sucessfully registered application master with test context: "
                      + testContext);
                } catch (Throwable ex) {
                  response = null;
                  LOG.error("Failed to register application master with test context: "
                      + testContext);
                }

                return response;
              }
            });

    Assert.assertEquals(
        "Number of responses received does not match with request",
        testContexts.size(), responses.size());

    Set<T> contextResponses = new TreeSet<T>();
    for (RegisterApplicationMasterResponseInfo<T> item : responses) {
      contextResponses.add(item.getTestContext());
    }

    for (T ep : testContexts) {
      Assert.assertTrue(contextResponses.contains(ep));
    }

    return responses;
  }

  /**
   * Unregisters the application master for specified application id
   * 
   * @param appId
   * @param status
   * @return
   * @throws Exception
   * @throws YarnException
   * @throws IOException
   */
  protected FinishApplicationMasterResponse finishApplicationMaster(
      final int appId, final FinalApplicationStatus status)
      throws Exception, YarnException, IOException {

    final ApplicationUserInfo ugi = getApplicationUserInfo(appId);

    return ugi.getUser().doAs(
        new PrivilegedExceptionAction<FinishApplicationMasterResponse>() {
          @Override
          public FinishApplicationMasterResponse run() throws Exception {
            final FinishApplicationMasterRequest req =
                Records.newRecord(FinishApplicationMasterRequest.class);
            req.setDiagnostics("");
            req.setTrackingUrl("");
            req.setFinalApplicationStatus(status);

            FinishApplicationMasterResponse response =
                getAMRMProxyService().finishApplicationMaster(req);

            getAMRMProxyService().stopApp(
                ugi.getAppAttemptId().getApplicationId());

            return response;
          }
        });
  }

  protected <T> List<FinishApplicationMasterResponseInfo<T>> finishApplicationMastersInParallel(
      final ArrayList<T> testContexts) {
    List<FinishApplicationMasterResponseInfo<T>> responses =
        runInParallel(testContexts,
            new Function<T, FinishApplicationMasterResponseInfo<T>>() {
              @Override
              public FinishApplicationMasterResponseInfo<T> invoke(
                  T testContext) {
                FinishApplicationMasterResponseInfo<T> response = null;
                try {
                  response =
                      new FinishApplicationMasterResponseInfo<T>(
                          finishApplicationMaster(
                              testContexts.indexOf(testContext),
                              FinalApplicationStatus.SUCCEEDED),
                          testContext);
                  Assert.assertNotNull(response.getResponse());

                  LOG.info("Sucessfully finished application master with test contexts: "
                      + testContext);
                } catch (Throwable ex) {
                  response = null;
                  LOG.error("Failed to finish application master with test context: "
                      + testContext);
                }

                return response;
              }
            });

    Assert.assertEquals(
        "Number of responses received does not match with request",
        testContexts.size(), responses.size());

    Set<T> contextResponses = new TreeSet<T>();
    for (FinishApplicationMasterResponseInfo<T> item : responses) {
      Assert.assertNotNull(item);
      Assert.assertNotNull(item.getResponse());
      contextResponses.add(item.getTestContext());
    }

    for (T ep : testContexts) {
      Assert.assertTrue(contextResponses.contains(ep));
    }

    return responses;
  }

  protected AllocateResponse allocate(final int testAppId)
      throws Exception, YarnException, IOException {
    final AllocateRequest req = Records.newRecord(AllocateRequest.class);
    req.setResponseId(testAppId);
    return allocate(testAppId, req);
  }

  protected AllocateResponse allocate(final int testAppId,
      final AllocateRequest request) throws Exception, YarnException,
      IOException {

    final ApplicationUserInfo ugi = getApplicationUserInfo(testAppId);

    return ugi.getUser().doAs(
        new PrivilegedExceptionAction<AllocateResponse>() {
          @Override
          public AllocateResponse run() throws Exception {
            AllocateResponse response =
                getAMRMProxyService().allocate(request);
            return response;
          }
        });
  }

  protected ApplicationUserInfo getApplicationUserInfo(final int testAppId) {
    final ApplicationAttemptId attemptId =
        getApplicationAttemptId(testAppId);

    UserGroupInformation ugi =
        UserGroupInformation.createRemoteUser(attemptId.toString());
    AMRMTokenIdentifier token = new AMRMTokenIdentifier(attemptId, 1);
    ugi.addTokenIdentifier(token);
    return new ApplicationUserInfo(ugi, attemptId);
  }

  protected List<ResourceRequest> createResourceRequests(String[] hosts,
      int memory, int vCores, int priority, int containers)
      throws Exception {
    return createResourceRequests(hosts, memory, vCores, priority,
        containers, null);
  }

  protected List<ResourceRequest> createResourceRequests(String[] hosts,
      int memory, int vCores, int priority, int containers,
      String labelExpression) throws Exception {
    List<ResourceRequest> reqs = new ArrayList<ResourceRequest>();
    for (String host : hosts) {
      ResourceRequest hostReq =
          createResourceRequest(host, memory, vCores, priority,
              containers, labelExpression);
      reqs.add(hostReq);
      ResourceRequest rackReq =
          createResourceRequest("/default-rack", memory, vCores, priority,
              containers, labelExpression);
      reqs.add(rackReq);
    }

    ResourceRequest offRackReq =
        createResourceRequest(ResourceRequest.ANY, memory, vCores,
            priority, containers, labelExpression);
    reqs.add(offRackReq);
    return reqs;
  }

  protected ResourceRequest createResourceRequest(String resource,
      int memory, int vCores, int priority, int containers)
      throws Exception {
    return createResourceRequest(resource, memory, vCores, priority,
        containers, null);
  }

  protected ResourceRequest createResourceRequest(String resource,
      int memory, int vCores, int priority, int containers,
      String labelExpression) throws Exception {
    ResourceRequest req = Records.newRecord(ResourceRequest.class);
    req.setResourceName(resource);
    req.setNumContainers(containers);
    Priority pri = Records.newRecord(Priority.class);
    pri.setPriority(priority);
    req.setPriority(pri);
    Resource capability = Records.newRecord(Resource.class);
    capability.setMemorySize(memory);
    capability.setVirtualCores(vCores);
    req.setCapability(capability);
    if (labelExpression != null) {
      req.setNodeLabelExpression(labelExpression);
    }
    return req;
  }

  /**
   * Returns an ApplicationId with the specified identifier
   * 
   * @param testAppId
   * @return
   */
  protected ApplicationId getApplicationId(int testAppId) {
    return ApplicationId.newInstance(123456, testAppId);
  }

  /**
   * Return an instance of ApplicationAttemptId using specified identifier. This
   * identifier will be used for the ApplicationId too.
   * 
   * @param testAppId
   * @return
   */
  protected ApplicationAttemptId getApplicationAttemptId(int testAppId) {
    return ApplicationAttemptId.newInstance(getApplicationId(testAppId),
        testAppId);
  }

  /**
   * Return an instance of ApplicationAttemptId using specified identifier and
   * application id
   * 
   * @param testAppId
   * @return
   */
  protected ApplicationAttemptId getApplicationAttemptId(int testAppId,
      ApplicationId appId) {
    return ApplicationAttemptId.newInstance(appId, testAppId);
  }

  protected static class RegisterApplicationMasterResponseInfo<T> {
    private RegisterApplicationMasterResponse response;
    private T testContext;

    RegisterApplicationMasterResponseInfo(
        RegisterApplicationMasterResponse response, T testContext) {
      this.response = response;
      this.testContext = testContext;
    }

    public RegisterApplicationMasterResponse getResponse() {
      return response;
    }

    public T getTestContext() {
      return testContext;
    }
  }

  protected static class FinishApplicationMasterResponseInfo<T> {
    private FinishApplicationMasterResponse response;
    private T testContext;

    FinishApplicationMasterResponseInfo(
        FinishApplicationMasterResponse response, T testContext) {
      this.response = response;
      this.testContext = testContext;
    }

    public FinishApplicationMasterResponse getResponse() {
      return response;
    }

    public T getTestContext() {
      return testContext;
    }
  }

  protected static class ApplicationUserInfo {
    private UserGroupInformation user;
    private ApplicationAttemptId attemptId;

    ApplicationUserInfo(UserGroupInformation user,
        ApplicationAttemptId attemptId) {
      this.user = user;
      this.attemptId = attemptId;
    }

    public UserGroupInformation getUser() {
      return this.user;
    }

    public ApplicationAttemptId getAppAttemptId() {
      return this.attemptId;
    }
  }

  protected static class MockAMRMProxyService extends AMRMProxyService {
    public MockAMRMProxyService(Context nmContext,
        AsyncDispatcher dispatcher) {
      super(nmContext, dispatcher);
    }

    @Override
    protected void serviceStart() throws Exception {
      // Override this method and do nothing to avoid the base class from
      // listening to server end point
      getSecretManager().start();
    }

    /**
     * This method is used by the test code to initialize the pipeline. In the
     * actual service, the initialization is called by the
     * ContainerManagerImpl::StartContainers method
     * 
     * @param applicationId
     * @param user
     */
    public void initApp(ApplicationAttemptId applicationId, String user) {
      super.initializePipeline(applicationId, user,
          new Token<AMRMTokenIdentifier>(), null, null, false, null);
    }

    public void stopApp(ApplicationId applicationId) {
      super.stopApplication(applicationId);
    }
  }

  /**
   * The Function interface is used for passing method pointers that can be
   * invoked asynchronously at a later point.
   */
  protected interface Function<T, R> {
    public R invoke(T input);
  }

  protected class NullContext implements Context {

    @Override
    public NodeId getNodeId() {
      return null;
    }

    @Override
    public int getHttpPort() {
      return 0;
    }

    @Override
    public ConcurrentMap<ApplicationId, Application> getApplications() {
      return null;
    }

    @Override
    public Map<ApplicationId, Credentials> getSystemCredentialsForApps() {
      return null;
    }

    @Override
    public ConcurrentMap<ApplicationId, AppCollectorData>
        getRegisteringCollectors() {
      return null;
    }

    @Override
    public ConcurrentMap<ApplicationId, AppCollectorData> getKnownCollectors() {
      return null;
    }

    @Override
    public ConcurrentMap<ContainerId, Container> getContainers() {
      return null;
    }

    @Override
    public ConcurrentMap<ContainerId, org.apache.hadoop.yarn.api.records.Container> getIncreasedContainers() {
      return null;
    }

    @Override
    public NMContainerTokenSecretManager getContainerTokenSecretManager() {
      return null;
    }

    @Override
    public NMTokenSecretManagerInNM getNMTokenSecretManager() {
      return null;
    }

    @Override
    public NodeHealthStatus getNodeHealthStatus() {
      return null;
    }

    @Override
    public ContainerManager getContainerManager() {
      return null;
    }

    @Override
    public LocalDirsHandlerService getLocalDirsHandler() {
      return null;
    }

    @Override
    public ApplicationACLsManager getApplicationACLsManager() {
      return null;
    }

    @Override
    public NMStateStoreService getNMStateStore() {
      return null;
    }

    @Override
    public boolean getDecommissioned() {
      return false;
    }

    @Override
    public Configuration getConf() {
      return null;
    }

    @Override
    public void setDecommissioned(boolean isDecommissioned) {
    }

    @Override
    public ConcurrentLinkedQueue<LogAggregationReport> getLogAggregationStatusForApps() {
      return null;
    }

    @Override
    public NodeResourceMonitor getNodeResourceMonitor() {
      return null;
    }

    @Override
    public NodeStatusUpdater getNodeStatusUpdater() {
      return null;
    }

    public boolean isDistributedSchedulingEnabled() {
      return false;
    }

    @Override
    public OpportunisticContainerAllocator getContainerAllocator() {
      return null;
    }

    public void setNMTimelinePublisher(NMTimelinePublisher nmMetricsPublisher) {
    }

    @Override
    public NMTimelinePublisher getNMTimelinePublisher() {
      return  null;
    }

    @Override
    public ContainerExecutor getContainerExecutor() {
      return null;
    }

    @Override
    public ContainerStateTransitionListener
        getContainerStateTransitionListener() {
      return null;
    }

    public ResourcePluginManager getResourcePluginManager() {
      return null;
    }

    @Override
    public NodeManagerMetrics getNodeManagerMetrics() {
      return null;
    }

    @Override
    public DeletionService getDeletionService() {
      return null;
    }

    @Override
    public NMLogAggregationStatusTracker getNMLogAggregationStatusTracker() {
      return null;
    }
  }
}
