import org.apache.hadoop.ipc.RefreshResponse; //导入依赖的package包/类
@Override
public GenericRefreshResponseCollectionProto refresh(
    RpcController controller, GenericRefreshRequestProto request)
    throws ServiceException {
  try {
    List<String> argList = request.getArgsList();
    String[] args = argList.toArray(new String[argList.size()]);

    if (!request.hasIdentifier()) {
      throw new ServiceException("Request must contain identifier");
    }

    Collection<RefreshResponse> results = impl.refresh(request.getIdentifier(), args);

    return pack(results);
  } catch (IOException e) {
    throw new ServiceException(e);
  }
}
 

import org.apache.hadoop.ipc.RefreshResponse; //导入依赖的package包/类
private GenericRefreshResponseCollectionProto pack(
  Collection<RefreshResponse> responses) {
  GenericRefreshResponseCollectionProto.Builder b =
    GenericRefreshResponseCollectionProto.newBuilder();

  for (RefreshResponse response : responses) {
    GenericRefreshResponseProto.Builder respBuilder =
      GenericRefreshResponseProto.newBuilder();
    respBuilder.setExitStatus(response.getReturnCode());
    respBuilder.setUserMessage(response.getMessage());
    respBuilder.setSenderName(response.getSenderName());

    // Add to collection
    b.addResponses(respBuilder);
  }

  return b.build();
}
 

import org.apache.hadoop.ipc.RefreshResponse; //导入依赖的package包/类
@Override
public Collection<RefreshResponse> refresh(String identifier, String[] args) throws IOException {
  List<String> argList = Arrays.asList(args);

  try {
    GenericRefreshRequestProto request = GenericRefreshRequestProto.newBuilder()
      .setIdentifier(identifier)
      .addAllArgs(argList)
      .build();

    GenericRefreshResponseCollectionProto resp = rpcProxy.refresh(NULL_CONTROLLER, request);
    return unpack(resp);
  } catch (ServiceException se) {
    throw ProtobufHelper.getRemoteException(se);
  }
}
 

import org.apache.hadoop.ipc.RefreshResponse; //导入依赖的package包/类
private RefreshResponse unpack(GenericRefreshResponseProto proto) {
  // The default values
  String message = null;
  String sender = null;
  int returnCode = -1;

  // ... that can be overridden by data from the protobuf
  if (proto.hasUserMessage()) {
    message = proto.getUserMessage();
  }
  if (proto.hasExitStatus()) {
    returnCode = proto.getExitStatus();
  }
  if (proto.hasSenderName()) {
    sender = proto.getSenderName();
  }

  // ... and put into a RefreshResponse
  RefreshResponse response = new RefreshResponse(returnCode, message);
  response.setSenderName(sender);

  return response;
}
 

import org.apache.hadoop.ipc.RefreshResponse; //导入依赖的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.RefreshResponse; //导入依赖的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");
}