TAO/tests/Portable_Interceptors/AdvSlotExt/server.cpp

   1 // author    : Boris Kolpackov <boris@kolpackov.net>
   2 #include "tao/LocalObject.h"
   3 #include "tao/ORBInitializer_Registry.h"
   4
   5 #include "tao/PI/PI.h"
   6 #include "tao/PI_Server/PI_Server.h"
   7
   8 #include "ace/OS_NS_stdio.h"
   9 #include "ace/Get_Opt.h"
  10
  11 #include "StateTransferS.h"
  12
  13 const ACE_TCHAR *ior_output_file = ACE_TEXT ("test.ior");
  14
  15 int
  16 parse_args (int argc, ACE_TCHAR *argv[])
  17 {
  18   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("o:"));
  19   int c;
  20
  21   while ((c = get_opts ()) != -1)
  22     switch (c)
  23       {
  24       case 'o':
  25         ior_output_file = get_opts.opt_arg ();
  26         break;
  27
  28       case '?':
  29       default:
  30         ACE_ERROR_RETURN ((LM_ERROR,
  31                            "usage:  %s "
  32                            "-o <iorfile>"
  33                            "\n",
  34                            argv [0]),
  35                           -1);
  36       }
  37   // Indicates successful parsing of the command line
  38   return 0;
  39 }
  40
  41 using namespace CORBA;
  42 using namespace PortableServer;
  43 using namespace PortableInterceptor;
  44
  45 //
  46 PortableInterceptor::SlotId slot_id;
  47
  48
  49 //
  50 class StateTransferImpl: public virtual POA_StateTransfer
  51 {
  52 public:
  53   StateTransferImpl (ORB_ptr orb)
  54       : orb_ (ORB::_duplicate (orb))
  55   {
  56   }
  57
  58   virtual Short
  59   number ()
  60   {
  61     // Prepare state update.
  62     //
  63     Any state;
  64     CORBA::Long number = 5;
  65     state <<= number;
  66
  67     Object_var obj (orb_->resolve_initial_references ("PICurrent"));
  68     PortableInterceptor::Current_var pic (
  69       PortableInterceptor::Current::_narrow (obj.in ()));
  70
  71     pic->set_slot (slot_id, state);
  72
  73     return 1;
  74   }
  75
  76   //FUZZ: disable check_for_lack_ACE_OS
  77   virtual void
  78   shutdown ()
  79   {
  80     ACE_DEBUG ((LM_DEBUG, "Server is shutting down.\n"));
  81     this->orb_->shutdown (0);
  82   }
  83   //FUZZ: enable check_for_lack_ACE_OS
  84
  85 private:
  86   ORB_var orb_;
  87 };
  88
  89
  90 //
  91 class ReplicaController: public virtual ServerRequestInterceptor,
  92                          public virtual ::CORBA::LocalObject
  93 {
  94 public:
  95   ReplicaController (PortableInterceptor::Current_ptr pi_current)
  96    : pi_current_ (PortableInterceptor::Current::_duplicate (pi_current))
  97   {
  98   }
  99
 100   virtual char*
 101   name ()
 102   {
 103     return string_dup ("ReplicaController");
 104   }
 105
 106   virtual void
 107   destroy ()
 108   {
 109   }
 110
 111 #if TAO_HAS_EXTENDED_FT_INTERCEPTORS == 1
 112   virtual void
 113   tao_ft_interception_point (ServerRequestInfo_ptr, OctetSeq_out)
 114   {
 115   }
 116 #endif /*TAO_HAS_EXTENDED_FT_INTERCEPTORS*/
 117
 118   virtual void
 119   receive_request_service_contexts (ServerRequestInfo_ptr)
 120   {
 121   }
 122
 123   virtual void
 124   receive_request (ServerRequestInfo_ptr ri)
 125   {
 126     Any state;
 127     CORBA::Long number = 5;
 128     state <<= number;
 129
 130     // After we have set things to TSC, change the value in RSC, at this
 131     // moment no copy should be done anymore.
 132     pi_current_->set_slot (slot_id, state);
 133     CORBA::Long number6 = 6;
 134     state <<= number6;
 135     ri->set_slot (slot_id, state);
 136
 137     Any_var state_get (pi_current_->get_slot (slot_id));
 138     CORBA::Long n (0);
 139     state_get >>= n;
 140
 141     if (n == 5)
 142       ACE_DEBUG ((LM_DEBUG, "State value is correctly %d.\n", n));
 143     else
 144       ACE_ERROR ((LM_ERROR, "ERROR: State value is incorrectly %d.\n", n));
 145   }
 146
 147   virtual void
 148   send_reply (ServerRequestInfo_ptr ri)
 149   {
 150     CORBA::String_var op = ri->operation ();
 151
 152     if (ACE_OS::strcmp (op.in (), "number") != 0)
 153       return; // Don't mess with PICurrent if not invoking test method.
 154
 155     Any_var state (ri->get_slot (slot_id));
 156     CORBA::Long n (0);
 157     state >>= n;
 158
 159     if (n == 5)
 160       ACE_DEBUG ((LM_DEBUG, "State value is correctly %d.\n", n));
 161     else
 162       ACE_ERROR ((LM_ERROR, "ERROR: State value is incorrectly %d.\n", n));
 163   }
 164
 165   virtual void
 166   send_exception (ServerRequestInfo_ptr)
 167   {
 168   }
 169
 170   virtual void
 171   send_other (ServerRequestInfo_ptr)
 172   {
 173   }
 174   PortableInterceptor::Current_var pi_current_;
 175 };
 176
 177
 178 //
 179 class ORB_Initializer : public virtual ORBInitializer,
 180                         public virtual ::CORBA::LocalObject
 181 {
 182 public:
 183   virtual void
 184   pre_init (ORBInitInfo_ptr)
 185   {
 186   }
 187
 188   virtual void
 189   post_init (ORBInitInfo_ptr info)
 190   {
 191     slot_id = info->allocate_slot_id ();
 192     ACE_DEBUG ((LM_DEBUG, "Allocated slot with id %d.\n", slot_id));
 193
 194     CORBA::Object_var obj =
 195       info->resolve_initial_references ("PICurrent");
 196
 197     PortableInterceptor::Current_var pi_current =
 198       PortableInterceptor::Current::_narrow (obj.in ());
 199
 200     if (CORBA::is_nil (pi_current.in ()))
 201       {
 202         ACE_ERROR ((LM_ERROR,
 203                     "(%P|%t) ERROR: Could not resolve PICurrent object.\n"));
 204
 205         throw CORBA::INTERNAL ();
 206       }
 207
 208     ServerRequestInterceptor_var interceptor (new ReplicaController (pi_current.in ()));
 209     info->add_server_request_interceptor (interceptor.in ());
 210   }
 211 };
 212
 213 int
 214 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 215 {
 216   try
 217     {
 218       ORBInitializer_var orb_initializer (new ORB_Initializer ());
 219       register_orb_initializer (orb_initializer.in ());
 220
 221       ORB_var orb (ORB_init (argc, argv));
 222
 223       if (parse_args (argc, argv) != 0)
 224         return 1;
 225
 226       Object_var obj (orb->resolve_initial_references ("RootPOA"));
 227
 228       POA_var root_poa (POA::_narrow (obj.in ()));
 229       POAManager_var poa_manager (root_poa->the_POAManager ());
 230
 231       StateTransferImpl* impl = new StateTransferImpl (orb.in ());
 232       ServantBase_var impl_var (impl);
 233
 234       PortableServer::ObjectId_var id_act =
 235         root_poa->activate_object (impl);
 236
 237       CORBA::Object_var object = root_poa->id_to_reference (id_act.in ());
 238
 239       StateTransfer_var ref = StateTransfer::_narrow (object.in ());
 240       String_var ior (orb->object_to_string (ref.in ()));
 241
 242       poa_manager->activate ();
 243
 244
 245       // Dump the ior.
 246       //
 247       FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
 248       if (output_file == 0)
 249       {
 250         ACE_ERROR_RETURN ((LM_ERROR,
 251                           "Cannot open output file <%s> for writing "
 252                           "IOR: %s",
 253                           ior_output_file,
 254                           ior.in ()),
 255                           1);
 256       }
 257
 258       ACE_OS::fprintf (output_file, "%s", ior.in ());
 259       ACE_OS::fclose (output_file);
 260
 261       ACE_DEBUG ((LM_DEBUG, "Server is ready, IOR is in '%s'\n", ior_output_file));
 262
 263
 264       // Run the ORB event loop.
 265       //
 266       orb->run ();
 267
 268       root_poa->destroy (1, 1);
 269       orb->destroy ();
 270
 271       ACE_DEBUG ((LM_DEBUG, "Event loop finished.\n"));
 272     }
 273   catch (const CORBA::Exception& ex)
 274     {
 275       ex._tao_print_exception ("Exception caught:");
 276       return 1;
 277     }
 278
 279   return 0;
 280 }