p-ranav / iris

iris::Component my_component;

iris::Component my_component(iris::threads = 2);

#include <iostream>
#include <iris/iris.hpp>
using namespace iris;

int main() {
  Component my_component;
  my_component.set_interval(period = 500,
                            on_triggered = [] { std::cout << "Timer fired!\n"; });
  my_component.start();
}

// oneshot_timers.cpp
#include <iris/iris.hpp>
using namespace iris;
#include <iostream>

int main() {
  Component c;
  c.set_timeout(delay = 1000,
                on_triggered = [] { std::cout << "1.0 second Timeout!" << std::endl; 
                });
  c.set_timeout(delay = 2500,
                on_triggered = [] { std::cout << "2.5 second Timeout!" << std::endl; 
                });
  c.set_timeout(delay = 5000, 
                on_triggered = [&] {
                    std::cout << "Stopping component" << std::endl;
                    c.stop();
                });
  c.start();
}

// nginx_log_entry.hpp
#pragma once
#include <string>

struct NginxLogEntry {
  std::string time;
  std::string remote_ip;
  std::string remote_user;
  std::string request;
  unsigned response;
  unsigned bytes;
  std::string agent;

  template <class Archive> void serialize(Archive &ar) {
    ar(time, remote_ip, remote_user, request, response, bytes, agent);
  }
};

// subscriber.cpp
#include <iostream>
#include <iris/iris.hpp>
using namespace iris;
#include "nginx_log_entry.hpp"

int main() {
  Component receiver(threads = 2);
  receiver.create_subscriber(
      endpoints = {"tcp://localhost:5555"}, 
      timeout = 5000,
      on_receive = [](Message msg) {
          auto entry = msg.get<NginxLogEntry>();
          std::cout << "[" << entry.time << "] "
                    << "{" << entry.remote_ip << "} "
                    << "-> " << entry.request
                    << "-> " << entry.response << std::endl;
      });
  receiver.start();
}

// publisher.cpp
#include <iostream>
#include <iris/iris.hpp>
using namespace iris;
#include "nginx_log_entry.hpp"
#include "json.hpp"
#include <fstream>

class NginxLogPublisher : public Component {
  Publisher pub;
  nlohmann::json j;
  nlohmann::json::iterator it;

public:
  NginxLogPublisher(const std::string &filename) {
    // read a JSON file
    std::ifstream stream("nginx_logs.json");
    stream >> j;
    it = j.begin();

    // Craete publisher
    pub = create_publisher(endpoints = {"tcp://*:5555"});

    // Publish periodically
    set_interval(period = 200, 
                 on_triggered = [this] {
                     auto element = *it;
                     std::cout << "Published: " << element << std::endl;
                     pub.send(NginxLogEntry{
                         .time = element["time"].get<std::string>(),
                         .remote_ip = element["remote_ip"].get<std::string>(),
                         .remote_user = element["remote_user"].get<std::string>(),
                         .request = element["request"].get<std::string>(),
                         .response = element["response"].get<unsigned>(),
                         .bytes = element["bytes"].get<unsigned>(),
                         .agent = element["agent"].get<std::string>()
                     });
                     ++it;
                 });
  }

  ~NginxLogPublisher() {
    join();
  }

};

int main() {
  NginxLogPublisher publisher("nginx_logs.json");
  publisher.start();
}

// album.hpp
#pragma once
#include <iris/cereal/types/vector.hpp>
#include <string>
#include <vector>

struct Album {
  std::string name;
  std::string artist;
  int year;
  std::string genre;
  std::vector<std::string> tracks;

  template <class Archive> void serialize(Archive &ar) {
    ar(name, artist, year, genre, tracks);
  }
};

// server.cpp
#include "album.hpp"
#include <iris/iris.hpp>
using namespace iris;
#include <iostream>
#include <map>
#include "json.hpp"
#include <fstream>
#include <iris/cereal/types/optional.hpp>
#include <iris/cereal/types/tuple.hpp>

int main() {

  // Load JSON database
  nlohmann::json j;
  std::ifstream stream("database.json");
  stream >> j;

  Component server;
  server.create_server(
      endpoints = {"tcp://*:5510"}, 
      timeout = 500,
      on_request = [&](Request request, Response &response) {
          // Request from client
          auto kvpair = request.get<std::tuple<std::string, std::string>>();
          auto key = std::get<0>(kvpair);
          auto value = std::get<1>(kvpair);
          std::cout << "Received request {key: " 
                    << key << ", value: " << value << "}\n";

          // Response to be filled and sent back 
          // Either a valid album struct or empty
          std::optional<Album> album{};

          // Find the album in the JSON database
          auto it = std::find_if(j.begin(), j.end(), 
            [&key, &value](const auto& element) {
              if (key == "year")
                return element[key] == std::stoi(value);
              else
                return element[key] == value;
          });

          // Populate the response fields
          if (it != j.end()) {
            album = Album {
              .name = (*it)["name"].get<std::string>(),
              .artist = (*it)["artist"].get<std::string>(),
              .year = (*it)["year"].get<unsigned>(),
              .genre = (*it)["genre"].get<std::string>(),
              .tracks = (*it)["tracks"].get<std::vector<std::string>>()
            };
          }

          // Set response
          response.set(album);
      });
  server.start();
}

// client.cpp
#include "album.hpp"
#include <iostream>
#include <optional>
#include <iris/iris.hpp>
using namespace iris;
#include <iris/cereal/types/optional.hpp>
#include <iris/cereal/types/tuple.hpp>

int main(int argc, char *argv[]) {

  std::tuple<std::string, std::string> request;

  if (argc != 3) {
    std::cout << "Usage: ./<executable> key value\n";
    return 0;
  } else {
    request = {argv[1], argv[2]};
  }

  Component c(threads = 1);
  c.start();
  auto client = c.create_client(endpoints = {"tcp://127.0.0.1:5510"},
                                timeout = 2500, 
                                retries = 3);

  // Send request to server
  auto response = client.send(request);

  // Check that the server has called `Response.set()`
  if (response.has_value()) {

    // Parse response and print result if available
    auto album = response.get<std::optional<Album>>();
    if (album.has_value()) {
      auto metadata = album.value();
      std::cout << "- Received album:\n";
      std::cout << "    Name: " << metadata.name << "\n";
      std::cout << "    Artist: " << metadata.artist << "\n";
      std::cout << "    Year: " << metadata.year << "\n";
      std::cout << "    Genre: " << metadata.genre << "\n";
      std::cout << "    Tracks:\n";
      for (size_t i = 0; i < metadata.tracks.size(); ++i) {
        std::cout << "      " << i << ". " << metadata.tracks[i] << "\n";
      }
    } else {
      std::cout << "Album not found!\n";
    }
    
  } else {
    std::cout << "Response not set by server\n";
  }

  c.stop();
}

// numbers.hpp
#pragma once
#include <iris/cereal/types/vector.hpp>
#include <vector>

struct Numbers {
  std::vector<double> values;

  auto size() const { return values.size(); }
  auto begin() const { return values.begin(); }
  auto end() const { return values.end(); }

  template <class Archive> void serialize(Archive &ar) {
    ar(values);
  }
};

// statistics.hpp
#pragma once

struct Statistics {
  double mean;
  double stdev;

  template <class Archive> void serialize(Archive &ar) {
    ar(mean, stdev);
  }
};

#include <iostream>
#include <iris/iris.hpp>
using namespace iris;

int main() {
  Component b(threads = 0);
  b.create_broker(
    router_endpoints = {"tcp://*:5510"},
    dealer_endpoints = {"tcp://*:5515"}
  );
  b.start();
}

#include <iostream>
#include "numbers.hpp"
#include "statistics.hpp"
#include <iris/iris.hpp>
using namespace iris;
#include <algorithm>
#include <numeric>
#include <cmath>

int main() {
  Component worker(threads = 3);

  worker.create_async_server(
      endpoints = {"tcp://localhost:5515"}, 
      timeout = 500,
      on_request = [&](Request request, Response &res) {
          auto numbers = request.get<Numbers>();

          std::cout << "Received numbers: {" << numbers.values[0] 
                    << ", " << numbers.values[1] 
                    << ", " << numbers.values[2] << "}\n";

          // Calculate mean
          double sum = std::accumulate(numbers.begin(), numbers.end(), 0.0);
          double mean = sum / numbers.size();

          // Calculate standard deviation
          double accum = 0.0;
          std::for_each(numbers.begin(), numbers.end(), [&](const double d) {
            accum += (d - mean) * (d -mean);
          });
          double stdev = std::sqrt(accum / numbers.size());

          // Set the response
          res.set(Statistics{.mean = mean, .stdev = stdev});

          std::cout << "Calculated stats successfully\n";
      });
  worker.start();
}

#include <iostream>
#include "numbers.hpp"
#include "statistics.hpp"
#include <iris/iris.hpp>
using namespace iris;

int main() {
  Component c(threads = 2);
  auto client = c.create_client(endpoints = {"tcp://localhost:5510"},
                                timeout = 2500, 
                                retries = 3);

  double i = 0.0, j = 1.0, k = 2.0;

  c.set_interval(
      period = 2000, 
      on_triggered = [&] {
          std::cout << "[Sent] numbers = {" << i << ", " << j << ", " << k << "}\n";
          auto response = client.send(Numbers{.values = {i, j, k}});
          auto stats = response.get<Statistics>();
          std::cout << "[Received] mean = " << stats.mean 
                    << "; stdev = " << stats.stdev
                    << std::endl;
          i += 0.3;
          j += 0.5;
          k += 0.9;
      });
  c.start();
}