Beispiel #1
0
        private void DoChannelWork(IPushChannel channel, CancellationTokenSource cancelTokenSource)
        {
            string id = Guid.NewGuid().ToString();

            long sendCount = 0;

            while (!cancelTokenSource.IsCancellationRequested)
            {
                var waitForNotification = new ManualResetEvent(false);

                INotification notification;

                if (!queuedNotifications.TryDequeue(out notification))
                {
                    Thread.Sleep(100);
                    continue;
                }

                var msWaited = (DateTime.UtcNow - notification.EnqueuedTimestamp).TotalMilliseconds;

                lock (measurements)
                {
                    measurements.Add(new WaitTimeMeasurement((long) msWaited));
                }

                //Log.Info("Waited: {0} ms", msWaited);

                var sendStart = DateTime.UtcNow;

                sendCount++;

                Interlocked.Increment(ref totalSendCount);

                if (sendCount % 1000 == 0)
                    Log.Info("{0}> Send Count: {1} ({2})", id, sendCount, Interlocked.Read(ref totalSendCount));

                channel.SendNotification(notification, (sender, result) =>
                    {
                        Interlocked.Decrement(ref trackedNotificationCount);

                        var sendTime = DateTime.UtcNow - sendStart;

                        lock (sendTimeMeasurements)
                        {
                            sendTimeMeasurements.Add(new WaitTimeMeasurement((long)sendTime.TotalMilliseconds));
                        }

                        //Log.Info("Send Time: " + sendTime.TotalMilliseconds + " ms");

                        //Trigger
                        if (this.BlockOnMessageResult)
                            waitForNotification.Set();

                        //Handle the notification send callback here
                        if (result.ShouldRequeue)
                        {
                            var eventArgs = new NotificationRequeueEventArgs(result.Notification);
                            var evt = this.OnNotificationRequeue;
                            if (evt != null)
                                evt(this, eventArgs);

                            //See if the requeue was cancelled in the event args
                            if (!eventArgs.Cancel)
                                this.QueueNotification(result.Notification, result.CountsAsRequeue, true);
                        }
                        else
                        {
                            //Result was a success, but there are still more possible outcomes than an outright success
                            if (!result.IsSuccess)
                            {
                                //Check if the subscription was expired
                                if (result.IsSubscriptionExpired)
                                {
                                    //If there is a new id, the subscription must have changed
                                    //This is a fairly special case that only GCM should really ever raise
                                    if (!string.IsNullOrEmpty(result.NewSubscriptionId))
                                    {
                                        var evt = this.OnDeviceSubscriptionChanged;
                                        if (evt != null)
                                            evt(this, result.OldSubscriptionId, result.NewSubscriptionId, result.Notification);
                                    }
                                    else
                                    {
                                        var evt = this.OnDeviceSubscriptionExpired;
                                        if (evt != null)
                                            evt(this, result.OldSubscriptionId, result.SubscriptionExpiryUtc, result.Notification);
                                    }
                                }
                                else //Otherwise some general failure
                                {
                                    var evt = this.OnNotificationFailed;
                                    if (evt != null)
                                        evt(this, result.Notification, result.Error);
                                }
                            }
                            else
                            {
                                var evt = this.OnNotificationSent;
                                if (evt != null)
                                    evt(this, result.Notification);
                            }
                        }
                    });

                if (this.BlockOnMessageResult && !waitForNotification.WaitOne(ServiceSettings.NotificationSendTimeout))
                {
                    Interlocked.Decrement(ref trackedNotificationCount);

                    Log.Info("Notification send timeout");

                    var evt = this.OnNotificationFailed;
                    if (evt != null)
                        evt(this, notification, new TimeoutException("Notification send timed out"));
                }
            }

            channel.Dispose();
        }
        private void DoChannelWork(IPushChannel channel, CancellationTokenSource cancelTokenSource)
        {
            while (!cancelTokenSource.IsCancellationRequested)
            {
                var waitForNotification = new ManualResetEvent(false);

                INotification notification;

                if (!queuedNotifications.TryDequeue(out notification))
                {
                    Thread.Sleep(100);
                    continue;
                }

                var msWaited = (DateTime.UtcNow - notification.EnqueuedTimestamp).TotalMilliseconds;
                measurements.Add(new WaitTimeMeasurement((long) msWaited));

                channel.SendNotification(notification, (sender, result) =>
                    {
                        //Trigger
                        if (this.BlockOnMessageResult)
                            waitForNotification.Set();

                        Interlocked.Decrement(ref trackedNotificationCount);

                        //Handle the notification send callback here
                        if (result.ShouldRequeue)
                            this.QueueNotification(result.Notification, result.CountsAsRequeue, true);
                        else
                        {
                            //This is a fairly special case that only GCM should really ever raise
                            if (!string.IsNullOrEmpty(result.NewSubscriptionId) && !string.IsNullOrEmpty(result.OldSubscriptionId))
                            {
                                var evt = this.OnDeviceSubscriptionChanged;
                                if (evt != null)
                                    evt(this, result.OldSubscriptionId, result.NewSubscriptionId, result.Notification);
                            }

                            if (!result.IsSuccess)
                            {
                                var evt = this.OnNotificationFailed;
                                if (evt != null)
                                    evt(this, result.Notification, result.Error);
                            }
                            else
                            {
                                var evt = this.OnNotificationSent;
                                if (evt != null)
                                    evt(this, result.Notification);
                            }
                        }
                    });

                if (this.BlockOnMessageResult && !waitForNotification.WaitOne(ServiceSettings.NotificationSendTimeout))
                {
                    Interlocked.Decrement(ref trackedNotificationCount);

                    var evt = this.OnNotificationFailed;
                    if (evt != null)
                        evt(this, notification, new TimeoutException("Notification send timed out"));
                }
            }

            channel.Dispose();
        }
Beispiel #3
0
        private void DoChannelWork(IPushChannel channel, CancellationTokenSource cancelTokenSource)
        {
            string id = Guid.NewGuid().ToString();

            long sendCount = 0;

            while (!cancelTokenSource.IsCancellationRequested)
            {
                var waitForNotification = new ManualResetEvent(false);

                var notification = queuedNotifications.Dequeue();

                if (notification == null)
                {
                    Thread.Sleep(100);
                    continue;
                }

                var msWaited = (DateTime.UtcNow - notification.EnqueuedTimestamp).TotalMilliseconds;

                lock (measurementsLock)
                {
                    measurements.Add(new WaitTimeMeasurement((long)msWaited));
                }

                //Log.Info("Waited: {0} ms", msWaited);

                var sendStart = DateTime.UtcNow;

                sendCount++;

                Interlocked.Increment(ref totalSendCount);

                if (sendCount % 1000 == 0)
                {
                    Log.Info("{0}> Send Count: {1} ({2})", id, sendCount, Interlocked.Read(ref totalSendCount));
                }

                channel.SendNotification(notification, (sender, result) =>
                {
                    Interlocked.Decrement(ref trackedNotificationCount);

                    var sendTime = DateTime.UtcNow - sendStart;

                    lock (sendTimeMeasurementsLock)
                    {
                        sendTimeMeasurements.Add(new WaitTimeMeasurement((long)sendTime.TotalMilliseconds));
                    }

                    //Log.Info("Send Time: " + sendTime.TotalMilliseconds + " ms");

                    //Trigger
                    if (this.BlockOnMessageResult)
                    {
                        waitForNotification.Set();
                    }

                    //Handle the notification send callback here
                    if (result.ShouldRequeue)
                    {
                        var eventArgs = new NotificationRequeueEventArgs(result.Notification, result.Error);
                        var evt       = this.OnNotificationRequeue;
                        if (evt != null)
                        {
                            evt(this, eventArgs);
                        }

                        //See if the requeue was cancelled in the event args
                        if (!eventArgs.Cancel)
                        {
                            this.QueueNotification(result.Notification, result.CountsAsRequeue, true, true);
                        }
                    }
                    else
                    {
                        //Result was a success, but there are still more possible outcomes than an outright success
                        if (!result.IsSuccess)
                        {
                            //Check if the subscription was expired
                            if (result.IsSubscriptionExpired)
                            {
                                //If there is a new id, the subscription must have changed
                                //This is a fairly special case that only GCM should really ever raise
                                if (!string.IsNullOrEmpty(result.NewSubscriptionId))
                                {
                                    var evt = this.OnDeviceSubscriptionChanged;
                                    if (evt != null)
                                    {
                                        evt(this, result.OldSubscriptionId, result.NewSubscriptionId, result.Notification);
                                    }
                                }
                                else
                                {
                                    var evt = this.OnDeviceSubscriptionExpired;
                                    if (evt != null)
                                    {
                                        evt(this, result.OldSubscriptionId, result.SubscriptionExpiryUtc, result.Notification);
                                    }
                                }
                            }
                            else                                     //Otherwise some general failure
                            {
                                var evt = this.OnNotificationFailed;
                                if (evt != null)
                                {
                                    evt(this, result.Notification, result.Error);
                                }
                            }
                        }
                        else
                        {
                            var evt = this.OnNotificationSent;
                            if (evt != null)
                            {
                                evt(this, result.Notification);
                            }
                        }
                    }
                });


                if (this.BlockOnMessageResult && !waitForNotification.WaitOne(ServiceSettings.NotificationSendTimeout))
                {
                    Interlocked.Decrement(ref trackedNotificationCount);

                    Log.Info("Notification send timeout");

                    var evt = this.OnNotificationFailed;
                    if (evt != null)
                    {
                        evt(this, notification, new TimeoutException("Notification send timed out"));
                    }
                }
            }

            channel.Dispose();
        }
        private void DoChannelWork(IPushChannel channel, CancellationTokenSource cancelTokenSource)
        {
            string str = Guid.NewGuid().ToString();
            long   num = 0;

            while (!cancelTokenSource.IsCancellationRequested)
            {
                INotification notification = this.queuedNotifications.Dequeue();
                if (notification == null)
                {
                    Thread.Sleep(100);
                }
                else
                {
                    ManualResetEvent waitForNotification = (ManualResetEvent)null;
                    if (this.BlockOnMessageResult)
                    {
                        waitForNotification = new ManualResetEvent(false);
                    }
                    double totalMilliseconds = (DateTime.UtcNow - notification.EnqueuedTimestamp).TotalMilliseconds;
                    lock (this.measurementsLock)
                        this.measurements.Add(new PushServiceBase.WaitTimeMeasurement((long)totalMilliseconds));
                    DateTime sendStart = DateTime.UtcNow;
                    ++num;
                    Interlocked.Increment(ref this.totalSendCount);
                    if (num % 1000L == 0L)
                    {
                        Log.Debug("{0}> Send Count: {1} ({2})", (object)str, (object)num, (object)Interlocked.Read(ref this.totalSendCount));
                    }
                    channel.SendNotification(notification, (SendNotificationCallbackDelegate)((sender, result) =>
                    {
                        Interlocked.Decrement(ref this.trackedNotificationCount);
                        TimeSpan timeSpan = DateTime.UtcNow - sendStart;
                        lock (this.sendTimeMeasurementsLock)
                            this.sendTimeMeasurements.Add(new PushServiceBase.WaitTimeMeasurement((long)timeSpan.TotalMilliseconds));
                        waitForNotification?.Set();
                        if (result.ShouldRequeue)
                        {
                            NotificationRequeueEventArgs e = new NotificationRequeueEventArgs(result.Notification, result.Error);
                            NotificationRequeueDelegate notificationRequeue = this.OnNotificationRequeue;
                            if (notificationRequeue != null)
                            {
                                notificationRequeue((object)this, e);
                            }
                            if (e.Cancel)
                            {
                                return;
                            }
                            this.QueueNotification(result.Notification, result.CountsAsRequeue, true, true);
                        }
                        else if (!result.IsSuccess)
                        {
                            if (result.IsSubscriptionExpired)
                            {
                                if (!string.IsNullOrEmpty(result.NewSubscriptionId))
                                {
                                    DeviceSubscriptionChangedDelegate subscriptionChanged = this.OnDeviceSubscriptionChanged;
                                    if (subscriptionChanged == null)
                                    {
                                        return;
                                    }
                                    subscriptionChanged((object)this, result.OldSubscriptionId, result.NewSubscriptionId, result.Notification);
                                }
                                else
                                {
                                    DeviceSubscriptionExpiredDelegate subscriptionExpired = this.OnDeviceSubscriptionExpired;
                                    if (subscriptionExpired == null)
                                    {
                                        return;
                                    }
                                    subscriptionExpired((object)this, result.OldSubscriptionId, result.SubscriptionExpiryUtc, result.Notification);
                                }
                            }
                            else
                            {
                                NotificationFailedDelegate notificationFailed = this.OnNotificationFailed;
                                if (notificationFailed == null)
                                {
                                    return;
                                }
                                notificationFailed((object)this, result.Notification, result.Error);
                            }
                        }
                        else
                        {
                            NotificationSentDelegate notificationSent = this.OnNotificationSent;
                            if (notificationSent == null)
                            {
                                return;
                            }
                            notificationSent((object)this, result.Notification);
                        }
                    }));
                    if (waitForNotification != null && !waitForNotification.WaitOne(this.ServiceSettings.NotificationSendTimeout))
                    {
                        Interlocked.Decrement(ref this.trackedNotificationCount);
                        Log.Info("Notification send timeout");
                        NotificationFailedDelegate notificationFailed = this.OnNotificationFailed;
                        if (notificationFailed != null)
                        {
                            notificationFailed((object)this, notification, (Exception) new TimeoutException("Notification send timed out"));
                        }
                    }
                    if (waitForNotification != null)
                    {
                        waitForNotification.Close();
                        waitForNotification = (ManualResetEvent)null;
                    }
                }
            }
            channel.Dispose();
        }