protected override void BrokerInstOnOnNotificationFailed(GcmNotification notification, AggregateException exception) { base.BrokerInstOnOnNotificationFailed(notification, exception); exception.Handle(ex => { if (ex is GcmNotificationException) { int count; if (WorkingQueue.TryGetValue(notification, out count) && count < TriesCount) { RetryQueue(notification); } else { Logger.NotificationFailed(notification, exception); } } else if (ex is GcmMulticastResultException) { RemoveNotification(notification); Logger.NotificationFailed(notification, exception); } else if (ex is DeviceSubscriptionExpiredException) { //TODO: Add notification expired logic var exc = ex as DeviceSubscriptionExpiredException; if (exc.NewSubscriptionId != null) { notification.RegistrationIds.Remove(exc.OldSubscriptionId); notification.RegistrationIds.Add(exc.NewSubscriptionId); RetryQueue(notification); } else { Logger.NotificationFailed(notification, exception); } TokenExperation.AddExpiredToken(exc.OldSubscriptionId, exc.NewSubscriptionId); } else if (ex is RetryAfterException) { RemoveNotification(notification); Logger.NotificationFailed(notification, exception); } else { int count; if (WorkingQueue.TryGetValue(notification, out count) && count < TriesCount) { RetryQueue(notification); } else { Logger.NotificationFailed(notification, exception); } } return(true); }); }
public override void Execute() { var execution = new Queue <ICommand>(); lock (SyncWorking) { SwapQueues(); while (WorkingQueue.Count > 0) { var command = WorkingQueue.Dequeue(); var wrapper = command as CommandWrapper; if (!wrapper?.IsExecutable ?? false) { Enqueue(command); } else { execution.Enqueue(command); } } } while (execution.Count > 0) { var executive = execution.Dequeue(); try { #if TRACE_COMMANDS var type = executive is ICommandTypeExtractor ? (executive as ICommandTypeExtractor).CommandType : executive.GetType(); Logger?.Log(_selfType, Level.Debug, $"executing command: {type.NameNice()}", null); executive.Execute(); #else executive.Execute(); #endif } catch (Exception exception) { Logger?.Log( executive is ICommandTypeExtractor ? (executive as ICommandTypeExtractor).CommandType : executive.GetType(), Level.Error, $"exception during execution from: {_selfType.NameNice()}\n{exception.ToText()}", exception); } } }
protected override void BrokerInstOnOnNotificationFailed(ApnsNotification notification, AggregateException exception) { base.BrokerInstOnOnNotificationFailed(notification, exception); exception.Handle(ex => { if (ex is ApnsNotificationException) { int count; if (WorkingQueue.TryGetValue(notification, out count) && count < TriesCount) { RetryQueue(notification); } else { TokenExperation.AddExpiredToken(notification.DeviceToken, null); Logger.NotificationFailed(notification, ex); } } return(true); }); }
public bool TryConsume(out ICommand result) { //! slow var execution = new Queue <ICommand>(); result = null; lock (SyncWorking) { SwapQueues(); while (WorkingQueue.Count > 0) { var command = WorkingQueue.Dequeue(); var wrapper = command as CommandWrapper; if (!wrapper?.IsExecutable ?? false) { Enqueue(command); } else { if (ReferenceEquals(null, result)) { result = wrapper?.Source; } else { execution.Enqueue(command); } } } while (execution.Count > 0) { Enqueue(execution.Dequeue()); } } return(!ReferenceEquals(null, result)); }
/// <summary> /// The Hopcroft - Karp algorithm finds equivalent states /// /// </summary> ///Algorithm: ///P := {{all accepting states}, {all nonaccepting states}}; ///Q := {{all accepting states}}; ///E := { all edges } ///while (Q is not empty) do /// choose and remove a set A from Q /// for each c in E do /// let X be the set of states for which a transition on c leads to a state in A /// for each set Y in P for which X ∩ Y is nonempty do /// replace Y in P by the two sets X ∩ Y and Y \ X /// if Y is in Q /// replace Y in Q by the same two sets /// else /// add the smaller of the two sets to Q /// end; /// end; ///end; public static LinkedList <HashSet <int> > Original(List <DfaNode> states, int edges) { var P = new LinkedList <HashSet <int> >(); var acceptingSet = new HashSet <int>(); var nonAcceptingSet = new HashSet <int>(); foreach (var state in states) { if (state.IsAccepting) { acceptingSet.Add(state.Index); } else { nonAcceptingSet.Add(state.Index); } } P.AddLast(acceptingSet); P.AddLast(nonAcceptingSet); var Q = new WorkingQueue(acceptingSet.ToSet(), nonAcceptingSet.ToSet()); var X = new HashSet <int>(); while (!Q.IsEmpty) { var A = Q.Remove(); for (var c = 1; c < edges; c++) { //X is the set of states for which a transition on c leads to a state in A X.CopyFrom(states.Where(x => A.Contains(x[c])).Select(x => x.Index)); if (X.Count == 0) { continue; } for (var Y = P.First; Y != null; Y = Y.Next) { var intersection = X.Intersect(Y.Value); if (intersection.Count == 0) { continue; } var disjointUnion = Y.Value.DisjointUnion(intersection); if (disjointUnion.Count == 0) { continue; } var oldY = Y.Value; if (disjointUnion.Count > 0) { Y.Value = intersection; P.AddBefore(Y, disjointUnion); } if (!Q.TryReplace(oldY, intersection, disjointUnion)) { Q.Add((intersection.Count < disjointUnion.Count) ? intersection : disjointUnion); } } } } for (var node = P.First; node != null; node = node.Next) { if (node.Value.Count <= 1) { P.Remove(node); } } return(P); }