ACE/examples/C++NPv2/WFMO_Reactor_Logging_Server.cpp

   1 /*
   2 ** Copyright 2002 Addison Wesley. All Rights Reserved.
   3 */
   4
   5 #include "ace/config-all.h"
   6
   7 #if defined (ACE_WIN32)
   8
   9 #include "ace/Reactor.h"
  10 #include "ace/WFMO_Reactor.h"
  11 #include "ace/Thread_Manager.h"
  12 #include "ace/OS_NS_string.h"
  13
  14 #include "Reactor_Logging_Server_T.h"
  15 #include "Logging_Acceptor_Ex.h"
  16 #include "Logging_Event_Handler_Ex.h"
  17
  18 class Quit_Handler : public ACE_Event_Handler {
  19 private:
  20   ACE_Manual_Event quit_seen_;
  21
  22 public:
  23   Quit_Handler (ACE_Reactor *r) : ACE_Event_Handler (r) {
  24     SetConsoleMode (ACE_STDIN, ENABLE_LINE_INPUT
  25                                | ENABLE_ECHO_INPUT
  26                                | ENABLE_PROCESSED_INPUT);
  27     if (reactor ()->register_handler
  28           (this, quit_seen_.handle ()) == -1
  29         || ACE_Event_Handler::register_stdin_handler
  30              (this, r, ACE_Thread_Manager::instance ()) == -1)
  31       r->end_reactor_event_loop ();
  32   }
  33
  34   ~Quit_Handler () {
  35     ACE_Event_Handler::remove_stdin_handler
  36       (reactor (), ACE_Thread_Manager::instance ());
  37     reactor ()->remove_handler (quit_seen_.handle (),
  38                                 ACE_Event_Handler::DONT_CALL);
  39   }
  40
  41   virtual int handle_input (ACE_HANDLE h) {
  42     CHAR user_input[BUFSIZ];
  43     DWORD count;
  44     if (!ReadFile (h, user_input, BUFSIZ, &count, 0))
  45       return -1;
  46
  47     user_input[count] = '\0';
  48     if (ACE_OS::strncmp (user_input, "quit", 4) == 0)
  49       return -1;
  50     return 0;
  51   }
  52
  53   virtual int handle_close (ACE_HANDLE, ACE_Reactor_Mask) {
  54     quit_seen_.signal ();
  55     return 0;
  56   }
  57
  58   virtual int handle_signal (int, siginfo_t *, ucontext_t *) {
  59     reactor ()->end_reactor_event_loop ();
  60     return 0;
  61   }
  62 };
  63
  64
  65 class Logging_Event_Handler_WFMO : public Logging_Event_Handler_Ex
  66 {
  67 public:
  68   Logging_Event_Handler_WFMO (ACE_Reactor *r)
  69     : Logging_Event_Handler_Ex (r) {}
  70
  71 protected:
  72   int handle_input (ACE_HANDLE) {
  73     ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, monitor, lock_, -1);
  74     return logging_handler_.log_record ();
  75   }
  76
  77   ACE_Thread_Mutex lock_; // Serialize threads in thread pool.
  78 };
  79
  80
  81 class Logging_Acceptor_WFMO : public Logging_Acceptor_Ex
  82 {
  83 public:
  84   // Simple constructor to pass ACE_Reactor to base class.
  85   Logging_Acceptor_WFMO (ACE_Reactor *r = ACE_Reactor::instance ())
  86     : Logging_Acceptor_Ex (r) {};
  87
  88 protected:
  89   virtual int handle_input (ACE_HANDLE) {
  90     Logging_Event_Handler_WFMO *peer_handler = 0;
  91     ACE_NEW_RETURN (peer_handler,
  92                     Logging_Event_Handler_WFMO (reactor ()),
  93                     -1);
  94
  95     if (acceptor_.accept (peer_handler->peer ()) == -1) {
  96       delete peer_handler;
  97       return -1;
  98     } else if (peer_handler->open () == -1) {
  99       peer_handler->handle_close ();
 100       return -1;
 101     }
 102     return 0;
 103   }
 104 };
 105
 106
 107 static ACE_THR_FUNC_RETURN event_loop (void *arg) {
 108   ACE_Reactor *reactor = static_cast<ACE_Reactor *> (arg);
 109
 110   reactor->owner (ACE_OS::thr_self ());
 111   reactor->run_reactor_event_loop ();
 112   return 0;
 113 }
 114
 115
 116 typedef Reactor_Logging_Server<Logging_Acceptor_WFMO>
 117         Server_Logging_Daemon;
 118
 119
 120 int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 121 {
 122   const size_t N_THREADS = 4;
 123   ACE_WFMO_Reactor wfmo_reactor;
 124   ACE_Reactor reactor (&wfmo_reactor);
 125
 126   Server_Logging_Daemon *server;
 127   // Ignore argv[0]...
 128   --argc; ++argv;
 129   ACE_NEW_RETURN (server,
 130                   Server_Logging_Daemon (argc, argv, &reactor),
 131                   1);
 132   Quit_Handler quit_handler (&reactor);
 133   ACE_Thread_Manager::instance ()->spawn_n
 134     (N_THREADS, event_loop, &reactor);
 135   return ACE_Thread_Manager::instance ()->wait ();
 136 }
 137
 138 #else /* !ACE_WIN32 */
 139 int ACE_TMAIN (int, ACE_TCHAR *[])
 140 {
 141   return 0;
 142 }
 143 #endif /* ACE_WIN32 */