Java 类org.apache.hadoop.hdfs.protocol.RollingUpgradeInfo 实例源码

private static void printMessage(RollingUpgradeInfo info,
    PrintStream out) {
  if (info != null && info.isStarted()) {
    if (!info.createdRollbackImages() && !info.isFinalized()) {
      out.println(
          "Preparing for upgrade. Data is being saved for rollback."
          + "\nRun \"dfsadmin -rollingUpgrade query\" to check the status"
          + "\nfor proceeding with rolling upgrade");
        out.println(info);
    } else if (!info.isFinalized()) {
      out.println("Proceed with rolling upgrade:");
      out.println(info);
    } else {
      out.println("Rolling upgrade is finalized.");
      out.println(info);
    }
  } else {
    out.println("There is no rolling upgrade in progress or rolling " +
        "upgrade has already been finalized.");
  }
}

static int run(DistributedFileSystem dfs, String[] argv, int idx) throws IOException {
  final RollingUpgradeAction action = RollingUpgradeAction.fromString(
      argv.length >= 2? argv[1]: "");
  if (action == null) {
    throw new IllegalArgumentException("Failed to covert \"" + argv[1]
        +"\" to " + RollingUpgradeAction.class.getSimpleName());
  }

  System.out.println(action + " rolling upgrade ...");

  final RollingUpgradeInfo info = dfs.rollingUpgrade(action);
  switch(action){
  case QUERY:
    break;
  case PREPARE:
    Preconditions.checkState(info.isStarted());
    break;
  case FINALIZE:
    Preconditions.checkState(info == null || info.isFinalized());
    break;
  }
  printMessage(info, System.out);
  return 0;
}

static void queryForPreparation(DistributedFileSystem dfs) throws IOException,
    InterruptedException {
  RollingUpgradeInfo info;
  int retries = 0;
  while (++retries < 10) {
    info = dfs.rollingUpgrade(RollingUpgradeAction.QUERY);
    if (info.createdRollbackImages()) {
      break;
    }
    Thread.sleep(1000);
  }

  if (retries >= 10) {
    Assert.fail("Query return false");
  }
}

@Override
public RollingUpgradeInfo rollingUpgrade(RollingUpgradeAction action)
    throws IOException {
  final RollingUpgradeRequestProto r = RollingUpgradeRequestProto.newBuilder()
      .setAction(PBHelperClient.convert(action)).build();
  try {
    final RollingUpgradeResponseProto proto =
        rpcProxy.rollingUpgrade(null, r);
    if (proto.hasRollingUpgradeInfo()) {
      return PBHelperClient.convert(proto.getRollingUpgradeInfo());
    }
    return null;
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}

RollingUpgradeInfo queryRollingUpgrade() throws IOException {
  checkSuperuserPrivilege();
  checkOperation(OperationCategory.READ);
  readLock();
  try {
    if (!isRollingUpgrade()) {
      return null;
    }
    Preconditions.checkNotNull(rollingUpgradeInfo);
    boolean hasRollbackImage = this.getFSImage().hasRollbackFSImage();
    rollingUpgradeInfo.setCreatedRollbackImages(hasRollbackImage);
    return rollingUpgradeInfo;
  } finally {
    readUnlock();
  }
}

private static void printMessage(RollingUpgradeInfo info,
    PrintStream out) {
  if (info != null && info.isStarted()) {
    if (!info.createdRollbackImages() && !info.isFinalized()) {
      out.println(
          "Preparing for upgrade. Data is being saved for rollback."
          + "\nRun \"dfsadmin -rollingUpgrade query\" to check the status"
          + "\nfor proceeding with rolling upgrade");
        out.println(info);
    } else if (!info.isFinalized()) {
      out.println("Proceed with rolling upgrade:");
      out.println(info);
    } else {
      out.println("Rolling upgrade is finalized.");
      out.println(info);
    }
  } else {
    out.println("There is no rolling upgrade in progress or rolling " +
        "upgrade has already been finalized.");
  }
}

static int run(DistributedFileSystem dfs, String[] argv, int idx) throws IOException {
  final RollingUpgradeAction action = RollingUpgradeAction.fromString(
      argv.length >= 2? argv[1]: "");
  if (action == null) {
    throw new IllegalArgumentException("Failed to covert \"" + argv[1]
        +"\" to " + RollingUpgradeAction.class.getSimpleName());
  }

  System.out.println(action + " rolling upgrade ...");

  final RollingUpgradeInfo info = dfs.rollingUpgrade(action);
  switch(action){
  case QUERY:
    break;
  case PREPARE:
    Preconditions.checkState(info.isStarted());
    break;
  case FINALIZE:
    Preconditions.checkState(info == null || info.isFinalized());
    break;
  }
  printMessage(info, System.out);
  return 0;
}

static void queryForPreparation(DistributedFileSystem dfs) throws IOException,
    InterruptedException {
  RollingUpgradeInfo info;
  int retries = 0;
  while (++retries < 10) {
    info = dfs.rollingUpgrade(RollingUpgradeAction.QUERY);
    if (info.createdRollbackImages()) {
      break;
    }
    Thread.sleep(1000);
  }

  if (retries >= 10) {
    Assert.fail("Query return false");
  }
}

private static void printMessage(RollingUpgradeInfo info,
    PrintStream out) {
  if (info != null && info.isStarted()) {
    if (!info.createdRollbackImages() && !info.isFinalized()) {
      out.println(
          "Preparing for upgrade. Data is being saved for rollback."
          + "\nRun \"dfsadmin -rollingUpgrade query\" to check the status"
          + "\nfor proceeding with rolling upgrade");
        out.println(info);
    } else if (!info.isFinalized()) {
      out.println("Proceed with rolling upgrade:");
      out.println(info);
    } else {
      out.println("Rolling upgrade is finalized.");
      out.println(info);
    }
  } else {
    out.println("There is no rolling upgrade in progress or rolling " +
        "upgrade has already been finalized.");
  }
}

static int run(DistributedFileSystem dfs, String[] argv, int idx) throws IOException {
  final RollingUpgradeAction action = RollingUpgradeAction.fromString(
      argv.length >= 2? argv[1]: "");
  if (action == null) {
    throw new IllegalArgumentException("Failed to covert \"" + argv[1]
        +"\" to " + RollingUpgradeAction.class.getSimpleName());
  }

  System.out.println(action + " rolling upgrade ...");

  final RollingUpgradeInfo info = dfs.rollingUpgrade(action);
  switch(action){
  case QUERY:
    break;
  case PREPARE:
    Preconditions.checkState(info.isStarted());
    break;
  case FINALIZE:
    Preconditions.checkState(info == null || info.isFinalized());
    break;
  }
  printMessage(info, System.out);
  return 0;
}

static void queryForPreparation(DistributedFileSystem dfs) throws IOException,
    InterruptedException {
  RollingUpgradeInfo info;
  int retries = 0;
  while (++retries < 10) {
    info = dfs.rollingUpgrade(RollingUpgradeAction.QUERY);
    if (info.createdRollbackImages()) {
      break;
    }
    Thread.sleep(1000);
  }

  if (retries >= 10) {
    Assert.fail("Query return false");
  }
}

private static void printMessage(RollingUpgradeInfo info,
    PrintStream out) {
  if (info != null && info.isStarted()) {
    if (!info.createdRollbackImages() && !info.isFinalized()) {
      out.println(
          "Preparing for upgrade. Data is being saved for rollback."
          + "\nRun \"dfsadmin -rollingUpgrade query\" to check the status"
          + "\nfor proceeding with rolling upgrade");
        out.println(info);
    } else if (!info.isFinalized()) {
      out.println("Proceed with rolling upgrade:");
      out.println(info);
    } else {
      out.println("Rolling upgrade is finalized.");
      out.println(info);
    }
  } else {
    out.println("There is no rolling upgrade in progress or rolling " +
        "upgrade has already been finalized.");
  }
}

static int run(DistributedFileSystem dfs, String[] argv, int idx) throws IOException {
  final RollingUpgradeAction action = RollingUpgradeAction.fromString(
      argv.length >= 2? argv[1]: "");
  if (action == null) {
    throw new IllegalArgumentException("Failed to covert \"" + argv[1]
        +"\" to " + RollingUpgradeAction.class.getSimpleName());
  }

  System.out.println(action + " rolling upgrade ...");

  final RollingUpgradeInfo info = dfs.rollingUpgrade(action);
  switch(action){
  case QUERY:
    break;
  case PREPARE:
    Preconditions.checkState(info.isStarted());
    break;
  case FINALIZE:
    Preconditions.checkState(info == null || info.isFinalized());
    break;
  }
  printMessage(info, System.out);
  return 0;
}

static void queryForPreparation(DistributedFileSystem dfs) throws IOException,
    InterruptedException {
  RollingUpgradeInfo info;
  int retries = 0;
  while (++retries < 10) {
    info = dfs.rollingUpgrade(RollingUpgradeAction.QUERY);
    if (info.createdRollbackImages()) {
      break;
    }
    Thread.sleep(1000);
  }

  if (retries >= 10) {
    Assert.fail("Query return false");
  }
}

private static void printMessage(RollingUpgradeInfo info,
    PrintStream out) {
  if (info != null && info.isStarted()) {
    if (!info.createdRollbackImages()) {
      out.println(
          "Preparing for upgrade. Data is being saved for rollback."
          + "\nRun \"dfsadmin -rollingUpgrade query\" to check the status"
          + "\nfor proceeding with rolling upgrade");
        out.println(info);
    } else if (!info.isFinalized()) {
      out.println("Proceed with rolling upgrade:");
      out.println(info);
    } else {
      out.println("Rolling upgrade is finalized.");
      out.println(info);
    }
  } else {
    out.println("There is no rolling upgrade in progress or rolling " +
        "upgrade has already been finalized.");
  }
}

static int run(DistributedFileSystem dfs, String[] argv, int idx) throws IOException {
  final RollingUpgradeAction action = RollingUpgradeAction.fromString(
      argv.length >= 2? argv[1]: "");
  if (action == null) {
    throw new IllegalArgumentException("Failed to covert \"" + argv[1]
        +"\" to " + RollingUpgradeAction.class.getSimpleName());
  }

  System.out.println(action + " rolling upgrade ...");

  final RollingUpgradeInfo info = dfs.rollingUpgrade(action);
  switch(action){
  case QUERY:
    break;
  case PREPARE:
    Preconditions.checkState(info.isStarted());
    break;
  case FINALIZE:
    Preconditions.checkState(info == null || info.isFinalized());
    break;
  }
  printMessage(info, System.out);
  return 0;
}

static void queryForPreparation(DistributedFileSystem dfs) throws IOException,
    InterruptedException {
  RollingUpgradeInfo info;
  int retries = 0;
  while (++retries < 10) {
    info = dfs.rollingUpgrade(RollingUpgradeAction.QUERY);
    if (info.createdRollbackImages()) {
      break;
    }
    Thread.sleep(1000);
  }

  if (retries >= 10) {
    Assert.fail("Query return false");
  }
}

RollingUpgradeInfo finalizeRollingUpgrade() throws IOException {
  checkSuperuserPrivilege();
  checkOperation(OperationCategory.WRITE);
  writeLock();
  final RollingUpgradeInfo returnInfo;
  try {
    checkOperation(OperationCategory.WRITE);
    checkNameNodeSafeMode("Failed to finalize rolling upgrade");

    returnInfo = finalizeRollingUpgradeInternal(now());
    getEditLog().logFinalizeRollingUpgrade(returnInfo.getFinalizeTime());
    getFSImage().saveNamespace(this);
    getFSImage().renameCheckpoint(NameNodeFile.IMAGE_ROLLBACK,
        NameNodeFile.IMAGE);
  } finally {
    writeUnlock();
  }

  // getEditLog().logSync() is not needed since it does saveNamespace 

  if (auditLog.isInfoEnabled() && isExternalInvocation()) {
    logAuditEvent(true, "finalizeRollingUpgrade", null, null, null);
  }
  return returnInfo;
}

private static void printMessage(RollingUpgradeInfo info,
    PrintStream out) {
  if (info != null && info.isStarted()) {
    if (!info.createdRollbackImages()) {
      out.println(
          "Preparing for upgrade. Data is being saved for rollback."
          + "\nRun \"dfsadmin -rollingUpgrade query\" to check the status"
          + "\nfor proceeding with rolling upgrade");
        out.println(info);
    } else if (!info.isFinalized()) {
      out.println("Proceed with rolling upgrade:");
      out.println(info);
    } else {
      out.println("Rolling upgrade is finalized.");
      out.println(info);
    }
  } else {
    out.println("There is no rolling upgrade in progress.");
  }
}

static int run(DistributedFileSystem dfs, String[] argv, int idx) throws IOException {
  final RollingUpgradeAction action = RollingUpgradeAction.fromString(
      argv.length >= 2? argv[1]: "");
  if (action == null) {
    throw new IllegalArgumentException("Failed to covert \"" + argv[1]
        +"\" to " + RollingUpgradeAction.class.getSimpleName());
  }

  System.out.println(action + " rolling upgrade ...");

  final RollingUpgradeInfo info = dfs.rollingUpgrade(action);
  switch(action){
  case QUERY:
    break;
  case PREPARE:
    Preconditions.checkState(info.isStarted());
    break;
  case FINALIZE:
    Preconditions.checkState(info.isFinalized());
    break;
  }
  printMessage(info, System.out);
  return 0;
}

static void queryForPreparation(DistributedFileSystem dfs) throws IOException,
    InterruptedException {
  RollingUpgradeInfo info;
  int retries = 0;
  while (++retries < 10) {
    info = dfs.rollingUpgrade(RollingUpgradeAction.QUERY);
    if (info.createdRollbackImages()) {
      break;
    }
    Thread.sleep(1000);
  }

  if (retries >= 10) {
    Assert.fail("Query return false");
  }
}

RollingUpgradeInfo rollingUpgrade(RollingUpgradeAction action) throws IOException {
  TraceScope scope = Trace.startSpan("rollingUpgrade", traceSampler);
  try {
    return namenode.rollingUpgrade(action);
  } finally {
    scope.close();
  }
}

RollingUpgradeInfo queryRollingUpgrade() throws IOException {
  checkSuperuserPrivilege();
  checkOperation(OperationCategory.READ);
  readLock();
  try {
    if (rollingUpgradeInfo != null) {
      boolean hasRollbackImage = this.getFSImage().hasRollbackFSImage();
      rollingUpgradeInfo.setCreatedRollbackImages(hasRollbackImage);
    }
    return rollingUpgradeInfo;
  } finally {
    readUnlock();
  }
}

RollingUpgradeInfo startRollingUpgrade() throws IOException {
  checkSuperuserPrivilege();
  checkOperation(OperationCategory.WRITE);
  writeLock();
  try {
    checkOperation(OperationCategory.WRITE);
    if (isRollingUpgrade()) {
      return rollingUpgradeInfo;
    }
    long startTime = now();
    if (!haEnabled) { // for non-HA, we require NN to be in safemode
      startRollingUpgradeInternalForNonHA(startTime);
    } else { // for HA, NN cannot be in safemode
      checkNameNodeSafeMode("Failed to start rolling upgrade");
      startRollingUpgradeInternal(startTime);
    }

    getEditLog().logStartRollingUpgrade(rollingUpgradeInfo.getStartTime());
    if (haEnabled) {
      // roll the edit log to make sure the standby NameNode can tail
      getFSImage().rollEditLog();
    }
  } finally {
    writeUnlock();
  }

  getEditLog().logSync();
  if (auditLog.isInfoEnabled() && isExternalInvocation()) {
    logAuditEvent(true, "startRollingUpgrade", null, null, null);
  }
  return rollingUpgradeInfo;
}

@Override  // NameNodeMXBean
public RollingUpgradeInfo.Bean getRollingUpgradeStatus() {
  if (!isRollingUpgrade()) {
    return null;
  }
  RollingUpgradeInfo upgradeInfo = getRollingUpgradeInfo();
  if (upgradeInfo.createdRollbackImages()) {
    return new RollingUpgradeInfo.Bean(upgradeInfo);
  }
  readLock();
  try {
    // check again after acquiring the read lock.
    upgradeInfo = getRollingUpgradeInfo();
    if (upgradeInfo == null) {
      return null;
    }
    if (!upgradeInfo.createdRollbackImages()) {
      boolean hasRollbackImage = this.getFSImage().hasRollbackFSImage();
      upgradeInfo.setCreatedRollbackImages(hasRollbackImage);
    }
  } catch (IOException ioe) {
    LOG.warn("Encountered exception setting Rollback Image", ioe);
  } finally {
    readUnlock();
  }
  return new RollingUpgradeInfo.Bean(upgradeInfo);
}

RollingUpgradeInfo finalizeRollingUpgrade() throws IOException {
  checkSuperuserPrivilege();
  checkOperation(OperationCategory.WRITE);
  writeLock();
  final RollingUpgradeInfo returnInfo;
  try {
    checkOperation(OperationCategory.WRITE);
    if (!isRollingUpgrade()) {
      return null;
    }
    checkNameNodeSafeMode("Failed to finalize rolling upgrade");

    returnInfo = finalizeRollingUpgradeInternal(now());
    getEditLog().logFinalizeRollingUpgrade(returnInfo.getFinalizeTime());
    if (haEnabled) {
      // roll the edit log to make sure the standby NameNode can tail
      getFSImage().rollEditLog();
    }
    getFSImage().updateStorageVersion();
    getFSImage().renameCheckpoint(NameNodeFile.IMAGE_ROLLBACK,
        NameNodeFile.IMAGE);
  } finally {
    writeUnlock();
  }

  if (!haEnabled) {
    // Sync not needed for ha since the edit was rolled after logging.
    getEditLog().logSync();
  }

  if (auditLog.isInfoEnabled() && isExternalInvocation()) {
    logAuditEvent(true, "finalizeRollingUpgrade", null, null, null);
  }
  return returnInfo;
}

@Override // ClientProtocol
public RollingUpgradeInfo rollingUpgrade(RollingUpgradeAction action) throws IOException {
  checkNNStartup();
  LOG.info("rollingUpgrade " + action);
  switch(action) {
  case QUERY:
    return namesystem.queryRollingUpgrade();
  case PREPARE:
    return namesystem.startRollingUpgrade();
  case FINALIZE:
    return namesystem.finalizeRollingUpgrade();
  default:
    throw new UnsupportedActionException(action + " is not yet supported.");
  }
}

public static RollingUpgradeInfoProto convert(RollingUpgradeInfo info) {
  return RollingUpgradeInfoProto.newBuilder()
      .setStatus(convertRollingUpgradeStatus(info))
      .setCreatedRollbackImages(info.createdRollbackImages())
      .setStartTime(info.getStartTime())
      .setFinalizeTime(info.getFinalizeTime())
      .build();
}

@Override
public RollingUpgradeResponseProto rollingUpgrade(RpcController controller,
    RollingUpgradeRequestProto req) throws ServiceException {
  try {
    final RollingUpgradeInfo info = server.rollingUpgrade(
        PBHelper.convert(req.getAction()));
    final RollingUpgradeResponseProto.Builder b = RollingUpgradeResponseProto.newBuilder();
    if (info != null) {
      b.setRollingUpgradeInfo(PBHelper.convert(info));
    }
    return b.build();
  } catch (IOException e) {
    throw new ServiceException(e);
  }
}

@Override
public RollingUpgradeInfo rollingUpgrade(RollingUpgradeAction action) throws IOException {
  final RollingUpgradeRequestProto r = RollingUpgradeRequestProto.newBuilder()
      .setAction(PBHelper.convert(action)).build();
  try {
    final RollingUpgradeResponseProto proto = rpcProxy.rollingUpgrade(null, r);
    if (proto.hasRollingUpgradeInfo()) {
      return PBHelper.convert(proto.getRollingUpgradeInfo());
    }
    return null;
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}

@Test (timeout = 300000)
public void testQuery() throws Exception {
  final Configuration conf = new Configuration();
  MiniQJMHACluster cluster = null;
  try {
    cluster = new MiniQJMHACluster.Builder(conf).build();
    MiniDFSCluster dfsCluster = cluster.getDfsCluster();
    dfsCluster.waitActive();

    dfsCluster.transitionToActive(0);
    DistributedFileSystem dfs = dfsCluster.getFileSystem(0);

    dfsCluster.shutdownNameNode(1);

    // start rolling upgrade
    RollingUpgradeInfo info = dfs
        .rollingUpgrade(RollingUpgradeAction.PREPARE);
    Assert.assertTrue(info.isStarted());

    info = dfs.rollingUpgrade(RollingUpgradeAction.QUERY);
    Assert.assertFalse(info.createdRollbackImages());

    dfsCluster.restartNameNode(1);

    queryForPreparation(dfs);

    // The NN should have a copy of the fsimage in case of rollbacks.
    Assert.assertTrue(dfsCluster.getNamesystem(0).getFSImage()
        .hasRollbackFSImage());
  } finally {
    if (cluster != null) {
      cluster.shutdown();
    }
  }
}

RollingUpgradeInfo rollingUpgrade(RollingUpgradeAction action)
    throws IOException {
  checkOpen();
  try (TraceScope ignored = tracer.newScope("rollingUpgrade")) {
    return namenode.rollingUpgrade(action);
  }
}

public static RollingUpgradeInfoProto convert(RollingUpgradeInfo info) {
  return RollingUpgradeInfoProto.newBuilder()
      .setStatus(convertRollingUpgradeStatus(info))
      .setCreatedRollbackImages(info.createdRollbackImages())
      .setStartTime(info.getStartTime())
      .setFinalizeTime(info.getFinalizeTime())
      .build();
}

RollingUpgradeInfo startRollingUpgrade() throws IOException {
  checkSuperuserPrivilege();
  checkOperation(OperationCategory.WRITE);
  writeLock();
  try {
    checkOperation(OperationCategory.WRITE);
    if (isRollingUpgrade()) {
      return rollingUpgradeInfo;
    }
    long startTime = now();
    if (!haEnabled) { // for non-HA, we require NN to be in safemode
      startRollingUpgradeInternalForNonHA(startTime);
    } else { // for HA, NN cannot be in safemode
      checkNameNodeSafeMode("Failed to start rolling upgrade");
      startRollingUpgradeInternal(startTime);
    }

    getEditLog().logStartRollingUpgrade(rollingUpgradeInfo.getStartTime());
    if (haEnabled) {
      // roll the edit log to make sure the standby NameNode can tail
      getFSImage().rollEditLog(getEffectiveLayoutVersion());
    }
  } finally {
    writeUnlock();
  }

  getEditLog().logSync();
  if (auditLog.isInfoEnabled() && isExternalInvocation()) {
    logAuditEvent(true, "startRollingUpgrade", null, null, null);
  }
  return rollingUpgradeInfo;
}

@Override  // NameNodeMXBean
public RollingUpgradeInfo.Bean getRollingUpgradeStatus() {
  if (!isRollingUpgrade()) {
    return null;
  }
  RollingUpgradeInfo upgradeInfo = getRollingUpgradeInfo();
  if (upgradeInfo.createdRollbackImages()) {
    return new RollingUpgradeInfo.Bean(upgradeInfo);
  }
  readLock();
  try {
    // check again after acquiring the read lock.
    upgradeInfo = getRollingUpgradeInfo();
    if (upgradeInfo == null) {
      return null;
    }
    if (!upgradeInfo.createdRollbackImages()) {
      boolean hasRollbackImage = this.getFSImage().hasRollbackFSImage();
      upgradeInfo.setCreatedRollbackImages(hasRollbackImage);
    }
  } catch (IOException ioe) {
    LOG.warn("Encountered exception setting Rollback Image", ioe);
  } finally {
    readUnlock();
  }
  return new RollingUpgradeInfo.Bean(upgradeInfo);
}

RollingUpgradeInfo finalizeRollingUpgrade() throws IOException {
  checkSuperuserPrivilege();
  checkOperation(OperationCategory.WRITE);
  writeLock();
  try {
    checkOperation(OperationCategory.WRITE);
    if (!isRollingUpgrade()) {
      return null;
    }
    checkNameNodeSafeMode("Failed to finalize rolling upgrade");

    finalizeRollingUpgradeInternal(now());
    getEditLog().logFinalizeRollingUpgrade(rollingUpgradeInfo.getFinalizeTime());
    if (haEnabled) {
      // roll the edit log to make sure the standby NameNode can tail
      getFSImage().rollEditLog(getEffectiveLayoutVersion());
    }
    getFSImage().updateStorageVersion();
    getFSImage().renameCheckpoint(NameNodeFile.IMAGE_ROLLBACK,
        NameNodeFile.IMAGE);
  } finally {
    writeUnlock();
  }

  if (!haEnabled) {
    // Sync not needed for ha since the edit was rolled after logging.
    getEditLog().logSync();
  }

  if (auditLog.isInfoEnabled() && isExternalInvocation()) {
    logAuditEvent(true, "finalizeRollingUpgrade", null, null, null);
  }
  return rollingUpgradeInfo;
}

@Override // ClientProtocol
public RollingUpgradeInfo rollingUpgrade(RollingUpgradeAction action) throws IOException {
  checkNNStartup();
  LOG.info("rollingUpgrade " + action);
  switch(action) {
  case QUERY:
    return namesystem.queryRollingUpgrade();
  case PREPARE:
    return namesystem.startRollingUpgrade();
  case FINALIZE:
    return namesystem.finalizeRollingUpgrade();
  default:
    throw new UnsupportedActionException(action + " is not yet supported.");
  }
}

/**
 * @return true if an upgrade is in progress, false if not.
 * @throws IOException
 */
public boolean isUpgrading() throws IOException {
  // fsimage upgrade
  final boolean isUpgrade = !namenode.isUpgradeFinalized();
  // rolling upgrade
  RollingUpgradeInfo info = fs.rollingUpgrade(
      HdfsConstants.RollingUpgradeAction.QUERY);
  final boolean isRollingUpgrade = (info != null && !info.isFinalized());
  return (isUpgrade || isRollingUpgrade);
}

@Override
public RollingUpgradeResponseProto rollingUpgrade(RpcController controller,
    RollingUpgradeRequestProto req) throws ServiceException {
  try {
    final RollingUpgradeInfo info = server.rollingUpgrade(
        PBHelperClient.convert(req.getAction()));
    final RollingUpgradeResponseProto.Builder b = RollingUpgradeResponseProto.newBuilder();
    if (info != null) {
      b.setRollingUpgradeInfo(PBHelperClient.convert(info));
    }
    return b.build();
  } catch (IOException e) {
    throw new ServiceException(e);
  }
}

private void testQuery(int nnCount) throws Exception{
  final Configuration conf = new Configuration();
  MiniQJMHACluster cluster = null;
  try {
    cluster = new MiniQJMHACluster.Builder(conf).setNumNameNodes(nnCount).build();
    MiniDFSCluster dfsCluster = cluster.getDfsCluster();
    dfsCluster.waitActive();

    dfsCluster.transitionToActive(0);
    DistributedFileSystem dfs = dfsCluster.getFileSystem(0);

    // shutdown other NNs
    for (int i = 1; i < nnCount; i++) {
      dfsCluster.shutdownNameNode(i);
    }

    // start rolling upgrade
    RollingUpgradeInfo info = dfs
        .rollingUpgrade(RollingUpgradeAction.PREPARE);
    Assert.assertTrue(info.isStarted());

    info = dfs.rollingUpgrade(RollingUpgradeAction.QUERY);
    Assert.assertFalse(info.createdRollbackImages());

    // restart other NNs
    for (int i = 1; i < nnCount; i++) {
      dfsCluster.restartNameNode(i);
    }
    // check that one of the other NNs has created the rollback image and uploaded it
    queryForPreparation(dfs);

    // The NN should have a copy of the fsimage in case of rollbacks.
    Assert.assertTrue(dfsCluster.getNamesystem(0).getFSImage()
            .hasRollbackFSImage());
  } finally {
    if (cluster != null) {
      cluster.shutdown();
    }
  }
}