cave/cave.h

/*--------------------------------------------------------------------------

  This is part of the testing system of the Karoo project.

  (C) 2009 Brian Modra <brian@zwartberg.com>

  This library is free software; you can redistribute them and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License,
  or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with these libraries; if not, write to the Free Software Foundation,
  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

--------------------------------------------------------------------------*/
#ifndef cave_h
#define cave_h

#ifndef _REENTRANT
#define _REENTRANT
#endif

#include "config.h"
#include "data.h"
#include "log.h"
#include "rock.h"
#include "util.h"
#include "db.h"
#include "fab.h"
#include "stream.h"
#include "cave_protocol.h"
#include <pqxx/pqxx>
#include <vector>
#include <map>

using std::vector;
using std::map;

namespace karoo {

    class cave_handler;
    class cave_service;
    class cave_element;

    class cave : public rock
    {
    public:
        class mime_type : public referable
        {
        public:
            text ext;
            text type;
            mime_type(const text& ext, const text& type) { this->ext = ext; this->type = type; }
            virtual ~mime_type() {}
        };
    private:
        text root;

        int http_port;
        time_t http_timeout;
        stream_service* service;
        stream_factory* factory;
        HTTP_handler_factory* handler_factory;
        khashe mime_types;
        exeque* listenq;
        exeque* streamq;
        exeque* httpq;

        db* database;
        mutable karoo_mutex db_sem;
        mutable karoo_mutex service_sem;
        map<text,cave_service*> services;

        class cave_config: public pebble
        {
        private:
            time_t poll_delay;
            cave* parent;
            text url;
            text dbname;
            map<text,cave_service*> services;
            cave_service* getService(const text& id);
            void add(const text& id, cave_service* svc);
            text connection_str;
            size_t connection_pool_size;
        public:
            cave_config(cave* parent, text url, time_t poll_delay);
            virtual ~cave_config();

            void run();
            bool traverse(fab& conf, nxml_data_t* node, cave_element* context);
        };
    public:
        cave(const vector<text>& opts, int argc, char *argv[]);
        void startup(const text& url, time_t poll_delay);
        virtual ~cave();

        void stop();
        text getType() const { return "cave"; }
        void initialiseDatabase(const text& conf, size_t pool_sz = 1);
        void initialiseDatabaseAndServices(const text& conf, size_t pool_sz, map<text,cave_service*>& services);
        cave_service* getService(const text& id);
        void add(const text& id, cave_service* svc);
        db* getDatabase() { return database; }
        void clearServices();

        bool getMimeType(const text& ext, text& type);
        void setMimeType(const text& ext, const text& type);
        text getRoot() const { return root; }
    };

    class cave_HTTP_handler_factory: public HTTP_handler_factory {
    private:
        cave* parent;
    public:
        cave_HTTP_handler_factory(cave* parent) { this->parent = parent; }
        virtual ~cave_HTTP_handler_factory() {}
            
        HTTP_handler* create_HTTP_handler(HTTP_parsed_data* data);
    };

    class cave_HTTP_handler: public HTTP_handler {
    private:
        cave* parent;
        bool head;
        size_t length;
    public:
        cave_HTTP_handler(HTTP_parsed_data* data, cave* parent, bool head = false);
        virtual ~cave_HTTP_handler();
            
        virtual bool run();

        void writeBack(const text& column_name, uint32_t uval, uint32_t row_count, cave_service* service);
        void writeBack(const text& column_name, uint64_t uval, uint32_t row_count, cave_service* service);
        void writeBack(const text& column_name, int32_t ival, uint32_t row_count, cave_service* service);
        void writeBack(const text& column_name, int64_t ival, uint32_t row_count, cave_service* service);
        void writeBack(const text& column_name, double dval, uint32_t row_count, cave_service* service);
        void writeBack(const text& column_name, long double ldval, uint32_t row_count, cave_service* service);
        void writeBack(const text& column_name, const text& tval, uint32_t row_count, cave_service* service);
    };

    
    class cave_handler: public rock_datagram_message_handler
    {
    public:
        cave_handler(cave* parent) : rock_datagram_message_handler(parent) {}
        virtual ~cave_handler() {}
        bool handle(uint32_t msg_type, uint64_t seq, int32_t port, const text& name, rock_datagram_message* msg);
    };

    class cave_context_data: public referable
    {
    public:
        union {
            uint8_t      u8;
            bool          b;
            char          c;
            uint16_t    u16;
            uint32_t    u32;
            uint64_t    u64;
            int8_t       i8;
            int16_t     i16;
            int32_t     i32;
            int64_t     i64;
            float         f;
            double        d;
            long double  ld;
        } val;
        text s;
        
        enum db_data_type type;

        cave_context_data() {}
        virtual ~cave_context_data() {}
    };

    class cave_service;

    class cave_context: public pebble
    {
    private:
        cave_service* service;
        cave_handler* handler;
        cave_HTTP_handler* http_handler;
        uint32_t msg_type;
        uint64_t seq;
        int32_t port;
        text name;
        rock_datagram_message* msg;
        text reply_id_string;
        uint64_t reply_id_number;
        map<text,cave_context_data*> params;
    public:
        cave_context(cave_service* service, cave_HTTP_handler* http_handler);
        cave_context(cave_service* service, cave_handler* handler, uint32_t msg_type, uint64_t seq, int32_t port, const text& name, rock_datagram_message* msg, const text& reply_id_string, uint64_t reply_id_number);
        virtual ~cave_context();

        void setParameter(const text& key, cave_context_data* val);
        const cave_context_data* getParameter(const text& key) const;

        cave_service* getService() { return service; }
        cave_handler* getHandler() { return handler; }
        cave_HTTP_handler* getHTTPHandler() { return http_handler; }
        uint32_t getMsgType() const { return msg_type; }
        uint64_t getSeq() const { return seq; }
        int32_t getPort() const { return port; }
        text getName() const { return name; }
        const rock_datagram_message* getMessage() const { return msg; }
        text getReplyIdString() const { return reply_id_string; }
        uint64_t getReplyIdNumber() const { return reply_id_number; }
        void run();
    };

    enum cave_element_type {
        CAVE_ELEMENT_TYPE_SERVICE = 0,
        CAVE_ELEMENT_TYPE_SQL,
    };

    class cave_element: public referable
    {
    protected:
        enum cave_element_type type;
    public:
        cave_element(enum cave_element_type type) { this->type = type; }
        virtual ~cave_element() {}
        enum cave_element_type getType() const { return type; }
        virtual void run(cave_context* context) = 0;
    };

    class cave_sql;

    class cave_service: public cave_element
    {
    private:
        text name;
        text id;
        vector<cave_sql*> sqls;
        karoo_mutex sqls_sem;
        cave* parent;
    public:
        cave_service(cave* parent, const text& name, const text& id);
        virtual ~cave_service();
        void add(cave_sql*);
        cave* getParent() { return parent; }

        void run(cave_context* context);
    };

    class cave_sql_component;

    class cave_sql: public cave_element
    {
    private:
        vector<cave_sql_component*> components;
        karoo_mutex components_sem;
        cave_service* parent;
        bool commit;
    public:
        cave_sql(cave_service* parent, bool commit);
        virtual ~cave_sql();
        void add(cave_sql_component* component);

        void run(cave_context* context);
        cave_service* getParent() { return parent; }
    };

    enum cave_sql_component_type {
        CAVE_SQL_COMPONENT_TYPE_TEXT = 0,
        CAVE_SQL_COMPONENT_TYPE_PARAMETER,
    };

    class cave_sql_component: public referable
    {
    protected:
        enum cave_sql_component_type type;
        cave_context* context;
    public:
        cave_sql_component(enum cave_sql_component_type type) { this->type = type; }
        virtual ~cave_sql_component() {}
        void setContext(cave_context* context) { this->context = context; }
        virtual void writeOut(text& out) const = 0;
    };

    extern text& operator<<(text& out, const cave_sql_component& component);

    class cave_sql_text : public cave_sql_component
    {
    private:
        text value;
    public:
        cave_sql_text(const text& value);
        virtual ~cave_sql_text();
        void writeOut(text& out) const;
    };

    enum cave_sql_parameter_type {
        CAVE_SQL_PARAMETER_TYPE_QUOTED_STRING = 0,
        CAVE_SQL_PARAMETER_TYPE_IMAGE,
        CAVE_SQL_PARAMETER_TYPE_ESCAPED_STRING,
        CAVE_SQL_PARAMETER_TYPE_BOOLEAN,
        CAVE_SQL_PARAMETER_TYPE_INTEGER,
        CAVE_SQL_PARAMETER_TYPE_UNSIGNED,
        CAVE_SQL_PARAMETER_TYPE_FLOAT,
    };

    class cave_sql_parameter: public cave_sql_component
    {
    private:
        cave_sql* parent;
        text name;
        enum cave_sql_parameter_type type;
        unsigned width;
        unsigned height;
    public:
        cave_sql_parameter(cave_sql* parent, const text& name, enum cave_sql_parameter_type type, unsigned width = 0, unsigned height = 0);
        virtual ~cave_sql_parameter();
        void writeOut(text& out) const;
    };
}

#endif

---