TAO/orbsvcs/tests/FT_App/FT_ReplicaFactory_i.h

   1 /* -*- C++ -*- */
   2 //=============================================================================
   3 /**
   4  *  @file    FT_ReplicaFactory_i.h
   5  *
   6  *  This file is part of Fault Tolerant CORBA.
   7  *  It declares the implementation of ReplicaFactory which
   8  *  creates and manages replicas as an agent for
   9  *  the ReplicationManager as defined in the FT CORBA specification.
  10  *
  11  *  @author Dale Wilson <wilson_d@ociweb.com>
  12  */
  13 //=============================================================================
  14
  15 #ifndef FT_REPLICAFACTORY_H_
  16 #define FT_REPLICAFACTORY_H_
  17 #include <ace/ACE.h>
  18 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  19 # pragma once
  20 #endif /* ACE_LACKS_PRAGMA_ONCE */
  21
  22 //////////////////////////////////
  23 // Classes declared in this header
  24 class  FT_ReplicaFactory_i;
  25
  26 /////////////////////////////////
  27 // Includes needed by this header
  28 #include <ace/Vector_T.h>
  29 #include "FT_TestReplicaS.h"
  30 #include <ace/Thread_Manager.h>
  31 #include <ace/SString.h>
  32 #include <orbsvcs/FT_ReplicationManagerC.h>
  33
  34 /////////////////////
  35 // Forward references
  36 class TAO_ORB_Manager;
  37 class FT_TestReplica_i;
  38
  39 /**
  40  * Implement the GenericFactory interface.
  41  */
  42 class  FT_ReplicaFactory_i
  43 //FT_TEST::ReplicaFactory
  44   : public virtual POA_PortableGroup::GenericFactory
  45 {
  46   typedef ACE_Vector<FT_TestReplica_i *> ReplicaVec;
  47   typedef ACE_Vector<ACE_CString> StringVec;
  48
  49   //////////////////////
  50   // non-CORBA interface
  51 public:
  52   /**
  53    * Default constructor.
  54    */
  55   FT_ReplicaFactory_i ();
  56
  57   /**
  58    * Virtual destructor.
  59    */
  60   virtual ~FT_ReplicaFactory_i ();
  61
  62   /**
  63    * Parse command line arguments.
  64    * @param argc traditional C argc
  65    * @param argv traditional C argv
  66    * @return zero for success; nonzero is process return code for failure.
  67    */
  68   int parse_args (int argc, ACE_TCHAR * argv[]);
  69
  70   /**
  71    * Initialize this object.
  72    * @param orb our ORB -- we keep var to it.
  73    * @return zero for success; nonzero is process return code for failure.
  74    */
  75   int init (CORBA::ORB_ptr orb);
  76
  77   /**
  78    * Prepare to exit.
  79    * @return zero for success; nonzero is process return code for failure.
  80    */
  81   int fini (void);
  82
  83   int idle(int & result);
  84
  85
  86   /**
  87    * Identify this replica factory.
  88    * @return a string to identify this object for logging/console message purposes.
  89    */
  90   const ACE_TCHAR * identity () const;
  91
  92   const char * location () const;
  93
  94   /**
  95    * Remove pointer to individual replica; delete FT_TestReplica_i.
  96    * See replica life cycle description.
  97    * @param id the numerical id assigned to this replica.
  98    * @param replica a pointer to the Replica object (redundant for safety.)
  99    */
 100   void remove_replica (CORBA::ULong id, FT_TestReplica_i * replica);
 101
 102   //////////////////
 103   // CORBA interface
 104   // See IDL for documentation
 105
 106   virtual void shutdown (void);
 107
 108   /////////////////////////////////////////
 109   // CORBA interface GenericFactory methods
 110   virtual CORBA::Object_ptr create_object (
 111     const char * type_id,
 112     const PortableGroup::Criteria & the_criteria,
 113     PortableGroup::GenericFactory::FactoryCreationId_out factory_creation_id
 114   );
 115
 116   virtual void delete_object (
 117     const PortableGroup::GenericFactory::FactoryCreationId & factory_creation_id
 118   );
 119
 120   //////////////////////////////////////////
 121   // CORBA interface PullMonitorable methods
 122
 123   virtual CORBA::Boolean is_alive (void);
 124
 125   /////////////////////////
 126   // Implementation methods
 127 private:
 128   /**
 129    * Actual replica creation happens in this method.
 130    * @param name becomes part of the objects identity.
 131    */
 132   FT_TestReplica_i * create_replica(const char * name);
 133
 134   /**
 135    * Find or allocate an ID for a new replica
 136    */
 137   CORBA::ULong allocate_id();
 138
 139   /**
 140    * Write this factory's IOR to a file
 141    */
 142   int write_ior (const ACE_TCHAR * outputFile, const char * ior);
 143
 144   /**
 145    * Clean house for factory shut down.
 146    */
 147   void shutdown_i ();
 148
 149   ///////////////
 150   // Data Members
 151 private:
 152
 153   /**
 154    * Protect internal state.
 155    * Mutex should be locked by corba methods, or by
 156    * external (public) methods before calling implementation
 157    * methods.
 158    * Implementation methods should assume the mutex is
 159    * locked if necessary.
 160    */
 161   TAO_SYNCH_MUTEX internals_;
 162
 163   /**
 164    * The orb
 165    */
 166   CORBA::ORB_var orb_;
 167
 168   /**
 169    * The POA used to activate this object.
 170    */
 171   PortableServer::POA_var poa_;
 172
 173   /**
 174    * The CORBA object id assigned to this object.
 175    */
 176   PortableServer::ObjectId_var object_id_;
 177
 178   /**
 179    * IOR of this object as assigned by poa
 180    */
 181   CORBA::String_var ior_;
 182
 183   /**
 184    * A file to which the factory's IOR should be written.
 185    */
 186   const ACE_TCHAR * ior_output_file_;
 187
 188   /**
 189    * A human-readable string to distinguish this from other Notifiers.
 190    */
 191   ACE_TString identity_;
 192
 193   /**
 194    * bool: true if we found a replication manager
 195    */
 196   int have_replication_manager_;
 197
 198   /**
 199    * The replication manager
 200    */
 201
 202   ::FT::ReplicationManager_var replication_manager_;
 203
 204
 205   /**
 206    * The factory registry IOR
 207    */
 208   const ACE_TCHAR * factory_registry_ior_;
 209
 210   /**
 211    * The factory registry with which to register.
 212    */
 213   PortableGroup::FactoryRegistry_var factory_registry_;
 214
 215   /**
 216    * true if registered with FactoryRegistry
 217    */
 218   int registered_; // bool
 219
 220   /**
 221    * A file to which the test replica's IOR will be written
 222    */
 223   const ACE_TCHAR * test_output_file_;
 224
 225   /**
 226    * A name to be used to register the factory with the name service.
 227    */
 228   ACE_CString ns_name_;
 229
 230   CosNaming::NamingContext_var naming_context_;
 231
 232   CosNaming::Name this_name_;
 233
 234   /////////////////
 235   // The roles used to register types
 236   StringVec roles_;
 237
 238   /**
 239    * the PortableGroup::Location within the domain
 240    */
 241   ACE_CString location_;
 242
 243   /**
 244    * bool: quit on idle flag.
 245    */
 246   int quit_on_idle_;
 247
 248   /**
 249    * bool: use a single call to unregister.
 250    */
 251   int unregister_by_location_;
 252
 253   /**
 254    * A vector of Replicas.  Note that the Replica ID
 255    * is an index into this vector.
 256    */
 257   ReplicaVec replicas_;
 258
 259   /**
 260    * count of entries in Replicas_ that have been deleted.
 261    * Used to determine when the factory is idle and to avoid futile
 262    * searches for empty slots.
 263    */
 264   size_t empty_slots_;
 265
 266   /**
 267    * boolean: starts false.  Set to true when it's time to quit.
 268    */
 269   int quit_requested_;
 270
 271   /**
 272   * A file that use by FT_TestReplica_i object
 273   */
 274   const ACE_TCHAR* name_persistent_file_;
 275
 276 };
 277
 278 #endif /* FT_REPLICAFACTORY_H_  */