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 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 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; }
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); }
