/// <exception cref="System.IO.IOException"/>
public virtual ReplicaRecoveryInfo InitReplicaRecovery(BlockRecoveryCommand.RecoveringBlock
rBlock)
{
InterDatanodeProtocolProtos.InitReplicaRecoveryRequestProto req = ((InterDatanodeProtocolProtos.InitReplicaRecoveryRequestProto
)InterDatanodeProtocolProtos.InitReplicaRecoveryRequestProto.NewBuilder().SetBlock
(PBHelper.Convert(rBlock)).Build());
InterDatanodeProtocolProtos.InitReplicaRecoveryResponseProto resp;
try
{
resp = rpcProxy.InitReplicaRecovery(NullController, req);
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
if (!resp.GetReplicaFound())
{
// No replica found on the remote node.
return(null);
}
else
{
if (!resp.HasBlock() || !resp.HasState())
{
throw new IOException("Replica was found but missing fields. " + "Req: " + req +
"\n" + "Resp: " + resp);
}
}
HdfsProtos.BlockProto b = resp.GetBlock();
return(new ReplicaRecoveryInfo(b.GetBlockId(), b.GetNumBytes(), b.GetGenStamp(),
PBHelper.Convert(resp.GetState())));
}
/// <exception cref="System.IO.IOException"/>
public virtual void BlockReceivedAndDeleted(DatanodeRegistration registration, string
poolId, StorageReceivedDeletedBlocks[] receivedAndDeletedBlocks)
{
DatanodeProtocolProtos.BlockReceivedAndDeletedRequestProto.Builder builder = DatanodeProtocolProtos.BlockReceivedAndDeletedRequestProto
.NewBuilder().SetRegistration(PBHelper.Convert(registration)).SetBlockPoolId(poolId
);
foreach (StorageReceivedDeletedBlocks storageBlock in receivedAndDeletedBlocks)
{
DatanodeProtocolProtos.StorageReceivedDeletedBlocksProto.Builder repBuilder = DatanodeProtocolProtos.StorageReceivedDeletedBlocksProto
.NewBuilder();
repBuilder.SetStorageUuid(storageBlock.GetStorage().GetStorageID());
// Set for wire compatibility.
repBuilder.SetStorage(PBHelper.Convert(storageBlock.GetStorage()));
foreach (ReceivedDeletedBlockInfo rdBlock in storageBlock.GetBlocks())
{
repBuilder.AddBlocks(PBHelper.Convert(rdBlock));
}
builder.AddBlocks(((DatanodeProtocolProtos.StorageReceivedDeletedBlocksProto)repBuilder
.Build()));
}
try
{
rpcProxy.BlockReceivedAndDeleted(NullController, ((DatanodeProtocolProtos.BlockReceivedAndDeletedRequestProto
)builder.Build()));
}
catch (ServiceException se)
{
throw ProtobufHelper.GetRemoteException(se);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual DatanodeCommand CacheReport(DatanodeRegistration registration, string
poolId, IList <long> blockIds)
{
DatanodeProtocolProtos.CacheReportRequestProto.Builder builder = DatanodeProtocolProtos.CacheReportRequestProto
.NewBuilder().SetRegistration(PBHelper.Convert(registration)).SetBlockPoolId(poolId
);
foreach (long blockId in blockIds)
{
builder.AddBlocks(blockId);
}
DatanodeProtocolProtos.CacheReportResponseProto resp;
try
{
resp = rpcProxy.CacheReport(NullController, ((DatanodeProtocolProtos.CacheReportRequestProto
)builder.Build()));
}
catch (ServiceException se)
{
throw ProtobufHelper.GetRemoteException(se);
}
if (resp.HasCmd())
{
return(PBHelper.Convert(resp.GetCmd()));
}
return(null);
}
/// <exception cref="System.IO.IOException"/>
public virtual HeartbeatResponse SendHeartbeat(DatanodeRegistration registration,
StorageReport[] reports, long cacheCapacity, long cacheUsed, int xmitsInProgress
, int xceiverCount, int failedVolumes, VolumeFailureSummary volumeFailureSummary
)
{
DatanodeProtocolProtos.HeartbeatRequestProto.Builder builder = DatanodeProtocolProtos.HeartbeatRequestProto
.NewBuilder().SetRegistration(PBHelper.Convert(registration)).SetXmitsInProgress
(xmitsInProgress).SetXceiverCount(xceiverCount).SetFailedVolumes(failedVolumes);
builder.AddAllReports(PBHelper.ConvertStorageReports(reports));
if (cacheCapacity != 0)
{
builder.SetCacheCapacity(cacheCapacity);
}
if (cacheUsed != 0)
{
builder.SetCacheUsed(cacheUsed);
}
if (volumeFailureSummary != null)
{
builder.SetVolumeFailureSummary(PBHelper.ConvertVolumeFailureSummary(volumeFailureSummary
));
}
DatanodeProtocolProtos.HeartbeatResponseProto resp;
try
{
resp = rpcProxy.SendHeartbeat(NullController, ((DatanodeProtocolProtos.HeartbeatRequestProto
)builder.Build()));
}
catch (ServiceException se)
{
throw ProtobufHelper.GetRemoteException(se);
}
DatanodeCommand[] cmds = new DatanodeCommand[resp.GetCmdsList().Count];
int index = 0;
foreach (DatanodeProtocolProtos.DatanodeCommandProto p in resp.GetCmdsList())
{
cmds[index] = PBHelper.Convert(p);
index++;
}
RollingUpgradeStatus rollingUpdateStatus = null;
// Use v2 semantics if available.
if (resp.HasRollingUpgradeStatusV2())
{
rollingUpdateStatus = PBHelper.Convert(resp.GetRollingUpgradeStatusV2());
}
else
{
if (resp.HasRollingUpgradeStatus())
{
rollingUpdateStatus = PBHelper.Convert(resp.GetRollingUpgradeStatus());
}
}
return(new HeartbeatResponse(cmds, PBHelper.Convert(resp.GetHaStatus()), rollingUpdateStatus
));
}
/// <exception cref="System.IO.IOException"/>
public virtual void RefreshNamenodes()
{
try
{
rpcProxy.RefreshNamenodes(NullController, VoidRefreshNamenodes);
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void StartReconfiguration()
{
try
{
rpcProxy.StartReconfiguration(NullController, VoidStartReconfig);
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void RefreshServiceAcl()
{
try
{
rpcProxy.RefreshServiceAcl(NullController, VoidRefreshServiceAclRequest);
}
catch (ServiceException se)
{
throw ProtobufHelper.GetRemoteException(se);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void MonitorHealth()
{
try
{
rpcProxy.MonitorHealth(NullController, MonitorHealthReq);
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void RefreshLogRetentionSettings()
{
try
{
rpcProxy.RefreshLogRetentionSettings(NullController, VoidRefreshLogRetentionSettingsRequest
);
}
catch (ServiceException se)
{
throw ProtobufHelper.GetRemoteException(se);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual long GetTransactionID()
{
try
{
return(rpcProxy.GetTransactionId(NullController, VoidGetTransactionidRequest).GetTxId
());
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual long GetMostRecentCheckpointTxId()
{
try
{
return(rpcProxy.GetMostRecentCheckpointTxId(NullController, NamenodeProtocolProtos.GetMostRecentCheckpointTxIdRequestProto
.GetDefaultInstance()).GetTxId());
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void RefreshSuperUserGroupsConfiguration()
{
try
{
rpcProxy.RefreshSuperUserGroupsConfiguration(NullController, VoidRefreshSuperuserGroupsConfigurationRequest
);
}
catch (ServiceException se)
{
throw ProtobufHelper.GetRemoteException(se);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual CheckpointSignature RollEditLog()
{
try
{
return(PBHelper.Convert(rpcProxy.RollEditLog(NullController, VoidRollEditlogRequest
).GetSignature()));
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
/// <exception cref="Org.Apache.Hadoop.Security.AccessControlException"/>
public virtual void GracefulFailover()
{
try
{
rpcProxy.GracefulFailover(NullController, ZKFCProtocolProtos.GracefulFailoverRequestProto
.GetDefaultInstance());
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual NamespaceInfo VersionRequest()
{
try
{
return(PBHelper.Convert(rpcProxy.VersionRequest(NullController, VoidVersionRequest
).GetInfo()));
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void RefreshUserToGroupsMappings()
{
try
{
rpcProxy.RefreshUserToGroupsMappings(NullController, VoidRefreshUserToGroupsMappingRequest
);
}
catch (ServiceException se)
{
throw ProtobufHelper.GetRemoteException(se);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void TriggerBlockReport(BlockReportOptions options)
{
try
{
rpcProxy.TriggerBlockReport(NullController, ((ClientDatanodeProtocolProtos.TriggerBlockReportRequestProto
)ClientDatanodeProtocolProtos.TriggerBlockReportRequestProto.NewBuilder().SetIncremental
(options.IsIncremental()).Build()));
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void DiscardSegments(string journalId, long startTxId)
{
try
{
rpcProxy.DiscardSegments(NullController, ((QJournalProtocolProtos.DiscardSegmentsRequestProto
)QJournalProtocolProtos.DiscardSegmentsRequestProto.NewBuilder().SetJid(ConvertJournalId
(journalId)).SetStartTxId(startTxId).Build()));
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual ExportedBlockKeys GetBlockKeys()
{
try
{
NamenodeProtocolProtos.GetBlockKeysResponseProto rsp = rpcProxy.GetBlockKeys(NullController
, VoidGetBlockkeysRequest);
return(rsp.HasKeys() ? PBHelper.Convert(rsp.GetKeys()) : null);
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void DoUpgrade(string journalId, StorageInfo sInfo)
{
try
{
rpcProxy.DoUpgrade(NullController, ((QJournalProtocolProtos.DoUpgradeRequestProto
)QJournalProtocolProtos.DoUpgradeRequestProto.NewBuilder().SetJid(ConvertJournalId
(journalId)).SetSInfo(PBHelper.Convert(sInfo)).Build()));
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void DoRollback(string journalId)
{
try
{
rpcProxy.DoRollback(NullController, ((QJournalProtocolProtos.DoRollbackRequestProto
)QJournalProtocolProtos.DoRollbackRequestProto.NewBuilder().SetJid(ConvertJournalId
(journalId)).Build()));
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual DatanodeLocalInfo GetDatanodeInfo()
{
ClientDatanodeProtocolProtos.GetDatanodeInfoResponseProto response;
try
{
response = rpcProxy.GetDatanodeInfo(NullController, VoidGetDatanodeInfo);
return(PBHelper.Convert(response.GetLocalInfo()));
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void Heartbeat(RequestInfo reqInfo)
{
try
{
rpcProxy.Heartbeat(NullController, ((QJournalProtocolProtos.HeartbeatRequestProto
)QJournalProtocolProtos.HeartbeatRequestProto.NewBuilder().SetReqInfo(Convert(reqInfo
)).Build()));
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual BlocksWithLocations GetBlocks(DatanodeInfo datanode, long size)
{
NamenodeProtocolProtos.GetBlocksRequestProto req = ((NamenodeProtocolProtos.GetBlocksRequestProto
)NamenodeProtocolProtos.GetBlocksRequestProto.NewBuilder().SetDatanode(PBHelper.
Convert((DatanodeID)datanode)).SetSize(size).Build());
try
{
return(PBHelper.Convert(rpcProxy.GetBlocks(NullController, req).GetBlocks()));
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
/// <exception cref="Org.Apache.Hadoop.Security.AccessControlException"/>
public virtual void CedeActive(int millisToCede)
{
try
{
ZKFCProtocolProtos.CedeActiveRequestProto req = ((ZKFCProtocolProtos.CedeActiveRequestProto
)ZKFCProtocolProtos.CedeActiveRequestProto.NewBuilder().SetMillisToCede(millisToCede
).Build());
rpcProxy.CedeActive(NullController, req);
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void DeleteBlockPool(string bpid, bool force)
{
ClientDatanodeProtocolProtos.DeleteBlockPoolRequestProto req = ((ClientDatanodeProtocolProtos.DeleteBlockPoolRequestProto
)ClientDatanodeProtocolProtos.DeleteBlockPoolRequestProto.NewBuilder().SetBlockPool
(bpid).SetForce(force).Build());
try
{
rpcProxy.DeleteBlockPool(NullController, req);
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void RemoveSpanReceiver(long spanReceiverId)
{
try
{
TraceAdminPB.RemoveSpanReceiverRequestProto req = ((TraceAdminPB.RemoveSpanReceiverRequestProto
)TraceAdminPB.RemoveSpanReceiverRequestProto.NewBuilder().SetId(spanReceiverId).
Build());
rpcProxy.RemoveSpanReceiver(null, req);
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void ShutdownDatanode(bool forUpgrade)
{
ClientDatanodeProtocolProtos.ShutdownDatanodeRequestProto request = ((ClientDatanodeProtocolProtos.ShutdownDatanodeRequestProto
)ClientDatanodeProtocolProtos.ShutdownDatanodeRequestProto.NewBuilder().SetForUpgrade
(forUpgrade).Build());
try
{
rpcProxy.ShutdownDatanode(NullController, request);
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual long GetReplicaVisibleLength(ExtendedBlock b)
{
ClientDatanodeProtocolProtos.GetReplicaVisibleLengthRequestProto req = ((ClientDatanodeProtocolProtos.GetReplicaVisibleLengthRequestProto
)ClientDatanodeProtocolProtos.GetReplicaVisibleLengthRequestProto.NewBuilder().SetBlock
(PBHelper.Convert(b)).Build());
try
{
return(rpcProxy.GetReplicaVisibleLength(NullController, req).GetLength());
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void Format(string jid, NamespaceInfo nsInfo)
{
try
{
QJournalProtocolProtos.FormatRequestProto req = ((QJournalProtocolProtos.FormatRequestProto
)QJournalProtocolProtos.FormatRequestProto.NewBuilder().SetJid(ConvertJournalId(
jid)).SetNsInfo(PBHelper.Convert(nsInfo)).Build());
rpcProxy.Format(NullController, req);
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
