pbm 1.0.0

There is a newer version of this package available.
See the version list below for details.
dotnet tool install --global pbm --version 1.0.0
This package contains a .NET tool you can call from the shell/command line.
dotnet new tool-manifest # if you are setting up this repo
dotnet tool install --local pbm --version 1.0.0
This package contains a .NET tool you can call from the shell/command line.
#tool dotnet:?package=pbm&version=1.0.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
nuke :add-package pbm --version 1.0.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.

CLI for managing Akka.NET applications and Akka.NET Clusters.

This package has no dependencies.

Version Downloads Last updated
1.0.2 1,134 11/16/2021
1.0.1 13,346 8/3/2021
1.0.0 730 7/26/2021
0.8.5 9,828 5/3/2021
0.8.4 444 4/30/2021
0.8.3 7,057 3/18/2021
0.8.2 12,002 11/24/2020
0.8.1 899 11/16/2020
0.8.0 18,568 3/11/2020
0.8.0-rc2 253 3/10/2020
0.8.0-rc1 247 3/3/2020
0.7.1 814 3/3/2020
0.7.0 7,812 10/3/2019
0.6.3 2,968 7/30/2019
0.6.2 1,508 6/19/2019
0.6.1 2,161 5/19/2019
0.6.0 609 5/9/2019
0.5.0 1,051 3/6/2019
0.4.1 544 12/7/2018
0.4.1-beta351 378 12/7/2018
0.4.0 469 11/27/2018
0.3.3 421 11/27/2018

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.