/// <exception cref="System.IO.IOException"/>
internal EditLogBackupOutputStream(NamenodeRegistration bnReg, JournalInfo journalInfo
)
: base()
{
// RPC proxy to backup node
// backup node registration
// active node registration
// serialized output sent to backup node
// backup node
// active name-node
this.bnRegistration = bnReg;
this.journalInfo = journalInfo;
IPEndPoint bnAddress = NetUtils.CreateSocketAddr(bnRegistration.GetAddress());
try
{
this.backupNode = NameNodeProxies.CreateNonHAProxy <JournalProtocol>(new HdfsConfiguration
(), bnAddress, UserGroupInformation.GetCurrentUser(), true).GetProxy();
}
catch (IOException e)
{
Storage.Log.Error("Error connecting to: " + bnAddress, e);
throw;
}
this.doubleBuf = new EditsDoubleBuffer(DefaultBufferSize);
this.@out = new DataOutputBuffer(DefaultBufferSize);
}
internal BackupJournalManager(NamenodeRegistration bnReg, NamenodeRegistration nnReg
)
{
journalInfo = new JournalInfo(nnReg.GetLayoutVersion(), nnReg.GetClusterID(), nnReg
.GetNamespaceID());
this.bnReg = bnReg;
}
/// <exception cref="System.IO.IOException"/>
public virtual void EndCheckpoint(NamenodeRegistration registration, CheckpointSignature
sig)
{
NamenodeProtocolProtos.EndCheckpointRequestProto req = ((NamenodeProtocolProtos.EndCheckpointRequestProto
)NamenodeProtocolProtos.EndCheckpointRequestProto.NewBuilder().SetRegistration(PBHelper
.Convert(registration)).SetSignature(PBHelper.Convert(sig)).Build());
try
{
rpcProxy.EndCheckpoint(NullController, req);
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual void ErrorReport(NamenodeRegistration registration, int errorCode,
string msg)
{
NamenodeProtocolProtos.ErrorReportRequestProto req = ((NamenodeProtocolProtos.ErrorReportRequestProto
)NamenodeProtocolProtos.ErrorReportRequestProto.NewBuilder().SetErrorCode(errorCode
).SetMsg(msg).SetRegistration(PBHelper.Convert(registration)).Build());
try
{
rpcProxy.ErrorReport(NullController, req);
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
/// <exception cref="System.IO.IOException"/>
public virtual NamenodeCommand StartCheckpoint(NamenodeRegistration registration)
{
NamenodeProtocolProtos.StartCheckpointRequestProto req = ((NamenodeProtocolProtos.StartCheckpointRequestProto
)NamenodeProtocolProtos.StartCheckpointRequestProto.NewBuilder().SetRegistration
(PBHelper.Convert(registration)).Build());
HdfsProtos.NamenodeCommandProto cmd;
try
{
cmd = rpcProxy.StartCheckpoint(NullController, req).GetCommand();
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
return(PBHelper.Convert(cmd));
}
/// <exception cref="System.IO.IOException"/>
public virtual NamenodeRegistration RegisterSubordinateNamenode(NamenodeRegistration
registration)
{
NamenodeProtocolProtos.RegisterRequestProto req = ((NamenodeProtocolProtos.RegisterRequestProto
)NamenodeProtocolProtos.RegisterRequestProto.NewBuilder().SetRegistration(PBHelper
.Convert(registration)).Build());
try
{
return(PBHelper.Convert(rpcProxy.RegisterSubordinateNamenode(NullController, req)
.GetRegistration()));
}
catch (ServiceException e)
{
throw ProtobufHelper.GetRemoteException(e);
}
}
public virtual void TestConvertNamenodeRegistration()
{
StorageInfo info = GetStorageInfo(HdfsServerConstants.NodeType.NameNode);
NamenodeRegistration reg = new NamenodeRegistration("address:999", "http:1000", info
, HdfsServerConstants.NamenodeRole.Namenode);
HdfsProtos.NamenodeRegistrationProto regProto = PBHelper.Convert(reg);
NamenodeRegistration reg2 = PBHelper.Convert(regProto);
NUnit.Framework.Assert.AreEqual(reg.GetAddress(), reg2.GetAddress());
NUnit.Framework.Assert.AreEqual(reg.GetClusterID(), reg2.GetClusterID());
NUnit.Framework.Assert.AreEqual(reg.GetCTime(), reg2.GetCTime());
NUnit.Framework.Assert.AreEqual(reg.GetHttpAddress(), reg2.GetHttpAddress());
NUnit.Framework.Assert.AreEqual(reg.GetLayoutVersion(), reg2.GetLayoutVersion());
NUnit.Framework.Assert.AreEqual(reg.GetNamespaceID(), reg2.GetNamespaceID());
NUnit.Framework.Assert.AreEqual(reg.GetRegistrationID(), reg2.GetRegistrationID()
);
NUnit.Framework.Assert.AreEqual(reg.GetRole(), reg2.GetRole());
NUnit.Framework.Assert.AreEqual(reg.GetVersion(), reg2.GetVersion());
}
public virtual bool MatchesRegistration(NamenodeRegistration bnReg)
{
return(bnReg.GetAddress().Equals(this.bnReg.GetAddress()));
}
/// <exception cref="System.IO.IOException"/>
public static NamenodeCommand StartCheckpoint(NameNode nn, NamenodeRegistration backupNode
, NamenodeRegistration activeNamenode)
{
return(nn.GetNamesystem().StartCheckpoint(backupNode, activeNamenode));
}
/// <summary>Register this backup node with the active name-node.</summary>
/// <param name="nsInfo">namespace information</param>
/// <exception cref="System.IO.IOException"/>
private void RegisterWith(NamespaceInfo nsInfo)
{
BackupImage bnImage = (BackupImage)GetFSImage();
NNStorage storage = bnImage.GetStorage();
// verify namespaceID
if (storage.GetNamespaceID() == 0)
{
// new backup storage
storage.SetStorageInfo(nsInfo);
storage.SetBlockPoolID(nsInfo.GetBlockPoolID());
storage.SetClusterID(nsInfo.GetClusterID());
}
else
{
nsInfo.ValidateStorage(storage);
}
bnImage.InitEditLog(HdfsServerConstants.StartupOption.Regular);
SetRegistration();
NamenodeRegistration nnReg = null;
while (!IsStopRequested())
{
try
{
nnReg = namenode.RegisterSubordinateNamenode(GetRegistration());
break;
}
catch (SocketTimeoutException e)
{
// name-node is busy
Log.Info("Problem connecting to name-node: " + nnRpcAddress);
try
{
Sharpen.Thread.Sleep(1000);
}
catch (Exception)
{
Log.Warn("Encountered exception ", e);
}
}
}
string msg = null;
if (nnReg == null)
{
// consider as a rejection
msg = "Registration rejected by " + nnRpcAddress;
}
else
{
if (!nnReg.IsRole(HdfsServerConstants.NamenodeRole.Namenode))
{
msg = "Name-node " + nnRpcAddress + " is not active";
}
}
if (msg != null)
{
msg += ". Shutting down.";
Log.Error(msg);
throw new IOException(msg);
}
// stop the node
nnRpcAddress = nnReg.GetAddress();
}
