private async Task AcquireLock(IDistributedLock consulLock, CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
if (!consulLock.IsHeld)
{
if (_currentRole != NodeRole.Follower)
{
_applicationEvents.Publish(new NodeRoleTransitioned(NodeRole.Follower));
_currentRole = NodeRole.Follower;
}
consulLock.Acquire(cancellationToken);
}
while (!cancellationToken.IsCancellationRequested && consulLock.IsHeld)
{
if (_currentRole != NodeRole.Leader)
{
_applicationEvents.Publish(new NodeRoleTransitioned(NodeRole.Leader));
_currentRole = NodeRole.Leader;
}
await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken).ConfigureAwait(false);
}
}
}
private void BecomeCandidate()
{
if (Role == NodeRole.Follower)
{
Role = NodeRole.Candidate;
}
}
public VoteBackStruct voteForMe(int term, int CandidateId, int lastLogIdx, int lastLogTerm)
{
lock (this)
{
VoteBackStruct ret = new VoteBackStruct();
ret.Term = term_;
ret.VoteGranted = false;
if (term > term_) // recv higher term request
{
Console.WriteLine(String.Format("{0} [{1}] voted in term {2}, recv_term {3} from {4}, isVoteInThisTerm_ {5}!", id, role, term, term, CandidateId, isVoteInThisTerm_));
role_ = NodeRole.Follower;
state_ = ServerState.HigherTerm;
term_ = term;
isVoteInThisTerm_ = false;
if (lastLogTerm < getLastLogTerm()) //log最后的term比我小
{
return(ret);
}
if (lastLogTerm == getLastLogTerm() && lastLogIdx < log_.Count) //log最后的term和我一样，但是log没有我多
{
return(ret);
}
//if(timeout_timer_ != null)
// timeout_timer_.Change(curRandTime_, curRandTime_);
ret.VoteGranted = isVoteInThisTerm_ = true;
return(ret);
}
else
{
ret.VoteGranted = false;
return(ret);
}
}
}
public void SetRoles(Node node)
{
//foreach (NodeRole np in node.NodeRoles)
//{
// node.RemoveNoderole(np.Id);
//}
foreach (RepeaterItem ri in rptRoles.Items)
{
CheckBox chkView = (CheckBox)ri.FindControl("chkViewAllowed");
CheckBox chkEdit = (CheckBox)ri.FindControl("chkEditAllowed");
if (chkView.Checked || chkEdit.Checked)
{
if (!node.Exists(Convert.ToInt32(ViewState[ri.UniqueID])))
{
NodeRole np = new NodeRole();
np.Node = node;
np.Role = _presenter.GetRole((int)ViewState[ri.UniqueID]);
np.ViewAllowed = chkView.Checked;
np.EditAllowed = chkEdit.Checked;
node.NodeRoles.Add(np);
}
}
}
}
public IDtpNode CreateNode(NodeRole role, int port = -1, IEnumerable <IInstructionSet> instructionSets = null)
{
instructionSets = instructionSets == null ? kNoInstructionSets : instructionSets.ToArray();
if (role == NodeRole.ServerOrClient)
{
IDtpNode result = null;
while (result == null)
{
try {
result = CreateNode(NodeRole.Server, port, instructionSets);
} catch {
try {
result = CreateNode(NodeRole.Client, -1, instructionSets).With(n => { n.Connect(port); });
} catch {
// gotta catch em all
}
}
}
return(result);
}
else if (role == NodeRole.Client)
{
if (port != -1)
{
throw new InvalidOperationException("Use node.Connect, not CreateNode constructor to connect to server!");
}
return(new DtpNode(new NullClientSource(), instructionSets));
}
else
{
return(new DtpNode(new SocketClientSource(port), instructionSets));
}
}
/// <summary>
/// Node info
/// </summary>
/// <param name="id"></param>
/// <param name="serviceUri"></param>
/// <param name="state"></param>
/// <param name="role"></param>
public NodeInfo(string id, Uri serviceUri, NodeState state, NodeRole role)
{
Id = id;
ServiceUri = serviceUri;
State = state;
Role = role;
}
public SellerNode(SellerNode mainSeller)
{
version = mainSeller.version;
uri = new Uri(mainSeller.uri.AbsoluteUri);
machineName = mainSeller.machineName;
role = mainSeller.role;
}
public bool AddNode(IKey key, NodeRole nodeRole, IPAddress ipAddress)
{
AccountIdentity accountIdentity = GetAccountIdentity(key);
if (accountIdentity == null)
{
GetOrAddIdentity(key);
accountIdentity = GetAccountIdentity(key);
}
if (accountIdentity != null)
{
lock (_sync)
{
NodeRecord node = _dataContext.Nodes.FirstOrDefault(n => n.Identity == accountIdentity && n.NodeRole == (byte)nodeRole);
if (node == null)
{
node = new NodeRecord {
Identity = accountIdentity, IPAddress = ipAddress.GetAddressBytes(), NodeRole = (byte)nodeRole
};
_dataContext.Nodes.Add(node);
if (!_keyToNodeMap.ContainsKey(key))
{
_keyToNodeMap.Add(key, node);
}
return(true);
}
}
}
return(false);
}
/// <inheritdoc/>
public override int GetHashCode()
{
unchecked
{
return((NodeIndex * 397) ^ (NodeRole.GetHashCode() * 397) ^ StartTime.GetHashCode());
}
}
private void BecomeSecondary(bool changeStatus = true)
{
_currentRole = NodeRole.Secondary;
if (changeStatus)
{
_status.SetStatusBit(UNINITIIALIZED, RUNNING);
}
}
public bool AddNode(IKey key, NodeRole nodeRole, string ipAddressExpression = null)
{
if (IPAddress.TryParse(ipAddressExpression ?? "127.0.0.1", out IPAddress ipAddress))
{
return(AddNode(key, nodeRole, ipAddress));
}
return(false);
}
/// <summary>
/// Internal constructor used by RoadSystem
/// </summary>
/// <param name="id"></param>
/// <param name="crashed"></param>
/// <param name="role"></param>
internal RoadNode(int id,
bool crashed = false,
NodeRole role = NodeRole.Normal)
{
this.ID = id;
this.Crashed = crashed;
this.Role = role;
this.Links = new LinkCollection();
}
public void SetNodeStatus(ServerNode primary, NodeRole status)
{
ManagementCommand command = GetManagementCommand(ConfigurationCommandUtil.MethodName.SetNodeStatus, 1);
command.Parameters.AddParameter(primary);
command.Parameters.AddParameter(status);
ExecuteCommandOnConfigurationServer(command, false);
}
private void BecomeLeader()
{
if (Role == NodeRole.Candidate)
{
Role = NodeRole.Leader;
var nextIndex = new Dictionary <string, long>();
var matchIndex = new Dictionary <string, long>();
State = new LeaderState(State, nextIndex, matchIndex);
}
}
private void BecomeFollower()
{
if (Role != NodeRole.Follower)
{
Role = NodeRole.Follower;
State = new NodeState(State.CurrentTerm, null, State.CommitIndex, State.LastApplied);
StartElection();
}
}
public async Task <ActionResult> NodeEnable(string node)
{
if (!Current.User.Is(Roles.ApiRequest))
{
return(JsonError("Invalid API key"));
}
await NodeRole.EnableAllAsync(node);
return(NodeRoles(node));
}
public void SetNodeStatus(ServerNode primary, NodeRole status)
{
try
{
this.service.SetNodeStatus(this.Cluster, this.shard, primary, status);
NotifyConfigurationChange(this.cluster);
}
catch (System.Exception ex)
{
}
}
public async Task <ActionResult> NodeDisable(string node)
{
if (!Current.IsInRole(Roles.ApiRequest))
{
return(JsonError("Invalid API key"));
}
await NodeRole.DisableAllAsync(node).ConfigureAwait(false);
return(NodeRoles(node));
}
public NodeSession(Socket socket, NodeRole localRole)
{
this.socket = socket;
this.localRole = localRole;
this.ns = new NetworkStream(socket, FileAccess.ReadWrite, true);
this.reader = new BinaryReader(ns, Encoding.UTF8, true);
this.writer = new BinaryWriter(ns, Encoding.UTF8, true);
ProcessHandshake();
this.frameWriter = new FrameWriter(writer);
// this.frameReader = new FrameReader(reader);
}
static public MemoryStream GenerateHandshake(NodeRole nr, params object[] info)
{
MemoryStream ms = new MemoryStream();
List <object> args = new List <object>();
args.Add(nr);
args.AddRange(info);
Serializer.Serialize(ms, args.ToArray());
return(ms);
}
public NodeResults(string node)
{
Roles = NodeRole.Get(node).ToList();
foreach (var r in Roles)
{
if (r.Active)
{
Active++;
}
else
{
Inactive++;
}
}
}
internal DtpNodeSession(DtpNode node, Stream connection, NodeRole localRole)
{
Trace.Assert(localRole.HasFlag(NodeRole.Client) != localRole.HasFlag(NodeRole.Server));
aliveCancellationToken = aliveCancellationTokenSource.Token;
m_node = node;
m_connection = connection;
m_localRole = localRole;
if (m_localRole == NodeRole.Client)
{
m_locallyInitiatedUidSet = new UniqueIdentificationSet(kClientLitIdLow, kClientLitIdHigh);
}
else // Server
{
m_locallyInitiatedUidSet = new UniqueIdentificationSet(kServerLitIdLow, kServerLitIdHigh);
}
// - Setup Frame Processing --------------------------------------------------------------
// : Setup Frame Processors :
InitializeFrameProcessors(Environment.ProcessorCount);
// : Setup Reader/Writer Workers :
m_reader = new BinaryReader(m_connection, Encoding.Default, true);
m_frameReaderThread = new Thread(FrameReaderThreadStart)
{
IsBackground = true
};
m_frameReaderThread.Start();
m_writer = new BinaryWriter(m_connection, Encoding.Default, true);
m_frameWriterThread = new Thread(FrameWriterThreadStart)
{
IsBackground = true
};
m_frameWriterThread.Start();
// If we're the client, Send DSP_EX_INIT to elevate from DSP to DSPEx
// If we're the server, the DSP_EX_INIT opcode will be read by the frame reader thread.
if (m_localRole == NodeRole.Client)
{
m_writer.Write((byte)DTP.DSPEX_INIT);
}
}
public IDtpNode CreateNode(NodeRole role, string pipeName, IEnumerable <IInstructionSet> instructionSets = null)
{
if (role == NodeRole.ServerOrClient)
{
throw new ArgumentException("Cannot use " + role + " with named pipe constructor.");
}
else if (role == NodeRole.Client)
{
if (pipeName != null)
{
throw new InvalidOperationException("Use node.Connect, not CreateNode constructor!");
}
return(new DtpNode(new NullClientSource(), instructionSets));
}
else
{
return(new DtpNode(new NamedPipeClientSource(pipeName), instructionSets));
}
}
public void StartTimer()
{
curRandTime_ = rand_.Next(Config.Heartbeat_interval * 3, Config.Heartbeat_interval * 4);
Console.WriteLine(String.Format("{0} [{1}] current timer = {2}", id, role, curRandTime_));
timeout_timer_ = new Timer(
(Object obj) => {
lock (this)
{
role_ = NodeRole.Candidate;
state_ = ServerState.Timeout;
term_ = term_ + 1;
isVoteInThisTerm_ = true;
Console.WriteLine("{0} [{1}] ServerHandler {2}", id, role, state);
}
},
null,
curRandTime_,
curRandTime_);
}
public Transform GetNodeTransform(NodeRole role = NodeRole.Default)
{
if (role == NodeRole.Root)
{
return(transform);
}
if (Nodes == null || Nodes.Length == 0)
{
return(transform);
}
var node = Nodes.FirstOrDefault(n => n.Role == role);
if (node != null)
{
return(node.Transform);
}
return(Nodes[0].Transform);
}
public ClusterMonitor(NodeRole role, string localAddress, string partnerAddress,
Action <NodeState> stateChangedAction = null, Action <ClusterException> clusterExceptionAction = null,
IEnumerable <Func <NodeState, bool> > confirmActivationFuncs = null,
int partnerTimeout = 500, int connectTimeout = 0, bool becomeActiveWhenPrimaryOnInitialConnectionTimeout = false)
{
Role = role;
_localState = new InstanceState {
Role = role, Status = NodeStatus.Initial
};
if (role == NodeRole.StandAlone)
{
return; //no need to run when standalone
}
_stateChangedAction = stateChangedAction;
_clusterExceptionAction = clusterExceptionAction;
_machine = new ClusterStateMachine(HandleClusterException, CreateConfirmFunction(confirmActivationFuncs), becomeActiveWhenPrimaryOnInitialConnectionTimeout);
_proxy = new PubSubProxy(localAddress, partnerAddress, OnPartnerUpdate, OnConnectionStateChanged,
connectTimeout);
_partnerTimeout = partnerTimeout;
_pollingInterval = _partnerTimeout / 2;
_timer = new Timer(SendUpdateAndCheckForTimeout, null, Timeout.Infinite, _pollingInterval);
}
private Task TransitionTo(NodeRole newRole, IDictionary <string, string[]> hostArguments)
{
var startTasks = new ConcurrentBag <Task>();
Parallel.ForEach(_appStarters, starter =>
{
AppFunc chain = null;
if (Chains.ContainsKey(starter.Chain))
{
chain = Chains[starter.Chain];
}
chain = chain ?? starter.GetDefaultChain(GetAppFunctionBuilder(starter.Chain), Environment, ApplicationEnvironment);
if (chain != null)
{
startTasks.Add(starter.BringToState(chain, Environment, ApplicationEnvironment, newRole, hostArguments));
}
});
return(Task.WhenAll(startTasks));
}
public ServerHandler(int term, int _id, NodeRole _role, List <ClusterNodeSocket> _ExClusterNodeList)
{
TestNum = 0;
id_ = _id;
role_ = _role;
term_ = term;
state_ = ServerState.Running;
isVoteInThisTerm_ = false;
leader_should_stop_ = false;
is_election_done_ = false;
lastApplied_ = -1; //与论文不同，论文下标从1开始，所以初始值为0
commitIndex_ = -1;
election_state_ = ElectionState.Stop;
ExClusterNodeList_ = new List <ClusterNodeSocket>();
ExClusterNodeList_ = _ExClusterNodeList;
nextIndex_ = new int[ExClusterNodeList_.Count];
matchIndex_ = new int[ExClusterNodeList_.Count];
log_ = new List <LogEntryStruct>();
rand_ = new Random();
int seed = rand_.Next() * _id;
rand_ = new Random(seed);
}
private static ClusterStateMachine CreateClusterStateMachine(MockStateObserver observer, NodeRole role,
out InstanceState localState, Action<ClusterException> clusterExceptionAction = null)
{
var machine = new ClusterStateMachine(clusterExceptionAction ?? Assert.IsNull, s => true);
machine.StateChanged.Subscribe(observer);
localState = new InstanceState {Role = role};
machine.RaiseEvent(localState, machine.Start);
return machine;
}
public ClusterMonitorBuilder WithRole(NodeRole role)
{
_role = role;
return this;
}
private void TransitionTo(NodeRole newState)
{
_logger.Info(Host + " Change {" + State + "} => {" + newState + "} " + CurrentTerm);
State = newState;
}
public void TestCreateNewNode(int id, bool crashed, NodeRole role)
{
var newNode = _roadSystem.CreateNewNode(id, crashed, role);
Assert.AreEqual(id, newNode.ID);
Assert.AreEqual(crashed, newNode.Crashed);
Assert.AreEqual(role, newNode.Role);
Assert.IsTrue(_roadSystem.Contains(newNode));
Assert.AreSame(_roadSystem[id], newNode);
}
private static ClusterStateMachine CreateClusterStateMachine(MockStateObserver observer, NodeRole role,
out InstanceState localState, Action<ClusterException> clusterExceptionAction = null, bool becomeActiveWhenPrimaryOnInitialConnectionTimeout = false)
{
var machine = new ClusterStateMachine(clusterExceptionAction ?? Assert.IsNull, s => true, becomeActiveWhenPrimaryOnInitialConnectionTimeout);
machine.StateChanged.Subscribe(observer);
localState = new InstanceState { Role = role };
machine.RaiseEvent(localState, machine.Start);
return machine;
}
protected GameNodeProcessors AssignProcessor(Node n, MemoryStream nodeInfo)
{
NodeRole role = Serializer.Deserialize <NodeRole>(nodeInfo);
if (role == NodeRole.CLIENT)
{
if (!AuthorizeClient(n))
{
throw new GameNodeException(Log.StDump(n.info, role));
}
return(new GameNodeProcessors(ProcessClientMessage, ProcessClientDisconnect));
}
if (role == NodeRole.SERVER)
{
if (n.info.remote != serverHost)
{
throw new GameNodeException(Log.StDump(n.info, role, "bad server host"));
}
if (!AuthorizeServer(n))
{
throw new GameNodeException(Log.StDump(n.info, role));
}
return(new GameNodeProcessors(ProcessServerMessage, ProcessServerDisconnect));
}
if (role == NodeRole.PLAYER_VALIDATOR)
{
PlayerInfo inf = Serializer.Deserialize <PlayerInfo>(nodeInfo);
if (!AuthorizePlayerValidator(n, inf))
{
throw new GameNodeException(Log.StDump(role, n.info, inf));
}
return(new GameNodeProcessors(
(mt, stm, nd) => ProcessPlayerValidatorMessage(mt, stm, nd, inf),
(di) => ProcessPlayerValidatorDisconnect(di, inf)));
}
if (role == NodeRole.PLAYER_AGENT)
{
PlayerInfo inf = Serializer.Deserialize <PlayerInfo>(nodeInfo);
if (!AuthorizePlayerAgent(n, inf))
{
throw new GameNodeException(Log.StDump(role, n.info, inf));
}
return(new GameNodeProcessors(
(mt, stm, nd) => ProcessPlayerAgentMessage(mt, stm, nd, inf),
(di) => ProcessPlayerAgentDisconnect(di, inf)));
}
if (role == NodeRole.WORLD_VALIDATOR)
{
WorldInfo inf = Serializer.Deserialize <WorldInfo>(nodeInfo);
if (!AuthorizeWorld(n, inf))
{
throw new GameNodeException(Log.StDump(role, n.info, inf));
}
return(new GameNodeProcessors(
(mt, stm, nd) => ProcessWorldMessage(mt, stm, nd, inf),
(di) => ProcessWorldDisconnect(di, inf)));
}
throw new GameNodeException(Log.StDump(n.info, role, "unexpected"));
}
private static ClusterStateMachine CreateClusterStateMachine(MockStateObserver observer, NodeRole role,
out InstanceState localState, Action <ClusterException> clusterExceptionAction = null, bool becomeActiveWhenPrimaryOnInitialConnectionTimeout = false)
{
var machine = new ClusterStateMachine(clusterExceptionAction ?? Assert.IsNull, s => true, becomeActiveWhenPrimaryOnInitialConnectionTimeout);
machine.StateChanged.Subscribe(observer);
localState = new InstanceState {
Role = role
};
machine.RaiseEvent(localState, machine.Start);
return(machine);
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I32) {
HttpPort = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32) {
ThriftPort = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String) {
DataFolder = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String) {
PluginFolder = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String) {
ConfFolder = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String) {
NodeName = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.I32) {
NodeRole = (NodeRole)iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public ServerSettings() {
this._HttpPort = 9800;
this.__isset.HttpPort = true;
this._ThriftPort = 9900;
this.__isset.ThriftPort = true;
this._DataFolder = "./data";
this.__isset.DataFolder = true;
this._PluginFolder = "./plugins";
this.__isset.PluginFolder = true;
this._ConfFolder = "./conf";
this.__isset.ConfFolder = true;
this._NodeName = "FlexNode";
this.__isset.NodeName = true;
this._NodeRole = NodeRole.Master;
this.__isset.NodeRole = true;
}
public CurrentPlatformNodeDto(short pNodeId, NodeRole pNodeRole, bool pBelongsToStandalonePlatform)
{
id = pNodeId;
nodeRole = pNodeRole;
belongsToStandalonePlatform = pBelongsToStandalonePlatform;
}
