TAO/orbsvcs/tests/FT_Naming/stress_storable/client.cpp

   1 #include "TestC.h"
   2 #include "ace/Get_Opt.h"
   3 #include "ace/Time_Value.h"
   4 #include "orbsvcs/Naming/Naming_Client.h"
   5 #include "orbsvcs/FT_NamingManagerC.h"
   6 #include "orbsvcs/Naming/FaultTolerant/nsgroup_svc.h"
   7 #include "ace/Task.h"
   8
   9
  10 const ACE_TCHAR *group_names[] =
  11   {ACE_TEXT("C++ Group"), ACE_TEXT("FORTRAN Group"), ACE_TEXT("Groovy Group"), ACE_TEXT("Basic Group"),
  12    ACE_TEXT("Java Group"), ACE_TEXT("Forth Group"), ACE_TEXT("COBOL Group"), ACE_TEXT("Ruby Group"),
  13    ACE_TEXT("wrong answer dude"), ACE_TEXT("Scala Group"), ACE_TEXT("R Group"), 0};
  14
  15 class Hammer : public ACE_Task_Base
  16 {
  17   NS_group_svc group_svc;
  18
  19 public:
  20   Hammer ()
  21     : group_svc(true)
  22   {}
  23
  24   int setup (CORBA::ORB_ptr orb, FT_Naming::NamingManager_ptr nm)
  25   {
  26     if (group_svc.set_orb (orb) != 0 || group_svc.set_naming_manager (nm))
  27       {
  28         ACE_DEBUG ((LM_DEBUG, "Hammer setup failed\n"));
  29         return -1;
  30       }
  31     return 0;
  32   }
  33
  34   int svc ()
  35   {
  36     for (int g = 0, i = 0; i < 100; i++)
  37       {
  38         try {
  39           group_svc.member_list (group_names[g]);
  40         }
  41         catch (PortableGroup::ObjectGroupNotFound&) {
  42           }
  43         catch (CORBA::Exception &ex) {
  44           ACE_DEBUG ((LM_DEBUG,
  45                       ACE_TEXT ("Hammer thread %t caught %C accessing %C\n"),
  46                       ex._name(), group_names[g]));
  47         }
  48         if (group_names[++g] == 0)
  49           g = 0;
  50       }
  51
  52     return 0;
  53   }
  54 };
  55
  56 const ACE_TCHAR *ior = ACE_TEXT("file://obj.ior");
  57 int hammers = 10;
  58
  59 int
  60 parse_args (int argc, ACE_TCHAR *argv[])
  61 {
  62   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:n:"));
  63   int c;
  64
  65   while ((c = get_opts ()) != -1)
  66     switch (c)
  67       {
  68       case 'k':
  69         ior = get_opts.opt_arg ();
  70         break;
  71       case 'n':
  72         hammers = ACE_OS::atoi (get_opts.opt_arg ());
  73         break;
  74       case '?':
  75       default:
  76         ACE_ERROR_RETURN ((LM_ERROR,
  77                            ACE_TEXT ("usage:  %s ")
  78                            ACE_TEXT ("-k <ior> ")
  79                            ACE_TEXT ("\n"),
  80                            argv [0]),
  81                           -1);
  82       }
  83   // Indicates successful parsing of the command line
  84   return 0;
  85 }
  86
  87 int
  88 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
  89 {
  90   try
  91     {
  92       CORBA::ORB_var orb =
  93         CORBA::ORB_init (argc, argv);
  94
  95       if (parse_args (argc, argv) != 0)
  96         return 1;
  97
  98       ACE_DEBUG ((LM_DEBUG,
  99                   ACE_TEXT ("(%P|%t) - Acquiring Name Service\n")));
 100
 101
 102       CORBA::Object_var nmobj = orb->resolve_initial_references ("NameManager");
 103       FT_Naming::NamingManager_var naming_manager =
 104         FT_Naming::NamingManager::_narrow (nmobj.in());
 105
 106       TAO_Naming_Client name_svc;
 107       try {
 108         ACE_Time_Value timeout (10); // Wait up to 10 seconds for the naming service
 109         if (name_svc.init (orb.in (), &timeout) != 0)
 110           ACE_ERROR_RETURN ((LM_DEBUG,
 111                              ACE_TEXT ("client: Could not connect to ")
 112                              ACE_TEXT ("naming service.\n")),
 113                             1);
 114       }
 115       catch (const CORBA::Exception& ex)
 116       {
 117         ex._tao_print_exception (
 118           ACE_TEXT ("Exception caught while initializing name ")
 119           ACE_TEXT ("service facade:"));
 120         return 1;
 121       }
 122
 123
 124       Hammer hammer;
 125
 126       if (hammer.setup(orb.in(), naming_manager.in()) == -1)
 127         {
 128           return 1;
 129         }
 130
 131       CosNaming::Name name (1);
 132       name.length (1);
 133       name[0].id = CORBA::string_dup ("basic_name");
 134
 135       CORBA::Object_var tmp;
 136       Test::Basic_var basic;
 137
 138       // Iterate enough so we get a few wrap-arounds
 139       for (int i = 0; i < 15; i++)
 140       {
 141         if (i == 3) {
 142           hammer.activate (THR_NEW_LWP | THR_JOINABLE, hammers);
 143         }
 144
 145         try {
 146           // Each time we invoke resolve, we get a different member
 147           tmp =
 148             name_svc->resolve (name);
 149
 150           // Narrow it to a Basic object
 151           basic =
 152             Test::Basic::_narrow (tmp.in ());
 153         }
 154         catch (CORBA::Exception& ex)
 155           {
 156             ex._tao_print_exception (ACE_TEXT ("Error resolving name.\n"));
 157           }
 158
 159         if (CORBA::is_nil (basic.in ()))
 160           {
 161             ACE_ERROR_RETURN ((LM_DEBUG,
 162                                ACE_TEXT ("Server obj ref not obtained ")
 163                                ACE_TEXT ("from Load Balancing Name Service\n"),
 164                                ior),
 165                               1);
 166           }
 167
 168         try {
 169           CORBA::String_var the_string =
 170             basic->get_string ();
 171
 172           ACE_DEBUG ((LM_DEBUG,
 173                       ACE_TEXT ("(%P|%t) - Client request handled ")
 174                       ACE_TEXT ("by object at <%C>\n"),
 175                       the_string.in ()));
 176         }
 177         catch (CORBA::Exception& ex)
 178           {
 179             ex._tao_print_exception (
 180               ACE_TEXT ("Error invoking get_string on Basic object.\n"));
 181             return 1;
 182           }
 183
 184         // Remove one member after we wrapped around to make sure naming manager can
 185         // handle it successufully
 186         if (i == 7)
 187           {
 188             try {
 189               // Try removing a member
 190               basic->remove_member ();
 191             }
 192             catch (CORBA::Exception& ex)
 193               {
 194                 ex._tao_print_exception (
 195                   ACE_TEXT ("Error invoking get_string on Basic object.\n"));
 196                 return 1;
 197               }
 198           }
 199       }
 200
 201       hammer.wait ();
 202
 203       try {
 204         basic->shutdown ();
 205
 206         ACE_DEBUG ((LM_DEBUG,
 207                     ACE_TEXT ("(%P|%t) - Shutting down server\n")));
 208       }
 209       catch (CORBA::Exception& ex)
 210       {
 211         ex._tao_print_exception (
 212           ACE_TEXT ("Error invoking get_string on Basic object.\n"));
 213         return 1;
 214       }
 215       orb->destroy ();
 216   }
 217   catch (const CORBA::Exception& ex)
 218   {
 219     ex._tao_print_exception (
 220       ACE_TEXT ("Exception caught in client.cpp:"));
 221     return 1;
 222   }
 223
 224   return 0;
 225 }