TAO/tests/Portable_Interceptors/AdvSlotDblCpy/server.cpp

   1 // author    : Boris Kolpackov <boris@kolpackov.net>
   2 #include "tao/AnyTypeCode/AnyTypeCode_methods.h"
   3
   4 #include "tao/PI/PI.h"
   5 #include "tao/PI_Server/PI_Server.h"
   6
   7 #include "tao/LocalObject.h"
   8 #include "tao/ORBInitializer_Registry.h"
   9
  10 #include "ace/OS_NS_stdio.h"
  11 #include "ace/Get_Opt.h"
  12
  13 #include "InvokeMeS.h"
  14
  15 using namespace CORBA;
  16 using namespace PortableServer;
  17 using namespace PortableInterceptor;
  18
  19 const ACE_TCHAR *ior_output_file = ACE_TEXT ("test.ior");
  20
  21 int
  22 parse_args (int argc, ACE_TCHAR *argv[])
  23 {
  24   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("o:"));
  25   int c;
  26
  27   while ((c = get_opts ()) != -1)
  28     switch (c)
  29       {
  30       case 'o':
  31         ior_output_file = get_opts.opt_arg ();
  32         break;
  33
  34       case '?':
  35       default:
  36         ACE_ERROR_RETURN ((LM_ERROR,
  37                            "usage:  %s "
  38                            "-o <iorfile>"
  39                            "\n",
  40                            argv [0]),
  41                           -1);
  42       }
  43   // Indicates successful parsing of the command line
  44   return 0;
  45 }
  46
  47
  48 namespace
  49 {
  50   PortableInterceptor::SlotId slot_id;
  51
  52   CORBA::Long getMySlot(
  53     PortableInterceptor::ServerRequestInfo_ptr ri,
  54     PortableInterceptor::Current_ptr pi_current,
  55     const char *location,
  56     const CORBA::Long correctTSCvalue,
  57     const CORBA::Long correctRSCvalue)
  58   {
  59     CORBA::Long number= 0;
  60     CORBA::String_var
  61       op= ri->operation ();
  62
  63     const bool correctOperation=
  64       (0 == ACE_OS::strcmp( op.in (), "invoke_me" ));
  65
  66     if (correctOperation)
  67     {
  68       CORBA::Any_var data;
  69
  70       ACE_DEBUG ((LM_DEBUG, "SERVER %C -> get_slot(TSC) -> is ", location));
  71       data= pi_current->get_slot(slot_id);
  72       CORBA::TypeCode_var
  73         tc= data->type();
  74       if (tc->kind() == CORBA::tk_null)
  75       {
  76         ACE_DEBUG ((LM_DEBUG, "EMPTY -> "));
  77         if (0 != correctTSCvalue)
  78         {
  79           ACE_DEBUG ((LM_DEBUG, "WRONG\n"));
  80           throw INTERNAL ();
  81         }
  82         ACE_DEBUG ((LM_DEBUG, "OK\n"));
  83       }
  84       else if (data.in() >>= number)
  85       {
  86         ACE_DEBUG ((LM_DEBUG, "long (%d) -> ", number));
  87         if ((0 != correctTSCvalue) && (correctTSCvalue != number))
  88         {
  89           ACE_DEBUG ((LM_DEBUG, "WRONG\n"));
  90           throw INTERNAL ();
  91         }
  92         ACE_DEBUG ((LM_DEBUG, "OK\n"));
  93       }
  94       else
  95       {
  96         ACE_DEBUG ((LM_DEBUG, "UNKNOWN TYPE\n"));
  97         throw INTERNAL ();
  98       }
  99
 100       ACE_DEBUG ((LM_DEBUG, "SERVER %C -> get_slot(RSC) -> is ", location));
 101       data= ri->get_slot(slot_id);
 102
 103       tc= data->type();
 104       if (tc->kind() == CORBA::tk_null)
 105       {
 106         ACE_DEBUG ((LM_DEBUG, "EMPTY -> "));
 107         if (0 != correctRSCvalue)
 108         {
 109           ACE_DEBUG ((LM_DEBUG, "WRONG\n"));
 110           throw INTERNAL ();
 111         }
 112         ACE_DEBUG ((LM_DEBUG, "OK\n"));
 113 #if TAO_HAS_EXTENDED_FT_INTERCEPTORS == 1
 114         number= 61;
 115 #else
 116         number= 62;
 117 #endif /* TAO_HAS_EXTENDED_FT_INTERCEPTORS == 1 */
 118       }
 119       else if (data.in() >>= number)
 120       {
 121         ACE_DEBUG ((LM_DEBUG, "long (%d) -> ", number));
 122         if ((0 != correctRSCvalue) && (correctRSCvalue != number))
 123         {
 124           ACE_DEBUG ((LM_DEBUG, "WRONG\n"));
 125           throw INTERNAL ();
 126         }
 127         ACE_DEBUG ((LM_DEBUG, "OK\n"));
 128         ++number;
 129       }
 130       else
 131       {
 132         ACE_DEBUG ((LM_DEBUG, "WRONG TYPE\n"));
 133         throw INTERNAL();
 134       }
 135     }
 136
 137     return number;
 138   }
 139
 140   void getAndSetMySlot(
 141     PortableInterceptor::ServerRequestInfo_ptr ri,
 142     PortableInterceptor::Current_ptr pi_current,
 143     const char *location,
 144     const CORBA::Long correctTSCvalue,
 145     const CORBA::Long correctRSCvalue)
 146   {
 147     const CORBA::Long number=
 148       getMySlot(
 149         ri,
 150         pi_current,
 151         location,
 152         correctTSCvalue,
 153         correctRSCvalue);
 154
 155     if (number && (0 != ACE_OS::strcmp( location, "receive_request" )))
 156     {
 157       // Insert data into the RSC (request scope current).
 158       CORBA::Any data;
 159       data <<= number;
 160
 161       ACE_DEBUG ((LM_DEBUG, "SERVER %C -> set_slot(RSC)", location));
 162       ri->set_slot( slot_id, data);
 163
 164       ACE_DEBUG ((LM_DEBUG, " -> long (%d)\n", number));
 165
 166       getMySlot(
 167           ri,
 168           pi_current,
 169           location,
 170           correctTSCvalue,
 171           number);
 172     }
 173   }
 174 }
 175
 176 //
 177 class InvokeMeImpl: public virtual POA_InvokeMe
 178 {
 179 public:
 180   InvokeMeImpl (ORB_ptr orb)
 181       : orb_ (ORB::_duplicate (orb))
 182   {
 183   }
 184
 185   virtual void invoke_me()
 186   {
 187     ACE_DEBUG ((LM_DEBUG, "invoke_me\n"));
 188   }
 189
 190   //FUZZ: disable check_for_lack_ACE_OS
 191   virtual void
 192   shutdown ()
 193   {
 194     ACE_DEBUG ((LM_DEBUG, "\nServer is shutting down.\n"));
 195     this->orb_->shutdown (false);
 196   }
 197   //FUZZ: enable check_for_lack_ACE_OS
 198
 199 private:
 200   ORB_var orb_;
 201 };
 202
 203
 204 //
 205 class ReplicaController: public virtual ServerRequestInterceptor,
 206                          public virtual ::CORBA::LocalObject
 207 {
 208   PortableInterceptor::Current_ptr pi_current_;
 209 public:
 210   ReplicaController (PortableInterceptor::Current_ptr pi_current )
 211     : pi_current_( pi_current )
 212   {
 213   }
 214
 215   virtual char*
 216   name ()
 217   {
 218     return string_dup ("ReplicaController");
 219   }
 220
 221   virtual void
 222   destroy ()
 223   {
 224   }
 225
 226 #if TAO_HAS_EXTENDED_FT_INTERCEPTORS == 1
 227   virtual void
 228   tao_ft_interception_point (ServerRequestInfo_ptr ri, OctetSeq_out)
 229   {
 230     getAndSetMySlot( ri, this->pi_current_, "tao_ft_interception_point", 0, 0);
 231   }
 232 #endif /*TAO_HAS_EXTENDED_FT_INTERCEPTORS*/
 233
 234   virtual void
 235   receive_request_service_contexts (ServerRequestInfo_ptr ri)
 236   {
 237 #if TAO_HAS_EXTENDED_FT_INTERCEPTORS == 1
 238     getAndSetMySlot( ri, this->pi_current_, "receive_request_service_contexts", 0, 61);
 239 #else
 240     getAndSetMySlot( ri, this->pi_current_, "receive_request_service_contexts", 0, 0);
 241 #endif /* TAO_HAS_EXTENDED_FT_INTERCEPTORS == 1 */
 242   }
 243
 244   virtual void
 245   receive_request (ServerRequestInfo_ptr ri)
 246   {
 247     getAndSetMySlot( ri, this->pi_current_, "receive_request", 62, 62);
 248   }
 249
 250   virtual void
 251   send_reply (ServerRequestInfo_ptr ri)
 252   {
 253     getAndSetMySlot( ri, this->pi_current_, "send_reply", 62, 62);
 254   }
 255
 256   virtual void
 257   send_exception (ServerRequestInfo_ptr ri)
 258   {
 259     getAndSetMySlot( ri, this->pi_current_, "send_exception", 62, 62);
 260   }
 261
 262   virtual void
 263   send_other (ServerRequestInfo_ptr ri)
 264   {
 265     getAndSetMySlot( ri, this->pi_current_, "send_other", 62, 62);
 266   }
 267 };
 268
 269 class ORB_Initializer : public virtual ORBInitializer,
 270                         public virtual ::CORBA::LocalObject
 271 {
 272 public:
 273   virtual void
 274   pre_init (ORBInitInfo_ptr)
 275   {
 276   }
 277
 278   virtual void
 279   post_init (ORBInitInfo_ptr info)
 280   {
 281     CORBA::Object_var obj =
 282       info->resolve_initial_references ("PICurrent");
 283
 284     PortableInterceptor::Current_var pi_current =
 285       PortableInterceptor::Current::_narrow (obj.in ());
 286
 287     slot_id = info->allocate_slot_id ();
 288     ACE_DEBUG ((LM_DEBUG, "Allocated slot with id %d.\n", slot_id));
 289
 290     ServerRequestInterceptor_var
 291       interceptor (new ReplicaController (pi_current.in ()));
 292     info->add_server_request_interceptor (interceptor.in ());
 293   }
 294 };
 295
 296 int
 297 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 298 {
 299   ORBInitializer_var orb_initializer (new ORB_Initializer ());
 300   register_orb_initializer (orb_initializer.in ());
 301
 302   ORB_var orb (ORB_init (argc, argv));
 303
 304   if (parse_args (argc, argv) != 0)
 305     return 1;
 306
 307   Object_var obj (orb->resolve_initial_references ("RootPOA"));
 308
 309   POA_var root_poa (POA::_narrow (obj.in ()));
 310   POAManager_var poa_manager (root_poa->the_POAManager ());
 311
 312   InvokeMeImpl* impl = new InvokeMeImpl (orb.in ());
 313   ServantBase_var impl_var (impl);
 314
 315   PortableServer::ObjectId_var id_act =
 316     root_poa->activate_object (impl);
 317
 318   CORBA::Object_var object = root_poa->id_to_reference (id_act.in ());
 319
 320   InvokeMe_var ref = InvokeMe::_narrow (object.in ());
 321   String_var ior (orb->object_to_string (ref.in ()));
 322
 323   poa_manager->activate ();
 324
 325   // Dump the ior.
 326   //
 327   FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
 328   if (output_file == 0)
 329   {
 330     ACE_ERROR_RETURN ((LM_ERROR,
 331                        "Cannot open output file <%s> for writing "
 332                        "IOR: %C",
 333                        ior_output_file,
 334                        ior.in ()),
 335                       1);
 336   }
 337
 338   ACE_OS::fprintf (output_file, "%s", ior.in ());
 339   ACE_OS::fclose (output_file);
 340
 341   ACE_DEBUG ((LM_DEBUG, "Server is ready, IOR is in '%s'\n", ior_output_file));
 342
 343   // Run the ORB event loop.
 344   //
 345   orb->run ();
 346
 347   root_poa->destroy (true, true);
 348   orb->destroy ();
 349
 350   ACE_DEBUG ((LM_DEBUG, "Event loop finished.\n"));
 351
 352   return 0;
 353 }