SnoopPrivate.hh

Go to the documentation of this file.

 
#pragma once
 
#include <websocketpp/config/asio_no_tls_client.hpp>
#include <websocketpp/client.hpp>
#include <websocketpp/common/thread.hpp>
#include <websocketpp/common/functional.hpp>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <set>
 
typedef websocketpp::client<websocketpp::config::asio_client> WebsocketClient;
typedef websocketpp::config::asio_client::message_type::ptr   message_ptr;
 
namespace snoop {
    
    class SnoopImpl {
        public:
            SnoopImpl(Snoop *);
            ~SnoopImpl();
 
         Snoop& operator<<(const Flush&);
 
 
            void init(const std::string& app_name, const std::string& app_version, 
                         std::string server="", std::string local_database_name="");
 
 
            std::string get_user_uuid(const std::string& app_name);
 
            Snoop& payload(const std::vector<char>&);
 
 
            Snoop& operator()(const std::string& type, std::string fl="", int loc=-1, std::string method="");
 
         void set_local_type(const std::string& type);
 
 
            void sync_with_server(bool from_wsthread=false);
            
 
            void sync_runs_with_server(bool from_wsthread=false);
            
 
            void sync_logs_with_server(bool from_wsthread=false);
 
 
            void sync_payloads_with_server(bool from_wsthread=false);
 
 
         bool is_connected() const;         
 
         
         std::string last_seen_version(std::string machine_id);
 
 
          bool authenticate(std::function<void (std::string, bool)>, std::string user="", std::string pass="");
 
 
         bool is_ticket_valid(std::string ticket_uuid);
 
 
         std::string ticket_for_login(std::string user, std::string password);
         
 
         bool add_user(std::string user, std::string password);
 
          Snoop             *snoop_;
 
          sqlite3           *db, *payload_db, *auth_db;
            
            Snoop::AppEntry    this_app_;
            Snoop::LogEntry    this_log_;
            std::string        server_;
 
 
            void start_websocket_client();
 
 
            void create_tables();
 
 
          void create_authentication_tables();
 
 
            void obtain_uuid();
 
 
            bool store_app_entry(Snoop::AppEntry&);
            bool store_app_entry_without_lock(Snoop::AppEntry&);
 
 
            bool store_log_entry(Snoop::LogEntry&, bool avoid_server_duplicates);
 
 
            bool store_payload_entry(Snoop::PayLoad&);
            
 
            std::vector<Snoop::AppEntry> get_app_registrations(std::string uuid_filter="");
 
            
            sqlite3_stmt *insert_statement, *id_for_uuid_statement, *payload_insert_statement;
            std::mutex    sqlite_mutex;
 
            
            WebsocketClient                 wsclient;
            std::thread                     wsclient_thread;
            std::mutex                      connection_mutex;
            std::condition_variable         connection_cv;
            bool                            connection_is_open, connection_attempt_failed;
            WebsocketClient::connection_ptr connection;
            websocketpp::connection_hdl     our_connection_hdl;
            
            void on_client_open(websocketpp::connection_hdl hdl);
            void on_client_fail(websocketpp::connection_hdl hdl);
            void on_client_close(websocketpp::connection_hdl hdl);
            void on_client_message(websocketpp::connection_hdl hdl, message_ptr msg);
 
        private:
            std::mutex   call_mutex;
            bool         secure;
 
          std::set<std::string> local_types;
//        std::set<std::string> ...
         std::function<void (std::string, bool)> authentication_callback;
 
          void store_ticket(std::string ticket_uuid, int user_id, bool valid);
    };
}