ServiceMessages.hpp

Go to the documentation of this file.

#ifndef ROUTE_MESSAGE_HPP
#define ROUTE_MESSAGE_HPP

#include <Poco/JSON/Object.h>
#include <Poco/JSON/Array.h>

#include "JsonSerializable.hpp"
#include "HandlerTypes.hpp"

namespace HCE
{
namespace handlers
{
//-----------------------------------------------------------------------------
class RouteMessage : public IJsonSerializable
{
public:
  enum ErrorCodes
  {
    NO_ERROR=0,
    ERROR_SERIALIZE=1,
    ERROR_UNSERIALIZE=2,
    ERROR_TITLE=3
  };
public:
  RouteMessage(std::vector<ClientWorkerItem>& queue_);
  ~RouteMessage(void) {}

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);

  std::string build(const std::string& title="");
  void extract(const std::string& title, const std::string& msgBody);

  void clear(void);

  static std::vector<std::string> extractIdentityNames(const std::string& routeMessage);
  static std::string buildIdentityNames(const std::vector<ClientWorkerItem>& clientQueue);
  static std::string buildIdentityNames(const std::vector<std::string>& names);

  static std::vector<std::string> extractRouteNames(const std::vector<ClientWorkerItem>& clientQueue);

  std::vector<std::string> extractRouteNames(void);

private:
  void packToObject(Poco::JSON::Object& obj, const std::vector<ClientWorkerItem>& workerItem);
  void unpackFromObject(Poco::JSON::Object& obj, std::vector<ClientWorkerItem>& workerItem);

  static void extractRouteNames(std::vector<std::string>& routeNames, const std::vector<ClientWorkerItem>& clientQueue);

  std::vector<ClientWorkerItem>& queue;

  typedef IJsonSerializable inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class RequestRouteMessage : public IJsonSerializable
{
  // json route message names
  const std::string MANAGER_ROLE = "role";
  const std::string NODES_NAMES = "nodes";
  const std::string RESOURCES_USAGE_ALGORITHM = "alg";
  const std::string RESOURCES_USAGE_ALGORITHM_WEIGHTS = "alg_weights";
  const std::string RESOURCES_USAGE_LIMITS = "limits";
public:
  enum ErrorCodes
  {
    NO_ERROR=0,
    ERROR_SERIALIZE=1,
    ERROR_UNSERIALIZE=2
  };
public:
  RequestRouteMessage(const std::string& json="");
  ~RequestRouteMessage(void) {}

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);

  void clear(void);

  void setManagerRole(unsigned int managerRole_) {managerRole=managerRole_;}
  unsigned int getManagerRole(void) const {return managerRole;}

  void setNodesNames(std::vector<std::string> nodesNames_) {nodesNames=nodesNames_;}
  std::vector<std::string> getNodesNames(void) const {return nodesNames;}

  void setResourcesUsageAlgorithm(unsigned int resourcesUsageAlgorithm_) {resourcesUsageAlgorithm=resourcesUsageAlgorithm_;}
  unsigned int getResourcesUsageAlgorithm(void) const {return resourcesUsageAlgorithm;}

  void setResourcesUsageAlgorithmWeights(const std::string& resourcesUsageAlgorithmWeights_) {resourcesUsageAlgorithmWeights=resourcesUsageAlgorithmWeights_;}
  std::string getResourcesUsageAlgorithmWeights(void) const {return resourcesUsageAlgorithmWeights;}

  void setResourcesUsageLimits(const std::string& resourcesUsageLimits_) {resourcesUsageLimits=resourcesUsageLimits_;}
  std::string getResourcesUsageLimits(void) const {return resourcesUsageLimits;}
private:
  unsigned int managerRole;
  std::vector<std::string> nodesNames;
  unsigned int resourcesUsageAlgorithm;
  std::string resourcesUsageAlgorithmWeights;
  std::string resourcesUsageLimits;

  typedef IJsonSerializable inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class HeartbeatMessage : public IJsonSerializable
{
public:
  enum ErrorCodes
  {
    NO_ERROR=0,
    ERROR_SERIALIZE=1,
    ERROR_UNSERIALIZE=2,
    ERROR_TITLE=3
  };
public:
  explicit HeartbeatMessage(std::vector<ClientWorkerItem>& queue_, const std::string& resources_="");
  ~HeartbeatMessage(void) {}

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);

  std::string build(const std::string& title=NODE_MSG_HEARTBEAT);
  void extract(const std::string& message, const std::string& title=NODE_MSG_HEARTBEAT);

  void clear(void);

  void setResources(const std::string& resources_) {resources=resources_;}
  std::string getResources(void) const {return resources;}
private:
  void packToObject(Poco::JSON::Object& obj, const std::vector<ClientWorkerItem>& workerItem);
  void unpackFromObject(Poco::JSON::Object& obj, std::vector<ClientWorkerItem>& workerItem);

  std::vector<ClientWorkerItem>& queue;
  std::string resources;

  typedef IJsonSerializable inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class PropertyMessage : public IJsonSerializable
{
public:
  enum ErrorCodes
  {
    NO_ERROR=0,
    ERROR_SERIALIZE=1,
    ERROR_UNSERIALIZE=2,
    ERROR_TITLE=3
  };
public:
  explicit PropertyMessage(const std::string& identity_="", const std::string& property_="");
  ~PropertyMessage(void) {}

  bool serialize(std::string& json);
  bool unserialize(const std::string& json);

  std::string build(const std::string& title=NODE_MSG_PROPERTIES);
  void extract(const std::string& message, const std::string& title=NODE_MSG_PROPERTIES);

  void clear(void);

  void setIdentity(const std::string& identity_) {identity=identity_;}
  std::string getIdentity(void) const {return identity;}

  void setProperty(const std::string& property_) {property=property_;}
  std::string getProperty(void) const {return property;}
private:
  std::string identity;
  std::string property;

  typedef IJsonSerializable inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace handlers
} // end namespace HCE 

#endif // ROUTE_MESSAGE_HPP