TAO/tests/Bug_1476_Test/client.cpp

   1 #include "HelloC.h"
   2
   3 #include "tao/Messaging/Messaging.h"
   4
   5 #include "tao/Transport_Cache_Manager.h"
   6 #include "tao/ORB_Core.h"
   7 #include "tao/Thread_Lane_Resources.h"
   8 #include "tao/Base_Transport_Property.h"
   9 #include "tao/Stub.h"
  10 #include "tao/Profile.h"
  11 #include "tao/Transport.h"
  12
  13 #include "ace/Get_Opt.h"
  14
  15 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
  16 bool level_obj = false;
  17 bool level_thread = false;
  18 bool level_orb = false;
  19
  20 bool synch_none = false;
  21 bool synch_delayed = false;
  22
  23 int
  24 parse_args (int argc, ACE_TCHAR *argv[])
  25 {
  26   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:l:s:"));
  27   int c;
  28   level_obj = true; //default
  29   synch_none = true; //default
  30
  31   while ((c = get_opts ()) != -1)
  32     switch (c)
  33       {
  34       case 'k':
  35         ior = get_opts.opt_arg ();
  36         break;
  37       case 'l':
  38   {
  39     ACE_TCHAR *level = get_opts.opt_arg ();
  40     level_obj = false;
  41
  42     if (ACE_OS::strcmp (level, ACE_TEXT("orb")) == 0) {
  43       level_orb = true;
  44     }
  45     else if (ACE_OS::strcmp (level, ACE_TEXT("thread")) == 0) {
  46       level_thread = true;
  47     }
  48     else {
  49       level_obj = true;
  50     }
  51     break;
  52   }
  53       case 's':
  54   {
  55     ACE_TCHAR *synch = get_opts.opt_arg ();
  56     synch_none = false;
  57
  58     if (ACE_OS::strcmp (synch, ACE_TEXT("delayed")) == 0) {
  59       synch_delayed = true;
  60     }
  61     else {
  62       synch_none = true;
  63     }
  64     break;
  65   }
  66
  67       case '?':
  68       default:
  69         ACE_ERROR_RETURN ((LM_ERROR,
  70                            "usage:  %s "
  71                            "-k <ior> "
  72          "-l <obj|orb|thread> "
  73          "-s <none|delayed> "
  74                            "\n",
  75                            argv [0]),
  76                           -1);
  77       }
  78   // Indicates successful parsing of the command line
  79   return 0;
  80 }
  81
  82 int
  83 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
  84 {
  85   try
  86     {
  87       CORBA::ORB_var orb =
  88         CORBA::ORB_init (argc, argv, "test");
  89
  90       if (parse_args (argc, argv) != 0)
  91         return 1;
  92
  93       CORBA::Object_var tmp = orb->string_to_object(ior);
  94
  95       if (CORBA::is_nil (tmp.in ()))
  96         {
  97           ACE_ERROR_RETURN ((LM_ERROR, "Invalid IOR.\n")
  98                             ,1);
  99         }
 100
 101       {
 102         // Set the Synch Scopes
 103
 104         CORBA::Any scope_as_any;
 105
 106         if (synch_none == true)
 107           {
 108             ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Applying SYNC_NONE.\n"));
 109             scope_as_any <<= Messaging::SYNC_NONE;
 110           }
 111         else if (synch_delayed == true)
 112           {
 113             ACE_DEBUG ((LM_DEBUG,
 114                         "(%P|%t) - Applying SYNC_DELAYED_BUFFERING.\n"));
 115             scope_as_any <<= TAO::SYNC_DELAYED_BUFFERING;
 116           }
 117
 118         CORBA::PolicyList policies (1);
 119         policies.length (1);
 120         policies[0] =
 121           orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
 122                               scope_as_any);
 123
 124         if (level_thread == true)
 125           {
 126             ACE_DEBUG ((LM_DEBUG,
 127                         "(%P|%t) - Applying Synch Scope at thread level.\n"));
 128
 129             CORBA::Object_var object =
 130               orb->resolve_initial_references ("PolicyCurrent");
 131             CORBA::PolicyCurrent_var policy_current =
 132               CORBA::PolicyCurrent::_narrow (object.in ());
 133
 134             policy_current->set_policy_overrides (policies,
 135                                                   CORBA::ADD_OVERRIDE);
 136           }
 137         else if (level_orb == true)
 138           {
 139             ACE_DEBUG ((LM_DEBUG,
 140                         "(%P|%t) - Applying Synch Scope at orb level.\n"));
 141
 142             CORBA::Object_var obj =
 143               orb->resolve_initial_references("ORBPolicyManager");
 144             CORBA::PolicyManager_var policy_manager =
 145               CORBA::PolicyManager::_narrow(obj.in());
 146
 147             policy_manager->set_policy_overrides (policies,
 148                                                   CORBA::ADD_OVERRIDE);
 149           }
 150         else if (level_obj == true)
 151           {
 152             ACE_DEBUG ((LM_DEBUG,
 153                         "(%P|%t) - Applying Synch Scope at Object level.\n"));
 154
 155             tmp = tmp->_set_policy_overrides (policies, CORBA::SET_OVERRIDE);
 156           }
 157
 158         policies[0]->destroy ();
 159       }
 160
 161       Test::Hello_var hello =
 162         Test::Hello::_unchecked_narrow(tmp.in ());
 163
 164       if (CORBA::is_nil (hello.in ()))
 165         {
 166           ACE_ERROR_RETURN ((LM_ERROR,
 167                              "Nil Test::Hello reference <%s>\n",
 168                              ior),
 169                             1);
 170         }
 171
 172       // If a blocking connection is initiated in the next step
 173       // the test will get an exception indicating test failure.
 174       // Be sure you IOR is for the localhost endpoint, else
 175       // grab a book and wait around for timeout.
 176       hello->get_string ();
 177
 178       TAO::Transport_Cache_Manager &tcm =
 179         hello->orb_core ()->lane_resources ().transport_cache ();
 180
 181       TAO_Base_Transport_Property desc (hello->_stubobj ()->profile_in_use ()->endpoint ());
 182
 183       if (tcm.current_size() == 0)
 184         {
 185           ACE_ERROR_RETURN ((LM_ERROR,
 186            "The Transport Cache shouldn't be empty here.\n"),
 187           1);
 188         }
 189
 190       size_t busy_count = 0;
 191       TAO_Transport *transport = 0;
 192       TAO::Transport_Cache_Manager::Find_Result find_result =
 193         tcm.find_transport (&desc, transport, busy_count);
 194       // We don't need this transport any more. Release the ownership.
 195       transport->remove_reference ();
 196
 197       switch (find_result){
 198         case TAO::Transport_Cache_Manager::CACHE_FOUND_NONE:
 199           {
 200             ACE_ERROR_RETURN ((LM_ERROR,
 201               ACE_TEXT("Expected to find a transport in the cache.\n")
 202               ),1);
 203           }
 204         case TAO::Transport_Cache_Manager::CACHE_FOUND_CONNECTING:
 205           {
 206             ACE_DEBUG (( LM_DEBUG,
 207               ACE_TEXT ("Transport Cache contains connecting entry as expected.\n")
 208               ));
 209             break; // that's what we expected
 210           }
 211         case TAO::Transport_Cache_Manager::CACHE_FOUND_BUSY:
 212           {
 213             ACE_ERROR_RETURN ((LM_ERROR,
 214               ACE_TEXT("Cached Transport is busy.  Should not happen because there's no server.\n")
 215               ),1);
 216           }
 217         case TAO::Transport_Cache_Manager::CACHE_FOUND_AVAILABLE:
 218           {
 219             ACE_ERROR_RETURN ((LM_ERROR,
 220               ACE_TEXT("Cached Transport is available.  Should not happen because there's no server.\n")
 221               ),1);
 222           }
 223         default:
 224           {
 225             ACE_ERROR_RETURN ((LM_ERROR,
 226               ACE_TEXT("Transport_Cache::find returned unknown status.\n")
 227               ),1);
 228           }
 229       }
 230
 231       orb->destroy ();
 232     }
 233   catch (const CORBA::Exception &ex)
 234     {
 235       ACE_ERROR ((LM_ERROR, "ERROR: Exception caught: %s\"%s\"\n"
 236       , ex._name(), ex._rep_id ()));
 237       return 1;
 238     }
 239
 240   return 0;
 241 }