/// <summary> /// The method that registers Service Bus listeners and assigns them to a receive event. When an event from the service bus listener is raised, trigger the callbackURL /// </summary> /// <param name="logicAppId"></param> /// <param name="triggerInput"></param> /// <returns></returns> public async Task RegisterTrigger(string workflowId, SubscriptionInfo subscriptionInfo, bool addToTable = true) { // Add to the table store if (addToTable) { // according to https://msdn.microsoft.com/en-us/library/azure/dd179338.aspx, PartitionKeys do not allow the "/" character, so when inserting we replaced with "||" TriggerRecord newTrigger = new TriggerRecord(workflowId.Replace("/", "||")); string jsonString = JsonConvert.SerializeObject(subscriptionInfo); newTrigger.subscriptionInfo = jsonString; TableOperation insertOperation = TableOperation.Insert(newTrigger); try { triggerTable.Execute(insertOperation); } catch (StorageException ex) { throw new Exception("Error occurred while trying to add trigger to Azure Table. Error: " + ex.RequestInformation.ExtendedErrorInformation.ErrorMessage, ex); } } // Create a new listener for this trigger ServiceBusListener listener = new ServiceBusListener(subscriptionInfo); HostingEnvironment.QueueBackgroundWorkItem(async ct => await listener.StartListening(subscriptionInfo.triggerConfig)); subscriptionInfo.listener = listener; // Register the logicAppId in the store, so on subsequent checks from the logic app we don't spin up a new set of listeners _store[workflowId] = subscriptionInfo; }
public void ScheduleNext(TriggerRecord triggerRecord) { DateTime triggerTime = triggerRecord.TIME; double tickTime = (triggerTime - DateTime.Now).TotalMilliseconds; if (tickTime < 0) { sourceLogger.Info($"Firing Trigger: {triggerRecord}"); DistributeMessage(triggerRecord); try { if (triggerQueue.Count == 0) { return; } ScheduleNext(triggerQueue.Dequeue()); } catch (Exception ex) { sourceLogger.Error(ex, "Error dequeuing next event (2) " + ex.Message); } return; } timers.Clear(); Timer timer = new Timer(tickTime) { AutoReset = false }; timer.Elapsed += (sender, e) => { Timer_Elapsed(triggerRecord); }; timer.Start(); timers.Add(timer); NextTrigger = triggerRecord.TIME; sourceLogger.Trace($"Started Event Timer for: {triggerRecord}"); }
internal Tuple <int, int, TriggerRecord> InitTriggers(int duration) { if (triggerRecords.Count == 0) { return(new Tuple <int, int, TriggerRecord>(0, 0, null)); } DateTime endOfTest = DateTime.Now.AddSeconds(duration); int lateTriggers = 0; int earlyTriggers = 0; List <TriggerRecord> sortedTriggers = new List <TriggerRecord>(); DateTime now = DateTime.Now; foreach (TriggerRecord rec in triggerRecords) { // First, modify the time relative to start if it is a relative trigger. if (rec.isRelative) { bool hasOffset = double.TryParse(rec.baseTime, out double offset); if (hasOffset) { rec.TIME = now.AddMilliseconds(offset * 1000); } } if (rec.TIME > endOfTest) { lateTriggers++; continue; } if (rec.TIME < now) { earlyTriggers++; continue; } sortedTriggers.Add(rec); } sortedTriggers.Sort((x, y) => { return(x.TIME.CompareTo(y.TIME)); }); // this.executionController.clientHub.SetSchedTrigger(executionController.executionNodeUuid, sortedTriggers); triggerQueue = new Queue <TriggerRecord>(sortedTriggers); if (triggerQueue.Count > 0) { TriggerRecord first = triggerQueue.Peek(); return(new Tuple <int, int, TriggerRecord>(earlyTriggers, lateTriggers, first)); } else { return(null); } }
public void AddSchedTrigger(string executionNodeUuid, TriggerRecord triggerRecord) { try { Application.Current.Dispatcher.Invoke(delegate { CentralMessagingHub.executionUI.SchedTriggers.Add(triggerRecord); }); } catch (Exception ex) { Debug.WriteLine("Add Sched Triggers " + ex.Message); } }
public void Timer_Elapsed(TriggerRecord rec) { DistributeMessage(rec); try { if (triggerQueue.Count == 0) { return; } ScheduleNext(triggerQueue.Dequeue()); } catch (Exception ex) { sourceLogger.Error(ex, "Error dequeuing next event (1)"); } }
internal bool ScheduleEvent(TriggerRecord triggerRecord) { double tickTime = (triggerRecord.TIME - DateTime.Now).TotalMilliseconds; if (tickTime < 0) { return(false); } triggerRecords.Add(triggerRecord); // this.executionController.clientHub.AddSchedTrigger(executionController.executionNodeUuid, triggerRecord); return(true); }
public void ScheduleFirst() { try { if (triggerQueue.Count > 0) { TriggerRecord first = triggerQueue.Dequeue(); if (first != null) { ScheduleNext(first); } } } catch (Exception) { // NO-OP } }
public void DistributeMessage(TriggerRecord rec) { //Used by event driven sources if (rec.refreshFlight && rec.record.Item2 != null) { try { FlightNode update = rec.record.Item2.RefeshFlight(executionController.amshost, executionController.token, executionController.apt_code).Result; if (update != null) { rec.record.Item2.UpdateFlight(update); } } catch (Exception e) { sourceLogger.Warn(e, "Failed to update flight. Using original data"); } } if (rec.record.Item2 != null) { if (rec.expression != null) { bool pass = rec.expression.Pass(rec.record.Item2.FightXML); if (!pass) { sourceLogger.Trace("Post Filtering: Flight did not pass filter"); return; } } if (rec.topLevelFilter != null) { bool pass = rec.topLevelFilter.Pass(rec.record.Item2.FightXML); if (!pass) { sourceLogger.Trace("Post Filtering: Flight did not pass filter"); return; } } } map[rec.ID]?.Fire(new TriggerFiredEventArgs(rec.ID, rec.record)); // Fire any chained elements foreach (IChainedSourceController chain in rec.chain) { chain.ParentFired(rec.record); } // this.executionController.clientHub.DispatcherDistributeMessage(executionController.executionNodeUuid, rec); }
public void DispatcherDistributeMessage(string executionNodeID, TriggerRecord rec) { Task.Run(() => { TriggerRecord remove = null; foreach (TriggerRecord r in CentralMessagingHub.executionUI.SchedTriggers) { if (r.uuid == rec.uuid) { remove = r; break; } } if (remove != null) { try { Application.Current.Dispatcher.Invoke(delegate { CentralMessagingHub.executionUI.SchedTriggers.Remove(remove); CentralMessagingHub.executionUI.OnPropertyChanged("lvTriggers"); CentralMessagingHub.executionUI.FiredTriggers.Add(rec); CentralMessagingHub.executionUI.OnPropertyChanged("lvFiredTriggers"); }); } catch (Exception ex) { Debug.WriteLine("Dispatcher Distribute Error " + ex.Message); } } else { try { Application.Current.Dispatcher.Invoke(delegate { CentralMessagingHub.executionUI.FiredTriggers.Add(rec); CentralMessagingHub.executionUI.OnPropertyChanged("lvFiredTriggers"); }); } catch (Exception ex) { Debug.WriteLine("Dispatcher Distribute Error " + ex.Message); } } }); }
public async Task UnregisterTrigger(string workflowId) { if (_store.ContainsKey(workflowId)) { // Remove from the table // according to https://msdn.microsoft.com/en-us/library/azure/dd179338.aspx, PartitionKeys do not allow the "/" character, so when inserting we replaced with "||" TriggerRecord oldTrigger = new TriggerRecord(workflowId.Replace("/", "||")); oldTrigger.ETag = "*"; TableOperation deleteOperation = TableOperation.Delete(oldTrigger); try { triggerTable.Execute(deleteOperation); } catch (StorageException ex) { throw new Exception("Error occurred while trying to remove trigger from Azure Table. Error: " + ex.RequestInformation.ExtendedErrorInformation.ErrorMessage, ex); } // stop listening await _store[workflowId].listener.StopListening(); } }
private void buttonEdit_Click(object sender, RoutedEventArgs e) { try { //update category trigger settings bool settingsUpdated = false; string centralPath = reportingInfo.CentralPath; if (AppCommand.Instance.ConfigDictionary.ContainsKey(centralPath)) { Configuration config = AppCommand.Instance.ConfigDictionary[centralPath]; var updaterFound = from updater in config.updaters where updater.updaterId.ToLower() == reportingInfo.UpdaterId.ToLower() select updater; if (updaterFound.Count() > 0) { ProjectUpdater pUpdater = updaterFound.First(); int updaterIndex = config.updaters.IndexOf(pUpdater); var triggerFound = from trigger in pUpdater.CategoryTriggers where trigger.categoryName == reportingInfo.CategoryName select trigger; if (triggerFound.Count() > 0) { CategoryTrigger cTrigger = triggerFound.First(); int triggerIndex = pUpdater.CategoryTriggers.IndexOf(cTrigger); config.updaters[updaterIndex].CategoryTriggers[triggerIndex].isEnabled = false; AppCommand.Instance.ConfigDictionary.Remove(centralPath); AppCommand.Instance.ConfigDictionary.Add(centralPath, config); //refresh category trigger AppCommand.Instance.DTMUpdaterInstance.Unregister(currentDoc); AppCommand.Instance.DTMUpdaterInstance.Register(currentDoc, config.updaters[updaterIndex]); settingsUpdated = true; } } } if (settingsUpdated) { //database updated TriggerRecord record = new TriggerRecord() { configId = reportingInfo.ConfigId, centralPath = reportingInfo.CentralPath, updaterId = reportingInfo.UpdaterId, categoryName = reportingInfo.CategoryName, elementUniqueId = reportingInfo.ReportingUniqueId, edited = DateTime.Now, editedBy = Environment.UserName }; string content; string errMessage; HttpStatusCode status = ServerUtil.PostTriggerRecords(out content, out errMessage, record); this.DialogResult = false; } this.Close(); } catch (Exception ex) { LogUtil.AppendLog("DTMWindow-buttonEdit_Click:" + ex.Message); } }
public static HttpStatusCode PostTriggerRecords(out string content, out string errorMessage, TriggerRecord record) { HttpStatusCode status = HttpStatusCode.Unused; content = ""; errorMessage = ""; try { var client = new RestClient(RestApiBaseUrl); var request = new RestRequest(apiVersion + "/triggerrecords", Method.POST); request.RequestFormat = RestSharp.DataFormat.Json; request.AddBody(record); IRestResponse response = client.Execute <TriggerRecord>(request); content = response.Content; errorMessage = response.ErrorMessage; status = response.StatusCode; } catch (Exception ex) { string message = ex.Message; LogUtil.AppendLog("ServerUtil-PostTriggerRecords:" + ex.Message); } return(status); }