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 java.util.ArrayList;
021 import java.util.Arrays;
022 import java.util.EnumSet;
023 import java.util.List;
024
025 import org.apache.hadoop.fs.ContentSummary;
026 import org.apache.hadoop.fs.CreateFlag;
027 import org.apache.hadoop.fs.FsServerDefaults;
028 import org.apache.hadoop.fs.permission.FsPermission;
029 import org.apache.hadoop.hdfs.server.protocol.StorageReport;
030 import org.apache.hadoop.hdfs.protocol.Block;
031 import org.apache.hadoop.hdfs.protocol.ClientProtocol;
032 import org.apache.hadoop.hdfs.protocol.CorruptFileBlocks;
033 import org.apache.hadoop.hdfs.protocol.DatanodeID;
034 import org.apache.hadoop.hdfs.protocol.DatanodeInfo;
035 import org.apache.hadoop.hdfs.protocol.DatanodeInfo.AdminStates;
036 import org.apache.hadoop.hdfs.protocol.DirectoryListing;
037 import org.apache.hadoop.hdfs.protocol.ExtendedBlock;
038 import org.apache.hadoop.hdfs.protocol.HdfsConstants.DatanodeReportType;
039 import org.apache.hadoop.hdfs.protocol.HdfsConstants.SafeModeAction;
040 import org.apache.hadoop.hdfs.protocol.HdfsConstants.UpgradeAction;
041 import org.apache.hadoop.hdfs.protocol.HdfsFileStatus;
042 import org.apache.hadoop.hdfs.protocol.HdfsLocatedFileStatus;
043 import org.apache.hadoop.hdfs.protocol.LocatedBlock;
044 import org.apache.hadoop.hdfs.protocol.LocatedBlocks;
045 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos;
046 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.CreateFlagProto;
047 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.DatanodeReportTypeProto;
048 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.GetFsStatsResponseProto;
049 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.SafeModeActionProto;
050 import org.apache.hadoop.hdfs.protocol.proto.ClientNamenodeProtocolProtos.UpgradeActionProto;
051 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BalancerBandwidthCommandProto;
052 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockCommandProto;
053 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.BlockRecoveryCommandProto;
054 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.DatanodeCommandProto;
055 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.DatanodeRegistrationProto;
056 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.DatanodeStorageProto;
057 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.DatanodeStorageProto.StorageState;
058 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.FinalizeCommandProto;
059 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.KeyUpdateCommandProto;
060 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.NNHAStatusHeartbeatProto;
061 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.ReceivedDeletedBlockInfoProto;
062 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.RegisterCommandProto;
063 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.StorageReportProto;
064 import org.apache.hadoop.hdfs.protocol.proto.DatanodeProtocolProtos.UpgradeCommandProto;
065 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.BlockKeyProto;
066 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.BlockProto;
067 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.BlockTokenIdentifierProto;
068 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.BlockWithLocationsProto;
069 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.BlocksWithLocationsProto;
070 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.CheckpointCommandProto;
071 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.CheckpointSignatureProto;
072 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.ContentSummaryProto;
073 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.CorruptFileBlocksProto;
074 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeIDProto;
075 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto;
076 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.AdminState;
077 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfosProto;
078 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DirectoryListingProto;
079 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.ExportedBlockKeysProto;
080 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.ExtendedBlockProto;
081 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.FsPermissionProto;
082 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.FsServerDefaultsProto;
083 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.HdfsFileStatusProto;
084 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.HdfsFileStatusProto.FileType;
085 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.LocatedBlockProto;
086 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.LocatedBlockProto.Builder;
087 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.LocatedBlocksProto;
088 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.NamenodeCommandProto;
089 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.NamenodeRegistrationProto;
090 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.NamespaceInfoProto;
091 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.RecoveringBlockProto;
092 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.RemoteEditLogManifestProto;
093 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.RemoteEditLogProto;
094 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.NamenodeRegistrationProto.NamenodeRoleProto;
095 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.ReplicaStateProto;
096 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.StorageInfoProto;
097 import org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.UpgradeStatusReportProto;
098 import org.apache.hadoop.hdfs.protocol.proto.JournalProtocolProtos.JournalInfoProto;
099 import org.apache.hadoop.hdfs.security.token.block.BlockKey;
100 import org.apache.hadoop.hdfs.security.token.block.BlockTokenIdentifier;
101 import org.apache.hadoop.hdfs.security.token.block.ExportedBlockKeys;
102 import org.apache.hadoop.hdfs.security.token.delegation.DelegationTokenIdentifier;
103 import org.apache.hadoop.hdfs.server.common.HdfsServerConstants.NamenodeRole;
104 import org.apache.hadoop.hdfs.server.common.HdfsServerConstants.ReplicaState;
105 import org.apache.hadoop.hdfs.server.common.StorageInfo;
106 import org.apache.hadoop.hdfs.server.common.UpgradeStatusReport;
107 import org.apache.hadoop.hdfs.server.namenode.CheckpointSignature;
108 import org.apache.hadoop.hdfs.server.protocol.BalancerBandwidthCommand;
109 import org.apache.hadoop.hdfs.server.protocol.BlockCommand;
110 import org.apache.hadoop.hdfs.server.protocol.BlockRecoveryCommand;
111 import org.apache.hadoop.hdfs.server.protocol.BlockRecoveryCommand.RecoveringBlock;
112 import org.apache.hadoop.hdfs.server.protocol.BlocksWithLocations;
113 import org.apache.hadoop.hdfs.server.protocol.BlocksWithLocations.BlockWithLocations;
114 import org.apache.hadoop.hdfs.server.protocol.CheckpointCommand;
115 import org.apache.hadoop.hdfs.server.protocol.DatanodeCommand;
116 import org.apache.hadoop.hdfs.server.protocol.DatanodeProtocol;
117 import org.apache.hadoop.hdfs.server.protocol.DatanodeRegistration;
118 import org.apache.hadoop.hdfs.server.protocol.DatanodeStorage;
119 import org.apache.hadoop.hdfs.server.protocol.DatanodeStorage.State;
120 import org.apache.hadoop.hdfs.server.protocol.FinalizeCommand;
121 import org.apache.hadoop.hdfs.server.protocol.JournalInfo;
122 import org.apache.hadoop.hdfs.server.protocol.KeyUpdateCommand;
123 import org.apache.hadoop.hdfs.server.protocol.NamenodeCommand;
124 import org.apache.hadoop.hdfs.server.protocol.NamenodeRegistration;
125 import org.apache.hadoop.hdfs.server.protocol.NamespaceInfo;
126 import org.apache.hadoop.hdfs.server.protocol.NNHAStatusHeartbeat;
127 import org.apache.hadoop.hdfs.server.protocol.ReceivedDeletedBlockInfo;
128 import org.apache.hadoop.hdfs.server.protocol.ReceivedDeletedBlockInfo.BlockStatus;
129 import org.apache.hadoop.hdfs.server.protocol.RegisterCommand;
130 import org.apache.hadoop.hdfs.server.protocol.RemoteEditLog;
131 import org.apache.hadoop.hdfs.server.protocol.RemoteEditLogManifest;
132 import org.apache.hadoop.hdfs.server.protocol.UpgradeCommand;
133 import org.apache.hadoop.io.EnumSetWritable;
134 import org.apache.hadoop.io.Text;
135 import org.apache.hadoop.security.token.Token;
136
137 import com.google.protobuf.ByteString;
138
139 /**
140 * Utilities for converting protobuf classes to and from implementation classes.
141 *
142 * Note that when converting from an internal type to protobuf type, the
143 * converter never return null for protobuf type. The check for internal type
144 * being null must be done before calling the convert() method.
145 */
146 public class PBHelper {
147 private static final RegisterCommandProto REG_CMD_PROTO =
148 RegisterCommandProto.newBuilder().build();
149 private static final RegisterCommand REG_CMD = new RegisterCommand();
150
151 private PBHelper() {
152 /** Hidden constructor */
153 }
154
155 public static ByteString getByteString(byte[] bytes) {
156 return ByteString.copyFrom(bytes);
157 }
158
159 public static NamenodeRole convert(NamenodeRoleProto role) {
160 switch (role) {
161 case NAMENODE:
162 return NamenodeRole.NAMENODE;
163 case BACKUP:
164 return NamenodeRole.BACKUP;
165 case CHECKPOINT:
166 return NamenodeRole.CHECKPOINT;
167 }
168 return null;
169 }
170
171 public static NamenodeRoleProto convert(NamenodeRole role) {
172 switch (role) {
173 case NAMENODE:
174 return NamenodeRoleProto.NAMENODE;
175 case BACKUP:
176 return NamenodeRoleProto.BACKUP;
177 case CHECKPOINT:
178 return NamenodeRoleProto.CHECKPOINT;
179 }
180 return null;
181 }
182
183 public static StorageInfoProto convert(StorageInfo info) {
184 return StorageInfoProto.newBuilder().setClusterID(info.getClusterID())
185 .setCTime(info.getCTime()).setLayoutVersion(info.getLayoutVersion())
186 .setNamespceID(info.getNamespaceID()).build();
187 }
188
189 public static StorageInfo convert(StorageInfoProto info) {
190 return new StorageInfo(info.getLayoutVersion(), info.getNamespceID(),
191 info.getClusterID(), info.getCTime());
192 }
193
194 public static NamenodeRegistrationProto convert(NamenodeRegistration reg) {
195 return NamenodeRegistrationProto.newBuilder()
196 .setHttpAddress(reg.getHttpAddress()).setRole(convert(reg.getRole()))
197 .setRpcAddress(reg.getAddress())
198 .setStorageInfo(convert((StorageInfo) reg)).build();
199 }
200
201 public static NamenodeRegistration convert(NamenodeRegistrationProto reg) {
202 return new NamenodeRegistration(reg.getRpcAddress(), reg.getHttpAddress(),
203 convert(reg.getStorageInfo()), convert(reg.getRole()));
204 }
205
206 // DatanodeId
207 public static DatanodeID convert(DatanodeIDProto dn) {
208 return new DatanodeID(dn.getIpAddr(), dn.getHostName(), dn.getStorageID(),
209 dn.getXferPort(), dn.getInfoPort(), dn.getIpcPort());
210 }
211
212 public static DatanodeIDProto convert(DatanodeID dn) {
213 return DatanodeIDProto.newBuilder()
214 .setIpAddr(dn.getIpAddr())
215 .setHostName(dn.getHostName())
216 .setStorageID(dn.getStorageID())
217 .setXferPort(dn.getXferPort())
218 .setInfoPort(dn.getInfoPort())
219 .setIpcPort(dn.getIpcPort()).build();
220 }
221
222 // Arrays of DatanodeId
223 public static DatanodeIDProto[] convert(DatanodeID[] did) {
224 if (did == null) return null;
225 final int len = did.length;
226 DatanodeIDProto[] result = new DatanodeIDProto[len];
227 for (int i = 0; i < len; ++i) {
228 result[i] = convert(did[i]);
229 }
230 return result;
231 }
232
233 public static DatanodeID[] convert(DatanodeIDProto[] did) {
234 if (did == null) return null;
235 final int len = did.length;
236 DatanodeID[] result = new DatanodeID[len];
237 for (int i = 0; i < len; ++i) {
238 result[i] = convert(did[i]);
239 }
240 return result;
241 }
242
243 // Block
244 public static BlockProto convert(Block b) {
245 return BlockProto.newBuilder().setBlockId(b.getBlockId())
246 .setGenStamp(b.getGenerationStamp()).setNumBytes(b.getNumBytes())
247 .build();
248 }
249
250 public static Block convert(BlockProto b) {
251 return new Block(b.getBlockId(), b.getNumBytes(), b.getGenStamp());
252 }
253
254 public static BlockWithLocationsProto convert(BlockWithLocations blk) {
255 return BlockWithLocationsProto.newBuilder()
256 .setBlock(convert(blk.getBlock()))
257 .addAllStorageIDs(Arrays.asList(blk.getStorageIDs())).build();
258 }
259
260 public static BlockWithLocations convert(BlockWithLocationsProto b) {
261 return new BlockWithLocations(convert(b.getBlock()), b.getStorageIDsList()
262 .toArray(new String[0]));
263 }
264
265 public static BlocksWithLocationsProto convert(BlocksWithLocations blks) {
266 BlocksWithLocationsProto.Builder builder = BlocksWithLocationsProto
267 .newBuilder();
268 for (BlockWithLocations b : blks.getBlocks()) {
269 builder.addBlocks(convert(b));
270 }
271 return builder.build();
272 }
273
274 public static BlocksWithLocations convert(BlocksWithLocationsProto blocks) {
275 List<BlockWithLocationsProto> b = blocks.getBlocksList();
276 BlockWithLocations[] ret = new BlockWithLocations[b.size()];
277 int i = 0;
278 for (BlockWithLocationsProto entry : b) {
279 ret[i++] = convert(entry);
280 }
281 return new BlocksWithLocations(ret);
282 }
283
284 public static BlockKeyProto convert(BlockKey key) {
285 byte[] encodedKey = key.getEncodedKey();
286 ByteString keyBytes = ByteString.copyFrom(encodedKey == null ? new byte[0]
287 : encodedKey);
288 return BlockKeyProto.newBuilder().setKeyId(key.getKeyId())
289 .setKeyBytes(keyBytes).setExpiryDate(key.getExpiryDate()).build();
290 }
291
292 public static BlockKey convert(BlockKeyProto k) {
293 return new BlockKey(k.getKeyId(), k.getExpiryDate(), k.getKeyBytes()
294 .toByteArray());
295 }
296
297 public static ExportedBlockKeysProto convert(ExportedBlockKeys keys) {
298 ExportedBlockKeysProto.Builder builder = ExportedBlockKeysProto
299 .newBuilder();
300 builder.setIsBlockTokenEnabled(keys.isBlockTokenEnabled())
301 .setKeyUpdateInterval(keys.getKeyUpdateInterval())
302 .setTokenLifeTime(keys.getTokenLifetime())
303 .setCurrentKey(convert(keys.getCurrentKey()));
304 for (BlockKey k : keys.getAllKeys()) {
305 builder.addAllKeys(convert(k));
306 }
307 return builder.build();
308 }
309
310 public static ExportedBlockKeys convert(ExportedBlockKeysProto keys) {
311 return new ExportedBlockKeys(keys.getIsBlockTokenEnabled(),
312 keys.getKeyUpdateInterval(), keys.getTokenLifeTime(),
313 convert(keys.getCurrentKey()), convertBlockKeys(keys.getAllKeysList()));
314 }
315
316 public static CheckpointSignatureProto convert(CheckpointSignature s) {
317 return CheckpointSignatureProto.newBuilder()
318 .setBlockPoolId(s.getBlockpoolID())
319 .setCurSegmentTxId(s.getCurSegmentTxId())
320 .setMostRecentCheckpointTxId(s.getMostRecentCheckpointTxId())
321 .setStorageInfo(PBHelper.convert((StorageInfo) s)).build();
322 }
323
324 public static CheckpointSignature convert(CheckpointSignatureProto s) {
325 return new CheckpointSignature(PBHelper.convert(s.getStorageInfo()),
326 s.getBlockPoolId(), s.getMostRecentCheckpointTxId(),
327 s.getCurSegmentTxId());
328 }
329
330 public static RemoteEditLogProto convert(RemoteEditLog log) {
331 return RemoteEditLogProto.newBuilder().setEndTxId(log.getEndTxId())
332 .setStartTxId(log.getStartTxId()).build();
333 }
334
335 public static RemoteEditLog convert(RemoteEditLogProto l) {
336 return new RemoteEditLog(l.getStartTxId(), l.getEndTxId());
337 }
338
339 public static RemoteEditLogManifestProto convert(
340 RemoteEditLogManifest manifest) {
341 RemoteEditLogManifestProto.Builder builder = RemoteEditLogManifestProto
342 .newBuilder();
343 for (RemoteEditLog log : manifest.getLogs()) {
344 builder.addLogs(convert(log));
345 }
346 return builder.build();
347 }
348
349 public static RemoteEditLogManifest convert(
350 RemoteEditLogManifestProto manifest) {
351 List<RemoteEditLog> logs = new ArrayList<RemoteEditLog>(manifest
352 .getLogsList().size());
353 for (RemoteEditLogProto l : manifest.getLogsList()) {
354 logs.add(convert(l));
355 }
356 return new RemoteEditLogManifest(logs);
357 }
358
359 public static CheckpointCommandProto convert(CheckpointCommand cmd) {
360 return CheckpointCommandProto.newBuilder()
361 .setSignature(convert(cmd.getSignature()))
362 .setNeedToReturnImage(cmd.needToReturnImage()).build();
363 }
364
365 public static NamenodeCommandProto convert(NamenodeCommand cmd) {
366 if (cmd instanceof CheckpointCommand) {
367 return NamenodeCommandProto.newBuilder().setAction(cmd.getAction())
368 .setType(NamenodeCommandProto.Type.CheckPointCommand)
369 .setCheckpointCmd(convert((CheckpointCommand) cmd)).build();
370 }
371 return NamenodeCommandProto.newBuilder()
372 .setType(NamenodeCommandProto.Type.NamenodeCommand)
373 .setAction(cmd.getAction()).build();
374 }
375
376 public static BlockKey[] convertBlockKeys(List<BlockKeyProto> list) {
377 BlockKey[] ret = new BlockKey[list.size()];
378 int i = 0;
379 for (BlockKeyProto k : list) {
380 ret[i++] = convert(k);
381 }
382 return ret;
383 }
384
385 public static NamespaceInfo convert(NamespaceInfoProto info) {
386 StorageInfoProto storage = info.getStorageInfo();
387 return new NamespaceInfo(storage.getNamespceID(), storage.getClusterID(),
388 info.getBlockPoolID(), storage.getCTime(), info.getDistUpgradeVersion(),
389 info.getBuildVersion(), info.getSoftwareVersion());
390 }
391
392 public static NamenodeCommand convert(NamenodeCommandProto cmd) {
393 if (cmd == null) return null;
394 switch (cmd.getType()) {
395 case CheckPointCommand:
396 CheckpointCommandProto chkPt = cmd.getCheckpointCmd();
397 return new CheckpointCommand(PBHelper.convert(chkPt.getSignature()),
398 chkPt.getNeedToReturnImage());
399 default:
400 return new NamenodeCommand(cmd.getAction());
401 }
402 }
403
404 public static ExtendedBlock convert(ExtendedBlockProto eb) {
405 if (eb == null) return null;
406 return new ExtendedBlock( eb.getPoolId(), eb.getBlockId(), eb.getNumBytes(),
407 eb.getGenerationStamp());
408 }
409
410 public static ExtendedBlockProto convert(final ExtendedBlock b) {
411 if (b == null) return null;
412 return ExtendedBlockProto.newBuilder().
413 setPoolId(b.getBlockPoolId()).
414 setBlockId(b.getBlockId()).
415 setNumBytes(b.getNumBytes()).
416 setGenerationStamp(b.getGenerationStamp()).
417 build();
418 }
419
420 public static RecoveringBlockProto convert(RecoveringBlock b) {
421 if (b == null) {
422 return null;
423 }
424 LocatedBlockProto lb = PBHelper.convert((LocatedBlock)b);
425 return RecoveringBlockProto.newBuilder().setBlock(lb)
426 .setNewGenStamp(b.getNewGenerationStamp()).build();
427 }
428
429 public static RecoveringBlock convert(RecoveringBlockProto b) {
430 ExtendedBlock block = convert(b.getBlock().getB());
431 DatanodeInfo[] locs = convert(b.getBlock().getLocsList());
432 return new RecoveringBlock(block, locs, b.getNewGenStamp());
433 }
434
435 public static DatanodeInfoProto.AdminState convert(
436 final DatanodeInfo.AdminStates inAs) {
437 switch (inAs) {
438 case NORMAL: return DatanodeInfoProto.AdminState.NORMAL;
439 case DECOMMISSION_INPROGRESS:
440 return DatanodeInfoProto.AdminState.DECOMMISSION_INPROGRESS;
441 case DECOMMISSIONED: return DatanodeInfoProto.AdminState.DECOMMISSIONED;
442 default: return DatanodeInfoProto.AdminState.NORMAL;
443 }
444 }
445
446 static public DatanodeInfo convert(DatanodeInfoProto di) {
447 if (di == null) return null;
448 return new DatanodeInfo(
449 PBHelper.convert(di.getId()),
450 di.hasLocation() ? di.getLocation() : null ,
451 di.getCapacity(), di.getDfsUsed(), di.getRemaining(),
452 di.getBlockPoolUsed() , di.getLastUpdate() , di.getXceiverCount() ,
453 PBHelper.convert(di.getAdminState()));
454 }
455
456 static public DatanodeInfoProto convertDatanodeInfo(DatanodeInfo di) {
457 if (di == null) return null;
458 DatanodeInfoProto.Builder builder = DatanodeInfoProto.newBuilder();
459 if (di.getNetworkLocation() != null) {
460 builder.setLocation(di.getNetworkLocation());
461 }
462
463 return builder.
464 setId(PBHelper.convert((DatanodeID) di)).
465 setCapacity(di.getCapacity()).
466 setDfsUsed(di.getDfsUsed()).
467 setRemaining(di.getRemaining()).
468 setBlockPoolUsed(di.getBlockPoolUsed()).
469 setLastUpdate(di.getLastUpdate()).
470 setXceiverCount(di.getXceiverCount()).
471 setAdminState(PBHelper.convert(di.getAdminState())).
472 build();
473 }
474
475
476 static public DatanodeInfo[] convert(DatanodeInfoProto di[]) {
477 if (di == null) return null;
478 DatanodeInfo[] result = new DatanodeInfo[di.length];
479 for (int i = 0; i < di.length; i++) {
480 result[i] = convert(di[i]);
481 }
482 return result;
483 }
484
485 static public DatanodeInfoProto[] convert(DatanodeInfo[] di) {
486 if (di == null) return null;
487 DatanodeInfoProto[] result = new DatanodeInfoProto[di.length];
488 for (int i = 0; i < di.length; i++) {
489 result[i] = PBHelper.convertDatanodeInfo(di[i]);
490 }
491 return result;
492 }
493
494 public static DatanodeInfo[] convert(List<DatanodeInfoProto> list) {
495 DatanodeInfo[] info = new DatanodeInfo[list.size()];
496 for (int i = 0; i < info.length; i++) {
497 info[i] = convert(list.get(i));
498 }
499 return info;
500 }
501
502 public static DatanodeInfoProto convert(DatanodeInfo info) {
503 DatanodeInfoProto.Builder builder = DatanodeInfoProto.newBuilder();
504 builder.setBlockPoolUsed(info.getBlockPoolUsed());
505 builder.setAdminState(PBHelper.convert(info.getAdminState()));
506 builder.setCapacity(info.getCapacity())
507 .setDfsUsed(info.getDfsUsed())
508 .setId(PBHelper.convert((DatanodeID)info))
509 .setLastUpdate(info.getLastUpdate())
510 .setLocation(info.getNetworkLocation())
511 .setRemaining(info.getRemaining())
512 .setXceiverCount(info.getXceiverCount())
513 .build();
514 return builder.build();
515 }
516
517 public static AdminStates convert(AdminState adminState) {
518 switch(adminState) {
519 case DECOMMISSION_INPROGRESS:
520 return AdminStates.DECOMMISSION_INPROGRESS;
521 case DECOMMISSIONED:
522 return AdminStates.DECOMMISSIONED;
523 case NORMAL:
524 default:
525 return AdminStates.NORMAL;
526 }
527 }
528
529 public static LocatedBlockProto convert(LocatedBlock b) {
530 if (b == null) return null;
531 Builder builder = LocatedBlockProto.newBuilder();
532 DatanodeInfo[] locs = b.getLocations();
533 for (int i = 0; i < locs.length; i++) {
534 builder.addLocs(i, PBHelper.convert(locs[i]));
535 }
536 return builder.setB(PBHelper.convert(b.getBlock()))
537 .setBlockToken(PBHelper.convert(b.getBlockToken()))
538 .setCorrupt(b.isCorrupt()).setOffset(b.getStartOffset()).build();
539 }
540
541 public static LocatedBlock convert(LocatedBlockProto proto) {
542 if (proto == null) return null;
543 List<DatanodeInfoProto> locs = proto.getLocsList();
544 DatanodeInfo[] targets = new DatanodeInfo[locs.size()];
545 for (int i = 0; i < locs.size(); i++) {
546 targets[i] = PBHelper.convert(locs.get(i));
547 }
548 LocatedBlock lb = new LocatedBlock(PBHelper.convert(proto.getB()), targets,
549 proto.getOffset(), proto.getCorrupt());
550 lb.setBlockToken(PBHelper.convert(proto.getBlockToken()));
551 return lb;
552 }
553
554 public static BlockTokenIdentifierProto convert(Token<?> tok) {
555 return BlockTokenIdentifierProto.newBuilder().
556 setIdentifier(ByteString.copyFrom(tok.getIdentifier())).
557 setPassword(ByteString.copyFrom(tok.getPassword())).
558 setKind(tok.getKind().toString()).
559 setService(tok.getService().toString()).build();
560 }
561
562 public static Token<BlockTokenIdentifier> convert(
563 BlockTokenIdentifierProto blockToken) {
564 return new Token<BlockTokenIdentifier>(blockToken.getIdentifier()
565 .toByteArray(), blockToken.getPassword().toByteArray(), new Text(
566 blockToken.getKind()), new Text(blockToken.getService()));
567 }
568
569
570 public static Token<DelegationTokenIdentifier> convertDelegationToken(
571 BlockTokenIdentifierProto blockToken) {
572 return new Token<DelegationTokenIdentifier>(blockToken.getIdentifier()
573 .toByteArray(), blockToken.getPassword().toByteArray(), new Text(
574 blockToken.getKind()), new Text(blockToken.getService()));
575 }
576
577 public static ReplicaState convert(ReplicaStateProto state) {
578 switch (state) {
579 case RBW:
580 return ReplicaState.RBW;
581 case RUR:
582 return ReplicaState.RUR;
583 case RWR:
584 return ReplicaState.RWR;
585 case TEMPORARY:
586 return ReplicaState.TEMPORARY;
587 case FINALIZED:
588 default:
589 return ReplicaState.FINALIZED;
590 }
591 }
592
593 public static ReplicaStateProto convert(ReplicaState state) {
594 switch (state) {
595 case RBW:
596 return ReplicaStateProto.RBW;
597 case RUR:
598 return ReplicaStateProto.RUR;
599 case RWR:
600 return ReplicaStateProto.RWR;
601 case TEMPORARY:
602 return ReplicaStateProto.TEMPORARY;
603 case FINALIZED:
604 default:
605 return ReplicaStateProto.FINALIZED;
606 }
607 }
608
609 public static DatanodeRegistrationProto convert(
610 DatanodeRegistration registration) {
611 DatanodeRegistrationProto.Builder builder = DatanodeRegistrationProto
612 .newBuilder();
613 return builder.setDatanodeID(PBHelper.convert((DatanodeID) registration))
614 .setStorageInfo(PBHelper.convert(registration.getStorageInfo()))
615 .setKeys(PBHelper.convert(registration.getExportedKeys()))
616 .setSoftwareVersion(registration.getSoftwareVersion()).build();
617 }
618
619 public static DatanodeRegistration convert(DatanodeRegistrationProto proto) {
620 return new DatanodeRegistration(PBHelper.convert(proto.getDatanodeID()),
621 PBHelper.convert(proto.getStorageInfo()), PBHelper.convert(proto
622 .getKeys()), proto.getSoftwareVersion());
623 }
624
625 public static DatanodeCommand convert(DatanodeCommandProto proto) {
626 switch (proto.getCmdType()) {
627 case BalancerBandwidthCommand:
628 return PBHelper.convert(proto.getBalancerCmd());
629 case BlockCommand:
630 return PBHelper.convert(proto.getBlkCmd());
631 case BlockRecoveryCommand:
632 return PBHelper.convert(proto.getRecoveryCmd());
633 case FinalizeCommand:
634 return PBHelper.convert(proto.getFinalizeCmd());
635 case KeyUpdateCommand:
636 return PBHelper.convert(proto.getKeyUpdateCmd());
637 case RegisterCommand:
638 return REG_CMD;
639 case UpgradeCommand:
640 return PBHelper.convert(proto.getUpgradeCmd());
641 }
642 return null;
643 }
644
645 public static BalancerBandwidthCommandProto convert(
646 BalancerBandwidthCommand bbCmd) {
647 return BalancerBandwidthCommandProto.newBuilder()
648 .setBandwidth(bbCmd.getBalancerBandwidthValue()).build();
649 }
650
651 public static KeyUpdateCommandProto convert(KeyUpdateCommand cmd) {
652 return KeyUpdateCommandProto.newBuilder()
653 .setKeys(PBHelper.convert(cmd.getExportedKeys())).build();
654 }
655
656 public static BlockRecoveryCommandProto convert(BlockRecoveryCommand cmd) {
657 BlockRecoveryCommandProto.Builder builder = BlockRecoveryCommandProto
658 .newBuilder();
659 for (RecoveringBlock b : cmd.getRecoveringBlocks()) {
660 builder.addBlocks(PBHelper.convert(b));
661 }
662 return builder.build();
663 }
664
665 public static FinalizeCommandProto convert(FinalizeCommand cmd) {
666 return FinalizeCommandProto.newBuilder()
667 .setBlockPoolId(cmd.getBlockPoolId()).build();
668 }
669
670 public static BlockCommandProto convert(BlockCommand cmd) {
671 BlockCommandProto.Builder builder = BlockCommandProto.newBuilder()
672 .setBlockPoolId(cmd.getBlockPoolId());
673 switch (cmd.getAction()) {
674 case DatanodeProtocol.DNA_TRANSFER:
675 builder.setAction(BlockCommandProto.Action.TRANSFER);
676 break;
677 case DatanodeProtocol.DNA_INVALIDATE:
678 builder.setAction(BlockCommandProto.Action.INVALIDATE);
679 break;
680 case DatanodeProtocol.DNA_SHUTDOWN:
681 builder.setAction(BlockCommandProto.Action.SHUTDOWN);
682 break;
683 }
684 Block[] blocks = cmd.getBlocks();
685 for (int i = 0; i < blocks.length; i++) {
686 builder.addBlocks(PBHelper.convert(blocks[i]));
687 }
688 builder.addAllTargets(PBHelper.convert(cmd.getTargets()));
689 return builder.build();
690 }
691
692 private static List<DatanodeInfosProto> convert(DatanodeInfo[][] targets) {
693 DatanodeInfosProto[] ret = new DatanodeInfosProto[targets.length];
694 for (int i = 0; i < targets.length; i++) {
695 ret[i] = DatanodeInfosProto.newBuilder()
696 .addAllDatanodes(Arrays.asList(PBHelper.convert(targets[i]))).build();
697 }
698 return Arrays.asList(ret);
699 }
700
701 public static DatanodeCommandProto convert(DatanodeCommand datanodeCommand) {
702 DatanodeCommandProto.Builder builder = DatanodeCommandProto.newBuilder();
703 if (datanodeCommand == null) {
704 return builder.setCmdType(DatanodeCommandProto.Type.NullDatanodeCommand)
705 .build();
706 }
707 switch (datanodeCommand.getAction()) {
708 case DatanodeProtocol.DNA_BALANCERBANDWIDTHUPDATE:
709 builder.setCmdType(DatanodeCommandProto.Type.BalancerBandwidthCommand)
710 .setBalancerCmd(
711 PBHelper.convert((BalancerBandwidthCommand) datanodeCommand));
712 break;
713 case DatanodeProtocol.DNA_ACCESSKEYUPDATE:
714 builder
715 .setCmdType(DatanodeCommandProto.Type.KeyUpdateCommand)
716 .setKeyUpdateCmd(PBHelper.convert((KeyUpdateCommand) datanodeCommand));
717 break;
718 case DatanodeProtocol.DNA_RECOVERBLOCK:
719 builder.setCmdType(DatanodeCommandProto.Type.BlockRecoveryCommand)
720 .setRecoveryCmd(
721 PBHelper.convert((BlockRecoveryCommand) datanodeCommand));
722 break;
723 case DatanodeProtocol.DNA_FINALIZE:
724 builder.setCmdType(DatanodeCommandProto.Type.FinalizeCommand)
725 .setFinalizeCmd(PBHelper.convert((FinalizeCommand) datanodeCommand));
726 break;
727 case DatanodeProtocol.DNA_REGISTER:
728 builder.setCmdType(DatanodeCommandProto.Type.RegisterCommand)
729 .setRegisterCmd(REG_CMD_PROTO);
730 break;
731 case DatanodeProtocol.DNA_TRANSFER:
732 case DatanodeProtocol.DNA_INVALIDATE:
733 case DatanodeProtocol.DNA_SHUTDOWN:
734 builder.setCmdType(DatanodeCommandProto.Type.BlockCommand).setBlkCmd(
735 PBHelper.convert((BlockCommand) datanodeCommand));
736 break;
737 case DatanodeProtocol.DNA_UC_ACTION_REPORT_STATUS:
738 case DatanodeProtocol.DNA_UC_ACTION_START_UPGRADE:
739 builder.setCmdType(DatanodeCommandProto.Type.UpgradeCommand)
740 .setUpgradeCmd(PBHelper.convert((UpgradeCommand) datanodeCommand));
741 break;
742 case DatanodeProtocol.DNA_UNKNOWN: //Not expected
743 default:
744 builder.setCmdType(DatanodeCommandProto.Type.NullDatanodeCommand);
745 }
746 return builder.build();
747 }
748
749 public static UpgradeCommand convert(UpgradeCommandProto upgradeCmd) {
750 int action = UpgradeCommand.UC_ACTION_UNKNOWN;
751 switch (upgradeCmd.getAction()) {
752 case REPORT_STATUS:
753 action = UpgradeCommand.UC_ACTION_REPORT_STATUS;
754 break;
755 case START_UPGRADE:
756 action = UpgradeCommand.UC_ACTION_START_UPGRADE;
757 }
758 return new UpgradeCommand(action, upgradeCmd.getVersion(),
759 (short) upgradeCmd.getUpgradeStatus());
760 }
761
762 public static KeyUpdateCommand convert(KeyUpdateCommandProto keyUpdateCmd) {
763 return new KeyUpdateCommand(PBHelper.convert(keyUpdateCmd.getKeys()));
764 }
765
766 public static FinalizeCommand convert(FinalizeCommandProto finalizeCmd) {
767 return new FinalizeCommand(finalizeCmd.getBlockPoolId());
768 }
769
770 public static BlockRecoveryCommand convert(
771 BlockRecoveryCommandProto recoveryCmd) {
772 List<RecoveringBlockProto> list = recoveryCmd.getBlocksList();
773 List<RecoveringBlock> recoveringBlocks = new ArrayList<RecoveringBlock>(
774 list.size());
775
776 for (RecoveringBlockProto rbp : list) {
777 recoveringBlocks.add(PBHelper.convert(rbp));
778 }
779 return new BlockRecoveryCommand(recoveringBlocks);
780 }
781
782 public static BlockCommand convert(BlockCommandProto blkCmd) {
783 List<BlockProto> blockProtoList = blkCmd.getBlocksList();
784 Block[] blocks = new Block[blockProtoList.size()];
785 for (int i = 0; i < blockProtoList.size(); i++) {
786 blocks[i] = PBHelper.convert(blockProtoList.get(i));
787 }
788 List<DatanodeInfosProto> targetList = blkCmd.getTargetsList();
789 DatanodeInfo[][] targets = new DatanodeInfo[targetList.size()][];
790 for (int i = 0; i < targetList.size(); i++) {
791 targets[i] = PBHelper.convert(targetList.get(i));
792 }
793 int action = DatanodeProtocol.DNA_UNKNOWN;
794 switch (blkCmd.getAction()) {
795 case TRANSFER:
796 action = DatanodeProtocol.DNA_TRANSFER;
797 break;
798 case INVALIDATE:
799 action = DatanodeProtocol.DNA_INVALIDATE;
800 break;
801 case SHUTDOWN:
802 action = DatanodeProtocol.DNA_SHUTDOWN;
803 break;
804 }
805 return new BlockCommand(action, blkCmd.getBlockPoolId(), blocks, targets);
806 }
807
808 public static DatanodeInfo[] convert(DatanodeInfosProto datanodeInfosProto) {
809 List<DatanodeInfoProto> proto = datanodeInfosProto.getDatanodesList();
810 DatanodeInfo[] infos = new DatanodeInfo[proto.size()];
811 for (int i = 0; i < infos.length; i++) {
812 infos[i] = PBHelper.convert(proto.get(i));
813 }
814 return infos;
815 }
816
817 public static BalancerBandwidthCommand convert(
818 BalancerBandwidthCommandProto balancerCmd) {
819 return new BalancerBandwidthCommand(balancerCmd.getBandwidth());
820 }
821
822 public static ReceivedDeletedBlockInfoProto convert(
823 ReceivedDeletedBlockInfo receivedDeletedBlockInfo) {
824 ReceivedDeletedBlockInfoProto.Builder builder =
825 ReceivedDeletedBlockInfoProto.newBuilder();
826
827 ReceivedDeletedBlockInfoProto.BlockStatus status;
828 switch (receivedDeletedBlockInfo.getStatus()) {
829 case RECEIVING_BLOCK:
830 status = ReceivedDeletedBlockInfoProto.BlockStatus.RECEIVING;
831 break;
832 case RECEIVED_BLOCK:
833 status = ReceivedDeletedBlockInfoProto.BlockStatus.RECEIVED;
834 break;
835 case DELETED_BLOCK:
836 status = ReceivedDeletedBlockInfoProto.BlockStatus.DELETED;
837 break;
838 default:
839 throw new IllegalArgumentException("Bad status: " +
840 receivedDeletedBlockInfo.getStatus());
841 }
842 builder.setStatus(status);
843
844 if (receivedDeletedBlockInfo.getDelHints() != null) {
845 builder.setDeleteHint(receivedDeletedBlockInfo.getDelHints());
846 }
847 return builder.setBlock(PBHelper.convert(receivedDeletedBlockInfo.getBlock()))
848 .build();
849 }
850
851 public static UpgradeCommandProto convert(UpgradeCommand comm) {
852 UpgradeCommandProto.Builder builder = UpgradeCommandProto.newBuilder();
853 if (comm == null) {
854 return builder.setAction(UpgradeCommandProto.Action.UNKNOWN)
855 .setVersion(0).setUpgradeStatus(0).build();
856 }
857 builder.setVersion(comm.getVersion()).setUpgradeStatus(
858 comm.getCurrentStatus());
859 switch (comm.getAction()) {
860 case UpgradeCommand.UC_ACTION_REPORT_STATUS:
861 builder.setAction(UpgradeCommandProto.Action.REPORT_STATUS);
862 break;
863 case UpgradeCommand.UC_ACTION_START_UPGRADE:
864 builder.setAction(UpgradeCommandProto.Action.START_UPGRADE);
865 break;
866 default:
867 builder.setAction(UpgradeCommandProto.Action.UNKNOWN);
868 break;
869 }
870 return builder.build();
871 }
872
873 public static ReceivedDeletedBlockInfo convert(
874 ReceivedDeletedBlockInfoProto proto) {
875 ReceivedDeletedBlockInfo.BlockStatus status = null;
876 switch (proto.getStatus()) {
877 case RECEIVING:
878 status = BlockStatus.RECEIVING_BLOCK;
879 break;
880 case RECEIVED:
881 status = BlockStatus.RECEIVED_BLOCK;
882 break;
883 case DELETED:
884 status = BlockStatus.DELETED_BLOCK;
885 break;
886 }
887 return new ReceivedDeletedBlockInfo(
888 PBHelper.convert(proto.getBlock()),
889 status,
890 proto.hasDeleteHint() ? proto.getDeleteHint() : null);
891 }
892
893 public static NamespaceInfoProto convert(NamespaceInfo info) {
894 return NamespaceInfoProto.newBuilder()
895 .setBlockPoolID(info.getBlockPoolID())
896 .setBuildVersion(info.getBuildVersion())
897 .setDistUpgradeVersion(info.getDistributedUpgradeVersion())
898 .setStorageInfo(PBHelper.convert((StorageInfo)info))
899 .setSoftwareVersion(info.getSoftwareVersion()).build();
900 }
901
902 // Located Block Arrays and Lists
903 public static LocatedBlockProto[] convertLocatedBlock(LocatedBlock[] lb) {
904 if (lb == null) return null;
905 final int len = lb.length;
906 LocatedBlockProto[] result = new LocatedBlockProto[len];
907 for (int i = 0; i < len; ++i) {
908 result[i] = PBHelper.convert(lb[i]);
909 }
910 return result;
911 }
912
913 public static LocatedBlock[] convertLocatedBlock(LocatedBlockProto[] lb) {
914 if (lb == null) return null;
915 final int len = lb.length;
916 LocatedBlock[] result = new LocatedBlock[len];
917 for (int i = 0; i < len; ++i) {
918 result[i] = new LocatedBlock(
919 PBHelper.convert(lb[i].getB()),
920 PBHelper.convert(lb[i].getLocsList()),
921 lb[i].getOffset(), lb[i].getCorrupt());
922 }
923 return result;
924 }
925
926 public static List<LocatedBlock> convertLocatedBlock(
927 List<LocatedBlockProto> lb) {
928 if (lb == null) return null;
929 final int len = lb.size();
930 List<LocatedBlock> result =
931 new ArrayList<LocatedBlock>(len);
932 for (int i = 0; i < len; ++i) {
933 result.add(PBHelper.convert(lb.get(i)));
934 }
935 return result;
936 }
937
938 public static List<LocatedBlockProto> convertLocatedBlock2(List<LocatedBlock> lb) {
939 if (lb == null) return null;
940 final int len = lb.size();
941 List<LocatedBlockProto> result = new ArrayList<LocatedBlockProto>(len);
942 for (int i = 0; i < len; ++i) {
943 result.add(PBHelper.convert(lb.get(i)));
944 }
945 return result;
946 }
947
948
949 // LocatedBlocks
950 public static LocatedBlocks convert(LocatedBlocksProto lb) {
951 return new LocatedBlocks(
952 lb.getFileLength(), lb.getUnderConstruction(),
953 PBHelper.convertLocatedBlock(lb.getBlocksList()),
954 lb.hasLastBlock() ? PBHelper.convert(lb.getLastBlock()) : null,
955 lb.getIsLastBlockComplete());
956 }
957
958 public static LocatedBlocksProto convert(LocatedBlocks lb) {
959 if (lb == null) {
960 return null;
961 }
962 LocatedBlocksProto.Builder builder =
963 LocatedBlocksProto.newBuilder();
964 if (lb.getLastLocatedBlock() != null) {
965 builder.setLastBlock(PBHelper.convert(lb.getLastLocatedBlock()));
966 }
967 return builder.setFileLength(lb.getFileLength())
968 .setUnderConstruction(lb.isUnderConstruction())
969 .addAllBlocks(PBHelper.convertLocatedBlock2(lb.getLocatedBlocks()))
970 .setIsLastBlockComplete(lb.isLastBlockComplete()).build();
971 }
972
973 public static FsServerDefaults convert(FsServerDefaultsProto fs) {
974 if (fs == null) return null;
975 return new FsServerDefaults(
976 fs.getBlockSize(), fs.getBytesPerChecksum(),
977 fs.getWritePacketSize(), (short) fs.getReplication(),
978 fs.getFileBufferSize());
979 }
980
981 public static FsServerDefaultsProto convert(FsServerDefaults fs) {
982 if (fs == null) return null;
983 return FsServerDefaultsProto.newBuilder().
984 setBlockSize(fs.getBlockSize()).
985 setBytesPerChecksum(fs.getBytesPerChecksum()).
986 setWritePacketSize(fs.getWritePacketSize()).setReplication(fs.getReplication()).setFileBufferSize(fs.getFileBufferSize()).build();
987 }
988
989 public static FsPermissionProto convert(FsPermission p) {
990 if (p == null) return null;
991 return FsPermissionProto.newBuilder().setPerm(p.toShort()).build();
992 }
993
994 public static FsPermission convert(FsPermissionProto p) {
995 if (p == null) return null;
996 return new FsPermission((short)p.getPerm());
997 }
998
999
1000 // The creatFlag field in PB is a bitmask whose values are the same a the
1001 // emum values of CreateFlag
1002 public static int convertCreateFlag(EnumSetWritable<CreateFlag> flag) {
1003 int value = 0;
1004 if (flag.contains(CreateFlag.APPEND)) {
1005 value |= CreateFlagProto.APPEND.getNumber();
1006 }
1007 if (flag.contains(CreateFlag.CREATE)) {
1008 value |= CreateFlagProto.CREATE.getNumber();
1009 }
1010 if (flag.contains(CreateFlag.OVERWRITE)) {
1011 value |= CreateFlagProto.OVERWRITE.getNumber();
1012 }
1013 return value;
1014 }
1015
1016 public static EnumSetWritable<CreateFlag> convert(int flag) {
1017 EnumSet<CreateFlag> result =
1018 EnumSet.noneOf(CreateFlag.class);
1019 if ((flag & CreateFlagProto.APPEND_VALUE) == CreateFlagProto.APPEND_VALUE) {
1020 result.add(CreateFlag.APPEND);
1021 }
1022 if ((flag & CreateFlagProto.CREATE_VALUE) == CreateFlagProto.CREATE_VALUE) {
1023 result.add(CreateFlag.CREATE);
1024 }
1025 if ((flag & CreateFlagProto.OVERWRITE_VALUE)
1026 == CreateFlagProto.OVERWRITE_VALUE) {
1027 result.add(CreateFlag.OVERWRITE);
1028 }
1029 return new EnumSetWritable<CreateFlag>(result);
1030 }
1031
1032
1033 public static HdfsFileStatus convert(HdfsFileStatusProto fs) {
1034 if (fs == null)
1035 return null;
1036 return new HdfsLocatedFileStatus(
1037 fs.getLength(), fs.getFileType().equals(FileType.IS_DIR),
1038 fs.getBlockReplication(), fs.getBlocksize(),
1039 fs.getModificationTime(), fs.getAccessTime(),
1040 PBHelper.convert(fs.getPermission()), fs.getOwner(), fs.getGroup(),
1041 fs.getFileType().equals(FileType.IS_SYMLINK) ?
1042 fs.getSymlink().toByteArray() : null,
1043 fs.getPath().toByteArray(),
1044 fs.hasLocations() ? PBHelper.convert(fs.getLocations()) : null);
1045 }
1046
1047 public static HdfsFileStatusProto convert(HdfsFileStatus fs) {
1048 if (fs == null)
1049 return null;
1050 FileType fType = FileType.IS_FILE;
1051 if (fs.isDir()) {
1052 fType = FileType.IS_DIR;
1053 } else if (fs.isSymlink()) {
1054 fType = FileType.IS_SYMLINK;
1055 }
1056
1057 HdfsFileStatusProto.Builder builder =
1058 HdfsFileStatusProto.newBuilder().
1059 setLength(fs.getLen()).
1060 setFileType(fType).
1061 setBlockReplication(fs.getReplication()).
1062 setBlocksize(fs.getBlockSize()).
1063 setModificationTime(fs.getModificationTime()).
1064 setAccessTime(fs.getAccessTime()).
1065 setPermission(PBHelper.convert(fs.getPermission())).
1066 setOwner(fs.getOwner()).
1067 setGroup(fs.getGroup()).
1068 setPath(ByteString.copyFrom(fs.getLocalNameInBytes()));
1069 if (fs.isSymlink()) {
1070 builder.setSymlink(ByteString.copyFrom(fs.getSymlinkInBytes()));
1071 }
1072 if (fs instanceof HdfsLocatedFileStatus) {
1073 LocatedBlocks locations = ((HdfsLocatedFileStatus)fs).getBlockLocations();
1074 if (locations != null) {
1075 builder.setLocations(PBHelper.convert(locations));
1076 }
1077 }
1078 return builder.build();
1079 }
1080
1081 public static HdfsFileStatusProto[] convert(HdfsFileStatus[] fs) {
1082 if (fs == null) return null;
1083 final int len = fs.length;
1084 HdfsFileStatusProto[] result = new HdfsFileStatusProto[len];
1085 for (int i = 0; i < len; ++i) {
1086 result[i] = PBHelper.convert(fs[i]);
1087 }
1088 return result;
1089 }
1090
1091 public static HdfsFileStatus[] convert(HdfsFileStatusProto[] fs) {
1092 if (fs == null) return null;
1093 final int len = fs.length;
1094 HdfsFileStatus[] result = new HdfsFileStatus[len];
1095 for (int i = 0; i < len; ++i) {
1096 result[i] = PBHelper.convert(fs[i]);
1097 }
1098 return result;
1099 }
1100
1101 public static DirectoryListing convert(DirectoryListingProto dl) {
1102 if (dl == null)
1103 return null;
1104 List<HdfsFileStatusProto> partList = dl.getPartialListingList();
1105 return new DirectoryListing(
1106 partList.isEmpty() ? new HdfsLocatedFileStatus[0]
1107 : PBHelper.convert(
1108 partList.toArray(new HdfsFileStatusProto[partList.size()])),
1109 dl.getRemainingEntries());
1110 }
1111
1112 public static DirectoryListingProto convert(DirectoryListing d) {
1113 if (d == null)
1114 return null;
1115 return DirectoryListingProto.newBuilder().
1116 addAllPartialListing(Arrays.asList(
1117 PBHelper.convert(d.getPartialListing()))).
1118 setRemainingEntries(d.getRemainingEntries()).
1119 build();
1120 }
1121
1122 public static long[] convert(GetFsStatsResponseProto res) {
1123 long[] result = new long[6];
1124 result[ClientProtocol.GET_STATS_CAPACITY_IDX] = res.getCapacity();
1125 result[ClientProtocol.GET_STATS_USED_IDX] = res.getUsed();
1126 result[ClientProtocol.GET_STATS_REMAINING_IDX] = res.getRemaining();
1127 result[ClientProtocol.GET_STATS_UNDER_REPLICATED_IDX] = res.getUnderReplicated();
1128 result[ClientProtocol.GET_STATS_CORRUPT_BLOCKS_IDX] = res.getCorruptBlocks();
1129 result[ClientProtocol.GET_STATS_MISSING_BLOCKS_IDX] = res.getMissingBlocks();
1130 return result;
1131 }
1132
1133 public static GetFsStatsResponseProto convert(long[] fsStats) {
1134 GetFsStatsResponseProto.Builder result = GetFsStatsResponseProto
1135 .newBuilder();
1136 if (fsStats.length >= ClientProtocol.GET_STATS_CAPACITY_IDX + 1)
1137 result.setCapacity(fsStats[ClientProtocol.GET_STATS_CAPACITY_IDX]);
1138 if (fsStats.length >= ClientProtocol.GET_STATS_USED_IDX + 1)
1139 result.setUsed(fsStats[ClientProtocol.GET_STATS_USED_IDX]);
1140 if (fsStats.length >= ClientProtocol.GET_STATS_REMAINING_IDX + 1)
1141 result.setRemaining(fsStats[ClientProtocol.GET_STATS_REMAINING_IDX]);
1142 if (fsStats.length >= ClientProtocol.GET_STATS_UNDER_REPLICATED_IDX + 1)
1143 result.setUnderReplicated(
1144 fsStats[ClientProtocol.GET_STATS_UNDER_REPLICATED_IDX]);
1145 if (fsStats.length >= ClientProtocol.GET_STATS_CORRUPT_BLOCKS_IDX + 1)
1146 result.setCorruptBlocks(
1147 fsStats[ClientProtocol.GET_STATS_CORRUPT_BLOCKS_IDX]);
1148 if (fsStats.length >= ClientProtocol.GET_STATS_MISSING_BLOCKS_IDX + 1)
1149 result.setMissingBlocks(
1150 fsStats[ClientProtocol.GET_STATS_MISSING_BLOCKS_IDX]);
1151 return result.build();
1152 }
1153
1154 public static DatanodeReportTypeProto
1155 convert(DatanodeReportType t) {
1156 switch (t) {
1157 case ALL: return DatanodeReportTypeProto.ALL;
1158 case LIVE: return DatanodeReportTypeProto.LIVE;
1159 case DEAD: return DatanodeReportTypeProto.DEAD;
1160 default:
1161 throw new IllegalArgumentException("Unexpected data type report:" + t);
1162 }
1163 }
1164
1165 public static DatanodeReportType
1166 convert(DatanodeReportTypeProto t) {
1167 switch (t) {
1168 case ALL: return DatanodeReportType.ALL;
1169 case LIVE: return DatanodeReportType.LIVE;
1170 case DEAD: return DatanodeReportType.DEAD;
1171 default:
1172 throw new IllegalArgumentException("Unexpected data type report:" + t);
1173 }
1174 }
1175
1176 public static SafeModeActionProto convert(
1177 SafeModeAction a) {
1178 switch (a) {
1179 case SAFEMODE_LEAVE:
1180 return SafeModeActionProto.SAFEMODE_LEAVE;
1181 case SAFEMODE_ENTER:
1182 return SafeModeActionProto.SAFEMODE_ENTER;
1183 case SAFEMODE_GET:
1184 return SafeModeActionProto.SAFEMODE_GET;
1185 default:
1186 throw new IllegalArgumentException("Unexpected SafeModeAction :" + a);
1187 }
1188 }
1189
1190 public static SafeModeAction convert(
1191 ClientNamenodeProtocolProtos.SafeModeActionProto a) {
1192 switch (a) {
1193 case SAFEMODE_LEAVE:
1194 return SafeModeAction.SAFEMODE_LEAVE;
1195 case SAFEMODE_ENTER:
1196 return SafeModeAction.SAFEMODE_ENTER;
1197 case SAFEMODE_GET:
1198 return SafeModeAction.SAFEMODE_GET;
1199 default:
1200 throw new IllegalArgumentException("Unexpected SafeModeAction :" + a);
1201 }
1202 }
1203
1204 public static UpgradeActionProto convert(
1205 UpgradeAction a) {
1206 switch (a) {
1207 case GET_STATUS:
1208 return UpgradeActionProto.GET_STATUS;
1209 case DETAILED_STATUS:
1210 return UpgradeActionProto.DETAILED_STATUS;
1211 case FORCE_PROCEED:
1212 return UpgradeActionProto.FORCE_PROCEED;
1213 default:
1214 throw new IllegalArgumentException("Unexpected UpgradeAction :" + a);
1215 }
1216 }
1217
1218
1219 public static UpgradeAction convert(
1220 UpgradeActionProto a) {
1221 switch (a) {
1222 case GET_STATUS:
1223 return UpgradeAction.GET_STATUS;
1224 case DETAILED_STATUS:
1225 return UpgradeAction.DETAILED_STATUS;
1226 case FORCE_PROCEED:
1227 return UpgradeAction.FORCE_PROCEED;
1228 default:
1229 throw new IllegalArgumentException("Unexpected UpgradeAction :" + a);
1230 }
1231 }
1232
1233 public static UpgradeStatusReportProto convert(UpgradeStatusReport r) {
1234 if (r == null)
1235 return null;
1236 return UpgradeStatusReportProto.newBuilder()
1237 .setVersion(r.getVersion())
1238 .setUpgradeStatus(r.getUpgradeStatus())
1239 .setFinalized(r.isFinalized())
1240 .build();
1241 }
1242
1243 public static UpgradeStatusReport convert(UpgradeStatusReportProto r) {
1244 if (r == null) return null;
1245 return new UpgradeStatusReport(r.getVersion(),
1246 (short) r.getUpgradeStatus(), r.getFinalized());
1247 }
1248
1249 public static CorruptFileBlocks convert(CorruptFileBlocksProto c) {
1250 if (c == null)
1251 return null;
1252 List<String> fileList = c.getFilesList();
1253 return new CorruptFileBlocks(fileList.toArray(new String[fileList.size()]),
1254 c.getCookie());
1255 }
1256
1257 public static CorruptFileBlocksProto convert(CorruptFileBlocks c) {
1258 if (c == null)
1259 return null;
1260 return CorruptFileBlocksProto.newBuilder().
1261 addAllFiles(Arrays.asList(c.getFiles())).
1262 setCookie(c.getCookie()).
1263 build();
1264 }
1265
1266 public static ContentSummary convert(ContentSummaryProto cs) {
1267 if (cs == null) return null;
1268 return new ContentSummary(
1269 cs.getLength(), cs.getFileCount(), cs.getDirectoryCount(), cs.getQuota(),
1270 cs.getSpaceConsumed(), cs.getSpaceQuota());
1271 }
1272
1273 public static ContentSummaryProto convert(ContentSummary cs) {
1274 if (cs == null) return null;
1275 return ContentSummaryProto.newBuilder().
1276 setLength(cs.getLength()).
1277 setFileCount(cs.getFileCount()).
1278 setDirectoryCount(cs.getDirectoryCount()).
1279 setQuota(cs.getQuota()).
1280 setSpaceConsumed(cs.getSpaceConsumed()).
1281 setSpaceQuota(cs.getSpaceQuota()).
1282 build();
1283 }
1284
1285 public static NNHAStatusHeartbeat convert(NNHAStatusHeartbeatProto s) {
1286 if (s == null) return null;
1287 switch (s.getState()) {
1288 case ACTIVE:
1289 return new NNHAStatusHeartbeat(NNHAStatusHeartbeat.State.ACTIVE, s.getTxid());
1290 case STANDBY:
1291 return new NNHAStatusHeartbeat(NNHAStatusHeartbeat.State.STANDBY, s.getTxid());
1292 default:
1293 throw new IllegalArgumentException("Unexpected NNHAStatusHeartbeat.State:" + s.getState());
1294 }
1295 }
1296
1297 public static NNHAStatusHeartbeatProto convert(NNHAStatusHeartbeat hb) {
1298 if (hb == null) return null;
1299 NNHAStatusHeartbeatProto.Builder builder =
1300 NNHAStatusHeartbeatProto.newBuilder();
1301 switch (hb.getState()) {
1302 case ACTIVE:
1303 builder.setState(NNHAStatusHeartbeatProto.State.ACTIVE);
1304 break;
1305 case STANDBY:
1306 builder.setState(NNHAStatusHeartbeatProto.State.STANDBY);
1307 break;
1308 default:
1309 throw new IllegalArgumentException("Unexpected NNHAStatusHeartbeat.State:" +
1310 hb.getState());
1311 }
1312 builder.setTxid(hb.getTxId());
1313 return builder.build();
1314 }
1315
1316 public static DatanodeStorageProto convert(DatanodeStorage s) {
1317 return DatanodeStorageProto.newBuilder()
1318 .setState(PBHelper.convert(s.getState()))
1319 .setStorageID(s.getStorageID()).build();
1320 }
1321
1322 private static StorageState convert(State state) {
1323 switch(state) {
1324 case READ_ONLY:
1325 return StorageState.READ_ONLY;
1326 case NORMAL:
1327 default:
1328 return StorageState.NORMAL;
1329 }
1330 }
1331
1332 public static DatanodeStorage convert(DatanodeStorageProto s) {
1333 return new DatanodeStorage(s.getStorageID(), PBHelper.convert(s.getState()));
1334 }
1335
1336 private static State convert(StorageState state) {
1337 switch(state) {
1338 case READ_ONLY:
1339 return DatanodeStorage.State.READ_ONLY;
1340 case NORMAL:
1341 default:
1342 return DatanodeStorage.State.NORMAL;
1343 }
1344 }
1345
1346 public static StorageReportProto convert(StorageReport r) {
1347 return StorageReportProto.newBuilder()
1348 .setBlockPoolUsed(r.getBlockPoolUsed()).setCapacity(r.getCapacity())
1349 .setDfsUsed(r.getDfsUsed()).setRemaining(r.getRemaining())
1350 .setStorageID(r.getStorageID()).build();
1351 }
1352
1353 public static JournalInfo convert(JournalInfoProto info) {
1354 int lv = info.hasLayoutVersion() ? info.getLayoutVersion() : 0;
1355 int nsID = info.hasNamespaceID() ? info.getNamespaceID() : 0;
1356 return new JournalInfo(lv, info.getClusterID(), nsID);
1357 }
1358
1359 /**
1360 * Method used for converting {@link JournalInfoProto} sent from Namenode
1361 * to Journal receivers to {@link NamenodeRegistration}.
1362 */
1363 public static JournalInfoProto convert(JournalInfo j) {
1364 return JournalInfoProto.newBuilder().setClusterID(j.getClusterId())
1365 .setLayoutVersion(j.getLayoutVersion())
1366 .setNamespaceID(j.getNamespaceId()).build();
1367 }
1368 }