ChangeLogTag: Mon Oct 3 10:02:06 2005 Simon McQueen <sm@prismtech.com>

1 files changed, 520 insertions, 0 deletions

diff --git a/TAO/orbsvcs/tests/Bug_2248_Regression/client.cpp b/TAO/orbsvcs/tests/Bug_2248_Regression/client.cpp
new file mode 100755
index 00000000000..13776f5f1f9
--- /dev/null
+++ b/TAO/orbsvcs/tests/Bug_2248_Regression/client.cpp
@@ -0,0 +1,520 @@
+// $Id$
+#include "client.h"
+#include "Client_i.h"
+#include "testC.h"
+#include "ace/Get_Opt.h"
+#include "ace/Read_Buffer.h"
+#include "tao/IORManipulation/IORManip_Loader.h"
+#include "tao/PortableServer/PortableServer.h"
+#include "orbsvcs/orbsvcs/FaultTolerance/FT_Service_Activate.h"
+#include "orbsvcs/orbsvcs/FaultTolerance/FT_IOGR_Property.h"
+#include "ace/OS_NS_stdio.h"
+
+// Files which have the IOR
+const char *first_ior = 0;
+const char *first_key = 0;
+const char *second_ior = 0;
+const char *second_key = 0;
+const char *first_iogr_file = 0;
+const char *second_iogr_file = 0;
+
+// Objects
+CORBA::Object_var object_primary = 0;
+CORBA::Object_var object_secondary = 0;
+
+// Reference to the IOR manipulator
+
+int
+parse_args (int argc, char* argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "a:k:b:l:g:h:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'a':
+        first_ior = get_opts.opt_arg ();
+        break;
+      case 'k':
+	first_key = get_opts.opt_arg ();
+	break;
+      case 'b':
+        second_ior = get_opts.opt_arg ();
+        break;
+      case 'l':
+	second_key = get_opts.opt_arg ();
+	break;
+      case 'g':
+        first_iogr_file = get_opts.opt_arg ();
+        break;
+      case 'h':
+        second_iogr_file = get_opts.opt_arg ();
+        break;
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-a <iorfile1> -k <key1> "
+                           "-b <iorfile2> -l <key2> "
+                           "-g <iogr v10 output file> "
+                           "-h <iogr v11 output file> "
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+
+int
+main (int argc,
+      char *argv[])
+{
+  ACE_DECLARE_NEW_CORBA_ENV;
+
+  Manager manager;
+
+  ACE_TRY
+    {
+      // Initilaize the ORB, POA etc.
+      manager.init (argc,
+                    argv
+                    ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      // the command line arguments
+      if (parse_args (argc, argv) == -1)
+        return -1;
+
+      // Merge the different IORS
+      manager.make_merged_iors (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      // Write IOR to file
+      if (manager.write_to_files ())
+	      return -1;
+
+      // Client, who is going to use the merged IOR
+      // Construct that with the managers ORB
+      Client_i client_imp (manager.orb ());
+      return client_imp.init (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
+                           "Caught");
+      return -1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
+
+Manager::Manager (void)
+{
+  //no-op
+}
+
+void
+Manager::init (int& argc,
+               char**& argv
+               ACE_ENV_ARG_DECL)
+{
+  this->orb_ = CORBA::ORB_init (argc,
+                                argv,
+                                0
+                                ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
+  // Obtain the RootPOA.
+  CORBA::Object_var obj_var =
+    this->orb_->resolve_initial_references ("RootPOA"
+                                            ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
+  // Get the POA_var object from Object_var.
+  PortableServer::POA_var root_poa_var =
+    PortableServer::POA::_narrow (obj_var.in () ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
+  // Get the POAManager of the RootPOA.
+  PortableServer::POAManager_var poa_manager_var =
+    root_poa_var->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  poa_manager_var->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+}
+
+int
+Manager::make_merged_iors (ACE_ENV_SINGLE_ARG_DECL)
+{
+  // Get an object reference for the ORBs IORManipultion object!
+  CORBA::Object_var IORM =
+	  this->orb_->resolve_initial_references (
+		  TAO_OBJID_IORMANIPULATION, 0 ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+  
+  if (CORBA::is_nil (IORM.in()))
+	  return -1;
+
+  TAO_IOP::TAO_IOR_Manipulation_var iorm =
+	  TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in() ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+  if (CORBA::is_nil (iorm.in()))
+	  return -1;
+
+  CORBA::Object_var first = orb_->string_to_object (first_ior ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+  if (CORBA::is_nil (first.in()))
+	  return -1;
+
+  // Create the list
+  TAO_IOP::TAO_IOR_Manipulation::IORList iors (1);
+  iors.length(1);
+  iors [0] = first;
+
+  merged_set_10_ = iorm->merge_iors (iors ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+  if (CORBA::is_nil (merged_set_10_.in()))
+    {
+      return -1;
+    }
+
+  int result = set_properties (iorm.in(), merged_set_10_.in(),
+			    first.in(), 10 ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+  if (-1 == result)
+    {
+      return -1;
+    }
+  
+  first = orb_->string_to_object (first_ior);
+  if (CORBA::is_nil (first.in()))
+    {
+      return -1;
+    }
+
+  CORBA::Object_var second = orb_->string_to_object (second_ior);
+  
+  if (CORBA::is_nil (second.in()))
+    {
+      return -1;
+    }
+
+  // Create the list
+  
+  iors.length(2);
+  iors [0] = first;
+  iors [1] = second;
+
+  merged_set_11_ = iorm->merge_iors (iors ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+  if (CORBA::is_nil (merged_set_11_.in()))
+    {
+      return -1;
+    }
+
+  result = set_properties (iorm.in(), merged_set_11_.in(),
+			    first.in(), 11 ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+  if (-1 == result)
+    {
+      return -1;
+    }
+
+  return 0;
+}
+
+int
+Manager::set_properties (TAO_IOP::TAO_IOR_Manipulation_ptr iorm,
+			 CORBA::Object_ptr merged_set,
+			 CORBA::Object_ptr primary,
+			 CORBA::ULong version
+                         ACE_ENV_ARG_DECL)
+{
+  FT::TagFTGroupTaggedComponent ft_tag_component;
+
+  // Property values
+
+  // Major and Minor revision numbers
+  ft_tag_component.component_version.major = (CORBA::Octet) 1;
+  ft_tag_component.component_version.minor = (CORBA::Octet) 0;
+
+  // Domain id
+  const char *id = "iogr_testing";
+  ft_tag_component.group_domain_id = id;
+
+  // Object group id
+  ft_tag_component.object_group_id = 10;
+
+  // Version
+  ft_tag_component.object_group_ref_version = version;
+
+  // Construct the IOGR Property class
+  TAO_FT_IOGR_Property iogr_prop (ft_tag_component);
+
+  // Set the property
+  CORBA::Boolean retval = iorm->set_primary (&iogr_prop,
+                                             primary,
+					     merged_set
+                                             ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+  // Set the primary
+  // See we are setting the second ior as the primary
+  if (retval != 0)
+    {
+      retval = iorm->set_property (&iogr_prop,
+                                    merged_set
+                                    ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK_RETURN (-1);
+    }
+
+  return 0;
+}
+
+int
+Manager::run (ACE_ENV_SINGLE_ARG_DECL)
+{
+  ACE_TRY
+    {
+      this->orb_->run (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_ERROR_RETURN ((LM_DEBUG,
+                         "Error in run \n"),
+                        -1);
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
+
+int Manager::write_to_files ()
+{
+  if (write_to_file (merged_set_10_.in(), first_iogr_file) ||
+      write_to_file (merged_set_11_.in(), second_iogr_file))
+    {
+      return -1;
+    }
+  return 0;
+}
+
+int
+Manager::write_to_file (CORBA::Object_ptr ior, const char* ior_output_file)
+{
+  CORBA::String_var iorref =
+    this->orb_->object_to_string (ior);
+
+  if (ior_output_file != 0)
+    {
+      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
+      if (output_file == 0)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Cannot open output file for writing IOR: %s",
+                           ior_output_file),
+                          1);
+      ACE_OS::fprintf (output_file, "%s", iorref.in ());
+      ACE_OS::fclose (output_file);
+    }
+
+  return 0;
+}
+
+CORBA::ORB_ptr
+Manager::orb (void)
+{
+  return this->orb_.in ();
+}
+
+Client_i::Client_i (CORBA::ORB_ptr orb)
+  :orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+int run_remote_test (Simple_Server_ptr server, const char* execute_key ACE_ENV_ARG_DECL)
+{
+  char expected[1024], received[1024];
+  if (execute_key)
+    {
+      ACE_OS::sprintf (expected,
+		      "remote_call() completed by %s", execute_key);
+    }
+  else
+    {
+      ACE_OS::strcpy (expected, "CORBA::TRANSIENT");
+    }
+
+  ACE_TRY
+    {
+      // Make a remote call
+      CORBA::String_var s =
+	      server->remote_call (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (!s.in())
+        {
+	  ACE_OS::strcpy (received, "(null)");
+        }
+      else
+        {
+	  ACE_OS::strcpy (received, s.in());
+        }
+    }
+  ACE_CATCH (CORBA::TRANSIENT, te)
+    {
+      ACE_OS::strcpy (received, "CORBA::TRANSIENT");
+    }
+  ACE_CATCH (CORBA::COMM_FAILURE, cf)
+    {
+      ACE_OS::strcpy (received, "CORBA::COMM_FAILURE");
+    }
+  ACE_ENDTRY;
+
+  ACE_DEBUG ((LM_DEBUG,
+	      ACE_TEXT("CLIENT> REMOTE   expected: '%s'"),
+		       expected));
+  if (ACE_OS::strcmp (expected, received))
+    {
+      ACE_DEBUG ((LM_DEBUG,
+		  ACE_TEXT ("... FAIL\n"
+			    "CLIENT>          received: '%s'\n"),
+		  received));
+      return -1;
+    }
+
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT("... OK\n")));
+  return 0;
+}
+
+int run_abort_test (Simple_Server_ptr server,
+		    const char* request_key, const char* execute_key ACE_ENV_ARG_DECL)
+{
+  char expected[1024], received[1024];
+  if (execute_key)
+    {
+      ACE_OS::sprintf (expected,
+		       "abort() completed by %s, still_alive=1",
+		        execute_key);
+    }
+  else
+    {
+      ACE_OS::strcpy (expected, "CORBA::TRANSIENT");
+    }
+
+  ACE_TRY
+    {
+      CORBA::String_var s = server->abort (request_key);
+      ACE_TRY_CHECK;
+
+      if (!s.in())
+        {
+	  ACE_OS::strcpy (received, "(null)");
+        }
+      else
+        {
+	  ACE_OS::strcpy (received, s.in());
+        }
+    }
+  ACE_CATCH (CORBA::TRANSIENT, te)
+    {
+      ACE_OS::strcpy (received, "CORBA::TRANSIENT");
+    }
+  ACE_CATCH (CORBA::COMM_FAILURE, cf)
+    {
+      ACE_OS::strcpy (received, "CORBA::COMM_FAILURE");
+    }
+  ACE_ENDTRY;
+
+  ACE_DEBUG ((LM_DEBUG,
+	      ACE_TEXT("CLIENT> ABORT    expected: '%s'"),
+		       expected));
+
+  if (ACE_OS::strcmp (expected, received))
+  {
+    ACE_DEBUG ((LM_DEBUG,
+	        ACE_TEXT ("... FAIL\n"
+			  "CLIENT>          received: '%s'\n"),
+	        received));
+    return -1;
+  }
+
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT("... OK\n")));
+  return 0;
+}
+
+int run_test (Simple_Server_ptr server ACE_ENV_ARG_DECL)
+{
+  int rv = run_abort_test (server, first_key, second_key ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+  
+  if (rv)
+    {
+      return rv;
+    }
+  
+  rv = run_remote_test (server, second_key ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+  if (rv)
+    {
+      return rv;
+    }
+  
+  rv = run_abort_test (server, second_key, 0 ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+  return rv;
+}
+
+int
+Client_i::init (ACE_ENV_SINGLE_ARG_DECL)
+{
+  char iogrstr[1024];
+  ACE_OS::sprintf (iogrstr, "file://%s", first_iogr_file);
+
+  int argc = 0;
+  char **argv = 0;
+  this->orb_ = CORBA::ORB_init (argc,
+			        argv,
+			        0
+			        ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+  CORBA::Object_var object =
+	  this->orb_->string_to_object (iogrstr
+				        ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+
+  // Combined IOR stuff
+  Simple_Server_var server =
+	  Simple_Server::_narrow (object.in ()
+				  ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+  if (CORBA::is_nil (server.in ()))
+  {
+	  ACE_ERROR ((LM_ERROR,
+		      "Object reference <%s> is nil\n",
+		      iogrstr));
+  }
+
+  // run tests
+  int result = run_test (server.in() ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK_RETURN (-1);
+
+  return result;
+}