SecTester.Bus 0.25.0

SecTester.Bus

The package includes a simplified implementation of the EventBus, one based on RabbitMQ, to establish synchronous and asynchronous communication between services and agents.

Setup

$ dotnet add package SecTester.Bus

Usage

Overview

To use the RabbitMQ Event Bus, pass the following options object to the constructor method:

const string repeaterId = "your Repeater ID";
var serviceProvider = new ServiceCollection()
  .AddSecTesterConfig("app.neuralegion.com")
  .AddSecTesterBus(repeaterId)
  .BuildServiceProvider();

var bus = serviceProvider.GetService<EventBus>();

The options are specific to the chosen transporter, the package distributes the RabbitMQ implementation by default. The implementation exposes the properties described below:

In case of unrecoverable or operational errors, you will get an exception while initial connecting.

Subscribing to events

To subscribe an event handler to the particular event, you should register the handler in the EventBus as follows:

public record Issue
{
  public string Name;
  public string Details;
  public string Type;
  public string? cvss;
  public string? cwe;
}

public record IssueDetected(Issue Payload) : Event
{
  public Issue Payload = Payload;
}

public class IssueDetectedHandler: EventListener<Issue>
{
  public Task Handle(IssueDetected @event)
  {
    // implementation
  }
}

bus.Register<IssueDetectedHandler, IssueDetected>();

⚡ Make sure that you register the corresponding provider in the IoC. Otherwise, you get an error while receiving an event in the EventBus.

You can also override a event name using the MessageType attribute as follows:

[MessageType(name: "issue-detected")]
public record IssueDetected(Issue Payload) : Event
{
  public Issue Payload = Payload;
}

Now the IssueDetectedHandler event handler listens for the IssueDetected event. As soon as the IssueDetected event appears, the EventBus will call the Handle() method with the payload passed from the application.

To remove subscription, and removes the event handler, you have to call the unregister() method:

await bus.Unregister<IssueDetectedHandler, IssueDetected>();

Publishing events through the event bus

The EventBus exposes a Publish() method. This method publishes an event to the message broker.

public record StatusChanged(string Status): Event
{
  public string Status = Status;
}

var event = new StatusChanged("connected");

await bus.Publish(event);

The Publish() method takes just a single argument, an instance of the derived class of the Event.

⚡ The class name should match one defined event in the application. Otherwise, you should override it by passing the expected name via the constructor or using the MessageType attribute.

For more information, please see SecTester.Core.

Executing RPC methods

The EventBus exposes a Execute() method. This method is intended to perform a command to the application and returns an Task with its response.

public record Version(string Value)
{
  public string Value = Value;
}

public record LastVersion(Version Value)
{
  public Version Value = Value;
}

public record CheckVersion(Version Version): Command<LastVersion>
{
  public Version Version = Version;
}

var command = new CheckVersion(new Version("1.1.1"));
var response = await bus.Execute(command);

This method returns a Task which will eventually be resolved as a response message.

For instance, if you do not expect any response, you can easily make the EventBus resolve a Task immediately to undefined:

public record Record(Version Version) : Command<Unit>(false)
{
  public Version Version = Version;
}

var command = new Record(new Version("1.1.1"));
await bus.Execute(command);

The HttpCommandDispatcher is an alternative way to execute the commands over HTTP. To start, you should create an HttpCommandDispatcher instance by passing the following options to the constructor:

var httpDispatcher = serviceProvider.GetService<HttpCommandDispatcher>();

The command dispatcher can be customized using the following options:

Then you have to create an instance of HttpRequest instead of a custom command, specifying the Url and Method in addition to the Body that a command accepts by default:

var body = JsonContent.Create(new { Foo = "bar" });
var command = new HttpRequest<Unit>(url: "/api/v1/repeaters",
  method: HttpMethods.Post,
  body: body);

Once it is done, you can perform a request using HttpComandDispatcher as follows:

var response = await httpDispatcher.Execute(command);

Below you will find a list of parameters that can be used to configure a command:

For more information, please see SecTester.Core.

Retry Strategy

For some noncritical operations, it is better to fail as soon as possible rather than retry a coupe of times. For example, it is better to fail right after a smaller number of retries with only a short delay between retry attempts, and display a message to the user.

By default, you can use the Exponential backoff retry strategy to retry an action when errors like SocketException appear.

You can implement your own to match the business requirements and the nature of the failure:

public class CustomRetryStrategy: RetryStrategy
{
  public async Task<TResult> Acquire<TResult>(task: Func<Task<TResult>>) {
    var times = 0;

    for (;;) {
      try
      {
        return await task();
      } catch
      {
        times++;

        if (times == 3)
        {
          throw;
        }
      }
    }
  }
}

Once a retry strategy is implemented, you can register it in the IoC container:

collection.AddSingleton<RetryStrategy, CustomRetryStrategy>();

License

Copyright © 2022 Bright Security.

This project is licensed under the MIT License - see the LICENSE file for details.