TAO/orbsvcs/tests/FT_Naming/FaultTolerant/LB_server.cpp

   1 #include "LB_server.h"
   2 #include "Basic.h"
   3
   4 #include "TestC.h"
   5 #include "ace/OS_NS_stdio.h"
   6
   7 LB_server::LB_server (int argc, ACE_TCHAR **argv)
   8   : argc_ (argc)
   9   , argv_ (argv)
  10   , ior_output_file_ (ACE_TEXT ("obj.ior"))
  11 {
  12 }
  13
  14 int
  15 LB_server::destroy ()
  16 {
  17   try
  18     {
  19       this->naming_manager_->delete_object_group ("BasicGroup");
  20
  21       this->root_poa_->destroy (1, 1);
  22
  23       this->orb_->destroy ();
  24     }
  25   catch (const CORBA::Exception& ex)
  26     {
  27       ex._tao_print_exception (
  28         ACE_TEXT ("Exception caught while destroying LB_server\n"));
  29       return -1;
  30     }
  31   return 0;
  32 }
  33
  34 CORBA::ORB_ptr
  35 LB_server::orb ()
  36 {
  37   return this->orb_.in ();
  38 }
  39
  40 CORBA::Object_ptr
  41 LB_server::object_group ()
  42 {
  43   return this->object_group_.in ();
  44 }
  45
  46 FT_Naming::NamingManager_ptr
  47 LB_server::naming_manager ()
  48 {
  49   return this->naming_manager_.in ();
  50 }
  51
  52 int
  53 LB_server::write_ior_to_file (const ACE_TCHAR *file_name,
  54                               const char *ior)
  55 {
  56   FILE *output_file =
  57     ACE_OS::fopen (file_name, "w");
  58
  59   if (output_file == 0)
  60     {
  61       ACE_ERROR ((LM_ERROR,
  62                   ACE_TEXT ("Cannot open output file for writing IOR:")));
  63       return -1;
  64     }
  65
  66   ACE_OS::fprintf (output_file, "%s", ior);
  67   ACE_OS::fclose (output_file);
  68   return 0;
  69 }
  70
  71 int
  72 LB_server::parse_args (int argc, ACE_TCHAR *argv[])
  73 {
  74   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("o:"));
  75   int c;
  76
  77   while ((c = get_opts ()) != -1)
  78     switch (c)
  79       {
  80       case 'o':
  81         this->ior_output_file_ = get_opts.opt_arg ();
  82         break;
  83       case '?':
  84       default:
  85         ACE_ERROR_RETURN ((LM_ERROR,
  86                            ACE_TEXT ("usage:  %s ")
  87                            ACE_TEXT ("-o <iorfile>")
  88                            ACE_TEXT ("\n"),
  89                            argv [0]),
  90                           -1);
  91       }
  92   // Indicates successful parsing of the command line
  93   return 0;
  94 }
  95
  96 int
  97 LB_server::start_orb_and_poa ()
  98 {
  99   try
 100     {
 101       // Initialise the ORB.
 102       this->orb_ = CORBA::ORB_init (this->argc_, this->argv_);
 103
 104       CORBA::Object_var poa_object =
 105         this->orb_->resolve_initial_references ("RootPOA");
 106
 107       if (CORBA::is_nil (poa_object.in ()))
 108         ACE_ERROR_RETURN ((LM_ERROR,
 109                            ACE_TEXT (" (%P|%t) Unable to initialize ")
 110                            ACE_TEXT ("the POA.\n")),
 111                           -1);
 112
 113       this->root_poa_ = PortableServer::POA::_narrow (poa_object.in ());
 114
 115       PortableServer::POAManager_var poa_manager =
 116         this->root_poa_->the_POAManager ();
 117
 118       poa_manager->activate ();
 119
 120       ACE_Time_Value timeout (10); // Wait up to 10 seconds for the naming service
 121       if (name_svc_.init (this->orb_.in (), &timeout) != 0)
 122         ACE_ERROR_RETURN ((LM_DEBUG,
 123                            ACE_TEXT (" (%P|%t) LB_server: Could not connect ")
 124                            ACE_TEXT ("to naming service.\n")),
 125                            -1);
 126
 127       CORBA::Object_var obj = this->orb_->resolve_initial_references (
 128         "NamingManager");
 129
 130       this->naming_manager_ =
 131         FT_Naming::NamingManager::_narrow (obj.in ());
 132
 133       if (CORBA::is_nil (this->naming_manager_.in ()))
 134         ACE_ERROR_RETURN ((LM_ERROR,
 135                            ACE_TEXT (" (%P|%t) Unable to get Naming Manager ")
 136                            ACE_TEXT ("Reference.\n")),
 137                           -1);
 138     }
 139   catch (const CORBA::Exception& ex)
 140     {
 141       ex._tao_print_exception (
 142         ACE_TEXT ("Exception raised initialising ORB or POA"));
 143       return -1;
 144     }
 145
 146   return 0;
 147 }
 148
 149 int
 150 LB_server::create_object_group (const char *group_name)
 151 {
 152   try
 153     {
 154       if (this->parse_args (argc_, argv_) != 0)
 155         return -1;
 156
 157       PortableGroup::Criteria criteria (2);
 158       criteria.length (1);
 159
 160       PortableGroup::Property &mem_style = criteria[0];
 161       mem_style.nam.length (1);
 162
 163       // Set the membership style property
 164       mem_style.nam[0].id = CORBA::string_dup (
 165         "org.omg.PortableGroup.MembershipStyle");
 166
 167       PortableGroup::MembershipStyleValue msv =
 168         PortableGroup::MEMB_APP_CTRL;
 169       mem_style.val <<= msv;
 170
 171       ACE_DEBUG ((LM_DEBUG,
 172                   ACE_TEXT ("(%P|%t) LB_server - creating the object group\n")));
 173
 174       this->object_group_ = this->naming_manager_->create_object_group (
 175         group_name,
 176         FT_Naming::ROUND_ROBIN,
 177         criteria);
 178
 179       CORBA::String_var ior =
 180         this->orb_->object_to_string (this->object_group_.in ());
 181
 182       this->write_ior_to_file (this->ior_output_file_, ior.in ());
 183     }
 184   catch (const PortableGroup::ObjectNotCreated&)
 185     {
 186       this->object_group_ =
 187         this->naming_manager_->get_object_group_ref_from_name (group_name);
 188       ACE_DEBUG ((LM_DEBUG,
 189                   "(%P|%t) LB_server - object group already exists\n"));
 190       return 1;
 191     }
 192   catch (const CORBA::Exception& ex)
 193     {
 194       ex._tao_print_exception (
 195         ACE_TEXT ("Exception raised while creating object group"));
 196       return -1;
 197     }
 198
 199   return 0;
 200 }
 201
 202 int
 203 LB_server::register_servant (Basic *servant, const char *loc)
 204 {
 205   try
 206     {
 207       Test::Basic_var basic =
 208         servant->_this ();
 209
 210       ACE_DEBUG ((LM_DEBUG,
 211                   ACE_TEXT ("Writing ior to file: %C\n"),
 212                   loc));
 213       CORBA::String_var ior =
 214         this->orb_->object_to_string (basic.in ());
 215
 216       this->write_ior_to_file (ACE_TEXT_CHAR_TO_TCHAR (loc), ior);
 217
 218       PortableGroup::Location location (1);
 219       location.length (1);
 220
 221       location[0].id = CORBA::string_dup (loc);
 222
 223       this->object_group_ =
 224         this->naming_manager_->add_member (this->object_group_.in (),
 225                                            location,
 226                                            basic.in ());
 227     }
 228   catch (const PortableGroup::ObjectNotAdded& )
 229     {
 230       ACE_DEBUG ((LM_DEBUG,
 231                   "(%P|%t) Member was already added previously.\n"));
 232     }
 233   catch (const CORBA::Exception& ex)
 234     {
 235       ex._tao_print_exception (
 236         ACE_TEXT ("Exception raised while registering servant"));
 237       return -1;
 238     }
 239
 240   return 0;
 241 }
 242
 243 int
 244 LB_server::remove_servant (const char *loc)
 245 {
 246   PortableGroup::Location location (1);
 247   location.length (1);
 248
 249   location[0].id = CORBA::string_dup (loc);
 250
 251   try {
 252     this->object_group_ =
 253       this->naming_manager_->remove_member (this->object_group_.in (),
 254                                             location);
 255   }
 256   catch (const CORBA::Exception& ex)
 257     {
 258       ex._tao_print_exception (
 259         ACE_TEXT ("Exception raised while removing servant"));
 260       return -1;
 261     }
 262
 263   return 0;
 264 }
 265
 266 TAO_Naming_Client&
 267 LB_server::name_svc ()
 268 {
 269   return name_svc_;
 270 }