From 958011c1b5df5b65e5a38a40d9f799ff4ab618e3 Mon Sep 17 00:00:00 2001 From: jai Date: Mon, 26 May 2008 16:34:04 +0000 Subject: added FLARe directory --- TAO/orbsvcs/examples/FaultTolerance/FLARe/Agent.h | 97 +++++ .../examples/FaultTolerance/FLARe/AppOptions.h | 63 +++ .../FaultTolerance/FLARe/AppSideMonitor_Handler.h | 40 ++ .../FaultTolerance/FLARe/AppSideMonitor_Thread.h | 44 ++ .../examples/FaultTolerance/FLARe/AppSideReg.h | 46 +++ .../examples/FaultTolerance/FLARe/ArgPair.h | 17 + .../FaultTolerance/FLARe/CPULoadCalculator.h | 19 + .../FaultTolerance/FLARe/Client_ORBInitializer.h | 54 +++ .../FLARe/Client_Request_Interceptor.h | 83 ++++ .../FaultTolerance/FLARe/Failure_Handler.h | 64 +++ .../examples/FaultTolerance/FLARe/HMOptions.h | 67 +++ TAO/orbsvcs/examples/FaultTolerance/FLARe/Hello.h | 29 ++ .../FaultTolerance/FLARe/HostMonitorImpl.h | 55 +++ .../FaultTolerance/FLARe/IOR_Interceptor.h | 64 +++ .../FaultTolerance/FLARe/LinuxCPULoadCalculator.h | 34 ++ .../examples/FaultTolerance/FLARe/Monitor_Thread.h | 34 ++ .../FaultTolerance/FLARe/ObjectReferenceFactory.h | 65 +++ .../examples/FaultTolerance/FLARe/RMOptions.h | 55 +++ .../examples/FaultTolerance/FLARe/RM_Proxy.h | 37 ++ .../FaultTolerance/FLARe/ReplicationManager.h | 460 +++++++++++++++++++++ .../FaultTolerance/FLARe/ServerORBInitializer.h | 50 +++ TAO/orbsvcs/examples/FaultTolerance/FLARe/Timer.h | 66 +++ .../FaultTolerance/FLARe/Utilization_Monitor.h | 37 ++ 23 files changed, 1580 insertions(+) create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/Agent.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/AppOptions.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/AppSideMonitor_Handler.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/AppSideMonitor_Thread.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/AppSideReg.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/ArgPair.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/CPULoadCalculator.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/Client_ORBInitializer.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/Client_Request_Interceptor.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/Failure_Handler.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/HMOptions.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/Hello.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/HostMonitorImpl.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/IOR_Interceptor.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/LinuxCPULoadCalculator.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/Monitor_Thread.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/ObjectReferenceFactory.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/RMOptions.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/RM_Proxy.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/ReplicationManager.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/ServerORBInitializer.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/Timer.h create mode 100644 TAO/orbsvcs/examples/FaultTolerance/FLARe/Utilization_Monitor.h diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/Agent.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Agent.h new file mode 100644 index 00000000000..8cd120eb2e5 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Agent.h @@ -0,0 +1,97 @@ +// cvs-id : $Id$ + +#ifndef AGENT_H +#define AGENT_H + +#include "LWFTS.h" +#include "ace/Hash_Map_Manager_T.h" +#include "ace/Unbounded_Queue.h" + +#include + +struct AGENT_RANKED_IOR_LIST +{ + bool now; + std::list ior_list; +}; + + +class Agent_i : public virtual POA_Agent +{ +public: + Agent_i (bool proactive = true); + + ~Agent_i (void); + + virtual CORBA::Object_ptr next_member (const char * m + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + virtual void update_rank_list (const RankList & rank_list + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + void initialize (CORBA::Object_ptr); + void proactive(bool v); + +/* + virtual void update_reference (const char * m + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + virtual void update_failover (const char * object_id, + CORBA::Object_ptr next_object + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + virtual void update_secondary (const char * object_id, + CORBA::Object_ptr next_member + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + + virtual void initialize_agent (const ReplicaList & replica_list, + const ReplicasList & replicas_list + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + + virtual void update_failover_list (const FailoverList &failover_list + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + CORBA::Object_var, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> REPLICA_MAP; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + CORBA::ULong, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> FAILURE_MAP; +*/ + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + AGENT_RANKED_IOR_LIST, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> OBJECTID_RANKED_IOR_MAP; + + +private: + //CORBA::String_var forward_str_; + //REPLICA_MAP failover_map_; + //REPLICA_MAP secondary_map_; + //FAILURE_MAP failure_map_; + ReplicationManager_var RM_var_; + OBJECTID_RANKED_IOR_MAP objectid_rankedior_map_; + ACE_Thread_Mutex ior_map_mutex_; + bool proactive_; + size_t update_count_; +}; + +#endif /* AGENT_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/AppOptions.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/AppOptions.h new file mode 100644 index 00000000000..a1c061f6e8c --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/AppOptions.h @@ -0,0 +1,63 @@ +/** + * @file AppOptions.h + * + * @brief Declared the AppOptions class interface. + * + */ + +#ifndef _APPOPTIONS_H +#define _APPOPTIONS_H + +#include +#include +#include "ace/Thread_Mutex.h" +#include "ArgPair.h" + +/** + * @class AppOptions + * + * @brief Declares AppOptions singleton to hold the command line options. + */ + +class AppOptions +/// TITLE +/// Singleton class for the program options. +{ +public: + + /// Singleton access method. + static AppOptions *instance (void); + + /// Parse command-line arguments and set the appropriate values as + /// follows: + bool parse_args (int argc, char **argv); + std::string host_id () const; + std::string host_monitor_ior () const; + size_t get_port () const; + std::string ior_output_file () const; + std::string object_info_file () const; + std::string process_id () const; + ArgPair arg_pair () const; + + +protected: + + /// Constructor is protected to ensure Singleton access. + AppOptions (void); + + std::string host_monitor_ior_; + std::string host_id_; + size_t port_; + std::string ior_output_file_; + std::string object_info_file_; + std::string process_id_; + ArgPair arg_pair_; + + /// Singleton instance. + static AppOptions * volatile instance_; + static std::auto_ptr deleter_; + static ACE_Thread_Mutex lock_; +}; + + +#endif /* _APPOPTIONS_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/AppSideMonitor_Handler.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/AppSideMonitor_Handler.h new file mode 100644 index 00000000000..bf782cd84a6 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/AppSideMonitor_Handler.h @@ -0,0 +1,40 @@ +/** + * @file C++ Interface: AppSideMonitor_Handler + * + * @brief Declares interface for AppSideMonitor_Handler. + * + */ + +#ifndef __APPSIDEMONITOR_HANDLER_H_ +#define __APPSIDEMONITOR_HANDLER_H_ + +#include "ace/Svc_Handler.h" +#include "ace/SOCK_Acceptor.h" +#include "ace/Acceptor.h" + +/** + * @class AppSideMonitor_Handler + * + * @brief Encapsulates AppSideMonitor_Handler + */ + +class AppSideMonitor_Handler : public ACE_Svc_Handler +{ + public: + + typedef ACE_Svc_Handler super; + typedef ACE_Acceptor FactoryAcceptor; + + //private: + AppSideMonitor_Handler (); + public: + + virtual int handle_input (ACE_HANDLE fd); + virtual int open (void *factory); + + private: + FactoryAcceptor *acceptor_; +}; + +#endif /// __APPSIDEMONITOR_HANDLER_H_ + diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/AppSideMonitor_Thread.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/AppSideMonitor_Thread.h new file mode 100644 index 00000000000..d8c30519b4f --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/AppSideMonitor_Thread.h @@ -0,0 +1,44 @@ +/** + * @file C++ Interface: AppSideMonitor_Thread + * + * @brief Declares interface for AppSideMonitor_Thread. + * + */ + +#ifndef __APPSIDEMONITOR_THREAD_H_ +#define __APPSIDEMONITOR_THREAD_H_ + +#include "ace/Task.h" +#include "ace/SOCK_Acceptor.h" +#include "ace/Reactor.h" +#include "ace/Barrier.h" +#include "ace/Acceptor.h" + +#include "AppSideMonitor_Handler.h" + +/** + * @class AppSideMonitor_Thread + * + * @brief Encapsulates AppSideMonitor_Thread + */ + +class AppSideMonitor_Thread : public ACE_Task_Base +{ +public: + + AppSideMonitor_Thread (ACE_Barrier *thread_barrier); + + void stop (); + virtual int svc (void); + +private: + size_t port_; + ACE_SOCK_Acceptor::PEER_ADDR serv_addr_; + ACE_Reactor reactor_; + ACE_Acceptor acceptor_; + ACE_Barrier *synchronizer_; +}; + + + +#endif /// __APPSIDEMONITOR_THREAD_H_ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/AppSideReg.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/AppSideReg.h new file mode 100644 index 00000000000..98ff84e2db8 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/AppSideReg.h @@ -0,0 +1,46 @@ +/** + * @file C++ Interface: AppSideReg + * + * @brief Declares interface for AppSideReg. + * + */ + +#ifndef __APPSIDEREG_H_ +#define __APPSIDEREG_H_ + +#include "ace/Task.h" + +#include "monitorC.h" +#include "AppSideMonitor_Thread.h" + +#include + +/** + * @class AppSideReg + * + * @brief Encapsulates AppSideReg + */ + +class ACE_Barrier; + +class AppSideReg : public ACE_Task_Base +{ +public: + AppSideReg(ACE_Barrier *ext_b, CORBA::ORB_ptr); + + ~AppSideReg(); + + virtual int svc (void); + void unregister_process (void); + +private: + std::string HM_ior_; + std::auto_ptr monitor_; + HostMonitor_var hmvar_; + CORBA::ORB_var orb_; + ACE_Barrier *external_barrier_; +}; + + + +#endif /// __APPSIDEREG_H_ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/ArgPair.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/ArgPair.h new file mode 100644 index 00000000000..873316b3531 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/ArgPair.h @@ -0,0 +1,17 @@ +#ifndef _ARGPAIR_H +#define _ARGPAIR_H + +struct ArgPair +{ + ArgPair (int argc, char **argv); + ~ArgPair (); + ArgPair (const ArgPair &); + ArgPair & operator = (const ArgPair &); + void swap (ArgPair &); + + int argc; + char **argv; +}; + +#endif /// _ARGPAIR_H + diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/CPULoadCalculator.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/CPULoadCalculator.h new file mode 100644 index 00000000000..82053c7b180 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/CPULoadCalculator.h @@ -0,0 +1,19 @@ +/** + * @file C++ Interface: CPULoadCalculator + * + * @brief Declares interface for CPULoadCalculator. + * + */ + +#ifndef __CPULOADCALCULATOR_H +#define __CPULOADCALCULATOR_H + +class CPULoadCalculator +{ + public: + virtual double percent_load (void) = 0; + virtual ~CPULoadCalculator () {} +}; + + +#endif /// __CPULOADCALCULATOR_H diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/Client_ORBInitializer.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Client_ORBInitializer.h new file mode 100644 index 00000000000..f78de24fcea --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Client_ORBInitializer.h @@ -0,0 +1,54 @@ +// -*- C++ -*- + +#ifndef TAO_CLIENT_ORB_INITIALIZER_H +#define TAO_CLIENT_ORB_INITIALIZER_H + +#include /**/ "ace/pre.h" + +#include "tao/PI/PI.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#if TAO_HAS_INTERCEPTORS == 1 + +#include "tao/LocalObject.h" + +// This is to remove "inherits via dominance" warnings from MSVC. +// MSVC is being a little too paranoid. +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +class Agent_i; + +/// Client side ORB initializer. +class Client_ORBInitializer : + public virtual PortableInterceptor::ORBInitializer, + public virtual TAO_Local_RefCounted_Object +{ +public: + + Client_ORBInitializer (Agent_i *agent); + + ~Client_ORBInitializer (void); + + virtual void pre_init (PortableInterceptor::ORBInitInfo_ptr info); + + virtual void post_init (PortableInterceptor::ORBInitInfo_ptr info); + +private: + Agent_i *agent_; +}; + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + +#include /**/ "ace/post.h" + +#endif /* TAO_CLIENT_ORB_INITIALIZER_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/Client_Request_Interceptor.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Client_Request_Interceptor.h new file mode 100644 index 00000000000..0e80b6570a3 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Client_Request_Interceptor.h @@ -0,0 +1,83 @@ +// -*- C++ -*- + +#ifndef CLIENT_REQUEST_INTERCEPTOR_H +#define CLIENT_REQUEST_INTERCEPTOR_H + +#include "ace/config-all.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/PI/PI.h" +#include "tao/PortableInterceptorC.h" +#include "tao/LocalObject.h" +#include "tao/ORB.h" +#include "tao/CORBA_String.h" + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +class Agent_i; + +class Client_Request_Interceptor + : public virtual PortableInterceptor::ClientRequestInterceptor, + public virtual TAO_Local_RefCounted_Object +{ +public: + + /// Constructor. + Client_Request_Interceptor (const char *orb_id, Agent_i *agent); + + /** + * @name Methods Required by the Client Request Interceptor + * Interface + * + * These are methods that must be implemented since they are pure + * virtual in the abstract base class. They are the canonical + * methods required for all client request interceptors. + */ + //@{ + /// Return the name of this ClientRequestinterceptor. + virtual char * name (void); + + virtual void destroy (void); + + virtual void send_request ( + PortableInterceptor::ClientRequestInfo_ptr ri); + + virtual void send_poll ( + PortableInterceptor::ClientRequestInfo_ptr ri); + + virtual void receive_reply ( + PortableInterceptor::ClientRequestInfo_ptr ri); + + virtual void receive_exception ( + PortableInterceptor::ClientRequestInfo_ptr ri); + + virtual void receive_other ( + PortableInterceptor::ClientRequestInfo_ptr ri); + //@} + +private: + + ///The ID of the ORB this interceptor is registered with. + CORBA::String_var orb_id_; + + /// Pseudo-reference to the ORB this interceptor is registered + /// with. + CORBA::ORB_var orb_; + + /// The number of requests intercepted by this interceptor. + CORBA::ULong request_count_; + + Agent_i *agent_; +}; + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#endif /* CLIENT_REQUEST_INTERCEPTOR_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/Failure_Handler.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Failure_Handler.h new file mode 100644 index 00000000000..b03b1f00e35 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Failure_Handler.h @@ -0,0 +1,64 @@ +/** + * @file C++ Interface: Failure_Handler + * + * @brief Declares interface for Failure_Handler. + * + */ + +#ifndef __FAILURE_HANDLER_H_ +#define __FAILURE_HANDLER_H_ + +#include + +struct ProcessInfo +{ + ProcessInfo () {} + ProcessInfo (const std::string &pid, + const std::string &hn, + size_t port); + + std::string process_id; + std::string hostname; + size_t port; +}; + + +/** + * @class Failure_Handler + * + * @brief Encapsulates Failure_Handler + */ + +#include "ace/Svc_Handler.h" +#include "ace/Map_Manager.h" +#include "ace/SOCK_Connector.h" +#include "ace/Connector.h" + +class HostMonitorImpl; + +class Failure_Handler : public ACE_Svc_Handler +{ + public: + typedef ACE_Map_Manager ProcessInfoMap; + typedef ACE_Svc_Handler super; + typedef ACE_Connector FactoryConnector; + + Failure_Handler (); + + virtual int handle_input (ACE_HANDLE fd); + virtual int open (void *factory); + + void set_host_monitor (HostMonitorImpl *hm); + int watch_process (ACE_HANDLE fd, const std::string &process_id, const std::string &hostname, size_t port); + int drop_process (ACE_HANDLE fd); + + private: + static ProcessInfoMap process_map_; + FactoryConnector *connector_factory_; + HostMonitorImpl *host_monitor_; +}; + + + + +#endif /// __FAILURE_HANDLER_H_ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/HMOptions.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/HMOptions.h new file mode 100644 index 00000000000..3298cf40179 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/HMOptions.h @@ -0,0 +1,67 @@ +/** + * @file HMOptions.h + * + * @brief Declared the HMOptions class interface. + * + */ + +#ifndef _HMOPTIONS_H +#define _HMOPTIONS_H + +#include +#include +#include "ace/Thread_Mutex.h" + + +/** + * @class HMOptions + * + * @brief Declares HMOptions singleton to hold the command line options. + */ + +#include "ArgPair.h" + +class HMOptions +/// TITLE +/// Singleton class for the program options. +{ +public: + + /// Singleton access method. + static HMOptions *instance (void); + + /// Parse command-line arguments and set the appropriate values as + /// follows: + bool parse_args (int argc, char **argv); + std::string RM_ior () const; + std::string HM_ior_file () const; + std::string host_id () const; + int RM_update_freq () const; + int load_monitor_freq () const; + std::string util_file () const; + ArgPair arg_pair (); + std::pair ior_access () const; + + +protected: + + /// Constructor is protected to ensure Singleton access. + HMOptions (void); + + std::string RM_ior_; + std::string host_id_; + std::string HM_ior_file_; + std::string util_file_; + ArgPair arg_pair_; + size_t RM_update_freq_; + size_t load_monitor_freq_; + std::pair ior_access_; + + /// Singleton instance. + static HMOptions * volatile instance_; + static std::auto_ptr deleter_; + static ACE_Thread_Mutex lock_; +}; + + +#endif /* _APPOPTIONS_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/Hello.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Hello.h new file mode 100644 index 00000000000..d93950d2bb9 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Hello.h @@ -0,0 +1,29 @@ +// +// $Id$ +// + +#ifndef HELLO_H +#define HELLO_H +#include /**/ "ace/pre.h" +#include "LWFTS.h" + +class Hello_i + : public virtual POA_Hello +{ +public: + /// Constructor + Hello_i (CORBA::ORB_ptr orb); + + // = The skeleton methods + virtual char * get_string (void); + + virtual void shutdown (void); + +private: + /// Use an ORB reference to conver strings to objects and shutdown + /// the application. + CORBA::ORB_var orb_; +}; + +#include /**/ "ace/post.h" +#endif /* HELLO_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/HostMonitorImpl.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/HostMonitorImpl.h new file mode 100644 index 00000000000..87b1b45a2fb --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/HostMonitorImpl.h @@ -0,0 +1,55 @@ +#ifndef __HOSTMONITORIMPL_H +#define __HOSTMONITORIMPL_H + +#include "monitorS.h" +#include "LWFTS.h" + +#include "ace/Map_Manager.h" +#include "ace/Event_Handler.h" +#include "ace/Thread_Mutex.h" +#include "ace/SOCK_Connector.h" + +#include "Failure_Handler.h" +#include "Utilization_Monitor.h" +#include "RM_Proxy.h" +#include + +class Monitor_Thread; + +class HostMonitorImpl : public virtual POA_HostMonitor +{ +public: + + typedef ACE_Map_Manager ProcessHandlerMap; + + explicit HostMonitorImpl (CORBA::ORB_ptr, Monitor_Thread *); + int drop_process (const std::string &process_id); + + ::CORBA::Boolean + register_process (const char *process_id, const char * hostname, CORBA::Long port) + throw (CORBA::SystemException); + + ::CORBA::Boolean + unregister_process (const char *process_id) + throw (CORBA::SystemException); + + void dump (void) + throw (CORBA::SystemException); + +protected: + RM_Proxy *create_rm_proxy (void); + void remove_rm_proxy (void); + int remove_process (std::string const &process_id); + +private: + Monitor_Thread *monitor_thread_; + std::auto_ptr rm_proxy_; + std::auto_ptr util_mon_; + ProcessHandlerMap process_map_; + ACE_Connector connector_; + CORBA::ORB_var orb_; +}; + + +#endif + diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/IOR_Interceptor.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/IOR_Interceptor.h new file mode 100644 index 00000000000..ca75d85160f --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/IOR_Interceptor.h @@ -0,0 +1,64 @@ +// -*- C++ -*- + +#ifndef IOR_INTERCEPTOR_H +#define IOR_INTERCEPTOR_H + +#include "ace/config-all.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/IORInterceptor/IORInterceptor.h" +#include "tao/PortableInterceptorC.h" +#include "tao/LocalObject.h" + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +class IOR_Interceptor + : public virtual PortableInterceptor::IORInterceptor_3_0, + public virtual TAO_Local_RefCounted_Object +{ +public: + + IOR_Interceptor (void); + + /** + * @name Methods Required by the IOR Interceptor Interface + * + * These are methods that must be implemented since they are pure + * virtual in the abstract base class. They are the canonical + * methods required for all IOR interceptors. + */ + //@{ + /// Return the name of this IORInterceptor. + virtual char * name (void); + + /// Cleanup resources acquired by this IORInterceptor. + virtual void destroy (void); + + /// Add the tagged components to the IOR. + virtual void establish_components ( + PortableInterceptor::IORInfo_ptr info); + + virtual void components_established ( + PortableInterceptor::IORInfo_ptr info); + + virtual void adapter_manager_state_changed ( + const char * id, + PortableInterceptor::AdapterState state); + + virtual void adapter_state_changed ( + const PortableInterceptor::ObjectReferenceTemplateSeq & templates, + PortableInterceptor::AdapterState state); + +}; + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#endif /* IOR_INTERCEPTOR_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/LinuxCPULoadCalculator.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/LinuxCPULoadCalculator.h new file mode 100644 index 00000000000..c9ebe36c881 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/LinuxCPULoadCalculator.h @@ -0,0 +1,34 @@ +/** + * @file C++ Interface: LinuxCPULoadCalculator + * + * @brief Declares interface for LinuxCPULoadCalculator. + * + */ + +#ifndef __LINUXCPULOADCALCULATOR_H_ +#define __LINUXCPULOADCALCULATOR_H_ + +#include "CPULoadCalculator.h" +#include "ace/Thread_Mutex.h" + +/** + * @class LinuxCPULoadCalculator + * + * @brief Encapsulates LinuxCPULoadCalculator + */ + +class LinuxCPULoadCalculator : public CPULoadCalculator +{ +public: + + LinuxCPULoadCalculator(); + + virtual double percent_load (void); + + ~LinuxCPULoadCalculator(); +private: + ACE_Thread_Mutex calc_mutex_; + +}; + +#endif /// __LINUXCPULOADCALCULATOR_H_ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/Monitor_Thread.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Monitor_Thread.h new file mode 100644 index 00000000000..e29d5cc029e --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Monitor_Thread.h @@ -0,0 +1,34 @@ +/** + * @file C++ Interface: Monitor_Thread + * + * @brief Declares interface for Monitor_Thread. + * + */ + +#ifndef __MONITOR_THREAD_H_ +#define __MONITOR_THREAD_H_ + +#include "ace/Reactor.h" +#include "ace/Task.h" + +/** + * @class Monitor_Thread + * + * @brief Encapsulates Monitor_Thread + */ + +class Monitor_Thread : public ACE_Task_Base +{ + public: + Monitor_Thread (); + virtual int svc (void); + //int register_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask); + ACE_Reactor * get_reactor (); + + private: + ACE_Reactor reactor_; +}; + + + +#endif /// __MONITOR_THREAD_H_ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/ObjectReferenceFactory.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/ObjectReferenceFactory.h new file mode 100644 index 00000000000..eec42bb929c --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/ObjectReferenceFactory.h @@ -0,0 +1,65 @@ +// -*- C++ -*- + +#ifndef TAO_OBJECT_REFERENCE_FACTORY_H +#define TAO_OBJECT_REFERENCE_FACTORY_H + +#include "ObjectReferenceFactoryC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +class ObjectReferenceFactory + : public virtual OBV_lwft::ObjectReferenceFactory + , public virtual CORBA::DefaultValueRefCountBase +{ + public: + + /// Constructor + ObjectReferenceFactory ( + PortableInterceptor::ObjectReferenceFactory * old_orf); + + /** + * @name PortableInterceptor::ObjectReferenceFactory Methods + * + * Methods required by the + * PortableInterceptor::ObjectReferenceFactory interface. + */ + //@{ + virtual CORBA::Object_ptr make_object ( + const char *repository_id, + const PortableInterceptor::ObjectId & id); + //@} + +protected: + + /// Destructor + /** + * Protected destructor to enforce proper memory management via + * reference counting. + */ + ~ObjectReferenceFactory (void); + +private: + + /// The old ObjectReferenceFactory used to create object references. + /** + * This ObjectReferenceFactory will still be used when creating + * object references. However, it will be invoked through this + * ObjectReferenceFactory. + */ + PortableInterceptor::ObjectReferenceFactory_var old_orf_; + +}; + + +#if defined (_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#endif /* TAO_OBJECT_REFERENCE_FACTORY_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/RMOptions.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/RMOptions.h new file mode 100644 index 00000000000..634e0cd7ab8 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/RMOptions.h @@ -0,0 +1,55 @@ +/** + * @file RMOptions.h + * + * @brief Declared the RMOptions class interface. + * + */ + +#ifndef _HMOPTIONS_H +#define _HMOPTIONS_H + +#include +#include +#include "ace/Thread_Mutex.h" + + +/** + * @class RMOptions + * + * @brief Declares RMOptions singleton to hold the command line options. + */ + +#include "ArgPair.h" + +class RMOptions +/// TITLE +/// Singleton class for the program options. +{ +public: + + /// Singleton access method. + static RMOptions *instance (void); + + /// Parse command-line arguments and set the appropriate values as + /// follows: + bool parse_args (int argc, char **argv); + bool proactive () const; + double hertz() const; + +protected: + + /// Constructor is protected to ensure Singleton access. + RMOptions (void); + + double hertz_; + bool proactive_; + ArgPair arg_pair_; + + /// Singleton instance. + static RMOptions * volatile instance_; + static std::auto_ptr deleter_; + static ACE_Thread_Mutex lock_; +}; + + +#endif /* _APPOPTIONS_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/RM_Proxy.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/RM_Proxy.h new file mode 100644 index 00000000000..5ce1c56e5b2 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/RM_Proxy.h @@ -0,0 +1,37 @@ + +#ifndef RM_PROXY_H +#define RM_PROXY_H + +#include "RM_Proxy.h" +#include "Timer.h" +#include "monitorC.h" +#include "CPULoadCalculator.h" +#include "LWFTC.h" + +class RM_Proxy : protected Timer +{ +public: + + using Timer::start; + using Timer::stop; + using Timer::hertz; + + RM_Proxy (CORBA::ORB_ptr); + virtual ~RM_Proxy (); + void setCPULoadCalculator (CPULoadCalculator *load_calc); + void proc_failure (const std::string &process_id); + + /// Helper function to be called back after a timeout + virtual int pulse (void); + +protected: + CORBA::Object_var obtain_RM_ior (CORBA::ORB_ptr orb); + +private: + CPULoadCalculator *load_calc_; + ReplicationManager_var RM_var_; + CORBA::ORB_var orb_; +}; + + +#endif /* RM_TIMER_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/ReplicationManager.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/ReplicationManager.h new file mode 100644 index 00000000000..d3d3c53bd1d --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/ReplicationManager.h @@ -0,0 +1,460 @@ +// cvs-id : $Id$ + +#ifndef REPLICATION_MANAGER_H +#define REPLICATION_MANAGER_H + +#include "LWFTS.h" +#include "ace/Hash_Map_Manager_T.h" +#include "ace/Unbounded_Queue.h" +#include "ace/Unbounded_Set.h" +#include "ace/Condition_T.h" +#include "ace/Containers_T.h" +#include "Timer.h" +#include "ace/Recursive_Thread_Mutex.h" + +#include +#include + +typedef enum { PRIMARY=1, BACKUP=2 } Role; +typedef enum { PROCESS_LEVEL=1, PROCESSOR_LEVEL=2 } AlgoMode; + +class Algorithm; + +struct APP_INFO +{ + ACE_CString object_id; + double load; + ACE_CString host_name; + ACE_CString process_id; + Role role; + CORBA::Object_var ior; + +public: + + APP_INFO(); + APP_INFO (APP_INFO const & app_info); + APP_INFO (const char *oid, double l, const char *hname, + const char *pid, Role r, CORBA::Object_ptr ref); + APP_INFO (const char *oid, const char *hname, + const char *pid, Role r); + void swap (APP_INFO & app_info); + APP_INFO & operator = (APP_INFO const & app_info); + bool operator == (APP_INFO const & app_info); +}; + +struct RANKED_IOR_LIST +{ + bool now; + std::list ior_list; + std::list host_list; + + RANKED_IOR_LIST(); +}; + +struct UtilRank +{ + double util; + std::string host_id; + + UtilRank (); + UtilRank (UtilRank const & ur); + UtilRank (double u, const char * hid); +}; + +bool operator < (UtilRank const & u1, UtilRank const & u2); + +struct MonitorUpdate +{ + typedef enum { PROC_FAIL_UPDATE, HOST_UTIL_UPDATE, RUN_NOW, APP_REG } UpdateType; + UpdateType type; + + ACE_CString process_id; + ACE_CString host_id; + double value; + APP_INFO app_info; + + static MonitorUpdate * + create_proc_fail_update(const char * pid); + static MonitorUpdate * + create_host_util_update(const char *hid, double value); + static MonitorUpdate * + create_run_now_update(); + static MonitorUpdate * + create_app_info_update (const char *oid, double l, + const char *hname, const char *pid, + Role r, CORBA::Object_ptr ref); +}; + +class ReplicationManager_i : public virtual POA_ReplicationManager, + protected Timer +{ +public: + + ReplicationManager_i (CORBA::ORB_ptr orb, double hertz, + bool proactive = true, AlgoMode mode = PROCESS_LEVEL); + + ~ReplicationManager_i (void); + + virtual void register_application (const char *object_id, + double load, + const char *host_name, + const char *process_id, + CORBA::Short role, + CORBA::Object_ptr server_reference + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + void util_update (const char *host_id, + double util + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + virtual void proc_failure (const char *process_id + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + virtual RankList * register_agent (CORBA::Object_ptr agent_reference + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + virtual CORBA::Object_ptr get_next (const char * object_id + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + bool replica_selection_algo (); + + typedef ACE_Unbounded_Set STRING_LIST; + typedef ACE_Unbounded_Set APP_SET; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + STRING_LIST, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> STRING_TO_STRING_LIST_MAP; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + ACE_CString, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> STRING_TO_STRING_MAP; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + double, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> STRING_TO_DOUBLE_MAP; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + APP_SET, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> OBJECTID_APPSET_MAP; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + RANKED_IOR_LIST, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> OBJECTID_RANKED_IOR_MAP; + + typedef ACE_Unbounded_Set AGENT_LIST; + + enum { UPDATE_LIST_MAX_SIZE = 100 }; + +private: + + CORBA::ORB_var orb_; + Algorithm * algo_thread_; + bool proactive_; + AlgoMode mode_; + + ACE_DLList update_list_; + ACE_Thread_Mutex update_mutex_; + ACE_Condition update_available_; + ACE_Condition update_list_full_; + + OBJECTID_APPSET_MAP objectid_appset_map_; + ACE_Recursive_Thread_Mutex appset_lock_; + OBJECTID_RANKED_IOR_MAP objectid_rankedior_map_; + STRING_TO_DOUBLE_MAP hostid_util_map_; + STRING_TO_DOUBLE_MAP objectid_load_map_; + STRING_TO_STRING_MAP processid_host_map_; + + STRING_TO_STRING_LIST_MAP processid_backup_map_; + STRING_TO_STRING_LIST_MAP processid_primary_map_; + STRING_TO_STRING_LIST_MAP hostid_process_map_; + + RankList rank_list_; + AGENT_LIST agent_list_; + ACE_Thread_Mutex rank_list_agent_list_combined_mutex_; + + + void update_map (const char * key_str, + const char * value_str, + STRING_TO_STRING_LIST_MAP & map); + + void update_util_map (const char * key_str, + double value, + STRING_TO_DOUBLE_MAP & map); + + void update_appset_map (const char * key_str, + APP_INFO const & app_info, + OBJECTID_APPSET_MAP &); + + void update_ior_map (ACE_CString const & oid, + std::priority_queue const & rank_list); + + void update_proc_host_map (const char *pid, + const char * hid, + STRING_TO_STRING_MAP & map); + + std::priority_queue + util_sorted_host_list (ACE_CString const & oid, + STRING_LIST const & host_list, + STRING_TO_DOUBLE_MAP const & hu_map); + + virtual int pulse(); + + void move_update_list (ACE_DLList & source, + ACE_DLList & dest); + + bool process_updates(ACE_DLList & update_list); + void remove_process(ACE_CString const & pid, + STRING_TO_STRING_LIST_MAP & map, + ACE_CString const & host, + Role role); + + void send_rank_list (); + void build_rank_list (); + void app_reg(APP_INFO & app_info); + void static_ranklist_update (const char * object_id, + CORBA::Object_ptr ior, + Role role); + void process_proc_failure (ACE_CString const & process_id); + STRING_LIST non_primary_host_list (ACE_CString const & primary_object_id); + void replace_primary_tags (ACE_CString const & pid, ACE_CString const & host); + void remove_from_appset (ACE_CString const & host, ACE_CString const & pid, + ACE_CString const & tag, Role role); + void elevate_backup_to_primary (ACE_CString const & tag); + void replace_backup_tags (ACE_CString const & pid, ACE_CString const & host); + void copy_map (STRING_TO_DOUBLE_MAP const & source, STRING_TO_DOUBLE_MAP & dest); + void print_queue (std::priority_queue queue); + // RankList * rank_list_clone (); +}; + +/* +class ReplicationManager_i : public virtual POA_ReplicationManager, + protected Timer +{ +public: + + using Timer::start; + using Timer::stop; + using Timer::hertz; + + ReplicationManager_i (CORBA::ORB_ptr orb); + + ~ReplicationManager_i (void); + +// ************************************************************************* + + virtual void register_application (const char *object_id, + CORBA::Long load, + const char *host_name, + const char *process_id, + CORBA::Short role, + CORBA::Object_ptr server_reference + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + virtual void register_agent (CORBA::Object_ptr agent_reference + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + virtual CORBA::Long next_member (const char * + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + virtual void util_update (const char *host_id, double utilization + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + virtual void proc_failure (const char *process_id + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((::CORBA::SystemException)); + + +// ************************************************************************* + + virtual int pulse (void); + + void update_replica_group_map (const char *object_id, + const char *host_name, + const char *process_id, + CORBA::Object_ptr server_reference); + + void update_replica_list (CORBA::Object_ptr server_reference, + const char *object_id); + + void update_replicas_list (CORBA::Object_ptr server_reference, + const char *object_id); + + void update_primary_map (const char *process_id, const char *object_id); + + void update_failover_map (const char *process_id, const char *object_id); + + void update_secondary_map (const char *process_id, const char *object_id); + + void update_host_list (const char *object_id, const char *host_id); + + void update_object_primary_map (const char *process_id, + const char *host_id, + const char *object_id); + + void update_object_failover_map (const char *process_id, + const char *host_id, + const char *object_id); + + void update_object_secondary_map (const char *process_id, + const char *host_id, + const char *object_id); + +// *************************************************************************** + + typedef ACE_Unbounded_Set PRIMARY_LIST; + typedef ACE_Unbounded_Set FAILOVER_LIST; + typedef ACE_Unbounded_Set SECONDARY_LIST; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + PRIMARY_LIST, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> PRIMARY_MAP; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + FAILOVER_LIST, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> FAILOVER_MAP; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + SECONDARY_LIST, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> SECONDARY_MAP; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + ACE_CString, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> PROCESS_MAP; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + CORBA::Object_var, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> REF_MAP; + + typedef ACE_Unbounded_Set HOST_LIST; + + typedef ACE_Unbounded_Set AGENT_LIST; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + HOST_LIST, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> REPLICA_HOST_MAP; + + struct Replica_Group_Entry + { + PROCESS_MAP process_map; + REF_MAP ref_map; + HOST_LIST host_list; + }; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + Replica_Group_Entry *, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> REPLICA_GROUP_MAP; + + typedef ACE_Hash_Map_Iterator_Ex < + ACE_CString, + Replica_Group_Entry *, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> REPLICA_GROUP_MAP_ITERATOR; + + struct Object_Info + { + ACE_CString process_id; + ACE_CString host_id; + }; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + Object_Info, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> OBJECT_PRIMARY_MAP; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + Object_Info, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> OBJECT_FAILOVER_MAP; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + Object_Info, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> OBJECT_SECONDARY_MAP; + + typedef ACE_Hash_Map_Manager_Ex< + ACE_CString, + double, + ACE_Hash, + ACE_Equal_To, + ACE_Null_Mutex> HOST_UTIL_MAP; + +private: + + CORBA::ORB_var orb_; + TAO_SYNCH_MUTEX lock_; + TAO_SYNCH_MUTEX primary_map_lock_; + TAO_SYNCH_MUTEX failover_map_lock_; + TAO_SYNCH_MUTEX secondary_map_lock_; + TAO_SYNCH_MUTEX replica_group_map_lock_; + TAO_SYNCH_MUTEX replica_host_map_lock_; + TAO_SYNCH_MUTEX object_primary_map_lock_; + TAO_SYNCH_MUTEX object_failover_map_lock_; + TAO_SYNCH_MUTEX object_secondary_map_lock_; + ReplicaList replica_list_; + ReplicasList replicas_list_; + PRIMARY_MAP primary_map_; + FAILOVER_MAP failover_map_; + SECONDARY_MAP secondary_map_; + REPLICA_GROUP_MAP replica_group_map_; + REPLICA_HOST_MAP replica_host_map_; + OBJECT_PRIMARY_MAP object_primary_map_; + OBJECT_FAILOVER_MAP object_failover_map_; + OBJECT_SECONDARY_MAP object_secondary_map_; + HOST_UTIL_MAP host_util_map_; + AGENT_LIST agent_list_; + +}; +*/ +#endif /* REPLICATION_MANAGER_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/ServerORBInitializer.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/ServerORBInitializer.h new file mode 100644 index 00000000000..bd8fb0e3805 --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/ServerORBInitializer.h @@ -0,0 +1,50 @@ +// -*- C++ -*- + +#ifndef SERVER_ORB_INITIALIZER_H +#define SERVER_ORB_INITIALIZER_H + +#include "ace/config-all.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/PI/PI.h" +#include "tao/LocalObject.h" + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +class ServerORBInitializer : + public virtual PortableInterceptor::ORBInitializer, + public virtual TAO_Local_RefCounted_Object +{ +public: + + /** + * @name Methods Required by the ORBInitializer Interface + * + * These are methods that must be implemented since they are pure + * virtual in the abstract base class. They are the canonical + * methods required for all ORB initializers. + */ + //@{ + /// The pre-initialization hook. + virtual void pre_init ( + PortableInterceptor::ORBInitInfo_ptr info); + + /// The post-initialization hook. + virtual void post_init ( + PortableInterceptor::ORBInitInfo_ptr info); + //@} + +}; + + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#endif /* SERVER_ORB_INITIALIZER_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/Timer.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Timer.h new file mode 100644 index 00000000000..37a28c08c3f --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Timer.h @@ -0,0 +1,66 @@ +//============================================================ +/** + * @file Timer.h + * + * taken from basic sp timer code + * @author + */ +//============================================================ + +#ifndef TIMER_H +#define TIMER_H + +#include "ace/Task.h" + +/** + * @class Timer + * + */ +class Timer : public ACE_Task_Base +{ +public: + /// Default constructor. + Timer (void); + + /// Default destructor. + ~Timer (void); + + double hertz (void); + void hertz (double h); + void start (); + void stop (); + + /// Helper function to be called back after a timeout + virtual int pulse (void); + + /// timer related functions including the active object svc function which + /// runs our timer + + /// Handle the timeout. + virtual int handle_timeout (const ACE_Time_Value &tv, + const void *arg); + + /// Called when is removed. + virtual int handle_close (ACE_HANDLE handle, + ACE_Reactor_Mask close_mask); + + virtual int svc (void); + +protected: + /// Flag to indicate completion of this active object. + int done_; + + /// flag to indicate if we are already activated + int active_; + + /// Frequency + double hertz_; + + /// The timer id we are waiting. + long tid_; + +}; + + + +#endif /* TIMER_H */ diff --git a/TAO/orbsvcs/examples/FaultTolerance/FLARe/Utilization_Monitor.h b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Utilization_Monitor.h new file mode 100644 index 00000000000..2784d88b4cb --- /dev/null +++ b/TAO/orbsvcs/examples/FaultTolerance/FLARe/Utilization_Monitor.h @@ -0,0 +1,37 @@ + +#ifndef UTILIZATION_MONITOR_H +#define UTILIZATION_MONITOR_H + +#include "Timer.h" +#include "CPULoadCalculator.h" +#include + +class RM_Proxy; + + +class Utilization_Monitor : protected Timer, + public CPULoadCalculator +{ +public: + + using Timer::start; + using Timer::stop; + using Timer::hertz; + + explicit Utilization_Monitor (CPULoadCalculator *load_calc); + virtual ~Utilization_Monitor (); + + /// Helper function to be called back after a timeout + virtual int pulse (void); + virtual double percent_load (void); + void setRM_Proxy (RM_Proxy *rm_proxy); + +private: + std::auto_ptr load_calc_; + RM_Proxy *rm_proxy_; + double load_; + std::ofstream outfile_; +}; + + +#endif /* UTILIZATION_MONITOR_H */ -- cgit v1.2.1