utils.h

/* Jazz (c) 2018-2025 kaalam.ai (The Authors of Jazz), using (under the same license):
 
    1. Biomodelling - The AATBlockQueue class (c) Jacques Basaldúa, 2009-2012 licensed
      exclusively for the use in the Jazz server software.
 
      Copyright 2009-2012 Jacques Basaldúa
 
    2. BBVA - Jazz: A lightweight analytical web server for data-driven applications.
 
      Copyright 2016-2017 Banco Bilbao Vizcaya Argentaria, S.A.
 
      This product includes software developed at
 
      BBVA (https://www.bbva.com/)
 
    3. LMDB, Copyright 2011-2017 Howard Chu, Symas Corp. All rights reserved.
 
      Licensed under http://www.OpenLDAP.org/license.html
 
 
      Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
 
      http://www.apache.org/licenses/LICENSE-2.0
 
      Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/
 
 
#include <chrono>
#include <iostream>
#include <fstream>
#include <map>
 
#include <string.h>
 
#include <unistd.h>
#include <dirent.h>
 
#include <sys/syscall.h>
#include <stdarg.h>
 
 
#include "src/jazz_elements/types.h"
 
#ifdef CATCH_TEST
#ifndef INCLUDED_JAZZ_CATCH2
#define INCLUDED_JAZZ_CATCH2
 
#include "src/catch2/catch.hpp"
 
#endif
#endif
 
 
#ifndef INCLUDED_JAZZ_ELEMENTS_UTILS
#define INCLUDED_JAZZ_ELEMENTS_UTILS
 
 
namespace jazz_elements
{
 
/* Miscellaneous utility functions for Jazz.
 
    This module defines many unrelated functions needed by Jazz. The only rule is: functions and classes
without global variables.
*/
 
#define TENBITS_LUT_SIZE 1024   
 
 
#define LOG_DEBUG             1
#define LOG_INFO              2
#define LOG_MISS              3
#define LOG_WARN              4
#define LOG_ERROR             5
 
#define MAX_FILENAME_LENGTH 256
 
#define MAX_BLOCK_SIZE          0x40000000      
 
#define SERVICE_NO_ERROR                  0     
#define SERVICE_NOT_IMPLEMENTED          -1     
#define SERVICE_ERROR_BAD_CONFIG         -2     
#define SERVICE_ERROR_STARTING           -3     
#define SERVICE_ERROR_NO_MEM             -4     
#define SERVICE_ERROR_LOADING_STAT       -5     
#define SERVICE_ERROR_NEW_BLOCK_ARGS     -6     
#define SERVICE_ERROR_WRONG_TYPE         -7     
#define SERVICE_ERROR_WRONG_NAME         -8     
#define SERVICE_ERROR_WRONG_ARGUMENTS    -9     
#define SERVICE_ERROR_BAD_BLOCK         -10     
#define SERVICE_ERROR_BAD_NEW_KIND      -11     
#define SERVICE_ERROR_BAD_KIND_ADD      -12     
#define SERVICE_ERROR_WRITE_FORBIDDEN   -13     
#define SERVICE_ERROR_WRITE_FAILED      -14     
#define SERVICE_ERROR_REMOVE_FAILED     -15     
#define SERVICE_ERROR_BLOCK_NOT_FOUND   -16     
#define SERVICE_ERROR_CREATE_FAILED     -17     
#define SERVICE_ERROR_PARSING_NAMES     -18     
#define SERVICE_ERROR_PARSING_NUMBERS   -19     
#define SERVICE_ERROR_TOO_DEEP          -20     
#define SERVICE_ERROR_WRONG_BASE        -21     
#define SERVICE_ERROR_PARSING_COMMAND   -22     
#define SERVICE_ERROR_EMPTY_ENTITY      -23     
#define SERVICE_ERROR_ENTITY_NOT_FOUND  -24     
#define SERVICE_ERROR_LOW_PRIORITY      -25     
#define SERVICE_ERROR_PARENT_NOT_FOUND  -26     
#define SERVICE_ERROR_TOO_MANY_ENTITIES -27     
#define SERVICE_ERROR_NOT_APPLICABLE    -28     
#define SERVICE_ERROR_IO_ERROR          -29     
#define SERVICE_ERROR_BLOCK_TOO_BIG     -30     
#define SERVICE_ERROR_BASE_FORBIDDEN    -31     
#define SERVICE_ERROR_READ_FORBIDDEN    -32     
#define SERVICE_ERROR_NOT_READY         -33     
#define SERVICE_ERROR_MISC_SERVER       -34     
#define SERVICE_ERROR_UNKNOWN_JAZZNODE  -35     
#define SERVICE_ERROR_CORRUPTED         -36     
 
#define JAZZ_DEFAULT_CONFIG_PATH "config/jazz_config.ini"
 
typedef int StatusCode;
 
 
bool         FileExists           (const char* file_name);
char        *ExpandEscapeSequences(char *buff);
pid_t        FindProcessIdByName  (const char *name);
uint64_t     MurmurHash64A        (const void *key, int len);
std::string  CleanConfigArgument  (std::string s);
 
 
typedef int TenBitIntLUT[TENBITS_LUT_SIZE];
 
 
typedef void* TenBitPtrLUT[TENBITS_LUT_SIZE];
 
 
inline int TenBitsAtAddress(const char* str) {
    return ((str[1] & 0x1f) << 5) | (str[0] & 0x1F);
}
 
 
inline int64_t elapsed_mu_sec(TimePoint big_bang) {
    TimePoint now = std::chrono::steady_clock::now();
 
    return std::chrono::duration_cast<std::chrono::microseconds>(now - big_bang).count();
}
 
 
inline bool valid_name(pChar p_name) {
    char ch = p_name++[0];
 
    if (!ch)
        return false;
 
    if (ch < 'A' || ch > 'z' || (ch > 'Z' && ch < 'a'))
        return false;
 
    for (int i = 1; i < NAME_SIZE; i++) {
        char ch = p_name++[0];
 
        if (!ch)
            return true;
 
        if (ch < '0' || ch > 'z' || (ch > '9' && ch < 'A') || (ch > 'Z' && ch < '_') || ch == 0x60)
            return false;
    }
    return false;
}
 
 
class ConfigFile {
 
    public:
 
        ConfigFile(const char *input_file_name);
 
        bool load_config(const char *input_file_name);
 
        int  num_keys();
 
        bool get_key(const char *key, int &value);
        bool get_key(const char *key, double &value);
        bool get_key(const char *key, std::string &value);
 
        void debug_put(const std::string key, const std::string val);
 
    private:
 
        std::map<std::string, std::string> config;  
};
typedef ConfigFile *pConfigFile;                    
 
 
class Logger {
 
    public:
 
         Logger(const char       *output_file_name);
         Logger(      ConfigFile  config,
                const char       *config_key);
        ~Logger();
 
        int  get_output_file_name(char *buff, int buff_size);
 
        void log       (int loglevel, const char *message);
        void log_printf(int loglevel, const char *fmt, ...);
        void log_printf(int loglevel, const char *fmt, va_list args);
 
#ifdef CATCH_TEST
        bool SkipLogOnce;
#endif
 
    private:
 
        void InitLogger();
 
        char file_name [MAX_FILENAME_LENGTH];   
        std::ofstream f_stream;                 
        std::filebuf *f_buff;                   
        TimePoint big_bang;                     
};
typedef Logger *pLogger;                        
 
 
class Service {
 
    public:
 
        Service(pLogger  a_logger,
                pConfigFile a_config);
 
        virtual StatusCode start    ();
        virtual StatusCode shut_down();
 
        virtual pChar const id();
 
        inline void log(int loglevel, const char *message) { if (p_log != nullptr) p_log->log(loglevel, message); }
 
        inline void log_printf(int loglevel, const char *fmt, ...) {
            if (p_log != nullptr) {
                va_list args;
                va_start(args, fmt);
                p_log->log_printf(loglevel, fmt, args);
                va_end(args);
            }
        }
 
        bool get_conf_key(const char *key, int &value) {
            if (p_conf != nullptr) return p_conf->get_key(key, value); else return false; }
 
        bool get_conf_key(const char *key, double &value) {
            if (p_conf != nullptr) return p_conf->get_key(key, value); else return false; }
 
        bool get_conf_key(const char *key, std::string &value) {
            if (p_conf != nullptr) return p_conf->get_key(key, value); else return false; }
 
        pLogger     p_log;      
        pConfigFile p_conf;     
};
typedef Service *pService;      
 
} // namespace jazz_elements
 
#endif // ifndef INCLUDED_JAZZ_ELEMENTS_UTILS