public ShellServer(
ILogger <ShellServer> logger,
IOptions <KernelContext> context,
IServiceProvider provider,
IShellRouter router
)
{
this.logger = logger;
this.context = context.Value;
this.provider = provider;
this.router = router;
router.RegisterHandler("kernel_info_request", async message => KernelInfoRequest?.Invoke(message));
router.RegisterHandler("shutdown_request", async message => ShutdownRequest?.Invoke(message));
}
public DebugMagic(
ISymbolResolver resolver, IConfigurationSource configurationSource, IShellRouter router, IShellServer shellServer,
ILogger <DebugMagic>?logger
) : base(
"debug",
new Microsoft.Jupyter.Core.Documentation
{
Summary = "Steps through the execution of a given Q# operation or function.",
Description = $@"
This magic command allows for stepping through the execution of a given Q# operation
or function using the QuantumSimulator.
#### Required parameters
- Q# operation or function name. This must be the first parameter, and must be a valid Q# operation
or function name that has been defined either in the notebook or in a Q# file in the same folder.
- Arguments for the Q# operation or function must also be specified as `key=value` pairs.
".Dedent(),
Examples = new[]
{
@"
Step through the execution of a Q# operation defined as `operation MyOperation() : Result`:
```
In []: %debug MyOperation
Out[]: <interactive HTML for stepping through the operation>
```
".Dedent(),
@"
Step through the execution of a Q# operation defined as `operation MyOperation(a : Int, b : Int) : Result`:
```
In []: %debug MyOperation a=5 b=10
Out[]: <interactive HTML for stepping through the operation>
```
".Dedent(),
}
})
{
this.SymbolResolver = resolver;
this.ConfigurationSource = configurationSource;
this.ShellServer = shellServer;
this.Logger = logger;
router.RegisterHandler("iqsharp_debug_advance", this.HandleAdvanceMessage);
}
public CommsRouter(IShellServer server, IShellRouter router, ILogger <CommsRouter>?logger = null)
{
this.Server = server;
this.Router = router;
this.logger = logger;
router.RegisterHandler("comm_open", async(message) =>
{
if (message.Content is CommOpenContent openContent)
{
if (sessionHandlers.TryGetValue(openContent.TargetName, out var handler))
{
var session = new CommSession(this, openContent.Id);
openSessions.Add(session.Id, session);
await handler.Handle(session, openContent.RawData);
}
else
{
// According to the Jupyter messaging protocol, we are
// supposed to ignore comm_open messages entirely if
// we don't recognizer the target_name property.
logger.LogWarning(
"Got a comm_open message for target name {TargetName}, but no handler for that target name has been registered.",
openContent.TargetName
);
}
}
else
{
logger.LogError(
"Expected message content for a comm_open message, but got content of type {Type} instead.",
message.Content.GetType()
);
}
});
router.RegisterHandler("comm_msg", async(message) =>
{
if (message.Content is CommMessageContent msgContent)
{
if (!openSessions.TryGetValue(msgContent.Id, out var session))
{
logger.LogError(
"Got comms message for session {Id}, but no such session is currently open.",
session.Id
);
}
await session.HandleMessage(msgContent);
}
else
{
logger.LogError(
"Expected message content for a comm_msg message, but got content of type {Type} instead.",
message.Content.GetType()
);
}
});
router.RegisterHandler("comm_close", async(message) =>
{
if (message.Content is CommCloseContent closeContent)
{
if (!openSessions.TryGetValue(closeContent.Id, out var session))
{
logger.LogError(
"Asked by client to close comms session with {Id}, but no such session is currently open.",
session.Id
);
}
openSessions.Remove(session.Id);
await session.HandleClose(CommSessionClosedBy.Client);
}
else
{
logger.LogError(
"Expected message content for a comm_close message, but got content of type {Type} instead.",
message.Content.GetType()
);
}
});
}
