* 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.

*/

* Utilities for converting protobuf classes to and from implementation classes

* and other helper utilities to help in dealing with protobuf.

*

* Note that when converting from an internal type to protobuf type, the

* converter never return null for protobuf type. The check for internal type

* being null must be done before calling the convert() method.

*/

  private static final RegisterCommandProto REG_CMD_PROTO =

      RegisterCommandProto.newBuilder().build();

  private static final RegisterCommand REG_CMD = new RegisterCommand();

  private static final AclEntryScope[] ACL_ENTRY_SCOPE_VALUES =

      AclEntryScope.values();

  private static final AclEntryType[] ACL_ENTRY_TYPE_VALUES =

      AclEntryType.values();

  private static final FsAction[] FSACTION_VALUES =

      FsAction.values();

  private static final XAttr.NameSpace[] XATTR_NAMESPACE_VALUES =

      XAttr.NameSpace.values();

  private PBHelper() {

    /** Hidden constructor */

  }

  public static ByteString getByteString(byte[] bytes) {

    return ByteString.copyFrom(bytes);

  }

  private static <T extends Enum<T>, U extends Enum<U>> U castEnum(T from, U[] to) {

    return to[from.ordinal()];

  }

  public static NamenodeRole convert(NamenodeRoleProto role) {

    switch (role) {

    case NAMENODE:

      return NamenodeRole.NAMENODE;

    case BACKUP:

      return NamenodeRole.BACKUP;

    case CHECKPOINT:

      return NamenodeRole.CHECKPOINT;

    }

    return null;

  }

  public static NamenodeRoleProto convert(NamenodeRole role) {

    switch (role) {

    case NAMENODE:

      return NamenodeRoleProto.NAMENODE;

    case BACKUP:

      return NamenodeRoleProto.BACKUP;

    case CHECKPOINT:

      return NamenodeRoleProto.CHECKPOINT;

    }

    return null;

  }

  public static StorageInfoProto convert(StorageInfo info) {

    return StorageInfoProto.newBuilder().setClusterID(info.getClusterID())

        .setCTime(info.getCTime()).setLayoutVersion(info.getLayoutVersion())

        .setNamespceID(info.getNamespaceID()).build();

  }

  public static StorageInfo convert(StorageInfoProto info, NodeType type) {

    return new StorageInfo(info.getLayoutVersion(), info.getNamespceID(),

        info.getClusterID(), info.getCTime(), type);

  }

  public static NamenodeRegistrationProto convert(NamenodeRegistration reg) {

    return NamenodeRegistrationProto.newBuilder()

        .setHttpAddress(reg.getHttpAddress()).setRole(convert(reg.getRole()))

        .setRpcAddress(reg.getAddress())

        .setStorageInfo(convert((StorageInfo) reg)).build();

  }

  public static NamenodeRegistration convert(NamenodeRegistrationProto reg) {

    StorageInfo si = convert(reg.getStorageInfo(), NodeType.NAME_NODE);

    return new NamenodeRegistration(reg.getRpcAddress(), reg.getHttpAddress(),

        si, convert(reg.getRole()));

  }

  // DatanodeId

  public static DatanodeID convert(DatanodeIDProto dn) {

    return new DatanodeID(dn.getIpAddr(), dn.getHostName(), dn.getDatanodeUuid(),

        dn.getXferPort(), dn.getInfoPort(), dn.hasInfoSecurePort() ? dn

        .getInfoSecurePort() : 0, dn.getIpcPort());

  }

  public static DatanodeIDProto convert(DatanodeID dn) {

    // For wire compatibility with older versions we transmit the StorageID

    // which is the same as the DatanodeUuid. Since StorageID is a required

    // field we pass the empty string if the DatanodeUuid is not yet known.

    return DatanodeIDProto.newBuilder()

        .setIpAddr(dn.getIpAddr())

        .setHostName(dn.getHostName())

        .setXferPort(dn.getXferPort())

        .setDatanodeUuid(dn.getDatanodeUuid() != null ? dn.getDatanodeUuid() : "")

        .setInfoPort(dn.getInfoPort())

        .setInfoSecurePort(dn.getInfoSecurePort())

        .setIpcPort(dn.getIpcPort()).build();

  }

  // Arrays of DatanodeId

  public static DatanodeIDProto[] convert(DatanodeID[] did) {

    if (did == null)

      return null;

    final int len = did.length;

    DatanodeIDProto[] result = new DatanodeIDProto[len];

    for (int i = 0; i < len; ++i) {

      result[i] = convert(did[i]);

    }

    return result;

  }

 

  public static DatanodeID[] convert(DatanodeIDProto[] did) {

    if (did == null) return null;

    final int len = did.length;

    DatanodeID[] result = new DatanodeID[len];

    for (int i = 0; i < len; ++i) {

      result[i] = convert(did[i]);

    }

    return result;

  }

 

  // Block

  public static BlockProto convert(Block b) {

    return BlockProto.newBuilder().setBlockId(b.getBlockId())

        .setGenStamp(b.getGenerationStamp()).setNumBytes(b.getNumBytes())

        .build();

  }

  public static Block convert(BlockProto b) {

    return new Block(b.getBlockId(), b.getNumBytes(), b.getGenStamp());

  }

  public static BlockWithLocationsProto convert(BlockWithLocations blk) {

    return BlockWithLocationsProto.newBuilder()

        .setBlock(convert(blk.getBlock()))

        .addAllDatanodeUuids(Arrays.asList(blk.getDatanodeUuids()))

        .addAllStorageUuids(Arrays.asList(blk.getStorageIDs())).build();

  }

  public static BlockWithLocations convert(BlockWithLocationsProto b) {

    final List<String> datanodeUuids = b.getDatanodeUuidsList();

    final List<String> storageUuids = b.getStorageUuidsList();

    return new BlockWithLocations(convert(b.getBlock()),

        datanodeUuids.toArray(new String[datanodeUuids.size()]),

        storageUuids.toArray(new String[storageUuids.size()]));

  }

  public static BlocksWithLocationsProto convert(BlocksWithLocations blks) {

    BlocksWithLocationsProto.Builder builder = BlocksWithLocationsProto

        .newBuilder();

    for (BlockWithLocations b : blks.getBlocks()) {

      builder.addBlocks(convert(b));

    }

    return builder.build();

  }

  public static BlocksWithLocations convert(BlocksWithLocationsProto blocks) {

    List<BlockWithLocationsProto> b = blocks.getBlocksList();

    BlockWithLocations[] ret = new BlockWithLocations[b.size()];

    int i = 0;

    for (BlockWithLocationsProto entry : b) {

      ret[i++] = convert(entry);

    }

    return new BlocksWithLocations(ret);

  }

  public static BlockKeyProto convert(BlockKey key) {

    byte[] encodedKey = key.getEncodedKey();

    ByteString keyBytes = ByteString.copyFrom(encodedKey == null ?

        DFSUtil.EMPTY_BYTES : encodedKey);

    return BlockKeyProto.newBuilder().setKeyId(key.getKeyId())

        .setKeyBytes(keyBytes).setExpiryDate(key.getExpiryDate()).build();

  }

  public static BlockKey convert(BlockKeyProto k) {

    return new BlockKey(k.getKeyId(), k.getExpiryDate(), k.getKeyBytes()

        .toByteArray());

  }

  public static ExportedBlockKeysProto convert(ExportedBlockKeys keys) {

    ExportedBlockKeysProto.Builder builder = ExportedBlockKeysProto

        .newBuilder();

    builder.setIsBlockTokenEnabled(keys.isBlockTokenEnabled())

        .setKeyUpdateInterval(keys.getKeyUpdateInterval())

        .setTokenLifeTime(keys.getTokenLifetime())

        .setCurrentKey(convert(keys.getCurrentKey()));

    for (BlockKey k : keys.getAllKeys()) {

      builder.addAllKeys(convert(k));

    }

    return builder.build();

  }

  public static ExportedBlockKeys convert(ExportedBlockKeysProto keys) {

    return new ExportedBlockKeys(keys.getIsBlockTokenEnabled(),

        keys.getKeyUpdateInterval(), keys.getTokenLifeTime(),

        convert(keys.getCurrentKey()), convertBlockKeys(keys.getAllKeysList()));

  }

  public static CheckpointSignatureProto convert(CheckpointSignature s) {

    return CheckpointSignatureProto.newBuilder()

        .setBlockPoolId(s.getBlockpoolID())

        .setCurSegmentTxId(s.getCurSegmentTxId())

        .setMostRecentCheckpointTxId(s.getMostRecentCheckpointTxId())

        .setStorageInfo(PBHelper.convert((StorageInfo) s)).build();

  }

  public static CheckpointSignature convert(CheckpointSignatureProto s) {

    StorageInfo si = PBHelper.convert(s.getStorageInfo(), NodeType.NAME_NODE);

    return new CheckpointSignature(si, s.getBlockPoolId(),

        s.getMostRecentCheckpointTxId(), s.getCurSegmentTxId());

  }

  public static RemoteEditLogProto convert(RemoteEditLog log) {

    return RemoteEditLogProto.newBuilder()

        .setStartTxId(log.getStartTxId())

        .setEndTxId(log.getEndTxId())

        .setIsInProgress(log.isInProgress()).build();

  }

  public static RemoteEditLog convert(RemoteEditLogProto l) {

    return new RemoteEditLog(l.getStartTxId(), l.getEndTxId(),

        l.getIsInProgress());

  }

  public static RemoteEditLogManifestProto convert(

      RemoteEditLogManifest manifest) {

    RemoteEditLogManifestProto.Builder builder = RemoteEditLogManifestProto

        .newBuilder();

    for (RemoteEditLog log : manifest.getLogs()) {

      builder.addLogs(convert(log));

    }

    return builder.build();

  }

  public static RemoteEditLogManifest convert(

      RemoteEditLogManifestProto manifest) {

    List<RemoteEditLog> logs = new ArrayList<RemoteEditLog>(manifest

        .getLogsList().size());

    for (RemoteEditLogProto l : manifest.getLogsList()) {

      logs.add(convert(l));

    }

    return new RemoteEditLogManifest(logs);

  }

  public static CheckpointCommandProto convert(CheckpointCommand cmd) {

    return CheckpointCommandProto.newBuilder()

        .setSignature(convert(cmd.getSignature()))

        .setNeedToReturnImage(cmd.needToReturnImage()).build();

  }

  public static NamenodeCommandProto convert(NamenodeCommand cmd) {

    if (cmd instanceof CheckpointCommand) {

      return NamenodeCommandProto.newBuilder().setAction(cmd.getAction())

          .setType(NamenodeCommandProto.Type.CheckPointCommand)

          .setCheckpointCmd(convert((CheckpointCommand) cmd)).build();

    }

    return NamenodeCommandProto.newBuilder()

        .setType(NamenodeCommandProto.Type.NamenodeCommand)

        .setAction(cmd.getAction()).build();

  }

  public static BlockKey[] convertBlockKeys(List<BlockKeyProto> list) {

    BlockKey[] ret = new BlockKey[list.size()];

    int i = 0;

    for (BlockKeyProto k : list) {

      ret[i++] = convert(k);

    }

    return ret;

  }

  public static NamespaceInfo convert(NamespaceInfoProto info) {

    StorageInfoProto storage = info.getStorageInfo();

    return new NamespaceInfo(storage.getNamespceID(), storage.getClusterID(),

        info.getBlockPoolID(), storage.getCTime(), info.getBuildVersion(),

        info.getSoftwareVersion());

  }

  public static NamenodeCommand convert(NamenodeCommandProto cmd) {

    if (cmd == null) return null;

    switch (cmd.getType()) {

    case CheckPointCommand:

      CheckpointCommandProto chkPt = cmd.getCheckpointCmd();

      return new CheckpointCommand(PBHelper.convert(chkPt.getSignature()),

          chkPt.getNeedToReturnImage());

    default:

      return new NamenodeCommand(cmd.getAction());

    }

  }

 

  public static ExtendedBlock convert(ExtendedBlockProto eb) {

    if (eb == null) return null;

    return new ExtendedBlock( eb.getPoolId(),  eb.getBlockId(),   eb.getNumBytes(),

       eb.getGenerationStamp());

  }

 

  public static ExtendedBlockProto convert(final ExtendedBlock b) {

    if (b == null) return null;

   return ExtendedBlockProto.newBuilder().

      setPoolId(b.getBlockPoolId()).

      setBlockId(b.getBlockId()).

      setNumBytes(b.getNumBytes()).

      setGenerationStamp(b.getGenerationStamp()).

      build();

  }

 

  public static RecoveringBlockProto convert(RecoveringBlock b) {

    if (b == null) {

      return null;

    }

    LocatedBlockProto lb = PBHelper.convert((LocatedBlock)b);

    return RecoveringBlockProto.newBuilder().setBlock(lb)

        .setNewGenStamp(b.getNewGenerationStamp()).build();

  }

  public static RecoveringBlock convert(RecoveringBlockProto b) {

    ExtendedBlock block = convert(b.getBlock().getB());

    DatanodeInfo[] locs = convert(b.getBlock().getLocsList());

    return new RecoveringBlock(block, locs, b.getNewGenStamp());

  }

 

  public static DatanodeInfoProto.AdminState convert(

      final DatanodeInfo.AdminStates inAs) {

    switch (inAs) {

    case NORMAL: return  DatanodeInfoProto.AdminState.NORMAL;

    case DECOMMISSION_INPROGRESS:

        return DatanodeInfoProto.AdminState.DECOMMISSION_INPROGRESS;

    case DECOMMISSIONED: return DatanodeInfoProto.AdminState.DECOMMISSIONED;

    default: return DatanodeInfoProto.AdminState.NORMAL;

    }

  }

 

  static public DatanodeInfo convert(DatanodeInfoProto di) {

    if (di == null) return null;

    return new DatanodeInfo(

        PBHelper.convert(di.getId()),

        di.hasLocation() ? di.getLocation() : null ,

        di.getCapacity(),  di.getDfsUsed(),  di.getRemaining(),

        di.getBlockPoolUsed(), di.getCacheCapacity(), di.getCacheUsed(),

        di.getLastUpdate(), di.getXceiverCount(),

        PBHelper.convert(di.getAdminState()));

  }

 

  static public DatanodeInfoProto convertDatanodeInfo(DatanodeInfo di) {

    if (di == null) return null;

    return convert(di);

  }

 

 

  static public DatanodeInfo[] convert(DatanodeInfoProto di[]) {

    if (di == null) return null;

    DatanodeInfo[] result = new DatanodeInfo[di.length];

    for (int i = 0; i < di.length; i++) {

      result[i] = convert(di[i]);

    }   

    return result;

  }

  public static List<? extends HdfsProtos.DatanodeInfoProto> convert(

      DatanodeInfo[] dnInfos) {

    return convert(dnInfos, 0);

  }

 

  /**

   * Copy from {@code dnInfos} to a target of list of same size starting at

   * {@code startIdx}.

   */

  public static List<? extends HdfsProtos.DatanodeInfoProto> convert(

      DatanodeInfo[] dnInfos, int startIdx) {

    if (dnInfos == null)

      return null;

    ArrayList<HdfsProtos.DatanodeInfoProto> protos = Lists

        .newArrayListWithCapacity(dnInfos.length);

    for (int i = startIdx; i < dnInfos.length; i++) {

      protos.add(convert(dnInfos[i]));

    }

    return protos;

  }

  public static DatanodeInfo[] convert(List<DatanodeInfoProto> list) {

    DatanodeInfo[] info = new DatanodeInfo[list.size()];

    for (int i = 0; i < info.length; i++) {

      info[i] = convert(list.get(i));

    }

    return info;

  }

 

  public static DatanodeInfoProto convert(DatanodeInfo info) {

    DatanodeInfoProto.Builder builder = DatanodeInfoProto.newBuilder();

    if (info.getNetworkLocation() != null) {

      builder.setLocation(info.getNetworkLocation());

    }

    builder

        .setId(PBHelper.convert((DatanodeID)info))

        .setCapacity(info.getCapacity())

        .setDfsUsed(info.getDfsUsed())

        .setRemaining(info.getRemaining())

        .setBlockPoolUsed(info.getBlockPoolUsed())

        .setCacheCapacity(info.getCacheCapacity())

        .setCacheUsed(info.getCacheUsed())

        .setLastUpdate(info.getLastUpdate())

        .setXceiverCount(info.getXceiverCount())

        .setAdminState(PBHelper.convert(info.getAdminState()))

        .build();

    return builder.build();

  }

  public static AdminStates convert(AdminState adminState) {

    switch(adminState) {

    case DECOMMISSION_INPROGRESS:

      return AdminStates.DECOMMISSION_INPROGRESS;

    case DECOMMISSIONED:

      return AdminStates.DECOMMISSIONED;

    case NORMAL:

    default:

      return AdminStates.NORMAL;

    }

  }

 

  public static LocatedBlockProto convert(LocatedBlock b) {

    if (b == null) return null;

    Builder builder = LocatedBlockProto.newBuilder();

    DatanodeInfo[] locs = b.getLocations();

    List<DatanodeInfo> cachedLocs =

        Lists.newLinkedList(Arrays.asList(b.getCachedLocations()));

    for (int i = 0; i < locs.length; i++) {

      DatanodeInfo loc = locs[i];

      builder.addLocs(i, PBHelper.convert(loc));

      boolean locIsCached = cachedLocs.contains(loc);

      builder.addIsCached(locIsCached);

      if (locIsCached) {

        cachedLocs.remove(loc);

      }

    }

    Preconditions.checkArgument(cachedLocs.size() == 0,

        "Found additional cached replica locations that are not in the set of"

        + " storage-backed locations!");

    StorageType[] storageTypes = b.getStorageTypes();

    if (storageTypes != null) {

      for (int i = 0; i < storageTypes.length; ++i) {

        builder.addStorageTypes(PBHelper.convertStorageType(storageTypes[i]));

      }

    }

    final String[] storageIDs = b.getStorageIDs();

    if (storageIDs != null) {

      builder.addAllStorageIDs(Arrays.asList(storageIDs));

    }

    return builder.setB(PBHelper.convert(b.getBlock()))

        .setBlockToken(PBHelper.convert(b.getBlockToken()))

        .setCorrupt(b.isCorrupt()).setOffset(b.getStartOffset()).build();

  }

 

  public static LocatedBlock convert(LocatedBlockProto proto) {

    if (proto == null) return null;

    List<DatanodeInfoProto> locs = proto.getLocsList();

    DatanodeInfo[] targets = new DatanodeInfo[locs.size()];

    for (int i = 0; i < locs.size(); i++) {

      targets[i] = PBHelper.convert(locs.get(i));

    }

    final int storageTypesCount = proto.getStorageTypesCount();

    final StorageType[] storageTypes;

    if (storageTypesCount == 0) {

      storageTypes = null;

    } else {

      Preconditions.checkState(storageTypesCount == locs.size());

      storageTypes = convertStorageTypeProtos(proto.getStorageTypesList());

    }

    final int storageIDsCount = proto.getStorageIDsCount();

    final String[] storageIDs;

    if (storageIDsCount == 0) {

      storageIDs = null;

    } else {

      Preconditions.checkState(storageIDsCount == locs.size());

      storageIDs = proto.getStorageIDsList().toArray(new String[storageIDsCount]);

    }

    // Set values from the isCached list, re-using references from loc

    List<DatanodeInfo> cachedLocs = new ArrayList<DatanodeInfo>(locs.size());

    List<Boolean> isCachedList = proto.getIsCachedList();

    for (int i=0; i<isCachedList.size(); i++) {

      if (isCachedList.get(i)) {

        cachedLocs.add(targets[i]);

      }

    }

    LocatedBlock lb = new LocatedBlock(PBHelper.convert(proto.getB()), targets,

        storageIDs, storageTypes, proto.getOffset(), proto.getCorrupt(),

        cachedLocs.toArray(new DatanodeInfo[0]));

    lb.setBlockToken(PBHelper.convert(proto.getBlockToken()));

    return lb;

  }

  public static TokenProto convert(Token<?> tok) {

    return TokenProto.newBuilder().

              setIdentifier(ByteString.copyFrom(tok.getIdentifier())).

              setPassword(ByteString.copyFrom(tok.getPassword())).

              setKind(tok.getKind().toString()).

              setService(tok.getService().toString()).build();

  }

 

  public static Token<BlockTokenIdentifier> convert(

      TokenProto blockToken) {

    return new Token<BlockTokenIdentifier>(blockToken.getIdentifier()

        .toByteArray(), blockToken.getPassword().toByteArray(), new Text(

        blockToken.getKind()), new Text(blockToken.getService()));

  }

 

  public static Token<DelegationTokenIdentifier> convertDelegationToken(

      TokenProto blockToken) {

    return new Token<DelegationTokenIdentifier>(blockToken.getIdentifier()

        .toByteArray(), blockToken.getPassword().toByteArray(), new Text(

        blockToken.getKind()), new Text(blockToken.getService()));

  }

  public static ReplicaState convert(ReplicaStateProto state) {

    switch (state) {

    case RBW:

      return ReplicaState.RBW;

    case RUR:

      return ReplicaState.RUR;

    case RWR:

      return ReplicaState.RWR;

    case TEMPORARY:

      return ReplicaState.TEMPORARY;

    case FINALIZED:

    default:

      return ReplicaState.FINALIZED;

    }

  }

  public static ReplicaStateProto convert(ReplicaState state) {

    switch (state) {

    case RBW:

      return ReplicaStateProto.RBW;

    case RUR:

      return ReplicaStateProto.RUR;

    case RWR:

      return ReplicaStateProto.RWR;

    case TEMPORARY:

      return ReplicaStateProto.TEMPORARY;

    case FINALIZED:

    default:

      return ReplicaStateProto.FINALIZED;

    }

  }

 

  public static DatanodeRegistrationProto convert(

      DatanodeRegistration registration) {

    DatanodeRegistrationProto.Builder builder = DatanodeRegistrationProto

        .newBuilder();

    return builder.setDatanodeID(PBHelper.convert((DatanodeID) registration))

        .setStorageInfo(PBHelper.convert(registration.getStorageInfo()))

        .setKeys(PBHelper.convert(registration.getExportedKeys()))

        .setSoftwareVersion(registration.getSoftwareVersion()).build();

  }

  public static DatanodeRegistration convert(DatanodeRegistrationProto proto) {

    StorageInfo si = convert(proto.getStorageInfo(), NodeType.DATA_NODE);

    return new DatanodeRegistration(PBHelper.convert(proto.getDatanodeID()),

        si, PBHelper.convert(proto.getKeys()), proto.getSoftwareVersion());

  }

  public static DatanodeCommand convert(DatanodeCommandProto proto) {

    switch (proto.getCmdType()) {

    case BalancerBandwidthCommand:

      return PBHelper.convert(proto.getBalancerCmd());

    case BlockCommand:

      return PBHelper.convert(proto.getBlkCmd());

    case BlockRecoveryCommand:

      return PBHelper.convert(proto.getRecoveryCmd());

    case FinalizeCommand:

      return PBHelper.convert(proto.getFinalizeCmd());

    case KeyUpdateCommand:

      return PBHelper.convert(proto.getKeyUpdateCmd());

    case RegisterCommand:

      return REG_CMD;

    case BlockIdCommand:

      return PBHelper.convert(proto.getBlkIdCmd());

    default:

      return null;

    }

  }

 

  public static BalancerBandwidthCommandProto convert(

      BalancerBandwidthCommand bbCmd) {

    return BalancerBandwidthCommandProto.newBuilder()

        .setBandwidth(bbCmd.getBalancerBandwidthValue()).build();

  }

  public static KeyUpdateCommandProto convert(KeyUpdateCommand cmd) {

    return KeyUpdateCommandProto.newBuilder()

        .setKeys(PBHelper.convert(cmd.getExportedKeys())).build();

  }

  public static BlockRecoveryCommandProto convert(BlockRecoveryCommand cmd) {

    BlockRecoveryCommandProto.Builder builder = BlockRecoveryCommandProto

        .newBuilder();

    for (RecoveringBlock b : cmd.getRecoveringBlocks()) {

      builder.addBlocks(PBHelper.convert(b));

    }

    return builder.build();

  }

  public static FinalizeCommandProto convert(FinalizeCommand cmd) {

    return FinalizeCommandProto.newBuilder()

        .setBlockPoolId(cmd.getBlockPoolId()).build();

  }

  public static BlockCommandProto convert(BlockCommand cmd) {

    BlockCommandProto.Builder builder = BlockCommandProto.newBuilder()

        .setBlockPoolId(cmd.getBlockPoolId());

    switch (cmd.getAction()) {

    case DatanodeProtocol.DNA_TRANSFER:

      builder.setAction(BlockCommandProto.Action.TRANSFER);

      break;

    case DatanodeProtocol.DNA_INVALIDATE:

      builder.setAction(BlockCommandProto.Action.INVALIDATE);

      break;

    case DatanodeProtocol.DNA_SHUTDOWN:

      builder.setAction(BlockCommandProto.Action.SHUTDOWN);

      break;

    default:

      throw new AssertionError("Invalid action");

    }

    Block[] blocks = cmd.getBlocks();

    for (int i = 0; i < blocks.length; i++) {

      builder.addBlocks(PBHelper.convert(blocks[i]));