public override void HandleMessage(ICDEThing sender, object pIncoming) { TheProcessMessage pMsg = pIncoming as TheProcessMessage; if (pMsg == null || pMsg.Message == null) { return; } var cmd = TheCommonUtils.cdeSplit(pMsg.Message.TXT, ":", false, false); switch (cmd[0]) { case nameof(MsgAddConnectionThing <TConnectionThingParam>): var addMsg = TheCommRequestResponse.ParseRequestMessageJSON <MsgAddConnectionThing <TConnectionThingParam> >(pMsg.Message); var responseMsg = new MsgAddConnectionThingResponse { Error = "Unexpected" }; if (addMsg != null) { var thingToAdd = addMsg.ThingToAdd; if (thingToAdd != null) { var currentThing = MyConnectionThings.MyMirrorCache.GetEntryByID(thingToAdd.cdeMID); var newThing = new TConnectionThing(); newThing.Initialize(thingToAdd); if (currentThing == null) { MyConnectionThings.AddAnItem(newThing); responseMsg.Error = null; } else { if (!newThing.IsEqual(currentThing)) { UpdateConnectionThing(currentThing, newThing); MyConnectionThings.UpdateItem(newThing); Connect(); } responseMsg.Error = null; } } else { responseMsg.Error = "INVALIDARGS"; } } TheCommRequestResponse.PublishResponseMessageJson(pMsg.Message, responseMsg); break; default: base.HandleMessage(sender, pIncoming); break; } }
internal TheStorageMirror <TheEventLogData> MyRuleEventLog; //The Storage Container for data to store public override bool LogEvent(TheEventLogData pData) { if (!MyRuleEventLog.IsReady) { return(false); } MyRuleEventLog.AddAnItem(pData); return(true); }
public void Write(TheNMILiveTag pTag, string pEventLabel, string pComment) { TheNMITagLogEntry tEntry = new TheNMITagLogEntry { ID = pTag.GetBaseThing().ID, Value = TheCommonUtils.CDbl(pTag.GetBaseThing().Value), EngineName = pTag.GetBaseThing().EngineName, EventLabel = pEventLabel, Comment = pComment }; MyTagLog.AddAnItem(tEntry); }
void sinkStorageReady(StoreEventArgs pArgs) { string FileToReturn1 = TheCommonUtils.cdeFixupFileName(Address); DirectoryInfo di = new DirectoryInfo(FileToReturn1); List <TheFileInfo> tList = new List <TheFileInfo>(); TheISMManager.ProcessDirectory(di, ref tList, "", ".TXT", false, true); MyLogFiles.MyMirrorCache.Clear(false); foreach (TheFileInfo t in tList) { MyLogFiles.AddAnItem(new TheBackupDefinition() { FileName = t.FileName, Title = t.Name, BackupSize = t.FileSize, BackupTime = t.CreateTime }); } }
private void Add(int pEventID, long pSerial, string pSource, TSM AMessage) { TheEventLogEntry tLog = new TheEventLogEntry { Message = AMessage, Serial = pSerial, Source = string.IsNullOrEmpty(pSource) ? AMessage.ENG : pSource, EventID = pEventID }; MyMessageLog.AddAnItem(tLog); if (IsEventRegistered("NewLogEntry")) { FireEvent("NewLogEntry", new TheProcessMessage() { Message = AMessage, Cookie = tLog }, true); //Prevents a call to AddScopeID for the TOPIC } }
//Helper to update storage list private void UpdateStorageList(string name, string status, int step, TheScript script, TheThing context, bool replay) { ScriptSnapshot existingSnapshot = null; // No longer adding a new entry on replay because the list is now used to disable script/steps etc. existingSnapshot = MyScriptTableStorage.MyMirrorCache.GetEntryByFunc(snapshot => snapshot.ScriptName == name && snapshot.ScriptStep == step); var stepName = step > 0 && step <= script?.Steps.Length ? script?.Steps[step - 1]?.GetName() ?? "" : ""; if (existingSnapshot == null) { var newSnapshot = new ScriptSnapshot { ScriptName = name, ScriptStatus = status, StepName = stepName, ScriptStep = step, ContextScript = script, FileName = script?.FileName, ScriptRaw = script?.ScriptRaw, Context = context, LastUpdate = DateTimeOffset.Now, }; MyScriptTableStorage.AddAnItem(newSnapshot); } else { existingSnapshot.ScriptName = name; existingSnapshot.ScriptStatus = status; existingSnapshot.StepName = stepName; existingSnapshot.ScriptStep = step; existingSnapshot.ContextScript = script; existingSnapshot.FileName = script?.FileName; existingSnapshot.ScriptRaw = script?.ScriptRaw; existingSnapshot.Context = context; existingSnapshot.LastUpdate = DateTimeOffset.Now; MyScriptTableStorage.UpdateItem(existingSnapshot); } }
/// <summary> /// Handles Messages sent from a host sub-engine to its clients /// </summary> /// <param name="Command"></param> /// <param name="pMessage"></param> public override void HandleMessage(ICDEThing sender, object pIncoming) { TheProcessMessage pMsg = pIncoming as TheProcessMessage; if (pMsg == null) { return; } string[] cmd = pMsg.Message.TXT.Split(':'); switch (cmd[0]) { case nameof(TheThing.MsgBrowseSensors): var browseRequest = TheCommRequestResponse.ParseRequestMessageJSON <TheThing.MsgBrowseSensors>(pMsg.Message); var browseResponse = new TheThing.MsgBrowseSensorsResponse { Error = "Internal error", Sensors = new List <TheThing.TheSensorSourceInfo>() }; foreach (FieldMapping fld in MyModFieldStore.TheValues) { browseResponse.Sensors.Add(new TheThing.TheSensorSourceInfo { SourceType = fld.SourceType, cdeType = ePropertyTypes.TNumber, SensorId = TheCommonUtils.CStr(fld.cdeMID), ExtensionData = new Dictionary <string, object> { { nameof(FieldMapping.SourceOffset), fld.SourceOffset }, { nameof(FieldMapping.SourceSize), fld.SourceSize }, { nameof(FieldMapping.AllowWrite), fld.AllowWrite } }, DisplayNamePath = new string[] { MyBaseEngine.GetEngineName(), MyBaseThing.FriendlyName, fld.PropertyName } }); } browseResponse.Error = null; TheCommRequestResponse.PublishResponseMessageJson(pMsg.Message, browseResponse); break; case nameof(TheThing.MsgSubscribeSensors): var subscribeRequest = TheCommRequestResponse.ParseRequestMessageJSON <TheThing.MsgSubscribeSensors>(pMsg.Message); var subscribeResponse = new TheThing.MsgSubscribeSensorsResponse { Error = "Internal error", SubscriptionStatus = new List <TheThing.TheSensorSubscriptionStatus>() }; if (subscribeRequest.ReplaceAll) { MyModFieldStore.RemoveAllItems(); } var subscriptionStatus = new List <TheThing.TheSensorSubscriptionStatus>(); foreach (TheThing.TheSensorSubscription sub in subscribeRequest.SubscriptionRequests) { FieldMapping fld = new FieldMapping() { PropertyName = sub.TargetProperty, cdeMID = TheCommonUtils.CGuid(sub.SensorId) }; if (fld.cdeMID == Guid.Empty) { fld.cdeMID = Guid.NewGuid(); } object sourceType; if (sub.ExtensionData != null) { if (sub.ExtensionData.TryGetValue(nameof(TheThing.TheSensorSourceInfo.SourceType), out sourceType)) { fld.SourceType = TheCommonUtils.CStr(sourceType); } object offset; if (sub.ExtensionData.TryGetValue("SourceOffset", out offset)) { fld.SourceOffset = TheCommonUtils.CInt(offset); } object size; if (sub.ExtensionData.TryGetValue("SourceSize", out size)) { fld.SourceSize = TheCommonUtils.CInt(size); } object allowWrite; if (sub.ExtensionData.TryGetValue("AllowWrite", out allowWrite)) { fld.AllowWrite = TheCommonUtils.CBool(allowWrite); } MyModFieldStore.AddAnItem(fld); subscriptionStatus.Add(CreateSubscriptionStatusFromFieldMapping(fld)); } else { subscriptionStatus.Add(new TheThing.TheSensorSubscriptionStatus { Error = "Missing source info", Subscription = sub, }); } } subscribeResponse.SubscriptionStatus = subscriptionStatus; subscribeResponse.Error = null; TheCommRequestResponse.PublishResponseMessageJson(pMsg.Message, subscribeResponse); break; case nameof(TheThing.MsgGetSensorSubscriptions): var getResponse = new TheThing.MsgGetSensorSubscriptionsResponse { Error = "Internal error" }; getResponse.Subscriptions = MyModFieldStore.TheValues.Select(fld => CreateSubscriptionStatusFromFieldMapping(fld).Subscription).ToList(); getResponse.Error = null; TheCommRequestResponse.PublishResponseMessageJson(pMsg.Message, getResponse); break; case nameof(TheThing.MsgUnsubscribeSensors): var unsubscribeRequest = TheCommRequestResponse.ParseRequestMessageJSON <TheThing.MsgUnsubscribeSensors>(pMsg.Message); var unsubscribeResponse = new TheThing.MsgUnsubscribeSensorsResponse { Error = "Internal error", Failed = new List <TheThing.TheSensorSubscriptionStatus>() }; if (unsubscribeRequest.UnsubscribeAll) { MyModFieldStore.RemoveAllItems(); if (MyModFieldStore.GetCount() > 0) { unsubscribeResponse.Failed = MyModFieldStore.TheValues.Select(fld => CreateSubscriptionStatusFromFieldMapping(fld)).ToList(); } } else { List <FieldMapping> toRemove = MyModFieldStore.TheValues.FindAll(fld => unsubscribeRequest.SubscriptionIds.Contains(fld.cdeMID)); MyModFieldStore.RemoveItems(toRemove, null); foreach (FieldMapping fld in MyModFieldStore.TheValues) { if (toRemove.Any(t => t.cdeMID == fld.cdeMID)) { unsubscribeResponse.Failed.Add(CreateSubscriptionStatusFromFieldMapping(fld)); } } } unsubscribeResponse.Error = null; TheCommRequestResponse.PublishResponseMessageJson(pMsg.Message, unsubscribeResponse); break; case nameof(TheThing.MsgExportConfig): var exportRequest = TheCommRequestResponse.ParseRequestMessageJSON <TheThing.MsgExportConfig>(pMsg.Message); var exportResponse = new TheThing.MsgExportConfigResponse { Error = "Internal error" }; // No custom config beyond config properties and subscriptions exportResponse.Error = null; TheCommRequestResponse.PublishResponseMessageJson(pMsg.Message, exportResponse); break; case nameof(TheThing.MsgApplyConfig): break; default: break; } TheThing.TheSensorSubscriptionStatus CreateSubscriptionStatusFromFieldMapping(FieldMapping fld) { return(new TheThing.TheSensorSubscriptionStatus { Subscription = new TheThing.TheSensorSubscription { TargetProperty = fld.PropertyName, SensorId = TheCommonUtils.CStr(fld.cdeMID), SubscriptionId = fld.cdeMID, ExtensionData = new Dictionary <string, object> { { nameof(FieldMapping.SourceType), fld.SourceType }, { nameof(FieldMapping.SourceOffset), fld.SourceOffset }, { nameof(FieldMapping.SourceSize), fld.SourceSize }, { nameof(FieldMapping.AllowWrite), fld.AllowWrite } }, TargetThing = new TheThingReference(MyBaseThing), SampleRate = (int?)this.Interval }, Error = null, }); } }
public void ApplyLoadToTheStorageMirrorTest() { #region ARRANGE PerformanceCounter counterCPU; PerformanceCounter counterRAM; BlockingCollection <float> metricsCPU; BlockingCollection <float> metricsRAM; counterCPU = new PerformanceCounter("Processor", "% Processor Time", "_Total"); counterRAM = new PerformanceCounter("Memory", "Available MBytes"); metricsCPU = new BlockingCollection <float>(100000); metricsRAM = new BlockingCollection <float>(100000); Timer timerCPU; timerCPU = new Timer((state) => { if (metricsCPU.IsAddingCompleted) { float oldest = metricsCPU.FirstOrDefault(); metricsCPU.TryTake(out oldest); } metricsCPU.TryAdd(counterCPU.NextValue()); }, null, 1000, 10); Timer timerRAM; timerRAM = new Timer((state) => { if (metricsRAM.IsAddingCompleted) { float oldest = metricsRAM.FirstOrDefault(); metricsRAM.TryTake(out oldest); } metricsRAM.TryAdd(counterRAM.NextValue()); }, null, 1000, 10); counterCPU.NextValue(); var memoryBefore = counterRAM.NextValue(); Thread.Sleep(1000); // Per MSDN suggestion when using PerformanceCounter mechanism... int totalCandidates = 1000000; int countCallbacks = 0; var random = new Random(); var data = Enumerable.Range(1, totalCandidates).OrderBy(i => random.Next(1, totalCandidates)); CountdownEvent countdown = new CountdownEvent(totalCandidates); TheStorageMirror <TheStorageEngineTSM> mirror; mirror = new TheStorageMirror <TheStorageEngineTSM>(TheCDEngines.MyIStorageService) { IsRAMStore = true, CacheStoreInterval = 1, IsStoreIntervalInSeconds = true, IsCachePersistent = true, UseSafeSave = true, AllowFireUpdates = true, }; #endregion #region ACT Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); try { Parallel.ForEach(data, currentNumber => { mirror.AddAnItem( new TheStorageEngineTSM() { TXTPattern = currentNumber.ToString() }, state => { Interlocked.Increment(ref countCallbacks); countdown.Signal(); }); }); } catch (Exception ex) { Assert.IsTrue(true, ex.Message); } countdown.Wait(); stopwatch.Stop(); timerCPU.Change(Timeout.Infinite, Timeout.Infinite); timerCPU.Dispose(); timerRAM.Change(Timeout.Infinite, Timeout.Infinite); timerRAM.Dispose(); counterCPU?.Dispose(); counterRAM?.Dispose(); countdown?.Dispose(); mirror?.Dispose(); #endregion #region ASSERT float avgCPU = metricsCPU.Average(); float maxCPU = 99f; float avgRAM = metricsRAM.Average(); float maxRAM = memoryBefore + 1000f; Assert.IsTrue( (avgCPU <= maxCPU && avgRAM <= maxRAM && totalCandidates == countCallbacks), buildSummary(totalCandidates, stopwatch.ElapsedMilliseconds, avgCPU, maxCPU, avgRAM, maxRAM)); #endregion }
public bool LogVisitor(TheVisitorLogData pData) { MyVisitorLogStore?.AddAnItem(pData); return(MyVisitorLogStore != null); }