server.h

/* $Id: server.h 2708 2011-12-24 14:02:14Z roma $ */
#ifndef _FFL_CSSC_SERVER_H_
#define _FFL_CSSC_SERVER_H_

#include <signal.h>
#include <queue>
#include <os.h>
#include "../../ipc/socket.h"
#include "../logbook.h"
#include "../request.h"
#include "../tag.h"

namespace ffl
{

        namespace cssc
        {

                namespace multithreaded
                {

                        class server
                        {
                        public:

                                class user
                                {
                                };

                                class processor;

                                class client;

                                struct signal
                                {

                                        static long Timeout;

                                        enum tag
                                        {
                                                NONE,                           
                                                READY,                          
                                                CLOSE,                          
                                                PERFORM,                        
                                                CANCEL,                         
                                        };
                                        
                                        unsigned char Tag;      

                                        client* Client;         

                                        signal() throw(){}

                                        signal(tag _t, client* _c = 0) throw():Tag(_t), Client(_c){}

                                        signal(const signal& _s) throw():Tag(_s.Tag), Client(_s.Client){}

                                };

                                class client:public ipc::socket
                                {
                                public:

                                        enum state
                                        {
                                                QUEUED = 1,                     
                                                PROCESSING,             
                                                COMPLETED,              
                                        } State;

                                        std::auto_ptr<user> User;

                                        processor* Processor;

                                        signal::tag (processor::*Action)(client* _c) throw(...);        

                                        client(server& _server, ipc::socket& _listener) throw(...):Server(_server), ipc::socket(_server.Environment, _listener), Processor(0), State(COMPLETED)
                                        {
                                                Server.Clients.push_back(this);
                                        }

                                        ~client()
                                        {
                                                Server.Clients.remove(this);
                                        }

                                        void write(const cssc::failure& _x, long _t) throw(...);

                                private:

                                        server& Server;

                                };

                                class processor:public os_thread
                                {
                                public:

                                        void enqueue(signal::tag _t) throw(...);

                                        void enqueue(signal::tag _t, client* _c) throw(...);

                                        void dequeue(signal& _s) throw(...);

                                        std::auto_ptr<ipc::socket> Processor;

                                        std::auto_ptr<ipc::socket> Dispatcher;

                                        int QueueSize;  

                                        static const long IOTimeout;

                                        signal::tag do_authorize(client* _c) throw(...);

                                        signal::tag do_request(client* _c) throw(...);

                                        processor(server& _server, const char* _log) throw(...);

                                        bool inactive() throw(){return getstate() != 0;}

                                        void cancel() throw(){}

                                        logbook Log;

                                        static processor* self() throw(){return Self;}
        
                                protected:

                                        server& Server;

                                        int run() throw();

                                        virtual void idle() throw(){Log.timestamp("idle");}

                                        virtual user* authorize(const char* _name, const char* _pass) throw(...){throw cssc::failure("SERV", "0001","Authorization failed"); return 0;}

                                        virtual void process(user& _u, request& _r) throw(...){}

                                        virtual void trace_exception(const user& _u) throw(){}

                                        void checkpoint() throw(...);

                                private:

                                        static __declspec(thread) processor* Self;

                                        client* Client;

                                };
        
                                server
                                        (
                                                size_t _max_users, 
                                                size_t _max_processors, 
                                                const char* _log_name,
                                                long _idle_timeout = 5000
                                        ) throw():MaxClients(_max_users), MaxProcessors(_max_processors), Log(_log_name), CountProcessors(0),
                                              IdleTimeout(_idle_timeout)
                                {}
        
                                void run(const char* _host, const char* _service) throw(...);
        
                                void cancel() throw();

                        protected:

                                virtual void idle() throw(...);

                                virtual void trace_request(const user& _u) throw(){}

                                virtual void just_started() throw(){}

                                virtual void just_ready() throw(){}

                                virtual void just_canceled() throw(){}

                                virtual processor* scale(const char* _log_name) throw(...)
                                {
                                        return new processor(*this, _log_name);
                                }

                                logbook         Log;    
        
                        private:

                                ipc::socket::environment Environment;

                                size_t MaxClients;      

                                size_t MaxProcessors;   

                                size_t CountProcessors; 

                                long IdleTimeout;       

                                std::list<processor*>   Processors;     

                                std::list<ipc::socket*> Listeners;      // Список слушающих сокетов.

                                std::list<client*>      Clients;        

                                void initialize_listeners(const char* _n, const char* _s) throw(...);

                                volatile sig_atomic_t Cancel;   

                                void dispatch(client* _c) throw(...);

                                void sweep_out_inactive_processors() throw();

                                void dismiss(client* _c) throw();

                        };

                }
        
        }

}

#endif