hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/service/TestGlobalStateChangeListener.java

/*
 * 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.service;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.service.AbstractService;
import org.apache.hadoop.service.LoggingStateChangeListener;
import org.apache.hadoop.service.Service;
import org.apache.hadoop.service.ServiceStateChangeListener;
import org.junit.After;
import org.junit.Test;

/**
 * Test global state changes. It is critical for all tests to clean up the
 * global listener afterwards to avoid interfering with follow-on tests.
 *
 * One listener, {@link #listener} is defined which is automatically
 * unregistered on cleanup. All other listeners must be unregistered in the
 * finally clauses of the tests.
 */
public class TestGlobalStateChangeListener extends ServiceAssert {

  BreakableStateChangeListener listener = new BreakableStateChangeListener("listener");


  private void register() {
    register(listener);
  }

  private boolean unregister() {
    return unregister(listener);
  }

  private void register(ServiceStateChangeListener l) {
    AbstractService.registerGlobalListener(l);
  }

  private boolean unregister(ServiceStateChangeListener l) {
    return AbstractService.unregisterGlobalListener(l);
  }

  /**
   * After every test case reset the list of global listeners.
   */
  @After
  public void cleanup() {
    AbstractService.resetGlobalListeners();
  }

  /**
   * Assert that the last state of the listener is that the test expected.
   * @param breakable a breakable listener
   * @param state the expected state
   */
  public void assertListenerState(BreakableStateChangeListener breakable,
                                  Service.STATE state) {
    assertEquals("Wrong state in " + breakable, state, breakable.getLastState());
  }

  /**
   * Assert that the number of state change notifications matches expectations.
   * @param breakable the listener
   * @param count the expected count.
   */
  public void assertListenerEventCount(BreakableStateChangeListener breakable,
                                       int count) {
    assertEquals("Wrong event count in " + breakable, count,
                 breakable.getEventCount());
  }

  /**
   * Test that register/unregister works
   */
  @Test
  public void testRegisterListener() {
    register();
    assertTrue("listener not registered", unregister());
  }

  /**
   * Test that double registration results in one registration only.
   */
  @Test
  public void testRegisterListenerTwice() {
    register();
    register();
    assertTrue("listener not registered", unregister());
    //there should be no listener to unregister the second time
    assertFalse("listener double registered", unregister());
  }

  /**
   * 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);
  }

  /**
   * 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();
  }

  /**
   * Create a chain of listeners and set one in the middle to fail; verify that
   * those in front got called, and those after did not.
   */
  @Test
  public void testListenerChain() {

    //create and register the listeners
    LoggingStateChangeListener logListener = new LoggingStateChangeListener();
    register(logListener);
    BreakableStateChangeListener l0 = new BreakableStateChangeListener("l0");
    register(l0);
    listener.setFailingState(Service.STATE.STARTED);
    register();
    BreakableStateChangeListener l3 = new BreakableStateChangeListener("l3");
    register(l3);

    //create and init a service.
    BreakableService service = new BreakableService();
    service.init(new Configuration());
    assertServiceStateInited(service);
    assertListenerState(l0, Service.STATE.INITED);
    assertListenerState(listener, Service.STATE.INITED);
    assertListenerState(l3, Service.STATE.INITED);

    service.start();
    //expect that listener l1 and the failing listener are in start, but
    //not the final one
    assertServiceStateStarted(service);
    assertListenerState(l0, Service.STATE.STARTED);
    assertListenerEventCount(l0, 2);
    assertListenerState(listener, Service.STATE.STARTED);
    assertListenerEventCount(listener, 2);
    //this is the listener that is not expected to have been invoked
    assertListenerState(l3, Service.STATE.INITED);
    assertListenerEventCount(l3, 1);

    //stop the service
    service.stop();
    //listeners are all updated
    assertListenerEventCount(l0, 3);
    assertListenerEventCount(listener, 3);
    assertListenerEventCount(l3, 2);
    //can all be unregistered in any order
    unregister(logListener);
    unregister(l0);
    unregister(l3);

    //check that the listeners are all unregistered, even
    //though they were registered in a different order.
    //rather than do this by doing unregister checks, a new service is created
    service = new BreakableService();
    //this service is initialized
    service.init(new Configuration());
    //it is asserted that the event count has not changed for the unregistered
    //listeners
    assertListenerEventCount(l0, 3);
    assertListenerEventCount(l3, 2);
    //except for the one listener that was not unregistered, which
    //has incremented by one
    assertListenerEventCount(listener, 4);
  }

}