NAV Navbar
  • Introduction
  • IModuleCore
  • IAPIServer
  • ILogger
  • IHooks
  • IHttpHeader
  • IHttpRequest
  • IHttpResponse
  • IHttpSession
  • IConfig
  • IConfigKey
  • Introduction

    Bienvenue sur la documentation de l'API NexusZiaAPI !

    Cette documentation a pour but de décrire les différents éléments de l'API, à savoir :

    Interface Description
    IModuleCore Interface décrivant un Module
    IAPIServer Interface passé a chaque Module contenant les accès au ILogger et IHooks du serveur
    ILogger Interface pour log des messages à différents niveaux (Info, etc..)
    IHooks Interface pour être notifié d'un événement
    IHttpHeader Interface pour stocker un header HTTP
    IHttpRequest Interface pour stocker une requête HTTP
    IHttpResponse Interface pour stocker une réponse HTTP
    IHttpSession Interface pour définir une session HTTP
    IConfig Interface pour un fichier de configuration d'un Module
    IConfigKey Interface pour définir un key (Scope ou Value) dans un fichier de configuration

    IModuleCore

    IModuleCore header

    namespace nx {
        class IModuleCore
        {
         public:
          /**
           * State for a module loading
           * 0: OFF / 1: UP
           */
          enum class State
          {
            OFF = 0,
            UP  = 1
          };
    
          /**
           * Start module
           */
          virtual void  start(void) = 0;
    
          /**
           * Stop module
           */
          virtual void  stop(void) = 0;
    
          /**
           * Reload module
           * @details A module is not stop then restart, it's always UP
           */
          virtual void  reload(void) = 0;
    
          /**
           * Set the name of the module
           * @param name Name of the module
           */
          virtual void  setName(const std::string & name) = 0;
    
          /**
           * Get the config
           * @return const IModuleConfig
           */
          virtual IModuleConfig & getModuleConfig(void) = 0;
    
          /**
           * Set API Server
           */
          virtual void setAPIServer(std::shared_ptr<IAPIServer> apiServer) = 0;
    
          /**
           * Get API Server
           * @return const IModuleConfig
           */
          virtual IAPIServer & getAPIServer(void) = 0;
    
    
          /**
           * Callback for registered and triggered events
           * @param type Type of the event
           * @param data Data of the event
           * @return
           */
          virtual IHooks::ReturnEvent triggerEvent(IHooks::Types type, void *data) = 0;
        };
    }
    

    L'interface IModuleCore définit un ensemble de fonctions d'un module.

    IAPIServer

    IAPIServer header

    namespace nx {
    class IAPIServer {
     public:
      /**
       * Get hooks from server's API
       * @attention This function allows edition of references
       * @return
       */
      virtual IHooks & getHooks(void) = 0;
    
      /**
       * Get hooks from server's API
       * @return
       */
      virtual const IHooks & getHooks(void) const = 0;
    
      /**
      * Get logger from server's API
      * @attention This function allows edit of reference
      * @return
      */
      virtual ILogger & getLogger(void) = 0;
    
      /**
      * Get logger from server's API
      * @return
      */
      virtual const ILogger & getLogger(void) const = 0;
    };
    }
    

    L'interface IAPIServer est passé à chaque module pour leur permettre d'avoir accès au Logger (pour log des messages) et aux hooks (pour être notifié en cas d'événements).

    ILogger

    ILogger header

    namespace nx {
    class ILogger {
     public:
      /**
       * @class Defines a level of log
       */
      enum class Level {
        DEFAULT = 0,
        INFO = 1,
        SUCCESS = 2,
        WARNING = 3,
        ERROR = 4,
        FATAL_ERROR = 5
      };
    
      /**
       * Log a message
       * @param level Type of log
       * @param msg Message
       */
      virtual void log(const ILogger::Level & level, const std::string & msg) = 0;
    
      /**
       * Log default message
       * @param msg
       */
      virtual void logDefault(const std::string & msg) = 0;
    
      /**
       * Log info message
       * @param msg
       */
      virtual void logInfo(const std::string & msg) = 0;
    
      /**
       * Log success message
       * @param msg
       */
      virtual void logSuccess(const std::string & msg) = 0;
    
      /**
       * Log warning message
       * @param msg
       */
      virtual void logWarning(const std::string & msg) = 0;
    
      /**
       * Log error message
       * @param msg
       */
      virtual void logError(const std::string & msg) = 0;
    
      /**
       * Log fatal error message
       * @param msg
       */
      virtual void logFatalError(const std::string & msg) = 0;
    };
    }
    

    L'interface ILogger permet de pouvoir log des informations.

    Level Description
    DEFAULT Niveau non défini
    INFO Information
    SUCCESS Succès
    WARNING Avertissement
    ERROR Erreur
    FATAL_ERROR Erreur critique

    IHooks

    IHooks header

    namespace nx {
    class IHooks {
     public:
      /**
       * Defines the hook's type
       */
      enum class Types {
        DEFAULT         = 0,
        CONNECTION          = 1,
        REQUEST_BEFORE_PARSING  = 2,
        REQUEST_PARSING     = 4,
        REQUEST_AFTER_PARSING   = 5,
        RESPONSE_BEFORE_BUILD   = 6,
        RESPONSE_BUILD      = 7,
        RESPONSE_AFTER_BUILD    = 8,
        RESPONSE_SEND       = 9
      };
    
      enum class ReturnEvent {
          SUCCESS   = 0,
          ERROR     = 1
      };
    
      /**
       * Get a list of registered hooks
       * @return
       */
      virtual const std::unordered_map<nx::IHooks::Types, std::vector<std::string>, EnumClassHash> & getAllHooksRegister(void) const = 0;
    
      /**
       * Get registered module by type
       * @param name Module's name
       * @return
       */
      virtual const std::vector<std::string> & getModuleRegisterForType(const nx::IHooks::Types type) const = 0;
    
      /**
       * Add hook registration
       * @param type Hook's type
       * @param name Module's name
       */
      virtual void subscribe(const Types & type, const std::string & name) = 0;
    
      /**
       * Remove hook registration
       * @param type Hook's type
       * @param name Module's name
       */
      virtual void unSubscribe(const Types & type, const std::string & name) = 0;
    };
    }
    

    L'interface IHooks permet de pouvoir recevoir des notifications lors d'un événement.

    Type Description
    CONNECTION Connection d'un client
    REQUEST_BEFORE_PARSING Avant le parsing de la requête HTTP
    REQUEST_PARSING Parsing de la requête HTTP
    REQUEST_AFTER_PARSING Après le parsing de la requête HTTP
    RESPONSE_BEFORE_BUILD Avant la création de la réponse HTTP
    RESPONSE_BUILD Création de la réponse HTTP
    RESPONSE_AFTER_BUILD Après la création de la réponse HTTP
    RESPONSE_SEND Envoi de la réponse

    IHttpHeader

    IHttpHeader header

    namespace nx {
    class IHttpHeader {
     public:
      /**
       * Set the key for the HTTP's header
       * @param key
       * @param value
       * @return
       */
      virtual void setKey(const std::string & key, const std::string & value) = 0;
    
      /**
       * Get the key for the HTTP's header
       * @param key
       * @return
       */
      virtual const std::string & getKey(const std::string & key) const = 0;
    };
    }
    

    L'interface IHttpHeader permet de définir un header Http.

    IHttpRequest

    IHttpRequest header

    namespace nx {
      class IHttpRequest : public IHttpHeader {
       public:
        enum class Method {
          UNDEFINED     = 0,
          OPTIONS       = 1,
          GET,
          HEAD,
          POST,
          PUT,
          DELETE,
          TRACE,
          CONNECT,
          PATCH
        };
    
        virtual const Method getMethod(void) const = 0;
    
        virtual const std::string &getURI(void) const = 0;
    
        virtual void setMethod(Method method) = 0;
    
        virtual void setURI(const std::string &uri) = 0;
      };
    }
    

    L'interface IHttpHeader permet de définir une requête HTTP.

    IHttpResponse

    IHttpResponse header

    namespace nx {
      class IHttpResponse : public IHttpHeader {
       public:
        enum class StatusCode {
          UNDEFINED     = 0,
    
          // INFORMATION
          CONTINUE              = 100,
          SWITCHING_PROTOCOLS       = 101,
    
          // SUCCESS
          OK                            = 200,
          CREATED                       = 201,
          ACCEPTED                      = 202,
          NON_AUTHORITATIVE_INFORMATION     = 203,
          NO_CONTENT                    = 204,
          RESET_CONTENT                     = 205,
          PARTIAL_CONTENT                   = 206,
    
          // REDIRECTION
          MULTIPLE_CHOICES          = 300,
          MOVED_PERMANENTLY         = 301,
          FOUND             = 302,
          SEE_OTHER             = 303,
          NOT_MODIFIED          = 304,
          USE_PROXY                         = 305,
          TEMPORARY_REDIRECT                = 307,
    
          // CLIENT ERROR
          BAD_REQUEST                       = 400,
          UNAUTHORIZED                  = 401,
          PAYMENT_REQUIRED              = 402,
          FORBIDDEN                     = 403,
          NOT_FOUND                     = 404,
          METHOD_NOT_ALLOWED            = 405,
          NOT_ACCEPTABLE            = 406,
          PROXY_AUTHENTICATION_REQUIRED = 407,
          REQUEST_TIME_OUT          = 408,
          CONFLICT                      = 409,
          GONE                          = 410,
          LENGTH_REQUIRED                   = 411,
          PRECONDITION_FAILED               = 412,
          REQUEST_ENTITY_TOO_LARGE          = 413,
          REQUEST_URI_TOO_LARGE             = 414,
          UNSUPPORTED_MEDIA_TYPE            = 415,
          REQUESTED_RANGE_NOT_SATISFIABLE   = 416,
          EXPECTATION_FAILED                = 417,
    
          // SERVER ERROR
          INTERNAL_SERVER_ERROR             = 500,
          NOT_IMPLEMENTED                   = 501,
          BAD_GATEWAY                       = 502,
          SERVICE_UNAVAILABLE               = 503,
          GATEWAY_TIME_OUT                  = 504,
          HTTP_VERSION_NOT_SUPPORTED        = 505
        };
    
        virtual StatusCode getStatusCode(void) const = 0;
    
        virtual const std::string &getReason(void) const = 0;
    
        virtual const std::vector<char> & getData(void) = 0;
    
        virtual void setStatusCode(StatusCode statusCode) = 0;
    
        virtual void setReason(const std::string &reason) = 0;
    
        virtual void setData(const std::vector<char> &data) = 0;
      };
    }
    

    L'interface IHttpResponse permet de définir une réponse HTTP.

    IHttpSession

    IHttpSession header

    namespace nx {
      class IHttpSession {
       public:
        virtual const std::string &getIP(void) const = 0;
    
        virtual void setIP(std::string ip) = 0;
      };
    }
    

    L'interface IHttpSession permet de définir une session HTTP.

    IConfig

    IConfig header

    namespace nx {
        class IModuleConfig
        {
         public:
          /**
           * State of config for loading
           */
          enum class State
          {
            UNLOADED        = 0,
            LOAD_START      = 1,
            LOADED          = 2,
            ERROR           = 3
          };
    
          /**
           * Init module's configuration
           * Default value of each key, etc
           */
          virtual void  init(void) = 0;
    
          /**
           * Load module's configuration
           */
          virtual void  load(void) = 0;
    
          /**
           * Reload module's configuration
           */
          virtual void  reload(void) = 0;
    
          /**
           * Get state module's configuration
           * "In loading", "is loaded", "error in config", etc
           * @return
           */
          virtual const State & getState(void) const = 0;
    
          /**
           *
           * @param key
           * @param configKey
           * @return
           */
          virtual void setKey(const std::string & key, const IConfigKey & configKey) = 0;
    
          /**
           * Get unique key in module's configuration
           * @param key
           * @return const IConfigKey &
           */
          virtual const IConfigKey & getKeyOne(const std::string & key) const = 0;
    
          /**
           * Get list of keys in module's configuration
           * @param key
           * @return const std::vector<IConfigkey> &
           */
          virtual const std::vector<IConfigKey> & getKey(const std::string & key) const = 0;
        };
    }
    

    L'interface IConfig permet de définir un fichier de configuration d'un module.

    Les fichiers de configuration sont au format JSON, comme dans l'exemple, en bas a droite.

    Exemple de configuration

    moduleName {
      myScope {
        mykey: "34"
        myKey2: "45"
      }
      myScope2 {
        myKey: "34"
      }
    }
    

    IConfigKey

    IConfigKey header

    namespace nx {
        class IConfigKey {
         public:
          enum class Type {
            VALUE   = 0,
            SCOPE   = 1
          };
    
          /**
           * Set the type of the configuration's key
           * @param type
           */
          virtual void setType(const Type & type) = 0;
    
          /**
           * Get the type of the configuration's key
           * @return
           */
          virtual const Type & getType(void) const = 0;
    
          /**
           * Set name of the configuration's key
           * @param type
           */
          virtual void setName(const std::string & name) = 0;
    
          /**
           * Get name of the configuration's key
           * @return
           */
          virtual const std::string & getName(void) const = 0;
    
          /**
           * Set value of the configuration's key
           * @attention Not for "scope" type
           * @param type
           */
          virtual void setValue(const std::string & value) = 0;
    
          /**
           * Get value of the configuration's key
           * @attention Return "" for scope
           * @return
           */
          virtual const std::string & getValue(void) const = 0;
    
          /**
           * Get value of the configuration's key
           * @attention Return IConfigKey empty for value
           * @return
           */
          virtual const IConfigKey & getScope(void) const = 0;
        };
    }
    

    L'interface IConfigKey permet de définir une clé ou un scope dans un fichier de configuration.