import org.apache.hadoop.ipc.RefreshRegistry; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  // Register Handlers, first one just sends an ok response
  firstHandler = Mockito.mock(RefreshHandler.class);
  Mockito.stub(firstHandler.handleRefresh(Mockito.anyString(), Mockito.any(String[].class)))
    .toReturn(RefreshResponse.successResponse());
  RefreshRegistry.defaultRegistry().register("firstHandler", firstHandler);

  // Second handler has conditional response for testing args
  secondHandler = Mockito.mock(RefreshHandler.class);
  Mockito.stub(secondHandler.handleRefresh("secondHandler", new String[]{"one", "two"}))
    .toReturn(new RefreshResponse(3, "three"));
  Mockito.stub(secondHandler.handleRefresh("secondHandler", new String[]{"one"}))
    .toReturn(new RefreshResponse(2, "two"));
  RefreshRegistry.defaultRegistry().register("secondHandler", secondHandler);
}
 

import org.apache.hadoop.ipc.RefreshRegistry; //导入依赖的package包/类
@Test
public void testMultipleRegistration() throws Exception {
  RefreshRegistry.defaultRegistry().register("sharedId", firstHandler);
  RefreshRegistry.defaultRegistry().register("sharedId", secondHandler);

  // this should trigger both
  DFSAdmin admin = new DFSAdmin(config);
  String[] args = new String[]{"-refresh", "localhost:" +
      cluster.getNameNodePort(), "sharedId", "one"};
  int exitCode = admin.run(args);
  assertEquals(-1, exitCode); // -1 because one of the responses is unregistered

  // verify we called both
  Mockito.verify(firstHandler).handleRefresh("sharedId", new String[]{"one"});
  Mockito.verify(secondHandler).handleRefresh("sharedId", new String[]{"one"});

  RefreshRegistry.defaultRegistry().unregisterAll("sharedId");
}
 

import org.apache.hadoop.ipc.RefreshRegistry; //导入依赖的package包/类
@Test
public void testExceptionResultsInNormalError() throws Exception {
  // In this test, we ensure that all handlers are called even if we throw an exception in one
  RefreshHandler exceptionalHandler = Mockito.mock(RefreshHandler.class);
  Mockito.stub(exceptionalHandler.handleRefresh(Mockito.anyString(), Mockito.any(String[].class)))
    .toThrow(new RuntimeException("Exceptional Handler Throws Exception"));

  RefreshHandler otherExceptionalHandler = Mockito.mock(RefreshHandler.class);
  Mockito.stub(otherExceptionalHandler.handleRefresh(Mockito.anyString(), Mockito.any(String[].class)))
    .toThrow(new RuntimeException("More Exceptions"));

  RefreshRegistry.defaultRegistry().register("exceptional", exceptionalHandler);
  RefreshRegistry.defaultRegistry().register("exceptional", otherExceptionalHandler);

  DFSAdmin admin = new DFSAdmin(config);
  String[] args = new String[]{"-refresh", "localhost:" +
      cluster.getNameNodePort(), "exceptional"};
  int exitCode = admin.run(args);
  assertEquals(-1, exitCode); // Exceptions result in a -1

  Mockito.verify(exceptionalHandler).handleRefresh("exceptional", new String[]{});
  Mockito.verify(otherExceptionalHandler).handleRefresh("exceptional", new String[]{});

  RefreshRegistry.defaultRegistry().unregisterAll("exceptional");
}
 

import org.apache.hadoop.ipc.RefreshRegistry; //导入依赖的package包/类
@Test
public void testUnregistration() throws Exception {
  RefreshRegistry.defaultRegistry().unregisterAll("firstHandler");

  // And now this should fail
  DFSAdmin admin = new DFSAdmin(config);
  String[] args = new String[]{"-refresh", "localhost:" +
      cluster.getNameNodePort(), "firstHandler"};
  int exitCode = admin.run(args);
  assertEquals("DFSAdmin should return -1", -1, exitCode);
}
 

import org.apache.hadoop.ipc.RefreshRegistry; //导入依赖的package包/类
@Test
public void testUnregistrationReturnValue() {
  RefreshHandler mockHandler = Mockito.mock(RefreshHandler.class);
  RefreshRegistry.defaultRegistry().register("test", mockHandler);
  boolean ret = RefreshRegistry.defaultRegistry().unregister("test", mockHandler);
  assertTrue(ret);
}
 

import org.apache.hadoop.ipc.RefreshRegistry; //导入依赖的package包/类
@Test
public void testMultipleReturnCodeMerging() throws Exception {
  // Two handlers which return two non-zero values
  RefreshHandler handlerOne = Mockito.mock(RefreshHandler.class);
  Mockito.stub(handlerOne.handleRefresh(Mockito.anyString(), Mockito.any(String[].class)))
    .toReturn(new RefreshResponse(23, "Twenty Three"));

  RefreshHandler handlerTwo = Mockito.mock(RefreshHandler.class);
  Mockito.stub(handlerTwo.handleRefresh(Mockito.anyString(), Mockito.any(String[].class)))
    .toReturn(new RefreshResponse(10, "Ten"));

  // Then registered to the same ID
  RefreshRegistry.defaultRegistry().register("shared", handlerOne);
  RefreshRegistry.defaultRegistry().register("shared", handlerTwo);

  // We refresh both
  DFSAdmin admin = new DFSAdmin(config);
  String[] args = new String[]{"-refresh", "localhost:" +
      cluster.getNameNodePort(), "shared"};
  int exitCode = admin.run(args);
  assertEquals(-1, exitCode); // We get -1 because of our logic for melding non-zero return codes

  // Verify we called both
  Mockito.verify(handlerOne).handleRefresh("shared", new String[]{});
  Mockito.verify(handlerTwo).handleRefresh("shared", new String[]{});

  RefreshRegistry.defaultRegistry().unregisterAll("shared");
}
 

import org.apache.hadoop.ipc.RefreshRegistry; //导入依赖的package包/类
@Override // GenericRefreshProtocol
public Collection<RefreshResponse> refresh(String identifier, String[] args) {
  // Let the registry handle as needed
  return RefreshRegistry.defaultRegistry().dispatch(identifier, args);
}
 

import org.apache.hadoop.ipc.RefreshRegistry; //导入依赖的package包/类
@After
public void tearDown() throws Exception {
  RefreshRegistry.defaultRegistry().unregisterAll("firstHandler");
  RefreshRegistry.defaultRegistry().unregisterAll("secondHandler");
}