static string StartClients(string sctx, SynchronizedLogger logger, out DomainCommunicationProvider clientsNetworkProvider)
{
var configuration = Configuration.Create().WithMonitorsInProductionEnabled().WithVerbosityEnabled(2);
var runtime = PSharpRuntime.Create(configuration);
var runtimeHost = HostInfo.NewRuntimeHost(runtime);
clientsNetworkProvider = new DomainCommunicationProvider(runtimeHost, "clients");
runtimeHost.SetNetworkProvider(clientsNetworkProvider);
runtimeHost.SetLogger(logger);
var messages = new MessageCollection();
messages.CollectionChanged += (sender, e) => logger.WriteLine(e.NewItems[0].ToString());
var ctx = sctx.FromJson <DistributedStorageContext>();
var synchronizable = Synchronizable.Empty();
foreach (var storageNode in ctx.StorageNodes)
{
var waitIfHandledReplReq = logger.MachineActionHandledWait((machineId, _, actionName) => Equals(machineId, storageNode.Id) && actionName == "HandleReplReq");
synchronizable = synchronizable.Then(waitIfHandledReplReq.Delay(10));
}
logger.ApplySynchronization(synchronizable);
NewClients(runtimeHost, ctx, messages);
logger.WaitForWriting(6000);
return(ctx.ToJson());
}
public void System_should_halt_normally_if_events_are_sent_by_intended_order()
{
var monitorsNetworkProvider = default(DomainCommunicationProvider);
var serversNetworkProvider = default(DomainCommunicationProvider);
var storageNodesNetworkProvider = default(DomainCommunicationProvider);
var clientsNetworkProvider = default(DomainCommunicationProvider);
try
{
// Arrange
var sctx = default(string);
var logger = new SynchronizedLogger(new InMemoryLogger());
sctx = StartMonitors(sctx, logger, out monitorsNetworkProvider);
sctx = StartServers(sctx, logger, out serversNetworkProvider);
sctx = StartStorageNodes(sctx, logger, out storageNodesNetworkProvider);
sctx = StartClients(sctx, logger, out clientsNetworkProvider);
// Act
StartTimers(sctx, logger);
// Assert
Assert.DoesNotThrow(() => logger.WaitForWriting(1));
}
finally
{
monitorsNetworkProvider?.Dispose();
serversNetworkProvider?.Dispose();
storageNodesNetworkProvider?.Dispose();
clientsNetworkProvider?.Dispose();
}
}
public void Context_should_not_return_same_Machine_if_it_is_in_remote_and_multi_application()
{
// Arrange
var expected = default(int);
var actual = default(int);
var expected_Assign = new MarshalByRefAction <int>(i => expected = i);
var actual_Assign = new MarshalByRefAction <int>(i => actual = i);
// Act
AppDomain.CurrentDomain.RunAtIsolatedDomain((expected_Assign_, actual_Assign_) =>
{
var configuration = Configuration.Create().WithVerbosityEnabled(2);
var runtime = PSharpRuntime.Create(configuration);
var runtimeHost = HostInfo.NewRuntimeHost(runtime);
var logger = new SynchronizedLogger(new InMemoryLogger());
var setIfHandledHandshake = logger.MachineActionHandledSet((_1, _2, actionName) => actionName == "HandleHandshake");
logger.ApplySynchronization(setIfHandledHandshake);
runtimeHost.SetLogger(logger);
using (var networkProvider = new DomainCommunicationProvider(runtimeHost, "servers"))
{
var parameter = default(string);
{
runtimeHost.SetNetworkProvider(networkProvider);
var ctx = runtimeHost.New <DistributedStorageContext>();
ctx.Server = runtimeHost.New(MachineInterface.Sender <IServerSender>().Bundler <IServerBundler>().Receiver <ServerReceiverWithoutBug>());
ctx.Server.Configure(new ConfigureServer(new MessageCollection(), null, null));
expected_Assign_.Invoke(RuntimeHelpers.GetHashCode(ctx.Server));
parameter = ctx.ToJson();
}
AppDomain.CurrentDomain.RunAtIsolatedDomain((actual_Assign__, parameter_) =>
{
var ctx = parameter_.FromJson <DistributedStorageContext>();
actual_Assign__.Invoke(RuntimeHelpers.GetHashCode(ctx.Server));
ctx.Server.Handshake(new HandshakeServer(null, new IStorageNodeSender[0]));
}, actual_Assign_, parameter);
logger.WaitForWriting(1000);
}
}, expected_Assign, actual_Assign);
// Assert
Assert.AreNotEqual(expected, actual);
}
public void Machine_should_transit_its_state_according_to_passed_event()
{
// Arrange
var configuration = Configuration.Create().WithMonitorsInProductionEnabled().WithVerbosityEnabled(2);
var runtime = PSharpRuntime.Create(configuration);
var runtimeHost = HostInfo.NewRuntimeHost(runtime);
var logger = new SynchronizedLogger(new InMemoryLogger());
var setIfHandledSync = logger.MachineActionHandledSet((_1, _2, actionName) => actionName == "HandleSync");
logger.ApplySynchronization(setIfHandledSync);
runtimeHost.SetLogger(logger);
var server = runtimeHost.New(MachineInterface.Sender <IServerSender>().Bundler <IServerBundler>().Receiver <ServerReceiverWithoutBug>());
// Act
var messages = new MessageCollection();
var safetyMonitorMock = new Mock <ISafetyMonitorSender>();
var livenessMonitorMock = new Mock <ILivenessMonitorSender>();
server.Configure(new ConfigureServer(messages, safetyMonitorMock.Object, livenessMonitorMock.Object));
var clientMock = new Mock <IClientSender>();
var clientId = runtime.CreateMachine(typeof(Client));
clientMock.SetupGet(_ => _.Id).Returns(clientId);
var storageNodeMock = new Mock <IStorageNodeSender>();
var storageNodeId = runtime.CreateMachine(typeof(StorageNode));
storageNodeMock.Setup(_ => _.Id).Returns(storageNodeId);
server.Handshake(new HandshakeServer(clientMock.Object, new[] { storageNodeMock.Object }));
var clientReq = new ClientReq(42);
server.ClientReq(clientReq);
server.Sync(new Sync(storageNodeMock.Object, 0));
// Assert
Assert.That(logger.WaitForWriting(3000), Does.Contain("handled action 'HandleSync'"));
livenessMonitorMock.Verify(_ => _.ClientReq(clientReq));
storageNodeMock.Verify(_ => _.ReplReq(It.Is <ReplReq>(x => x.Data == clientReq.DataToReplicate)));
}
public void Initializer_and_OnEnterInvoke_can_specify_to_the_same_place()
{
// Arrange
var configuration = Configuration.Create().WithVerbosityEnabled(2);
var runtime = PSharpRuntime.Create(configuration);
var runtimeHost = HostInfo.NewRuntimeHost(runtime);
var logger = new SynchronizedLogger(new InMemoryLogger());
var waitIfEnteredInitialized1 = logger.MachineActionHandledWait((machineId, _, actionName) => machineId.Name.Contains("M1") && actionName == "EnterInitialized");
var waitIfEnteredInitialized2 = logger.MachineActionHandledWait((machineId, _, actionName) => machineId.Name.Contains("M2") && actionName == "EnterInitialized");
logger.ApplySynchronization(waitIfEnteredInitialized2.Then(waitIfEnteredInitialized1));
runtimeHost.SetLogger(logger);
// Act
runtimeHost.New(MachineInterface.Sender <M1.ISender>().Bundler <M1.IBundler>().Receiver <M1.Receiver>());
runtimeHost.New(MachineInterface.Sender <M2.ISender>().Bundler <M2.IBundler>().Receiver <M2.Receiver>());
// Assert
Assert.DoesNotThrow(() => logger.WaitForWriting(1000));
}
static void StartTimers(string sctx, SynchronizedLogger logger)
{
var ctx = sctx.FromJson <DistributedStorageContext>();
var lastStorageNode = ctx.StorageNodes.Last();
foreach (var storageNode in ctx.StorageNodes)
{
if (storageNode == lastStorageNode)
{
var setIfHandledTimeout = logger.MachineActionHandledSet((_1, _2, actionName) => actionName == "HandleTimeout");
var setIfEnteredExit = logger.MachineActionHandledSet((_1, _2, actionName) => actionName == "EnterExit");
logger.ApplySynchronization(setIfHandledTimeout.And(setIfEnteredExit));
}
else
{
var setIfHandledTimeout = logger.MachineActionHandledSet((_1, _2, actionName) => actionName == "HandleTimeout");
logger.ApplySynchronization(setIfHandledTimeout);
}
storageNode.Timeout(new Timeout());
logger.WaitForWriting(3000);
}
}
void InterfaceActivityTracker()
{
int k = 0;
int[] dataSavedSeconds = new int[this._Sensors.Count];
int[] secondsCounter = new int[this._Sensors.Count];
int[] full = new int[this._Sensors.Count];
int[] partial = new int[this._Sensors.Count];
int[] empty = new int[this._Sensors.Count];
if (!Directory.Exists(this._StorageDirectory + "\\log\\"))
{
Directory.CreateDirectory(this._StorageDirectory + "\\log\\");
}
if (!Directory.Exists(this._StorageDirectory + "\\data\\summary\\"))
{
Directory.CreateDirectory(this._StorageDirectory + "\\data\\summary\\");
}
for (int i = 0; (i < this._Sensors.Count); i++)
{
dataSavedSeconds[i] = 0;
secondsCounter[i] = 0;
full[i] = 0;
partial[i] = 0;
this._Sensors[i]._ReceivedACs = 0;
this._Sensors[i]._TotalReceivedACs = 0;
this._Sensors[i]._SavedACs = 0;
this._Sensors[i]._TotalSavedACs = 0;
Core.WRITE_FULL_RECEIVED_COUNT(i, 0);
Core.WRITE_PARTIAL_RECEIVED_COUNT(i, 0);
Core.WRITE_EMPTY_RECEIVED_COUNT(i, 0);
Core.WRITE_RECEIVED_ACs(i, -1);
Core.WRITE_SAVED_ACs(i, -1);
}
while (true)
{
if (connecting)
{
SystemIdleTimerReset();
if ((this != null) && (this._Sensors.Count > 0))
{
//Check 2 things, num of connection failures
// check if data received is > 0
// if num connections >2, ready to pause
// if data received is >0, ready to pause within 2 seconds.
bool receiveFailed = true;
bool receivedFullData = true;
bool notimeoutData = true;
for (int i = 0; (i < this._Sensors.Count); i++)
{
receivedFullData &= (this._Sensors[i]._ReceivedPackets == ((WocketsDecoder)this._Decoders[i])._ExpectedBatchCount);
//halt, if either 1 successful connection was made
// or any data was received
// or 3 or more reconnections were made
if ((((RFCOMMReceiver)this._Receivers[i])._Reconnections < 3))
{
receiveFailed = false;
}
//if (((RFCOMMReceiver)this._Receivers[i])._SuccessfulConnections >= 1)
secondsCounter[i] = secondsCounter[i] + 1;
notimeoutData &= (secondsCounter[i] > 20);
}
if ((receivedFullData) || (receiveFailed) || (notimeoutData))
{
// if didnt get full data, sleep for 2 seconds
if (!receivedFullData)
{
Thread.Sleep(3000);
}
//save whatever we have so far then sleep
connecting = false;
SYSTEM_POWER_STATUS_EX2 bpower = Battery.GetSystemPowerStatus();
DateTime now = DateTime.Now;
double unixtime = WocketsTimer.GetUnixTime(now);
string currentTime = now.ToString("yyyy-MM-dd HH:mm:ss");
string log_line = ++k + "," + currentTime + "," + bpower.BatteryLifePercent + "," + bpower.BatteryVoltage + "," + bpower.BatteryCurrent + "," + bpower.BatteryTemperature;
string hourlyPath = now.ToString("yyyy-MM-dd") + "\\" + now.Hour;
DiskSpace space1 = Memory.GetDiskSpace(this._StorageDirectory);
DiskSpace space2 = Memory.GetDiskSpace("/");
int remainingStorage1 = (int)(space1.TotalNumberOfBytes / System.Math.Pow(2, 20));
int remainingStorage2 = (int)(space2.TotalNumberOfBytes / System.Math.Pow(2, 20));
string upload_log = currentTime + "," + bpower.BatteryLifePercent + "," + remainingStorage2 + "," + remainingStorage1;
for (int i = 0; (i < this._Sensors.Count); i++)
{
if ((this._Sensors[i]._ReceivedPackets > 4000) || (((WocketsDecoder)this._Decoders[i])._ExpectedBatchCount > 4000))
{
upload_log += "," + this._Sensors[i]._BatteryLevel + "," + 0 + "," + 0;
}
else
{
upload_log += "," + this._Sensors[i]._BatteryLevel + "," + ((WocketsDecoder)this._Decoders[i])._ExpectedBatchCount + "," + this._Sensors[i]._ReceivedPackets;
}
if (this._Sensors[i]._ReceivedPackets == ((WocketsDecoder)this._Decoders[i])._ExpectedBatchCount)
{
full[i] = full[i] + 1;
}
else if (this._Sensors[i]._ReceivedPackets == 0)
{
empty[i] = empty[i] + 1;
}
else
{
partial[i] = partial[i] + 1;
}
Core.WRITE_FULL_RECEIVED_COUNT(i, full[i]);
Core.WRITE_PARTIAL_RECEIVED_COUNT(i, partial[i]);
Core.WRITE_EMPTY_RECEIVED_COUNT(i, empty[i]);
Core.WRITE_RECEIVED_ACs(i, ((WocketsDecoder)this._Decoders[i])._ACIndex);
Core.WRITE_RECEIVED_COUNT(i, this._Sensors[i]._ReceivedPackets);
log_line += "," + this._Sensors[i]._ReceivedPackets + "," + ((WocketsDecoder)this._Decoders[i])._ExpectedBatchCount + "," + ((RFCOMMReceiver)this._Receivers[i])._SuccessfulConnections + "," + ((RFCOMMReceiver)this._Receivers[i])._Reconnections + "," + ((RFCOMMReceiver)this._Receivers[i])._ConnectionTime;
dataSavedSeconds[i] = 0;
countSeconds[i] = false;
secondsCounter[i] = 0;
((WocketsDecoder)this._Decoders[i])._ExpectedBatchCount = -1;
if (!Directory.Exists(this._StorageDirectory + "\\data\\summary\\" + hourlyPath))
{
Directory.CreateDirectory(this._StorageDirectory + "\\data\\summary\\" + hourlyPath);
}
TextWriter tw2 = new StreamWriter(this._StorageDirectory + "\\data\\summary\\" + hourlyPath + "\\SummaryAC-" + this._Sensors[i]._Location + "-" + i + ".csv", true);
int nextACIndex = LastACIndex[i] + 1;
if (nextACIndex == 960)
{
nextACIndex = 0;
}
int countsaved = 0;
for (int j = nextACIndex; (j != ((WocketsDecoder)this._Decoders[i])._ActivityCountIndex);)
{
DateTime ac_dt = new DateTime();
WocketsTimer.GetDateTime((long)((WocketsDecoder)this._Decoders[i])._ActivityCounts[j]._TimeStamp, out ac_dt);
string ac_currentTime = ac_dt.ToString("yyyy-MM-dd HH:mm:ss");
tw2.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "," + j + "," + ((WocketsDecoder)this._Decoders[i])._ActivityCounts[j]._SeqNum + "," + ac_currentTime + "," + ((WocketsDecoder)this._Decoders[i])._ActivityCounts[j]._TimeStamp + "," + ((WocketsDecoder)this._Decoders[i])._ActivityCounts[j]._Count);
SynchronizedLogger.Write(i + "," + ac_currentTime + "," + ((RFCOMMReceiver)this._Receivers[i])._Address + "," + ((WocketsDecoder)this._Decoders[i])._ActivityCounts[j]._Count);
LastSeqNum[i] = ((WocketsDecoder)this._Decoders[i])._ActivityCounts[j]._SeqNum;
LastACIndex[i] = j;
countsaved++;
j++;
if (j == 960)
{
j = 0;
}
}
if (countsaved > 10)
{
Core.WRITE_SAVED_ACs(i, 10);
}
else
{
Core.WRITE_SAVED_ACs(i, countsaved);
}
tw2.Close();
}
this._Polling = false;
//shutting down BT here causes a strange delay on wakeup.
int btshutdown_counter = 0;
while (true)
{
btshutdown_counter++;
try
{
if ((Wockets.Utils.network.NetworkStacks._BluetoothStack.Dispose()) || (btshutdown_counter > 5))
{
break;
}
}
catch
{
}
SystemIdleTimerReset();
Thread.Sleep(1000);
}
SynchronizedLogger.Write(upload_log);
//TextWriter tw = new StreamWriter(this._StorageDirectory + "\\data\\log\\" + hourlyPath + "\\stats.csv", true);
//tw.Close();
Logger.Log(log_line);
SystemIdleTimerReset();
for (int i = 0; (i < this._Sensors.Count); i++)
{
try
{
this._Sensors[i].Save();
}
catch (Exception e)
{
Logger.Error("Sensor " + i + ": failed to save:" + e.Message);
}
}
Thread.Sleep(1000);
if ((bpower.BatteryCurrent < 0) && (DateTime.Now.Subtract(lastActivity).TotalSeconds > 30))
{
SetSystemPowerState(null, POWER_STATE_SUSPEND, POWER_FORCE);
}
}
}
}
Thread.Sleep(1000);
}
}