Java 类org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.StorageTypeProto 实例源码

public static BlockStoragePolicy convert(BlockStoragePolicyProto proto) {
  List<StorageTypeProto> cList = proto.getCreationPolicy()
      .getStorageTypesList();
  StorageType[] creationTypes = convertStorageTypes(cList, cList.size());
  List<StorageTypeProto> cfList = proto.hasCreationFallbackPolicy() ? proto
      .getCreationFallbackPolicy().getStorageTypesList() : null;
  StorageType[] creationFallbackTypes = cfList == null ? StorageType
      .EMPTY_ARRAY : convertStorageTypes(cfList, cfList.size());
  List<StorageTypeProto> rfList = proto.hasReplicationFallbackPolicy() ?
      proto.getReplicationFallbackPolicy().getStorageTypesList() : null;
  StorageType[] replicationFallbackTypes = rfList == null ? StorageType
      .EMPTY_ARRAY : convertStorageTypes(rfList, rfList.size());
  return new BlockStoragePolicy((byte) proto.getPolicyId(), proto.getName(),
      creationTypes, creationFallbackTypes, replicationFallbackTypes);
}

public static StorageTypesProto convert(StorageType[] types) {
  if (types == null || types.length == 0) {
    return null;
  }
  List<StorageTypeProto> list = convertStorageTypes(types);
  return StorageTypesProto.newBuilder().addAllStorageTypes(list).build();
}

public static BlockWithLocations convert(BlockWithLocationsProto b) {
  final List<String> datanodeUuids = b.getDatanodeUuidsList();
  final List<String> storageUuids = b.getStorageUuidsList();
  final List<StorageTypeProto> storageTypes = b.getStorageTypesList();
  return new BlockWithLocations(convert(b.getBlock()),
      datanodeUuids.toArray(new String[datanodeUuids.size()]),
      storageUuids.toArray(new String[storageUuids.size()]),
      convertStorageTypes(storageTypes, storageUuids.size()));
}

public static List<StorageTypeProto> convertStorageTypes(
    StorageType[] types, int startIdx) {
  if (types == null) {
    return null;
  }
  final List<StorageTypeProto> protos = new ArrayList<StorageTypeProto>(
      types.length);
  for (int i = startIdx; i < types.length; ++i) {
    protos.add(convertStorageType(types[i]));
  }
  return protos; 
}

public static StorageTypeProto convertStorageType(StorageType type) {
  switch(type) {
  case DISK:
    return StorageTypeProto.DISK;
  case SSD:
    return StorageTypeProto.SSD;
  case ARCHIVE:
    return StorageTypeProto.ARCHIVE;
  case RAM_DISK:
    return StorageTypeProto.RAM_DISK;
  default:
    throw new IllegalStateException(
        "BUG: StorageType not found, type=" + type);
  }
}

public static StorageType convertStorageType(StorageTypeProto type) {
  switch(type) {
    case DISK:
      return StorageType.DISK;
    case SSD:
      return StorageType.SSD;
    case ARCHIVE:
      return StorageType.ARCHIVE;
    case RAM_DISK:
      return StorageType.RAM_DISK;
    default:
      throw new IllegalStateException(
          "BUG: StorageTypeProto not found, type=" + type);
  }
}

public static StorageType[] convertStorageTypes(
    List<StorageTypeProto> storageTypesList, int expectedSize) {
  final StorageType[] storageTypes = new StorageType[expectedSize];
  if (storageTypesList.size() != expectedSize) { // missing storage types
    Preconditions.checkState(storageTypesList.isEmpty());
    Arrays.fill(storageTypes, StorageType.DEFAULT);
  } else {
    for (int i = 0; i < storageTypes.length; ++i) {
      storageTypes[i] = convertStorageType(storageTypesList.get(i));
    }
  }
  return storageTypes;
}

public static StorageTypeProto convertStorageType(StorageType type) {
  switch(type) {
  case DISK:
    return StorageTypeProto.DISK;
  case SSD:
    return StorageTypeProto.SSD;
  case ARCHIVE:
    return StorageTypeProto.ARCHIVE;
  case RAM_DISK:
    return StorageTypeProto.RAM_DISK;
  default:
    throw new IllegalStateException(
        "BUG: StorageType not found, type=" + type);
  }
}

public static StorageType convertStorageType(StorageTypeProto type) {
  switch(type) {
  case DISK:
    return StorageType.DISK;
  case SSD:
    return StorageType.SSD;
  case ARCHIVE:
    return StorageType.ARCHIVE;
  case RAM_DISK:
    return StorageType.RAM_DISK;
  default:
    throw new IllegalStateException(
        "BUG: StorageTypeProto not found, type=" + type);
  }
}

public static List<StorageTypeProto> convertStorageTypes(
    StorageType[] types, int startIdx) {
  if (types == null) {
    return null;
  }
  final List<StorageTypeProto> protos = new ArrayList<>(
      types.length);
  for (int i = startIdx; i < types.length; ++i) {
    protos.add(convertStorageType(types[i]));
  }
  return protos;
}

public static StorageType[] convertStorageTypes(
    List<StorageTypeProto> storageTypesList, int expectedSize) {
  final StorageType[] storageTypes = new StorageType[expectedSize];
  if (storageTypesList.size() != expectedSize) {
    // missing storage types
    Preconditions.checkState(storageTypesList.isEmpty());
    Arrays.fill(storageTypes, StorageType.DEFAULT);
  } else {
    for (int i = 0; i < storageTypes.length; ++i) {
      storageTypes[i] = convertStorageType(storageTypesList.get(i));
    }
  }
  return storageTypes;
}

public static BlockStoragePolicy convert(BlockStoragePolicyProto proto) {
  List<StorageTypeProto> cList = proto.getCreationPolicy()
      .getStorageTypesList();
  StorageType[] creationTypes = convertStorageTypes(cList, cList.size());
  List<StorageTypeProto> cfList = proto.hasCreationFallbackPolicy() ? proto
      .getCreationFallbackPolicy().getStorageTypesList() : null;
  StorageType[] creationFallbackTypes = cfList == null ? StorageType
      .EMPTY_ARRAY : convertStorageTypes(cfList, cfList.size());
  List<StorageTypeProto> rfList = proto.hasReplicationFallbackPolicy() ?
      proto.getReplicationFallbackPolicy().getStorageTypesList() : null;
  StorageType[] replicationFallbackTypes = rfList == null ? StorageType
      .EMPTY_ARRAY : convertStorageTypes(rfList, rfList.size());
  return new BlockStoragePolicy((byte) proto.getPolicyId(), proto.getName(),
      creationTypes, creationFallbackTypes, replicationFallbackTypes);
}

public static StorageTypesProto convert(StorageType[] types) {
  if (types == null || types.length == 0) {
    return null;
  }
  List<StorageTypeProto> list = convertStorageTypes(types);
  return StorageTypesProto.newBuilder().addAllStorageTypes(list).build();
}

public static BlockWithLocations convert(BlockWithLocationsProto b) {
  final List<String> datanodeUuids = b.getDatanodeUuidsList();
  final List<String> storageUuids = b.getStorageUuidsList();
  final List<StorageTypeProto> storageTypes = b.getStorageTypesList();
  BlockWithLocations blk = new BlockWithLocations(PBHelperClient.
      convert(b.getBlock()),
      datanodeUuids.toArray(new String[datanodeUuids.size()]),
      storageUuids.toArray(new String[storageUuids.size()]),
      PBHelperClient.convertStorageTypes(storageTypes, storageUuids.size()));
  if (b.hasIndices()) {
    blk = new StripedBlockWithLocations(blk, b.getIndices().toByteArray(),
        (short) b.getDataBlockNum(), b.getCellSize());
  }
  return blk;
}

public static BlockStoragePolicy convert(BlockStoragePolicyProto proto) {
  List<StorageTypeProto> cList = proto.getCreationPolicy()
      .getStorageTypesList();
  StorageType[] creationTypes = convertStorageTypes(cList, cList.size());
  List<StorageTypeProto> cfList = proto.hasCreationFallbackPolicy() ? proto
      .getCreationFallbackPolicy().getStorageTypesList() : null;
  StorageType[] creationFallbackTypes = cfList == null ? StorageType
      .EMPTY_ARRAY : convertStorageTypes(cfList, cfList.size());
  List<StorageTypeProto> rfList = proto.hasReplicationFallbackPolicy() ?
      proto.getReplicationFallbackPolicy().getStorageTypesList() : null;
  StorageType[] replicationFallbackTypes = rfList == null ? StorageType
      .EMPTY_ARRAY : convertStorageTypes(rfList, rfList.size());
  return new BlockStoragePolicy((byte) proto.getPolicyId(), proto.getName(),
      creationTypes, creationFallbackTypes, replicationFallbackTypes);
}

public static StorageTypesProto convert(StorageType[] types) {
  if (types == null || types.length == 0) {
    return null;
  }
  List<StorageTypeProto> list = convertStorageTypes(types);
  return StorageTypesProto.newBuilder().addAllStorageTypes(list).build();
}

public static BlockWithLocations convert(BlockWithLocationsProto b) {
  final List<String> datanodeUuids = b.getDatanodeUuidsList();
  final List<String> storageUuids = b.getStorageUuidsList();
  final List<StorageTypeProto> storageTypes = b.getStorageTypesList();
  return new BlockWithLocations(convert(b.getBlock()),
      datanodeUuids.toArray(new String[datanodeUuids.size()]),
      storageUuids.toArray(new String[storageUuids.size()]),
      convertStorageTypes(storageTypes, storageUuids.size()));
}

public static List<StorageTypeProto> convertStorageTypes(
    StorageType[] types, int startIdx) {
  if (types == null) {
    return null;
  }
  final List<StorageTypeProto> protos = new ArrayList<StorageTypeProto>(
      types.length);
  for (int i = startIdx; i < types.length; ++i) {
    protos.add(convertStorageType(types[i]));
  }
  return protos; 
}

public static StorageTypeProto convertStorageType(StorageType type) {
  switch(type) {
  case DISK:
    return StorageTypeProto.DISK;
  case SSD:
    return StorageTypeProto.SSD;
  case ARCHIVE:
    return StorageTypeProto.ARCHIVE;
  case RAM_DISK:
    return StorageTypeProto.RAM_DISK;
  default:
    throw new IllegalStateException(
        "BUG: StorageType not found, type=" + type);
  }
}

public static StorageType convertStorageType(StorageTypeProto type) {
  switch(type) {
    case DISK:
      return StorageType.DISK;
    case SSD:
      return StorageType.SSD;
    case ARCHIVE:
      return StorageType.ARCHIVE;
    case RAM_DISK:
      return StorageType.RAM_DISK;
    default:
      throw new IllegalStateException(
          "BUG: StorageTypeProto not found, type=" + type);
  }
}

public static StorageType[] convertStorageTypes(
    List<StorageTypeProto> storageTypesList, int expectedSize) {
  final StorageType[] storageTypes = new StorageType[expectedSize];
  if (storageTypesList.size() != expectedSize) { // missing storage types
    Preconditions.checkState(storageTypesList.isEmpty());
    Arrays.fill(storageTypes, StorageType.DEFAULT);
  } else {
    for (int i = 0; i < storageTypes.length; ++i) {
      storageTypes[i] = convertStorageType(storageTypesList.get(i));
    }
  }
  return storageTypes;
}

public static BlockStoragePolicy convert(BlockStoragePolicyProto proto) {
  List<StorageTypeProto> cList = proto.getCreationPolicy()
      .getStorageTypesList();
  StorageType[] creationTypes = convertStorageTypes(cList, cList.size());
  List<StorageTypeProto> cfList = proto.hasCreationFallbackPolicy() ? proto
      .getCreationFallbackPolicy().getStorageTypesList() : null;
  StorageType[] creationFallbackTypes = cfList == null ? StorageType
      .EMPTY_ARRAY : convertStorageTypes(cfList, cfList.size());
  List<StorageTypeProto> rfList = proto.hasReplicationFallbackPolicy() ?
      proto.getReplicationFallbackPolicy().getStorageTypesList() : null;
  StorageType[] replicationFallbackTypes = rfList == null ? StorageType
      .EMPTY_ARRAY : convertStorageTypes(rfList, rfList.size());
  return new BlockStoragePolicy((byte) proto.getPolicyId(), proto.getName(),
      creationTypes, creationFallbackTypes, replicationFallbackTypes);
}

public static StorageTypesProto convert(StorageType[] types) {
  if (types == null || types.length == 0) {
    return null;
  }
  List<StorageTypeProto> list = convertStorageTypes(types);
  return StorageTypesProto.newBuilder().addAllStorageTypes(list).build();
}

public static BlockWithLocations convert(BlockWithLocationsProto b) {
  final List<String> datanodeUuids = b.getDatanodeUuidsList();
  final List<String> storageUuids = b.getStorageUuidsList();
  final List<StorageTypeProto> storageTypes = b.getStorageTypesList();
  return new BlockWithLocations(convert(b.getBlock()),
      datanodeUuids.toArray(new String[datanodeUuids.size()]),
      storageUuids.toArray(new String[storageUuids.size()]),
      convertStorageTypes(storageTypes, storageUuids.size()));
}

public static List<StorageTypeProto> convertStorageTypes(
    StorageType[] types, int startIdx) {
  if (types == null) {
    return null;
  }
  final List<StorageTypeProto> protos = new ArrayList<StorageTypeProto>(
      types.length);
  for (int i = startIdx; i < types.length; ++i) {
    protos.add(convertStorageType(types[i]));
  }
  return protos; 
}

public static StorageTypeProto convertStorageType(StorageType type) {
  switch(type) {
  case DISK:
    return StorageTypeProto.DISK;
  case SSD:
    return StorageTypeProto.SSD;
  case ARCHIVE:
    return StorageTypeProto.ARCHIVE;
  case RAM_DISK:
    return StorageTypeProto.RAM_DISK;
  default:
    throw new IllegalStateException(
        "BUG: StorageType not found, type=" + type);
  }
}

public static StorageType convertStorageType(StorageTypeProto type) {
  switch(type) {
    case DISK:
      return StorageType.DISK;
    case SSD:
      return StorageType.SSD;
    case ARCHIVE:
      return StorageType.ARCHIVE;
    case RAM_DISK:
      return StorageType.RAM_DISK;
    default:
      throw new IllegalStateException(
          "BUG: StorageTypeProto not found, type=" + type);
  }
}

public static StorageType[] convertStorageTypes(
    List<StorageTypeProto> storageTypesList, int expectedSize) {
  final StorageType[] storageTypes = new StorageType[expectedSize];
  if (storageTypesList.size() != expectedSize) { // missing storage types
    Preconditions.checkState(storageTypesList.isEmpty());
    Arrays.fill(storageTypes, StorageType.DEFAULT);
  } else {
    for (int i = 0; i < storageTypes.length; ++i) {
      storageTypes[i] = convertStorageType(storageTypesList.get(i));
    }
  }
  return storageTypes;
}

public static BlockStoragePolicy convert(BlockStoragePolicyProto proto) {
  List<StorageTypeProto> cList = proto.getCreationPolicy()
      .getStorageTypesList();
  StorageType[] creationTypes = convertStorageTypes(cList, cList.size());
  List<StorageTypeProto> cfList = proto.hasCreationFallbackPolicy() ? proto
      .getCreationFallbackPolicy().getStorageTypesList() : null;
  StorageType[] creationFallbackTypes = cfList == null ? StorageType
      .EMPTY_ARRAY : convertStorageTypes(cfList, cfList.size());
  List<StorageTypeProto> rfList = proto.hasReplicationFallbackPolicy() ?
      proto.getReplicationFallbackPolicy().getStorageTypesList() : null;
  StorageType[] replicationFallbackTypes = rfList == null ? StorageType
      .EMPTY_ARRAY : convertStorageTypes(rfList, rfList.size());
  return new BlockStoragePolicy((byte) proto.getPolicyId(), proto.getName(),
      creationTypes, creationFallbackTypes, replicationFallbackTypes);
}

public static StorageTypesProto convert(StorageType[] types) {
  if (types == null || types.length == 0) {
    return null;
  }
  List<StorageTypeProto> list = convertStorageTypes(types);
  return StorageTypesProto.newBuilder().addAllStorageTypes(list).build();
}

public static BlockWithLocations convert(BlockWithLocationsProto b) {
  final List<String> datanodeUuids = b.getDatanodeUuidsList();
  final List<String> storageUuids = b.getStorageUuidsList();
  final List<StorageTypeProto> storageTypes = b.getStorageTypesList();
  return new BlockWithLocations(convert(b.getBlock()),
      datanodeUuids.toArray(new String[datanodeUuids.size()]),
      storageUuids.toArray(new String[storageUuids.size()]),
      convertStorageTypes(storageTypes, storageUuids.size()));
}

public static List<StorageTypeProto> convertStorageTypes(
    StorageType[] types, int startIdx) {
  if (types == null) {
    return null;
  }
  final List<StorageTypeProto> protos = new ArrayList<StorageTypeProto>(
      types.length);
  for (int i = startIdx; i < types.length; ++i) {
    protos.add(convertStorageType(types[i]));
  }
  return protos; 
}

public static StorageTypeProto convertStorageType(StorageType type) {
  switch(type) {
  case DISK:
    return StorageTypeProto.DISK;
  case SSD:
    return StorageTypeProto.SSD;
  case ARCHIVE:
    return StorageTypeProto.ARCHIVE;
  case RAM_DISK:
    return StorageTypeProto.RAM_DISK;
  default:
    throw new IllegalStateException(
        "BUG: StorageType not found, type=" + type);
  }
}

public static StorageType convertStorageType(StorageTypeProto type) {
  switch(type) {
    case DISK:
      return StorageType.DISK;
    case SSD:
      return StorageType.SSD;
    case ARCHIVE:
      return StorageType.ARCHIVE;
    case RAM_DISK:
      return StorageType.RAM_DISK;
    default:
      throw new IllegalStateException(
          "BUG: StorageTypeProto not found, type=" + type);
  }
}

public static StorageType[] convertStorageTypes(
    List<StorageTypeProto> storageTypesList, int expectedSize) {
  final StorageType[] storageTypes = new StorageType[expectedSize];
  if (storageTypesList.size() != expectedSize) { // missing storage types
    Preconditions.checkState(storageTypesList.isEmpty());
    Arrays.fill(storageTypes, StorageType.DEFAULT);
  } else {
    for (int i = 0; i < storageTypes.length; ++i) {
      storageTypes[i] = convertStorageType(storageTypesList.get(i));
    }
  }
  return storageTypes;
}

private static StorageTypeProto convertStorageType(
    StorageType type) {
  switch(type) {
  case DISK:
    return StorageTypeProto.DISK;
  case SSD:
    return StorageTypeProto.SSD;
  default:
    throw new IllegalStateException(
        "BUG: StorageType not found, type=" + type);
  }
}

private static StorageType convertType(StorageTypeProto type) {
  switch(type) {
    case DISK:
      return StorageType.DISK;
    case SSD:
      return StorageType.SSD;
    default:
      throw new IllegalStateException(
          "BUG: StorageTypeProto not found, type=" + type);
  }
}

private static StorageType[] convertStorageTypeProtos(
    List<StorageTypeProto> storageTypesList) {
  final StorageType[] storageTypes = new StorageType[storageTypesList.size()];
  for (int i = 0; i < storageTypes.length; ++i) {
    storageTypes[i] = PBHelper.convertType(storageTypesList.get(i));
  }
  return storageTypes;
}

public static BlockCommand convert(BlockCommandProto blkCmd) {
  List<BlockProto> blockProtoList = blkCmd.getBlocksList();
  Block[] blocks = new Block[blockProtoList.size()];
  for (int i = 0; i < blockProtoList.size(); i++) {
    blocks[i] = PBHelper.convert(blockProtoList.get(i));
  }
  List<DatanodeInfosProto> targetList = blkCmd.getTargetsList();
  DatanodeInfo[][] targets = new DatanodeInfo[targetList.size()][];
  for (int i = 0; i < targetList.size(); i++) {
    targets[i] = PBHelper.convert(targetList.get(i));
  }

  StorageType[][] targetStorageTypes = new StorageType[targetList.size()][];
  List<StorageTypesProto> targetStorageTypesList = blkCmd.getTargetStorageTypesList();
  if (targetStorageTypesList.isEmpty()) { // missing storage types
    for(int i = 0; i < targetStorageTypes.length; i++) {
      targetStorageTypes[i] = new StorageType[targets[i].length];
      Arrays.fill(targetStorageTypes[i], StorageType.DEFAULT);
    }
  } else {
    for(int i = 0; i < targetStorageTypes.length; i++) {
      List<StorageTypeProto> p = targetStorageTypesList.get(i).getStorageTypesList();
      targetStorageTypes[i] = convertStorageTypes(p, targets[i].length);
    }
  }

  List<StorageUuidsProto> targetStorageUuidsList = blkCmd.getTargetStorageUuidsList();
  String[][] targetStorageIDs = new String[targetStorageUuidsList.size()][];
  for(int i = 0; i < targetStorageIDs.length; i++) {
    List<String> storageIDs = targetStorageUuidsList.get(i).getStorageUuidsList();
    targetStorageIDs[i] = storageIDs.toArray(new String[storageIDs.size()]);
  }

  int action = DatanodeProtocol.DNA_UNKNOWN;
  switch (blkCmd.getAction()) {
  case TRANSFER:
    action = DatanodeProtocol.DNA_TRANSFER;
    break;
  case INVALIDATE:
    action = DatanodeProtocol.DNA_INVALIDATE;
    break;
  case SHUTDOWN:
    action = DatanodeProtocol.DNA_SHUTDOWN;
    break;
  default:
    throw new AssertionError("Unknown action type: " + blkCmd.getAction());
  }
  return new BlockCommand(action, blkCmd.getBlockPoolId(), blocks, targets,
      targetStorageTypes, targetStorageIDs);
}

public static List<StorageTypeProto> convertStorageTypes(
    StorageType[] types) {
  return convertStorageTypes(types, 0);
}