TAO/orbsvcs/tests/FT_App/StubFaultNotifier.cpp

   1 // -*- C++ -*-
   2 #include "StubFaultNotifier.h"
   3 #include "ace/Get_Opt.h"
   4 #include "ace/OS_NS_stdio.h"
   5 #include "orbsvcs/PortableGroup/PG_Properties_Encoder.h"
   6 // FUZZ: disable check_for_streams_include
   7 #include "ace/streams.h"
   8
   9 StubFaultNotifier::StubFaultNotifier ()
  10   : ior_output_file_(0)
  11   , detector_ior_(0)
  12   , ns_name_("")
  13 {
  14 }
  15
  16
  17 StubFaultNotifier::~StubFaultNotifier ()
  18 {
  19 }
  20
  21
  22 ::PortableServer::POA_ptr StubFaultNotifier::_default_POA ()
  23 {
  24   return ::PortableServer::POA::_duplicate(this->poa_.in ());
  25 }
  26
  27 PortableServer::ObjectId StubFaultNotifier::objectId()const
  28 {
  29   return this->object_id_.in();
  30 }
  31
  32 int StubFaultNotifier::parse_args (int argc, ACE_TCHAR * argv[])
  33 {
  34   int optionError = 0;
  35   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("o:r:d:n:"));
  36   int c;
  37   while ((c = get_opts ()) != -1)
  38   {
  39     switch (c)
  40     {
  41       case 'r':
  42       {
  43         this->iorReplicaFiles_.push_back( ACE_TEXT_ALWAYS_CHAR(get_opts.opt_arg ()));
  44         break;
  45       }
  46       case 'd':
  47       {
  48         this->detector_ior_ = get_opts.opt_arg ();
  49         break;
  50       }
  51       case 'n':
  52       {
  53         this->ns_name_ = ACE_TEXT_ALWAYS_CHAR(get_opts.opt_arg ());
  54         break;
  55       }
  56       case 'o':
  57       {
  58         this->ior_output_file_ = get_opts.opt_arg ();
  59         break;
  60       }
  61
  62       default:
  63         // fall thru
  64       case '?':
  65       {
  66         break;
  67       }
  68     }
  69   }
  70
  71   if(! optionError)
  72   {
  73     if (iorReplicaFiles_.size() == 0)
  74     {
  75       ACE_ERROR ((LM_ERROR,
  76         "-r option is required.\n"
  77         ));
  78       optionError = -1;
  79     }
  80     if (0 == this->detector_ior_)
  81     {
  82       ACE_ERROR ((LM_ERROR,
  83         "-d option is required.\n"
  84         ));
  85       optionError = -1;
  86     }
  87   }
  88
  89   if(optionError)
  90   {
  91     ACE_ERROR ((LM_ERROR,
  92       "usage:  %s"
  93       " -r <replica.ior [-r <replica2.ior]...>"
  94       " -d <detector.ior>"
  95       " -o <this.ior>"
  96       " -n <nameService name>"
  97       "\n",
  98       argv [0]
  99       ));
 100   }
 101   return optionError;
 102 }
 103
 104 /**
 105  * Prepare to exit.
 106  */
 107 int StubFaultNotifier::fini ()
 108 {
 109   if(this->ns_name_.length () != 0)
 110   {
 111     CORBA::Object_var naming_obj =
 112       this->orb_->resolve_initial_references ("NameService");
 113
 114     if (CORBA::is_nil(naming_obj.in ())){
 115       ACE_ERROR_RETURN ((LM_ERROR,
 116                        "%T %n (%P|%t) Unable to find the Naming Service\n"),
 117                        1);
 118     }
 119
 120     CosNaming::NamingContext_var naming_context =
 121       CosNaming::NamingContext::_narrow (naming_obj.in ());
 122
 123     CosNaming::Name this_name (1);
 124     this_name.length (1);
 125     this_name[0].id = CORBA::string_dup (this->ns_name_.c_str ());
 126
 127     naming_context->unbind (this_name);
 128   }
 129   return 0;
 130 }
 131
 132
 133 /**
 134  * Publish this objects IOR.
 135  */
 136 int StubFaultNotifier::init (CORBA::ORB_ptr orb)
 137 {
 138   int result = 0;
 139   this->orb_ = CORBA::ORB::_duplicate (orb);
 140
 141   // Use the ROOT POA for now
 142   CORBA::Object_var poa_object =
 143     this->orb_->resolve_initial_references (TAO_OBJID_ROOTPOA);
 144
 145   if (CORBA::is_nil (poa_object.in ()))
 146     ACE_ERROR_RETURN ((LM_ERROR,
 147                        ACE_TEXT (" (%P|%t) Unable to initialize the POA.\n")),
 148                       -1);
 149
 150   // Get the POA object.
 151   this->poa_ =
 152     PortableServer::POA::_narrow (poa_object.in ());
 153
 154
 155   if (CORBA::is_nil(this->poa_.in ()))
 156   {
 157     ACE_ERROR_RETURN ((LM_ERROR,
 158                        ACE_TEXT (" (%P|%t) Unable to narrow the POA.\n")),
 159                       -1);
 160   }
 161
 162   PortableServer::POAManager_var poa_manager =
 163     this->poa_->the_POAManager ();
 164
 165   poa_manager->activate ();
 166
 167   // Register with the POA.
 168
 169   this->object_id_ = this->poa_->activate_object (this);
 170
 171   // find my identity as a corba object
 172   CORBA::Object_var this_obj =
 173     this->poa_->id_to_reference (object_id_.in ());
 174
 175   //////////////////////////////////////////
 176   // resolve references to detector factory
 177
 178   CORBA::Object_var obj = this->orb_->string_to_object(detector_ior_);
 179   this->factory_ = ::FT::FaultDetectorFactory::_narrow(obj.in ());
 180   if (CORBA::is_nil(this->factory_.in ()))
 181   {
 182     ACE_OS::fprintf (stderr, "Can't resolve Detector Factory IOR %s\n",
 183                      ACE_TEXT_ALWAYS_CHAR (this->detector_ior_));
 184     result = -1;
 185   }
 186   if (result == 0)
 187   {
 188     ////////////////////////////////////
 189     // resolve references to replicas
 190     size_t replicaCount = this->iorReplicaFiles_.size();
 191     for(size_t nRep = 0; result == 0 && nRep < replicaCount; ++nRep)
 192     {
 193       const char * iorName = this->iorReplicaFiles_[nRep];
 194       CORBA::Object_var obj = this->orb_->string_to_object(iorName);
 195       FT::PullMonitorable_var replica = FT::PullMonitorable::_narrow(obj.in ());
 196       if (CORBA::is_nil(replica.in ()))
 197       {
 198         ACE_OS::fprintf (stderr, "Can't resolve Replica IOR %s\n", iorName);
 199         result = -1;
 200       }
 201       else
 202       {
 203         this->replicas_.push_back(replica);
 204
 205         CORBA::String_var type_id = CORBA::string_dup("FaultDetector");
 206
 207         TAO_PG::Properties_Encoder encoder;
 208
 209         PortableGroup::Value value;
 210         //////////////////
 211         // FaultDetectorFactory gets picky about FaultNotifier's object type.
 212         // coddle it.
 213         ::FT::FaultNotifier_var notifier = ::FT::FaultNotifier::_narrow(this_obj.in ());
 214         value <<= notifier.in ();
 215         encoder.add(::FT::FT_NOTIFIER, value);
 216
 217
 218         value <<= replica.in ();
 219         encoder.add(::FT::FT_MONITORABLE, value);
 220
 221         FT::FTDomainId domain_id = 0;
 222         value <<= domain_id;
 223         encoder.add(::FT::FT_DOMAIN_ID, value);
 224
 225         PortableGroup::Location object_location;
 226         object_location.length(1);
 227         object_location[0].id = CORBA::string_dup("Test location");
 228         value <<= object_location;
 229         encoder.add(::FT::FT_LOCATION, value);
 230
 231         PortableGroup::TypeId object_type = 0;
 232         value <<= object_type;
 233         encoder.add(::FT::FT_TYPE_ID, value);
 234
 235         PortableGroup::ObjectGroupId group_id = 0;
 236         value <<= group_id;
 237         encoder.add(::FT::FT_GROUP_ID, value);
 238
 239         // allocate and populate the criteria
 240         PortableGroup::Criteria_var criteria;
 241         ACE_NEW_NORETURN (criteria,
 242           PortableGroup::Criteria);
 243         if (criteria.ptr() == 0)
 244         {
 245           ACE_ERROR((LM_ERROR,
 246             "Error cannot allocate criteria.\n"
 247             ));
 248             result = -1;
 249         }
 250         else
 251         {
 252           encoder.encode(criteria);
 253           PortableGroup::GenericFactory::FactoryCreationId_var factory_creation_id;
 254
 255           this->factory_->create_object (
 256             type_id.in(),
 257             criteria.in(),
 258             factory_creation_id);
 259         }
 260       }
 261     }
 262
 263     if (this->ior_output_file_ != 0)
 264     {
 265       this->identity_ = ACE_TEXT("file:");
 266       this->identity_ += this->ior_output_file_;
 267       result = write_ior_file();
 268     }
 269     else
 270     {
 271       // if no IOR file specified,
 272       // then always try to register with name service
 273       this->ns_name_ = "FT_FaultNotifier";
 274     }
 275
 276     if(this->ns_name_.length () != 0)
 277     {
 278       this->identity_ = ACE_TEXT("name:");
 279       this->identity_ += ACE_TEXT_CHAR_TO_TCHAR(this->ns_name_.c_str ());
 280
 281       CORBA::Object_var naming_obj =
 282         this->orb_->resolve_initial_references ("NameService");
 283
 284       if (CORBA::is_nil(naming_obj.in ())){
 285         ACE_ERROR_RETURN ((LM_ERROR,
 286                            "%T %n (%P|%t) Unable to find the Naming Service\n"),
 287                           1);
 288       }
 289
 290       CosNaming::NamingContext_var naming_context =
 291         CosNaming::NamingContext::_narrow (naming_obj.in ());
 292
 293       CosNaming::Name this_name (1);
 294       this_name.length (1);
 295       this_name[0].id = CORBA::string_dup (this->ns_name_.c_str ());
 296
 297       naming_context->rebind (this_name, this_obj.in());
 298     }
 299   }
 300   return result;
 301 }
 302
 303 int StubFaultNotifier::write_ior_file()
 304 {
 305   int result = -1;
 306   FILE* out = ACE_OS::fopen (this->ior_output_file_, "w");
 307   if (out)
 308   {
 309     ACE_OS::fprintf (out, "%s", this->ior_.in ());
 310     ACE_OS::fclose (out);
 311     result = 0;
 312   }
 313   return result;
 314 }
 315
 316 /**
 317  * Return a string to identify this object for logging/console message purposes.
 318  */
 319 const ACE_TCHAR * StubFaultNotifier::identity () const
 320 {
 321   return this->identity_.c_str();
 322 }
 323
 324 /**
 325  * Clean house for process shut down.
 326  */
 327 void StubFaultNotifier::shutdown_i ()
 328 {
 329   this->orb_->shutdown (false);
 330 }
 331
 332 void StubFaultNotifier::push_structured_fault (
 333     const CosNotification::StructuredEvent & event
 334   )
 335 {
 336   ACE_ERROR ((LM_ERROR,
 337     "FaultNotifier: Received Fault notification:\n"
 338     "FaultNotifier:   Header EventType domain: %s\n"
 339     "FaultNotifier:   Header EventType type: %s\n"
 340     "FaultNotifier:   Header EventName: %s\n",
 341     static_cast<const char *> (event.header.fixed_header.event_type.domain_name),
 342     static_cast<const char *> (event.header.fixed_header.event_type.type_name),
 343     static_cast<const char *> (event.header.fixed_header.event_name)
 344     ));
 345   const CosNotification::FilterableEventBody & filterable = event.filterable_data;
 346
 347   size_t propertyCount = filterable.length ();
 348   for (size_t nProp = 0; nProp < propertyCount; ++nProp)
 349   {
 350     const CosNotification::Property & property = filterable[nProp];
 351     ACE_ERROR ((LM_ERROR,
 352       "FaultNotifier:   Property Name: %s\n",
 353       static_cast<const char *> (property.name)
 354       ));
 355     //@@ we could stand to decode more--just for completeness
 356   }
 357 }
 358
 359
 360 void StubFaultNotifier::push_sequence_fault (
 361     const CosNotification::EventBatch & events
 362   )
 363 {
 364   ACE_UNUSED_ARG (events);
 365   throw CORBA::NO_IMPLEMENT();
 366 }
 367
 368 ::CosNotifyFilter::Filter_ptr StubFaultNotifier::create_subscription_filter (
 369     const char * constraint_grammar
 370   )
 371 {
 372   ACE_UNUSED_ARG (constraint_grammar);
 373   throw CORBA::NO_IMPLEMENT();
 374   return 0;
 375 }
 376
 377
 378 FT::FaultNotifier::ConsumerId StubFaultNotifier::connect_structured_fault_consumer (
 379     CosNotifyComm::StructuredPushConsumer_ptr push_consumer,
 380     CosNotifyFilter::Filter_ptr filter
 381   )
 382 {
 383   ACE_UNUSED_ARG(push_consumer);
 384   ACE_UNUSED_ARG(filter);
 385
 386   throw CORBA::NO_IMPLEMENT();
 387   return 0;
 388 }
 389
 390
 391 FT::FaultNotifier::ConsumerId StubFaultNotifier::connect_sequence_fault_consumer (
 392     CosNotifyComm::SequencePushConsumer_ptr push_consumer,
 393     CosNotifyFilter::Filter_ptr filter
 394   )
 395 {
 396   ACE_UNUSED_ARG(push_consumer);
 397   ACE_UNUSED_ARG(filter);
 398
 399   throw CORBA::NO_IMPLEMENT();
 400   return 0;
 401 }
 402
 403 void StubFaultNotifier::disconnect_consumer (
 404     FT::FaultNotifier::ConsumerId connection
 405   )
 406 {
 407   ACE_UNUSED_ARG(connection);
 408
 409   throw CORBA::NO_IMPLEMENT();
 410 }
 411
 412 CORBA::Boolean StubFaultNotifier::is_alive ()
 413 {
 414   return 1;
 415 }
 416
 417 int StubFaultNotifier::idle(int & result)
 418 {
 419   ACE_UNUSED_ARG(result);
 420   int quit = 0;
 421   try
 422   {
 423     if(!CORBA::is_nil(this->factory_.in ()))
 424     {
 425       int ok = this->factory_->is_alive();
 426       if (!ok)
 427       {
 428         quit = 1;
 429       }
 430     }
 431   }
 432   catch (const CORBA::Exception&)
 433   {
 434     quit = 1;
 435   }
 436   return quit;
 437 }