IEnumerator PeriodicAction(TimeSpan period, Action action, ICancelable cancellation)
            {
                // zero == every frame
                if (period == TimeSpan.Zero)
                {
                    while (true)
                    {
                        yield return null; // not immediately, run next frame
                        if (cancellation.IsDisposed) yield break;

                        MainThreadDispatcher.UnsafeSend(action);
                    }
                }
                else
                {
                    var seconds = (float)(period.TotalMilliseconds / 1000.0);
                    var yieldInstruction = new WaitForSeconds(seconds); // cache single instruction object

                    while (true)
                    {
                        yield return yieldInstruction;
                        if (cancellation.IsDisposed) yield break;

                        MainThreadDispatcher.UnsafeSend(action);
                    }
                }
            }

 protected override void InternalScheduleTellOnce(TimeSpan delay, ICanTell receiver, object message, IActorRef sender, ICancelable cancelable)
 {
     var cancellationToken = cancelable == null ? CancellationToken.None : cancelable.Token;
     InternalScheduleOnce(delay, () =>
     {
         receiver.Tell(message, sender);
     }, cancellationToken);
 }

            // delay action is run in StartCoroutine
            // Okay to action run synchronous and guaranteed run on MainThread
            IEnumerator DelayAction(TimeSpan dueTime, Action action, ICancelable cancellation)
            {
#if UNITY_EDITOR
                if (!ScenePlaybackDetector.IsPlaying)
                {
                    var startTime = DateTimeOffset.UtcNow;
                    while (true)
                    {
                        yield return null;
                        if (cancellation.IsDisposed) break;

                        var elapsed = DateTimeOffset.UtcNow - startTime;
                        if (elapsed >= dueTime)
                        {
                            MainThreadDispatcher.UnsafeSend(action);
                            break;
                        }
                    };
                    yield break;
                }
#endif
                
                if (dueTime == TimeSpan.Zero)
                {
                    yield return null; // not immediately, run next frame
                    if (cancellation.IsDisposed) yield break;

                    MainThreadDispatcher.UnsafeSend(action);
                }
                else if (dueTime.TotalMilliseconds % 1000 == 0)
                {
                    yield return new WaitForSeconds((float)dueTime.TotalSeconds);
                    if (cancellation.IsDisposed) yield break;

                    MainThreadDispatcher.UnsafeSend(action);
                }
                else
                {
                    var startTime = Time.time;
                    var dt = (float)dueTime.TotalSeconds;
                    while (true)
                    {
                        yield return null;
                        if (cancellation.IsDisposed) break;

                        var elapsed = Time.time - startTime;
                        if (elapsed >= dt)
                        {
                            MainThreadDispatcher.UnsafeSend(action);
                            break;
                        }
                    }
                }
            }

        public ClusterMetricsCollector(IActorRef publisher)
        {
            _publisher = publisher;
            _cluster = Cluster.Get(Context.System);
            Collector = MetricsCollector.Get(Context.System.AsInstanceOf<ExtendedActorSystem>(), _cluster.Settings);
            LatestGossip = MetricsGossip.Empty;
            Nodes = ImmutableHashSet.Create<Address>();

            _metricsCancelable = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(
                _cluster.Settings.PeriodicTasksInitialDelay.Max(_cluster.Settings.MetricsInterval),
                _cluster.Settings.MetricsInterval, Self, InternalClusterAction.MetricsTick.Instance, Self);

            _gossipCancelable = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(
                _cluster.Settings.PeriodicTasksInitialDelay.Max(_cluster.Settings.GossipInterval), 
                _cluster.Settings.GossipInterval, Self, InternalClusterAction.GossipTick.Instance, Self);

            Receive<InternalClusterAction.GossipTick>(tick => Gossip());
            Receive<InternalClusterAction.MetricsTick>(tick => Collect());
            Receive<MetricsGossipEnvelope>(envelope => ReceiveGossip(envelope));
            Receive<ClusterEvent.CurrentClusterState>(state => ReceiveState(state));
            Receive<ClusterEvent.MemberUp>(up => AddMember(up.Member));
            Receive<ClusterEvent.MemberRemoved>(removed => RemoveMember(removed.Member));
            Receive<ClusterEvent.MemberExited>(exited => RemoveMember(exited.Member));
            Receive<ClusterEvent.UnreachableMember>(member => RemoveMember(member.Member));
            Receive<ClusterEvent.ReachableMember>(member =>
            {
                if (member.Member.Status == MemberStatus.Up) AddMember(member.Member);
            });
            Receive<ClusterEvent.IMemberEvent>(@event => { }); //not interested in other types of member event
        }

        public SignalRClusterStatusActor()
        {
            ClusterStatusTeller = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(TimeSpan.FromSeconds(5),
                    TimeSpan.FromSeconds(1), Self, new ClusterStatus.SendCurrentClusterState(), Self);

            Ready();
        }

        protected override void PreStart()
        {
            _cluster = Cluster.Get(Context.System);
            _cancelStatusUpdates = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(2), Self, new SendState(), Self);

            base.PreStart();
        }

 public PerformanceCounterActor(string seriesName, Func<PerformanceCounter> performanceCounterGenerator)
 {
     _seriesName = seriesName;
     _performanceCounterGenerator = performanceCounterGenerator;
     _subscriptions = new HashSet<IActorRef>();
     _cancelPublishing = new Cancelable(Context.System.Scheduler);
 }

        /// <summary>
        ///		Create a new <see cref="PerformanceCounterMonitor"/> actor.
        /// </summary>
        /// <param name="seriesName">
        ///		The name of the data series that tracks the performance counter's value.
        /// </param>
        /// <param name="performanceCounterFactory">
        ///		A factory delegate that creates the <see cref="PerformanceCounter"/> to monitor.
        /// </param>
        public PerformanceCounterMonitor(string seriesName, Func<PerformanceCounter> performanceCounterFactory)
        {
            if (String.IsNullOrWhiteSpace(seriesName))
                throw new ArgumentException("Argument cannot be null, empty, or entirely componsed of whitespace: 'seriesName'.", nameof(seriesName));

            if (performanceCounterFactory == null)
                throw new ArgumentNullException(nameof(performanceCounterFactory));

            _seriesName = seriesName;
            _performanceCounterFactory = performanceCounterFactory;
            _cancelPublishing = new Cancelable(Context.System.Scheduler);

            Receive<GatherMetrics>(_ =>
            {
                Metric metric = new Metric(
                    _seriesName,
                    _performanceCounter.NextValue()
                );
                foreach (IActorRef subscriber in _subscribers)
                    subscriber.Tell(metric);
            });
            Receive<SubscribePerformanceCounter>(request =>
            {
                _subscribers.Add(request.Subscriber);
            });
            Receive<UnsubscribePerformanceCounter>(request =>
            {
                _subscribers.Remove(request.Subscriber);
            });
        }

 protected TopicLike(TimeSpan emptyTimeToLive)
 {
     Subscribers = new HashSet<IActorRef>();
     EmptyTimeToLive = emptyTimeToLive;
     PruneInterval = new TimeSpan(emptyTimeToLive.Ticks / 2);
     PruneCancelable = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(PruneInterval, PruneInterval, Self, Prune.Instance, Self);
 }

        public PerformanceCounterActor(string seriesName, Func<PerformanceCounter> performanceCounterGenerator)
        {
            _seriesName = seriesName;
            _performanceCounterGenerator = performanceCounterGenerator;
            _subscriptions = new HashSet<IActorRef>();
            _cancelPublishing = new Cancelable(Context.System.Scheduler);

            Receive<GatherMetrics>(m =>
            {
                //publish latest counter value to all subscribers
                var metric = new Metric(_seriesName, _counter.NextValue());
                foreach (var sub in _subscriptions)
                    sub.Tell(metric);
            });
            Receive<SubscribeCounter>(sc =>
            {
                // add a subscription for this counter
                // (it's parent's job to filter by counter types)
                _subscriptions.Add(sc.Subscriber);
            });
            Receive<UnsubscribeCounter>(uc =>
            {
                // remove a subscription from this counter
                _subscriptions.Remove(uc.Subscriber);
            });
        }

 private void Timeout()
 {
     _timedOut = true;
     _cancelHeartbeat?.Cancel(false);
     _cancelHeartbeat = null;
     Context.Parent.Tell(new ConnectionMessages.ConnectionLost());
 }

        public SignalRItemStatusActor()
        {
            ItemSubscriberTeller = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(TimeSpan.FromSeconds(5),
                    TimeSpan.FromSeconds(2), Self, new SubscribeToWorkers(), Self);

            Ready();
        }

 private void receiveEngineRunCommand(MessageEngineRunCommand msg)
 {
     MessageTick pulse = new MessageTick(0);
     if (msg.RunCommand == EngineRunCommand.RunMax && _runState != TickEngineRunState.RunningMax)
     {
         cancelPulse();
         _numberOfIncompleteSS = _subscribedActorSolarSystems.Count();
         _runState = TickEngineRunState.RunningMax;
         startTicksTimer();
         receiveTick(pulse);
     }
     else if (msg.RunCommand == EngineRunCommand.RunPulse && _runState != TickEngineRunState.Running)
     {
         _runState = TickEngineRunState.Running;
         _runCancel = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(0, 5, Self, pulse, ActorRefs.Nobody);
         startTicksTimer();
         receiveTick(pulse);
     }
     else if (msg.RunCommand == EngineRunCommand.Stop && _runState != TickEngineRunState.Stopped)
     {
         _runState = TickEngineRunState.Stopped;
         cancelPulse();
         _secondTimer.Stop();
     }
 }

        public ClusterServiceStatusActor()
        {
            _cancel = new CancellationTokenSource();
            ClusterServiceStatusTeller = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(TimeSpan.FromSeconds(5),
                    TimeSpan.FromSeconds(1), Self, new GetServiceStatus(), Self);

            Ready();
        }

 private void CancelReceiveTimeout()
 {
     if (_pendingReceiveTimeout != null)
     {
         _pendingReceiveTimeout.Cancel();
         _pendingReceiveTimeout = null;
     }
 }

 public void CheckReceiveTimeout()
 {
     CancelReceiveTimeout();
     if (_receiveTimeoutDuration != null && !Mailbox.HasMessages)
     {
         _pendingReceiveTimeout = System.Scheduler.ScheduleTellOnceCancelable(_receiveTimeoutDuration.Value, Self, ReceiveTimeout.Instance, Self);
     }
 }

        /*
        private async void HandleSendPayment(SendPaymentMessage message)
        {
            var sender = Sender;

            var result = await _paymentGateway.Pay(message.AccountNumber, message.Amount);

            sender.Tell(new PaymentSentMessage(result.AccountNumber, result.PaymentConfirmationReceipt));
        }

        private void HandleSendPayment(SendPaymentMessage message)
        {
            var result = _paymentGateway.Pay(message.AccountNumber, message.Amount).Result;

            Sender.Tell(new PaymentSentMessage(result.AccountNumber, result.PaymentConfirmationReceipt));
        }

        */
        protected override void PreStart()
        {
            _unstashSchedule = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(
                TimeSpan.FromSeconds(1),
                TimeSpan.FromSeconds(1),
                Self,
                new ProcessStashedPaymentsMessage(),
                Self);
        }

 protected override void PreStart()
 {
     _cancelOutput = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(
         TimeSpan.FromMilliseconds(800),
         TimeSpan.FromMilliseconds(200),
         Self,
         new WriteClientList(),
         Self);
 }

        private void HandleHeartBeat()
        {
            _lastHeard = Context.System.Scheduler.Now;
            Context.System.ActorSelection(Addresses.ConsoleWriter.Path).Tell(new MachineStatus(_machineName, true, _lastHeard, null));

            if (_cancelable != null)
                _cancelable.Cancel();

            _cancelable = Context.System.Scheduler.ScheduleTellOnceCancelable(TimeSpan.FromSeconds(2), Self, new Flatlined(), Self);
        }

 private void BecomeWorking(RepoKey repo)
 {
     _receivedInitialUsers = false;
     _currentRepo = repo;
     _subscribers = new HashSet<IActorRef>();
     _similarRepos = new Dictionary<string, SimilarRepo>();
     _publishTimer = new Cancelable(Context.System.Scheduler);
     _githubProgressStats = new GithubProgressStats();
     Become(Working);
 }