/// <summary> /// TBD /// </summary> /// <param name="wrappedHandle">TBD</param> /// <param name="gremlinAdapter">TBD</param> public FailureInjectorHandle(AssociationHandle wrappedHandle, FailureInjectorTransportAdapter gremlinAdapter) : base(wrappedHandle, FailureInjectorTransportAdapter.FailureInjectorSchemeIdentifier) { _gremlinAdapter = gremlinAdapter; ReadHandlerSource.Task.ContinueWith(tr => { _upstreamListener = tr.Result; WrappedHandle.ReadHandlerSource.SetResult(this); }, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnRanToCompletion); }
private void SetListener(IHandleEventListener handleEventListener) { _listener = handleEventListener; foreach (var msg in _pendingMessages) { _listener.Notify(new InboundPayload(msg)); } _pendingMessages.Clear(); _pendingMessages = null; // GC the collection right away SetHandler(_sink.In, () => Recv(Grab(_sink.In)), Finish, OnUpstreamFailure); }
private UntypedReceive WaitingForPrefix(IHandleEventListener el, IO.ByteString buffer) { if (buffer.Count >= 4) { var length = buffer.Iterator().GetInt(); return WaitingForBody(el, buffer.Drop(4), length); } return message => { if (message is Tcp.Received) { var received = message as Tcp.Received; Become(WaitingForPrefix(el, buffer.Concat(received.Data))); } else HandleWrite(message); }; }
private UntypedReceive WaitingForBody(IHandleEventListener el, IO.ByteString buffer, int length) { if (buffer.Count >= length) { var parts = buffer.SplitAt(length); el.Notify(new InboundPayload(ByteString.CopyFrom(parts.Item1.ToArray()))); return WaitingForPrefix(el, parts.Item2); } return message => { if (message is Tcp.Received) { var received = message as Tcp.Received; Become(WaitingForBody(el, buffer.Concat(received.Data), length)); } else HandleWrite(message); }; }
private UntypedReceive Receiving(IHandleEventListener el) { return message => { if (message is Tcp.Received) { var received = message as Tcp.Received; el.Notify(new InboundPayload(ByteString.CopyFrom(received.Data.ToArray()))); } if (message is ByteString) { var bs = message as ByteString; _connection.Tell(Tcp.Write.Create(IO.ByteString.Create(bs.ToByteArray()))); } else { Unhandled(message); } }; }
private UntypedReceive Receiving(IHandleEventListener el) { return(message => { if (message is Tcp.Received) { var received = message as Tcp.Received; el.Notify(new InboundPayload(ByteString.CopyFrom(received.Data.ToArray()))); } if (message is ByteString) { var bs = message as ByteString; _connection.Tell(Tcp.Write.Create(IO.ByteString.Create(bs.ToByteArray()))); } else { Unhandled(message); } }); }
private UntypedReceive WaitingForPrefix(IHandleEventListener el, IO.ByteString buffer) { if (buffer.Count >= 4) { var length = buffer.Iterator().GetInt(); return(WaitingForBody(el, buffer.Drop(4), length)); } return(message => { if (message is Tcp.Received) { var received = message as Tcp.Received; Become(WaitingForPrefix(el, buffer.Concat(received.Data))); } else { HandleWrite(message); } }); }
private UntypedReceive WaitingForBody(IHandleEventListener el, IO.ByteString buffer, int length) { if (buffer.Count >= length) { var parts = buffer.SplitAt(length); el.Notify(new InboundPayload(ByteString.CopyFrom(parts.Item1.ToArray()))); return(WaitingForPrefix(el, parts.Item2)); } return(message => { if (message is Tcp.Received) { var received = message as Tcp.Received; Become(WaitingForBody(el, buffer.Concat(received.Data), length)); } else { HandleWrite(message); } }); }
internal void Initialize(IHandleEventListener eventListener) { _eventListener = eventListener; _readLoop.ContinueWith(task => { bool gracefulStop = task.Result; //Log(gracefulStop, "Read loop completed"); _disassociated.TrySetResult(gracefulStop); }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default); _writeLoop.ContinueWith(task => { bool gracefulStop = task.Result; //Log(gracefulStop, "Write loop completed"); _disassociated.TrySetResult(gracefulStop); }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default); _initialized.TrySetResult(true); }
protected virtual void Initialize(IChannel channel, IPEndPoint remoteSocketAddress, Address remoteAddress, object msg, out AssociationHandle handle) { var localAddress = Helpers.MapSocketToAddress(channel.LocalAddress as IPEndPoint, this.Transport.SchemeIdentifier, this.Transport.System.Name, this.Transport.Settings.Host); if (localAddress != null) { handle = new TcpAssociationHandle(localAddress, remoteAddress, channel); handle.ReadHandlerSource.Task.ContinueWith(task => { this.listener = task.Result; channel.Configuration.AutoRead = true; }, ReaderHandlerSourceContinuationOptions); } else { handle = null; channel.CloseAsync(); } }
/// <summary> /// TBD /// </summary> /// <param name="handleEventListener">TBD</param> /// <param name="mode">TBD</param> public ListenerAndMode(IHandleEventListener handleEventListener, ThrottleMode mode) { Mode = mode; HandleEventListener = handleEventListener; }
public ListenerReady(IHandleEventListener listener, AssociationHandle wrappedHandle) { WrappedHandle = wrappedHandle; Listener = listener; }
protected abstract void RegisterListener(IConnection channel, IHandleEventListener listener, NetworkData msg, INode remoteAddress);
public static void Set(IConnection channel, IHandleEventListener listener = null) { _channelActors.AddOrUpdate(channel, listener, (connection, eventListener) => listener); }
protected abstract void RegisterListener(IConnection channel, IHandleEventListener listener, NetworkData msg, INode remoteAddress);
protected override void RegisterListener(IChannel channel, IHandleEventListener listener, object msg, IPEndPoint remoteAddress) { _listener = listener; }
protected override void RegisterListener(IConnection channel, IHandleEventListener listener, NetworkData msg, INode remoteAddress) { ChannelLocalActor.Set(channel, listener); BindEvents(channel); }
public static void Set(IConnection channel, IHandleEventListener listener = null) { _channelActors.AddOrUpdate(channel, listener, (connection, eventListener) => listener); }
public HandleListenerRegistered(IHandleEventListener listener) { Listener = listener; }
protected override void RegisterListener(IConnection channel, IHandleEventListener listener, NetworkData msg, INode remoteAddress) { ChannelLocalActor.Set(channel, listener); BindEvents(channel); }
/// <summary> /// TBD /// </summary> /// <param name="channel">TBD</param> /// <param name="listener">TBD</param> /// <param name="msg">TBD</param> /// <param name="remoteAddress">TBD</param> /// <returns>TBD</returns> protected abstract void RegisterListener(IChannel channel, IHandleEventListener listener, object msg, IPEndPoint remoteAddress);
protected override void RegisterListener(IChannel channel, IHandleEventListener listener, object msg, IPEndPoint remoteAddress) { this._listener = listener; }
private void InitializeFSM() { When(ThrottlerState.WaitExposedHandle, @event => { if (@event.FsmEvent is ThrottlerManager.Handle && @event.StateData is Uninitialized) { // register to downstream layer and wait for origin OriginalHandle.ReadHandlerSource.SetResult(new ActorHandleEventListener(Self)); return (GoTo(ThrottlerState.WaitOrigin) .Using( new ExposedHandle( @event.FsmEvent.AsInstanceOf <ThrottlerManager.Handle>().ThrottlerHandle))); } return(null); }); When(ThrottlerState.WaitOrigin, @event => { if (@event.FsmEvent is InboundPayload && @event.StateData is ExposedHandle) { var b = @event.FsmEvent.AsInstanceOf <InboundPayload>().Payload; ThrottledMessages.Enqueue(b); var origin = PeekOrigin(b); if (origin != null) { Manager.Tell(new ThrottlerManager.Checkin(origin, @event.StateData.AsInstanceOf <ExposedHandle>().Handle)); return(GoTo(ThrottlerState.WaitMode)); } return(Stay()); } return(null); }); When(ThrottlerState.WaitMode, @event => { if (@event.FsmEvent is InboundPayload) { var b = @event.FsmEvent.AsInstanceOf <InboundPayload>().Payload; ThrottledMessages.Enqueue(b); return(Stay()); } if (@event.FsmEvent is ThrottleMode && @event.StateData is ExposedHandle) { var mode = @event.FsmEvent.AsInstanceOf <ThrottleMode>(); var exposedHandle = @event.StateData.AsInstanceOf <ExposedHandle>().Handle; InboundThrottleMode = mode; try { if (mode is Blackhole) { ThrottledMessages = new Queue <ByteString>(); exposedHandle.Disassociate(); return(Stop()); } else { AssociationHandler.Notify(new InboundAssociation(exposedHandle)); var self = Self; exposedHandle.ReadHandlerSource.Task.ContinueWith( r => new ThrottlerManager.Listener(r.Result), TaskContinuationOptions.ExecuteSynchronously) .PipeTo(self); return(GoTo(ThrottlerState.WaitUpstreamListener)); } } finally { Sender.Tell(SetThrottleAck.Instance); } } return(null); }); When(ThrottlerState.WaitUpstreamListener, @event => { if (@event.FsmEvent is InboundPayload) { var b = @event.FsmEvent.AsInstanceOf <InboundPayload>(); ThrottledMessages.Enqueue(b.Payload); return(Stay()); } if (@event.FsmEvent is ThrottlerManager.Listener) { UpstreamListener = @event.FsmEvent.AsInstanceOf <ThrottlerManager.Listener>().HandleEventListener; Self.Tell(new Dequeue()); return(GoTo(ThrottlerState.Throttling)); } return(null); }); When(ThrottlerState.WaitModeAndUpstreamListener, @event => { if (@event.FsmEvent is ThrottlerManager.ListenerAndMode) { var listenerAndMode = @event.FsmEvent.AsInstanceOf <ThrottlerManager.ListenerAndMode>(); UpstreamListener = listenerAndMode.HandleEventListener; InboundThrottleMode = listenerAndMode.Mode; Self.Tell(new Dequeue()); return(GoTo(ThrottlerState.Throttling)); } if (@event.FsmEvent is InboundPayload) { var b = @event.FsmEvent.AsInstanceOf <InboundPayload>(); ThrottledMessages.Enqueue(b.Payload); return(Stay()); } return(null); }); When(ThrottlerState.Throttling, @event => { if (@event.FsmEvent is ThrottleMode) { var mode = @event.FsmEvent.AsInstanceOf <ThrottleMode>(); InboundThrottleMode = mode; if (mode is Blackhole) { ThrottledMessages = new Queue <ByteString>(); } CancelTimer(DequeueTimerName); if (ThrottledMessages.Any()) { ScheduleDequeue(InboundThrottleMode.TimeToAvailable(MonotonicClock.GetNanos(), ThrottledMessages.Peek().Length)); } Sender.Tell(SetThrottleAck.Instance); return(Stay()); } if (@event.FsmEvent is InboundPayload) { ForwardOrDelay(@event.FsmEvent.AsInstanceOf <InboundPayload>().Payload); return(Stay()); } if (@event.FsmEvent is Dequeue) { if (ThrottledMessages.Any()) { var payload = ThrottledMessages.Dequeue(); UpstreamListener.Notify(new InboundPayload(payload)); InboundThrottleMode = InboundThrottleMode.TryConsumeTokens(MonotonicClock.GetNanos(), payload.Length).Item1; if (ThrottledMessages.Any()) { ScheduleDequeue(InboundThrottleMode.TimeToAvailable(MonotonicClock.GetNanos(), ThrottledMessages.Peek().Length)); } } return(Stay()); } return(null); }); WhenUnhandled(@event => { // we should always set the throttling mode if (@event.FsmEvent is ThrottleMode) { InboundThrottleMode = @event.FsmEvent.AsInstanceOf <ThrottleMode>(); Sender.Tell(SetThrottleAck.Instance); return(Stay()); } if (@event.FsmEvent is Disassociated) { return(Stop()); // not notifying the upstream handler is intentional: we are relying on heartbeating } if (@event.FsmEvent is FailWith) { var reason = @event.FsmEvent.AsInstanceOf <FailWith>().FailReason; if (UpstreamListener != null) { UpstreamListener.Notify(new Disassociated(reason)); } return(Stop()); } return(null); }); if (Inbound) { StartWith(ThrottlerState.WaitExposedHandle, Uninitialized.Instance); } else { OriginalHandle.ReadHandlerSource.SetResult(new ActorHandleEventListener(Self)); StartWith(ThrottlerState.WaitModeAndUpstreamListener, Uninitialized.Instance); } }
public FailureInjectorHandle(AssociationHandle wrappedHandle, FailureInjectorTransportAdapter gremlinAdapter) : base(wrappedHandle, FailureInjectorTransportAdapter.FailureInjectorSchemeIdentifier) { _gremlinAdapter = gremlinAdapter; ReadHandlerSource.Task.ContinueWith(tr => { _upstreamListener = tr.Result; WrappedHandle.ReadHandlerSource.SetResult(this); }, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnRanToCompletion); }
/// <summary> /// TBD /// </summary> /// <param name="handleEventListener">TBD</param> public Listener(IHandleEventListener handleEventListener) { HandleEventListener = handleEventListener; }
protected abstract void RegisterListener(IChannel channel, IHandleEventListener listener, object msg, IPEndPoint remoteAddress);