/* -*- C++ -*- */ // $Id$ // ============================================================================ // // = LIBRARY // ace // // = FILENAME // Reactor.h // // = AUTHOR // Irfan Pyarali // // ============================================================================ #ifndef ACE_REACTOR_H #define ACE_REACTOR_H class ACE_Reactor_Impl; // Need the class def for ACE_Handle_Set to compile references to it in // programs. #include "ace/Handle_Set.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ // Timer Queue is a complicated template class. A simple forward // declaration will not work #include "ace/Timer_Queue.h" // Event_Handler.h contains the definition of ACE_Reactor_Mask #include "ace/Event_Handler.h" // We are using 4 or 5 signal classes, we could forward declare // them.... But Timer_Queue_T.h includes Signal.h, so I don't think // forward declaration will be useful here #include "ace/Signal.h" class ACE_Export ACE_Reactor { // = TITLE // The resposiblility of this class is to forward all methods to // its delegation/implementation class, e.g., // or . public: enum { // = Operations on the "ready" mask and the "dispatch" mask. GET_MASK = 1, // Retrieve current value of the the "ready" mask or the // "dispatch" mask. SET_MASK = 2, // Set value of bits to new mask (changes the entire mask). ADD_MASK = 3, // Bitwise "or" the value into the mask (only changes enabled // bits). CLR_MASK = 4 // Bitwise "and" the negation of the value out of the mask (only // changes enabled bits). }; typedef int (*REACTOR_EVENT_HOOK)(void*); // You can add a hook to various run_event methods and the hook will // be called after handling every reactor event. If this function // returns 0, run_reactor_event_loop will check for the return value of // handle_event. If it is -1, the the run_reactor_event_loop will return // (pre-maturely.) static ACE_Reactor *instance (void); // Get pointer to a process-wide . static ACE_Reactor *instance (ACE_Reactor *, int delete_reactor = 0); // Set pointer to a process-wide and return existing // pointer. If != 0 then we'll delete the Reactor // at destruction time. static void close_singleton (void); // Delete the dynamically allocated Singleton // = Singleton reactor event loop management methods. // Note that these method ONLY work on the "Singleton Reactor," // i.e., the one returned from . static int run_event_loop (void); static int run_alertable_event_loop (void); // Run the event loop until the // // method returns -1 or the method is invoked. static int run_event_loop (ACE_Time_Value &tv); static int run_alertable_event_loop (ACE_Time_Value &tv); // Run the event loop until the or // methods returns -1, the // method is invoked, or the // expires. static int end_event_loop (void); // Instruct the to terminate its event loop // and notifies the so that it can wake up // and close down gracefully. static int event_loop_done (void); // Report if the 's event loop is finished. static void reset_event_loop (void); // Resets the static so that the // method can be restarted. static int check_reconfiguration (void *); // The singleton reactor is used by the service_configurator. // Therefore, we must check for the reconfiguration request and // handle it after handling an event. // = Reactor event loop management methods. // These methods work with an instance of a reactor. virtual int run_reactor_event_loop (REACTOR_EVENT_HOOK = 0); virtual int run_alertable_reactor_event_loop (REACTOR_EVENT_HOOK = 0); // Run the event loop until the // // method returns -1 or the method is invoked. virtual int run_reactor_event_loop (ACE_Time_Value &tv, REACTOR_EVENT_HOOK = 0); virtual int run_alertable_reactor_event_loop (ACE_Time_Value &tv, REACTOR_EVENT_HOOK = 0); // Run the event loop until the or // methods returns -1, the // method is invoked, or the // expires. virtual int end_reactor_event_loop (void); // Instruct the to terminate its event loop // and notifies the so that it can wake up // and close down gracefully. virtual int reactor_event_loop_done (void); // Report if the 's event loop is finished. virtual void reset_reactor_event_loop (void); // Resets the static so that the // method can be restarted. ACE_Reactor (ACE_Reactor_Impl *implementation = 0, int delete_implementation = 0); // Create the Reactor using . The flag // tells the Reactor whether or not to // delete the on destruction. virtual ~ACE_Reactor (void); // Close down and release all resources. virtual int open (size_t max_number_of_handles, int restart = 0, ACE_Sig_Handler *signal_handler = 0, ACE_Timer_Queue *timer_queue = 0); // Initialize the to manage . // If is non-0 then the 's // method will be restarted automatically when occurs. If // or are non-0 they are used as the // signal handler and timer queue, respectively. virtual int set_sig_handler (ACE_Sig_Handler *signal_handler); // Use a user specified signal handler instead. virtual int set_timer_queue (ACE_Timer_Queue *timer_queue); // Use a user specified timer queue instead. // Notice that I don't think you should mess with timer queue // once the Reactor is up and running. virtual int close (void); // Close down and release all resources. // = Event loop drivers. virtual int work_pending (const ACE_Time_Value &max_wait_time = ACE_Time_Value::zero); // Returns non-zero if there are I/O events "ready" for dispatching, // but does not actually dispatch the event handlers. By default, // don't block while checking this, i.e., "poll". virtual int handle_events (ACE_Time_Value *max_wait_time = 0); virtual int alertable_handle_events (ACE_Time_Value *max_wait_time = 0); // This event loop driver blocks for up to before // returning. It will return earlier if events occur. Note that // can be 0, in which case this method blocks // indefinitely until events occur. // // is decremented to reflect how much time this call // took. For instance, if a time value of 3 seconds is passed to // handle_events and an event occurs after 2 seconds, // will equal 1 second. This can be used if an // application wishes to handle events for some fixed amount of // time. // // Returns the total number of timers and I/O s // that were dispatched, 0 if the elapsed without // dispatching any handlers, or -1 if an error occurs. // // The only difference between and // is that in the alertable case, the eventloop will // return when the system queues an I/O completion routine or an // Asynchronous Procedure Call. virtual int handle_events (ACE_Time_Value &max_wait_time); virtual int alertable_handle_events (ACE_Time_Value &max_wait_time); // This method is just like the one above, except the // value is a reference and can therefore never be // NULL. // // The only difference between and // is that in the alertable case, the eventloop will // return when the system queues an I/O completion routine or an // Asynchronous Procedure Call. // = Register and remove Handlers. virtual int register_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask); // Register with . The I/O handle will always // come from on the . virtual int register_handler (ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask); // Register with . The I/O handle is provided // through the parameter. #if defined (ACE_WIN32) virtual int register_handler (ACE_Event_Handler *event_handler, ACE_HANDLE event_handle = ACE_INVALID_HANDLE); // Register an that will be notified when // is signaled. Since no event mask is passed // through this interface, it is assumed that the // being passed in is an event handle and not an I/O handle. // // Originally this interface was available for all platforms, but // because ACE_HANDLE is an int on non-Win32 platforms, compilers // are not able to tell the difference between // register_handler(ACE_Event_Handler*,ACE_Reactor_Mask) and // register_handler(ACE_Event_Handler*,ACE_HANDLE). Therefore, we // have restricted this method to Win32 only. #endif /* ACE_WIN32 */ virtual int register_handler (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask); // Register an that will be notified when // is signaled. specifies the network events // that the is interested in. virtual int register_handler (const ACE_Handle_Set &handles, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask); // Register with all the in the . virtual int register_handler (int signum, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp = 0, ACE_Event_Handler **old_sh = 0, ACE_Sig_Action *old_disp = 0); // Register to handle the signal using the // . Returns the that was previously registered // (if any), along with the of the signal handler. virtual int register_handler (const ACE_Sig_Set &sigset, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp = 0); // Registers to handle a set of signals using the // . virtual int remove_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask); // Removes . Note that the I/O handle will be // obtained using method of . If // == then the // method of the is not invoked. virtual int remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask mask); // Removes . If == // then the method of the associated // is not invoked. virtual int remove_handler (const ACE_Handle_Set &handle_set, ACE_Reactor_Mask mask); // Removes all handles in . If == // then the method of // the associated s is not invoked. virtual int remove_handler (int signum, ACE_Sig_Action *new_disp, ACE_Sig_Action *old_disp = 0, int sigkey = -1); // Remove the ACE_Event_Handler currently associated with . // Install the new disposition (if given) and return the previous // disposition (if desired by the caller). Returns 0 on success and // -1 if is invalid. virtual int remove_handler (const ACE_Sig_Set &sigset); // Calls for every signal in . // = Suspend and resume Handlers. virtual int suspend_handler (ACE_Event_Handler *event_handler); // Suspend temporarily. Use // to get the handle. virtual int suspend_handler (ACE_HANDLE handle); // Suspend temporarily. virtual int suspend_handler (const ACE_Handle_Set &handles); // Suspend all in handle set temporarily. virtual int suspend_handlers (void); // Suspend all temporarily. virtual int resume_handler (ACE_Event_Handler *event_handler); // Resume . Use to // get the handle. virtual int resume_handler (ACE_HANDLE handle); // Resume . virtual int resume_handler (const ACE_Handle_Set &handles); // Resume all in handle set. virtual int resume_handlers (void); // Resume all . // = Timer management. virtual long schedule_timer (ACE_Event_Handler *event_handler, const void *arg, const ACE_Time_Value &delta, const ACE_Time_Value &interval = ACE_Time_Value::zero); // Schedule an that will expire after amount // of time, which is specified as relative time to the current // . If it expires then is passed in as the // value to the 's callback method. // If is != to then it is used to // reschedule the automatically, also specified // using relative time. This method returns a that // uniquely identifies the in an internal list. // This can be used to cancel an before // it expires. The cancellation ensures that are unique // up to values of greater than 2 billion timers. As long as timers // don't stay around longer than this there should be no problems // with accidentally deleting the wrong timer. Returns -1 on // failure (which is guaranteed never to be a valid . virtual int reset_timer_interval (long timer_id, const ACE_Time_Value &interval); // Resets the interval of the timer represented by to // , which is specified in relative time to the current // . If is equal to // , the timer will become a non-rescheduling // timer. Returns 0 if successful, -1 if not. virtual int cancel_timer (ACE_Event_Handler *event_handler, int dont_call_handle_close = 1); // Cancel all s that match the address of // . Returns number of handlers cancelled. virtual int cancel_timer (long timer_id, const void **arg = 0, int dont_call_handle_close = 1); // Cancel the single that matches the // value, which was returned from the schedule method. If arg is // non-NULL then it will be set to point to the ``magic cookie'' // argument passed in when the Event_Handler was registered. This // makes it possible to free up the memory and avoid memory leaks. // Returns 1 if cancellation succeeded and 0 if the // wasn't found. // = High-level Event_Handler scheduling operations virtual int schedule_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_added); // Add to the 's entry. // must already have been registered. virtual int schedule_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_added); // Add to the 's entry. // associated with must already have been registered. virtual int cancel_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_cleared); // Clear from the 's entry. virtual int cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_cleared); // Clear from the 's entry. // = Notification methods. virtual int notify (ACE_Event_Handler *event_handler = 0, ACE_Reactor_Mask mask = ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *tv = 0); // Notify of event. The // indicates how long to blocking trying to notify. If == // 0, the caller will block until action is possible, else will wait // until the relative time specified in elapses). virtual void max_notify_iterations (int iterations); // Set the maximum number of times that ACE_Reactor will // iterate and dispatch the that are passed in // via the notify queue before breaking out of its // loop. By default, this is set to // -1, which means "iterate until the queue is empty." Setting this // to a value like "1 or 2" will increase "fairness" (and thus // prevent starvation) at the expense of slightly higher dispatching // overhead. virtual int max_notify_iterations (void); // Get the maximum number of times that the ACE_Reactor will // iterate and dispatch the that are passed in // via the notify queue before breaking out of its // loop. // = Assorted helper methods. virtual int handler (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **event_handler = 0); // Check to see if is associated with a valid Event_Handler // bound to . Return the associated with this // if != 0. virtual int handler (int signum, ACE_Event_Handler **event_handler = 0); // Check to see if is associated with a valid Event_Handler // bound to a signal. Return the associated with // this if != 0. virtual int initialized (void); // Returns true if Reactor has been successfully initialized, else // false. virtual size_t size (void); // Returns the current size of the Reactor's internal descriptor // table. virtual ACE_Lock &lock (void); // Returns a reference to the Reactor's internal lock. virtual void wakeup_all_threads (void); // Wake up all threads in waiting in the event loop virtual int owner (ACE_thread_t new_owner, ACE_thread_t *old_owner = 0); // Transfers ownership of Reactor to the . virtual int owner (ACE_thread_t *owner); // Return the ID of the "owner" thread. virtual void requeue_position (int position); // Set position of the owner thread. virtual int requeue_position (void); // Get position of the owner thread. virtual int restart (void); // Get the existing restart value. virtual int restart (int r); // Set a new value for restart and return the original value. // = Low-level wait_set mask manipulation methods. virtual int mask_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops); // GET/SET/ADD/CLR the dispatch mask "bit" bound with the // and . virtual int mask_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops); // GET/SET/ADD/CLR the dispatch MASK "bit" bound with the // and . // = Low-level ready_set mask manipulation methods. virtual int ready_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops); // GET/SET/ADD/CLR the ready "bit" bound with the // and . virtual int ready_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops); // GET/SET/ADD/CLR the ready "bit" bound with the and . virtual ACE_Reactor_Impl *implementation (void); // Get the implementation class virtual int current_info (ACE_HANDLE handle, size_t &msg_size); // Returns 0, if the size of the current message has been put in // returns -1, if not. ACE_HANDLE allows the reactor to // check if the caller is valid. Used for CLASSIX Reactor // implementation. virtual int uses_event_associations (void); // Return 1 if we any event associations were made by the reactor // for the handles that it waits on, 0 otherwise. ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. void dump (void) const; // Dump the state of the object. protected: virtual void implementation (ACE_Reactor_Impl *implementation); // Set the implementation class. ACE_Reactor_Impl *implementation_; // Delegation/implementation class that all methods will be // forwarded to. int delete_implementation_; // Flag used to indicate whether we are responsible for cleaning up // the implementation instance static ACE_Reactor *reactor_; // Pointer to a process-wide singleton. static int delete_reactor_; // Must delete the singleton if non-0. ACE_Reactor (const ACE_Reactor &); ACE_Reactor &operator = (const ACE_Reactor &); // Deny access since member-wise won't work... }; #if defined (__ACE_INLINE__) #include "ace/Reactor.i" #endif /* __ACE_INLINE__ */ #endif /* ACE_REACTOR_H */