static void PopulateNode(ManagedRSLNode node, ulong memberId)
{
node.HostName = "127.0.0.1";
//node.Ip = (uint) IPAddress.Parse(node.HostName).Address;
node.Ip = new IPAddress(0x0100007F);
node.MemberId = memberId.ToString();
node.RslPort = (ushort)(g_port + memberId * 1000);
}
void ChangeConfigurationIfNeeded()
{
ManagedRSLMemberSet currentMemberSet = new ManagedRSLMemberSet();
uint configurationNumber = 0;
GetConfiguration(currentMemberSet, ref configurationNumber);
uint currentConfigurationNumber = 0;
byte[] cookie = currentMemberSet.ConfigurationCookie;
if (cookie != null)
{
currentConfigurationNumber = (uint)BitConverter.ToInt32(cookie, 0);
}
int desiredConfigurationNumber = 0;
int numMembersInDesiredConfiguration = 0;
int[] memberIdsOfDesiredConfiguration = null;
if (!ReadConfigurationFromFile(ref desiredConfigurationNumber,
ref numMembersInDesiredConfiguration,
ref memberIdsOfDesiredConfiguration))
{
return;
}
if (currentConfigurationNumber >= desiredConfigurationNumber)
{
if (currentConfigurationNumber > g_maxConfigurationReported)
{
if (ReportCurrentConfiguration(currentConfigurationNumber))
{
g_maxConfigurationReported = currentConfigurationNumber;
}
}
return;
}
Console.WriteLine("New configuration found:");
ManagedRSLNode[] membersOfNewConfiguration =
new ManagedRSLNode[numMembersInDesiredConfiguration];
for (int whichMember = 0; whichMember < numMembersInDesiredConfiguration; ++whichMember)
{
ManagedRSLNode node = new ManagedRSLNode();
membersOfNewConfiguration[whichMember] = node;
PopulateNode(node, (ulong)memberIdsOfDesiredConfiguration[whichMember]);
Console.Write("{0} ", node.MemberId);
}
Console.WriteLine();
byte[] configNumberBytes = BitConverter.GetBytes(desiredConfigurationNumber);
ManagedRSLMemberSet memberSet = new ManagedRSLMemberSet(
membersOfNewConfiguration,
configNumberBytes,
0,
configNumberBytes.Length);
ChangeConfiguration(memberSet, this);
}
public override bool AcceptMessageFromReplica(ManagedRSLNode node, byte[] data)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
this.Log(TestTracer.EventType.AcceptMessageFromReplicaCalled, " AcceptMessageFromReplica was called: node = {0}", node.MemberId);
return(true);
}
public override bool AcceptMessageFromReplica(ManagedRSLNode node, byte [] primaryCookie)
{
Console.WriteLine(this.Self.MemberId + ".AcceptMessageFromReplica(" + node.MemberId + ")");
if (String.Equals(node.MemberId, MemberIdToEvict))
{
Console.WriteLine(this.Self.MemberId + ".AcceptMessageFromReplica(" + node.MemberId + ")=false --------------------------------------------");
return(false);
}
return(true);
}
public static BasicStateMachine CreateSM(int instance, bool designatedPrimary, TestConfig cfg, TestTracer tracer)
{
ManagedRSLNode[] nodes = new ManagedRSLNode[cfg.Ports.Length / 2];
for (int i = 0; i < nodes.Length; i++)
{
nodes[i] = BasicStateMachine.CreateNode(cfg.Ports[2 * i], cfg.Ports[(2 * i) + 1]);
}
BasicStateMachine sm = new BasicStateMachine(tracer, nodes[instance].RslPort, nodes[instance].RslLearnPort);
try
{
sm.CanBP = designatedPrimary;
using (ManagedRSLConfigParam rslCfg = SetupConfiguration(cfg.RslData))
{
Stopwatch w = Stopwatch.StartNew();
while (true)
{
if (sm.Initialize(rslCfg, sm.SelfNode, ManagedRSLProtocolVersion.ManagedRSLProtocolVersion_5, false))
{
break;
}
if (w.ElapsedMilliseconds > 10000)
{
throw new InvalidOperationException("couldn't initialize the SM");
}
Thread.Sleep(100);
}
sm.InitiateBootstrap(nodes, 10);
return(sm);
}
}
catch (Exception e)
{
try
{
sm.Log("Exception during InitializeStateMachine {0}", e);
}
catch (Exception)
{
// ignore
}
sm.Dispose();
throw;
}
}
void Run(ManagedRSLNode[] nodes, ManagedRSLConfigParam cfgParam, ManagedRSLNode selfNode)
{
m_score = 0;
m_outstanding = 0;
m_size = 10 * 1024 * 1024;
m_state = new byte[m_size];
m_clientEnd = false;
m_isPrimary = false;
bool res = Initialize(
cfgParam,
nodes,
selfNode,
ManagedRSLProtocolVersion.ManagedRSLProtocolVersion_3,
false);
Debug.Assert(res);
for (int timer = 0; !m_clientEnd; timer++)
{
if (timer >= 1000 / SLEEP_TIME)
{
timer = 0;
if (m_isPrimary)
{
ChangeConfigurationIfNeeded();
}
}
if (m_isPrimary && m_outstanding < 1)
{
byte[] inc = BitConverter.GetBytes((int)1);
SendRequest(inc, this, UInt64.MaxValue);
}
Thread.Sleep(SLEEP_TIME);
}
}
public static ManagedRSLNode CreateNode(ushort port, ushort learnport)
{
ManagedRSLNode node = new ManagedRSLNode();
try
{
node.Ip = IPAddress.Loopback;
node.HostName = node.Ip.ToString();
node.MemberId = "instance_" + port;
node.RslPort = port;
node.RslLearnPort = learnport;
}
catch (Exception)
{
if (node != null)
{
node.Dispose();
}
throw;
}
return(node);
}
public BasicRSLTestMachine(ManagedRSLNode self)
{
this.Self = self;
this.InternalState = int.MinValue;
}
public override bool AcceptMessageFromReplica(ManagedRSLNode node, byte [] primaryCookie)
{
return(true);
}
static void Main(string[] args)
{
if (args.Length != 1)
{
PrintUsage(null);
Exit(1);
}
int id = Int32.Parse(args[0]);
ManagedRSLStateMachine.Init(@".\debuglogs\" + id);
ManagedRSLConfigParam cfgParam = new ManagedRSLConfigParam();
// Initialize the default config param
cfgParam.NewLeaderGracePeriodSec = 15;
cfgParam.HeartBeatIntervalSec = 2;
cfgParam.ElectionDelaySec = 10;
cfgParam.MaxElectionRandomizeSec = 1;
cfgParam.InitializeRetryIntervalSec = 1;
cfgParam.PrepareRetryIntervalSec = 1;
cfgParam.VoteRetryIntervalSec = 3;
cfgParam.CPQueryRetryIntervalSec = 5;
cfgParam.MaxCheckpointIntervalSec = 0;
cfgParam.JoinMessagesIntervalSec = 1;
cfgParam.MaxLogLenMB = 1;
cfgParam.SendTimeoutSec = 5;
cfgParam.ReceiveTimeoutSec = 5;
cfgParam.MaxCacheLengthMB = 50;
cfgParam.MaxVotesInLog = 10000;
cfgParam.MaxOutstandingPerReplica = 10;
cfgParam.MaxCheckpoints = 4;
cfgParam.MaxLogs = 10;
cfgParam.LogLenRandomize = 20;
cfgParam.ElectionRandomize = 10;
cfgParam.FastReadSeqThreshold = 5;
cfgParam.InMemoryExecutionQueueSizeMB = 10;
cfgParam.NumReaderThreads = 3;
cfgParam.WorkingDir = @".\data";
int configNumber = 0;
int numReplicas = 0;
int[] memberIds = null;
bool res = ReadConfigurationFromFile(ref configNumber, ref numReplicas, ref memberIds);
Debug.Assert(res);
// Populate member set
if (id <= 0)
{
PrintUsage("invalid member id!");
Exit(1);
}
int bufSize = 100 * 1024;
g_buf = new byte[bufSize];
for (int i = 0; i < bufSize; i++)
{
g_buf[i] = (byte)('a' + (i % 26));
}
ManagedRSLNode[] nodes = new ManagedRSLNode[numReplicas];
for (int i = 0; i < numReplicas; i++)
{
nodes[i] = new ManagedRSLNode();
PopulateNode(nodes[i], (uint)memberIds[i]);
}
ManagedRSLNode selfNode = new ManagedRSLNode();
PopulateNode(selfNode, (uint)id);
// Start replica
Console.WriteLine("Starting member #" + selfNode.MemberId);
TestRSLStateMachineProcessor sm = new TestRSLStateMachineProcessor();
sm.Run(nodes, cfgParam, selfNode);
}
/// <summary>
/// Starts the configured number of replicas, this function will create
/// the necessery files that are needed for the aplicaton to run
/// </summary>
/// <param name="numberOfReplicas">numberOfReplicas</param>
/// <returns></returns>
public int StartUp(int numberOfReplicas)
{
cfg = new ManagedRSLConfigParam();
cfg.NewLeaderGracePeriodSec = 10;
cfg.HeartBeatIntervalSec = 2;
cfg.ElectionDelaySec = 5;
cfg.MaxElectionRandomizeSec = 1;
cfg.InitializeRetryIntervalSec = 1;
cfg.PrepareRetryIntervalSec = 1;
cfg.VoteRetryIntervalSec = 1;
cfg.CPQueryRetryIntervalSec = 5;
cfg.MaxCheckpointIntervalSec = 0;
cfg.MaxLogLenMB = 100;
cfg.SendTimeoutSec = 10;
cfg.ReceiveTimeoutSec = 10;
cfg.MaxCacheLengthMB = 50;
cfg.MaxVotesInLog = 1000;
cfg.MaxOutstandingPerReplica = 10;
cfg.MaxCheckpoints = 2;
cfg.MaxLogs = 5;
cfg.LogLenRandomize = 20;
cfg.ElectionRandomize = 10;
cfg.FastReadSeqThreshold = 5;
cfg.InMemoryExecutionQueueSizeMB = 10;
cfg.NumReaderThreads = 5;
cfg.MaxMessageSizeMB = 1;
cfg.WorkingDir = RSLWorkingDir;
ManagedRSLNode[] nodes = new ManagedRSLNode[numberOfReplicas];
for (int i = 0; i < nodes.Length; i++)
{
nodes[i] = new ManagedRSLNode();
nodes[i].MemberId = (i + 1).ToString();
nodes[i].RslPort = (ushort)(5000 + (100 * (i + 1)));
nodes[i].HostName = "127.0.0.1";
nodes[i].Ip = new IPAddress(0x0100007F); // 127.0.0.1
}
int startedReplicas = 0;
if (_replicaSet == null)
{
_replicaSet = new List <BasicRSLTestMachine>();
ManagedRSLStateMachine.NotificationsCallback = OnNotification;
ManagedRSLStateMachine.Init(".\\" + RSLDebugLogsDir);
for (int i = 0; i < nodes.Length; i++)
{
BasicRSLTestMachine replica = new BasicRSLTestMachine(nodes[i]);
try
{
bool res = replica.Initialize(
cfg,
nodes[i],
ManagedRSLProtocolVersion.ManagedRSLProtocolVersion_4,
false);
Debug.Assert(res);
startedReplicas++;
_replicaSet.Add(replica);
_allReplicaSet.Add(replica);
}
catch (Exception e)
{
if (e is NullReferenceException || e is System.Runtime.InteropServices.SEHException)
{
throw;
}
} //catch
} // for
Console.WriteLine("Bootstrapping");
byte[] buf = new byte[] { 1 };
ManagedRSLMemberSet memberSet = new ManagedRSLMemberSet(nodes, buf, 0, 1);
foreach (BasicRSLTestMachine replica in _allReplicaSet)
{
RSLResponse resp = replica.Bootstrap(memberSet, 10);
Console.WriteLine(resp);
}
}
else
{
startedReplicas = _replicaSet.Count;
}
return(startedReplicas);
} //StartUp
static void Main(string[] args)
{
uint lastRequested = 0;
Hashtable arguments = ParseArguments(args);
imPrimary = false;
int id = (int)arguments["id"];
int targetState = (int)arguments["cases"];
int numReplicas = (int)arguments["numreplicas"];
//Create the output stream
try
{
//_writer = new System.IO.StreamWriter((String)arguments["out"], true);
_writer = Console.Out;
}
catch
{
System.Environment.Exit(-1);
}
//Start up the common infraestructure
ManagedRSLConfigParam cfg = new ManagedRSLConfigParam();
cfg.NewLeaderGracePeriodSec = 10;
cfg.HeartBeatIntervalSec = 2;
cfg.ElectionDelaySec = 5;
cfg.MaxElectionRandomizeSec = 1;
cfg.InitializeRetryIntervalSec = 1;
cfg.PrepareRetryIntervalSec = 1;
cfg.VoteRetryIntervalSec = 1;
cfg.CPQueryRetryIntervalSec = 5;
cfg.MaxCheckpointIntervalSec = 0;
cfg.JoinMessagesIntervalSec = 1;
cfg.MaxLogLenMB = 10;
cfg.SendTimeoutSec = 10;
cfg.ReceiveTimeoutSec = 10;
cfg.MaxCacheLengthMB = 50;
cfg.MaxVotesInLog = 1000;
cfg.MaxOutstandingPerReplica = 10;
cfg.MaxCheckpoints = 2;
cfg.MaxLogs = 5;
cfg.LogLenRandomize = 20;
cfg.ElectionRandomize = 10;
cfg.FastReadSeqThreshold = 5;
cfg.InMemoryExecutionQueueSizeMB = 10;
cfg.NumReaderThreads = 5;
cfg.MaxMessageSizeMB = 1;
cfg.WorkingDir = ".\\rslib" + id;
ManagedRSLNode[] nodes = new ManagedRSLNode[numReplicas];
for (int i = 0; i < nodes.Length; i++)
{
nodes[i] = new ManagedRSLNode();
nodes[i].MemberId = (i + 1).ToString();
nodes[i].RslPort = (ushort)(20000 + (1000 * (i + 1)));
nodes[i].HostName = "127.0.0.1";
nodes[i].Ip = new IPAddress(0x0100007F); // 127.0.0.1
}
ManagedRSLNode selfNode = new ManagedRSLNode();
selfNode.MemberId = id.ToString();
selfNode.RslPort = (ushort)(20000 + (1000 * id));
selfNode.HostName = "127.0.0.1";
selfNode.Ip = new IPAddress(0x0100007F); // 127.0.0.1
ManagedRSLStateMachine.Init(".\\debuglogs" + id);
//Create and initialize the state machine
_stateMachine = new StateMachine((int)arguments["reqsize"]);
if (_stateMachine.Initialize(cfg, nodes, selfNode, ManagedRSLProtocolVersion.ManagedRSLProtocolVersion_4, false) == false)
{
System.Environment.Exit(-1);
}
//Wait 3 seconds for the pending request to be executed
System.Threading.Thread.Sleep(3000);
_writer.WriteLine("{1} Initial state: {0}", _stateMachine.State, DateTime.Now);
lastRequested = _stateMachine.State;
//Execute the test scenario
while (_stateMachine.State < targetState)
{
if (imPrimary)
{
if (_stateMachine.State == lastRequested)
{
if (_stateMachine.WriteToState((UInt32)_stateMachine.State + 1) == true)
{
lastRequested = _stateMachine.State + 1;
lock (_writer)
{
_writer.WriteLine("{1} Request: {0}", lastRequested, DateTime.Now);
}
}
}
}
else
{
lastRequested = _stateMachine.State;
}
_stateMachine.ReadFromState();
_writer.Flush();
System.Threading.Thread.Sleep(1);
}
_stateMachine.DumpState();
_writer.Flush();
try
{
_writerFlag = new System.IO.StreamWriter(String.Format("{0}.done", arguments["out"]), true);
_writerFlag.WriteLine("DONE");
_writerFlag.Close();
}
catch
{
System.Environment.Exit(-1);
}
_writer.Close();
System.Threading.Thread.Sleep(int.MaxValue);
}
