Envelope class, represents a message and the sender of the message.
Пример #1
0
 public void Enqueue(IActorRef receiver, Envelope envelope)
 {
     if (!_queue.TryAdd(envelope, PushTimeOut)) // dump messages that can't be delivered in-time into DeadLetters
     {
         receiver.AsInstanceOf<IInternalActorRef>().Provider.DeadLetters.Tell(new DeadLetter(envelope.Message, envelope.Sender, receiver), envelope.Sender);
     }
 }
Пример #2
0
        /// <summary>
        ///     Invokes the specified envelope.
        /// </summary>
        /// <param name="envelope">The envelope.</param>
        public void Invoke(Envelope envelope)
        {
            var message = envelope.Message;
            CurrentMessage = message;
            _currentEnvelopeId ++;
            Sender = MatchSender(envelope);

            try
            {
                var autoReceivedMessage = message as IAutoReceivedMessage;
                if (autoReceivedMessage != null)
                    AutoReceiveMessage(envelope);
                else
                    ReceiveMessage(message);
                CurrentMessage = null;
            }
            catch (Exception cause)
            {
                HandleInvokeFailure(cause);
            }
            finally
            {
                CheckReceiveTimeout(); // Reschedule receive timeout
            }
        }
Пример #3
0
 /// <summary>
 /// Directly inject messages into actor receive behavior. Any exceptions
 /// thrown will be available to you, while still being able to use
 /// become/unbecome.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="sender">The sender.</param>
 public void Receive(object message, IActorRef sender = null)
 {
     var cell = Cell;
     sender = sender.IsNobody() ? cell.System.DeadLetters : sender;
     var envelope = new Envelope { Message = message, Sender = sender };
     cell.UseThreadContext(() => cell.ReceiveMessageForTest(envelope));
 }
 protected override bool LockedTryDequeue(out Envelope envelope)
 {
     if (_prioQueue.Count() > 0)
     {
         envelope = _prioQueue.Dequeue();
         return true;
     }
     envelope = default (Envelope);
     return false;
 }
Пример #5
0
        public void Enqueue(IActorRef receiver, Envelope envelope)
        {
            if (envelope.Message is DeadLetter)
            {
                // actor subscribing to DeadLetter. Drop it.
                return;
            }

            _deadLetters.Tell(new DeadLetter(envelope.Message, envelope.Sender, receiver), envelope.Sender);
        }
        /// <summary>
        /// Attempt to dequeue a message from the front of the prepend buffer.
        /// 
        /// If the prepend buffer is empty, dequeue a message from the normal
        /// <see cref="MessageQueue"/> wrapped but this wrapper.
        /// </summary>
        /// <param name="envelope">The message to return, if any</param>
        /// <returns><c>true</c> if a message was available, <c>false</c> otherwise.</returns>
        public bool TryDequeue(out Envelope envelope)
        {
            if (_prependBuffer.Count > 0)
            {
                envelope = _prependBuffer.Pop();
                return true;
            }

            return _messageQueue.TryDequeue(out envelope);
        }
Пример #7
0
        public override void SendMessage(Envelope envelope)
        {
            if(!(RouterConfig.IsManagementMessage(envelope.Message)) &&
                resizer.IsTimeForResize(_resizeCounter.GetAndIncrement()) &&
                _resizeInProgress.CompareAndSet(false, true))
            {
                base.SendMessage(new Envelope(new Resize(), Self, System));
            }

            base.SendMessage(envelope);
        }
  public void Enqueue(Envelope envelope)
  {
      if (PushTimeOut.Milliseconds >= 0)
      {
          _queue.TryAdd(envelope, PushTimeOut);
      }
      else
      {
          _queue.Add(envelope);
      }
 }
Пример #9
0
 public bool TryDequeue(out Envelope envelope)
 {
     Monitor.TryEnter(_lock, BlockTimeOut);
     try
     {
         return LockedTryDequeue(out envelope);
     }
     finally
     {
         Monitor.Exit(_lock);
     }
 }
Пример #10
0
 public void Enqueue(Envelope envelope)
 {
     Monitor.TryEnter(_lock, BlockTimeOut);
     try
     {
         LockedEnqueue(envelope);
     }
     finally
     {
         Monitor.Exit(_lock);
     }
 }
Пример #11
0
        public void Enqueue(Envelope item)
        {

            _data.Add(item);
            var ci = _data.Count - 1; // child index; start at end
            while (ci > 0)
            {
                var pi = (ci - 1) / 2; // parent index
                if (_priorityCalculator(_data[ci].Message).CompareTo(_priorityCalculator(_data[pi].Message)) >= 0) break; // child item is larger than (or equal) parent so we're done
                var tmp = _data[ci]; _data[ci] = _data[pi]; _data[pi] = tmp;
                ci = pi;
            }
        }
Пример #12
0
        /// <summary>
        ///     Invokes the specified envelope.
        /// </summary>
        /// <param name="envelope">The envelope.</param>
        public void Invoke(Envelope envelope)
        {
            CurrentMessage = envelope.Message;
            Sender = envelope.Sender;
            //set the current context

                try
                {
                    AutoReceiveMessage(envelope);
                }
                catch (Exception cause)
                {
                    Parent.Tell(new Failed(Self, cause));
                }

        }
        /*
 def autoReceiveMessage(msg: Envelope): Unit = {
    if (system.settings.DebugAutoReceive)
      publish(Debug(self.path.toString, clazz(actor), "received AutoReceiveMessage " + msg))

    msg.message match {
      case t: Terminated              ⇒ receivedTerminated(t)
      case AddressTerminated(address) ⇒ addressTerminated(address)
      case Kill                       ⇒ throw new ActorKilledException("Kill")
      case PoisonPill                 ⇒ self.stop()
      case sel: ActorSelectionMessage ⇒ receiveSelection(sel)
      case Identify(messageId)        ⇒ sender() ! ActorIdentity(messageId, Some(self))
    }
  }
         */

        protected virtual void AutoReceiveMessage(Envelope envelope)
        {
            var message = envelope.Message;

            var actor = _actor;
            var actorType = actor != null ? actor.GetType() : null;

            if (System.Settings.DebugAutoReceive)
                Publish(new Debug(Self.Path.ToString(), actorType, "received AutoReceiveMessage " + message));

            var m = envelope.Message;
            if (m is Terminated) ReceivedTerminated(m as Terminated);
            else if (m is AddressTerminated) AddressTerminated((m as AddressTerminated).Address);
            else if (m is Kill) Kill();
            else if (m is PoisonPill) HandlePoisonPill();
            else if (m is ActorSelectionMessage) ReceiveSelection(m as ActorSelectionMessage);
            else if (m is Identify) HandleIdentity(m as Identify);
        }
        /*
 def autoReceiveMessage(msg: Envelope): Unit = {
    if (system.settings.DebugAutoReceive)
      publish(Debug(self.path.toString, clazz(actor), "received AutoReceiveMessage " + msg))

    msg.message match {
      case t: Terminated              ⇒ receivedTerminated(t)
      case AddressTerminated(address) ⇒ addressTerminated(address)
      case Kill                       ⇒ throw new ActorKilledException("Kill")
      case PoisonPill                 ⇒ self.stop()
      case sel: ActorSelectionMessage ⇒ receiveSelection(sel)
      case Identify(messageId)        ⇒ sender() ! ActorIdentity(messageId, Some(self))
    }
  }
         */

        protected virtual void AutoReceiveMessage(Envelope envelope)
        {
            var message = envelope.Message;

            var actor = _actor;
            var actorType = actor != null ? actor.GetType() : null;

            if(System.Settings.DebugAutoReceive)
                Publish(new Debug(Self.Path.ToString(), actorType, "received AutoReceiveMessage " + message));

            envelope.Message
                .Match()
                .With<Terminated>(ReceivedTerminated)
                .With<AddressTerminated>(a => AddressTerminated(a.Address))
                .With<Kill>(Kill)
                .With<PoisonPill>(HandlePoisonPill)
                .With<ActorSelectionMessage>(ReceiveSelection)
                .With<Identify>(HandleIdentity);
        }
Пример #15
0
 public override void Post(IActorRef receiver, Envelope envelope)
 {
     var message = envelope.Message;
     if(message is ISystemMessage)
     {
         Mailbox.DebugPrint("DeadLetterMailbox forwarded system message " + envelope+ " as a DeadLetter");
         _deadLetters.Tell(new DeadLetter(message, receiver, receiver), receiver);
     }
     else if(message is DeadLetter)
     {
         //Just drop it like it's hot
         Mailbox.DebugPrint("DeadLetterMailbox dropped DeadLetter " + envelope);
     }
     else
     {
         Mailbox.DebugPrint("DeadLetterMailbox forwarded message " + envelope + " as a DeadLetter");
         var sender = envelope.Sender;
         _deadLetters.Tell(new DeadLetter(message, sender, receiver),sender);
     }
 }
Пример #16
0
 public override void Post(Envelope envelope)
 {
     var message = envelope.Message;
     if(message is SystemMessage)
     {
         Mailbox.DebugPrint("DeadLetterMailbox forwarded system message " + envelope+ " as a DeadLetter");
         _deadLetters.Tell(new DeadLetter(message, _deadLetters, _deadLetters), _deadLetters);//TODO: When we have refactored Post to SystemEnqueue(ActorRef receiver, Envelope envelope), replace _deadLetters with receiver               
     }
     else if(message is DeadLetter)
     {
         //Just drop it like it's hot
         Mailbox.DebugPrint("DeadLetterMailbox dropped DeadLetter " + envelope);
     }
     else
     {
         Mailbox.DebugPrint("DeadLetterMailbox forwarded message " + envelope + " as a DeadLetter");
         var sender = envelope.Sender;
         _deadLetters.Tell(new DeadLetter(message,sender,_deadLetters),sender);//TODO: When we have refactored Post to Enqueue(ActorRef receiver, Envelope envelope), replace _deadLetters with receiver
     }
 }
        /// <summary>
        ///     Invokes the specified envelope.
        /// </summary>
        /// <param name="envelope">The envelope.</param>
        /// <exception cref="ActorKilledException">
        /// This exception is thrown if a <see cref="Akka.Actor.Kill"/> message is included in the given <paramref name="envelope"/>.
        /// </exception>>
        public void Invoke(Envelope envelope)
        {
            
            var message = envelope.Message;
            var influenceReceiveTimeout = !(message is INotInfluenceReceiveTimeout);

            try
            {
                // Akka JVM doesn't have these lines
                CurrentMessage = envelope.Message;
                _currentEnvelopeId++;

                Sender = MatchSender(envelope);

                if (influenceReceiveTimeout)
                {
                    CancelReceiveTimeout();
                }

                if (message is IAutoReceivedMessage)
                {
                    AutoReceiveMessage(envelope);
                }
                else
                {
                    ReceiveMessage(message);
                }
                CurrentMessage = null;
            }
            catch (Exception cause)
            {
                HandleInvokeFailure(cause);
            }
            finally
            {
                if (influenceReceiveTimeout)
                {
                    CheckReceiveTimeout(); // Reschedule receive timeout
                }
            }
        }
Пример #18
0
        /// <summary>
        ///     Invokes the specified envelope.
        /// </summary>
        /// <param name="envelope">The envelope.</param>
        public void Invoke(Envelope envelope)
        {
            var message = envelope.Message;
            CurrentMessage = message;
            Sender = envelope.Sender;

            try
            {
                var autoReceivedMessage = message as AutoReceivedMessage;
                if(autoReceivedMessage!=null)
                    AutoReceiveMessage(envelope);
                else
                    ReceiveMessage(message);
            }
            catch(Exception cause)
            {
                Mailbox.Suspend();
                Parent.Tell(new Failed(Self, cause));
            }

        }
 protected override void LockedEnqueue(Envelope envelope)
 {
     _prioQueue.Enqueue(envelope);
 }
Пример #20
0
        /// <summary>
        ///     Systems the invoke.
        /// </summary>
        /// <param name="envelope">The envelope.</param>
        public void SystemInvoke(Envelope envelope)
        {

            try
            {
                var m = envelope.Message;

                if (m is CompleteTask) HandleCompleteTask(m as CompleteTask);
                else if (m is Failed) HandleFailed(m as Failed);
                else if (m is DeathWatchNotification)
                {
                    var msg = m as DeathWatchNotification;
                    WatchedActorTerminated(msg.Actor, msg.ExistenceConfirmed, msg.AddressTerminated);
                }
                else if (m is Create) HandleCreate((m as Create).Failure);
                else if (m is Watch)
                {
                    var watch = m as Watch;
                    AddWatcher(watch.Watchee, watch.Watcher);
                }
                else if (m is Unwatch)
                {
                    var unwatch = m as Unwatch;
                    RemWatcher(unwatch.Watchee, unwatch.Watcher);
                }
                else if (m is Recreate) FaultRecreate((m as Recreate).Cause);
                else if (m is Suspend) FaultSuspend();
                else if (m is Resume) FaultResume((m as Resume).CausedByFailure);
                else if (m is Terminate) Terminate();
                else if (m is Supervise)
                {
                    var supervise = m as Supervise;
                    Supervise(supervise.Child, supervise.Async);
                }
                else
                {
                    throw new NotSupportedException("Unknown message " + m.GetType().Name);
                }
            }
            catch (Exception cause)
            {
                HandleInvokeFailure(cause);
            }
        }
Пример #21
0
 /// <summary>
 /// If the envelope.Sender property is null, then we'll substitute
 /// Deadletters as the <see cref="Sender"/> of this message.
 /// </summary>
 /// <param name="envelope">The envelope we received</param>
 /// <returns>An IActorRef that corresponds to a Sender</returns>
 private IActorRef MatchSender(Envelope envelope)
 {
     var sender = envelope.Sender;
     return sender ?? System.DeadLetters;
 }
Пример #22
0
 /// <summary>
 ///     Posts the specified envelope to the mailbox.
 /// </summary>
 /// <param name="receiver"></param>
 /// <param name="envelope">The envelope.</param>
 public abstract void Post(ActorRef receiver, Envelope envelope);
Пример #23
0
 /// <summary>
 /// This is only intended to be called from TestKit's TestActorRef
 /// </summary>
 /// <param name="envelope"></param>
 public void ReceiveMessageForTest(Envelope envelope)
 {
     var message = envelope.Message;
     CurrentMessage = message;
     Sender = envelope.Sender;
     try
     {
         ReceiveMessage(message);
     }
     finally
     {
         CurrentMessage = null;
         Sender = System.DeadLetters;
     }
 }
Пример #24
0
 public bool TryDequeue(out Envelope envelope)
 {
     return _queue.TryDequeue(out envelope);
 }
Пример #25
0
 public void Enqueue(Envelope envelope)
 {
     _queue.Enqueue(envelope);
 }
Пример #26
0
 /// <summary>
 ///     Posts the specified envelope to the mailbox.
 /// </summary>
 /// <param name="envelope">The envelope.</param>
 public abstract void Post(Envelope envelope);
        /// <summary>
        ///     Systems the invoke.
        /// </summary>
        /// <param name="envelope">The envelope.</param>
        public void SystemInvoke(Envelope envelope)
        {

            try
            {
                envelope
                    .Message
                    .Match()
                    .With<CompleteFuture>(HandleCompleteFuture)
                    .With<Failed>(HandleFailed)
                    .With<DeathWatchNotification>(m => WatchedActorTerminated(m.Actor, m.ExistenceConfirmed, m.AddressTerminated))
                    .With<Create>(m => HandleCreate(m.Failure))
                    //TODO: see """final def init(sendSupervise: Boolean, mailboxType: MailboxType): this.type = {""" in dispatch.scala
                    //case Create(failure) ⇒ create(failure)
                    .With<Watch>(m => AddWatcher(m.Watchee, m.Watcher))
                    .With<Unwatch>(m => RemWatcher(m.Watchee, m.Watcher))
                    .With<Recreate>(m => FaultRecreate(m.Cause))
                    .With<Suspend>(m => FaultSuspend())
                    .With<Resume>(m => FaultResume(m.CausedByFailure))
                    .With<Terminate>(Terminate)
                    .With<Supervise>(s => Supervise(s.Child, s.Async))
                    .Default(m => { throw new NotSupportedException("Unknown message " + m.GetType().Name); });
            }
            catch (Exception cause)
            {
                HandleInvokeFailure(cause);
            }
        }
Пример #28
0
 public override void SendMessage(Envelope envelope)
 {
     if (RouterConfig.IsManagementMessage(envelope.Message))
         base.SendMessage(envelope);
     else
         Router.Route(envelope.Message, envelope.Sender);
 }
        /// <summary>
        /// Posts the specified envelope.
        /// </summary>
        /// <param name="receiver"></param>
        /// <param name="envelope"> The envelope. </param>
        public override void Post(IActorRef receiver, Envelope envelope)
        {
            if (_isClosed)
                return;

            hasUnscheduledMessages = true;
            if (envelope.Message is ISystemMessage)
            {
                Mailbox.DebugPrint("{0} enqueued system message {1} to {2}", ActorCell.Self, envelope, ActorCell.Self.Equals(receiver) ? "itself" : receiver.ToString());
                _systemMessages.Enqueue(envelope);
            }
            else
            {
                Mailbox.DebugPrint("{0} enqueued message {1} to {2}", ActorCell.Self, envelope, ActorCell.Self.Equals(receiver) ? "itself" : receiver.ToString());
                _userMessages.Enqueue(envelope);
            }

            Schedule();
        }
Пример #30
0
        public virtual void Post(IActorRef sender, object message)
        {
            if (Mailbox == null)
            {
                return;
                //stackoverflow if this is the deadletters actorref
                //this._systemImpl.DeadLetters.Tell(new DeadLetter(message, sender, this.Self));
            }

            if (_systemImpl.Settings.SerializeAllMessages && !(message is INoSerializationVerificationNeeded))
            {
                Serializer serializer = _systemImpl.Serialization.FindSerializerFor(message);
                byte[] serialized = serializer.ToBinary(message);
                object deserialized = _systemImpl.Serialization.Deserialize(serialized, serializer.Identifier,
                    message.GetType());
                message = deserialized;
            }           

            var m = new Envelope
            {
                Sender = sender,
                Message = message,
            };

            Mailbox.Post(Self, m);
        }