001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements. See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership. The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License. You may obtain a copy of the License at
009 *
010 * http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018 package org.apache.hadoop.hdfs.protocolPB;
019
020 import static com.google.common.base.Preconditions.checkNotNull;
021
022 import java.io.EOFException;
023 import java.io.IOException;
024 import java.io.InputStream;
025 import java.util.ArrayList;
026 import java.util.Arrays;
027 import java.util.EnumSet;
028 import java.util.List;
029
030 import com.google.common.base.Preconditions;
031 import org.apache.hadoop.fs.CacheFlag;
032 import org.apache.hadoop.fs.ContentSummary;
033 import org.apache.hadoop.fs.CreateFlag;
034 import org.apache.hadoop.fs.FsServerDefaults;
035 import org.apache.hadoop.fs.Path;
036 import org.apache.hadoop.fs.permission.AclEntry;
037 import org.apache.hadoop.fs.permission.AclEntryScope;
038 import org.apache.hadoop.fs.permission.AclEntryType;
039 import org.apache.hadoop.fs.permission.AclStatus;
040 import org.apache.hadoop.fs.permission.FsAction;
041 import org.apache.hadoop.fs.permission.FsPermission;
042 import org.apache.hadoop.ha.HAServiceProtocol.HAServiceState;
043 import org.apache.hadoop.hdfs.DFSUtil;
044 import org.apache.hadoop.hdfs.ShortCircuitShm.ShmId;
045 import org.apache.hadoop.hdfs.ShortCircuitShm.SlotId;
046 import org.apache.hadoop.hdfs.StorageType;
047 import org.apache.hadoop.hdfs.protocol.Block;
048 import org.apache.hadoop.hdfs.protocol.CacheDirectiveEntry;
049 import org.apache.hadoop.hdfs.protocol.CacheDirectiveInfo;
050 import org.apache.hadoop.hdfs.protocol.CacheDirectiveStats;
051 import org.apache.hadoop.hdfs.protocol.CachePoolEntry;
052 import org.apache.hadoop.hdfs.protocol.CachePoolInfo;
053 import org.apache.hadoop.hdfs.protocol.CachePoolStats;
054 import org.apache.hadoop.hdfs.protocol.ClientProtocol;
055 import org.apache.hadoop.hdfs.protocol.CorruptFileBlocks;
056 import org.apache.hadoop.hdfs.protocol.DatanodeID;
057 import org.apache.hadoop.hdfs.protocol.DatanodeInfo;
058 import org.apache.hadoop.hdfs.protocol.DatanodeInfo.AdminStates;
059 import org.apache.hadoop.hdfs.protocol.DatanodeLocalInfo;
060 import org.apache.hadoop.hdfs.protocol.DirectoryListing;
061 import org.apache.hadoop.hdfs.protocol.ExtendedBlock;
062 import org.apache.hadoop.hdfs.protocol.HdfsConstants.DatanodeReportType;
063 import org.apache.hadoop.hdfs.protocol.HdfsConstants.RollingUpgradeAction;
064 import org.apache.hadoop.hdfs.protocol.HdfsConstants.SafeModeAction;
065 import org.apache.hadoop.hdfs.protocol.HdfsFileStatus;
066 import org.apache.hadoop.hdfs.protocol.HdfsLocatedFileStatus;
067 import org.apache.hadoop.hdfs.protocol.LocatedBlock;
068 import org.apache.hadoop.hdfs.protocol.LocatedBlocks;
069 import org.apache.hadoop.hdfs.protocol.RollingUpgradeInfo;
070 import org.apache.hadoop.hdfs.protocol.RollingUpgradeStatus;
071 import org.apache.hadoop.hdfs.protocol.SnapshotDiffReport;
072 import org.apache.hadoop.hdfs.protocol.SnapshotDiffReport.DiffReportEntry;
073 import org.apache.hadoop.hdfs.protocol.SnapshotDiffReport.DiffType;
074 import org.apache.hadoop.hdfs.protocol.SnapshottableDirectoryStatus;
075 import org.apache.hadoop.hdfs.protocol.proto.AclProtos.AclEntryProto;
076 import org.apache.hadoop.hdfs.protocol.proto.AclProtos.AclStatusProto;
077 import org.apache.hadoop.hdfs.protocol.proto.AclProtos.AclEntryProto.AclEntryScopeProto;
078 import org.apache.hadoop.hdfs.protocol.proto.AclProtos.AclEntryProto.AclEntryTypeProto;
079 import org.apache.hadoop.hdfs.protocol.proto.AclProtos.AclEntryProto.FsActionProto;
080 import org.apache.hadoop.hdfs.protocol.proto.AclProtos.GetAclStatusResponseProto;
081 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos;
082 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.CacheDirectiveEntryProto;
083 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.CacheDirectiveInfoExpirationProto;
084 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.CacheDirectiveInfoProto;
085 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.CacheDirectiveStatsProto;
086 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.CacheFlagProto;
087 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.CachePoolEntryProto;
088 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.CachePoolInfoProto;
089 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.CachePoolStatsProto;
090 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.CreateFlagProto;
091 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.DatanodeReportTypeProto;
092 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.GetFsStatsResponseProto;
093 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.RollingUpgradeActionProto;
094 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.RollingUpgradeInfoProto;
095 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.SafeModeActionProto;
096 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.CacheDirectiveInfoProto;
097 import org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ShortCircuitShmSlotProto;
098 import org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ShortCircuitShmIdProto;
099 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BalancerBandwidthCommandProto;
100 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockCommandProto;
101 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockIdCommandProto;
102 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockRecoveryCommandProto;
103 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.DatanodeCommandProto;
104 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.DatanodeRegistrationProto;
105 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.DatanodeStorageProto;
106 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.DatanodeStorageProto.StorageState;
107 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.FinalizeCommandProto;
108 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.KeyUpdateCommandProto;
109 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.NNHAStatusHeartbeatProto;
110 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ReceivedDeletedBlockInfoProto;
111 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.RegisterCommandProto;
112 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.StorageReportProto;
113 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos;
114 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.BlockKeyProto;
115 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.BlockProto;
116 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.BlockWithLocationsProto;
117 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.BlocksWithLocationsProto;
118 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.CheckpointCommandProto;
119 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.CheckpointSignatureProto;
120 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.ContentSummaryProto;
121 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.CorruptFileBlocksProto;
122 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DataEncryptionKeyProto;
123 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeIDProto;
124 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto;
125 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.AdminState;
126 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfosProto;
127 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeLocalInfoProto;
128 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DirectoryListingProto;
129 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.ExportedBlockKeysProto;
130 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.ExtendedBlockProto;
131 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.FsPermissionProto;
132 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.FsServerDefaultsProto;
133 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.HdfsFileStatusProto;
134 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.HdfsFileStatusProto.FileType;
135 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.LocatedBlockProto;
136 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.LocatedBlockProto.Builder;
137 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.LocatedBlocksProto;
138 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.NamenodeCommandProto;
139 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.NamenodeRegistrationProto;
140 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.NamenodeRegistrationProto.NamenodeRoleProto;
141 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.NamespaceInfoProto;
142 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.RecoveringBlockProto;
143 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.RemoteEditLogManifestProto;
144 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.RemoteEditLogProto;
145 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.ReplicaStateProto;
146 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.RollingUpgradeStatusProto;
147 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.SnapshotDiffReportEntryProto;
148 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.SnapshotDiffReportProto;
149 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.SnapshottableDirectoryListingProto;
150 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.SnapshottableDirectoryStatusProto;
151 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.StorageInfoProto;
152 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.StorageTypeProto;
153 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.StorageUuidsProto;
154 import org.apache.hadoop.hdfs.protocol.proto.JournalProtocolProtos.JournalInfoProto;
155 import org.apache.hadoop.hdfs.security.token.block.BlockKey;
156 import org.apache.hadoop.hdfs.security.token.block.BlockTokenIdentifier;
157 import org.apache.hadoop.hdfs.security.token.block.DataEncryptionKey;
158 import org.apache.hadoop.hdfs.security.token.block.ExportedBlockKeys;
159 import org.apache.hadoop.hdfs.security.token.delegation.DelegationTokenIdentifier;
160 import org.apache.hadoop.hdfs.server.common.HdfsServerConstants.NamenodeRole;
161 import org.apache.hadoop.hdfs.server.common.HdfsServerConstants.NodeType;
162 import org.apache.hadoop.hdfs.server.common.HdfsServerConstants.ReplicaState;
163 import org.apache.hadoop.hdfs.server.common.StorageInfo;
164 import org.apache.hadoop.hdfs.server.namenode.CheckpointSignature;
165 import org.apache.hadoop.hdfs.server.namenode.INodeId;
166 import org.apache.hadoop.hdfs.server.protocol.BalancerBandwidthCommand;
167 import org.apache.hadoop.hdfs.server.protocol.BlockCommand;
168 import org.apache.hadoop.hdfs.server.protocol.BlockIdCommand;
169 import org.apache.hadoop.hdfs.server.protocol.BlockRecoveryCommand;
170 import org.apache.hadoop.hdfs.server.protocol.BlockRecoveryCommand.RecoveringBlock;
171 import org.apache.hadoop.hdfs.server.protocol.BlocksWithLocations;
172 import org.apache.hadoop.hdfs.server.protocol.BlocksWithLocations.BlockWithLocations;
173 import org.apache.hadoop.hdfs.server.protocol.CheckpointCommand;
174 import org.apache.hadoop.hdfs.server.protocol.DatanodeCommand;
175 import org.apache.hadoop.hdfs.server.protocol.DatanodeProtocol;
176 import org.apache.hadoop.hdfs.server.protocol.DatanodeRegistration;
177 import org.apache.hadoop.hdfs.server.protocol.DatanodeStorage;
178 import org.apache.hadoop.hdfs.server.protocol.DatanodeStorage.State;
179 import org.apache.hadoop.hdfs.server.protocol.FinalizeCommand;
180 import org.apache.hadoop.hdfs.server.protocol.JournalInfo;
181 import org.apache.hadoop.hdfs.server.protocol.KeyUpdateCommand;
182 import org.apache.hadoop.hdfs.server.protocol.NNHAStatusHeartbeat;
183 import org.apache.hadoop.hdfs.server.protocol.NamenodeCommand;
184 import org.apache.hadoop.hdfs.server.protocol.NamenodeRegistration;
185 import org.apache.hadoop.hdfs.server.protocol.NamespaceInfo;
186 import org.apache.hadoop.hdfs.server.protocol.ReceivedDeletedBlockInfo;
187 import org.apache.hadoop.hdfs.server.protocol.ReceivedDeletedBlockInfo.BlockStatus;
188 import org.apache.hadoop.hdfs.server.protocol.RegisterCommand;
189 import org.apache.hadoop.hdfs.server.protocol.RemoteEditLog;
190 import org.apache.hadoop.hdfs.server.protocol.RemoteEditLogManifest;
191 import org.apache.hadoop.hdfs.server.protocol.StorageReport;
192 import org.apache.hadoop.hdfs.util.ExactSizeInputStream;
193 import org.apache.hadoop.io.EnumSetWritable;
194 import org.apache.hadoop.io.Text;
195 import org.apache.hadoop.security.proto.SecurityProtos.TokenProto;
196 import org.apache.hadoop.security.token.Token;
197 import org.apache.hadoop.util.DataChecksum;
198
199 import com.google.common.base.Preconditions;
200 import com.google.common.collect.Lists;
201 import com.google.common.primitives.Shorts;
202 import com.google.protobuf.ByteString;
203 import com.google.protobuf.CodedInputStream;
204
205 /**
206 * Utilities for converting protobuf classes to and from implementation classes
207 * and other helper utilities to help in dealing with protobuf.
208 *
209 * Note that when converting from an internal type to protobuf type, the
210 * converter never return null for protobuf type. The check for internal type
211 * being null must be done before calling the convert() method.
212 */
213 public class PBHelper {
214 private static final RegisterCommandProto REG_CMD_PROTO =
215 RegisterCommandProto.newBuilder().build();
216 private static final RegisterCommand REG_CMD = new RegisterCommand();
217
218 private static final AclEntryScope[] ACL_ENTRY_SCOPE_VALUES =
219 AclEntryScope.values();
220 private static final AclEntryType[] ACL_ENTRY_TYPE_VALUES =
221 AclEntryType.values();
222 private static final FsAction[] FSACTION_VALUES =
223 FsAction.values();
224
225 private PBHelper() {
226 /** Hidden constructor */
227 }
228
229 public static ByteString getByteString(byte[] bytes) {
230 return ByteString.copyFrom(bytes);
231 }
232
233 private static <T extends Enum<T>, U extends Enum<U>> U castEnum(T from, U[] to) {
234 return to[from.ordinal()];
235 }
236
237 public static NamenodeRole convert(NamenodeRoleProto role) {
238 switch (role) {
239 case NAMENODE:
240 return NamenodeRole.NAMENODE;
241 case BACKUP:
242 return NamenodeRole.BACKUP;
243 case CHECKPOINT:
244 return NamenodeRole.CHECKPOINT;
245 }
246 return null;
247 }
248
249 public static NamenodeRoleProto convert(NamenodeRole role) {
250 switch (role) {
251 case NAMENODE:
252 return NamenodeRoleProto.NAMENODE;
253 case BACKUP:
254 return NamenodeRoleProto.BACKUP;
255 case CHECKPOINT:
256 return NamenodeRoleProto.CHECKPOINT;
257 }
258 return null;
259 }
260
261 public static StorageInfoProto convert(StorageInfo info) {
262 return StorageInfoProto.newBuilder().setClusterID(info.getClusterID())
263 .setCTime(info.getCTime()).setLayoutVersion(info.getLayoutVersion())
264 .setNamespceID(info.getNamespaceID()).build();
265 }
266
267 public static StorageInfo convert(StorageInfoProto info, NodeType type) {
268 return new StorageInfo(info.getLayoutVersion(), info.getNamespceID(),
269 info.getClusterID(), info.getCTime(), type);
270 }
271
272 public static NamenodeRegistrationProto convert(NamenodeRegistration reg) {
273 return NamenodeRegistrationProto.newBuilder()
274 .setHttpAddress(reg.getHttpAddress()).setRole(convert(reg.getRole()))
275 .setRpcAddress(reg.getAddress())
276 .setStorageInfo(convert((StorageInfo) reg)).build();
277 }
278
279 public static NamenodeRegistration convert(NamenodeRegistrationProto reg) {
280 StorageInfo si = convert(reg.getStorageInfo(), NodeType.NAME_NODE);
281 return new NamenodeRegistration(reg.getRpcAddress(), reg.getHttpAddress(),
282 si, convert(reg.getRole()));
283 }
284
285 // DatanodeId
286 public static DatanodeID convert(DatanodeIDProto dn) {
287 return new DatanodeID(dn.getIpAddr(), dn.getHostName(), dn.getDatanodeUuid(),
288 dn.getXferPort(), dn.getInfoPort(), dn.hasInfoSecurePort() ? dn
289 .getInfoSecurePort() : 0, dn.getIpcPort());
290 }
291
292 public static DatanodeIDProto convert(DatanodeID dn) {
293 // For wire compatibility with older versions we transmit the StorageID
294 // which is the same as the DatanodeUuid. Since StorageID is a required
295 // field we pass the empty string if the DatanodeUuid is not yet known.
296 return DatanodeIDProto.newBuilder()
297 .setIpAddr(dn.getIpAddr())
298 .setHostName(dn.getHostName())
299 .setXferPort(dn.getXferPort())
300 .setDatanodeUuid(dn.getDatanodeUuid() != null ? dn.getDatanodeUuid() : "")
301 .setInfoPort(dn.getInfoPort())
302 .setInfoSecurePort(dn.getInfoSecurePort())
303 .setIpcPort(dn.getIpcPort()).build();
304 }
305
306 // Arrays of DatanodeId
307 public static DatanodeIDProto[] convert(DatanodeID[] did) {
308 if (did == null)
309 return null;
310 final int len = did.length;
311 DatanodeIDProto[] result = new DatanodeIDProto[len];
312 for (int i = 0; i < len; ++i) {
313 result[i] = convert(did[i]);
314 }
315 return result;
316 }
317
318 public static DatanodeID[] convert(DatanodeIDProto[] did) {
319 if (did == null) return null;
320 final int len = did.length;
321 DatanodeID[] result = new DatanodeID[len];
322 for (int i = 0; i < len; ++i) {
323 result[i] = convert(did[i]);
324 }
325 return result;
326 }
327
328 // Block
329 public static BlockProto convert(Block b) {
330 return BlockProto.newBuilder().setBlockId(b.getBlockId())
331 .setGenStamp(b.getGenerationStamp()).setNumBytes(b.getNumBytes())
332 .build();
333 }
334
335 public static Block convert(BlockProto b) {
336 return new Block(b.getBlockId(), b.getNumBytes(), b.getGenStamp());
337 }
338
339 public static BlockWithLocationsProto convert(BlockWithLocations blk) {
340 return BlockWithLocationsProto.newBuilder()
341 .setBlock(convert(blk.getBlock()))
342 .addAllDatanodeUuids(Arrays.asList(blk.getDatanodeUuids()))
343 .addAllStorageUuids(Arrays.asList(blk.getStorageIDs())).build();
344 }
345
346 public static BlockWithLocations convert(BlockWithLocationsProto b) {
347 final List<String> datanodeUuids = b.getDatanodeUuidsList();
348 final List<String> storageUuids = b.getStorageUuidsList();
349 return new BlockWithLocations(convert(b.getBlock()),
350 datanodeUuids.toArray(new String[datanodeUuids.size()]),
351 storageUuids.toArray(new String[storageUuids.size()]));
352 }
353
354 public static BlocksWithLocationsProto convert(BlocksWithLocations blks) {
355 BlocksWithLocationsProto.Builder builder = BlocksWithLocationsProto
356 .newBuilder();
357 for (BlockWithLocations b : blks.getBlocks()) {
358 builder.addBlocks(convert(b));
359 }
360 return builder.build();
361 }
362
363 public static BlocksWithLocations convert(BlocksWithLocationsProto blocks) {
364 List<BlockWithLocationsProto> b = blocks.getBlocksList();
365 BlockWithLocations[] ret = new BlockWithLocations[b.size()];
366 int i = 0;
367 for (BlockWithLocationsProto entry : b) {
368 ret[i++] = convert(entry);
369 }
370 return new BlocksWithLocations(ret);
371 }
372
373 public static BlockKeyProto convert(BlockKey key) {
374 byte[] encodedKey = key.getEncodedKey();
375 ByteString keyBytes = ByteString.copyFrom(encodedKey == null ?
376 DFSUtil.EMPTY_BYTES : encodedKey);
377 return BlockKeyProto.newBuilder().setKeyId(key.getKeyId())
378 .setKeyBytes(keyBytes).setExpiryDate(key.getExpiryDate()).build();
379 }
380
381 public static BlockKey convert(BlockKeyProto k) {
382 return new BlockKey(k.getKeyId(), k.getExpiryDate(), k.getKeyBytes()
383 .toByteArray());
384 }
385
386 public static ExportedBlockKeysProto convert(ExportedBlockKeys keys) {
387 ExportedBlockKeysProto.Builder builder = ExportedBlockKeysProto
388 .newBuilder();
389 builder.setIsBlockTokenEnabled(keys.isBlockTokenEnabled())
390 .setKeyUpdateInterval(keys.getKeyUpdateInterval())
391 .setTokenLifeTime(keys.getTokenLifetime())
392 .setCurrentKey(convert(keys.getCurrentKey()));
393 for (BlockKey k : keys.getAllKeys()) {
394 builder.addAllKeys(convert(k));
395 }
396 return builder.build();
397 }
398
399 public static ExportedBlockKeys convert(ExportedBlockKeysProto keys) {
400 return new ExportedBlockKeys(keys.getIsBlockTokenEnabled(),
401 keys.getKeyUpdateInterval(), keys.getTokenLifeTime(),
402 convert(keys.getCurrentKey()), convertBlockKeys(keys.getAllKeysList()));
403 }
404
405 public static CheckpointSignatureProto convert(CheckpointSignature s) {
406 return CheckpointSignatureProto.newBuilder()
407 .setBlockPoolId(s.getBlockpoolID())
408 .setCurSegmentTxId(s.getCurSegmentTxId())
409 .setMostRecentCheckpointTxId(s.getMostRecentCheckpointTxId())
410 .setStorageInfo(PBHelper.convert((StorageInfo) s)).build();
411 }
412
413 public static CheckpointSignature convert(CheckpointSignatureProto s) {
414 StorageInfo si = PBHelper.convert(s.getStorageInfo(), NodeType.NAME_NODE);
415 return new CheckpointSignature(si, s.getBlockPoolId(),
416 s.getMostRecentCheckpointTxId(), s.getCurSegmentTxId());
417 }
418
419 public static RemoteEditLogProto convert(RemoteEditLog log) {
420 return RemoteEditLogProto.newBuilder()
421 .setStartTxId(log.getStartTxId())
422 .setEndTxId(log.getEndTxId())
423 .setIsInProgress(log.isInProgress()).build();
424 }
425
426 public static RemoteEditLog convert(RemoteEditLogProto l) {
427 return new RemoteEditLog(l.getStartTxId(), l.getEndTxId(),
428 l.getIsInProgress());
429 }
430
431 public static RemoteEditLogManifestProto convert(
432 RemoteEditLogManifest manifest) {
433 RemoteEditLogManifestProto.Builder builder = RemoteEditLogManifestProto
434 .newBuilder();
435 for (RemoteEditLog log : manifest.getLogs()) {
436 builder.addLogs(convert(log));
437 }
438 return builder.build();
439 }
440
441 public static RemoteEditLogManifest convert(
442 RemoteEditLogManifestProto manifest) {
443 List<RemoteEditLog> logs = new ArrayList<RemoteEditLog>(manifest
444 .getLogsList().size());
445 for (RemoteEditLogProto l : manifest.getLogsList()) {
446 logs.add(convert(l));
447 }
448 return new RemoteEditLogManifest(logs);
449 }
450
451 public static CheckpointCommandProto convert(CheckpointCommand cmd) {
452 return CheckpointCommandProto.newBuilder()
453 .setSignature(convert(cmd.getSignature()))
454 .setNeedToReturnImage(cmd.needToReturnImage()).build();
455 }
456
457 public static NamenodeCommandProto convert(NamenodeCommand cmd) {
458 if (cmd instanceof CheckpointCommand) {
459 return NamenodeCommandProto.newBuilder().setAction(cmd.getAction())
460 .setType(NamenodeCommandProto.Type.CheckPointCommand)
461 .setCheckpointCmd(convert((CheckpointCommand) cmd)).build();
462 }
463 return NamenodeCommandProto.newBuilder()
464 .setType(NamenodeCommandProto.Type.NamenodeCommand)
465 .setAction(cmd.getAction()).build();
466 }
467
468 public static BlockKey[] convertBlockKeys(List<BlockKeyProto> list) {
469 BlockKey[] ret = new BlockKey[list.size()];
470 int i = 0;
471 for (BlockKeyProto k : list) {
472 ret[i++] = convert(k);
473 }
474 return ret;
475 }
476
477 public static NamespaceInfo convert(NamespaceInfoProto info) {
478 StorageInfoProto storage = info.getStorageInfo();
479 return new NamespaceInfo(storage.getNamespceID(), storage.getClusterID(),
480 info.getBlockPoolID(), storage.getCTime(), info.getBuildVersion(),
481 info.getSoftwareVersion());
482 }
483
484 public static NamenodeCommand convert(NamenodeCommandProto cmd) {
485 if (cmd == null) return null;
486 switch (cmd.getType()) {
487 case CheckPointCommand:
488 CheckpointCommandProto chkPt = cmd.getCheckpointCmd();
489 return new CheckpointCommand(PBHelper.convert(chkPt.getSignature()),
490 chkPt.getNeedToReturnImage());
491 default:
492 return new NamenodeCommand(cmd.getAction());
493 }
494 }
495
496 public static ExtendedBlock convert(ExtendedBlockProto eb) {
497 if (eb == null) return null;
498 return new ExtendedBlock( eb.getPoolId(), eb.getBlockId(), eb.getNumBytes(),
499 eb.getGenerationStamp());
500 }
501
502 public static ExtendedBlockProto convert(final ExtendedBlock b) {
503 if (b == null) return null;
504 return ExtendedBlockProto.newBuilder().
505 setPoolId(b.getBlockPoolId()).
506 setBlockId(b.getBlockId()).
507 setNumBytes(b.getNumBytes()).
508 setGenerationStamp(b.getGenerationStamp()).
509 build();
510 }
511
512 public static RecoveringBlockProto convert(RecoveringBlock b) {
513 if (b == null) {
514 return null;
515 }
516 LocatedBlockProto lb = PBHelper.convert((LocatedBlock)b);
517 return RecoveringBlockProto.newBuilder().setBlock(lb)
518 .setNewGenStamp(b.getNewGenerationStamp()).build();
519 }
520
521 public static RecoveringBlock convert(RecoveringBlockProto b) {
522 ExtendedBlock block = convert(b.getBlock().getB());
523 DatanodeInfo[] locs = convert(b.getBlock().getLocsList());
524 return new RecoveringBlock(block, locs, b.getNewGenStamp());
525 }
526
527 public static DatanodeInfoProto.AdminState convert(
528 final DatanodeInfo.AdminStates inAs) {
529 switch (inAs) {
530 case NORMAL: return DatanodeInfoProto.AdminState.NORMAL;
531 case DECOMMISSION_INPROGRESS:
532 return DatanodeInfoProto.AdminState.DECOMMISSION_INPROGRESS;
533 case DECOMMISSIONED: return DatanodeInfoProto.AdminState.DECOMMISSIONED;
534 default: return DatanodeInfoProto.AdminState.NORMAL;
535 }
536 }
537
538 static public DatanodeInfo convert(DatanodeInfoProto di) {
539 if (di == null) return null;
540 return new DatanodeInfo(
541 PBHelper.convert(di.getId()),
542 di.hasLocation() ? di.getLocation() : null ,
543 di.getCapacity(), di.getDfsUsed(), di.getRemaining(),
544 di.getBlockPoolUsed(), di.getCacheCapacity(), di.getCacheUsed(),
545 di.getLastUpdate(), di.getXceiverCount(),
546 PBHelper.convert(di.getAdminState()));
547 }
548
549 static public DatanodeInfoProto convertDatanodeInfo(DatanodeInfo di) {
550 if (di == null) return null;
551 return convert(di);
552 }
553
554
555 static public DatanodeInfo[] convert(DatanodeInfoProto di[]) {
556 if (di == null) return null;
557 DatanodeInfo[] result = new DatanodeInfo[di.length];
558 for (int i = 0; i < di.length; i++) {
559 result[i] = convert(di[i]);
560 }
561 return result;
562 }
563
564 public static List<? extends HdfsProtos.DatanodeInfoProto> convert(
565 DatanodeInfo[] dnInfos) {
566 return convert(dnInfos, 0);
567 }
568
569 /**
570 * Copy from {@code dnInfos} to a target of list of same size starting at
571 * {@code startIdx}.
572 */
573 public static List<? extends HdfsProtos.DatanodeInfoProto> convert(
574 DatanodeInfo[] dnInfos, int startIdx) {
575 if (dnInfos == null)
576 return null;
577 ArrayList<HdfsProtos.DatanodeInfoProto> protos = Lists
578 .newArrayListWithCapacity(dnInfos.length);
579 for (int i = startIdx; i < dnInfos.length; i++) {
580 protos.add(convert(dnInfos[i]));
581 }
582 return protos;
583 }
584
585 public static DatanodeInfo[] convert(List<DatanodeInfoProto> list) {
586 DatanodeInfo[] info = new DatanodeInfo[list.size()];
587 for (int i = 0; i < info.length; i++) {
588 info[i] = convert(list.get(i));
589 }
590 return info;
591 }
592
593 public static DatanodeInfoProto convert(DatanodeInfo info) {
594 DatanodeInfoProto.Builder builder = DatanodeInfoProto.newBuilder();
595 if (info.getNetworkLocation() != null) {
596 builder.setLocation(info.getNetworkLocation());
597 }
598 builder
599 .setId(PBHelper.convert((DatanodeID)info))
600 .setCapacity(info.getCapacity())
601 .setDfsUsed(info.getDfsUsed())
602 .setRemaining(info.getRemaining())
603 .setBlockPoolUsed(info.getBlockPoolUsed())
604 .setCacheCapacity(info.getCacheCapacity())
605 .setCacheUsed(info.getCacheUsed())
606 .setLastUpdate(info.getLastUpdate())
607 .setXceiverCount(info.getXceiverCount())
608 .setAdminState(PBHelper.convert(info.getAdminState()))
609 .build();
610 return builder.build();
611 }
612
613 public static AdminStates convert(AdminState adminState) {
614 switch(adminState) {
615 case DECOMMISSION_INPROGRESS:
616 return AdminStates.DECOMMISSION_INPROGRESS;
617 case DECOMMISSIONED:
618 return AdminStates.DECOMMISSIONED;
619 case NORMAL:
620 default:
621 return AdminStates.NORMAL;
622 }
623 }
624
625 public static LocatedBlockProto convert(LocatedBlock b) {
626 if (b == null) return null;
627 Builder builder = LocatedBlockProto.newBuilder();
628 DatanodeInfo[] locs = b.getLocations();
629 List<DatanodeInfo> cachedLocs =
630 Lists.newLinkedList(Arrays.asList(b.getCachedLocations()));
631 for (int i = 0; i < locs.length; i++) {
632 DatanodeInfo loc = locs[i];
633 builder.addLocs(i, PBHelper.convert(loc));
634 boolean locIsCached = cachedLocs.contains(loc);
635 builder.addIsCached(locIsCached);
636 if (locIsCached) {
637 cachedLocs.remove(loc);
638 }
639 }
640 Preconditions.checkArgument(cachedLocs.size() == 0,
641 "Found additional cached replica locations that are not in the set of"
642 + " storage-backed locations!");
643
644 StorageType[] storageTypes = b.getStorageTypes();
645 if (storageTypes != null) {
646 for (int i = 0; i < storageTypes.length; ++i) {
647 builder.addStorageTypes(PBHelper.convertStorageType(storageTypes[i]));
648 }
649 }
650 final String[] storageIDs = b.getStorageIDs();
651 if (storageIDs != null) {
652 builder.addAllStorageIDs(Arrays.asList(storageIDs));
653 }
654
655 return builder.setB(PBHelper.convert(b.getBlock()))
656 .setBlockToken(PBHelper.convert(b.getBlockToken()))
657 .setCorrupt(b.isCorrupt()).setOffset(b.getStartOffset()).build();
658 }
659
660 public static LocatedBlock convert(LocatedBlockProto proto) {
661 if (proto == null) return null;
662 List<DatanodeInfoProto> locs = proto.getLocsList();
663 DatanodeInfo[] targets = new DatanodeInfo[locs.size()];
664 for (int i = 0; i < locs.size(); i++) {
665 targets[i] = PBHelper.convert(locs.get(i));
666 }
667
668 final int storageTypesCount = proto.getStorageTypesCount();
669 final StorageType[] storageTypes;
670 if (storageTypesCount == 0) {
671 storageTypes = null;
672 } else {
673 Preconditions.checkState(storageTypesCount == locs.size());
674 storageTypes = convertStorageTypeProtos(proto.getStorageTypesList());
675 }
676
677 final int storageIDsCount = proto.getStorageIDsCount();
678 final String[] storageIDs;
679 if (storageIDsCount == 0) {
680 storageIDs = null;
681 } else {
682 Preconditions.checkState(storageIDsCount == locs.size());
683 storageIDs = proto.getStorageIDsList().toArray(new String[storageIDsCount]);
684 }
685
686 // Set values from the isCached list, re-using references from loc
687 List<DatanodeInfo> cachedLocs = new ArrayList<DatanodeInfo>(locs.size());
688 List<Boolean> isCachedList = proto.getIsCachedList();
689 for (int i=0; i<isCachedList.size(); i++) {
690 if (isCachedList.get(i)) {
691 cachedLocs.add(targets[i]);
692 }
693 }
694
695 LocatedBlock lb = new LocatedBlock(PBHelper.convert(proto.getB()), targets,
696 storageIDs, storageTypes, proto.getOffset(), proto.getCorrupt(),
697 cachedLocs.toArray(new DatanodeInfo[0]));
698 lb.setBlockToken(PBHelper.convert(proto.getBlockToken()));
699
700 return lb;
701 }
702
703 public static TokenProto convert(Token<?> tok) {
704 return TokenProto.newBuilder().
705 setIdentifier(ByteString.copyFrom(tok.getIdentifier())).
706 setPassword(ByteString.copyFrom(tok.getPassword())).
707 setKind(tok.getKind().toString()).
708 setService(tok.getService().toString()).build();
709 }
710
711 public static Token<BlockTokenIdentifier> convert(
712 TokenProto blockToken) {
713 return new Token<BlockTokenIdentifier>(blockToken.getIdentifier()
714 .toByteArray(), blockToken.getPassword().toByteArray(), new Text(
715 blockToken.getKind()), new Text(blockToken.getService()));
716 }
717
718
719 public static Token<DelegationTokenIdentifier> convertDelegationToken(
720 TokenProto blockToken) {
721 return new Token<DelegationTokenIdentifier>(blockToken.getIdentifier()
722 .toByteArray(), blockToken.getPassword().toByteArray(), new Text(
723 blockToken.getKind()), new Text(blockToken.getService()));
724 }
725
726 public static ReplicaState convert(ReplicaStateProto state) {
727 switch (state) {
728 case RBW:
729 return ReplicaState.RBW;
730 case RUR:
731 return ReplicaState.RUR;
732 case RWR:
733 return ReplicaState.RWR;
734 case TEMPORARY:
735 return ReplicaState.TEMPORARY;
736 case FINALIZED:
737 default:
738 return ReplicaState.FINALIZED;
739 }
740 }
741
742 public static ReplicaStateProto convert(ReplicaState state) {
743 switch (state) {
744 case RBW:
745 return ReplicaStateProto.RBW;
746 case RUR:
747 return ReplicaStateProto.RUR;
748 case RWR:
749 return ReplicaStateProto.RWR;
750 case TEMPORARY:
751 return ReplicaStateProto.TEMPORARY;
752 case FINALIZED:
753 default:
754 return ReplicaStateProto.FINALIZED;
755 }
756 }
757
758 public static DatanodeRegistrationProto convert(
759 DatanodeRegistration registration) {
760 DatanodeRegistrationProto.Builder builder = DatanodeRegistrationProto
761 .newBuilder();
762 return builder.setDatanodeID(PBHelper.convert((DatanodeID) registration))
763 .setStorageInfo(PBHelper.convert(registration.getStorageInfo()))
764 .setKeys(PBHelper.convert(registration.getExportedKeys()))
765 .setSoftwareVersion(registration.getSoftwareVersion()).build();
766 }
767
768 public static DatanodeRegistration convert(DatanodeRegistrationProto proto) {
769 StorageInfo si = convert(proto.getStorageInfo(), NodeType.DATA_NODE);
770 return new DatanodeRegistration(PBHelper.convert(proto.getDatanodeID()),
771 si, PBHelper.convert(proto.getKeys()), proto.getSoftwareVersion());
772 }
773
774 public static DatanodeCommand convert(DatanodeCommandProto proto) {
775 switch (proto.getCmdType()) {
776 case BalancerBandwidthCommand:
777 return PBHelper.convert(proto.getBalancerCmd());
778 case BlockCommand:
779 return PBHelper.convert(proto.getBlkCmd());
780 case BlockRecoveryCommand:
781 return PBHelper.convert(proto.getRecoveryCmd());
782 case FinalizeCommand:
783 return PBHelper.convert(proto.getFinalizeCmd());
784 case KeyUpdateCommand:
785 return PBHelper.convert(proto.getKeyUpdateCmd());
786 case RegisterCommand:
787 return REG_CMD;
788 case BlockIdCommand:
789 return PBHelper.convert(proto.getBlkIdCmd());
790 default:
791 return null;
792 }
793 }
794
795 public static BalancerBandwidthCommandProto convert(
796 BalancerBandwidthCommand bbCmd) {
797 return BalancerBandwidthCommandProto.newBuilder()
798 .setBandwidth(bbCmd.getBalancerBandwidthValue()).build();
799 }
800
801 public static KeyUpdateCommandProto convert(KeyUpdateCommand cmd) {
802 return KeyUpdateCommandProto.newBuilder()
803 .setKeys(PBHelper.convert(cmd.getExportedKeys())).build();
804 }
805
806 public static BlockRecoveryCommandProto convert(BlockRecoveryCommand cmd) {
807 BlockRecoveryCommandProto.Builder builder = BlockRecoveryCommandProto
808 .newBuilder();
809 for (RecoveringBlock b : cmd.getRecoveringBlocks()) {
810 builder.addBlocks(PBHelper.convert(b));
811 }
812 return builder.build();
813 }
814
815 public static FinalizeCommandProto convert(FinalizeCommand cmd) {
816 return FinalizeCommandProto.newBuilder()
817 .setBlockPoolId(cmd.getBlockPoolId()).build();
818 }
819
820 public static BlockCommandProto convert(BlockCommand cmd) {
821 BlockCommandProto.Builder builder = BlockCommandProto.newBuilder()
822 .setBlockPoolId(cmd.getBlockPoolId());
823 switch (cmd.getAction()) {
824 case DatanodeProtocol.DNA_TRANSFER:
825 builder.setAction(BlockCommandProto.Action.TRANSFER);
826 break;
827 case DatanodeProtocol.DNA_INVALIDATE:
828 builder.setAction(BlockCommandProto.Action.INVALIDATE);
829 break;
830 case DatanodeProtocol.DNA_SHUTDOWN:
831 builder.setAction(BlockCommandProto.Action.SHUTDOWN);
832 break;
833 default:
834 throw new AssertionError("Invalid action");
835 }
836 Block[] blocks = cmd.getBlocks();
837 for (int i = 0; i < blocks.length; i++) {
838 builder.addBlocks(PBHelper.convert(blocks[i]));
839 }
840 builder.addAllTargets(convert(cmd.getTargets()))
841 .addAllTargetStorageUuids(convert(cmd.getTargetStorageIDs()));
842 return builder.build();
843 }
844
845 public static BlockIdCommandProto convert(BlockIdCommand cmd) {
846 BlockIdCommandProto.Builder builder = BlockIdCommandProto.newBuilder()
847 .setBlockPoolId(cmd.getBlockPoolId());
848 switch (cmd.getAction()) {
849 case DatanodeProtocol.DNA_CACHE:
850 builder.setAction(BlockIdCommandProto.Action.CACHE);
851 break;
852 case DatanodeProtocol.DNA_UNCACHE:
853 builder.setAction(BlockIdCommandProto.Action.UNCACHE);
854 break;
855 default:
856 throw new AssertionError("Invalid action");
857 }
858 long[] blockIds = cmd.getBlockIds();
859 for (int i = 0; i < blockIds.length; i++) {
860 builder.addBlockIds(blockIds[i]);
861 }
862 return builder.build();
863 }
864
865 private static List<DatanodeInfosProto> convert(DatanodeInfo[][] targets) {
866 DatanodeInfosProto[] ret = new DatanodeInfosProto[targets.length];
867 for (int i = 0; i < targets.length; i++) {
868 ret[i] = DatanodeInfosProto.newBuilder()
869 .addAllDatanodes(PBHelper.convert(targets[i])).build();
870 }
871 return Arrays.asList(ret);
872 }
873
874 private static List<StorageUuidsProto> convert(String[][] targetStorageUuids) {
875 StorageUuidsProto[] ret = new StorageUuidsProto[targetStorageUuids.length];
876 for (int i = 0; i < targetStorageUuids.length; i++) {
877 ret[i] = StorageUuidsProto.newBuilder()
878 .addAllStorageUuids(Arrays.asList(targetStorageUuids[i])).build();
879 }
880 return Arrays.asList(ret);
881 }
882
883 public static DatanodeCommandProto convert(DatanodeCommand datanodeCommand) {
884 DatanodeCommandProto.Builder builder = DatanodeCommandProto.newBuilder();
885 if (datanodeCommand == null) {
886 return builder.setCmdType(DatanodeCommandProto.Type.NullDatanodeCommand)
887 .build();
888 }
889 switch (datanodeCommand.getAction()) {
890 case DatanodeProtocol.DNA_BALANCERBANDWIDTHUPDATE:
891 builder.setCmdType(DatanodeCommandProto.Type.BalancerBandwidthCommand)
892 .setBalancerCmd(
893 PBHelper.convert((BalancerBandwidthCommand) datanodeCommand));
894 break;
895 case DatanodeProtocol.DNA_ACCESSKEYUPDATE:
896 builder
897 .setCmdType(DatanodeCommandProto.Type.KeyUpdateCommand)
898 .setKeyUpdateCmd(PBHelper.convert((KeyUpdateCommand) datanodeCommand));
899 break;
900 case DatanodeProtocol.DNA_RECOVERBLOCK:
901 builder.setCmdType(DatanodeCommandProto.Type.BlockRecoveryCommand)
902 .setRecoveryCmd(
903 PBHelper.convert((BlockRecoveryCommand) datanodeCommand));
904 break;
905 case DatanodeProtocol.DNA_FINALIZE:
906 builder.setCmdType(DatanodeCommandProto.Type.FinalizeCommand)
907 .setFinalizeCmd(PBHelper.convert((FinalizeCommand) datanodeCommand));
908 break;
909 case DatanodeProtocol.DNA_REGISTER:
910 builder.setCmdType(DatanodeCommandProto.Type.RegisterCommand)
911 .setRegisterCmd(REG_CMD_PROTO);
912 break;
913 case DatanodeProtocol.DNA_TRANSFER:
914 case DatanodeProtocol.DNA_INVALIDATE:
915 case DatanodeProtocol.DNA_SHUTDOWN:
916 builder.setCmdType(DatanodeCommandProto.Type.BlockCommand).
917 setBlkCmd(PBHelper.convert((BlockCommand) datanodeCommand));
918 break;
919 case DatanodeProtocol.DNA_CACHE:
920 case DatanodeProtocol.DNA_UNCACHE:
921 builder.setCmdType(DatanodeCommandProto.Type.BlockIdCommand).
922 setBlkIdCmd(PBHelper.convert((BlockIdCommand) datanodeCommand));
923 break;
924 case DatanodeProtocol.DNA_UNKNOWN: //Not expected
925 default:
926 builder.setCmdType(DatanodeCommandProto.Type.NullDatanodeCommand);
927 }
928 return builder.build();
929 }
930
931 public static KeyUpdateCommand convert(KeyUpdateCommandProto keyUpdateCmd) {
932 return new KeyUpdateCommand(PBHelper.convert(keyUpdateCmd.getKeys()));
933 }
934
935 public static FinalizeCommand convert(FinalizeCommandProto finalizeCmd) {
936 return new FinalizeCommand(finalizeCmd.getBlockPoolId());
937 }
938
939 public static BlockRecoveryCommand convert(
940 BlockRecoveryCommandProto recoveryCmd) {
941 List<RecoveringBlockProto> list = recoveryCmd.getBlocksList();
942 List<RecoveringBlock> recoveringBlocks = new ArrayList<RecoveringBlock>(
943 list.size());
944
945 for (RecoveringBlockProto rbp : list) {
946 recoveringBlocks.add(PBHelper.convert(rbp));
947 }
948 return new BlockRecoveryCommand(recoveringBlocks);
949 }
950
951 public static BlockCommand convert(BlockCommandProto blkCmd) {
952 List<BlockProto> blockProtoList = blkCmd.getBlocksList();
953 Block[] blocks = new Block[blockProtoList.size()];
954 for (int i = 0; i < blockProtoList.size(); i++) {
955 blocks[i] = PBHelper.convert(blockProtoList.get(i));
956 }
957 List<DatanodeInfosProto> targetList = blkCmd.getTargetsList();
958 DatanodeInfo[][] targets = new DatanodeInfo[targetList.size()][];
959 for (int i = 0; i < targetList.size(); i++) {
960 targets[i] = PBHelper.convert(targetList.get(i));
961 }
962
963 List<StorageUuidsProto> targetStorageUuidsList = blkCmd.getTargetStorageUuidsList();
964 String[][] targetStorageIDs = new String[targetStorageUuidsList.size()][];
965 for(int i = 0; i < targetStorageIDs.length; i++) {
966 List<String> storageIDs = targetStorageUuidsList.get(i).getStorageUuidsList();
967 targetStorageIDs[i] = storageIDs.toArray(new String[storageIDs.size()]);
968 }
969
970 int action = DatanodeProtocol.DNA_UNKNOWN;
971 switch (blkCmd.getAction()) {
972 case TRANSFER:
973 action = DatanodeProtocol.DNA_TRANSFER;
974 break;
975 case INVALIDATE:
976 action = DatanodeProtocol.DNA_INVALIDATE;
977 break;
978 case SHUTDOWN:
979 action = DatanodeProtocol.DNA_SHUTDOWN;
980 break;
981 default:
982 throw new AssertionError("Unknown action type: " + blkCmd.getAction());
983 }
984 return new BlockCommand(action, blkCmd.getBlockPoolId(), blocks, targets,
985 targetStorageIDs);
986 }
987
988 public static BlockIdCommand convert(BlockIdCommandProto blkIdCmd) {
989 int numBlockIds = blkIdCmd.getBlockIdsCount();
990 long blockIds[] = new long[numBlockIds];
991 for (int i = 0; i < numBlockIds; i++) {
992 blockIds[i] = blkIdCmd.getBlockIds(i);
993 }
994 int action = DatanodeProtocol.DNA_UNKNOWN;
995 switch (blkIdCmd.getAction()) {
996 case CACHE:
997 action = DatanodeProtocol.DNA_CACHE;
998 break;
999 case UNCACHE:
1000 action = DatanodeProtocol.DNA_UNCACHE;
1001 break;
1002 default:
1003 throw new AssertionError("Unknown action type: " + blkIdCmd.getAction());
1004 }
1005 return new BlockIdCommand(action, blkIdCmd.getBlockPoolId(), blockIds);
1006 }
1007
1008 public static DatanodeInfo[] convert(DatanodeInfosProto datanodeInfosProto) {
1009 List<DatanodeInfoProto> proto = datanodeInfosProto.getDatanodesList();
1010 DatanodeInfo[] infos = new DatanodeInfo[proto.size()];
1011 for (int i = 0; i < infos.length; i++) {
1012 infos[i] = PBHelper.convert(proto.get(i));
1013 }
1014 return infos;
1015 }
1016
1017 public static BalancerBandwidthCommand convert(
1018 BalancerBandwidthCommandProto balancerCmd) {
1019 return new BalancerBandwidthCommand(balancerCmd.getBandwidth());
1020 }
1021
1022 public static ReceivedDeletedBlockInfoProto convert(
1023 ReceivedDeletedBlockInfo receivedDeletedBlockInfo) {
1024 ReceivedDeletedBlockInfoProto.Builder builder =
1025 ReceivedDeletedBlockInfoProto.newBuilder();
1026
1027 ReceivedDeletedBlockInfoProto.BlockStatus status;
1028 switch (receivedDeletedBlockInfo.getStatus()) {
1029 case RECEIVING_BLOCK:
1030 status = ReceivedDeletedBlockInfoProto.BlockStatus.RECEIVING;
1031 break;
1032 case RECEIVED_BLOCK:
1033 status = ReceivedDeletedBlockInfoProto.BlockStatus.RECEIVED;
1034 break;
1035 case DELETED_BLOCK:
1036 status = ReceivedDeletedBlockInfoProto.BlockStatus.DELETED;
1037 break;
1038 default:
1039 throw new IllegalArgumentException("Bad status: " +
1040 receivedDeletedBlockInfo.getStatus());
1041 }
1042 builder.setStatus(status);
1043
1044 if (receivedDeletedBlockInfo.getDelHints() != null) {
1045 builder.setDeleteHint(receivedDeletedBlockInfo.getDelHints());
1046 }
1047 return builder.setBlock(PBHelper.convert(receivedDeletedBlockInfo.getBlock()))
1048 .build();
1049 }
1050
1051 public static ReceivedDeletedBlockInfo convert(
1052 ReceivedDeletedBlockInfoProto proto) {
1053 ReceivedDeletedBlockInfo.BlockStatus status = null;
1054 switch (proto.getStatus()) {
1055 case RECEIVING:
1056 status = BlockStatus.RECEIVING_BLOCK;
1057 break;
1058 case RECEIVED:
1059 status = BlockStatus.RECEIVED_BLOCK;
1060 break;
1061 case DELETED:
1062 status = BlockStatus.DELETED_BLOCK;
1063 break;
1064 }
1065 return new ReceivedDeletedBlockInfo(
1066 PBHelper.convert(proto.getBlock()),
1067 status,
1068 proto.hasDeleteHint() ? proto.getDeleteHint() : null);
1069 }
1070
1071 public static NamespaceInfoProto convert(NamespaceInfo info) {
1072 return NamespaceInfoProto.newBuilder()
1073 .setBlockPoolID(info.getBlockPoolID())
1074 .setBuildVersion(info.getBuildVersion())
1075 .setUnused(0)
1076 .setStorageInfo(PBHelper.convert((StorageInfo)info))
1077 .setSoftwareVersion(info.getSoftwareVersion()).build();
1078 }
1079
1080 // Located Block Arrays and Lists
1081 public static LocatedBlockProto[] convertLocatedBlock(LocatedBlock[] lb) {
1082 if (lb == null) return null;
1083 return convertLocatedBlock2(Arrays.asList(lb)).toArray(
1084 new LocatedBlockProto[lb.length]);
1085 }
1086
1087 public static LocatedBlock[] convertLocatedBlock(LocatedBlockProto[] lb) {
1088 if (lb == null) return null;
1089 return convertLocatedBlock(Arrays.asList(lb)).toArray(
1090 new LocatedBlock[lb.length]);
1091 }
1092
1093 public static List<LocatedBlock> convertLocatedBlock(
1094 List<LocatedBlockProto> lb) {
1095 if (lb == null) return null;
1096 final int len = lb.size();
1097 List<LocatedBlock> result =
1098 new ArrayList<LocatedBlock>(len);
1099 for (int i = 0; i < len; ++i) {
1100 result.add(PBHelper.convert(lb.get(i)));
1101 }
1102 return result;
1103 }
1104
1105 public static List<LocatedBlockProto> convertLocatedBlock2(List<LocatedBlock> lb) {
1106 if (lb == null) return null;
1107 final int len = lb.size();
1108 List<LocatedBlockProto> result = new ArrayList<LocatedBlockProto>(len);
1109 for (int i = 0; i < len; ++i) {
1110 result.add(PBHelper.convert(lb.get(i)));
1111 }
1112 return result;
1113 }
1114
1115
1116 // LocatedBlocks
1117 public static LocatedBlocks convert(LocatedBlocksProto lb) {
1118 return new LocatedBlocks(
1119 lb.getFileLength(), lb.getUnderConstruction(),
1120 PBHelper.convertLocatedBlock(lb.getBlocksList()),
1121 lb.hasLastBlock() ? PBHelper.convert(lb.getLastBlock()) : null,
1122 lb.getIsLastBlockComplete());
1123 }
1124
1125 public static LocatedBlocksProto convert(LocatedBlocks lb) {
1126 if (lb == null) {
1127 return null;
1128 }
1129 LocatedBlocksProto.Builder builder =
1130 LocatedBlocksProto.newBuilder();
1131 if (lb.getLastLocatedBlock() != null) {
1132 builder.setLastBlock(PBHelper.convert(lb.getLastLocatedBlock()));
1133 }
1134 return builder.setFileLength(lb.getFileLength())
1135 .setUnderConstruction(lb.isUnderConstruction())
1136 .addAllBlocks(PBHelper.convertLocatedBlock2(lb.getLocatedBlocks()))
1137 .setIsLastBlockComplete(lb.isLastBlockComplete()).build();
1138 }
1139
1140 // DataEncryptionKey
1141 public static DataEncryptionKey convert(DataEncryptionKeyProto bet) {
1142 String encryptionAlgorithm = bet.getEncryptionAlgorithm();
1143 return new DataEncryptionKey(bet.getKeyId(),
1144 bet.getBlockPoolId(),
1145 bet.getNonce().toByteArray(),
1146 bet.getEncryptionKey().toByteArray(),
1147 bet.getExpiryDate(),
1148 encryptionAlgorithm.isEmpty() ? null : encryptionAlgorithm);
1149 }
1150
1151 public static DataEncryptionKeyProto convert(DataEncryptionKey bet) {
1152 DataEncryptionKeyProto.Builder b = DataEncryptionKeyProto.newBuilder()
1153 .setKeyId(bet.keyId)
1154 .setBlockPoolId(bet.blockPoolId)
1155 .setNonce(ByteString.copyFrom(bet.nonce))
1156 .setEncryptionKey(ByteString.copyFrom(bet.encryptionKey))
1157 .setExpiryDate(bet.expiryDate);
1158 if (bet.encryptionAlgorithm != null) {
1159 b.setEncryptionAlgorithm(bet.encryptionAlgorithm);
1160 }
1161 return b.build();
1162 }
1163
1164 public static FsServerDefaults convert(FsServerDefaultsProto fs) {
1165 if (fs == null) return null;
1166 return new FsServerDefaults(
1167 fs.getBlockSize(), fs.getBytesPerChecksum(),
1168 fs.getWritePacketSize(), (short) fs.getReplication(),
1169 fs.getFileBufferSize(),
1170 fs.getEncryptDataTransfer(),
1171 fs.getTrashInterval(),
1172 PBHelper.convert(fs.getChecksumType()));
1173 }
1174
1175 public static FsServerDefaultsProto convert(FsServerDefaults fs) {
1176 if (fs == null) return null;
1177 return FsServerDefaultsProto.newBuilder().
1178 setBlockSize(fs.getBlockSize()).
1179 setBytesPerChecksum(fs.getBytesPerChecksum()).
1180 setWritePacketSize(fs.getWritePacketSize())
1181 .setReplication(fs.getReplication())
1182 .setFileBufferSize(fs.getFileBufferSize())
1183 .setEncryptDataTransfer(fs.getEncryptDataTransfer())
1184 .setTrashInterval(fs.getTrashInterval())
1185 .setChecksumType(PBHelper.convert(fs.getChecksumType()))
1186 .build();
1187 }
1188
1189 public static FsPermissionProto convert(FsPermission p) {
1190 if (p == null) return null;
1191 return FsPermissionProto.newBuilder().setPerm(p.toShort()).build();
1192 }
1193
1194 public static FsPermission convert(FsPermissionProto p) {
1195 if (p == null) return null;
1196 return new FsPermission((short)p.getPerm());
1197 }
1198
1199
1200 // The creatFlag field in PB is a bitmask whose values are the same a the
1201 // emum values of CreateFlag
1202 public static int convertCreateFlag(EnumSetWritable<CreateFlag> flag) {
1203 int value = 0;
1204 if (flag.contains(CreateFlag.APPEND)) {
1205 value |= CreateFlagProto.APPEND.getNumber();
1206 }
1207 if (flag.contains(CreateFlag.CREATE)) {
1208 value |= CreateFlagProto.CREATE.getNumber();
1209 }
1210 if (flag.contains(CreateFlag.OVERWRITE)) {
1211 value |= CreateFlagProto.OVERWRITE.getNumber();
1212 }
1213 return value;
1214 }
1215
1216 public static EnumSetWritable<CreateFlag> convertCreateFlag(int flag) {
1217 EnumSet<CreateFlag> result =
1218 EnumSet.noneOf(CreateFlag.class);
1219 if ((flag & CreateFlagProto.APPEND_VALUE) == CreateFlagProto.APPEND_VALUE) {
1220 result.add(CreateFlag.APPEND);
1221 }
1222 if ((flag & CreateFlagProto.CREATE_VALUE) == CreateFlagProto.CREATE_VALUE) {
1223 result.add(CreateFlag.CREATE);
1224 }
1225 if ((flag & CreateFlagProto.OVERWRITE_VALUE)
1226 == CreateFlagProto.OVERWRITE_VALUE) {
1227 result.add(CreateFlag.OVERWRITE);
1228 }
1229 return new EnumSetWritable<CreateFlag>(result);
1230 }
1231
1232 public static int convertCacheFlags(EnumSet<CacheFlag> flags) {
1233 int value = 0;
1234 if (flags.contains(CacheFlag.FORCE)) {
1235 value |= CacheFlagProto.FORCE.getNumber();
1236 }
1237 return value;
1238 }
1239
1240 public static EnumSet<CacheFlag> convertCacheFlags(int flags) {
1241 EnumSet<CacheFlag> result = EnumSet.noneOf(CacheFlag.class);
1242 if ((flags & CacheFlagProto.FORCE_VALUE) == CacheFlagProto.FORCE_VALUE) {
1243 result.add(CacheFlag.FORCE);
1244 }
1245 return result;
1246 }
1247
1248 public static HdfsFileStatus convert(HdfsFileStatusProto fs) {
1249 if (fs == null)
1250 return null;
1251 return new HdfsLocatedFileStatus(
1252 fs.getLength(), fs.getFileType().equals(FileType.IS_DIR),
1253 fs.getBlockReplication(), fs.getBlocksize(),
1254 fs.getModificationTime(), fs.getAccessTime(),
1255 PBHelper.convert(fs.getPermission()), fs.getOwner(), fs.getGroup(),
1256 fs.getFileType().equals(FileType.IS_SYMLINK) ?
1257 fs.getSymlink().toByteArray() : null,
1258 fs.getPath().toByteArray(),
1259 fs.hasFileId()? fs.getFileId(): INodeId.GRANDFATHER_INODE_ID,
1260 fs.hasLocations() ? PBHelper.convert(fs.getLocations()) : null,
1261 fs.hasChildrenNum() ? fs.getChildrenNum() : -1);
1262 }
1263
1264 public static SnapshottableDirectoryStatus convert(
1265 SnapshottableDirectoryStatusProto sdirStatusProto) {
1266 if (sdirStatusProto == null) {
1267 return null;
1268 }
1269 final HdfsFileStatusProto status = sdirStatusProto.getDirStatus();
1270 return new SnapshottableDirectoryStatus(
1271 status.getModificationTime(),
1272 status.getAccessTime(),
1273 PBHelper.convert(status.getPermission()),
1274 status.getOwner(),
1275 status.getGroup(),
1276 status.getPath().toByteArray(),
1277 status.getFileId(),
1278 status.getChildrenNum(),
1279 sdirStatusProto.getSnapshotNumber(),
1280 sdirStatusProto.getSnapshotQuota(),
1281 sdirStatusProto.getParentFullpath().toByteArray());
1282 }
1283
1284 public static HdfsFileStatusProto convert(HdfsFileStatus fs) {
1285 if (fs == null)
1286 return null;
1287 FileType fType = FileType.IS_FILE;
1288 if (fs.isDir()) {
1289 fType = FileType.IS_DIR;
1290 } else if (fs.isSymlink()) {
1291 fType = FileType.IS_SYMLINK;
1292 }
1293
1294 HdfsFileStatusProto.Builder builder =
1295 HdfsFileStatusProto.newBuilder().
1296 setLength(fs.getLen()).
1297 setFileType(fType).
1298 setBlockReplication(fs.getReplication()).
1299 setBlocksize(fs.getBlockSize()).
1300 setModificationTime(fs.getModificationTime()).
1301 setAccessTime(fs.getAccessTime()).
1302 setPermission(PBHelper.convert(fs.getPermission())).
1303 setOwner(fs.getOwner()).
1304 setGroup(fs.getGroup()).
1305 setFileId(fs.getFileId()).
1306 setChildrenNum(fs.getChildrenNum()).
1307 setPath(ByteString.copyFrom(fs.getLocalNameInBytes()));
1308 if (fs.isSymlink()) {
1309 builder.setSymlink(ByteString.copyFrom(fs.getSymlinkInBytes()));
1310 }
1311 if (fs instanceof HdfsLocatedFileStatus) {
1312 LocatedBlocks locations = ((HdfsLocatedFileStatus)fs).getBlockLocations();
1313 if (locations != null) {
1314 builder.setLocations(PBHelper.convert(locations));
1315 }
1316 }
1317 return builder.build();
1318 }
1319
1320 public static SnapshottableDirectoryStatusProto convert(
1321 SnapshottableDirectoryStatus status) {
1322 if (status == null) {
1323 return null;
1324 }
1325 int snapshotNumber = status.getSnapshotNumber();
1326 int snapshotQuota = status.getSnapshotQuota();
1327 byte[] parentFullPath = status.getParentFullPath();
1328 ByteString parentFullPathBytes = ByteString.copyFrom(
1329 parentFullPath == null ? DFSUtil.EMPTY_BYTES : parentFullPath);
1330 HdfsFileStatusProto fs = convert(status.getDirStatus());
1331 SnapshottableDirectoryStatusProto.Builder builder =
1332 SnapshottableDirectoryStatusProto
1333 .newBuilder().setSnapshotNumber(snapshotNumber)
1334 .setSnapshotQuota(snapshotQuota).setParentFullpath(parentFullPathBytes)
1335 .setDirStatus(fs);
1336 return builder.build();
1337 }
1338
1339 public static HdfsFileStatusProto[] convert(HdfsFileStatus[] fs) {
1340 if (fs == null) return null;
1341 final int len = fs.length;
1342 HdfsFileStatusProto[] result = new HdfsFileStatusProto[len];
1343 for (int i = 0; i < len; ++i) {
1344 result[i] = PBHelper.convert(fs[i]);
1345 }
1346 return result;
1347 }
1348
1349 public static HdfsFileStatus[] convert(HdfsFileStatusProto[] fs) {
1350 if (fs == null) return null;
1351 final int len = fs.length;
1352 HdfsFileStatus[] result = new HdfsFileStatus[len];
1353 for (int i = 0; i < len; ++i) {
1354 result[i] = PBHelper.convert(fs[i]);
1355 }
1356 return result;
1357 }
1358
1359 public static DirectoryListing convert(DirectoryListingProto dl) {
1360 if (dl == null)
1361 return null;
1362 List<HdfsFileStatusProto> partList = dl.getPartialListingList();
1363 return new DirectoryListing(
1364 partList.isEmpty() ? new HdfsLocatedFileStatus[0]
1365 : PBHelper.convert(
1366 partList.toArray(new HdfsFileStatusProto[partList.size()])),
1367 dl.getRemainingEntries());
1368 }
1369
1370 public static DirectoryListingProto convert(DirectoryListing d) {
1371 if (d == null)
1372 return null;
1373 return DirectoryListingProto.newBuilder().
1374 addAllPartialListing(Arrays.asList(
1375 PBHelper.convert(d.getPartialListing()))).
1376 setRemainingEntries(d.getRemainingEntries()).
1377 build();
1378 }
1379
1380 public static long[] convert(GetFsStatsResponseProto res) {
1381 long[] result = new long[6];
1382 result[ClientProtocol.GET_STATS_CAPACITY_IDX] = res.getCapacity();
1383 result[ClientProtocol.GET_STATS_USED_IDX] = res.getUsed();
1384 result[ClientProtocol.GET_STATS_REMAINING_IDX] = res.getRemaining();
1385 result[ClientProtocol.GET_STATS_UNDER_REPLICATED_IDX] = res.getUnderReplicated();
1386 result[ClientProtocol.GET_STATS_CORRUPT_BLOCKS_IDX] = res.getCorruptBlocks();
1387 result[ClientProtocol.GET_STATS_MISSING_BLOCKS_IDX] = res.getMissingBlocks();
1388 return result;
1389 }
1390
1391 public static GetFsStatsResponseProto convert(long[] fsStats) {
1392 GetFsStatsResponseProto.Builder result = GetFsStatsResponseProto
1393 .newBuilder();
1394 if (fsStats.length >= ClientProtocol.GET_STATS_CAPACITY_IDX + 1)
1395 result.setCapacity(fsStats[ClientProtocol.GET_STATS_CAPACITY_IDX]);
1396 if (fsStats.length >= ClientProtocol.GET_STATS_USED_IDX + 1)
1397 result.setUsed(fsStats[ClientProtocol.GET_STATS_USED_IDX]);
1398 if (fsStats.length >= ClientProtocol.GET_STATS_REMAINING_IDX + 1)
1399 result.setRemaining(fsStats[ClientProtocol.GET_STATS_REMAINING_IDX]);
1400 if (fsStats.length >= ClientProtocol.GET_STATS_UNDER_REPLICATED_IDX + 1)
1401 result.setUnderReplicated(
1402 fsStats[ClientProtocol.GET_STATS_UNDER_REPLICATED_IDX]);
1403 if (fsStats.length >= ClientProtocol.GET_STATS_CORRUPT_BLOCKS_IDX + 1)
1404 result.setCorruptBlocks(
1405 fsStats[ClientProtocol.GET_STATS_CORRUPT_BLOCKS_IDX]);
1406 if (fsStats.length >= ClientProtocol.GET_STATS_MISSING_BLOCKS_IDX + 1)
1407 result.setMissingBlocks(
1408 fsStats[ClientProtocol.GET_STATS_MISSING_BLOCKS_IDX]);
1409 return result.build();
1410 }
1411
1412 public static DatanodeReportTypeProto
1413 convert(DatanodeReportType t) {
1414 switch (t) {
1415 case ALL: return DatanodeReportTypeProto.ALL;
1416 case LIVE: return DatanodeReportTypeProto.LIVE;
1417 case DEAD: return DatanodeReportTypeProto.DEAD;
1418 default:
1419 throw new IllegalArgumentException("Unexpected data type report:" + t);
1420 }
1421 }
1422
1423 public static DatanodeReportType
1424 convert(DatanodeReportTypeProto t) {
1425 switch (t) {
1426 case ALL: return DatanodeReportType.ALL;
1427 case LIVE: return DatanodeReportType.LIVE;
1428 case DEAD: return DatanodeReportType.DEAD;
1429 default:
1430 throw new IllegalArgumentException("Unexpected data type report:" + t);
1431 }
1432 }
1433
1434 public static SafeModeActionProto convert(
1435 SafeModeAction a) {
1436 switch (a) {
1437 case SAFEMODE_LEAVE:
1438 return SafeModeActionProto.SAFEMODE_LEAVE;
1439 case SAFEMODE_ENTER:
1440 return SafeModeActionProto.SAFEMODE_ENTER;
1441 case SAFEMODE_GET:
1442 return SafeModeActionProto.SAFEMODE_GET;
1443 default:
1444 throw new IllegalArgumentException("Unexpected SafeModeAction :" + a);
1445 }
1446 }
1447
1448 public static SafeModeAction convert(
1449 ClientNamenodeProtocolProtos.SafeModeActionProto a) {
1450 switch (a) {
1451 case SAFEMODE_LEAVE:
1452 return SafeModeAction.SAFEMODE_LEAVE;
1453 case SAFEMODE_ENTER:
1454 return SafeModeAction.SAFEMODE_ENTER;
1455 case SAFEMODE_GET:
1456 return SafeModeAction.SAFEMODE_GET;
1457 default:
1458 throw new IllegalArgumentException("Unexpected SafeModeAction :" + a);
1459 }
1460 }
1461
1462 public static RollingUpgradeActionProto convert(RollingUpgradeAction a) {
1463 switch (a) {
1464 case QUERY:
1465 return RollingUpgradeActionProto.QUERY;
1466 case PREPARE:
1467 return RollingUpgradeActionProto.START;
1468 case FINALIZE:
1469 return RollingUpgradeActionProto.FINALIZE;
1470 default:
1471 throw new IllegalArgumentException("Unexpected value: " + a);
1472 }
1473 }
1474
1475 public static RollingUpgradeAction convert(RollingUpgradeActionProto a) {
1476 switch (a) {
1477 case QUERY:
1478 return RollingUpgradeAction.QUERY;
1479 case START:
1480 return RollingUpgradeAction.PREPARE;
1481 case FINALIZE:
1482 return RollingUpgradeAction.FINALIZE;
1483 default:
1484 throw new IllegalArgumentException("Unexpected value: " + a);
1485 }
1486 }
1487
1488 public static RollingUpgradeStatusProto convertRollingUpgradeStatus(
1489 RollingUpgradeStatus status) {
1490 return RollingUpgradeStatusProto.newBuilder()
1491 .setBlockPoolId(status.getBlockPoolId())
1492 .build();
1493 }
1494
1495 public static RollingUpgradeStatus convert(RollingUpgradeStatusProto proto) {
1496 return new RollingUpgradeStatus(proto.getBlockPoolId());
1497 }
1498
1499 public static RollingUpgradeInfoProto convert(RollingUpgradeInfo info) {
1500 return RollingUpgradeInfoProto.newBuilder()
1501 .setStatus(convertRollingUpgradeStatus(info))
1502 .setCreatedRollbackImages(info.createdRollbackImages())
1503 .setStartTime(info.getStartTime())
1504 .setFinalizeTime(info.getFinalizeTime())
1505 .build();
1506 }
1507
1508 public static RollingUpgradeInfo convert(RollingUpgradeInfoProto proto) {
1509 RollingUpgradeStatusProto status = proto.getStatus();
1510 return new RollingUpgradeInfo(status.getBlockPoolId(),
1511 proto.getCreatedRollbackImages(),
1512 proto.getStartTime(), proto.getFinalizeTime());
1513 }
1514
1515 public static CorruptFileBlocks convert(CorruptFileBlocksProto c) {
1516 if (c == null)
1517 return null;
1518 List<String> fileList = c.getFilesList();
1519 return new CorruptFileBlocks(fileList.toArray(new String[fileList.size()]),
1520 c.getCookie());
1521 }
1522
1523 public static CorruptFileBlocksProto convert(CorruptFileBlocks c) {
1524 if (c == null)
1525 return null;
1526 return CorruptFileBlocksProto.newBuilder().
1527 addAllFiles(Arrays.asList(c.getFiles())).
1528 setCookie(c.getCookie()).
1529 build();
1530 }
1531
1532 public static ContentSummary convert(ContentSummaryProto cs) {
1533 if (cs == null) return null;
1534 return new ContentSummary(
1535 cs.getLength(), cs.getFileCount(), cs.getDirectoryCount(), cs.getQuota(),
1536 cs.getSpaceConsumed(), cs.getSpaceQuota());
1537 }
1538
1539 public static ContentSummaryProto convert(ContentSummary cs) {
1540 if (cs == null) return null;
1541 return ContentSummaryProto.newBuilder().
1542 setLength(cs.getLength()).
1543 setFileCount(cs.getFileCount()).
1544 setDirectoryCount(cs.getDirectoryCount()).
1545 setQuota(cs.getQuota()).
1546 setSpaceConsumed(cs.getSpaceConsumed()).
1547 setSpaceQuota(cs.getSpaceQuota()).
1548 build();
1549 }
1550
1551 public static NNHAStatusHeartbeat convert(NNHAStatusHeartbeatProto s) {
1552 if (s == null) return null;
1553 switch (s.getState()) {
1554 case ACTIVE:
1555 return new NNHAStatusHeartbeat(HAServiceState.ACTIVE, s.getTxid());
1556 case STANDBY:
1557 return new NNHAStatusHeartbeat(HAServiceState.STANDBY, s.getTxid());
1558 default:
1559 throw new IllegalArgumentException("Unexpected NNHAStatusHeartbeat.State:" + s.getState());
1560 }
1561 }
1562
1563 public static NNHAStatusHeartbeatProto convert(NNHAStatusHeartbeat hb) {
1564 if (hb == null) return null;
1565 NNHAStatusHeartbeatProto.Builder builder =
1566 NNHAStatusHeartbeatProto.newBuilder();
1567 switch (hb.getState()) {
1568 case ACTIVE:
1569 builder.setState(NNHAStatusHeartbeatProto.State.ACTIVE);
1570 break;
1571 case STANDBY:
1572 builder.setState(NNHAStatusHeartbeatProto.State.STANDBY);
1573 break;
1574 default:
1575 throw new IllegalArgumentException("Unexpected NNHAStatusHeartbeat.State:" +
1576 hb.getState());
1577 }
1578 builder.setTxid(hb.getTxId());
1579 return builder.build();
1580 }
1581
1582 public static DatanodeStorageProto convert(DatanodeStorage s) {
1583 return DatanodeStorageProto.newBuilder()
1584 .setState(PBHelper.convertState(s.getState()))
1585 .setStorageType(PBHelper.convertStorageType(s.getStorageType()))
1586 .setStorageUuid(s.getStorageID()).build();
1587 }
1588
1589 private static StorageState convertState(State state) {
1590 switch(state) {
1591 case READ_ONLY_SHARED:
1592 return StorageState.READ_ONLY_SHARED;
1593 case NORMAL:
1594 default:
1595 return StorageState.NORMAL;
1596 }
1597 }
1598
1599 private static StorageTypeProto convertStorageType(
1600 StorageType type) {
1601 switch(type) {
1602 case DISK:
1603 return StorageTypeProto.DISK;
1604 case SSD:
1605 return StorageTypeProto.SSD;
1606 default:
1607 throw new IllegalStateException(
1608 "BUG: StorageType not found, type=" + type);
1609 }
1610 }
1611
1612 public static DatanodeStorage convert(DatanodeStorageProto s) {
1613 return new DatanodeStorage(s.getStorageUuid(),
1614 PBHelper.convertState(s.getState()),
1615 PBHelper.convertType(s.getStorageType()));
1616 }
1617
1618 private static State convertState(StorageState state) {
1619 switch(state) {
1620 case READ_ONLY_SHARED:
1621 return DatanodeStorage.State.READ_ONLY_SHARED;
1622 case NORMAL:
1623 default:
1624 return DatanodeStorage.State.NORMAL;
1625 }
1626 }
1627
1628 private static StorageType convertType(StorageTypeProto type) {
1629 switch(type) {
1630 case DISK:
1631 return StorageType.DISK;
1632 case SSD:
1633 return StorageType.SSD;
1634 default:
1635 throw new IllegalStateException(
1636 "BUG: StorageTypeProto not found, type=" + type);
1637 }
1638 }
1639
1640 private static StorageType[] convertStorageTypeProtos(
1641 List<StorageTypeProto> storageTypesList) {
1642 final StorageType[] storageTypes = new StorageType[storageTypesList.size()];
1643 for (int i = 0; i < storageTypes.length; ++i) {
1644 storageTypes[i] = PBHelper.convertType(storageTypesList.get(i));
1645 }
1646 return storageTypes;
1647 }
1648
1649 public static StorageReportProto convert(StorageReport r) {
1650 StorageReportProto.Builder builder = StorageReportProto.newBuilder()
1651 .setBlockPoolUsed(r.getBlockPoolUsed()).setCapacity(r.getCapacity())
1652 .setDfsUsed(r.getDfsUsed()).setRemaining(r.getRemaining())
1653 .setStorageUuid(r.getStorage().getStorageID())
1654 .setStorage(convert(r.getStorage()));
1655 return builder.build();
1656 }
1657
1658 public static StorageReport convert(StorageReportProto p) {
1659 return new StorageReport(
1660 p.hasStorage() ?
1661 convert(p.getStorage()) :
1662 new DatanodeStorage(p.getStorageUuid()),
1663 p.getFailed(), p.getCapacity(), p.getDfsUsed(), p.getRemaining(),
1664 p.getBlockPoolUsed());
1665 }
1666
1667 public static StorageReport[] convertStorageReports(
1668 List<StorageReportProto> list) {
1669 final StorageReport[] report = new StorageReport[list.size()];
1670 for (int i = 0; i < report.length; i++) {
1671 report[i] = convert(list.get(i));
1672 }
1673 return report;
1674 }
1675
1676 public static JournalInfo convert(JournalInfoProto info) {
1677 int lv = info.hasLayoutVersion() ? info.getLayoutVersion() : 0;
1678 int nsID = info.hasNamespaceID() ? info.getNamespaceID() : 0;
1679 return new JournalInfo(lv, info.getClusterID(), nsID);
1680 }
1681
1682 /**
1683 * Method used for converting {@link JournalInfoProto} sent from Namenode
1684 * to Journal receivers to {@link NamenodeRegistration}.
1685 */
1686 public static JournalInfoProto convert(JournalInfo j) {
1687 return JournalInfoProto.newBuilder().setClusterID(j.getClusterId())
1688 .setLayoutVersion(j.getLayoutVersion())
1689 .setNamespaceID(j.getNamespaceId()).build();
1690 }
1691
1692 public static SnapshottableDirectoryStatus[] convert(
1693 SnapshottableDirectoryListingProto sdlp) {
1694 if (sdlp == null)
1695 return null;
1696 List<SnapshottableDirectoryStatusProto> list = sdlp
1697 .getSnapshottableDirListingList();
1698 if (list.isEmpty()) {
1699 return new SnapshottableDirectoryStatus[0];
1700 } else {
1701 SnapshottableDirectoryStatus[] result =
1702 new SnapshottableDirectoryStatus[list.size()];
1703 for (int i = 0; i < list.size(); i++) {
1704 result[i] = PBHelper.convert(list.get(i));
1705 }
1706 return result;
1707 }
1708 }
1709
1710 public static SnapshottableDirectoryListingProto convert(
1711 SnapshottableDirectoryStatus[] status) {
1712 if (status == null)
1713 return null;
1714 SnapshottableDirectoryStatusProto[] protos =
1715 new SnapshottableDirectoryStatusProto[status.length];
1716 for (int i = 0; i < status.length; i++) {
1717 protos[i] = PBHelper.convert(status[i]);
1718 }
1719 List<SnapshottableDirectoryStatusProto> protoList = Arrays.asList(protos);
1720 return SnapshottableDirectoryListingProto.newBuilder()
1721 .addAllSnapshottableDirListing(protoList).build();
1722 }
1723
1724 public static DiffReportEntry convert(SnapshotDiffReportEntryProto entry) {
1725 if (entry == null) {
1726 return null;
1727 }
1728 DiffType type = DiffType.getTypeFromLabel(entry
1729 .getModificationLabel());
1730 return type == null ? null :
1731 new DiffReportEntry(type, entry.getFullpath().toByteArray());
1732 }
1733
1734 public static SnapshotDiffReportEntryProto convert(DiffReportEntry entry) {
1735 if (entry == null) {
1736 return null;
1737 }
1738 byte[] fullPath = entry.getRelativePath();
1739 ByteString fullPathString = ByteString
1740 .copyFrom(fullPath == null ? DFSUtil.EMPTY_BYTES : fullPath);
1741
1742 String modification = entry.getType().getLabel();
1743
1744 SnapshotDiffReportEntryProto entryProto = SnapshotDiffReportEntryProto
1745 .newBuilder().setFullpath(fullPathString)
1746 .setModificationLabel(modification).build();
1747 return entryProto;
1748 }
1749
1750 public static SnapshotDiffReport convert(SnapshotDiffReportProto reportProto) {
1751 if (reportProto == null) {
1752 return null;
1753 }
1754 String snapshotDir = reportProto.getSnapshotRoot();
1755 String fromSnapshot = reportProto.getFromSnapshot();
1756 String toSnapshot = reportProto.getToSnapshot();
1757 List<SnapshotDiffReportEntryProto> list = reportProto
1758 .getDiffReportEntriesList();
1759 List<DiffReportEntry> entries = new ArrayList<DiffReportEntry>();
1760 for (SnapshotDiffReportEntryProto entryProto : list) {
1761 DiffReportEntry entry = convert(entryProto);
1762 if (entry != null)
1763 entries.add(entry);
1764 }
1765 return new SnapshotDiffReport(snapshotDir, fromSnapshot, toSnapshot,
1766 entries);
1767 }
1768
1769 public static SnapshotDiffReportProto convert(SnapshotDiffReport report) {
1770 if (report == null) {
1771 return null;
1772 }
1773 List<DiffReportEntry> entries = report.getDiffList();
1774 List<SnapshotDiffReportEntryProto> entryProtos =
1775 new ArrayList<SnapshotDiffReportEntryProto>();
1776 for (DiffReportEntry entry : entries) {
1777 SnapshotDiffReportEntryProto entryProto = convert(entry);
1778 if (entryProto != null)
1779 entryProtos.add(entryProto);
1780 }
1781
1782 SnapshotDiffReportProto reportProto = SnapshotDiffReportProto.newBuilder()
1783 .setSnapshotRoot(report.getSnapshotRoot())
1784 .setFromSnapshot(report.getFromSnapshot())
1785 .setToSnapshot(report.getLaterSnapshotName())
1786 .addAllDiffReportEntries(entryProtos).build();
1787 return reportProto;
1788 }
1789
1790 public static DataChecksum.Type convert(HdfsProtos.ChecksumTypeProto type) {
1791 return DataChecksum.Type.valueOf(type.getNumber());
1792 }
1793
1794 public static CacheDirectiveInfoProto convert
1795 (CacheDirectiveInfo info) {
1796 CacheDirectiveInfoProto.Builder builder =
1797 CacheDirectiveInfoProto.newBuilder();
1798 if (info.getId() != null) {
1799 builder.setId(info.getId());
1800 }
1801 if (info.getPath() != null) {
1802 builder.setPath(info.getPath().toUri().getPath());
1803 }
1804 if (info.getReplication() != null) {
1805 builder.setReplication(info.getReplication());
1806 }
1807 if (info.getPool() != null) {
1808 builder.setPool(info.getPool());
1809 }
1810 if (info.getExpiration() != null) {
1811 builder.setExpiration(convert(info.getExpiration()));
1812 }
1813 return builder.build();
1814 }
1815
1816 public static CacheDirectiveInfo convert
1817 (CacheDirectiveInfoProto proto) {
1818 CacheDirectiveInfo.Builder builder =
1819 new CacheDirectiveInfo.Builder();
1820 if (proto.hasId()) {
1821 builder.setId(proto.getId());
1822 }
1823 if (proto.hasPath()) {
1824 builder.setPath(new Path(proto.getPath()));
1825 }
1826 if (proto.hasReplication()) {
1827 builder.setReplication(Shorts.checkedCast(
1828 proto.getReplication()));
1829 }
1830 if (proto.hasPool()) {
1831 builder.setPool(proto.getPool());
1832 }
1833 if (proto.hasExpiration()) {
1834 builder.setExpiration(convert(proto.getExpiration()));
1835 }
1836 return builder.build();
1837 }
1838
1839 public static CacheDirectiveInfoExpirationProto convert(
1840 CacheDirectiveInfo.Expiration expiration) {
1841 return CacheDirectiveInfoExpirationProto.newBuilder()
1842 .setIsRelative(expiration.isRelative())
1843 .setMillis(expiration.getMillis())
1844 .build();
1845 }
1846
1847 public static CacheDirectiveInfo.Expiration convert(
1848 CacheDirectiveInfoExpirationProto proto) {
1849 if (proto.getIsRelative()) {
1850 return CacheDirectiveInfo.Expiration.newRelative(proto.getMillis());
1851 }
1852 return CacheDirectiveInfo.Expiration.newAbsolute(proto.getMillis());
1853 }
1854
1855 public static CacheDirectiveStatsProto convert(CacheDirectiveStats stats) {
1856 CacheDirectiveStatsProto.Builder builder =
1857 CacheDirectiveStatsProto.newBuilder();
1858 builder.setBytesNeeded(stats.getBytesNeeded());
1859 builder.setBytesCached(stats.getBytesCached());
1860 builder.setFilesNeeded(stats.getFilesNeeded());
1861 builder.setFilesCached(stats.getFilesCached());
1862 builder.setHasExpired(stats.hasExpired());
1863 return builder.build();
1864 }
1865
1866 public static CacheDirectiveStats convert(CacheDirectiveStatsProto proto) {
1867 CacheDirectiveStats.Builder builder = new CacheDirectiveStats.Builder();
1868 builder.setBytesNeeded(proto.getBytesNeeded());
1869 builder.setBytesCached(proto.getBytesCached());
1870 builder.setFilesNeeded(proto.getFilesNeeded());
1871 builder.setFilesCached(proto.getFilesCached());
1872 builder.setHasExpired(proto.getHasExpired());
1873 return builder.build();
1874 }
1875
1876 public static CacheDirectiveEntryProto convert(CacheDirectiveEntry entry) {
1877 CacheDirectiveEntryProto.Builder builder =
1878 CacheDirectiveEntryProto.newBuilder();
1879 builder.setInfo(PBHelper.convert(entry.getInfo()));
1880 builder.setStats(PBHelper.convert(entry.getStats()));
1881 return builder.build();
1882 }
1883
1884 public static CacheDirectiveEntry convert(CacheDirectiveEntryProto proto) {
1885 CacheDirectiveInfo info = PBHelper.convert(proto.getInfo());
1886 CacheDirectiveStats stats = PBHelper.convert(proto.getStats());
1887 return new CacheDirectiveEntry(info, stats);
1888 }
1889
1890 public static CachePoolInfoProto convert(CachePoolInfo info) {
1891 CachePoolInfoProto.Builder builder = CachePoolInfoProto.newBuilder();
1892 builder.setPoolName(info.getPoolName());
1893 if (info.getOwnerName() != null) {
1894 builder.setOwnerName(info.getOwnerName());
1895 }
1896 if (info.getGroupName() != null) {
1897 builder.setGroupName(info.getGroupName());
1898 }
1899 if (info.getMode() != null) {
1900 builder.setMode(info.getMode().toShort());
1901 }
1902 if (info.getLimit() != null) {
1903 builder.setLimit(info.getLimit());
1904 }
1905 if (info.getMaxRelativeExpiryMs() != null) {
1906 builder.setMaxRelativeExpiry(info.getMaxRelativeExpiryMs());
1907 }
1908 return builder.build();
1909 }
1910
1911 public static CachePoolInfo convert (CachePoolInfoProto proto) {
1912 // Pool name is a required field, the rest are optional
1913 String poolName = checkNotNull(proto.getPoolName());
1914 CachePoolInfo info = new CachePoolInfo(poolName);
1915 if (proto.hasOwnerName()) {
1916 info.setOwnerName(proto.getOwnerName());
1917 }
1918 if (proto.hasGroupName()) {
1919 info.setGroupName(proto.getGroupName());
1920 }
1921 if (proto.hasMode()) {
1922 info.setMode(new FsPermission((short)proto.getMode()));
1923 }
1924 if (proto.hasLimit()) {
1925 info.setLimit(proto.getLimit());
1926 }
1927 if (proto.hasMaxRelativeExpiry()) {
1928 info.setMaxRelativeExpiryMs(proto.getMaxRelativeExpiry());
1929 }
1930 return info;
1931 }
1932
1933 public static CachePoolStatsProto convert(CachePoolStats stats) {
1934 CachePoolStatsProto.Builder builder = CachePoolStatsProto.newBuilder();
1935 builder.setBytesNeeded(stats.getBytesNeeded());
1936 builder.setBytesCached(stats.getBytesCached());
1937 builder.setBytesOverlimit(stats.getBytesOverlimit());
1938 builder.setFilesNeeded(stats.getFilesNeeded());
1939 builder.setFilesCached(stats.getFilesCached());
1940 return builder.build();
1941 }
1942
1943 public static CachePoolStats convert (CachePoolStatsProto proto) {
1944 CachePoolStats.Builder builder = new CachePoolStats.Builder();
1945 builder.setBytesNeeded(proto.getBytesNeeded());
1946 builder.setBytesCached(proto.getBytesCached());
1947 builder.setBytesOverlimit(proto.getBytesOverlimit());
1948 builder.setFilesNeeded(proto.getFilesNeeded());
1949 builder.setFilesCached(proto.getFilesCached());
1950 return builder.build();
1951 }
1952
1953 public static CachePoolEntryProto convert(CachePoolEntry entry) {
1954 CachePoolEntryProto.Builder builder = CachePoolEntryProto.newBuilder();
1955 builder.setInfo(PBHelper.convert(entry.getInfo()));
1956 builder.setStats(PBHelper.convert(entry.getStats()));
1957 return builder.build();
1958 }
1959
1960 public static CachePoolEntry convert (CachePoolEntryProto proto) {
1961 CachePoolInfo info = PBHelper.convert(proto.getInfo());
1962 CachePoolStats stats = PBHelper.convert(proto.getStats());
1963 return new CachePoolEntry(info, stats);
1964 }
1965
1966 public static HdfsProtos.ChecksumTypeProto convert(DataChecksum.Type type) {
1967 return HdfsProtos.ChecksumTypeProto.valueOf(type.id);
1968 }
1969
1970 public static DatanodeLocalInfoProto convert(DatanodeLocalInfo info) {
1971 DatanodeLocalInfoProto.Builder builder = DatanodeLocalInfoProto.newBuilder();
1972 builder.setSoftwareVersion(info.getSoftwareVersion());
1973 builder.setConfigVersion(info.getConfigVersion());
1974 builder.setUptime(info.getUptime());
1975 return builder.build();
1976 }
1977
1978 public static DatanodeLocalInfo convert(DatanodeLocalInfoProto proto) {
1979 return new DatanodeLocalInfo(proto.getSoftwareVersion(),
1980 proto.getConfigVersion(), proto.getUptime());
1981 }
1982
1983 public static InputStream vintPrefixed(final InputStream input)
1984 throws IOException {
1985 final int firstByte = input.read();
1986 if (firstByte == -1) {
1987 throw new EOFException("Premature EOF: no length prefix available");
1988 }
1989
1990 int size = CodedInputStream.readRawVarint32(firstByte, input);
1991 assert size >= 0;
1992 return new ExactSizeInputStream(input, size);
1993 }
1994
1995 private static AclEntryScopeProto convert(AclEntryScope v) {
1996 return AclEntryScopeProto.valueOf(v.ordinal());
1997 }
1998
1999 private static AclEntryScope convert(AclEntryScopeProto v) {
2000 return castEnum(v, ACL_ENTRY_SCOPE_VALUES);
2001 }
2002
2003 private static AclEntryTypeProto convert(AclEntryType e) {
2004 return AclEntryTypeProto.valueOf(e.ordinal());
2005 }
2006
2007 private static AclEntryType convert(AclEntryTypeProto v) {
2008 return castEnum(v, ACL_ENTRY_TYPE_VALUES);
2009 }
2010
2011 private static FsActionProto convert(FsAction v) {
2012 return FsActionProto.valueOf(v != null ? v.ordinal() : 0);
2013 }
2014
2015 private static FsAction convert(FsActionProto v) {
2016 return castEnum(v, FSACTION_VALUES);
2017 }
2018
2019 public static List<AclEntryProto> convertAclEntryProto(
2020 List<AclEntry> aclSpec) {
2021 ArrayList<AclEntryProto> r = Lists.newArrayListWithCapacity(aclSpec.size());
2022 for (AclEntry e : aclSpec) {
2023 AclEntryProto.Builder builder = AclEntryProto.newBuilder();
2024 builder.setType(convert(e.getType()));
2025 builder.setScope(convert(e.getScope()));
2026 builder.setPermissions(convert(e.getPermission()));
2027 if (e.getName() != null) {
2028 builder.setName(e.getName());
2029 }
2030 r.add(builder.build());
2031 }
2032 return r;
2033 }
2034
2035 public static List<AclEntry> convertAclEntry(List<AclEntryProto> aclSpec) {
2036 ArrayList<AclEntry> r = Lists.newArrayListWithCapacity(aclSpec.size());
2037 for (AclEntryProto e : aclSpec) {
2038 AclEntry.Builder builder = new AclEntry.Builder();
2039 builder.setType(convert(e.getType()));
2040 builder.setScope(convert(e.getScope()));
2041 builder.setPermission(convert(e.getPermissions()));
2042 if (e.hasName()) {
2043 builder.setName(e.getName());
2044 }
2045 r.add(builder.build());
2046 }
2047 return r;
2048 }
2049
2050 public static AclStatus convert(GetAclStatusResponseProto e) {
2051 AclStatusProto r = e.getResult();
2052 return new AclStatus.Builder().owner(r.getOwner()).group(r.getGroup())
2053 .stickyBit(r.getSticky())
2054 .addEntries(convertAclEntry(r.getEntriesList())).build();
2055 }
2056
2057 public static GetAclStatusResponseProto convert(AclStatus e) {
2058 AclStatusProto r = AclStatusProto.newBuilder().setOwner(e.getOwner())
2059 .setGroup(e.getGroup()).setSticky(e.isStickyBit())
2060 .addAllEntries(convertAclEntryProto(e.getEntries())).build();
2061 return GetAclStatusResponseProto.newBuilder().setResult(r).build();
2062 }
2063
2064 public static ShortCircuitShmSlotProto convert(SlotId slotId) {
2065 return ShortCircuitShmSlotProto.newBuilder().
2066 setShmId(convert(slotId.getShmId())).
2067 setSlotIdx(slotId.getSlotIdx()).
2068 build();
2069 }
2070
2071 public static ShortCircuitShmIdProto convert(ShmId shmId) {
2072 return ShortCircuitShmIdProto.newBuilder().
2073 setHi(shmId.getHi()).
2074 setLo(shmId.getLo()).
2075 build();
2076
2077 }
2078
2079 public static SlotId convert(ShortCircuitShmSlotProto slotId) {
2080 return new SlotId(PBHelper.convert(slotId.getShmId()),
2081 slotId.getSlotIdx());
2082 }
2083
2084 public static ShmId convert(ShortCircuitShmIdProto shmId) {
2085 return new ShmId(shmId.getHi(), shmId.getLo());
2086 }
2087 }
2088