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);
