TAO/examples/Persistent_Grid/Simple_util.cpp

   1 #ifndef SIMPLE_UTIL_C
   2 #define SIMPLE_UTIL_C
   3 # include "Simple_util.h"
   4 # include "tao/debug.h"
   5 # include "ace/OS_NS_fcntl.h"
   6 # include "ace/OS_NS_unistd.h"
   7 # include "ace/OS_NS_stdio.h"
   8 # include "ace/OS_NS_string.h"
   9
  10 // Constructor.
  11
  12 template <class Servant>
  13 Server<Servant>::Server (void)
  14   : ior_output_file_ (0),
  15     mem_pool_name_ (0)
  16 {
  17 }
  18
  19 // Destructor.
  20
  21 template <class Servant>
  22 Server<Servant>::~Server (void)
  23 {
  24 }
  25
  26 // Parse the command-line arguments and set options.
  27
  28 template <class Servant> int
  29 Server<Servant>::parse_args (void)
  30 {
  31   ACE_Get_Opt get_opts (this->argc_, this->argv_, ACE_TEXT("do:m:"));
  32   int c = 0;
  33
  34   while ((c = get_opts ()) != -1)
  35     switch (c)
  36       {
  37       case 'd':  // debug flag.
  38         TAO_debug_level++;
  39         break;
  40       case 'o':  // output the IOR to a file.
  41         this->ior_output_file_ = ACE_OS::fopen (get_opts.opt_arg (), "w");
  42         if (this->ior_output_file_ == 0)
  43           ACE_ERROR_RETURN ((LM_ERROR,
  44                              "Unable to open %s for writing: %p\n",
  45                              get_opts.opt_arg ()), -1);
  46         break;
  47
  48       case 'm':
  49         this->mem_pool_name_ = get_opts.opt_arg ();
  50         break;
  51       case '?':  // display help for use of the server.
  52       default:
  53         ACE_ERROR_RETURN ((LM_ERROR,
  54                            "usage:  %s"
  55                            " [-d]"
  56                            " [-o] <ior_output_file>"
  57                            "\n",
  58                            this->argv_ [0]),
  59                           -1);
  60       }
  61
  62   // Indicates successful parsing of command line.
  63   return 0;
  64 }
  65
  66
  67 // Initialize the server.
  68 template <class Servant> int
  69 Server<Servant>::init (const char *servant_name,
  70                        int argc,
  71                        ACE_TCHAR *argv[])
  72 {
  73   // Call the init of <TAO_ORB_Manager> to initialize the ORB and
  74   // create a child POA under the root POA.
  75   if (this->orb_manager_.init_child_poa (argc,
  76                                          argv,
  77                                          "child_poa") == -1)
  78     ACE_ERROR_RETURN ((LM_ERROR,
  79                        "%p\n",
  80                        "init_child_poa"),
  81                       -1);
  82
  83
  84   this->argc_ = argc;
  85   this->argv_ = argv;
  86
  87   int retval = this->parse_args ();
  88
  89   if (retval != 0)
  90     return retval;
  91
  92   CORBA::ORB_var orb = this->orb_manager_.orb ();
  93
  94   // Stash our ORB pointer for later reference.
  95   this->servant_.orb (orb.in ());
  96
  97   // Stash the memory pool name for reference
  98   this->servant_.pool_name (mem_pool_name_);
  99
 100   // Activate the servant in its own child POA.
 101
 102   // Make sure that you check for failures here via the ACE_TRY
 103   // macros?!
 104   try
 105     {
 106       CORBA::String_var str  =
 107         this->orb_manager_.activate_under_child_poa (servant_name,
 108                                                      &this->servant_);
 109
 110       ACE_DEBUG ((LM_DEBUG,
 111                   "The IOR is: <%C>\n",
 112                   str.in ()));
 113
 114       if (this->ior_output_file_)
 115         {
 116           ACE_OS::fprintf (this->ior_output_file_,
 117                            "%s",
 118                            str.in ());
 119           ACE_OS::fclose (this->ior_output_file_);
 120         }
 121
 122     }
 123   catch (const CORBA::Exception& ex)
 124     {
 125       ex._tao_print_exception ("\tException in activation of POA");
 126       return -1;
 127     }
 128
 129   return 0;
 130 }
 131
 132 template <class Servant> int
 133 Server<Servant>::run (void)
 134 {
 135     // Run the main event loop for the ORB.
 136   int ret = this->orb_manager_.run ();
 137
 138   if (ret == -1)
 139     ACE_ERROR_RETURN ((LM_ERROR,
 140                        "Server_i::run"),
 141                       -1);
 142
 143   return 0;
 144 }
 145
 146
 147
 148 /////////////////////////////////////////////////////////////////
 149 //      Client code Starts here
 150 ////////////////////////////////////////////////////////////////
 151
 152 // Constructor.
 153 template <class InterfaceObj, class Var>
 154 Client<InterfaceObj, Var>::Client (void)
 155   : ior_ (0)
 156 {
 157   //no-op
 158 }
 159
 160 // Reads the Server ior from a file
 161
 162 template <class InterfaceObj, class Var> int
 163 Client<InterfaceObj, Var>::read_ior (ACE_TCHAR *filename)
 164 {
 165   // Open the file for reading.
 166   ACE_HANDLE f_handle = ACE_OS::open (filename, 0);
 167
 168   if (f_handle == ACE_INVALID_HANDLE)
 169     ACE_ERROR_RETURN ((LM_ERROR,
 170                        "Unable to open %s for writing: %p\n",
 171                        filename),
 172                       -1);
 173
 174   ACE_Read_Buffer ior_buffer (f_handle);
 175   char *data = ior_buffer.read ();
 176
 177   if (data == 0)
 178     ACE_ERROR_RETURN ((LM_ERROR,
 179                        "Unable to read ior: %p\n"),
 180                       -1);
 181
 182   this->ior_ = ACE_OS::strdup (data);
 183   ior_buffer.alloc ()->free (data);
 184
 185   ACE_OS::close (f_handle);
 186
 187   return 0;
 188 }
 189
 190 // Parses the command line arguments and returns an error status.
 191
 192 template <class InterfaceObj, class Var> int
 193 Client<InterfaceObj, Var>::parse_args (void)
 194 {
 195   ACE_Get_Opt get_opts (argc_, argv_, ACE_TEXT("df:k:x"));
 196   int c = 0;
 197   int result = 0;
 198
 199   while ((c = get_opts ()) != -1)
 200     switch (c)
 201       {
 202       case 'd':  // debug flag
 203         TAO_debug_level++;
 204         break;
 205       case 'k':  // ior provide on command line
 206         this->ior_ = ACE_OS::strdup (ACE_TEXT_ALWAYS_CHAR(get_opts.opt_arg ()));
 207         break;
 208       case 'f': // read the IOR from the file.
 209         result = this->read_ior (get_opts.opt_arg ());
 210         if (result < 0)
 211           ACE_ERROR_RETURN ((LM_ERROR,
 212                              "Unable to read ior from %s : %p\n",
 213                              get_opts.opt_arg ()),
 214                             -1);
 215         break;
 216       case 'x': // read the flag for shutting down
 217         this->shutdown_ = 1;
 218         break;
 219       }
 220
 221   // Indicates successful parsing of command line.
 222   return 0;
 223 }
 224
 225 template <class InterfaceObj, class Var>
 226 Client<InterfaceObj, Var>::~Client (void)
 227 {
 228   ACE_OS::free (this->ior_);
 229 }
 230
 231 template <class InterfaceObj, class Var> int
 232 Client<InterfaceObj, Var>::init (const char * /*name*/,
 233                                  int argc,
 234                                  ACE_TCHAR **argv)
 235 {
 236   this->argc_ = argc;
 237   this->argv_ = argv;
 238
 239   try
 240     {
 241       // Retrieve the ORB.
 242       this->orb_ = CORBA::ORB_init (this->argc_, this->argv_);
 243
 244       // Parse command line and verify parameters.
 245       if (this->parse_args () == -1)
 246         return -1;
 247
 248       if(this->ior_ != 0)
 249         {
 250           CORBA::Object_var server_object =
 251             this->orb_->string_to_object (this->ior_);
 252
 253           if (CORBA::is_nil (server_object.in ()))
 254             ACE_ERROR_RETURN ((LM_ERROR,
 255                                "invalid ior <%C>\n",
 256                                this->ior_),
 257                               -1);
 258           this->server_ = InterfaceObj::_narrow (server_object.in ());
 259         }
 260       else
 261         ACE_ERROR_RETURN ((LM_ERROR,
 262                            "no ior or naming options  specified\n"),
 263                           -1);
 264
 265
 266     }
 267   catch (const CORBA::Exception& ex)
 268     {
 269       ex._tao_print_exception ("Client_i::init");
 270       return -1;
 271     }
 272
 273
 274   return 0;
 275 }
 276
 277
 278 template <class InterfaceObj, class Var> int
 279 Client<InterfaceObj, Var>::shutdown (void)
 280 {
 281   // Returns the shutdwon flag
 282   return shutdown_;
 283 }
 284
 285 template <class InterfaceObj, class Var> void
 286 Client<InterfaceObj, Var>::shutdown (int flag)
 287 {
 288   // Fills the flag
 289   shutdown_ = flag;
 290 }
 291
 292 #endif