private async Task Publish(ICommandDelivery <T> item) { var receivers = GetReceivers(); if (receivers.Length == 0) { clock.Schedule(async s => await Publish(item), dueAfter: TimeSpan.FromSeconds(1)); return; } foreach (var receiver in receivers) { var result = await receiver.Invoke(item); switch (result) { case RetryDeliveryResult <T> retry: clock.Schedule(async s => await Publish(item), item.DueTime); break; case CancelDeliveryResult <T> _: case CompleteDeliveryResult <T> _: pendingDeliveries.TryRemove(item.IdempotencyToken, out var _); scheduledIdempotencyTokens.TryAdd(item.IdempotencyToken); break; } } }
public async Task <ICommandDeliveryResult> Handle( ICommandDelivery <JupyterRequestContext> delivery) { switch (delivery.Command.JupyterRequestMessageEnvelope.Content) { case ExecuteRequest _: await _executeHandler.Handle(delivery.Command); break; case CompleteRequest _: await _completeHandler.Handle(delivery.Command); break; case InterruptRequest _: await _interruptHandler.Handle(delivery.Command); break; case IsCompleteRequest _: await _isCompleteHandler.Handle(delivery.Command); break; case ShutdownRequest _: await _shutdownHandler.Handle(delivery.Command); break; } delivery.Command.Complete(); return(delivery.Complete()); }
public async Task <ICommandDeliveryResult> Handle( ICommandDelivery <JupyterRequestContext> delivery) { switch (delivery.Command.Request.Header.MessageType) { case MessageTypeValues.ExecuteRequest: await _executeHandler.Handle(delivery.Command); break; case MessageTypeValues.CompleteRequest: await _completeHandler.Handle(delivery.Command); break; case MessageTypeValues.InterruptRequest: await _interruptHandler.Handle(delivery.Command); break; case MessageTypeValues.IsCompleteRequest: await _isCompleteHandler.Handle(delivery.Command); break; } return(delivery.Complete()); }
public static ConfirmationLogger Receive <T>(ICommandDelivery <T> delivery) => new ConfirmationLogger( "Receive", Category <T> .Receiver, messageTemplate, args: Destructure(delivery), logOnStart: true);
public static void Completion <T>( ConfirmationLogger operation, ICommandDelivery <T> delivery, ICommandDeliveryResult result) { string resultString = null; switch (result) { case CompleteDeliveryResult <T> complete: resultString = "Complete"; break; case RetryDeliveryResult <T> retry: resultString = "WillRetry"; break; case CancelDeliveryResult <T> cancel: resultString = "Cancelled"; break; } operation.Succeed( $"{{result}}: {messageTemplate}", resultString, delivery.Command, delivery.IdempotencyToken, delivery.DueTime, delivery.NumberOfPreviousAttempts); }
public async Task <ICommandDeliveryResult> Handle( ICommandDelivery <JupyterRequestContext> delivery) { switch (delivery.Command.Request.Content) { case ExecuteRequest _: await _executeHandler.Handle(delivery.Command); break; case CompleteRequest _: await _completeHandler.Handle(delivery.Command); break; case InterruptRequest _: await _interruptHandler.Handle(delivery.Command); break; case IsCompleteRequest _: await _isCompleteHandler.Handle(delivery.Command); break; default: break; } delivery.Command.Complete(); return(delivery.Complete()); }
public async Task A_command_can_be_scheduled_for_future_delivery() { ICommandDelivery <string> received = null; SubscribeHandler <string>(cmd => { received = cmd; return(cmd.Complete()); }); var scheduler = CreateScheduler <string>(); await scheduler.Schedule( "hello eventually!", 10.Seconds()); await Clock.Wait(5.Seconds()); if (received != null) { throw new Exception("Message arrived sooner than expected: " + received.Command); } await Clock.Wait(5.Seconds()); received.Command.Should().Be("hello eventually!"); }
private static object[] Destructure <T>(this ICommandDelivery <T> delivery) => new object[] { delivery.Command, delivery.IdempotencyToken, delivery.DueTime, delivery.NumberOfPreviousAttempts };
public static void Completion <T>( ConfirmationLogger operation, ICommandDelivery <T> delivery) => operation.Succeed( "{Command} :{IdempotencyToken} due @ {DueTime}", delivery.Command, delivery.IdempotencyToken, delivery.DueTime);
public CancelDeliveryResult( ICommandDelivery <T> commandDelivery, string reason = null, Exception exception = null) : base(commandDelivery) { Reason = reason; Exception = exception; }
public async Task <ICommandDeliveryResult> Handle(ICommandDelivery <UpdateCommandTarget> delivery) { var commandTarget = await store.Get(delivery.Command.TargetId); await delivery.Command.ApplyTo(commandTarget); await store.Put(commandTarget); return(delivery.Complete()); }
public RetryDeliveryResult( ICommandDelivery <T> delivery, TimeSpan retryPeriod) : base(delivery) { RetryPeriod = retryPeriod; if (delivery is CommandDelivery <T> d) { d.SignalRetry(RetryPeriod); } }
public async Task <ICommandDeliveryResult> Handle(ICommandDelivery <TestCommand> delivery) { await Task.Yield(); if (delivery.Command.Payload > 10) { return(delivery.PauseAllDeliveriesFor(5.Seconds())); } delivery.Command.Processed.Add(delivery.Command.Payload); return(delivery.Complete()); }
public static DeliveryContext Establish(ICommandDelivery delivery) { var context = new DeliveryContext(delivery); if (current.Value == null) { current.Value = new Stack <DeliveryContext>(); } current.Value.Push(context); return(context); }
private DeliveryContext(ICommandDelivery delivery) { Delivery = delivery ?? throw new ArgumentNullException(nameof(delivery)); if (current.Value?.Count > 0 && current.Value?.Peek().Delivery != null) { parentDelivery = current.Value.Peek().Delivery; } else { parentDelivery = new NoParent(delivery.IdempotencyToken); } }
public async Task Schedule(ICommandDelivery <T> item) { await Task.Yield(); if (!scheduledIdempotencyTokens.TryAdd(item.IdempotencyToken)) { return; } pendingDeliveries.TryAdd(item.IdempotencyToken, item); clock.Schedule(async s => await Publish(item), after: item.DueTime); }
public static Message ToMessage <T>(this ICommandDelivery <T> delivery) { var json = delivery.Command.ToJson(); var message = new Message { Body = Encoding.UTF8.GetBytes(json), ContentType = "application/json", MessageId = delivery.IdempotencyToken }; if (delivery.DueTime != null) { message.ScheduledEnqueueTimeUtc = delivery.DueTime.Value.UtcDateTime; } return(message); }
public async Task The_Service_Bus_Message_is_available_as_a_property() { ICommandDelivery <string> received = null; var handler = CreateHandler <string>(cmd => { received = cmd; return(cmd.Complete()); }); var scheduler = CreateScheduler <string>(); await scheduler.Schedule("hello!"); await CreateReceiver <string>().Receive(handler); received.Properties["Message"].Should().BeOfType <Message>(); }
public async Task A_command_can_be_scheduled_for_asap_delivery() { ICommandDelivery <string> received = null; var scheduler = CreateScheduler <string>(); await scheduler.Schedule("now!"); var receiver = CreateReceiver <string>(); await receiver.Receive( CreateHandler <string>(cmd => { received = cmd; return(cmd.Complete()); })); received.Command.Should().Be("now!"); }
private async Task HandleCompleteRequest(ICommandDelivery <JupyterRequestContext> delivery) { var serverChannel = delivery.Command.ServerChannel; var completeRequest = delivery.Command.Request.Content as CompleteRequest; var code = completeRequest.Code; var workspace = CreateScaffoldWorkspace(code, completeRequest.CursorPosition); var workspaceRequest = new WorkspaceRequest(workspace, activeBufferId: workspace.Buffers.First().Id); var result = await _server.GetCompletionList(workspaceRequest); var pos = ComputeReplacementStartPosition(code, completeRequest.CursorPosition); var reply = new CompleteReply(pos, completeRequest.CursorPosition, matches: result.Items.Select(e => e.InsertText).ToList()); var completeReply = Message.CreateResponseMessage(reply, delivery.Command.Request); serverChannel.Send(completeReply); }
public async Task <ICommandDeliveryResult> Handle( ICommandDelivery <JupyterRequestContext> delivery) { switch (delivery.Command.Request.Header.MessageType) { case MessageTypeValues.ExecuteRequest: await _executeHandler.Handle(delivery.Command); // await HandleExecuteRequest(delivery); break; case MessageTypeValues.CompleteRequest: delivery.Command.RequestHandlerStatus.SetAsBusy(); await HandleCompleteRequest(delivery); delivery.Command.RequestHandlerStatus.SetAsIdle(); break; } return(delivery.Complete()); }
public async Task <ICommandDeliveryResult> Handle( ICommandDelivery <JupyterRequestContext> delivery) { switch (delivery.Command.Request.Header.MessageType) { case MessageTypeValues.ExecuteRequest: var transient = new Dictionary <string, object> { { "display_id", Guid.NewGuid().ToString() } }; var jObject = (JObject)delivery.Command.Request.Content; var executeRequest = jObject.ToObject <ExecuteRequest>(); var code = executeRequest.Code; var workspace = new Workspace( files: new[] { new File("Program.cs", Scaffold()) }, buffers: new[] { new Buffer(new BufferId("Program.cs", "main"), code), }, workspaceType: "console"); var workspaceRequest = new WorkspaceRequest(workspace); var server = new WorkspaceServerMultiplexer(new PackageRegistry()); var result = await server.Run(workspaceRequest); var messageBuilder = delivery.Command.Builder; var ioPubChannel = delivery.Command.IoPubChannel; var serverChannel = delivery.Command.ServerChannel; if (!executeRequest.Silent) { _executionCount++; var executeInput = messageBuilder.CreateMessage( MessageTypeValues.ExecuteInput, new ExecuteInput { Code = code, ExecutionCount = _executionCount }, delivery.Command.Request.Header); ioPubChannel.Send(executeInput); } // execute result var output = string.Join("\n", result.Output); // executeResult data var executeResultData = new ExecuteResult() { Data = new JObject { { "text/html", output }, { "text/plain", output } }, Transient = transient, ExecutionCount = _executionCount }; var resultSucceeded = result.Succeeded && result.Exception == null; if (resultSucceeded) { // reply ok var executeReplyPayload = new ExecuteReplyOk { ExecutionCount = _executionCount }; // send to server var executeReply = messageBuilder.CreateMessage( MessageTypeValues.ExecuteReply, executeReplyPayload, delivery.Command.Request.Header); executeReply.Identifiers = delivery.Command.Request.Identifiers; serverChannel.Send(executeReply); } else { var errorContent = new Error { EName = string.IsNullOrWhiteSpace(result.Exception) ? "Compile Error" : "Unhandled Exception", EValue = output, Traceback = new List <string>() }; // reply Error var executeReplyPayload = new ExecuteReplyError(errorContent) { ExecutionCount = _executionCount }; // send to server var executeReply = messageBuilder.CreateMessage( MessageTypeValues.ExecuteReply, executeReplyPayload, delivery.Command.Request.Header); executeReply.Identifiers = delivery.Command.Request.Identifiers; serverChannel.Send(executeReply); if (!executeRequest.Silent) { // send on io var error = messageBuilder.CreateMessage( MessageTypeValues.Error, errorContent, delivery.Command.Request.Header); ioPubChannel.Send(error); // send on stderr var stdErr = new StdErrStream { Text = errorContent.EValue }; var stream = messageBuilder.CreateMessage( MessageTypeValues.Stream, stdErr, delivery.Command.Request.Header); ioPubChannel.Send(stream); } } if (!executeRequest.Silent && resultSucceeded) { // send on io var executeResultMessage = messageBuilder.CreateMessage( MessageTypeValues.ExecuteResult, executeResultData, delivery.Command.Request.Header); ioPubChannel.Send(executeResultMessage); } break; } return(delivery.Complete()); }
public async Task Schedule(ICommandDelivery <T> delivery) => await messageSender.SendAsync(delivery.ToMessage());
public CompleteDeliveryResult( ICommandDelivery <T> commandDelivery) : base(commandDelivery) { }
public override Task <ICommandDeliveryResult> Handle(HandleCommand <TChannel> handlerDelegate, ICommandDelivery <TChannel> delivery) { if (handlerDelegate == null) { throw new ArgumentNullException(nameof(handlerDelegate)); } if (delivery == null) { throw new ArgumentNullException(nameof(delivery)); } return(handlerDelegate(delivery)); }
private async Task HandleExecuteRequest(ICommandDelivery <JupyterRequestContext> delivery) { var ioPubChannel = delivery.Command.IoPubChannel; var serverChannel = delivery.Command.ServerChannel; var transient = new Dictionary <string, object> { { "display_id", Guid.NewGuid().ToString() } }; var executeRequest = delivery.Command.GetRequestContent <ExecuteRequest>(); var code = executeRequest.Code; var workspace = CreateScaffoldWorkspace(code); var workspaceRequest = new WorkspaceRequest(workspace); var result = await _server.Run(workspaceRequest); if (!executeRequest.Silent) { _executionCount++; var executeInput = Message.Create( new ExecuteInput(code: code, executionCount: _executionCount), delivery.Command.Request.Header); ioPubChannel.Send(executeInput); } // execute result var output = string.Join("\n", result.Output); // executeResult data var executeResultData = new ExecuteResult( _executionCount, transient: transient, data: new Dictionary <string, object> { { "text/html", output }, { "text/plain", output } }); var resultSucceeded = result.Succeeded && result.Exception == null; if (resultSucceeded) { // reply ok var executeReplyPayload = new ExecuteReplyOk(executionCount: _executionCount); // send to server var executeReply = Message.CreateResponse( executeReplyPayload, delivery.Command.Request); serverChannel.Send(executeReply); } else { var errorContent = new Error( eName: string.IsNullOrWhiteSpace(result.Exception) ? "Compile Error" : "Unhandled Exception", eValue: output ); // reply Error var executeReplyPayload = new ExecuteReplyError(errorContent, executionCount: _executionCount); // send to server var executeReply = Message.CreateResponse( executeReplyPayload, delivery.Command.Request); serverChannel.Send(executeReply); if (!executeRequest.Silent) { // send on io var error = Message.Create( errorContent, delivery.Command.Request.Header); ioPubChannel.Send(error); // send on stderr var stdErr = new StdErrStream(errorContent.EValue); var stream = Message.Create( stdErr, delivery.Command.Request.Header); ioPubChannel.Send(stream); } } if (!executeRequest.Silent && resultSucceeded) { // send on io var executeResultMessage = Message.Create( executeResultData, delivery.Command.Request.Header); ioPubChannel.Send(executeResultMessage); } }
public async Task <ICommandDeliveryResult> Handle(ICommandDelivery <CreateCommandTarget> delivery) { await store.Put(new CommandTarget(delivery.Command.TargetId)); return(delivery.Complete()); }
public static CancelDeliveryResult <T> Cancel <T>( this ICommandDelivery <T> commandDelivery, string reason = null, Exception exception = null) => new CancelDeliveryResult <T>(commandDelivery, reason, exception);
public static RetryDeliveryResult <T> Retry <T>( this ICommandDelivery <T> commandDelivery, TimeSpan?after = null) =>
public static CompleteDeliveryResult <T> Complete <T>( this ICommandDelivery <T> commandDelivery) => new CompleteDeliveryResult <T>(commandDelivery);