Client

In this example we’re going to create a pars application by deriving from an app::single class that allows us to create an application that uses just one component, namely comp::client in this case.

If you’re interested in building the library and examples as well as running the examples, take a look at the building page.

Main

The main function is straightforward. We just instantiate ::pars_example::apps::client, and then execute it passing argc and argv. Should any exception arise, we will print the exception message to standard output:

int main(int argc, char** argv)
{
  auto app = ::pars_example::apps::client{};

  try
  {
    return app.exec(argc, argv);
  }
  catch (std::exception& e)
  {
    std::cout << fmt::format("Error: {}", e.what()) << "\n";

    return EXIT_FAILURE;
  }
}

Application

We start by declaring such application:

class client : public app::single<comp::client>

Then we override the only functions that we are required to implement in order to have a runnable single application (ie: the startup function):

  void startup(int argc, char** argv) override

Startup

We are going to leverage the pars::app::state_machine to handle the application state, which can be in one of the cases defined in resource::client_state.

  app::state_machine<client_state> state = {client_state::creating};

As a first thing hence, we’re going to ask for a transition from the actual expected state to the next state. This will check that the current application state is resource::client_state::creating (and will throws if it’s not) and creates a pars::app::state_tx object that initiate the transition on the pars::app::state_machine.

Once we’re done, we’re going to commit this state transition in order for the state to change to resource::client_state::initializing. Should any exception be raised after the creation of this pars::app::state_tx, the initiated transition will be rolled back and the app state machine will remain in the initial state:

    auto ts = state.tx(client_state::creating, client_state::initializing);

Next we’re going to read the inputs:

    switch (argc)
    {
    case 6:
      connect_p.service_cmode = net::cmode_from_string(argv[1]);

      connect_p.service_addr = argv[2];

      work_id = std::stoull(argv[3]);

      if (std::string_view(argv[4]).compare("fast") == 0)
        fast_fib = true;
      else if (std::string_view(argv[4]).compare("slow") == 0)
        fast_fib = false;
      else
        usage();

      n = std::stoull(argv[5]);

      break;

    default:
      usage();
    }

Now we register the handler functions (ie: the ones that react to various kinds of events) for the events that we’re intrested in:

    hfs().on<fired, init>(&self::initialize, this);

    hfs().on<fired, exception>(&self::terminate, this);

    comp().req().on<fired, pipe_created>(&self::send_work, this);

    comp().req().on<sent, fib_requested>(&self::recv_answer, this);

    comp().req().on<received, fib_computed>(&self::terminate, this);

    comp().req().on<fired, network_error>(&self::terminate, this);

    comp().req().on<fired, pipe_removed>(&self::terminate, this);

Finally as anticipated, we just commit the state transition:

    ts.commit();

    pars::info(SL, "Application Started!");

Handler Functions

We’re going now to briefly comment all the handler functions that we registered during startup (see previous section).

This application is made out of a client component, which has a single nng_req socket. These handler functions are going to connect to the server, send the request and print the output or any error that could arise.

On fired<init> we’re going to initialize the client component and connect to the specified address using the given mode:

  void initialize(hf_arg<fired, init> fired)
  {
    auto ts = state.tx(client_state::initializing, client_state::started);

    comp().init({.req_opts = {.recv_timeout = req_recv_timeout.count(),
                              .send_timeout = req_send_timeout.count()}});

    comp().connect(connect_p);

    ts.commit();

    pars::info(SL, "Fired {}, Application Initialized!", fired.event());
  }

On fired<pipe_created> (ie: connection established), we’re going to start a send operation on the req socket:

  void send_work(hf_arg<fired, pipe_created> fired)
  {
    auto ts = state.tx(client_state::started, client_state::sending_work);

    auto [ev, md] = fired.as_tuple();

    auto out_ev = fib_requested{work_id, n, fast_fib};

    // use the default context on the sock to send the event
    comp().req().sock().send(out_ev, md.pipe());

    ts.commit();

    pars::info(SL, "Fired {}, Sent {}!", ev, out_ev);
  }

On sent<event::fib_requested> we start a receive operation:

  void recv_answer(hf_arg<sent, fib_requested> sent)
  {
    auto ts =
      state.tx(client_state::sending_work, client_state::waiting_work_done);

    // recv on the default context of the sock
    comp().req().sock().recv();

    ts.commit();

    pars::info(SL, "Sent {}, Receiving!", sent.event());
  }

On received<event::fib_computed> we terminate the component and print the result:

  void terminate(hf_arg<received, fib_computed> recv)
  {
    auto ts =
      state.tx(client_state::waiting_work_done, client_state::terminating);

    auto& ev = recv.event();

    graceful_terminate();

    ts.commit();

    pars::info(SL, "Received {}, Application Terminated!", ev);

    std::cout << "WORK(" << ev.work_id << ") FIB(" << n << ") = " << ev.fib_n
              << "\n";
  }

On fired<exception> (ie: an exception was thrown during an execution of some handler function), we just terminate and print the exception message:

  void terminate(hf_arg<fired, exception> fired)
  {
    auto ts = state.tx(client_state::terminated);

    auto& ev = fired.event();

    graceful_terminate();

    ts.commit();

    pars::info(SL, "Fired {} while \"{}\", Application Terminated!", ev,
               state.current());

    std::cout << fmt::format("ERROR: {}", ev) << std::endl;
  }

On fired<network_error> (ie: we got some error while executing a send or recv operation), we just terminate and print the error message:

  void terminate(hf_arg<fired, network_error> fired)
  {
    auto ts = state.tx(client_state::terminated);

    auto& ev = fired.event();

    graceful_terminate();

    ts.commit();

    pars::info(SL, "Fired {} while \"{}\", Application Terminated!", ev,
               state.current());

    std::cout << fmt::format("ERROR: {}", ev.error) << std::endl;
  }

On fired<pipe_removed> (ie: connection gone), we just terminate and inform the client was disconnected:

  void terminate(hf_arg<fired, pipe_removed> fired)
  {
    auto ts = state.tx(client_state::terminated);

    graceful_terminate();

    ts.commit();

    pars::info(SL, "Fired {} while \"{}\", Application Terminated!",
               fired.event(), state.current());

    std::cout << fmt::format("Client Disconnected!") << std::endl;
  }