Petabridge.Cmd.Remote 1.0.0

Petabridge.Cmd v1.0.0 is a major release of Petabridge.Cmd that doesn't include any breaking changes for older clients. Programmatic `IPbmClient` Support** It is now possible to invoke Petabridge.Cmd programmatically, as of Petabridge.Cmd 1.0.0 - and this can be done in one of two ways: 1. In-process, inside the same Akka.NET `ActorSystem` that is running the `PetabridgeCmd` host; 2. Remotely, from an external process that connects to the `PetabridgeCmd` host using the same TCP port used by the `pbm` CLI clients. We've added [extensive documentation to the Petabridge.Cmd website which documents how to use these new `IPbmClient` implementations](https://cmd.petabridge.com/articles/clients/index.html#ipbmclient-programmatic-client), but we've also included a small example here: ```csharp // <configureHost> // create a Petabridge.Cmd host from our ActorSystem // host is configured to run on port 11555 via HOCON var pbmHost = PetabridgeCmd.Get(Sys); // start the host pbmHost.Start(); // </configureHost> // <clientActorSystem> // create client ActorSystem using ActorSystem clientSystem = ActorSystem.Create("ClientSystem"); // grab copy of the PetabridgeCmdClient extension (Petabridge.Cmd.Common NuGet package) var clientExt = PetabridgeCmdClient.Get(clientSystem); // create IpEndPoint or DnsEndPoint for contacting remote host // either one of these would work var ip = new IPEndPoint(IPAddress.Loopback, 11555); var dns = new DnsEndPoint("localhost", 11555); // start a new IPbmClient attached to one of these EndPoints // by default this operation will time out in 5 seconds. // you can extend that by passing in a custom CancellationToken IPbmClient remoteClient = await clientExt.StartRemoteClient(ip); // </clientActorSystem> // <runClient> // invoke a "log peek" command, just like you would on CLI CommandSession session = await remoteClient.ExecuteTextCommandAsync("log peek"); // grab a hold of the Akka.Streams materializer from ActorSystem var materializer = Sys.Materializer(); // pipe the Akka.Streams Source<CommandResponse> to a Sink<CommandResponse> // in this case, we're just going to send everything to a TestActor. // // This Akka.Streams "graph" can be materialized into a Task, which will // complete once the stream is marked as complete by the Petabridge.Cmd host. var completionTask = session.Stream.RunForeach(rsp => { TestActor.Tell(rsp); }, materializer); // a client can also cancel the stream using the KillSwitch included // inside the CommandSession object session.KillSwitch.Shutdown(); // once either of those two events occur, the Task returned earlier // will be complete await completionTask; // and we can validate that the TestActor received at least one CommandResponse var response = ExpectMsg<CommandResponse>(); // </runClient> ``` Multiple Concurrent Client Sessions** Another major architectural change we've introduced to Petabridge.Cmd in order to support programmatic clients is the notion of multiple client-facing sessions all originating from the same connection. Petabridge.Cmd now effectively supports command multi-plexing on the server and client side. In effect, a single `IPbmClient` can now run multiple streaming commands at once - such as `log tail`, `cluster tail`, and `remote tail`, all over the same TCP connection. This is a minor breaking change to some command palettes - all of the official Petabridge ones will be updated shortly to support this, but user-defined `CommandPalette`s may also need to be updated in order to support this. We will update our "[Creating Custom Commands](https://cmd.petabridge.com/articles/commands/custom-commands.html)" documentation shortly to help developers implement these changes successfully - the changes required are minor.