diff options
118 files changed, 4698 insertions, 3519 deletions
diff --git a/ChangeLog b/ChangeLog index d18f1024fb2..26f80c841e9 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,35 @@ +Wed Sep 29 17:30:25 2004 Irfan Pyarali <irfan@oomworks.com> + + * ace/Basic_Stats.{h,inl,cpp}: + + - Removed calculation of variation squared or deviation in the + output from dump_results(). I don't think either was been + calculated since the formula of (sum squared / samples_count) - + (avg squared) isn't a meaningful statistical value. + + - Also simplified division in dump_results() and removed + unnecessary conversions. + + - <sum2> is no longer needed. + + - Made some minor simplifications to the code. + + - Made the fields of ACE_Basic_Stats public. + + - <min_at_> and <max_at_> were not being assigned in accumulate(). + + * performance-tests/SCTP/SOCK_SEQPACK_srv.cpp: + + Fixed a for loop. It should be 1 to n inclusive. + + * ace/DLL_Manager.cpp: + + Added additional debug statements. + + * bin/tao_other_tests.lst: + + TAO/performance-tests/Protocols/run_test.pl was added. + Wed Sep 29 17:11:39 2004 Steve Huston <shuston@riverace.com> * ace/TMCast/LinkListener.hpp: Added #include "Protocol.hpp" to diff --git a/TAO/CIAO/ChangeLog b/TAO/CIAO/ChangeLog index a2d10d0a3dc..ffd74594211 100644 --- a/TAO/CIAO/ChangeLog +++ b/TAO/CIAO/ChangeLog @@ -1,3 +1,71 @@ +Wed Sep 29 17:30:25 2004 Irfan Pyarali <irfan@oomworks.com> + + * performance-tests/Protocols: + + - Minor changes were made to the Sender to in lieu of some + interface changes. + + - run_test.pl was changed so that a simple version of the test + can be executed. + + * performance-tests/Protocols/Sender/Sender.mpc: + * performance-tests/Protocols/Receiver/Receiver.mpc: + + Removed "dummy" label so that it is included in nightly builds. + + * performance-tests/Protocols/descriptors/CIAO_Installation_Data.ini: + * performance-tests/Protocols/Sender/Sender.mpc: + * performance-tests/Protocols/descriptors/Receiver.csd: + * performance-tests/Protocols/descriptors/Receiver.ssd: + * performance-tests/Protocols/descriptors/Sender.csd: + * performance-tests/Protocols/descriptors/Sender.ssd: + + Sender_* was changed to Protocols_Sender_* and Receiver_* was + changed to Protocols_Receiver_*. + + * performance-tests/Protocols/Sender/Sender_exec.cpp: + * performance-tests/Protocols/Sender/Sender.mpc: + + Custom_Network_Priority_Mapping.cpp was included directly. If + listed as a source file that is not in the current directory, + mpc mucks the object file location. + + * performance-tests/Protocols/descriptors/Receiver.csd: + * performance-tests/Protocols/descriptors/Receiver.ssd: + * performance-tests/Protocols/descriptors/Sender.csd: + * performance-tests/Protocols/descriptors/Sender.ssd: + + Hello was changed to Protocols. + + * tests/RTCCM/DiffServ/descriptors/CIAO_Installation_Data.ini: + * tests/RTCCM/DiffServ/Sender/Sender.mpc: + * tests/RTCCM/DiffServ/descriptors/Receiver.csd: + * tests/RTCCM/DiffServ/descriptors/Receiver.ssd: + * tests/RTCCM/DiffServ/descriptors/Sender.csd: + * tests/RTCCM/DiffServ/descriptors/Sender.ssd: + + Sender_* was changed to DiffServ_Sender_* and Receiver_* was + changed to DiffServ_Receiver_*. + + * tests/RTCCM/DiffServ/Sender/Sender_exec.cpp: + * tests/RTCCM/DiffServ/Sender/Sender.mpc: + + Custom_Network_Priority_Mapping.cpp was included directly. If + listed as a source file that is not in the current directory, + mpc mucks the object file location. + + * tests/RTCCM/DiffServ/descriptors/Receiver.csd: + * tests/RTCCM/DiffServ/descriptors/Receiver.ssd: + * tests/RTCCM/DiffServ/descriptors/Sender.csd: + * tests/RTCCM/DiffServ/descriptors/Sender.ssd: + + Hello was changed to DiffServ. + + * tests/RTCCM/DiffServ/Controller/Controller.mpc: + + "requires" directive was incorrect. Correct directive is + "after". + Wed Sep 29 19:20:19 2004 Balachandran Natarajan <bala@dre.vanderbilt.edu> * DAnCE/examples/BasicSP/BMClosedED/BMClosedED_svnt.cpp: diff --git a/TAO/CIAO/performance-tests/Protocols/Controller/Controller.cpp b/TAO/CIAO/performance-tests/Protocols/Controller/Controller.cpp index 01fb78d3f9c..3f99fbd9836 100644 --- a/TAO/CIAO/performance-tests/Protocols/Controller/Controller.cpp +++ b/TAO/CIAO/performance-tests/Protocols/Controller/Controller.cpp @@ -16,7 +16,7 @@ static CORBA::ULong invocation_rate = 5; static int count_missed_end_deadlines = 0; static int do_dump_history = 0; static int print_missed_invocations = 0; -static CORBA::ULong message_size = 0; +static CORBA::ULong message_size = 100; static const char *test_protocol = "IIOP"; static int print_statistics = 1; static int number_of_connection_attempts = 20; diff --git a/TAO/CIAO/performance-tests/Protocols/Receiver/Receiver.mpc b/TAO/CIAO/performance-tests/Protocols/Receiver/Receiver.mpc index b24ccfcf9e8..398e114cca2 100644 --- a/TAO/CIAO/performance-tests/Protocols/Receiver/Receiver.mpc +++ b/TAO/CIAO/performance-tests/Protocols/Receiver/Receiver.mpc @@ -44,7 +44,6 @@ project(Protocols_Receiver_svnt) : ciao_servant { project(Protocols_Receiver_exec) : ciao_component { after += Protocols_Receiver_svnt sharedname = Protocols_Receiver_exec - requires += dummy libs += Protocols_Receiver_stub Protocols_Receiver_svnt Protocols_stub Protocols_svnt idlflags += -Wb,export_macro=RECEIVER_EXEC_Export -Wb,export_include=Receiver_exec_export.h diff --git a/TAO/CIAO/performance-tests/Protocols/Sender/Sender.mpc b/TAO/CIAO/performance-tests/Protocols/Sender/Sender.mpc index b517cc2d754..7079dc503c9 100644 --- a/TAO/CIAO/performance-tests/Protocols/Sender/Sender.mpc +++ b/TAO/CIAO/performance-tests/Protocols/Sender/Sender.mpc @@ -44,10 +44,9 @@ project(Protocols_Sender_svnt) : ciao_servant { project(Protocols_Sender_exec) : ciao_component, rtcorba { after += Protocols_Sender_svnt - requires += dummy sharedname = Protocols_Sender_exec - libs += Sender_stub Sender_svnt Protocols_stub Protocols_svnt - includes += ../../../../tests/RTCORBA/DiffServ + libs += Protocols_Sender_stub Protocols_Sender_svnt Protocols_stub Protocols_svnt + includes += ../../../../tests/RTCORBA/Diffserv idlflags += -Wb,export_macro=SENDER_EXEC_Export -Wb,export_include=Sender_exec_export.h dynamicflags = SENDER_EXEC_BUILD_DLL @@ -58,7 +57,6 @@ project(Protocols_Sender_exec) : ciao_component, rtcorba { Source_Files { Sender_exec.cpp - ../../../../tests/RTCORBA/DiffServ/Custom_Network_Priority_Mapping.cpp } } diff --git a/TAO/CIAO/performance-tests/Protocols/Sender/Sender_exec.cpp b/TAO/CIAO/performance-tests/Protocols/Sender/Sender_exec.cpp index a22a117aa87..b7f3483f0ae 100644 --- a/TAO/CIAO/performance-tests/Protocols/Sender/Sender_exec.cpp +++ b/TAO/CIAO/performance-tests/Protocols/Sender/Sender_exec.cpp @@ -15,6 +15,7 @@ #include "ace/Array.h" #include "ace/Sample_History.h" #include "Custom_Network_Priority_Mapping.h" +#include "Custom_Network_Priority_Mapping.cpp" #include "Sender_exec.h" static ACE_UINT32 gsf = 0; @@ -45,7 +46,8 @@ to_hrtime (double seconds, class Worker { public: - Worker (RTCORBA::RTORB_ptr rtorb, + Worker (CORBA::ORB_ptr orb, + RTCORBA::RTORB_ptr rtorb, CORBA::PolicyManager_ptr policy_manager, Protocols::test_ptr test, ::CORBA::ULong iterations, @@ -102,7 +104,8 @@ private: ::Protocols::Sender_Controller::Test_Type test_type_; }; -Worker::Worker (RTCORBA::RTORB_ptr rtorb, +Worker::Worker (CORBA::ORB_ptr orb, + RTCORBA::RTORB_ptr rtorb, CORBA::PolicyManager_ptr policy_manager, Protocols::test_ptr test, ::CORBA::ULong iterations, @@ -151,9 +154,13 @@ Worker::Worker (RTCORBA::RTORB_ptr rtorb, this->test_protocol_policy_.length (1); RTCORBA::ProtocolProperties_var base_transport_protocol_properties = - TAO_Protocol_Properties_Factory::create_transport_protocol_property (IOP::TAG_INTERNET_IOP); + TAO_Protocol_Properties_Factory::create_transport_protocol_property (IOP::TAG_INTERNET_IOP, + orb->orb_core ()); - base_transport_protocol_properties->set_network_priority (this->enable_diffserv_code_points_); + RTCORBA::TCPProtocolProperties_var tcp_base_transport_protocol_properties = + RTCORBA::TCPProtocolProperties::_narrow (base_transport_protocol_properties.in ()); + + tcp_base_transport_protocol_properties->enable_network_priority (this->enable_diffserv_code_points_); ACE_CHECK; RTCORBA::ProtocolList protocols; @@ -173,10 +180,33 @@ Worker::Worker (RTCORBA::RTORB_ptr rtorb, protocols[0].protocol_type = test_protocol_tag; RTCORBA::ProtocolProperties_var test_transport_protocol_properties = - TAO_Protocol_Properties_Factory::create_transport_protocol_property (protocols[0].protocol_type); + TAO_Protocol_Properties_Factory::create_transport_protocol_property (protocols[0].protocol_type, + orb->orb_core ()); - test_transport_protocol_properties->set_network_priority (enable_diffserv_code_points); - ACE_CHECK; + if (protocols[0].protocol_type == TAO_TAG_UDP_PROFILE) + { + RTCORBA::UserDatagramProtocolProperties_var udp_test_transport_protocol_properties = + RTCORBA::UserDatagramProtocolProperties::_narrow (test_transport_protocol_properties.in ()); + + udp_test_transport_protocol_properties->enable_network_priority (enable_diffserv_code_points); + ACE_CHECK; + } + else if (protocols[0].protocol_type == TAO_TAG_SCIOP_PROFILE) + { + RTCORBA::StreamControlProtocolProperties_var sctp_test_transport_protocol_properties = + RTCORBA::StreamControlProtocolProperties::_narrow (test_transport_protocol_properties.in ()); + + sctp_test_transport_protocol_properties->enable_network_priority (enable_diffserv_code_points); + ACE_CHECK; + } + else if (protocols[0].protocol_type == IOP::TAG_INTERNET_IOP) + { + RTCORBA::TCPProtocolProperties_var tcp_test_transport_protocol_properties = + RTCORBA::TCPProtocolProperties::_narrow (test_transport_protocol_properties.in ()); + + tcp_test_transport_protocol_properties->enable_network_priority (enable_diffserv_code_points); + ACE_CHECK; + } protocols[0].transport_protocol_properties = test_transport_protocol_properties; @@ -332,7 +362,7 @@ Worker::setup (void) // Since the network maybe unavailable temporarily, make sure to try // for a few times before giving up. - for (int j = 0;;) + for (CORBA::ULong j = 0;;) { try { @@ -374,7 +404,7 @@ Worker::setup (void) // Since the network maybe unavailable temporarily, make sure to try // for a few times before giving up. - for (int k = 0;;) + for (CORBA::ULong k = 0;;) { try { @@ -588,7 +618,8 @@ SenderImpl::SenderExec_i::start (::CORBA::ULong iterations, Protocols::test_var test = this->context_->get_connection_reader (); - Worker worker (rtorb.in (), + Worker worker (this->orb_.in (), + rtorb.in (), policy_manager.in (), test.in (), iterations, diff --git a/TAO/CIAO/performance-tests/Protocols/descriptors/CIAO_Installation_Data.ini b/TAO/CIAO/performance-tests/Protocols/descriptors/CIAO_Installation_Data.ini index c75aea61ebf..379d481d131 100644 --- a/TAO/CIAO/performance-tests/Protocols/descriptors/CIAO_Installation_Data.ini +++ b/TAO/CIAO/performance-tests/Protocols/descriptors/CIAO_Installation_Data.ini @@ -1,5 +1,5 @@ [ComponentInstallation] -DCE:83d9348a-3248-445c-82c6-e38294943d65=Sender_exec -DCE:2c16cd81-a364-4422-b9e0-ee2ebe084954=Sender_svnt -DCE:6b6d29ca-c6e7-4823-806d-157113767331=Receiver_svnt -DCE:34b61767-2b7d-459d-985d-ece6255275d5=Receiver_exec +DCE:83d9348a-3248-445c-82c6-e38294943d65=Protocols_Sender_exec +DCE:2c16cd81-a364-4422-b9e0-ee2ebe084954=Protocols_Sender_svnt +DCE:6b6d29ca-c6e7-4823-806d-157113767331=Protocols_Receiver_svnt +DCE:34b61767-2b7d-459d-985d-ece6255275d5=Protocols_Receiver_exec diff --git a/TAO/CIAO/performance-tests/Protocols/descriptors/Receiver.csd b/TAO/CIAO/performance-tests/Protocols/descriptors/Receiver.csd index b0d9ff97dcb..44606201edc 100644 --- a/TAO/CIAO/performance-tests/Protocols/descriptors/Receiver.csd +++ b/TAO/CIAO/performance-tests/Protocols/descriptors/Receiver.csd @@ -11,8 +11,8 @@ <title>Receiver</title> - <idl id="IDL:Hello/Receiver:1.0" - homeid="IDL:Hello/ReceiverHome:1.0"> + <idl id="IDL:Protocols/Receiver:1.0" + homeid="IDL:Protocols/ReceiverHome:1.0"> <fileinarchive name="Receiver.idl"/> </idl> @@ -31,7 +31,7 @@ </dependency> <code type="DLL"> - <fileinarchive name="Receiver_exec"/> + <fileinarchive name="Protocols_Receiver_exec"/> <entrypoint>createReceiverHome_Impl</entrypoint> </code> diff --git a/TAO/CIAO/performance-tests/Protocols/descriptors/Receiver.ssd b/TAO/CIAO/performance-tests/Protocols/descriptors/Receiver.ssd index 2f687961d27..83f896c5416 100644 --- a/TAO/CIAO/performance-tests/Protocols/descriptors/Receiver.ssd +++ b/TAO/CIAO/performance-tests/Protocols/descriptors/Receiver.ssd @@ -11,8 +11,8 @@ <title>componentizedSender::Receiver Servants</title> - <idl id="IDL:Hello/Receiver:1.0" - homeid="IDL:Hello/ReceiverHome:1.0"> + <idl id="IDL:Protocols/Receiver:1.0" + homeid="IDL:Protocols/ReceiverHome:1.0"> <fileinarchive name="Receiver.idl"/> </idl> @@ -28,7 +28,7 @@ <code> <!-- No need to specify extension below since ACE takes care of that, --> - <fileinarchive name="Receiver_svnt"/> + <fileinarchive name="Protocols_Receiver_svnt"/> <entrypoint>createReceiverHome_Servant</entrypoint> </code> diff --git a/TAO/CIAO/performance-tests/Protocols/descriptors/Sender.csd b/TAO/CIAO/performance-tests/Protocols/descriptors/Sender.csd index 18c189e0989..f2d899f3338 100644 --- a/TAO/CIAO/performance-tests/Protocols/descriptors/Sender.csd +++ b/TAO/CIAO/performance-tests/Protocols/descriptors/Sender.csd @@ -11,8 +11,8 @@ <title>Sender</title> - <idl id="IDL:Hello/Sender:1.0" - homeid="IDL:Hello/SenderHome:1.0"> + <idl id="IDL:Protocols/Sender:1.0" + homeid="IDL:Protocols/SenderHome:1.0"> <fileinarchive name="Sender.idl"/> </idl> @@ -31,7 +31,7 @@ </dependency> <code type="DLL"> - <fileinarchive name="Sender_exec"/> + <fileinarchive name="Protocols_Sender_exec"/> <entrypoint>createSenderHome_Impl</entrypoint> </code> diff --git a/TAO/CIAO/performance-tests/Protocols/descriptors/Sender.ssd b/TAO/CIAO/performance-tests/Protocols/descriptors/Sender.ssd index 1f677cbef03..411bbbc66d6 100644 --- a/TAO/CIAO/performance-tests/Protocols/descriptors/Sender.ssd +++ b/TAO/CIAO/performance-tests/Protocols/descriptors/Sender.ssd @@ -11,8 +11,8 @@ <title>componentizedSender::Sender Servants</title> - <idl id="IDL:Hello/Sender:1.0" - homeid="IDL:Hello/SenderHome:1.0"> + <idl id="IDL:Protocols/Sender:1.0" + homeid="IDL:Protocols/SenderHome:1.0"> <fileinarchive name="Sender.idl"/> </idl> @@ -28,7 +28,7 @@ <code> <!-- No need to specify extension below since ACE takes care of that, --> - <fileinarchive name="Sender_svnt"/> + <fileinarchive name="Protocols_Sender_svnt"/> <entrypoint>createSenderHome_Servant</entrypoint> </code> diff --git a/TAO/CIAO/performance-tests/Protocols/descriptors/run_test.pl b/TAO/CIAO/performance-tests/Protocols/descriptors/run_test.pl index f16e0bad168..b9ec459dcde 100755 --- a/TAO/CIAO/performance-tests/Protocols/descriptors/run_test.pl +++ b/TAO/CIAO/performance-tests/Protocols/descriptors/run_test.pl @@ -12,6 +12,8 @@ $ACE_ROOT = $ENV {'ACE_ROOT'}; $CIAO_ROOT = $ENV {'CIAO_ROOT'}; $ORBdebuglevel = 0; +$protocols = "-ORBEndpoint \'iiop://\'"; +#$protocols = "-ORBEndpoint \'iiop://;diop://:5678;sciop://\'"; $daemon_1 = new PerlACE::Process ("${CIAO_ROOT}/tools/Daemon/CIAO_Daemon", "-ORBEndpoint iiop://localhost:20000 " . @@ -19,7 +21,7 @@ $daemon_1 = new PerlACE::Process ("${CIAO_ROOT}/tools/Daemon/CIAO_Daemon", $daemon_2 = new PerlACE::Process ("${CIAO_ROOT}/tools/Daemon/CIAO_Daemon", "-ORBEndpoint iiop://localhost:12000 " . - "-n \"${CIAO_ROOT}/tools/RTComponentServer/RTComponentServer -ORBdebuglevel $ORBdebuglevel -ORBEndpoint iiop:// -ORBEndpoint diop://:5678\""); + "-n \"${CIAO_ROOT}/tools/RTComponentServer/RTComponentServer -ORBdebuglevel $ORBdebuglevel $protocols\""); $assembly_manager_args = "-o assembly_manager.ior -c test.dat"; $assembly_manager = new PerlACE::Process ("${CIAO_ROOT}/tools/Assembly_Deployer/Assembly_Manager", "$assembly_manager_args"); @@ -27,7 +29,7 @@ $assembly_manager = new PerlACE::Process ("${CIAO_ROOT}/tools/Assembly_Deployer/ $assembly_deployer_args = "-k file://assembly_manager.ior -a remote.cad -o assembly"; $assembly_deployer = new PerlACE::Process ("${CIAO_ROOT}/tools/Assembly_Deployer/Assembly_Deployer", "$assembly_deployer_args"); -$controller = new PerlACE::Process ("../Controller/Controller", "-p DIOP -x 1 -z 1"); +$controller = new PerlACE::Process ("../Controller/Controller", "-x 1 -z 1"); # Remove all ior files unlink "assembly_manager.ior"; @@ -53,23 +55,23 @@ $assembly_deployer->Spawn (); PerlACE::waitforfile ("sender.ior"); PerlACE::waitforfile ("receiver.ior"); -## Now start the controller -#$controller->Spawn (); -# -## Wait for controller to get done. -#$controller->Wait (); -#$controller->{RUNNING} = 0; -# -## Kill daemons. -#$daemon_1->Kill (); -#$daemon_2->Kill (); -#$assembly_manager->Kill (); -#$assembly_deployer->Kill (); -# -## Remove all ior files -#unlink "assembly_manager.ior"; -#unlink "daemon.ior"; -#unlink "receiver.ior"; -#unlink "sender.ior"; -#unlink "assembly"; +# Now start the controller +$controller->Spawn (); + +# Wait for controller to get done. +$controller->Wait (); +$controller->{RUNNING} = 0; + +# Kill daemons. +$daemon_1->Kill (); +$daemon_2->Kill (); +$assembly_manager->Kill (); +$assembly_deployer->Kill (); + +# Remove all ior files +unlink "assembly_manager.ior"; +unlink "daemon.ior"; +unlink "receiver.ior"; +unlink "sender.ior"; +unlink "assembly"; diff --git a/TAO/CIAO/tests/RTCCM/DiffServ/Controller/Controller.mpc b/TAO/CIAO/tests/RTCCM/DiffServ/Controller/Controller.mpc index 4d89e627648..556aa9a40f3 100644 --- a/TAO/CIAO/tests/RTCCM/DiffServ/Controller/Controller.mpc +++ b/TAO/CIAO/tests/RTCCM/DiffServ/Controller/Controller.mpc @@ -1,7 +1,7 @@ // $Id$ project (*) : ciao_client, rtcorba { - requires += DiffServ_Sender_stub DiffServ_Receiver_stub + after += DiffServ_Sender_stub DiffServ_Receiver_stub includes += ../Sender includes += ../Receiver libs += DiffServ_Sender_stub diff --git a/TAO/CIAO/tests/RTCCM/DiffServ/Sender/Sender.mpc b/TAO/CIAO/tests/RTCCM/DiffServ/Sender/Sender.mpc index e6463ed256d..8414a989886 100644 --- a/TAO/CIAO/tests/RTCCM/DiffServ/Sender/Sender.mpc +++ b/TAO/CIAO/tests/RTCCM/DiffServ/Sender/Sender.mpc @@ -20,7 +20,7 @@ project(DiffServ_Sender_stub): ciao_client { project(DiffServ_Sender_svnt) : ciao_servant { after += DiffServ_svnt DiffServ_Sender_stub sharedname = DiffServ_Sender_svnt - libs += Sender_stub DiffServ_stub DiffServ_svnt + libs += DiffServ_Sender_stub DiffServ_stub DiffServ_svnt idlflags += -Wb,export_macro=SENDER_SVNT_Export -Wb,export_include=Sender_svnt_export.h dynamicflags = SENDER_SVNT_BUILD_DLL @@ -44,7 +44,7 @@ project(DiffServ_Sender_svnt) : ciao_servant { project(DiffServ_Sender_exec) : ciao_component, rtcorba { after += DiffServ_Sender_svnt sharedname = DiffServ_Sender_exec - libs += Sender_stub Sender_svnt DiffServ_stub DiffServ_svnt + libs += DiffServ_Sender_stub DiffServ_Sender_svnt DiffServ_stub DiffServ_svnt includes += ../../../../../tests/RTCORBA/Diffserv idlflags += -Wb,export_macro=SENDER_EXEC_Export -Wb,export_include=Sender_exec_export.h @@ -57,7 +57,6 @@ project(DiffServ_Sender_exec) : ciao_component, rtcorba { Source_Files { Sender_exec.cpp - ../../../../../tests/RTCORBA/Diffserv/Custom_Network_Priority_Mapping.cpp } } diff --git a/TAO/CIAO/tests/RTCCM/DiffServ/Sender/Sender_exec.cpp b/TAO/CIAO/tests/RTCCM/DiffServ/Sender/Sender_exec.cpp index c63a0d32d2d..902adc3a04d 100644 --- a/TAO/CIAO/tests/RTCCM/DiffServ/Sender/Sender_exec.cpp +++ b/TAO/CIAO/tests/RTCCM/DiffServ/Sender/Sender_exec.cpp @@ -4,6 +4,7 @@ #include "tao/RTCORBA/Network_Priority_Mapping_Manager.h" #include "tao/RTCORBA/Network_Priority_Mapping.h" #include "Custom_Network_Priority_Mapping.h" +#include "Custom_Network_Priority_Mapping.cpp" #include "Sender_exec.h" #include "ace/OS_NS_unistd.h" diff --git a/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/CIAO_Installation_Data.ini b/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/CIAO_Installation_Data.ini index c75aea61ebf..dd3bead273e 100644 --- a/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/CIAO_Installation_Data.ini +++ b/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/CIAO_Installation_Data.ini @@ -1,5 +1,5 @@ [ComponentInstallation] -DCE:83d9348a-3248-445c-82c6-e38294943d65=Sender_exec -DCE:2c16cd81-a364-4422-b9e0-ee2ebe084954=Sender_svnt -DCE:6b6d29ca-c6e7-4823-806d-157113767331=Receiver_svnt -DCE:34b61767-2b7d-459d-985d-ece6255275d5=Receiver_exec +DCE:83d9348a-3248-445c-82c6-e38294943d65=DiffServ_Sender_exec +DCE:2c16cd81-a364-4422-b9e0-ee2ebe084954=DiffServ_Sender_svnt +DCE:6b6d29ca-c6e7-4823-806d-157113767331=DiffServ_Receiver_svnt +DCE:34b61767-2b7d-459d-985d-ece6255275d5=DiffServ_Receiver_exec diff --git a/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Receiver.csd b/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Receiver.csd index 3ac941a00a8..757e9f7532b 100644 --- a/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Receiver.csd +++ b/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Receiver.csd @@ -11,8 +11,8 @@ <title>Receiver</title> - <idl id="IDL:Hello/Receiver:1.0" - homeid="IDL:Hello/ReceiverHome:1.0"> + <idl id="IDL:DiffServ/Receiver:1.0" + homeid="IDL:DiffServ/ReceiverHome:1.0"> <fileinarchive name="Receiver.idl"/> </idl> @@ -31,7 +31,7 @@ </dependency> <code type="DLL"> - <fileinarchive name="Receiver_exec"/> + <fileinarchive name="DiffServ_Receiver_exec"/> <entrypoint>createReceiverHome_Impl</entrypoint> </code> diff --git a/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Receiver.ssd b/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Receiver.ssd index 3e090c2921b..a292a0a7a5b 100644 --- a/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Receiver.ssd +++ b/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Receiver.ssd @@ -11,8 +11,8 @@ <title>componentizedSender::Receiver Servants</title> - <idl id="IDL:Hello/Receiver:1.0" - homeid="IDL:Hello/ReceiverHome:1.0"> + <idl id="IDL:DiffServ/Receiver:1.0" + homeid="IDL:DiffServ/ReceiverHome:1.0"> <fileinarchive name="Receiver.idl"/> </idl> @@ -28,7 +28,7 @@ <code> <!-- No need to specify extension below since ACE takes care of that, --> - <fileinarchive name="Receiver_svnt"/> + <fileinarchive name="DiffServ_Receiver_svnt"/> <entrypoint>createReceiverHome_Servant</entrypoint> </code> diff --git a/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Sender.csd b/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Sender.csd index d402ccc1818..1814d85830d 100644 --- a/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Sender.csd +++ b/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Sender.csd @@ -11,8 +11,8 @@ <title>Sender</title> - <idl id="IDL:Hello/Sender:1.0" - homeid="IDL:Hello/SenderHome:1.0"> + <idl id="IDL:DiffServ/Sender:1.0" + homeid="IDL:DiffServ/SenderHome:1.0"> <fileinarchive name="Sender.idl"/> </idl> @@ -31,7 +31,7 @@ </dependency> <code type="DLL"> - <fileinarchive name="Sender_exec"/> + <fileinarchive name="DiffServ_Sender_exec"/> <entrypoint>createSenderHome_Impl</entrypoint> </code> diff --git a/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Sender.ssd b/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Sender.ssd index 4f20c6edde5..196b618e0c6 100644 --- a/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Sender.ssd +++ b/TAO/CIAO/tests/RTCCM/DiffServ/descriptors/Sender.ssd @@ -11,8 +11,8 @@ <title>componentizedSender::Sender Servants</title> - <idl id="IDL:Hello/Sender:1.0" - homeid="IDL:Hello/SenderHome:1.0"> + <idl id="IDL:DiffServ/Sender:1.0" + homeid="IDL:DiffServ/SenderHome:1.0"> <fileinarchive name="Sender.idl"/> </idl> @@ -28,7 +28,7 @@ <code> <!-- No need to specify extension below since ACE takes care of that, --> - <fileinarchive name="Sender_svnt"/> + <fileinarchive name="DiffServ_Sender_svnt"/> <entrypoint>createSenderHome_Servant</entrypoint> </code> diff --git a/TAO/ChangeLog b/TAO/ChangeLog index 696e897761b..c4be9d427db 100644 --- a/TAO/ChangeLog +++ b/TAO/ChangeLog @@ -1,3 +1,386 @@ +Wed Sep 29 17:30:25 2004 Irfan Pyarali <irfan@oomworks.com> + + The following changes were made to accommodate the setting of + protocol properties for non-IIOP protocols. IIOP is part of the + TAO library while the other protocols are part of the Strategies + library. Protocol properties is part of RTCORBA. Protocol + properties for IIOP were implemented poorly and if the same + model was followed for the other protocols, it would create a + coupling of the RTCORBA and the Strategies libraries. + + The other major change here is how policies are retrieved. The + Policy Set implementation is nice and powerful, providing quick + access to policy evaluated in the critical path. These features + were not being used consistently and there was a lot of code + duplication. These changes also clean things up. + + Also a lot of policy related code - what policies are set, when + they are set and when they are evaluated - was also fixed. + + * tao/RTCORBA/RTCORBA.pidl: + + Added these two local interfaces: + + # UserDatagramProtocolProperties + # StreamControlProtocolProperties. + + Updated SharedMemoryProtocolProperties to include all the TCP + related parameters. The implementation was also changed + accordingly. + + Added the following methods to create the different protocol + properties: + + # create_unix_domain_protocol_properties() + # create_shared_memory_protocol_properties() + # create_user_datagram_protocol_properties() + # create_stream_control_protocol_properties() + + * tao/RTCORBA/RTCORBAC.{h,cpp}: + + Added code to match the changes in the pidl file. + + * RTCORBA/RT_ORB.{h,cpp}: + + Added code for implementing changes in the pidl file. + + * tao/RTCORBA/RT_Policy_i.{h,cpp}: + + To make things consistent, TAO_TCP_Properties, + TAO_Unix_Domain_Properties, and TAO_SMEM_Properties were renamed + to TAO_TCP_Protocol_Properties, + TAO_UnixDomain_Protocol_Properties, and + TAO_SharedMemory_Protocol_Properties respectively. These two + classes were added: TAO_UserDatagram_Protocol_Properties and + TAO_StreamControl_Protocol_Properties. Also default constructor + parameters were removed. If one does not know what parameters + one of these should be created with, he should use the + TAO_Protocol_Properties_Factory to create these classes. + + TAO_Protocol_Properties_Factory::create_transport_protocol_property() + was changed to require that the ORB_Core is passed in since we + need to use the user passed command line parameters to + initialize the protocol properties. + + TAO_ServerProtocolPolicy::hook() and + TAO_ClientProtocolPolicy::hook() were removed. + + * tao/RTCORBA/RT_Protocols_Hooks.{h,cpp}: + * tao/Default_Protocols_Hooks.{h,cpp): + * tao/Protocols_Hooks.{h,cpp}: + + - Removed client_protocols_hook and server_protocols_hook. + These 'hooks' were trying to be generic across protocols, but + really were specific to IIOP. + + - Removed update_client_protocol_properties and + update_server_protocol_properties since they were very poorly + written. Expanding these methods to other protocols would add a + dependency from RTCORBA to the Strategies library. + + - Removed the set_default_policies method. It took all the + protocols that the ORB knows about, made client and server + protocol properties from them and set them as default ORB + policies. The server protocol properties were being overridden + in set_default_server_protocol_policy() so that only the + protocols requested by the user are in the default protocol + properties and not all the protocols that the ORB knows about. + Client protocol properties were never used and were always + ignored. Therefore, this method was removed. This method was + also removed from ORB_Core::init(). + + - Added the following methods and classes were added: + + # TAO_IIOP_Protocol_Properties + # TAO_UIOP_Protocol_Properties + # TAO_SHMIOP_Protocol_Properties + # TAO_DIOP_Protocol_Properties + # TAO_SCIOP_Protocol_Properties + # client_protocol_properties_at_orb_level() + # server_protocol_properties_at_orb_level() + + These classes and methods are used to set connection handler + properties at creation time. These classes and methods in the + Protocols_Hooks allow us to decouple the RTCORBA library from + the Strategies library. + + Also the following were added to set network priority during + sending of packets. + + # set_client_network_priority() + # set_server_network_priority() + + * tao/ORB_Core.{h,cpp}: + + Added the following methods: + + # get_policy() - Get a policy; first, check the ORB-level Policy + Manager, then check the ORB defaults. + + # get_policy_including_current() - Get a policy; first, check + the thread current, then check the ORB-level Policy Manager, + then check the ORB defaults. + + # get_cached_policy() - Get a cached policy; first, check the + ORB-level Policy Manager, then check the ORB defaults. + + # get_cached_policy_including_current() - Get a cached policy; + first, check the thread current, then check the ORB-level Policy + Manager, then check the ORB defaults. + + Removed the following custom methods that are replaced with the + above general methods: + + # stubless_relative_roundtrip_timeout() + # stubless_connection_timeout() + # stubless_sync_scope() + + Also, get_protocols_hooks() was made simplier as the initiation + of the protocols hooks was moved explicitly to + ORB_Core::init(). This also allowed the removal of the + environment being passed to this function. The use of + get_protocols_hooks() was updated in the following files: + + # IIOP_Connection_Handler.cpp + # Remote_Invocation.cpp + # PortableServer/Object_Adapter.cpp + # RTCORBA/RT_Current.cpp + # RTCORBA/RT_Invocation_Endpoint_Selectors.cpp + # RTPortableServer/RT_Servant_Dispatcher.cpp + + * tao/Remote_Invocation.cpp: + + In send_message(), we figure out if we need to set dscp on the + client produced network packets. Then we ask the Connection + Handler to go ahead and set the dscp on the socket if needed. + + * tao/IIOP_Transport.cpp: + + The following is how things used to happen: + + - First we get the client protocol properties in effect in + TAO_IIOP_Transport::send_message() and figure out whether the + network priority needs to be set. + + - Then just before we send the message out, we set the dcsp on + the socket if needed. + + These steps are correct but were spread out in mutiple functions + executed at different times. This amount of complexity was + unwarranted. + + All these are now down in one place: + Remote_Invocation::send_message(). + + * tao/IIOP_Connection_Handler.{h,cpp}: + + # TAO_IIOP_Properties class was removed since the + IIOP_Properties are no longer being passed from the Connector + and Acceptor to the Connection Handler. Instead the protocol + properties are retrieved when the the Connection Handler is + created. The previous method was flawed becaused any updates to + the properties by the user were not considered when the protocol + properties were set. With this changes, any updates will get + used. + + # update_protocol_properties() method was removed since protocol + properties are no longer updated in this manner. + + # IPDSFIELD_DSCP_DEFAULT was moved to ORB_Constants.h since it + is used my multiple protocols, not just IIOP. + + * tao/Acceptor_Impl.{h,cpp}: + * tao/Connector_Impl.{h,cpp}: + * tao/IIOP_Acceptor.{h,cpp}: + * tao/IIOP_Connector.{h,cpp}: + + - The void * arg parameter that was being passed to + TAO_Creation_Strategy is no longer necessary. Service handlers + now figure out protocol properties when they are created. + + * tao/Connection_Handler.h (set_dscp_codepoint): + + Made set_dscp_codepoint() a pure virtual method in the base + class. Super classes for remote protocols (e.g., IIOP) + implement this method; for local protocols this is a no-op. + + * tao/Object.{h,cpp}: + * tao/LocalObject.{h,cpp}: + * tao/RTCORBA/RT_Stub.{h,cpp}: + + _get_cached_policy() has added and _get_client_policy() was removed. + + * tao/Stub.{h,cpp}: + + Removed the following methods since they can be easily replace + with one new method get_cached_policy(): + + # relative_roundtrip_timeout() + # sync_scope() + # buffering_constraint() + # connection_timeout() + + Also removed get_client_policy() since it was not useful. Also, + the get_policy() method was streamlined. + + * tao/RTCORBA/RT_Stub.{h,cpp}: + + effective_priority_banded_connection() and + effective_client_protocol() were made private. The user should + simply use the get_policy() or the get_cached_policy() + interface. All the necessary smarts of returning the correct + policy are now in this method. + + Specialized funtion private_connection(), client_protocol() and + priority_banded_connection() were removed. + + Call to priority_banded_connection() was replaced by + TAO_Stub::get_cached_policy(TAO_CACHED_POLICY_RT_PRIORITY_BANDED_CONNECTION) + and call to client_protocol() was replaced by + TAO_Stub::get_cached_policy(TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL). + + * tao/RTPortableServer/RT_POA.cpp (server_protocol): + + This method was removed. ORB level policies are already + included in the POA policy set when the POA is created. + Therefore, there is no need to check at the ORB level. + + * tao/RTPortableServer/RT_Servant_Dispatcher.cpp + (pre_invoke_remote_request): + + Special treatment of IIOP was removed. The code for setting up + dscp was generalized to work with any protocol. + + * tao/orbconf.h: + + Removed several unused lierals, including + TAO_CLIENT_PRIORITY_POLICY_TYPE, + TAO_BUFFERING_CONSTRAINT_POLICY_TYPE, + TAO_CONNECTION_TIMEOUT_POLICY_TYPE, + TAO_RT_PRIORITY_MODEL_POLICY_TYPE, + TAO_RT_THREADPOOL_POLICY_TYPE, + TAO_RT_CLIENT_PROTOCOL_POLICY_TYPE, + TAO_RT_PRIVATE_CONNECTION_POLICY_TYPE, and + TAO_RT_PRIORITY_BANDED_CONNECTION_POLICY_TYPE + + TAO_RT_SERVER_PROTOCOL_POLICY_TYPE was not removed since it is + needed for a check in the Policy Set, though it should really + not be here though; We should find a different way to handle the + check in the Policy Set. + + * tao/Messaging/Messaging_PolicyFactory.cpp (create_policy): + * tao/Messaging/Messaging_ORBInitializer.cpp (register_policy_factories): + + TAO_BUFFERING_CONSTRAINT_POLICY_TYPE was replaced by + TAO::BUFFERING_CONSTRAINT_POLICY_TYPE. + + * tao/RTCORBA/RT_Invocation_Endpoint_Selectors.cpp: + + Call to TAO_RT_Endpoint_Utils::client_protocol_policy() was + replaced by + TAO_RT_Endpoint_Utils::policy(TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL). + + Call to rt_stub->exposed_priority_model() was replaced by + rt_stub->get_cached_policy(TAO_CACHED_POLICY_PRIORITY_MODEL). + + Call to TAO_RT_Endpoint_Utils::priority_bands_policy() was + replaced by + TAO_RT_Endpoint_Utils::policy(TAO_CACHED_POLICY_RT_PRIORITY_BANDED_CONNECTION). + + Call to rt_stub->private_connection() was replaced by + rt_stub->get_cached_policy(TAO_CACHED_POLICY_RT_PRIVATE_CONNECTION). + + * tao/RTCORBA/RT_Endpoint_Utils.{h,cpp}: + + priority_bands_policy() and client_protocol_policy() were + replaced by one general policy() method. + + * tao/Messaging/Messaging_Policy_i.cpp (TAO_RelativeRoundtripTimeoutPolicy::hook): + + Call to orb_core->stubless_relative_roundtrip_timeout() was + replaced by + orb_core->get_cached_policy_including_current(TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT) + and stub->relative_roundtrip_timeout() was replaced by + stub->get_cached_policy(TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT). + + * tao/Messaging/Messaging_Policy_i.cpp (TAO_Sync_Scope_Policy::hook): + + Call to orb_core->stubless_sync_scope() was replaced by + orb_core->get_cached_policy_including_current(TAO_CACHED_POLICY_SYNC_SCOPE) + and call to stub->sync_scope() was replaced by + stub->get_cached_policy (TAO_CACHED_POLICY_SYNC_SCOPE). + + * tao/Messaging/Connection_Timeout_Policy_i.cpp (hook): + + Call to orb_core->stubless_connection_timeout() was replaced by + orb_core->get_cached_policy_including_current(TAO_CACHED_POLICY_CONNECTION_TIMEOUT) + and stub->connection_timeout() was replaced by + stub->get_cached_policy(TAO_CACHED_POLICY_CONNECTION_TIMEOUT). + + * tao/Sync_Strategies.cpp (buffering_constraints_reached): + + Call to stub->buffering_constraint() was replaced by + stub->get_cached_policy(TAO_CACHED_POLICY_BUFFERING_CONSTRAINT). + + * tao/Strategies/DIOP_Connection_Handler.{h,cpp}: + * tao/Strategies/SCIOP_Connection_Handler.{h,cpp}: + * tao/Strategies/SHMIOP_Connection_Handler.{h,cpp}: + * tao/Strategies/UIOP_Connection_Handler.{h,cpp}: + + TAO_{Protocol Name}_Properties was removed. <arg> parameter + that was used to pass information between acceptor/connector and + service handler was removed. open() was modified to get the + protocol properties from the correct place. + set_dscp_codepoint() was added/modified. + enable_network_priority() and update_protocol_properties() were + removed. + + * tao/Strategies/DIOP_Connector.{h,cpp}: + * tao/Strategies/SCIOP_Connector.{h,cpp}: + * tao/Strategies/SHMIOP_Connector.{h,cpp}: + * tao/Strategies/UIOP_Connector.{h,cpp}: + * tao/Strategies/DIOP_Acceptor.{h,cpp}: + * tao/Strategies/SCIOP_Acceptor.{h,cpp}: + * tao/Strategies/SHMIOP_Acceptor.{h,cpp}: + * tao/Strategies/UIOP_Acceptor.{h,cpp}: + + Removed init_tcp_properties. Removed {Protocol Name}_Properties + from both the Connector and Acceptor. Removed passing of the + protocol properties from the Connector and Acceptor to the + service handler. + + * tao/Strategies/SCIOP_Connector.{h,cpp}: + + We need to specify an empty ACE_Multihomed_INET_Addr to + connect() for it to succeed. + + * TAO/tests/RTCORBA/Server_Protocol/server_iiop_shmiop.conf: + * TAO/tests/RTCORBA/Server_Protocol/server_iiop_uiop.conf: + * TAO/tests/RTCORBA/Server_Protocol/run_test.pl: + + Added a couple of new conf file and updated the run_test.pl to + extend the scenarios in this test. + + * TAO/tests/RTCORBA/Server_Protocol/server.cpp: + + Brought the printing of the protocols up-to-date. + + * TAO/tests/RTCORBA/Diffserv/README: + + Updated documentation. + + * TAO/tests/RTCORBA/Client_Protocol/server.cpp: + + create_transport_protocol_property() now needs the ORB Core. + + * TAO/performance-tests/Protocols: + + - Several changes to sender.cpp to make the test more + comprehensive. + + - Simple run_test.pl added so that a simple version of the test + can be executed. + Wed Sep 29 19:09:12 2004 Balachandran Natarajan <bala@dre.vanderbilt.edu> * TAO_IDL/be/be_visitor_interface/interface_cs.cpp: diff --git a/TAO/performance-tests/Protocols/Protocols.mpc b/TAO/performance-tests/Protocols/Protocols.mpc index ac1fcb6415f..29762452fb7 100644 --- a/TAO/performance-tests/Protocols/Protocols.mpc +++ b/TAO/performance-tests/Protocols/Protocols.mpc @@ -3,8 +3,6 @@ project(*Receiver): taoserver { - requires += dummy_label - exename = receiver Source_Files { @@ -14,8 +12,6 @@ project(*Receiver): taoserver { project(*Distributor): rt_server { - requires += dummy_label - exename = distributor Source_Files { @@ -25,8 +21,8 @@ project(*Distributor): rt_server { project(*Sender): rt_client { - requires += dummy_label - + includes += ../../tests/RTCORBA/Diffserv + Source_Files { sender.cpp testC.cpp diff --git a/TAO/performance-tests/Protocols/run_test.pl b/TAO/performance-tests/Protocols/run_test.pl index 60b1fe3b730..dd3d00f0aeb 100755 --- a/TAO/performance-tests/Protocols/run_test.pl +++ b/TAO/performance-tests/Protocols/run_test.pl @@ -8,17 +8,14 @@ eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' use lib '../../../bin'; use PerlACE::Run_Test; -$iterations = 5; $ORBdebuglevel = 0; $status = 0; -$iorfile = "ior"; +$iorfile = "receiver.ior"; unlink $iorfile; -$protocol = "diop"; - -$SV = new PerlACE::Process ("server", "-ORBdebuglevel $ORBdebuglevel -ORBEndpoint $protocol://"); -$CL = new PerlACE::Process ("client", "-ORBdebuglevel $ORBdebuglevel -x 1 -i $iterations"); +$SV = new PerlACE::Process ("receiver", "-ORBdebuglevel $ORBdebuglevel"); +$CL = new PerlACE::Process ("sender", "-ORBdebuglevel $ORBdebuglevel -a 0 -b 0 -c 0 -d 0 -e 0 -i 10 -k file://receiver.ior -m 0 -p IIOP -r 5 -s 100 -t 0 -x 1"); $SV->Spawn (); @@ -28,18 +25,18 @@ if (PerlACE::waitforfile_timed ($iorfile, 10) == -1) { exit 1; } -$client = $CL->SpawnWaitKill (60); -$server = $SV->WaitKill (5); +$sender = $CL->SpawnWaitKill (60); +$receiver = $SV->WaitKill (5); unlink $iorfile; -if ($client != 0) { - print STDERR "ERROR: client returned $client\n"; +if ($sender != 0) { + print STDERR "ERROR: sender returned $sender\n"; $status = 1; } -if ($server != 0) { - print STDERR "ERROR: server returned $server\n"; +if ($receiver != 0) { + print STDERR "ERROR: receiver returned $receiver\n"; $status = 1; } diff --git a/TAO/performance-tests/Protocols/sender.cpp b/TAO/performance-tests/Protocols/sender.cpp index af127eb9020..9f4d187123f 100644 --- a/TAO/performance-tests/Protocols/sender.cpp +++ b/TAO/performance-tests/Protocols/sender.cpp @@ -9,17 +9,22 @@ #include "ace/OS_NS_stdlib.h" #include "ace/OS_NS_time.h" #include "tao/RTCORBA/RTCORBA.h" +#include "tao/RTCORBA/RT_Policy_i.h" +#include "tao/RTCORBA/Network_Priority_Mapping_Manager.h" +#include "tao/RTCORBA/Network_Priority_Mapping.h" +#include "Custom_Network_Priority_Mapping.h" +#include "Custom_Network_Priority_Mapping.cpp" #include "tao/ORB_Constants.h" #include "tao/debug.h" #include "testC.h" // Types of tests supported. enum Test_Type -{ - PACED, - THROUGHPUT, - LATENCY -}; + { + PACED, + THROUGHPUT, + LATENCY + }; static const char *ior = "file://distributor.ior"; static int shutdown_server = 0; @@ -33,12 +38,14 @@ static CORBA::ULong message_size = 0; static const char *test_protocol = "IIOP"; static int print_statistics = 1; static int number_of_connection_attempts = 20; +static int enable_diffserv_code_points = 0; +static RTCORBA::Priority corba_priority = RTCORBA::minPriority; static Test_Type test_type = PACED; static int parse_args (int argc, char **argv) { - ACE_Get_Opt get_opts (argc, argv, "a:d:e:i:k:m:p:r:s:t:x:"); + ACE_Get_Opt get_opts (argc, argv, "a:b:c:d:e:i:k:m:p:r:s:t:x:"); int c; while ((c = get_opts ()) != -1) @@ -48,6 +55,14 @@ parse_args (int argc, char **argv) test_type = static_cast<Test_Type> (ACE_OS::atoi (get_opts.opt_arg ())); break; + case 'b': + enable_diffserv_code_points = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case 'c': + corba_priority = ACE_OS::atoi (get_opts.opt_arg ()); + break; + case 'd': do_dump_history = ACE_OS::atoi (get_opts.opt_arg ()); break; @@ -89,50 +104,54 @@ parse_args (int argc, char **argv) break; default: - { - const char *test = 0; - switch (test_type) - { - case PACED: - test = "PACED"; - break; - case THROUGHPUT: - test = "THROUGHPUT"; - break; - case LATENCY: - test = "LATENCY"; - break; - } - - ACE_ERROR_RETURN ((LM_ERROR, - "usage: %s\n" - "\t-a <test type> (defaults to %s [valid values are PACED(%d), THROUGHPUT(%d), and LATENCY(%d))\n" - "\t-d <show history> (defaults to %d)\n" - "\t-e <count missed end deadlines> (defaults to %d)\n" - "\t-h <help: shows options menu>\n" - "\t-i <iterations> (defaults to %d)\n" - "\t-k <ior> (defaults to %s)\n" - "\t-m <print missed invocations for paced workers> (defaults to %d)\n" - "\t-p <test protocol> (defaults to %s [valid values are IIOP, DIOP, and SCIOP])\n" - "\t-r <invocation rate> (defaults to %d)\n" - "\t-s <message size> (defaults to %d)\n" - "\t-t <print stats> (defaults to %d)\n" - "\t-x <shutdown server> (defaults to %d)\n" - "\n", - argv[0], - test, PACED, THROUGHPUT, LATENCY, - do_dump_history, - count_missed_end_deadlines, - iterations, - ior, - print_missed_invocations, - test_protocol, - invocation_rate, - message_size, - print_statistics, - shutdown_server), - -1); - } + { + const char *test = 0; + switch (test_type) + { + case PACED: + test = "PACED"; + break; + case THROUGHPUT: + test = "THROUGHPUT"; + break; + case LATENCY: + test = "LATENCY"; + break; + } + + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s\n" + "\t-a <test type> (defaults to %s [valid values are PACED(%d), THROUGHPUT(%d), and LATENCY(%d))\n" + "\t-b <enable diffserv code points> (defaults to %d)\n" + "\t-c <corba priority> (defaults to %d)\n" + "\t-d <show history> (defaults to %d)\n" + "\t-e <count missed end deadlines> (defaults to %d)\n" + "\t-h <help: shows options menu>\n" + "\t-i <iterations> (defaults to %d)\n" + "\t-k <ior> (defaults to %s)\n" + "\t-m <print missed invocations for paced workers> (defaults to %d)\n" + "\t-p <test protocol> (defaults to %s [valid values are IIOP, DIOP, and SCIOP])\n" + "\t-r <invocation rate> (defaults to %d)\n" + "\t-s <message size> (defaults to %d)\n" + "\t-t <print stats> (defaults to %d)\n" + "\t-x <shutdown server> (defaults to %d)\n" + "\n", + argv[0], + test, PACED, THROUGHPUT, LATENCY, + enable_diffserv_code_points, + corba_priority, + do_dump_history, + count_missed_end_deadlines, + iterations, + ior, + print_missed_invocations, + test_protocol, + invocation_rate, + message_size, + print_statistics, + shutdown_server), + -1); + } } return 0; @@ -164,9 +183,10 @@ to_hrtime (double seconds, class Worker { public: - Worker (RTCORBA::RTORB_ptr rtorb, - CORBA::PolicyManager_ptr policy_manager, - test_ptr test); + Worker (CORBA::ORB_ptr orb, + RTCORBA::RTORB_ptr rtorb, + CORBA::PolicyManager_ptr policy_manager, + test_ptr test); void run (ACE_ENV_SINGLE_ARG_DECL); @@ -200,9 +220,10 @@ private: CORBA::Long session_id_; }; -Worker::Worker (RTCORBA::RTORB_ptr rtorb, - CORBA::PolicyManager_ptr policy_manager, - test_ptr test) +Worker::Worker (CORBA::ORB_ptr orb, + RTCORBA::RTORB_ptr rtorb, + CORBA::PolicyManager_ptr policy_manager, + test_ptr test) : rtorb_ (RTCORBA::RTORB::_duplicate (rtorb)), policy_manager_ (CORBA::PolicyManager::_duplicate (policy_manager)), test_ (test::_duplicate (test)), @@ -224,19 +245,29 @@ Worker::Worker (RTCORBA::RTORB_ptr rtorb, // Base protocol is used for setting up and tearing down the test. this->base_protocol_policy_.length (1); - + // Test protocol is the one being tested. this->test_protocol_policy_.length (1); + RTCORBA::ProtocolProperties_var base_transport_protocol_properties = + TAO_Protocol_Properties_Factory::create_transport_protocol_property (IOP::TAG_INTERNET_IOP, + orb->orb_core ()); + + RTCORBA::TCPProtocolProperties_var tcp_base_transport_protocol_properties = + RTCORBA::TCPProtocolProperties::_narrow (base_transport_protocol_properties.in ()); + + tcp_base_transport_protocol_properties->enable_network_priority (enable_diffserv_code_points); + ACE_CHECK; + RTCORBA::ProtocolList protocols; protocols.length (1); protocols[0].transport_protocol_properties = - RTCORBA::ProtocolProperties::_nil (); + base_transport_protocol_properties; protocols[0].orb_protocol_properties = RTCORBA::ProtocolProperties::_nil (); // IIOP is always used for the base protocol. - protocols[0].protocol_type = 0; + protocols[0].protocol_type = IOP::TAG_INTERNET_IOP; // User decides the test protocol. this->base_protocol_policy_[0] = @@ -255,9 +286,41 @@ Worker::Worker (RTCORBA::RTORB_ptr rtorb, else { if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "test protocol is IIOP\n")); - protocols[0].protocol_type = 0; + protocols[0].protocol_type = IOP::TAG_INTERNET_IOP; } + RTCORBA::ProtocolProperties_var test_transport_protocol_properties = + TAO_Protocol_Properties_Factory::create_transport_protocol_property (protocols[0].protocol_type, + orb->orb_core ()); + + if (protocols[0].protocol_type == TAO_TAG_UDP_PROFILE) + { + RTCORBA::UserDatagramProtocolProperties_var udp_test_transport_protocol_properties = + RTCORBA::UserDatagramProtocolProperties::_narrow (test_transport_protocol_properties.in ()); + + udp_test_transport_protocol_properties->enable_network_priority (enable_diffserv_code_points); + ACE_CHECK; + } + else if (protocols[0].protocol_type == TAO_TAG_SCIOP_PROFILE) + { + RTCORBA::StreamControlProtocolProperties_var sctp_test_transport_protocol_properties = + RTCORBA::StreamControlProtocolProperties::_narrow (test_transport_protocol_properties.in ()); + + sctp_test_transport_protocol_properties->enable_network_priority (enable_diffserv_code_points); + ACE_CHECK; + } + else if (protocols[0].protocol_type == IOP::TAG_INTERNET_IOP) + { + RTCORBA::TCPProtocolProperties_var tcp_test_transport_protocol_properties = + RTCORBA::TCPProtocolProperties::_narrow (test_transport_protocol_properties.in ()); + + tcp_test_transport_protocol_properties->enable_network_priority (enable_diffserv_code_points); + ACE_CHECK; + } + + protocols[0].transport_protocol_properties = + test_transport_protocol_properties; + this->test_protocol_policy_[0] = this->rtorb_->create_client_protocol_policy (protocols); } @@ -274,105 +337,100 @@ Worker::print_stats (void) ACE_DEBUG ((LM_DEBUG, "\n************ Statistics ************\n\n")); - // + // // Senders-side stats for PACED invocations are not too relevant // since we are doing one way calls. // if (test_type == PACED) { ACE_DEBUG ((LM_DEBUG, - "Rate = %d/sec; Iterations = %d; ", - invocation_rate, - iterations)); - + "Rate = %d/sec; Iterations = %d; ", + invocation_rate, + iterations)); + if (count_missed_end_deadlines) - ACE_DEBUG ((LM_DEBUG, - "Deadlines made/missed[start,end]/%% = %d/%d[%d,%d]/%.2f%%; Effective Rate = %.2f\n", - made_total_deadlines, - missed_total_deadlines, - this->missed_start_deadlines_, - this->missed_end_deadlines_, - made_total_deadlines * 100 / (double) iterations, - made_total_deadlines / to_seconds (this->test_end_ - this->test_start_, gsf))); + ACE_DEBUG ((LM_DEBUG, + "Deadlines made/missed[start,end]/%% = %d/%d[%d,%d]/%.2f%%; Effective Rate = %.2f\n", + made_total_deadlines, + missed_total_deadlines, + this->missed_start_deadlines_, + this->missed_end_deadlines_, + made_total_deadlines * 100 / (double) iterations, + made_total_deadlines / to_seconds (this->test_end_ - this->test_start_, gsf))); else - ACE_DEBUG ((LM_DEBUG, - "Deadlines made/missed/%% = %d/%d/%.2f%%; Effective Rate = %.2f\n", - made_total_deadlines, - missed_total_deadlines, - made_total_deadlines * 100 / (double) iterations, - made_total_deadlines / to_seconds (this->test_end_ - this->test_start_, gsf))); + ACE_DEBUG ((LM_DEBUG, + "Deadlines made/missed/%% = %d/%d/%.2f%%; Effective Rate = %.2f\n", + made_total_deadlines, + missed_total_deadlines, + made_total_deadlines * 100 / (double) iterations, + made_total_deadlines / to_seconds (this->test_end_ - this->test_start_, gsf))); if (print_missed_invocations) - { - ACE_DEBUG ((LM_DEBUG, "\nMissed start invocations are:\n")); - - for (CORBA::ULong j = 0; - j < this->missed_start_deadlines_; - ++j) - { - ACE_DEBUG ((LM_DEBUG, - "%d ", - this->missed_start_invocations_[j])); - } - - ACE_DEBUG ((LM_DEBUG, "\n")); - - if (count_missed_end_deadlines) - { - ACE_DEBUG ((LM_DEBUG, "\nMissed end invocations are:\n")); - - for (CORBA::ULong j = 0; - j < this->missed_end_deadlines_; - ++j) - { - ACE_DEBUG ((LM_DEBUG, - "%d ", - this->missed_end_invocations_[j])); - } - - ACE_DEBUG ((LM_DEBUG, "\n")); - } - } + { + ACE_DEBUG ((LM_DEBUG, "\nMissed start invocations are:\n")); + + for (CORBA::ULong j = 0; + j < this->missed_start_deadlines_; + ++j) + { + ACE_DEBUG ((LM_DEBUG, + "%d ", + this->missed_start_invocations_[j])); + } + + ACE_DEBUG ((LM_DEBUG, "\n")); + + if (count_missed_end_deadlines) + { + ACE_DEBUG ((LM_DEBUG, "\nMissed end invocations are:\n")); + + for (CORBA::ULong j = 0; + j < this->missed_end_deadlines_; + ++j) + { + ACE_DEBUG ((LM_DEBUG, + "%d ", + this->missed_end_invocations_[j])); + } + + ACE_DEBUG ((LM_DEBUG, "\n")); + } + } } // Individual calls are relevant for the PACED and LATENCY tests. - if (test_type == PACED || + if (test_type == PACED || test_type == LATENCY) { if (do_dump_history) - { - this->history_.dump_samples ("HISTORY", gsf); - } - + { + this->history_.dump_samples ("HISTORY", gsf); + } + ACE_Basic_Stats stats; this->history_.collect_basic_stats (stats); stats.dump_results ("Total", gsf); - + ACE_Throughput_Stats::dump_throughput ("Total", gsf, - this->test_end_ - this->test_start_, - iterations); + this->test_end_ - this->test_start_, + iterations); } else { - ACE_hrtime_t elapsed_time = - this->test_end_ - this->test_start_; + ACE_hrtime_t elapsed_time = + this->test_end_ - this->test_start_; double seconds = -# if defined ACE_LACKS_LONGLONG_T - elapsed_time / gsf; -# else /* ! ACE_LACKS_LONGLONG_T */ - static_cast<double> (ACE_UINT64_DBLCAST_ADAPTER (elapsed_time / gsf)); -# endif /* ! ACE_LACKS_LONGLONG_T */ - seconds /= ACE_HR_SCALE_CONVERSION; - + to_seconds (elapsed_time, gsf); + ACE_hrtime_t bits = iterations; bits *= message_size * 8; ACE_DEBUG ((LM_DEBUG, - "%Q bits sent in %5.1f seconds at a rate of %5.2f Mbps\n", - bits, - seconds, - bits / seconds / 1000 / 1000)); + "%Q bits sent in %5.1f seconds at a rate of %5.2f Mbps\n", + bits, + seconds, + bits / seconds / 1000 / 1000)); } } @@ -422,30 +480,30 @@ Worker::setup (ACE_ENV_SINGLE_ARG_DECL) test_protocol_setup: ACE_TRY - { - // Send a message to ensure that the connection is setup. - this->test_->oneway_sync (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; + { + // Send a message to ensure that the connection is setup. + this->test_->oneway_sync (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; - goto test_protocol_success; - } + goto test_protocol_success; + } ACE_CATCH (CORBA::TRANSIENT, exception) - { - ++j; - - if (j < number_of_connection_attempts) - { - ACE_OS::sleep (1); - goto test_protocol_setup; - } - } + { + ++j; + + if (j < number_of_connection_attempts) + { + ACE_OS::sleep (1); + goto test_protocol_setup; + } + } ACE_ENDTRY; - ACE_ERROR ((LM_ERROR, - "Cannot setup test protocol\n")); + ACE_ERROR ((LM_ERROR, + "Cannot setup test protocol\n")); ACE_OS::exit (-1); - } + } test_protocol_success: @@ -464,35 +522,35 @@ Worker::setup (ACE_ENV_SINGLE_ARG_DECL) base_protocol_setup: ACE_TRY - { - // Let the server know what to expect.. - this->test_->start_test (this->session_id_, - test_protocol, - invocation_rate, - message_size, - iterations - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - goto base_protocol_success; - } + { + // Let the server know what to expect.. + this->test_->start_test (this->session_id_, + test_protocol, + invocation_rate, + message_size, + iterations + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + goto base_protocol_success; + } ACE_CATCH (CORBA::TRANSIENT, exception) - { - ACE_OS::sleep (1); - - if (k < number_of_connection_attempts) - { - ACE_OS::sleep (1); - goto base_protocol_setup; - } - } + { + ACE_OS::sleep (1); + + if (k < number_of_connection_attempts) + { + ACE_OS::sleep (1); + goto base_protocol_setup; + } + } ACE_ENDTRY; - ACE_ERROR ((LM_ERROR, - "Cannot setup base protocol\n")); + ACE_ERROR ((LM_ERROR, + "Cannot setup base protocol\n")); ACE_OS::exit (-1); - } + } base_protocol_success: @@ -507,7 +565,7 @@ Worker::run (ACE_ENV_SINGLE_ARG_DECL) CORBA::SET_OVERRIDE ACE_ENV_ARG_PARAMETER); ACE_CHECK; - + // Payload. ::test::octets_var payload (new ::test::octets); payload->length (message_size); @@ -534,80 +592,81 @@ Worker::run (ACE_ENV_SINGLE_ARG_DECL) // For PACED and LATENCY, each sender call is individually // noted. - if (test_type == PACED || - test_type == LATENCY) - { - time_before_call = - ACE_OS::gethrtime (); - - // Pacing code. - if (test_type == PACED) - { - deadline_for_current_call = - this->deadline_for_current_call (i); - - if (time_before_call > deadline_for_current_call) - { - this->missed_start_deadline (i); - continue; - } - } - } + if (test_type == PACED || + test_type == LATENCY) + { + time_before_call = + ACE_OS::gethrtime (); + + // Pacing code. + if (test_type == PACED) + { + deadline_for_current_call = + this->deadline_for_current_call (i); + + if (time_before_call > deadline_for_current_call) + { + this->missed_start_deadline (i); + continue; + } + } + } // Use oneways for PACING and THROUGHPUT. - if (test_type == PACED || - test_type == THROUGHPUT) - { - this->test_->oneway_method (this->session_id_, - i, - payload.in () - ACE_ENV_ARG_PARAMETER); - ACE_CHECK; - } + if (test_type == PACED || + test_type == THROUGHPUT) + { + this->test_->oneway_method (this->session_id_, + i, + payload.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } else - { - // Use twoway calls for LATENCY. - this->test_->twoway_method (this->session_id_, - i, - payload.inout () - ACE_ENV_ARG_PARAMETER); - ACE_CHECK; - } + { + // Use twoway calls for LATENCY. + this->test_->twoway_method (this->session_id_, + i, + payload.inout () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } // For PACED and LATENCY, each sender call is individually // noted. - if (test_type == PACED || - test_type == LATENCY) - { - ACE_hrtime_t time_after_call = - ACE_OS::gethrtime (); - - if (test_type == LATENCY) - this->history_.sample ((time_after_call - time_before_call) / 2); - else - this->history_.sample (time_after_call - time_before_call); - - if (test_type == PACED) - { - if (time_after_call > deadline_for_current_call) - { - this->missed_end_deadline (i); - continue; - } - - ACE_hrtime_t sleep_time = - deadline_for_current_call - time_after_call; - - ACE_OS::sleep (ACE_Time_Value (0, - long (to_seconds (sleep_time, gsf) * - ACE_ONE_SECOND_IN_USECS))); - } - } + if (test_type == PACED || + test_type == LATENCY) + { + ACE_hrtime_t time_after_call = + ACE_OS::gethrtime (); + + if (test_type == LATENCY) + this->history_.sample ((time_after_call - time_before_call) / 2); + else + this->history_.sample (time_after_call - time_before_call); + + if (test_type == PACED) + { + if (time_after_call > deadline_for_current_call) + { + this->missed_end_deadline (i); + continue; + } + + ACE_hrtime_t sleep_time = + deadline_for_current_call - time_after_call; + + ACE_OS::sleep (ACE_Time_Value (0, + long (to_seconds (sleep_time, gsf) * + ACE_ONE_SECOND_IN_USECS))); + } + } } // This call is used to ensure that all the THROUGHPUT related data // has reached the server. - if (test_type == THROUGHPUT) + if (test_type == THROUGHPUT && + ACE_OS::strcmp (test_protocol, "DIOP") != 0) { this->test_->twoway_sync (ACE_ENV_ARG_PARAMETER); ACE_CHECK; @@ -666,6 +725,31 @@ main (int argc, char **argv) if (parse_args_result != 0) return parse_args_result; + // Resolve the Network priority Mapping Manager + object = + orb->resolve_initial_references ("NetworkPriorityMappingManager" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + RTCORBA::NetworkPriorityMappingManager_var mapping_manager = + RTCORBA::NetworkPriorityMappingManager::_narrow (object.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + // Initialize the custom priority mapping + Custom_Network_Priority_Mapping *cnpm = 0; + ACE_NEW_RETURN (cnpm, + Custom_Network_Priority_Mapping, + -1); + + // Set the desired corba priority on the network mapping manager + cnpm->corba_priority (corba_priority); + + // Load the custom network priority mapping object in the + // network priority mapping manager. The user can thus add his + // own priority mapping. + mapping_manager->mapping (cnpm); + object = orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); @@ -676,18 +760,19 @@ main (int argc, char **argv) ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - Worker worker (rtorb.in (), - policy_manager.in (), - test.in ()); + Worker worker (orb.in (), + rtorb.in (), + policy_manager.in (), + test.in ()); worker.setup (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - + worker.run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (print_statistics) - worker.print_stats (); + worker.print_stats (); if (shutdown_server) { diff --git a/TAO/tao/Acceptor_Impl.cpp b/TAO/tao/Acceptor_Impl.cpp index 60de99f4815..5f9aad5e08b 100644 --- a/TAO/tao/Acceptor_Impl.cpp +++ b/TAO/tao/Acceptor_Impl.cpp @@ -44,13 +44,10 @@ ACE_RCSID (tao, ////////////////////////////////////////////////////////////////////////////// template <class SVC_HANDLER> -TAO_Creation_Strategy<SVC_HANDLER>::TAO_Creation_Strategy ( - TAO_ORB_Core *orb_core, - void *arg, - CORBA::Boolean flag) +TAO_Creation_Strategy<SVC_HANDLER>::TAO_Creation_Strategy (TAO_ORB_Core *orb_core, + CORBA::Boolean flag) : ACE_Creation_Strategy<SVC_HANDLER> (0, orb_core->reactor()), orb_core_ (orb_core), - arg_ (arg), lite_flag_ (flag) { } @@ -65,8 +62,7 @@ TAO_Creation_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&sh) ACE_NEW_RETURN (sh, SVC_HANDLER (this->orb_core_, - this->lite_flag_, - this->arg_), + this->lite_flag_), -1); } diff --git a/TAO/tao/Acceptor_Impl.h b/TAO/tao/Acceptor_Impl.h index 836150520c6..883b918df50 100644 --- a/TAO/tao/Acceptor_Impl.h +++ b/TAO/tao/Acceptor_Impl.h @@ -37,12 +37,9 @@ class TAO_Creation_Strategy : public ACE_Creation_Strategy<SVC_HANDLER> { public: /** - * Constructor. <arg> parameter is used to pass any special - * state/info to the service handler upon creation. Currently used - * by IIOP and UIOP to pass protocol configuration properties. + * Constructor. */ TAO_Creation_Strategy (TAO_ORB_Core *orb_core, - void *arg = 0, CORBA::Boolean flag = 0); /// Create a SVC_HANDLER and set the ORB_Core pointer on it. @@ -52,9 +49,6 @@ protected: /// Pointer to the ORB Core. TAO_ORB_Core *orb_core_; - /// Some info/state to be passed to the service handler we create. - void *arg_; - /// Should we use the Lite version for any protocol? CORBA::Boolean lite_flag_; }; diff --git a/TAO/tao/Connection_Handler.h b/TAO/tao/Connection_Handler.h index 357ea8ab768..c85bd2e05ef 100644 --- a/TAO/tao/Connection_Handler.h +++ b/TAO/tao/Connection_Handler.h @@ -22,6 +22,8 @@ # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ +#include "tao/Basic_Types.h" + class TAO_ORB_Core; class TAO_ORB_Core_TSS_Resources; class TAO_Transport; @@ -97,6 +99,11 @@ public: /// this handler virtual int close_handler (void); + /// Set the Diff-Serv codepoint on outgoing packets. Only has + /// effect for remote protocols (e.g., IIOP); no effect for local + /// protocols (UIOP). + virtual int set_dscp_codepoint (CORBA::Boolean set_network_priority) = 0; + protected: /// Return our TAO_ORB_Core pointer diff --git a/TAO/tao/Connector_Impl.cpp b/TAO/tao/Connector_Impl.cpp index 577427054c0..b2cbfadae39 100644 --- a/TAO/tao/Connector_Impl.cpp +++ b/TAO/tao/Connector_Impl.cpp @@ -19,11 +19,9 @@ template <class SVC_HANDLER> TAO_Connect_Creation_Strategy<SVC_HANDLER>:: TAO_Connect_Creation_Strategy (ACE_Thread_Manager* t, TAO_ORB_Core *orb_core, - void *arg, CORBA::Boolean flag) : ACE_Creation_Strategy <SVC_HANDLER> (t), orb_core_ (orb_core), - arg_ (arg), lite_flag_ (flag) { @@ -35,8 +33,7 @@ TAO_Connect_Creation_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&sh) if (sh == 0) ACE_NEW_RETURN (sh, SVC_HANDLER (this->orb_core_, - this->lite_flag_, - this->arg_), + this->lite_flag_), -1); // We add to the #REFCOUNT# since the Connector needs this. See diff --git a/TAO/tao/Connector_Impl.h b/TAO/tao/Connector_Impl.h index e9aaa3acbe3..de78c3a2082 100644 --- a/TAO/tao/Connector_Impl.h +++ b/TAO/tao/Connector_Impl.h @@ -42,12 +42,9 @@ class TAO_Connect_Creation_Strategy : public ACE_Creation_Strategy<SVC_HANDLER> { public: - /// Constructor. <arg> parameter is used to pass any special - /// state/info to the service handler upon creation. Currently used - /// by IIOP and UIOP to pass protocol configuration properties. + /// Constructor. TAO_Connect_Creation_Strategy (ACE_Thread_Manager * = 0, TAO_ORB_Core* orb_core = 0, - void *arg = 0, CORBA::Boolean flag = 0); /// Makes TAO_*_Client_Connection_Handlers @@ -59,9 +56,6 @@ private: /// Pointer to the ORB_Core on which we are activated TAO_ORB_Core* orb_core_; - /// Some info/state to be passed to the service handler we create. - void *arg_; - /// Are we using GIOP lite? CORBA::Boolean lite_flag_; }; diff --git a/TAO/tao/Default_Protocols_Hooks.cpp b/TAO/tao/Default_Protocols_Hooks.cpp index 91b374a8fe1..0216e38aeec 100644 --- a/TAO/tao/Default_Protocols_Hooks.cpp +++ b/TAO/tao/Default_Protocols_Hooks.cpp @@ -26,26 +26,6 @@ TAO_Default_Protocols_Hooks::init_hooks (TAO_ORB_Core * { } -int -TAO_Default_Protocols_Hooks::call_client_protocols_hook (int &, - int &, - int &, - int &, - const char *) -{ - return 0; -} - -int -TAO_Default_Protocols_Hooks::call_server_protocols_hook (int &, - int &, - int &, - int &, - const char *) -{ - return 0; -} - void TAO_Default_Protocols_Hooks::add_rt_service_context_hook (TAO_Service_Context &, CORBA::Policy *, @@ -107,12 +87,6 @@ TAO_Default_Protocols_Hooks::set_thread_native_priority (CORBA::Short } int -TAO_Default_Protocols_Hooks::set_default_policies (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) -{ - return 0; -} - -int TAO_Default_Protocols_Hooks::set_default_server_protocol_policy (TAO_Acceptor_Registry & ACE_ENV_ARG_DECL_NOT_USED) { @@ -127,20 +101,80 @@ TAO_Default_Protocols_Hooks::rt_service_context (TAO_Stub *, { } -int -TAO_Default_Protocols_Hooks::update_client_protocol_properties (TAO_Stub *, - TAO_Transport *, - const char *) +CORBA::Boolean +TAO_Default_Protocols_Hooks::set_client_network_priority (IOP::ProfileId, + TAO_Stub * + ACE_ENV_ARG_DECL) { - return 0; + return false; } -int -TAO_Default_Protocols_Hooks::update_server_protocol_properties (CORBA::Policy *, - TAO_Transport *, - const char *) +CORBA::Boolean +TAO_Default_Protocols_Hooks::set_server_network_priority (IOP::ProfileId, + CORBA::Policy * + ACE_ENV_ARG_DECL) +{ + return false; +} + +void +TAO_Default_Protocols_Hooks::server_protocol_properties_at_orb_level (TAO_IIOP_Protocol_Properties & + ACE_ENV_ARG_DECL_NOT_USED) +{ +} + +void +TAO_Default_Protocols_Hooks::client_protocol_properties_at_orb_level (TAO_IIOP_Protocol_Properties & + ACE_ENV_ARG_DECL_NOT_USED) +{ +} + +void +TAO_Default_Protocols_Hooks::server_protocol_properties_at_orb_level (TAO_UIOP_Protocol_Properties & + ACE_ENV_ARG_DECL_NOT_USED) +{ +} + +void +TAO_Default_Protocols_Hooks::client_protocol_properties_at_orb_level (TAO_UIOP_Protocol_Properties & + ACE_ENV_ARG_DECL_NOT_USED) +{ +} + +void +TAO_Default_Protocols_Hooks::server_protocol_properties_at_orb_level (TAO_SHMIOP_Protocol_Properties & + ACE_ENV_ARG_DECL_NOT_USED) +{ +} + +void +TAO_Default_Protocols_Hooks::client_protocol_properties_at_orb_level (TAO_SHMIOP_Protocol_Properties & + ACE_ENV_ARG_DECL_NOT_USED) +{ +} + +void +TAO_Default_Protocols_Hooks::server_protocol_properties_at_orb_level (TAO_DIOP_Protocol_Properties & + ACE_ENV_ARG_DECL_NOT_USED) +{ +} + +void +TAO_Default_Protocols_Hooks::client_protocol_properties_at_orb_level (TAO_DIOP_Protocol_Properties & + ACE_ENV_ARG_DECL_NOT_USED) +{ +} + +void +TAO_Default_Protocols_Hooks::server_protocol_properties_at_orb_level (TAO_SCIOP_Protocol_Properties & + ACE_ENV_ARG_DECL_NOT_USED) +{ +} + +void +TAO_Default_Protocols_Hooks::client_protocol_properties_at_orb_level (TAO_SCIOP_Protocol_Properties & + ACE_ENV_ARG_DECL_NOT_USED) { - return 0; } CORBA::Long diff --git a/TAO/tao/Default_Protocols_Hooks.h b/TAO/tao/Default_Protocols_Hooks.h index fc8a3e7177b..21bfb4c26d4 100644 --- a/TAO/tao/Default_Protocols_Hooks.h +++ b/TAO/tao/Default_Protocols_Hooks.h @@ -32,78 +32,88 @@ public: /// destructor virtual ~TAO_Default_Protocols_Hooks (void); - virtual void init_hooks (TAO_ORB_Core *orb_core + void init_hooks (TAO_ORB_Core *orb_core + ACE_ENV_ARG_DECL); + + CORBA::Boolean set_client_network_priority (IOP::ProfileId protocol_tag, + TAO_Stub *stub + ACE_ENV_ARG_DECL); + + CORBA::Boolean set_server_network_priority (IOP::ProfileId protocol_tag, + CORBA::Policy *policy + ACE_ENV_ARG_DECL); + + void server_protocol_properties_at_orb_level (TAO_IIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void client_protocol_properties_at_orb_level (TAO_IIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void server_protocol_properties_at_orb_level (TAO_UIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void client_protocol_properties_at_orb_level (TAO_UIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void server_protocol_properties_at_orb_level (TAO_SHMIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void client_protocol_properties_at_orb_level (TAO_SHMIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void server_protocol_properties_at_orb_level (TAO_DIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void client_protocol_properties_at_orb_level (TAO_DIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void server_protocol_properties_at_orb_level (TAO_SCIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void client_protocol_properties_at_orb_level (TAO_SCIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + CORBA::Long get_dscp_codepoint (void); + + void rt_service_context (TAO_Stub *stub, + TAO_Service_Context &service_context, + CORBA::Boolean restart ACE_ENV_ARG_DECL); - - virtual int call_client_protocols_hook (int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char *protocol_type); - - virtual int call_server_protocols_hook (int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char *protocol_type); - - virtual int update_client_protocol_properties (TAO_Stub *stub, - TAO_Transport *t, - const char *protocol_type); - - virtual int update_server_protocol_properties (CORBA::Policy *policy, - TAO_Transport *t, - const char *protocol_type); - - virtual CORBA::Long get_dscp_codepoint (void); - - virtual void rt_service_context (TAO_Stub *stub, - TAO_Service_Context &service_context, - CORBA::Boolean restart - ACE_ENV_ARG_DECL); - - virtual void add_rt_service_context_hook ( - TAO_Service_Context &service_context, - CORBA::Policy *model_policy, - CORBA::Short &client_priority - ACE_ENV_ARG_DECL - ); - - virtual void get_selector_hook (CORBA::Policy *model_policy, - CORBA::Boolean - &is_client_propagated, - CORBA::Short &server_priority); - - virtual void get_selector_bands_policy_hook (CORBA::Policy *bands_policy, - CORBA::Short p, - CORBA::Short &min_priority, - CORBA::Short &max_priority, - int &in_range); - - virtual int get_thread_CORBA_priority (CORBA::Short & - ACE_ENV_ARG_DECL_NOT_USED); - - virtual int get_thread_native_priority (CORBA::Short & - ACE_ENV_ARG_DECL_NOT_USED); - - virtual int get_thread_CORBA_and_native_priority ( - CORBA::Short &, - CORBA::Short & - ACE_ENV_ARG_DECL_NOT_USED - ); - - virtual int set_thread_CORBA_priority (CORBA::Short - ACE_ENV_ARG_DECL_NOT_USED); - - virtual int set_thread_native_priority (CORBA::Short - ACE_ENV_ARG_DECL_NOT_USED); - - virtual int set_default_policies (ACE_ENV_SINGLE_ARG_DECL); - - virtual int set_default_server_protocol_policy ( - TAO_Acceptor_Registry &acceptor_registry - ACE_ENV_ARG_DECL - ); + + void add_rt_service_context_hook (TAO_Service_Context &service_context, + CORBA::Policy *model_policy, + CORBA::Short &client_priority + ACE_ENV_ARG_DECL); + + void get_selector_hook (CORBA::Policy *model_policy, + CORBA::Boolean + &is_client_propagated, + CORBA::Short &server_priority); + + void get_selector_bands_policy_hook (CORBA::Policy *bands_policy, + CORBA::Short p, + CORBA::Short &min_priority, + CORBA::Short &max_priority, + int &in_range); + + int get_thread_CORBA_priority (CORBA::Short & + ACE_ENV_ARG_DECL); + + int get_thread_native_priority (CORBA::Short & + ACE_ENV_ARG_DECL); + + int get_thread_CORBA_and_native_priority (CORBA::Short &, + CORBA::Short & + ACE_ENV_ARG_DECL); + + int set_thread_CORBA_priority (CORBA::Short + ACE_ENV_ARG_DECL); + + int set_thread_native_priority (CORBA::Short + ACE_ENV_ARG_DECL); + + int set_default_server_protocol_policy (TAO_Acceptor_Registry &acceptor_registry + ACE_ENV_ARG_DECL); }; diff --git a/TAO/tao/IIOP_Acceptor.cpp b/TAO/tao/IIOP_Acceptor.cpp index b81421e9bbb..5f7d76ff640 100644 --- a/TAO/tao/IIOP_Acceptor.cpp +++ b/TAO/tao/IIOP_Acceptor.cpp @@ -272,9 +272,6 @@ TAO_IIOP_Acceptor::open (TAO_ORB_Core *orb_core, { this->orb_core_ = orb_core; - if (this->init_tcp_properties () != 0) - return -1; - if (this->hosts_ != 0) { // The hostname cache has already been set! @@ -401,9 +398,6 @@ TAO_IIOP_Acceptor::open_default (TAO_ORB_Core *orb_core, { this->orb_core_ = orb_core; - if (this->init_tcp_properties () != 0) - return -1; - if (this->hosts_ != 0) { // The hostname cache has already been set! @@ -447,7 +441,6 @@ TAO_IIOP_Acceptor::open_i (const ACE_INET_Addr& addr, { ACE_NEW_RETURN (this->creation_strategy_, CREATION_STRATEGY (this->orb_core_, - &(this->tcp_properties_), this->lite_flag_), -1); @@ -919,70 +912,3 @@ TAO_IIOP_Acceptor::parse_options (const char *str) return 0; } - -int -TAO_IIOP_Acceptor::init_tcp_properties (void) -{ - // @@ Currently (in the code below), we obtain protocol properties from - // ORB-level ServerProtocol, even though the policy may - // have been overridden on POA level. That's because currently all - // endpoints (acceptors) are global. Once endpoints become per POA, - // the code below will have to be changed to look at the POA-level - // ServerProtocol policy first. - - // @@ Later we may want to factor some of the code below - // among different protocols and place it into TAO_Acceptor, for - // example. - - // ServerProtocolProperties policy controls protocols configuration. - // Look for protocol properties in the effective ServerProtocolPolicy. - - ACE_DECLARE_NEW_CORBA_ENV; - - // Initialize the parameters to their defaults. If RTCORBA is loaded, - // the server_protocols_hook will override any of the values if they - // have been set by a ServerProtocolProperties policy. - - int send_buffer_size = this->orb_core_->orb_params ()->sock_sndbuf_size (); - int recv_buffer_size = this->orb_core_->orb_params ()->sock_rcvbuf_size (); - int no_delay = this->orb_core_->orb_params ()->nodelay (); - int enable_network_priority = 0; - - TAO_Protocols_Hooks *tph = this->orb_core_->get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK_RETURN (-1); - - if (tph != 0) - { - static const char protocol[] = "iiop"; - const char *protocol_type = protocol; - - const int hook_return = - tph->call_server_protocols_hook (send_buffer_size, - recv_buffer_size, - no_delay, - enable_network_priority, - protocol_type); - - if (hook_return == -1) - return -1; - } - - this->tcp_properties_.send_buffer_size = - send_buffer_size; - this->tcp_properties_.recv_buffer_size = - recv_buffer_size; - this->tcp_properties_.no_delay = - no_delay; - this->tcp_properties_.enable_network_priority = - enable_network_priority; - - - // @@ NOTE. RTCORBA treats a combination of transport+messaging - // as a single protocol. Keep this in mind for when we adopt - // RTCORBA approach to protocols configuration for nonRT use. In - // particular, what are the semantics of independent variation of - // messaging and transport layers, when one transport appears in - // combination with several messaging protocols, for example. - - return 0; -} diff --git a/TAO/tao/IIOP_Acceptor.h b/TAO/tao/IIOP_Acceptor.h index b16b53fcf60..1faf926a88e 100644 --- a/TAO/tao/IIOP_Acceptor.h +++ b/TAO/tao/IIOP_Acceptor.h @@ -135,10 +135,6 @@ protected: */ virtual int parse_options (const char *options); - /// Obtain tcp properties that must be used by this acceptor, i.e., - /// initialize <tcp_properties_>. - int init_tcp_properties (void); - /// Helper method to add a new profile to the mprofile for /// each endpoint. int create_new_profile (const TAO::ObjectKey &object_key, @@ -192,10 +188,6 @@ protected: /// ORB Core. TAO_ORB_Core *orb_core_; - /// TCP configuration properties to be used for all - /// connections opened by this acceptor. - TAO_IIOP_Properties tcp_properties_; - /// Should we use GIOP lite?? const bool lite_flag_; diff --git a/TAO/tao/IIOP_Connection_Handler.cpp b/TAO/tao/IIOP_Connection_Handler.cpp index c48e62962c8..d8f389ebc9a 100644 --- a/TAO/tao/IIOP_Connection_Handler.cpp +++ b/TAO/tao/IIOP_Connection_Handler.cpp @@ -23,7 +23,7 @@ ACE_RCSID (tao, TAO_IIOP_Connection_Handler::TAO_IIOP_Connection_Handler (ACE_Thread_Manager *t) : TAO_IIOP_SVC_HANDLER (t, 0 , 0), TAO_Connection_Handler (0), - dscp_codepoint_ (0) + dscp_codepoint_ (IPDSFIELD_DSCP_DEFAULT << 2) { // This constructor should *never* get called, it is just here to // make the compiler happy: the default implementation of the @@ -36,12 +36,10 @@ TAO_IIOP_Connection_Handler::TAO_IIOP_Connection_Handler (ACE_Thread_Manager *t) TAO_IIOP_Connection_Handler::TAO_IIOP_Connection_Handler ( TAO_ORB_Core *orb_core, - CORBA::Boolean flag, - void *arg) + CORBA::Boolean flag) : TAO_IIOP_SVC_HANDLER (orb_core->thr_mgr (), 0, 0), TAO_Connection_Handler (orb_core), - tcp_properties_ (*(static_cast<TAO_IIOP_Properties *> (arg))), - dscp_codepoint_ (0) + dscp_codepoint_ (IPDSFIELD_DSCP_DEFAULT << 2) { TAO_IIOP_Transport* specific_transport = 0; ACE_NEW (specific_transport, @@ -51,12 +49,10 @@ TAO_IIOP_Connection_Handler::TAO_IIOP_Connection_Handler ( this->transport (specific_transport); } -TAO_IIOP_Connection_Handler::TAO_IIOP_Connection_Handler (TAO_ORB_Core *orb_core, - void *arg) +TAO_IIOP_Connection_Handler::TAO_IIOP_Connection_Handler (TAO_ORB_Core *orb_core) : TAO_IIOP_SVC_HANDLER (orb_core->thr_mgr (), 0, 0), TAO_Connection_Handler (orb_core), - tcp_properties_ (*(static_cast<TAO_IIOP_Properties *> (arg))), - dscp_codepoint_ (0) + dscp_codepoint_ (IPDSFIELD_DSCP_DEFAULT << 2) { } @@ -74,16 +70,37 @@ TAO_IIOP_Connection_Handler::open_handler (void *v) int TAO_IIOP_Connection_Handler::open (void*) { + TAO_IIOP_Protocol_Properties protocol_properties; + + // Initialize values from ORB params. + protocol_properties.send_buffer_size_ = + this->orb_core ()->orb_params ()->sock_sndbuf_size (); + protocol_properties.recv_buffer_size_ = + this->orb_core ()->orb_params ()->sock_rcvbuf_size (); + protocol_properties.no_delay_ = + this->orb_core ()->orb_params ()->nodelay (); + + TAO_Protocols_Hooks *tph = + this->orb_core ()->get_protocols_hooks (); + + int client = + this->transport ()->opened_as () == TAO::TAO_CLIENT_ROLE;; + + if (client) + tph->client_protocol_properties_at_orb_level (protocol_properties); + else + tph->server_protocol_properties_at_orb_level (protocol_properties); + if (this->set_socket_option (this->peer (), - this->tcp_properties_.send_buffer_size, - this->tcp_properties_.recv_buffer_size) == -1) + protocol_properties.send_buffer_size_, + protocol_properties.recv_buffer_size_) == -1) return -1; #if !defined (ACE_LACKS_TCP_NODELAY) if (this->peer ().set_option (ACE_IPPROTO_TCP, TCP_NODELAY, - (void *) &tcp_properties_.no_delay, + (void *) &protocol_properties.no_delay_, sizeof (int)) == -1) return -1; #endif /* ! ACE_LACKS_TCP_NODELAY */ @@ -295,96 +312,43 @@ TAO_IIOP_Connection_Handler::process_listen_point_list ( return 0; } -void -TAO_IIOP_Connection_Handler::update_protocol_properties ( - int send_buffer_size, - int recv_buffer_size, - int no_delay, - int enable_network_priority) -{ - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler::") - ACE_TEXT("update_protocol_properties, ") - ACE_TEXT("enable_network_priority = %d\n"), - enable_network_priority)); - - if (this->tcp_properties_.send_buffer_size != send_buffer_size) - this->tcp_properties_.send_buffer_size = send_buffer_size; - - if (this->tcp_properties_.recv_buffer_size != recv_buffer_size) - this->tcp_properties_.recv_buffer_size = recv_buffer_size; - - if (this->tcp_properties_.no_delay != no_delay) - this->tcp_properties_.no_delay = no_delay; - - if (this->tcp_properties_.enable_network_priority != enable_network_priority) - this->tcp_properties_.enable_network_priority = enable_network_priority; - -} - int -TAO_IIOP_Connection_Handler::enable_network_priority (void) +TAO_IIOP_Connection_Handler::set_dscp_codepoint (CORBA::Boolean set_network_priority) { - return this->tcp_properties_.enable_network_priority; -} + int tos = IPDSFIELD_DSCP_DEFAULT << 2; -int -TAO_IIOP_Connection_Handler::set_dscp_codepoint (void) -{ - int tos = 0; - if (this->enable_network_priority ()) + if (set_network_priority) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - TAO_Protocols_Hooks *tph = - this->orb_core ()->get_protocols_hooks ( - ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (tph != 0) - { - CORBA::Long codepoint = - tph->get_dscp_codepoint (); - - tos = (int)(codepoint) << 2; - } - } - ACE_CATCHANY - { - if (TAO_debug_level > 0) - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "TAO_IIOP_Connection_Handler::" - "set_dscp_codepoint - " - "get_protocol_hooks"); - - return -1; - } - ACE_ENDTRY; - ACE_CHECK_RETURN (-1); + TAO_Protocols_Hooks *tph = + this->orb_core ()->get_protocols_hooks (); + + CORBA::Long codepoint = + tph->get_dscp_codepoint (); + + tos = (int)(codepoint) << 2; } - else - tos = IPDSFIELD_DSCP_DEFAULT << 2; if (tos != this->dscp_codepoint_) { - const int ret = this->peer ().set_option (IPPROTO_IP, - IP_TOS, - (int *) &tos , - (int) sizeof (tos)); - + int result = this->peer ().set_option (IPPROTO_IP, + IP_TOS, + (int *) &tos , + (int) sizeof (tos)); + if (TAO_debug_level) { ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - IIOP_Connection_Handler::" "set_dscp_codepoint -> dscp: %x; result: %d; %s\n", tos, - ret, - ret == -1 ? "try running as superuser" : "")); + result, + result == -1 ? "try running as superuser" : "")); } + + // On successful setting of TOS field. + if (result == 0) + this->dscp_codepoint_ = tos; - this->dscp_codepoint_ = tos; } return 0; diff --git a/TAO/tao/IIOP_Connection_Handler.h b/TAO/tao/IIOP_Connection_Handler.h index 869c73bfd48..59515092960 100644 --- a/TAO/tao/IIOP_Connection_Handler.h +++ b/TAO/tao/IIOP_Connection_Handler.h @@ -46,30 +46,6 @@ class TAO_Pluggable_Messaging; // **************************************************************** /** - * @class TAO_IIOP_Properties - * - * @brief TCP protocol properties specification for a set of - * connections. - * - */ - -#define IPDSFIELD_DSCP_DEFAULT 0x00 - -class TAO_Export TAO_IIOP_Properties -{ - -public: - int send_buffer_size; - int recv_buffer_size; - int no_delay; - int enable_network_priority; -}; - - - -// **************************************************************** - -/** * @class TAO_IIOP_Connection_Handler * * @brief Handles requests on a single connection. @@ -87,12 +63,9 @@ public: TAO_IIOP_Connection_Handler (ACE_Thread_Manager * = 0); - /// Constructor. @a arg parameter is used by the Acceptor to pass the - /// protocol configuration properties for this connection. + /// Constructor. TAO_IIOP_Connection_Handler (TAO_ORB_Core *orb_core, - CORBA::Boolean flag, - void *arg); - + CORBA::Boolean flag); /// Destructor. ~TAO_IIOP_Connection_Handler (void); @@ -126,18 +99,9 @@ public: /// Check if network priority needs to be enabled int enable_network_priority (void); - /// Set the Diff-Serv codepoint if the Policy dictates the setting of - /// Network Priority - int set_dscp_codepoint (void); - - int set_dscp_codepoint (int tos); - - /// Update the tcp properties of the hanlder to the most recent - /// properties set after the last invocation - virtual void update_protocol_properties (int send_buffer_size, - int recv_buffer_size, - int no_delay, - int enable_network_priority); + /// Set Diff-Serv codepoint on outgoing packets. + int set_dscp_codepoint (CORBA::Boolean set_network_priority); + virtual int open_handler (void *); protected: @@ -150,8 +114,7 @@ protected: * constructor just initializes its base class and sets all of its * contents to the default value, if any */ - TAO_IIOP_Connection_Handler (TAO_ORB_Core *orb_core, - void *arg); + TAO_IIOP_Connection_Handler (TAO_ORB_Core *orb_core); //@{ /** @@ -161,8 +124,6 @@ protected: //@} private: - /// TCP configuration for this connection. - TAO_IIOP_Properties tcp_properties_; /// Stores the type of service value. int dscp_codepoint_; diff --git a/TAO/tao/IIOP_Connector.cpp b/TAO/tao/IIOP_Connector.cpp index b99f47d2132..f8eefc25128 100644 --- a/TAO/tao/IIOP_Connector.cpp +++ b/TAO/tao/IIOP_Connector.cpp @@ -66,9 +66,6 @@ TAO_IIOP_Connector::open (TAO_ORB_Core *orb_core) if (this->create_connect_strategy () == -1) return -1; - if (this->init_tcp_properties () != 0) - return -1; - /// Our connect creation strategy TAO_IIOP_CONNECT_CREATION_STRATEGY *connect_creation_strategy = 0; @@ -76,7 +73,6 @@ TAO_IIOP_Connector::open (TAO_ORB_Core *orb_core) TAO_IIOP_CONNECT_CREATION_STRATEGY (orb_core->thr_mgr (), orb_core, - &(this->tcp_properties_), this->lite_flag_), -1); @@ -375,62 +371,6 @@ TAO_IIOP_Connector::object_key_delimiter (void) const return TAO_IIOP_Profile::object_key_delimiter_; } -int -TAO_IIOP_Connector::init_tcp_properties (void) -{ - // Connector protocol properties are obtained from ORB-level - // RTCORBA::ClientProtocolProperties policy override. - // If the override doesn't exist or doesn't contain the - // properties, we use ORB default. - // - // Currently, we do not use Object-level and Current-level policy - // overrides for protocol configuration because connection - // lookup and caching are not done based on protocol - // properties. - - ACE_DECLARE_NEW_CORBA_ENV; - - // Initialize the settings to the ORB defaults. If RT CORBA is enabled, - // it may override these. - int send_buffer_size = this->orb_core ()->orb_params ()->sock_sndbuf_size (); - int recv_buffer_size = this->orb_core ()->orb_params ()->sock_rcvbuf_size (); - int no_delay = this->orb_core ()->orb_params ()->nodelay (); - int enable_network_priority = 0; - - TAO_Protocols_Hooks *tph = - this->orb_core ()->get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK_RETURN (-1); - - if (tph != 0) - { - static const char protocol[] = "iiop"; - const char *protocol_type = protocol; - - const int hook_result = - tph->call_client_protocols_hook (send_buffer_size, - recv_buffer_size, - no_delay, - enable_network_priority, - protocol_type); - - if (hook_result == -1) - return -1; - } - - // Extract and locally store properties of interest. - this->tcp_properties_.send_buffer_size = - send_buffer_size; - this->tcp_properties_.recv_buffer_size = - recv_buffer_size; - this->tcp_properties_.no_delay = - no_delay; - this->tcp_properties_.enable_network_priority = - enable_network_priority; - - return 0; -} - - TAO_IIOP_Endpoint * TAO_IIOP_Connector::remote_endpoint (TAO_Endpoint *endpoint) { diff --git a/TAO/tao/IIOP_Connector.h b/TAO/tao/IIOP_Connector.h index 8b2bcefb164..2f7d91f769c 100644 --- a/TAO/tao/IIOP_Connector.h +++ b/TAO/tao/IIOP_Connector.h @@ -95,19 +95,11 @@ protected: /// Transport_Connector.h virtual TAO_Profile *make_profile (ACE_ENV_SINGLE_ARG_DECL); - /// Obtain tcp properties that must be used by this connector, i.e., - /// initialize <tcp_properties_>. - int init_tcp_properties (void); - /// Cancel the passed cvs handler from the connector virtual int cancel_svc_handler (TAO_Connection_Handler * svc_handler); protected: - /// TCP configuration properties to be used for all - /// connections established by this connector. - TAO_IIOP_Properties tcp_properties_; - /// Do we need to use a GIOP_Lite for sending messages? const bool lite_flag_; diff --git a/TAO/tao/IIOP_Transport.cpp b/TAO/tao/IIOP_Transport.cpp index cc77eb99222..cd592abce6e 100644 --- a/TAO/tao/IIOP_Transport.cpp +++ b/TAO/tao/IIOP_Transport.cpp @@ -129,36 +129,6 @@ TAO_IIOP_Transport::send_request (TAO_Stub *stub, int message_semantics, ACE_Time_Value *max_wait_time) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - TAO_Protocols_Hooks *tph = - this->orb_core_->get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (tph != 0) - { - const int result = - tph->update_client_protocol_properties (stub, - this, - "iiop"); - - if (result == -1) - return -1; - } - } - ACE_CATCHANY - { - if (TAO_debug_level > 0) - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "TAO (%P|%t) - TAO_IIOP_Transport::send_request - " - "get_protocol_hooks"); - - return -1; - } - ACE_ENDTRY; - ACE_CHECK_RETURN (-1); - if (this->ws_->sending_request (orb_core, message_semantics) == -1) @@ -220,15 +190,6 @@ TAO_IIOP_Transport::send_message_shared ( { ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->handler_lock_, -1); - if (TAO_debug_level > 6) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t) - ") - ACE_TEXT ("IIOP_Transport::send_message_shared, ") - ACE_TEXT ("enable_network_priority = %d\n"), - this->connection_handler_->enable_network_priority ())); - - this->connection_handler_->set_dscp_codepoint (); - r = this->send_message_shared_i (stub, message_semantics, message_block, max_wait_time); } @@ -425,16 +386,3 @@ TAO_IIOP_Transport::get_listen_point ( return 1; } - -void -TAO_IIOP_Transport::update_protocol_properties (int snd_buf_sz, - int rcv_buf_sz, - int no_delay, - int enable_nw_prio) -{ - this->connection_handler_->update_protocol_properties ( - snd_buf_sz, - rcv_buf_sz, - no_delay, - enable_nw_prio); -} diff --git a/TAO/tao/LocalObject.cpp b/TAO/tao/LocalObject.cpp index f561d37ae0d..227902328ba 100644 --- a/TAO/tao/LocalObject.cpp +++ b/TAO/tao/LocalObject.cpp @@ -166,7 +166,7 @@ CORBA::LocalObject::_get_policy (CORBA::PolicyType } CORBA::Policy_ptr -CORBA::LocalObject::_get_client_policy (CORBA::PolicyType +CORBA::LocalObject::_get_cached_policy (TAO_Cached_Policy_Type ACE_ENV_ARG_DECL) { ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), 0); diff --git a/TAO/tao/LocalObject.h b/TAO/tao/LocalObject.h index 37decb84104..662f1471ab8 100644 --- a/TAO/tao/LocalObject.h +++ b/TAO/tao/LocalObject.h @@ -118,7 +118,7 @@ namespace CORBA ACE_ENV_ARG_DECL_WITH_DEFAULTS); /// Throws CORBA::NO_IMPLEMENT. - CORBA::Policy_ptr _get_client_policy (CORBA::PolicyType type + CORBA::Policy_ptr _get_cached_policy (TAO_Cached_Policy_Type type ACE_ENV_ARG_DECL_WITH_DEFAULTS); /// Throws CORBA::NO_IMPLEMENT. diff --git a/TAO/tao/Messaging/Connection_Timeout_Policy_i.cpp b/TAO/tao/Messaging/Connection_Timeout_Policy_i.cpp index 6b22bf9d0b7..99e8511844b 100644 --- a/TAO/tao/Messaging/Connection_Timeout_Policy_i.cpp +++ b/TAO/tao/Messaging/Connection_Timeout_Policy_i.cpp @@ -58,8 +58,8 @@ TAO_ConnectionTimeoutPolicy::hook (TAO_ORB_Core *orb_core, { CORBA::Policy_var policy = (stub == 0 - ? orb_core->stubless_connection_timeout () - : stub->connection_timeout ()); + ? orb_core->get_cached_policy_including_current (TAO_CACHED_POLICY_CONNECTION_TIMEOUT) + : stub->get_cached_policy (TAO_CACHED_POLICY_CONNECTION_TIMEOUT)); if (CORBA::is_nil (policy.in ())) { diff --git a/TAO/tao/Messaging/Messaging_ORBInitializer.cpp b/TAO/tao/Messaging/Messaging_ORBInitializer.cpp index b892255d5da..9e12f86dd52 100644 --- a/TAO/tao/Messaging/Messaging_ORBInitializer.cpp +++ b/TAO/tao/Messaging/Messaging_ORBInitializer.cpp @@ -80,7 +80,7 @@ TAO_Messaging_ORBInitializer::register_policy_factories ( Messaging::SYNC_SCOPE_POLICY_TYPE, #endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */ #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) - TAO_BUFFERING_CONSTRAINT_POLICY_TYPE, + TAO::BUFFERING_CONSTRAINT_POLICY_TYPE, #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */ #if (TAO_HAS_REBIND_POLICY == 1) Messaging::REBIND_POLICY_TYPE, diff --git a/TAO/tao/Messaging/Messaging_PolicyFactory.cpp b/TAO/tao/Messaging/Messaging_PolicyFactory.cpp index 50499dc94b0..2897a284bd5 100644 --- a/TAO/tao/Messaging/Messaging_PolicyFactory.cpp +++ b/TAO/tao/Messaging/Messaging_PolicyFactory.cpp @@ -38,7 +38,7 @@ TAO_Messaging_PolicyFactory::create_policy ( #endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */ #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) - if (type == TAO_BUFFERING_CONSTRAINT_POLICY_TYPE) + if (type == TAO::BUFFERING_CONSTRAINT_POLICY_TYPE) return TAO_Buffering_Constraint_Policy::create (value ACE_ENV_ARG_PARAMETER); #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */ diff --git a/TAO/tao/Messaging/Messaging_Policy_i.cpp b/TAO/tao/Messaging/Messaging_Policy_i.cpp index c509c7f7f65..9648c655337 100644 --- a/TAO/tao/Messaging/Messaging_Policy_i.cpp +++ b/TAO/tao/Messaging/Messaging_Policy_i.cpp @@ -60,8 +60,8 @@ TAO_RelativeRoundtripTimeoutPolicy::hook (TAO_ORB_Core *orb_core, { CORBA::Policy_var policy = (stub == 0 - ? orb_core->stubless_relative_roundtrip_timeout () - : stub->relative_roundtrip_timeout ()); + ? orb_core->get_cached_policy_including_current (TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT) + : stub->get_cached_policy (TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT)); if (CORBA::is_nil (policy.in ())) { @@ -218,7 +218,9 @@ TAO_Sync_Scope_Policy::hook (TAO_ORB_Core *orb_core, Messaging::SyncScope &scope) { CORBA::Policy_var policy = - (stub == 0 ? orb_core->stubless_sync_scope () : stub->sync_scope ()); + (stub == 0 + ? orb_core->get_cached_policy_including_current (TAO_CACHED_POLICY_SYNC_SCOPE) + : stub->get_cached_policy (TAO_CACHED_POLICY_SYNC_SCOPE)); if (CORBA::is_nil (policy.in ())) { diff --git a/TAO/tao/Messaging/TAO_Ext.pidl b/TAO/tao/Messaging/TAO_Ext.pidl index d06cb9f91cc..526fd11d520 100644 --- a/TAO/tao/Messaging/TAO_Ext.pidl +++ b/TAO/tao/Messaging/TAO_Ext.pidl @@ -50,10 +50,9 @@ module TAO { const CORBA::PolicyType CONNECTION_TIMEOUT_POLICY_TYPE = 0x54410008; - local interface ConnectionTimeoutPolicy : CORBA::Policy { + local interface ConnectionTimeoutPolicy : CORBA::Policy { readonly attribute TimeBase::TimeT relative_expiry; - }; - + }; }; #endif /* TAO_TAO_EXT_IDL */ diff --git a/TAO/tao/ORB_Constants.h b/TAO/tao/ORB_Constants.h index 585914e1604..1cbdc8cac88 100644 --- a/TAO/tao/ORB_Constants.h +++ b/TAO/tao/ORB_Constants.h @@ -185,6 +185,9 @@ const CORBA::ULong TAO_TAG_NSKFS_PROFILE = 0x00003039U; /// Tandem (HP) Pathsend Protocol const CORBA::ULong TAO_TAG_NSKPW_PROFILE = 0x0000303AU; +// Default DiffServ CodePoint. +const int IPDSFIELD_DSCP_DEFAULT = 0x00; + /** * @name Minor Code Encoding * diff --git a/TAO/tao/ORB_Core.cpp b/TAO/tao/ORB_Core.cpp index f32effcf875..80b8f4a5063 100644 --- a/TAO/tao/ORB_Core.cpp +++ b/TAO/tao/ORB_Core.cpp @@ -118,7 +118,6 @@ TAO_ORB_Core_Static_Resources::TAO_ORB_Core_Static_Resources (void) TAO_ORB_Core::TAO_ORB_Core (const char *orbid) : protocols_hooks_ (0), - protocols_hooks_checked_ (false), lock_ (), thread_lane_resources_manager_ (0), collocation_resolver_ (0), @@ -1078,24 +1077,13 @@ TAO_ORB_Core::init (int &argc, char *argv[] ACE_ENV_ARG_DECL) // Initialize the flushing strategy this->flushing_strategy_ = trf->create_flushing_strategy (); - // Now that we have a complete list of available protocols and their - // related factory objects, set default policies and initialize the - // registries! - - // Set ORB-level policy defaults. - TAO_Protocols_Hooks *tph = - this->get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK_RETURN (-1); - - int status = 0; - - if (tph) - { - status = tph->set_default_policies (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK_RETURN (-1); - } - - if (status != 0) + // Look in the service repository for an instance of the Protocol Hooks. + this->protocols_hooks_ = + ACE_Dynamic_Service<TAO_Protocols_Hooks>::instance + (TAO_ORB_Core_Static_Resources::instance ()->protocols_hooks_name_.c_str()); + + // Must have valid protocol hooks. + if (this->protocols_hooks_ == 0) ACE_THROW_RETURN (CORBA::INITIALIZE ( CORBA::SystemException::_tao_minor_code ( TAO_ORB_CORE_INIT_LOCATION_CODE, @@ -1103,6 +1091,11 @@ TAO_ORB_Core::init (int &argc, char *argv[] ACE_ENV_ARG_DECL) CORBA::COMPLETED_NO), -1); + // Initialize the protocols hooks instance. + this->protocols_hooks_->init_hooks (this + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + // Look for BiDirectional library here. If the user has svc.conf // file, load the library at this point. int ret = this->bidirectional_giop_init (ACE_ENV_SINGLE_ARG_PARAMETER); @@ -1385,43 +1378,11 @@ TAO_ORB_Core::set_protocols_hooks (const char *protocols_hooks_name) // Is synchronization necessary? TAO_ORB_Core_Static_Resources::instance ()->protocols_hooks_name_ = protocols_hooks_name; - - // Probably we need to reset the - // TAO_ORB_Core::protocols_hooks_checked_ flag. Not sure how to do - // it though. } TAO_Protocols_Hooks * -TAO_ORB_Core::get_protocols_hooks (ACE_ENV_SINGLE_ARG_DECL) +TAO_ORB_Core::get_protocols_hooks (void) { - // Check if there is a cached reference. - if (this->protocols_hooks_ == 0 && - this->protocols_hooks_checked_ == false) - { - // We need synchronization here since this is called in the - // critical path where more than one thread could be active on - // different handlers. - ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, - ace_mon, - this->lock_, - 0); - - // If not, look in the service repository for an instance. - this->protocols_hooks_ = - ACE_Dynamic_Service<TAO_Protocols_Hooks>::instance - (TAO_ORB_Core_Static_Resources::instance ()->protocols_hooks_name_.c_str()); - - if (this->protocols_hooks_) - { - // Initialize the protocols hooks instance. - this->protocols_hooks_->init_hooks (this - ACE_ENV_ARG_PARAMETER); - ACE_CHECK_RETURN (0); - } - - this->protocols_hooks_checked_ = true; - } - return this->protocols_hooks_; } @@ -2576,39 +2537,6 @@ TAO_ORB_Core::set_sync_scope_hook (Sync_Scope_Hook hook) TAO_ORB_Core_Static_Resources::instance ()-> sync_scope_hook_ = hook; } -#if (TAO_HAS_SYNC_SCOPE_POLICY == 1) - -CORBA::Policy_ptr -TAO_ORB_Core::stubless_sync_scope (void) -{ - CORBA::Policy_var result; - - // No need to lock, the object is in TSS storage.... - TAO_Policy_Current &policy_current = - this->policy_current (); - result = policy_current.get_cached_policy (TAO_CACHED_POLICY_SYNC_SCOPE); - - // @@ Must lock, but is is harder to implement than just modifying - // this call: the ORB does take a lock to modify the policy - // manager - if (CORBA::is_nil (result.in ())) - { - TAO_Policy_Manager *policy_manager = - this->policy_manager (); - if (policy_manager != 0) - result = policy_manager->get_cached_policy ( - TAO_CACHED_POLICY_SYNC_SCOPE); - } - - if (CORBA::is_nil (result.in ())) - result = this->default_policies_->get_cached_policy ( - TAO_CACHED_POLICY_SYNC_SCOPE); - - return result._retn (); -} - -#endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */ - void TAO_ORB_Core::call_timeout_hook (TAO_Stub *stub, bool &has_timeout, @@ -2634,43 +2562,6 @@ TAO_ORB_Core::set_timeout_hook (Timeout_Hook hook) return; } -CORBA::Policy_ptr -TAO_ORB_Core::stubless_relative_roundtrip_timeout (void) -{ - CORBA::Policy_var result; - -#if (TAO_HAS_CORBA_MESSAGING == 1 \ - && TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1) - - // No need to lock, the object is in TSS storage.... - TAO_Policy_Current &policy_current = - this->policy_current (); - result = policy_current.get_cached_policy ( - TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT); - - // @@ Must lock, but is is harder to implement than just modifying - // this call: the ORB does take a lock to modify the policy - // manager - if (CORBA::is_nil (result.in ())) - { - TAO_Policy_Manager *policy_manager = - this->policy_manager (); - if (policy_manager != 0) - result = policy_manager->get_cached_policy ( - TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT); - } - - if (CORBA::is_nil (result.in ())) - result = this->default_policies_->get_cached_policy ( - TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT); - -#endif /* TAO_HAS_CORBA_MESSAGING == 1 - && TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */ - - return result._retn (); -} - - void TAO_ORB_Core::connection_timeout (TAO_Stub *stub, bool &has_timeout, @@ -2695,53 +2586,44 @@ TAO_ORB_Core::connection_timeout_hook (Timeout_Hook hook) TAO_ORB_Core_Static_Resources::instance ()->connection_timeout_hook_ = hook; } +#if (TAO_HAS_CORBA_MESSAGING == 1) + CORBA::Policy_ptr -TAO_ORB_Core::stubless_connection_timeout (void) +TAO_ORB_Core::get_policy (CORBA::PolicyType type) { CORBA::Policy_var result; -#if (TAO_HAS_CORBA_MESSAGING == 1 \ - && TAO_HAS_CONNECTION_TIMEOUT_POLICY == 1) + TAO_Policy_Manager *policy_manager = + this->policy_manager (); + if (policy_manager != 0) + result = policy_manager->get_policy (type); + + if (CORBA::is_nil (result.in ())) + result = this->get_default_policies ()->get_policy (type); + + return result._retn (); +} - // No need to lock, the object is in TSS storage.... +CORBA::Policy_ptr +TAO_ORB_Core::get_policy_including_current (CORBA::PolicyType type) +{ TAO_Policy_Current &policy_current = this->policy_current (); - result = policy_current.get_cached_policy ( - TAO_CACHED_POLICY_CONNECTION_TIMEOUT); - // @@ Must lock, but is is harder to implement than just modifying - // this call: the ORB does take a lock to modify the policy - // manager - if (CORBA::is_nil (result.in ())) - { - TAO_Policy_Manager *policy_manager = - this->policy_manager (); - if (policy_manager != 0) - result = policy_manager->get_cached_policy ( - TAO_CACHED_POLICY_CONNECTION_TIMEOUT); - } + CORBA::Policy_var result = + policy_current.get_policy (type); if (CORBA::is_nil (result.in ())) - result = this->default_policies_->get_cached_policy ( - TAO_CACHED_POLICY_CONNECTION_TIMEOUT); - -#endif /* TAO_HAS_CORBA_MESSAGING == 1 - && TAO_HAS_CONNECTION_TIMEOUT_POLICY == 1 */ + result = this->get_policy (type); return result._retn (); } - -#if (TAO_HAS_CORBA_MESSAGING == 1) - CORBA::Policy_ptr TAO_ORB_Core::get_cached_policy (TAO_Cached_Policy_Type type) { CORBA::Policy_var result; - // @@ Must lock, but is is harder to implement than just modifying - // this call: the ORB does take a lock to modify the policy - // manager TAO_Policy_Manager *policy_manager = this->policy_manager (); if (policy_manager != 0) @@ -2753,6 +2635,21 @@ TAO_ORB_Core::get_cached_policy (TAO_Cached_Policy_Type type) return result._retn (); } +CORBA::Policy_ptr +TAO_ORB_Core::get_cached_policy_including_current (TAO_Cached_Policy_Type type) +{ + TAO_Policy_Current &policy_current = + this->policy_current (); + + CORBA::Policy_var result = + policy_current.get_cached_policy (type); + + if (CORBA::is_nil (result.in ())) + result = this->get_cached_policy (type); + + return result._retn (); +} + #endif /* (TAO_HAS_CORBA_MESSAGING == 1) */ CORBA::Environment * diff --git a/TAO/tao/ORB_Core.h b/TAO/tao/ORB_Core.h index 2a879aa4216..9c47c7aca77 100644 --- a/TAO/tao/ORB_Core.h +++ b/TAO/tao/ORB_Core.h @@ -428,7 +428,7 @@ public: static const ACE_CString &poa_factory_name (void); /// Gets the value of TAO_ORB_Core::protocols_hooks__ - TAO_Protocols_Hooks * get_protocols_hooks (ACE_ENV_SINGLE_ARG_DECL); + TAO_Protocols_Hooks * get_protocols_hooks (void); /// Sets the value of TAO_ORB_Core::dynamic_adapter_name_. static void dynamic_adapter_name (const char *name); @@ -542,10 +542,22 @@ public: /// Accessor method for the default_policies_ TAO_Policy_Set *get_default_policies (void); - /// Get a cached policy. First, check the ORB-level Policy - /// Manager, and then check the ORB defaults. + /// Get a policy. First, check the ORB-level Policy Manager, then + /// check the ORB defaults. + CORBA::Policy_ptr get_policy (CORBA::PolicyType type); + + /// Get a policy. First, check the thread current, then check the + /// ORB-level Policy Manager, then check the ORB defaults. + CORBA::Policy_ptr get_policy_including_current (CORBA::PolicyType type); + + /// Get a cached policy. First, check the ORB-level Policy Manager, + /// then check the ORB defaults. CORBA::Policy_ptr get_cached_policy (TAO_Cached_Policy_Type type); + /// Get a cached policy. First, check the thread current, then + /// check the ORB-level Policy Manager, then check the ORB defaults. + CORBA::Policy_ptr get_cached_policy_including_current (TAO_Cached_Policy_Type type); + #endif /* TAO_HAS_CORBA_MESSAGING == 1 */ /** @@ -604,12 +616,6 @@ public: static void set_timeout_hook (Timeout_Hook hook); - - /// Access to the RoundtripTimeoutPolicy policy set on the thread or - /// on the ORB. In this method, we do not consider the stub since - /// we do not have access to it. - CORBA::Policy_ptr stubless_relative_roundtrip_timeout (void); - /// Invoke the timeout hook if present. /** * The timeout hook is used to determine if the timeout policy is @@ -626,13 +632,6 @@ public: /// Define the Timeout_Hook signature static void connection_timeout_hook (Timeout_Hook hook); - - /// Access to the connection timeout policy set on the thread or - /// on the ORB. In this method, we do not consider the stub since - /// we do not have access to it. - CORBA::Policy_ptr stubless_connection_timeout (void); - - void call_sync_scope_hook (TAO_Stub *stub, bool &has_synchronization, Messaging::SyncScope &scope); @@ -643,11 +642,8 @@ public: TAO_Stub *, bool &, Messaging::SyncScope &); - static void set_sync_scope_hook (Sync_Scope_Hook hook); -#if (TAO_HAS_SYNC_SCOPE_POLICY == 1) - CORBA::Policy_ptr stubless_sync_scope (void); -#endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */ + static void set_sync_scope_hook (Sync_Scope_Hook hook); #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) @@ -667,10 +663,6 @@ public: /// Handle to the factory for protocols_hooks_.. TAO_Protocols_Hooks *protocols_hooks_; - /// Flag to check whether the protocols hooks have been checked or - /// not. - bool protocols_hooks_checked_; - /// Obtain the TSS resources of this orb. TAO_ORB_Core_TSS_Resources* get_tss_resources (void); diff --git a/TAO/tao/Object.cpp b/TAO/tao/Object.cpp index bb64bcd766e..9128c56a59a 100644 --- a/TAO/tao/Object.cpp +++ b/TAO/tao/Object.cpp @@ -503,15 +503,15 @@ CORBA::Object::_get_policy ( } CORBA::Policy_ptr -CORBA::Object::_get_client_policy ( - CORBA::PolicyType type +CORBA::Object::_get_cached_policy ( + TAO_Cached_Policy_Type type ACE_ENV_ARG_DECL) { TAO_OBJECT_IOR_EVALUATE_RETURN; if (this->protocol_proxy_) - return this->_stubobj ()->get_client_policy (type - ACE_ENV_ARG_PARAMETER); + return this->protocol_proxy_->get_cached_policy (type + ACE_ENV_ARG_PARAMETER); else ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), CORBA::Policy::_nil ()); } diff --git a/TAO/tao/Object.h b/TAO/tao/Object.h index abe40a97ce6..f0509917711 100644 --- a/TAO/tao/Object.h +++ b/TAO/tao/Object.h @@ -213,7 +213,8 @@ namespace CORBA CORBA::Policy_ptr _get_policy (CORBA::PolicyType type ACE_ENV_ARG_DECL_WITH_DEFAULTS); - + CORBA::Policy_ptr _get_cached_policy (TAO_Cached_Policy_Type type + ACE_ENV_ARG_DECL_WITH_DEFAULTS); CORBA::Object_ptr _set_policy_overrides ( const CORBA::PolicyList & policies, @@ -287,12 +288,6 @@ namespace CORBA /// return value when finished with it. virtual TAO::ObjectKey *_key (ACE_ENV_SINGLE_ARG_DECL); -#if (TAO_HAS_CORBA_MESSAGING == 1) - - CORBA::Policy_ptr _get_client_policy (CORBA::PolicyType type - ACE_ENV_ARG_DECL_WITH_DEFAULTS); -#endif /*TAO_HAS_CORBA_MESSAGING*/ - /// Constructor Object (TAO_Stub *p, CORBA::Boolean collocated = 0, diff --git a/TAO/tao/Policy_Set.cpp b/TAO/tao/Policy_Set.cpp index 518901ec37d..3ffa2f14d8e 100644 --- a/TAO/tao/Policy_Set.cpp +++ b/TAO/tao/Policy_Set.cpp @@ -319,7 +319,7 @@ TAO_Policy_Set::get_policy_overrides (const CORBA::PolicyTypeSeq &types CORBA::Policy_ptr TAO_Policy_Set::get_policy (CORBA::PolicyType type - ACE_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { const CORBA::ULong length = this->policy_list_.length (); diff --git a/TAO/tao/PortableServer/Object_Adapter.cpp b/TAO/tao/PortableServer/Object_Adapter.cpp index 5f5257e9cd1..93c226157b8 100644 --- a/TAO/tao/PortableServer/Object_Adapter.cpp +++ b/TAO/tao/PortableServer/Object_Adapter.cpp @@ -660,8 +660,7 @@ TAO_Object_Adapter::set_default_server_protocol_policy (ACE_ENV_SINGLE_ARG_DECL) default_lane_resources.acceptor_registry (); TAO_Protocols_Hooks *protocols_hooks = - this->orb_core_.get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK; + this->orb_core_.get_protocols_hooks (); protocols_hooks->set_default_server_protocol_policy (acceptor_registry ACE_ENV_ARG_PARAMETER); diff --git a/TAO/tao/Protocols_Hooks.cpp b/TAO/tao/Protocols_Hooks.cpp index 16020c118d0..fe6aee07028 100644 --- a/TAO/tao/Protocols_Hooks.cpp +++ b/TAO/tao/Protocols_Hooks.cpp @@ -7,6 +7,49 @@ ACE_RCSID (tao, Protocols_Hooks, "$Id$") +TAO_IIOP_Protocol_Properties::TAO_IIOP_Protocol_Properties (void) + : send_buffer_size_ (0), + recv_buffer_size_ (0), + keep_alive_ (0), + dont_route_ (0), + no_delay_ (0), + enable_network_priority_ (0) +{ +} + +TAO_UIOP_Protocol_Properties::TAO_UIOP_Protocol_Properties (void) + : send_buffer_size_ (0), + recv_buffer_size_ (0) +{ +} + +TAO_SHMIOP_Protocol_Properties::TAO_SHMIOP_Protocol_Properties (void) + : send_buffer_size_ (0), + recv_buffer_size_ (0), + keep_alive_ (0), + dont_route_ (0), + no_delay_ (0), + preallocate_buffer_size_ (0), + mmap_filename_ (), + mmap_lockname_ () +{ +} + +TAO_DIOP_Protocol_Properties::TAO_DIOP_Protocol_Properties (void) + : enable_network_priority_ (0) +{ +} + +TAO_SCIOP_Protocol_Properties::TAO_SCIOP_Protocol_Properties (void) + : send_buffer_size_ (0), + recv_buffer_size_ (0), + keep_alive_ (0), + dont_route_ (0), + no_delay_ (0), + enable_network_priority_ (0) +{ +} + /// destructor TAO_Protocols_Hooks::~TAO_Protocols_Hooks (void) { diff --git a/TAO/tao/Protocols_Hooks.h b/TAO/tao/Protocols_Hooks.h index d6a325df4da..1818438e4b5 100644 --- a/TAO/tao/Protocols_Hooks.h +++ b/TAO/tao/Protocols_Hooks.h @@ -24,6 +24,8 @@ #include "TAO_Export.h" #include "Basic_Types.h" +#include "IOP_IORC.h" +#include "ace/SString.h" namespace CORBA { @@ -40,6 +42,69 @@ class TAO_Connection_Handler; class TAO_Transport; class TAO_Stub; +class TAO_IIOP_Protocol_Properties +{ +public: + + TAO_IIOP_Protocol_Properties (void); + + CORBA::Long send_buffer_size_; + CORBA::Long recv_buffer_size_; + CORBA::Boolean keep_alive_; + CORBA::Boolean dont_route_; + CORBA::Boolean no_delay_; + CORBA::Boolean enable_network_priority_; +}; + +class TAO_UIOP_Protocol_Properties +{ +public: + + TAO_UIOP_Protocol_Properties (void); + + CORBA::Long send_buffer_size_; + CORBA::Long recv_buffer_size_; +}; + +class TAO_SHMIOP_Protocol_Properties +{ +public: + + TAO_SHMIOP_Protocol_Properties (void); + + CORBA::Long send_buffer_size_; + CORBA::Long recv_buffer_size_; + CORBA::Boolean keep_alive_; + CORBA::Boolean dont_route_; + CORBA::Boolean no_delay_; + CORBA::Long preallocate_buffer_size_; + ACE_CString mmap_filename_; + ACE_CString mmap_lockname_; +}; + +class TAO_DIOP_Protocol_Properties +{ +public: + + TAO_DIOP_Protocol_Properties (void); + + CORBA::Boolean enable_network_priority_; +}; + +class TAO_SCIOP_Protocol_Properties +{ +public: + + TAO_SCIOP_Protocol_Properties (void); + + CORBA::Long send_buffer_size_; + CORBA::Long recv_buffer_size_; + CORBA::Boolean keep_alive_; + CORBA::Boolean dont_route_; + CORBA::Boolean no_delay_; + CORBA::Boolean enable_network_priority_; +}; + class TAO_Export TAO_Protocols_Hooks : public ACE_Service_Object { public: @@ -50,30 +115,44 @@ public: virtual void init_hooks (TAO_ORB_Core *orb_core ACE_ENV_ARG_DECL) = 0; - virtual int call_client_protocols_hook (int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char *protocol_type) = 0; - - virtual int call_server_protocols_hook (int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char *protocol_type) = 0; - - virtual int update_client_protocol_properties ( - TAO_Stub *stub, - TAO_Transport *t, - const char *protocol_type) = 0; - - - virtual int update_server_protocol_properties ( - CORBA::Policy *policy, - TAO_Transport *t, - const char *protocol_type) = 0; - - + virtual CORBA::Boolean set_client_network_priority (IOP::ProfileId protocol_tag, + TAO_Stub *stub + ACE_ENV_ARG_DECL) = 0; + + virtual CORBA::Boolean set_server_network_priority (IOP::ProfileId protocol_tag, + CORBA::Policy *policy + ACE_ENV_ARG_DECL) = 0; + + virtual void server_protocol_properties_at_orb_level (TAO_IIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL) = 0; + + virtual void client_protocol_properties_at_orb_level (TAO_IIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL) = 0; + + virtual void server_protocol_properties_at_orb_level (TAO_UIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL) = 0; + + virtual void client_protocol_properties_at_orb_level (TAO_UIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL) = 0; + + virtual void server_protocol_properties_at_orb_level (TAO_SHMIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL) = 0; + + virtual void client_protocol_properties_at_orb_level (TAO_SHMIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL) = 0; + + virtual void server_protocol_properties_at_orb_level (TAO_DIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL) = 0; + + virtual void client_protocol_properties_at_orb_level (TAO_DIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL) = 0; + + virtual void server_protocol_properties_at_orb_level (TAO_SCIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL) = 0; + + virtual void client_protocol_properties_at_orb_level (TAO_SCIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL) = 0; + virtual CORBA::Long get_dscp_codepoint (void) = 0; virtual void rt_service_context (TAO_Stub *stub, @@ -106,29 +185,24 @@ public: */ //@{ virtual int get_thread_CORBA_priority (CORBA::Short & - ACE_ENV_ARG_DECL_NOT_USED) = 0; + ACE_ENV_ARG_DECL) = 0; virtual int get_thread_native_priority (CORBA::Short & - ACE_ENV_ARG_DECL_NOT_USED) = 0; + ACE_ENV_ARG_DECL) = 0; virtual int get_thread_CORBA_and_native_priority ( CORBA::Short &, CORBA::Short & - ACE_ENV_ARG_DECL_NOT_USED) = 0; + ACE_ENV_ARG_DECL) = 0; virtual int set_thread_CORBA_priority (CORBA::Short - ACE_ENV_ARG_DECL_NOT_USED) = 0; + ACE_ENV_ARG_DECL) = 0; virtual int set_thread_native_priority (CORBA::Short - ACE_ENV_ARG_DECL_NOT_USED) = 0; + ACE_ENV_ARG_DECL) = 0; //@} - /// Sets the default_policies for ORB. - /// 1. Sets ORB-level policy defaults for this ORB. Currently sets - /// default RTCORBA policies: ClientProtocolPolicy. - virtual int set_default_policies (ACE_ENV_SINGLE_ARG_DECL) = 0; - /// Sets the default ServerProtocolPolicy. virtual int set_default_server_protocol_policy ( TAO_Acceptor_Registry &acceptor_registry diff --git a/TAO/tao/RTCORBA/RTCORBA.pidl b/TAO/tao/RTCORBA/RTCORBA.pidl index ddc3c2c9dc9..1f2f0e3ce93 100644 --- a/TAO/tao/RTCORBA/RTCORBA.pidl +++ b/TAO/tao/RTCORBA/RTCORBA.pidl @@ -18,7 +18,7 @@ * 3. Added RT_ORB::create_tcp_protocol_properties which seems * to come and go from the formal specification, but is needed. * - * This file was used to generate the code in RTCORBAC.{h,i,cpp}. + * This file was used to generate the code in RTCORBAC.{h,inl,cpp}. * The steps to regenerate the code are as follows: * * 1. Run the tao_idl compiler on the pidl file. The command used for @@ -43,7 +43,7 @@ * * Note: The diffs were generated with these commands: * - * for i in RTCORBAC.{h,i,cpp}; do + * for i in RTCORBAC.{h,inl,cpp}; do * diff -wBbu orig/$i $i * done > diffs/RTCORBA.diff * @@ -166,11 +166,31 @@ module RTCORBA // Communication over Shared Memory. local interface SharedMemoryProtocolProperties : ProtocolProperties { + attribute long send_buffer_size; + attribute long recv_buffer_size; + attribute boolean keep_alive; + attribute boolean dont_route; + attribute boolean no_delay; attribute long preallocate_buffer_size; attribute string mmap_filename; attribute string mmap_lockname; }; + local interface UserDatagramProtocolProperties : ProtocolProperties + { + attribute boolean enable_network_priority; + }; + + local interface StreamControlProtocolProperties : ProtocolProperties + { + attribute long send_buffer_size; + attribute long recv_buffer_size; + attribute boolean keep_alive; + attribute boolean dont_route; + attribute boolean no_delay; + attribute boolean enable_network_priority; + }; + // End of TAO-specific interfaces. // PriorityBandedConnectionPolicy. @@ -225,7 +245,32 @@ module RTCORBA in boolean keep_alive, in boolean dont_route, in boolean no_delay, - in boolean enable_network_priority); + in boolean enable_network_priority); + + UnixDomainProtocolProperties create_unix_domain_protocol_properties( + in long send_buffer_size, + in long recv_buffer_size); + + SharedMemoryProtocolProperties create_shared_memory_protocol_properties( + in long send_buffer_size, + in long recv_buffer_size, + in boolean keep_alive, + in boolean dont_route, + in boolean no_delay, + in long preallocate_buffer_size, + in string mmap_filename, + in string mmap_lockname); + + UserDatagramProtocolProperties create_user_datagram_protocol_properties( + in boolean enable_network_priority); + + StreamControlProtocolProperties create_stream_control_protocol_properties( + in long send_buffer_size, + in long recv_buffer_size, + in boolean keep_alive, + in boolean dont_route, + in boolean no_delay, + in boolean enable_network_priority); // Threadpool creation/destruction. exception InvalidThreadpool {}; diff --git a/TAO/tao/RTCORBA/RTCORBAC.cpp b/TAO/tao/RTCORBA/RTCORBAC.cpp index 7c31e119b55..d54c0cc9cde 100644 --- a/TAO/tao/RTCORBA/RTCORBAC.cpp +++ b/TAO/tao/RTCORBA/RTCORBAC.cpp @@ -26,7 +26,7 @@ // http://www.cs.wustl.edu/~schmidt/TAO.html // TAO_IDL - Generated from -// be\be_codegen.cpp:303 +// be/be_codegen.cpp:303 #include "RTCORBA.h" @@ -49,14 +49,13 @@ #endif /* !defined INLINE */ // TAO_IDL - Generated from -// be\be_visitor_arg_traits.cpp:64 +// be/be_visitor_arg_traits.cpp:64 // Arg traits specializations. namespace TAO { } - ////////////////////////////////////////////////////// // CDR Encoding Support hand crafted @@ -74,7 +73,8 @@ RTCORBA::ProtocolProperties::_tao_decode (TAO_InputCDR &) return 1; } -// be\be_visitor_typecode/typecode_defn.cpp:290 +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_NativePriority[] = { @@ -114,7 +114,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_Priority[] = { @@ -152,7 +152,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_NetworkPriority[] = { @@ -192,7 +192,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_ThreadpoolId[] = { @@ -232,7 +232,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_ThreadpoolLane[] = { @@ -310,7 +310,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_structure/structure_cs.cpp:66 +// be/be_visitor_structure/structure_cs.cpp:66 void RTCORBA::ThreadpoolLane::_tao_any_destructor ( @@ -323,7 +323,7 @@ RTCORBA::ThreadpoolLane::_tao_any_destructor ( } // TAO_IDL - Generated from -// be\be_visitor_sequence/sequence_cs.cpp:65 +// be/be_visitor_sequence/sequence_cs.cpp:65 #if !defined (_RTCORBA_THREADPOOLLANES_CS_) #define _RTCORBA_THREADPOOLLANES_CS_ @@ -376,7 +376,7 @@ void RTCORBA::ThreadpoolLanes::_tao_any_destructor ( #endif /* end #if !defined */ // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_ThreadpoolLanes[] = { @@ -479,7 +479,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_PriorityModel[] = { @@ -529,7 +529,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::PriorityModelPolicy. @@ -678,7 +678,7 @@ RTCORBA::PriorityModelPolicy::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_PriorityModelPolicy[] = { @@ -718,7 +718,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::ThreadpoolPolicy. @@ -867,7 +867,7 @@ RTCORBA::ThreadpoolPolicy::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_ThreadpoolPolicy[] = { @@ -907,7 +907,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::ProtocolProperties. @@ -1052,7 +1052,7 @@ RTCORBA::ProtocolProperties::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_ProtocolProperties[] = { @@ -1092,7 +1092,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_Protocol[] = { @@ -1213,7 +1213,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_structure/structure_cs.cpp:66 +// be/be_visitor_structure/structure_cs.cpp:66 void RTCORBA::Protocol::_tao_any_destructor ( @@ -1226,7 +1226,7 @@ RTCORBA::Protocol::_tao_any_destructor ( } // TAO_IDL - Generated from -// be\be_visitor_sequence/sequence_cs.cpp:65 +// be/be_visitor_sequence/sequence_cs.cpp:65 #if !defined (_RTCORBA_PROTOCOLLIST_CS_) #define _RTCORBA_PROTOCOLLIST_CS_ @@ -1279,7 +1279,7 @@ void RTCORBA::ProtocolList::_tao_any_destructor ( #endif /* end #if !defined */ // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_ProtocolList[] = { @@ -1425,7 +1425,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::ServerProtocolPolicy. @@ -1574,7 +1574,7 @@ RTCORBA::ServerProtocolPolicy::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_ServerProtocolPolicy[] = { @@ -1616,7 +1616,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::ClientProtocolPolicy. @@ -1765,7 +1765,7 @@ RTCORBA::ClientProtocolPolicy::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_ClientProtocolPolicy[] = { @@ -1807,7 +1807,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::PrivateConnectionPolicy. @@ -1956,7 +1956,7 @@ RTCORBA::PrivateConnectionPolicy::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_PrivateConnectionPolicy[] = { @@ -1998,7 +1998,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::TCPProtocolProperties. @@ -2147,7 +2147,7 @@ RTCORBA::TCPProtocolProperties::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_TCPProtocolProperties[] = { @@ -2189,7 +2189,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::GIOPProtocolProperties. @@ -2338,7 +2338,7 @@ RTCORBA::GIOPProtocolProperties::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_GIOPProtocolProperties[] = { @@ -2380,7 +2380,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::UnixDomainProtocolProperties. @@ -2529,7 +2529,7 @@ RTCORBA::UnixDomainProtocolProperties::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_UnixDomainProtocolProperties[] = { @@ -2575,7 +2575,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::SharedMemoryProtocolProperties. @@ -2724,7 +2724,7 @@ RTCORBA::SharedMemoryProtocolProperties::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_SharedMemoryProtocolProperties[] = { @@ -2770,7 +2770,397 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_interface/interface_cs.cpp:60 + +// Traits specializations for RTCORBA::UserDatagramProtocolProperties. + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +RTCORBA::UserDatagramProtocolProperties_ptr +TAO::Objref_Traits<RTCORBA::UserDatagramProtocolProperties>::duplicate ( + RTCORBA::UserDatagramProtocolProperties_ptr p + ) +{ + return RTCORBA::UserDatagramProtocolProperties::_duplicate (p); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +void +TAO::Objref_Traits<RTCORBA::UserDatagramProtocolProperties>::release ( + RTCORBA::UserDatagramProtocolProperties_ptr p + ) +{ + CORBA::release (p); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +RTCORBA::UserDatagramProtocolProperties_ptr +TAO::Objref_Traits<RTCORBA::UserDatagramProtocolProperties>::nil (void) +{ + return RTCORBA::UserDatagramProtocolProperties::_nil (); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +CORBA::Boolean +TAO::Objref_Traits<RTCORBA::UserDatagramProtocolProperties>::marshal ( + RTCORBA::UserDatagramProtocolProperties_ptr p, + TAO_OutputCDR & cdr + ) +{ + return CORBA::Object::marshal (p, cdr); +} + +// Function pointer for collocation factory initialization. +TAO::Collocation_Proxy_Broker * +(*RTCORBA__TAO_UserDatagramProtocolProperties_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; + +RTCORBA::UserDatagramProtocolProperties::UserDatagramProtocolProperties (void) +{} + +RTCORBA::UserDatagramProtocolProperties::~UserDatagramProtocolProperties (void) +{} + +void +RTCORBA::UserDatagramProtocolProperties::_tao_any_destructor (void *_tao_void_pointer) +{ + UserDatagramProtocolProperties *_tao_tmp_pointer = + static_cast<UserDatagramProtocolProperties *> (_tao_void_pointer); + CORBA::release (_tao_tmp_pointer); +} + +RTCORBA::UserDatagramProtocolProperties_ptr +RTCORBA::UserDatagramProtocolProperties::_narrow ( + CORBA::Object_ptr _tao_objref + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (_tao_objref)) + { + return UserDatagramProtocolProperties::_nil (); + } + + UserDatagramProtocolProperties_ptr proxy = + dynamic_cast<UserDatagramProtocolProperties_ptr> (_tao_objref); + + return UserDatagramProtocolProperties::_duplicate (proxy); +} + +RTCORBA::UserDatagramProtocolProperties_ptr +RTCORBA::UserDatagramProtocolProperties::_unchecked_narrow ( + CORBA::Object_ptr _tao_objref + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (_tao_objref)) + { + return UserDatagramProtocolProperties::_nil (); + } + + UserDatagramProtocolProperties_ptr proxy = + dynamic_cast<UserDatagramProtocolProperties_ptr> (_tao_objref); + + return UserDatagramProtocolProperties::_duplicate (proxy); +} + +RTCORBA::UserDatagramProtocolProperties_ptr +RTCORBA::UserDatagramProtocolProperties::_duplicate (UserDatagramProtocolProperties_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +CORBA::Boolean +RTCORBA::UserDatagramProtocolProperties::_is_a ( + const char *value + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if ( + !ACE_OS::strcmp ( + (char *)value, + "IDL:omg.org/RTCORBA/ProtocolProperties:1.0" + ) || + !ACE_OS::strcmp ( + (char *)value, + "IDL:omg.org/RTCORBA/UserDatagramProtocolProperties:1.0" + ) || + !ACE_OS::strcmp ( + (char *)value, + "IDL:omg.org/CORBA/LocalObject:1.0" + ) || + !ACE_OS::strcmp ( + (char *)value, + "IDL:omg.org/CORBA/Object:1.0" + ) + ) + { + return 1; // success using local knowledge + } + else + { + return 0; + } +} + +const char* RTCORBA::UserDatagramProtocolProperties::_interface_repository_id (void) const +{ + return "IDL:omg.org/RTCORBA/UserDatagramProtocolProperties:1.0"; +} + +CORBA::Boolean +RTCORBA::UserDatagramProtocolProperties::marshal (TAO_OutputCDR &) +{ + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:290 + +static const CORBA::Long _oc_RTCORBA_UserDatagramProtocolProperties[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 55, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x5254434f), + ACE_NTOHL (0x5242412f), + ACE_NTOHL (0x55736572), + ACE_NTOHL (0x44617461), + ACE_NTOHL (0x6772616d), + ACE_NTOHL (0x50726f74), + ACE_NTOHL (0x6f636f6c), + ACE_NTOHL (0x50726f70), + ACE_NTOHL (0x65727469), + ACE_NTOHL (0x65733a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/RTCORBA/UserDatagramProtocolProperties:1.0 + 31, + ACE_NTOHL (0x55736572), + ACE_NTOHL (0x44617461), + ACE_NTOHL (0x6772616d), + ACE_NTOHL (0x50726f74), + ACE_NTOHL (0x6f636f6c), + ACE_NTOHL (0x50726f70), + ACE_NTOHL (0x65727469), + ACE_NTOHL (0x65730000), // name = UserDatagramProtocolProperties + }; + +static CORBA::TypeCode _tc_TAO_tc_RTCORBA_UserDatagramProtocolProperties ( + CORBA::tk_objref, + sizeof (_oc_RTCORBA_UserDatagramProtocolProperties), + (char *) &_oc_RTCORBA_UserDatagramProtocolProperties, + 0, + sizeof (RTCORBA::UserDatagramProtocolProperties) + ); + +namespace RTCORBA +{ + ::CORBA::TypeCode_ptr _tc_UserDatagramProtocolProperties = + &_tc_TAO_tc_RTCORBA_UserDatagramProtocolProperties; +} + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:60 + +// Traits specializations for RTCORBA::StreamControlProtocolProperties. + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +RTCORBA::StreamControlProtocolProperties_ptr +TAO::Objref_Traits<RTCORBA::StreamControlProtocolProperties>::duplicate ( + RTCORBA::StreamControlProtocolProperties_ptr p + ) +{ + return RTCORBA::StreamControlProtocolProperties::_duplicate (p); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +void +TAO::Objref_Traits<RTCORBA::StreamControlProtocolProperties>::release ( + RTCORBA::StreamControlProtocolProperties_ptr p + ) +{ + CORBA::release (p); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +RTCORBA::StreamControlProtocolProperties_ptr +TAO::Objref_Traits<RTCORBA::StreamControlProtocolProperties>::nil (void) +{ + return RTCORBA::StreamControlProtocolProperties::_nil (); +} + +ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION +CORBA::Boolean +TAO::Objref_Traits<RTCORBA::StreamControlProtocolProperties>::marshal ( + RTCORBA::StreamControlProtocolProperties_ptr p, + TAO_OutputCDR & cdr + ) +{ + return CORBA::Object::marshal (p, cdr); +} + +// Function pointer for collocation factory initialization. +TAO::Collocation_Proxy_Broker * +(*RTCORBA__TAO_StreamControlProtocolProperties_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; + +RTCORBA::StreamControlProtocolProperties::StreamControlProtocolProperties (void) +{} + +RTCORBA::StreamControlProtocolProperties::~StreamControlProtocolProperties (void) +{} + +void +RTCORBA::StreamControlProtocolProperties::_tao_any_destructor (void *_tao_void_pointer) +{ + StreamControlProtocolProperties *_tao_tmp_pointer = + static_cast<StreamControlProtocolProperties *> (_tao_void_pointer); + CORBA::release (_tao_tmp_pointer); +} + +RTCORBA::StreamControlProtocolProperties_ptr +RTCORBA::StreamControlProtocolProperties::_narrow ( + CORBA::Object_ptr _tao_objref + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (_tao_objref)) + { + return StreamControlProtocolProperties::_nil (); + } + + StreamControlProtocolProperties_ptr proxy = + dynamic_cast<StreamControlProtocolProperties_ptr> (_tao_objref); + + return StreamControlProtocolProperties::_duplicate (proxy); +} + +RTCORBA::StreamControlProtocolProperties_ptr +RTCORBA::StreamControlProtocolProperties::_unchecked_narrow ( + CORBA::Object_ptr _tao_objref + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (_tao_objref)) + { + return StreamControlProtocolProperties::_nil (); + } + + StreamControlProtocolProperties_ptr proxy = + dynamic_cast<StreamControlProtocolProperties_ptr> (_tao_objref); + + return StreamControlProtocolProperties::_duplicate (proxy); +} + +RTCORBA::StreamControlProtocolProperties_ptr +RTCORBA::StreamControlProtocolProperties::_duplicate (StreamControlProtocolProperties_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +CORBA::Boolean +RTCORBA::StreamControlProtocolProperties::_is_a ( + const char *value + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if ( + !ACE_OS::strcmp ( + (char *)value, + "IDL:omg.org/RTCORBA/ProtocolProperties:1.0" + ) || + !ACE_OS::strcmp ( + (char *)value, + "IDL:omg.org/RTCORBA/StreamControlProtocolProperties:1.0" + ) || + !ACE_OS::strcmp ( + (char *)value, + "IDL:omg.org/CORBA/LocalObject:1.0" + ) || + !ACE_OS::strcmp ( + (char *)value, + "IDL:omg.org/CORBA/Object:1.0" + ) + ) + { + return 1; // success using local knowledge + } + else + { + return 0; + } +} + +const char* RTCORBA::StreamControlProtocolProperties::_interface_repository_id (void) const +{ + return "IDL:omg.org/RTCORBA/StreamControlProtocolProperties:1.0"; +} + +CORBA::Boolean +RTCORBA::StreamControlProtocolProperties::marshal (TAO_OutputCDR &) +{ + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:290 + +static const CORBA::Long _oc_RTCORBA_StreamControlProtocolProperties[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 56, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x5254434f), + ACE_NTOHL (0x5242412f), + ACE_NTOHL (0x53747265), + ACE_NTOHL (0x616d436f), + ACE_NTOHL (0x6e74726f), + ACE_NTOHL (0x6c50726f), + ACE_NTOHL (0x746f636f), + ACE_NTOHL (0x6c50726f), + ACE_NTOHL (0x70657274), + ACE_NTOHL (0x6965733a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/RTCORBA/StreamControlProtocolProperties:1.0 + 32, + ACE_NTOHL (0x53747265), + ACE_NTOHL (0x616d436f), + ACE_NTOHL (0x6e74726f), + ACE_NTOHL (0x6c50726f), + ACE_NTOHL (0x746f636f), + ACE_NTOHL (0x6c50726f), + ACE_NTOHL (0x70657274), + ACE_NTOHL (0x69657300), // name = StreamControlProtocolProperties + }; + +static CORBA::TypeCode _tc_TAO_tc_RTCORBA_StreamControlProtocolProperties ( + CORBA::tk_objref, + sizeof (_oc_RTCORBA_StreamControlProtocolProperties), + (char *) &_oc_RTCORBA_StreamControlProtocolProperties, + 0, + sizeof (RTCORBA::StreamControlProtocolProperties) + ); + +namespace RTCORBA +{ + ::CORBA::TypeCode_ptr _tc_StreamControlProtocolProperties = + &_tc_TAO_tc_RTCORBA_StreamControlProtocolProperties; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_PriorityBand[] = { @@ -2854,7 +3244,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_structure/structure_cs.cpp:66 +// be/be_visitor_structure/structure_cs.cpp:66 void RTCORBA::PriorityBand::_tao_any_destructor ( @@ -2867,7 +3257,7 @@ RTCORBA::PriorityBand::_tao_any_destructor ( } // TAO_IDL - Generated from -// be\be_visitor_sequence/sequence_cs.cpp:65 +// be/be_visitor_sequence/sequence_cs.cpp:65 #if !defined (_RTCORBA_PRIORITYBANDS_CS_) #define _RTCORBA_PRIORITYBANDS_CS_ @@ -2920,7 +3310,7 @@ void RTCORBA::PriorityBands::_tao_any_destructor ( #endif /* end #if !defined */ // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_PriorityBands[] = { @@ -3029,7 +3419,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::PriorityBandedConnectionPolicy. @@ -3178,7 +3568,7 @@ RTCORBA::PriorityBandedConnectionPolicy::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_PriorityBandedConnectionPolicy[] = { @@ -3224,7 +3614,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::Current. @@ -3373,7 +3763,7 @@ RTCORBA::Current::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_Current[] = { @@ -3407,7 +3797,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::Mutex. @@ -3552,7 +3942,7 @@ RTCORBA::Mutex::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_Mutex[] = { @@ -3586,7 +3976,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_interface/interface_cs.cpp:60 +// be/be_visitor_interface/interface_cs.cpp:60 // Traits specializations for RTCORBA::RTORB. @@ -3632,7 +4022,7 @@ TAO::Collocation_Proxy_Broker * ) = 0; // TAO_IDL - Generated from -// be\be_visitor_exception/exception_cs.cpp:63 +// be/be_visitor_exception/exception_cs.cpp:63 RTCORBA::RTORB::MutexNotFound::MutexNotFound (void) : CORBA::UserException ( @@ -3728,7 +4118,7 @@ CORBA::TypeCode_ptr RTCORBA::RTORB::MutexNotFound::_type (void) const } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_RTORB_MutexNotFound[] = { @@ -3765,7 +4155,7 @@ static CORBA::TypeCode _tc_TAO_tc_RTCORBA_RTORB_MutexNotFound ( &_tc_TAO_tc_RTCORBA_RTORB_MutexNotFound; // TAO_IDL - Generated from -// be\be_visitor_exception/exception_cs.cpp:63 +// be/be_visitor_exception/exception_cs.cpp:63 RTCORBA::RTORB::InvalidThreadpool::InvalidThreadpool (void) : CORBA::UserException ( @@ -3861,7 +4251,7 @@ CORBA::TypeCode_ptr RTCORBA::RTORB::InvalidThreadpool::_type (void) const } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_RTORB_InvalidThreadpool[] = { @@ -3999,7 +4389,7 @@ RTCORBA::RTORB::marshal (TAO_OutputCDR &) } // TAO_IDL - Generated from -// be\be_visitor_typecode/typecode_defn.cpp:290 +// be/be_visitor_typecode/typecode_defn.cpp:290 static const CORBA::Long _oc_RTCORBA_RTORB[] = { @@ -4033,7 +4423,7 @@ namespace RTCORBA } // TAO_IDL - Generated from -// be\be_visitor_structure/any_op_cs.cpp:54 +// be/be_visitor_structure/any_op_cs.cpp:54 // Copying insertion. void operator<<= ( @@ -4091,7 +4481,7 @@ CORBA::Boolean operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_sequence/any_op_cs.cpp:54 +// be/be_visitor_sequence/any_op_cs.cpp:54 // Copying insertion. void operator<<= ( @@ -4149,7 +4539,7 @@ CORBA::Boolean operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_enum/any_op_cs.cpp:52 +// be/be_visitor_enum/any_op_cs.cpp:52 void operator<<= ( CORBA::Any &_tao_any, @@ -4177,7 +4567,7 @@ CORBA::Boolean operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -4246,7 +4636,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -4315,7 +4705,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -4384,7 +4774,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_structure/any_op_cs.cpp:54 +// be/be_visitor_structure/any_op_cs.cpp:54 @@ -4456,7 +4846,7 @@ CORBA::Boolean operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_sequence/any_op_cs.cpp:54 +// be/be_visitor_sequence/any_op_cs.cpp:54 @@ -4528,7 +4918,7 @@ CORBA::Boolean operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -4597,7 +4987,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -4666,7 +5056,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -4735,7 +5125,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -4804,7 +5194,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -4873,7 +5263,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -4942,7 +5332,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -5010,8 +5400,146 @@ operator>>= ( ); } +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_cs.cpp:50 + +ACE_TEMPLATE_SPECIALIZATION +CORBA::Boolean +TAO::Any_Impl_T<RTCORBA::UserDatagramProtocolProperties>::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +ACE_TEMPLATE_SPECIALIZATION +CORBA::Boolean +TAO::Any_Impl_T<RTCORBA::UserDatagramProtocolProperties>::marshal_value (TAO_OutputCDR &) +{ + return 0; +} + +ACE_TEMPLATE_SPECIALIZATION +CORBA::Boolean +TAO::Any_Impl_T<RTCORBA::UserDatagramProtocolProperties>::demarshal_value (TAO_InputCDR &) +{ + return 0; +} + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + RTCORBA::UserDatagramProtocolProperties_ptr _tao_elem + ) +{ + RTCORBA::UserDatagramProtocolProperties_ptr _tao_objptr = + RTCORBA::UserDatagramProtocolProperties::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + RTCORBA::UserDatagramProtocolProperties_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T<RTCORBA::UserDatagramProtocolProperties>::insert ( + _tao_any, + RTCORBA::UserDatagramProtocolProperties::_tao_any_destructor, + RTCORBA::_tc_UserDatagramProtocolProperties, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + RTCORBA::UserDatagramProtocolProperties_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T<RTCORBA::UserDatagramProtocolProperties>::extract ( + _tao_any, + RTCORBA::UserDatagramProtocolProperties::_tao_any_destructor, + RTCORBA::_tc_UserDatagramProtocolProperties, + _tao_elem + ); +} + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_cs.cpp:50 + +ACE_TEMPLATE_SPECIALIZATION +CORBA::Boolean +TAO::Any_Impl_T<RTCORBA::StreamControlProtocolProperties>::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +ACE_TEMPLATE_SPECIALIZATION +CORBA::Boolean +TAO::Any_Impl_T<RTCORBA::StreamControlProtocolProperties>::marshal_value (TAO_OutputCDR &) +{ + return 0; +} + +ACE_TEMPLATE_SPECIALIZATION +CORBA::Boolean +TAO::Any_Impl_T<RTCORBA::StreamControlProtocolProperties>::demarshal_value (TAO_InputCDR &) +{ + return 0; +} + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + RTCORBA::StreamControlProtocolProperties_ptr _tao_elem + ) +{ + RTCORBA::StreamControlProtocolProperties_ptr _tao_objptr = + RTCORBA::StreamControlProtocolProperties::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + RTCORBA::StreamControlProtocolProperties_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T<RTCORBA::StreamControlProtocolProperties>::insert ( + _tao_any, + RTCORBA::StreamControlProtocolProperties::_tao_any_destructor, + RTCORBA::_tc_StreamControlProtocolProperties, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + RTCORBA::StreamControlProtocolProperties_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T<RTCORBA::StreamControlProtocolProperties>::extract ( + _tao_any, + RTCORBA::StreamControlProtocolProperties::_tao_any_destructor, + RTCORBA::_tc_StreamControlProtocolProperties, + _tao_elem + ); +} + // TAO_IDL - Generated from -// be\be_visitor_structure/any_op_cs.cpp:54 +// be/be_visitor_structure/any_op_cs.cpp:54 // Copying insertion. void operator<<= ( @@ -5069,7 +5597,7 @@ CORBA::Boolean operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_sequence/any_op_cs.cpp:54 +// be/be_visitor_sequence/any_op_cs.cpp:54 // Copying insertion. void operator<<= ( @@ -5127,7 +5655,7 @@ CORBA::Boolean operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -5196,7 +5724,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -5265,7 +5793,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -5334,7 +5862,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_cs.cpp:50 +// be/be_visitor_interface/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -5403,7 +5931,7 @@ operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_exception/any_op_cs.cpp:50 +// be/be_visitor_exception/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -5475,7 +6003,7 @@ CORBA::Boolean operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_exception/any_op_cs.cpp:50 +// be/be_visitor_exception/any_op_cs.cpp:50 ACE_TEMPLATE_SPECIALIZATION CORBA::Boolean @@ -5547,7 +6075,7 @@ CORBA::Boolean operator>>= ( } // TAO_IDL - Generated from -// be\be_visitor_structure/cdr_op_cs.cpp:61 +// be/be_visitor_structure/cdr_op_cs.cpp:61 CORBA::Boolean operator<< ( TAO_OutputCDR &strm, @@ -5572,7 +6100,7 @@ CORBA::Boolean operator>> ( } // TAO_IDL - Generated from -// be\be_visitor_sequence/cdr_op_cs.cpp:96 +// be/be_visitor_sequence/cdr_op_cs.cpp:96 #if !defined _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_CPP_ #define _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_CPP_ @@ -5644,7 +6172,7 @@ CORBA::Boolean operator>> ( #endif /* _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_CPP_ */ // TAO_IDL - Generated from -// be\be_visitor_enum/cdr_op_cs.cpp:51 +// be/be_visitor_enum/cdr_op_cs.cpp:51 CORBA::Boolean operator<< (TAO_OutputCDR &strm, const RTCORBA::PriorityModel &_tao_enumval) { @@ -5666,7 +6194,7 @@ CORBA::Boolean operator>> (TAO_InputCDR &strm, RTCORBA::PriorityModel &_tao_enum } // TAO_IDL - Generated from -// be\be_visitor_structure/cdr_op_cs.cpp:61 +// be/be_visitor_structure/cdr_op_cs.cpp:61 CORBA::Boolean operator<< ( TAO_OutputCDR &strm, @@ -5689,7 +6217,7 @@ CORBA::Boolean operator>> ( } // TAO_IDL - Generated from -// be\be_visitor_sequence/cdr_op_cs.cpp:96 +// be/be_visitor_sequence/cdr_op_cs.cpp:96 #if !defined _TAO_CDR_OP_RTCORBA_PriorityBands_CPP_ #define _TAO_CDR_OP_RTCORBA_PriorityBands_CPP_ @@ -5761,7 +6289,7 @@ CORBA::Boolean operator>> ( #endif /* _TAO_CDR_OP_RTCORBA_PriorityBands_CPP_ */ // TAO_IDL - Generated from -// be\be_visitor_root/root.cpp:1629 +// be/be_visitor_root/root.cpp:1629 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) @@ -6075,6 +6603,46 @@ CORBA::Boolean operator>> ( >; template class + TAO::Objref_Traits< + RTCORBA::UserDatagramProtocolProperties + >; + + template class + TAO_Objref_Var_T< + RTCORBA::UserDatagramProtocolProperties + >; + + template class + TAO_Objref_Out_T< + RTCORBA::UserDatagramProtocolProperties + >; + + template class + TAO::Any_Impl_T< + RTCORBA::UserDatagramProtocolProperties + >; + + template class + TAO::Objref_Traits< + RTCORBA::StreamControlProtocolProperties + >; + + template class + TAO_Objref_Var_T< + RTCORBA::StreamControlProtocolProperties + >; + + template class + TAO_Objref_Out_T< + RTCORBA::StreamControlProtocolProperties + >; + + template class + TAO::Any_Impl_T< + RTCORBA::StreamControlProtocolProperties + >; + + template class TAO_Fixed_Var_T< RTCORBA::PriorityBand >; @@ -6525,6 +7093,46 @@ CORBA::Boolean operator>> ( > # pragma instantiate \ + TAO::Objref_Traits< \ + RTCORBA::UserDatagramProtocolProperties \ + > + +# pragma instantiate \ + TAO_Objref_Var_T< \ + RTCORBA::UserDatagramProtocolProperties + > + +# pragma instantiate \ + TAO_Objref_Out_T< \ + RTCORBA::UserDatagramProtocolProperties + > + +# pragma instantiate \ + TAO::Any_Impl_T< \ + RTCORBA::UserDatagramProtocolProperties \ + > + +# pragma instantiate \ + TAO::Objref_Traits< \ + RTCORBA::StreamControlProtocolProperties \ + > + +# pragma instantiate \ + TAO_Objref_Var_T< \ + RTCORBA::StreamControlProtocolProperties + > + +# pragma instantiate \ + TAO_Objref_Out_T< \ + RTCORBA::StreamControlProtocolProperties + > + +# pragma instantiate \ + TAO::Any_Impl_T< \ + RTCORBA::StreamControlProtocolProperties \ + > + +# pragma instantiate \ TAO_Fixed_Var_T< \ RTCORBA::PriorityBand \ > diff --git a/TAO/tao/RTCORBA/RTCORBAC.h b/TAO/tao/RTCORBA/RTCORBAC.h index 35d04be0554..5603ff1398f 100644 --- a/TAO/tao/RTCORBA/RTCORBAC.h +++ b/TAO/tao/RTCORBA/RTCORBAC.h @@ -26,10 +26,10 @@ // http://www.cs.wustl.edu/~schmidt/TAO.html // TAO_IDL - Generated from -// be\be_codegen.cpp:153 +// be/be_codegen.cpp:153 -#ifndef _TAO_IDL_ORIG_RTCORBAC_H_ -#define _TAO_IDL_ORIG_RTCORBAC_H_ +#ifndef _TAO_IDL_RTCORBAC_H_ +#define _TAO_IDL_RTCORBAC_H_ #include /**/ "ace/pre.h" @@ -59,6 +59,9 @@ #include "tao/Encodable.h" #include "tao/PolicyC.h" +#include "tao/IOPC.h" +#include "tao/TimeBaseC.h" + #if defined (TAO_EXPORT_MACRO) #undef TAO_EXPORT_MACRO #endif @@ -83,7 +86,7 @@ #endif /* __BORLANDC__ */ // TAO_IDL - Generated from -// be\be_visitor_root/root_ch.cpp:63 +// be/be_visitor_root/root_ch.cpp:63 namespace TAO { @@ -94,67 +97,67 @@ namespace TAO } // TAO_IDL - Generated from -// be\be_visitor_module/module_ch.cpp:48 +// be/be_visitor_module/module_ch.cpp:48 namespace RTCORBA { // TAO_IDL - Generated from - // be\be_visitor_typedef/typedef_ch.cpp:342 + // be/be_visitor_typedef/typedef_ch.cpp:342 typedef CORBA::Short NativePriority; typedef CORBA::Short_out NativePriority_out; // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_NativePriority; // TAO_IDL - Generated from - // be\be_visitor_typedef/typedef_ch.cpp:342 + // be/be_visitor_typedef/typedef_ch.cpp:342 typedef CORBA::Short Priority; typedef CORBA::Short_out Priority_out; // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Priority; // TAO_IDL - Generated from - // be\be_visitor_constant/constant_ch.cpp:52 + // be/be_visitor_constant/constant_ch.cpp:52 const RTCORBA::Priority minPriority = 0; // TAO_IDL - Generated from - // be\be_visitor_constant/constant_ch.cpp:52 + // be/be_visitor_constant/constant_ch.cpp:52 const RTCORBA::Priority maxPriority = 32767; // TAO_IDL - Generated from - // be\be_visitor_typedef/typedef_ch.cpp:342 + // be/be_visitor_typedef/typedef_ch.cpp:342 typedef CORBA::Long NetworkPriority; typedef CORBA::Long_out NetworkPriority_out; // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_NetworkPriority; // TAO_IDL - Generated from - // be\be_visitor_typedef/typedef_ch.cpp:342 + // be/be_visitor_typedef/typedef_ch.cpp:342 typedef CORBA::ULong ThreadpoolId; typedef CORBA::ULong_out ThreadpoolId_out; // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ThreadpoolId; // TAO_IDL - Generated from - // be\be_type.cpp:258 + // be/be_type.cpp:258 struct ThreadpoolLane; @@ -169,7 +172,7 @@ namespace RTCORBA ThreadpoolLane_out; // TAO_IDL - Generated from - // be\be_visitor_structure/structure_ch.cpp:52 + // be/be_visitor_structure/structure_ch.cpp:52 struct TAO_RTCORBA_Export ThreadpoolLane { @@ -182,12 +185,12 @@ namespace RTCORBA }; // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ThreadpoolLane; // TAO_IDL - Generated from - // be\be_visitor_sequence/sequence_ch.cpp:101 + // be/be_visitor_sequence/sequence_ch.cpp:101 #if !defined (_RTCORBA_THREADPOOLLANES_CH_) #define _RTCORBA_THREADPOOLLANES_CH_ @@ -235,17 +238,17 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ThreadpoolLanes; // TAO_IDL - Generated from - // be\be_visitor_constant/constant_ch.cpp:52 + // be/be_visitor_constant/constant_ch.cpp:52 const CORBA::PolicyType PRIORITY_MODEL_POLICY_TYPE = 40U; // TAO_IDL - Generated from - // be\be_visitor_enum/enum_ch.cpp:57 + // be/be_visitor_enum/enum_ch.cpp:57 enum PriorityModel { @@ -256,12 +259,12 @@ namespace RTCORBA typedef PriorityModel &PriorityModel_out; // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_PriorityModel; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_PRIORITYMODELPOLICY__VAR_OUT_CH_) #define _RTCORBA_PRIORITYMODELPOLICY__VAR_OUT_CH_ @@ -284,7 +287,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_PRIORITYMODELPOLICY_CH_) #define _RTCORBA_PRIORITYMODELPOLICY_CH_ @@ -317,7 +320,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::PriorityModel priority_model ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -327,7 +330,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual RTCORBA::Priority server_priority ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -337,7 +340,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::CORBA::Policy_ptr copy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -347,7 +350,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void destroy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -357,7 +360,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -383,17 +386,17 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_PriorityModelPolicy; // TAO_IDL - Generated from - // be\be_visitor_constant/constant_ch.cpp:52 + // be/be_visitor_constant/constant_ch.cpp:52 const CORBA::PolicyType THREADPOOL_POLICY_TYPE = 41U; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_THREADPOOLPOLICY__VAR_OUT_CH_) #define _RTCORBA_THREADPOOLPOLICY__VAR_OUT_CH_ @@ -416,7 +419,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_THREADPOOLPOLICY_CH_) #define _RTCORBA_THREADPOOLPOLICY_CH_ @@ -449,7 +452,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual RTCORBA::ThreadpoolId threadpool ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -459,7 +462,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::CORBA::Policy_ptr copy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -469,7 +472,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void destroy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -479,7 +482,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -505,12 +508,12 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ThreadpoolPolicy; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_PROTOCOLPROPERTIES__VAR_OUT_CH_) #define _RTCORBA_PROTOCOLPROPERTIES__VAR_OUT_CH_ @@ -533,7 +536,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_PROTOCOLPROPERTIES_CH_) #define _RTCORBA_PROTOCOLPROPERTIES_CH_ @@ -567,7 +570,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -596,12 +599,12 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ProtocolProperties; // TAO_IDL - Generated from - // be\be_type.cpp:258 + // be/be_type.cpp:258 struct Protocol; @@ -619,7 +622,7 @@ namespace RTCORBA Protocol_out; // TAO_IDL - Generated from - // be\be_visitor_structure/structure_ch.cpp:52 + // be/be_visitor_structure/structure_ch.cpp:52 struct TAO_RTCORBA_Export Protocol { @@ -632,12 +635,12 @@ namespace RTCORBA }; // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Protocol; // TAO_IDL - Generated from - // be\be_visitor_sequence/sequence_ch.cpp:101 + // be/be_visitor_sequence/sequence_ch.cpp:101 #if !defined (_RTCORBA_PROTOCOLLIST_CH_) #define _RTCORBA_PROTOCOLLIST_CH_ @@ -685,17 +688,17 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ProtocolList; // TAO_IDL - Generated from - // be\be_visitor_constant/constant_ch.cpp:52 + // be/be_visitor_constant/constant_ch.cpp:52 const CORBA::PolicyType SERVER_PROTOCOL_POLICY_TYPE = 42U; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_SERVERPROTOCOLPOLICY__VAR_OUT_CH_) #define _RTCORBA_SERVERPROTOCOLPOLICY__VAR_OUT_CH_ @@ -718,7 +721,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_SERVERPROTOCOLPOLICY_CH_) #define _RTCORBA_SERVERPROTOCOLPOLICY_CH_ @@ -751,7 +754,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::ProtocolList * protocols ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -761,7 +764,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::CORBA::Policy_ptr copy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -771,7 +774,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void destroy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -781,7 +784,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -807,17 +810,17 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ServerProtocolPolicy; // TAO_IDL - Generated from - // be\be_visitor_constant/constant_ch.cpp:52 + // be/be_visitor_constant/constant_ch.cpp:52 const CORBA::PolicyType CLIENT_PROTOCOL_POLICY_TYPE = 43U; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_CLIENTPROTOCOLPOLICY__VAR_OUT_CH_) #define _RTCORBA_CLIENTPROTOCOLPOLICY__VAR_OUT_CH_ @@ -840,7 +843,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_CLIENTPROTOCOLPOLICY_CH_) #define _RTCORBA_CLIENTPROTOCOLPOLICY_CH_ @@ -873,7 +876,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::ProtocolList * protocols ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -883,7 +886,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::CORBA::Policy_ptr copy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -893,7 +896,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void destroy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -903,7 +906,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -929,17 +932,17 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ClientProtocolPolicy; // TAO_IDL - Generated from - // be\be_visitor_constant/constant_ch.cpp:52 + // be/be_visitor_constant/constant_ch.cpp:52 const CORBA::PolicyType PRIVATE_CONNECTION_POLICY_TYPE = 44U; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_PRIVATECONNECTIONPOLICY__VAR_OUT_CH_) #define _RTCORBA_PRIVATECONNECTIONPOLICY__VAR_OUT_CH_ @@ -962,7 +965,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_PRIVATECONNECTIONPOLICY_CH_) #define _RTCORBA_PRIVATECONNECTIONPOLICY_CH_ @@ -995,7 +998,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::CORBA::Policy_ptr copy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1005,7 +1008,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void destroy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1015,7 +1018,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -1041,12 +1044,12 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_PrivateConnectionPolicy; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_TCPPROTOCOLPROPERTIES__VAR_OUT_CH_) #define _RTCORBA_TCPPROTOCOLPROPERTIES__VAR_OUT_CH_ @@ -1069,7 +1072,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_TCPPROTOCOLPROPERTIES_CH_) #define _RTCORBA_TCPPROTOCOLPROPERTIES_CH_ @@ -1102,7 +1105,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual CORBA::Long send_buffer_size ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1112,7 +1115,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void send_buffer_size ( ::CORBA::Long send_buffer_size @@ -1123,7 +1126,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual CORBA::Long recv_buffer_size ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1133,7 +1136,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void recv_buffer_size ( ::CORBA::Long recv_buffer_size @@ -1144,7 +1147,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual CORBA::Boolean keep_alive ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1154,7 +1157,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void keep_alive ( ::CORBA::Boolean keep_alive @@ -1165,7 +1168,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual CORBA::Boolean dont_route ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1175,7 +1178,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void dont_route ( ::CORBA::Boolean dont_route @@ -1186,7 +1189,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual CORBA::Boolean no_delay ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1196,7 +1199,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void no_delay ( ::CORBA::Boolean no_delay @@ -1207,7 +1210,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual CORBA::Boolean enable_network_priority ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1217,7 +1220,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void enable_network_priority ( ::CORBA::Boolean enable_network_priority @@ -1228,7 +1231,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -1254,12 +1257,12 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_TCPProtocolProperties; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_GIOPPROTOCOLPROPERTIES__VAR_OUT_CH_) #define _RTCORBA_GIOPPROTOCOLPROPERTIES__VAR_OUT_CH_ @@ -1282,7 +1285,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_GIOPPROTOCOLPROPERTIES_CH_) #define _RTCORBA_GIOPPROTOCOLPROPERTIES_CH_ @@ -1315,7 +1318,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -1341,12 +1344,12 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_GIOPProtocolProperties; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES__VAR_OUT_CH_) #define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES__VAR_OUT_CH_ @@ -1369,7 +1372,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES_CH_) #define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES_CH_ @@ -1402,7 +1405,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual CORBA::Long send_buffer_size ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1412,7 +1415,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void send_buffer_size ( ::CORBA::Long send_buffer_size @@ -1423,7 +1426,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual CORBA::Long recv_buffer_size ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1433,7 +1436,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void recv_buffer_size ( ::CORBA::Long recv_buffer_size @@ -1444,7 +1447,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -1470,12 +1473,12 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_UnixDomainProtocolProperties; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES__VAR_OUT_CH_) #define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES__VAR_OUT_CH_ @@ -1498,7 +1501,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES_CH_) #define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES_CH_ @@ -1531,7 +1534,112 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Long send_buffer_size ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void send_buffer_size ( + ::CORBA::Long send_buffer_size + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Long recv_buffer_size ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void recv_buffer_size ( + ::CORBA::Long recv_buffer_size + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Boolean keep_alive ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void keep_alive ( + ::CORBA::Boolean keep_alive + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Boolean dont_route ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void dont_route ( + ::CORBA::Boolean dont_route + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Boolean no_delay ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void no_delay ( + ::CORBA::Boolean no_delay + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 virtual CORBA::Long preallocate_buffer_size ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1541,7 +1649,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void preallocate_buffer_size ( ::CORBA::Long preallocate_buffer_size @@ -1552,7 +1660,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual char * mmap_filename ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1562,7 +1670,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void mmap_filename ( const char * mmap_filename @@ -1573,7 +1681,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual char * mmap_lockname ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1583,7 +1691,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void mmap_lockname ( const char * mmap_lockname @@ -1594,7 +1702,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -1620,12 +1728,333 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_SharedMemoryProtocolProperties; // TAO_IDL - Generated from - // be\be_type.cpp:258 + // be/be_interface.cpp:601 + +#if !defined (_RTCORBA_USERDATAGRAMPROTOCOLPROPERTIES__VAR_OUT_CH_) +#define _RTCORBA_USERDATAGRAMPROTOCOLPROPERTIES__VAR_OUT_CH_ + + class UserDatagramProtocolProperties; + typedef UserDatagramProtocolProperties *UserDatagramProtocolProperties_ptr; + + typedef + TAO_Objref_Var_T< + UserDatagramProtocolProperties + > + UserDatagramProtocolProperties_var; + + typedef + TAO_Objref_Out_T< + UserDatagramProtocolProperties + > + UserDatagramProtocolProperties_out; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:54 + +#if !defined (_RTCORBA_USERDATAGRAMPROTOCOLPROPERTIES_CH_) +#define _RTCORBA_USERDATAGRAMPROTOCOLPROPERTIES_CH_ + + class TAO_RTCORBA_Export UserDatagramProtocolProperties + : public virtual ::RTCORBA::ProtocolProperties + { + public: + typedef UserDatagramProtocolProperties_ptr _ptr_type; + typedef UserDatagramProtocolProperties_var _var_type; + + // The static operations. + static UserDatagramProtocolProperties_ptr _duplicate (UserDatagramProtocolProperties_ptr obj); + + static UserDatagramProtocolProperties_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static UserDatagramProtocolProperties_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static UserDatagramProtocolProperties_ptr _nil (void) + { + return (UserDatagramProtocolProperties_ptr)0; + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Boolean enable_network_priority ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void enable_network_priority ( + ::CORBA::Boolean enable_network_priority + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:208 + + virtual CORBA::Boolean _is_a ( + const char *type_id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + + protected: + // Abstract or local interface only. + UserDatagramProtocolProperties (void); + + virtual ~UserDatagramProtocolProperties (void); + + private: + // Private and unimplemented for concrete interfaces. + UserDatagramProtocolProperties (const UserDatagramProtocolProperties &); + + void operator= (const UserDatagramProtocolProperties &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_UserDatagramProtocolProperties; + + // TAO_IDL - Generated from + // be/be_interface.cpp:601 + +#if !defined (_RTCORBA_STREAMCONTROLPROTOCOLPROPERTIES__VAR_OUT_CH_) +#define _RTCORBA_STREAMCONTROLPROTOCOLPROPERTIES__VAR_OUT_CH_ + + class StreamControlProtocolProperties; + typedef StreamControlProtocolProperties *StreamControlProtocolProperties_ptr; + + typedef + TAO_Objref_Var_T< + StreamControlProtocolProperties + > + StreamControlProtocolProperties_var; + + typedef + TAO_Objref_Out_T< + StreamControlProtocolProperties + > + StreamControlProtocolProperties_out; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:54 + +#if !defined (_RTCORBA_STREAMCONTROLPROTOCOLPROPERTIES_CH_) +#define _RTCORBA_STREAMCONTROLPROTOCOLPROPERTIES_CH_ + + class TAO_RTCORBA_Export StreamControlProtocolProperties + : public virtual ::RTCORBA::ProtocolProperties + { + public: + typedef StreamControlProtocolProperties_ptr _ptr_type; + typedef StreamControlProtocolProperties_var _var_type; + + // The static operations. + static StreamControlProtocolProperties_ptr _duplicate (StreamControlProtocolProperties_ptr obj); + + static StreamControlProtocolProperties_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static StreamControlProtocolProperties_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static StreamControlProtocolProperties_ptr _nil (void) + { + return (StreamControlProtocolProperties_ptr)0; + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Long send_buffer_size ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void send_buffer_size ( + ::CORBA::Long send_buffer_size + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Long recv_buffer_size ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void recv_buffer_size ( + ::CORBA::Long recv_buffer_size + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Boolean keep_alive ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void keep_alive ( + ::CORBA::Boolean keep_alive + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Boolean dont_route ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void dont_route ( + ::CORBA::Boolean dont_route + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Boolean no_delay ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void no_delay ( + ::CORBA::Boolean no_delay + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Boolean enable_network_priority ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void enable_network_priority ( + ::CORBA::Boolean enable_network_priority + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:208 + + virtual CORBA::Boolean _is_a ( + const char *type_id + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + + protected: + // Abstract or local interface only. + StreamControlProtocolProperties (void); + + virtual ~StreamControlProtocolProperties (void); + + private: + // Private and unimplemented for concrete interfaces. + StreamControlProtocolProperties (const StreamControlProtocolProperties &); + + void operator= (const StreamControlProtocolProperties &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_StreamControlProtocolProperties; + + // TAO_IDL - Generated from + // be/be_type.cpp:258 struct PriorityBand; @@ -1640,7 +2069,7 @@ namespace RTCORBA PriorityBand_out; // TAO_IDL - Generated from - // be\be_visitor_structure/structure_ch.cpp:52 + // be/be_visitor_structure/structure_ch.cpp:52 struct TAO_RTCORBA_Export PriorityBand { @@ -1652,12 +2081,12 @@ namespace RTCORBA }; // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_PriorityBand; // TAO_IDL - Generated from - // be\be_visitor_sequence/sequence_ch.cpp:101 + // be/be_visitor_sequence/sequence_ch.cpp:101 #if !defined (_RTCORBA_PRIORITYBANDS_CH_) #define _RTCORBA_PRIORITYBANDS_CH_ @@ -1705,17 +2134,17 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_PriorityBands; // TAO_IDL - Generated from - // be\be_visitor_constant/constant_ch.cpp:52 + // be/be_visitor_constant/constant_ch.cpp:52 const CORBA::PolicyType PRIORITY_BANDED_CONNECTION_POLICY_TYPE = 45U; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY__VAR_OUT_CH_) #define _RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY__VAR_OUT_CH_ @@ -1738,7 +2167,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY_CH_) #define _RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY_CH_ @@ -1771,7 +2200,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::PriorityBands * priority_bands ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1781,7 +2210,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::CORBA::Policy_ptr copy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1791,7 +2220,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void destroy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1801,7 +2230,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -1827,12 +2256,12 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_PriorityBandedConnectionPolicy; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_CURRENT__VAR_OUT_CH_) #define _RTCORBA_CURRENT__VAR_OUT_CH_ @@ -1855,7 +2284,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_CURRENT_CH_) #define _RTCORBA_CURRENT_CH_ @@ -1888,7 +2317,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual RTCORBA::Priority the_priority ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -1898,7 +2327,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void the_priority ( ::RTCORBA::Priority the_priority @@ -1909,7 +2338,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -1935,12 +2364,12 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Current; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_MUTEX__VAR_OUT_CH_) #define _RTCORBA_MUTEX__VAR_OUT_CH_ @@ -1963,7 +2392,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_MUTEX_CH_) #define _RTCORBA_MUTEX_CH_ @@ -1996,7 +2425,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void lock ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -2006,7 +2435,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void unlock ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -2016,7 +2445,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual CORBA::Boolean try_lock ( ::TimeBase::TimeT max_wait @@ -2027,7 +2456,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -2053,12 +2482,12 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Mutex; // TAO_IDL - Generated from - // be\be_interface.cpp:601 + // be/be_interface.cpp:601 #if !defined (_RTCORBA_RTORB__VAR_OUT_CH_) #define _RTCORBA_RTORB__VAR_OUT_CH_ @@ -2081,7 +2510,7 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:54 + // be/be_visitor_interface/interface_ch.cpp:54 #if !defined (_RTCORBA_RTORB_CH_) #define _RTCORBA_RTORB_CH_ @@ -2114,7 +2543,7 @@ namespace RTCORBA static void _tao_any_destructor (void *); // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::Mutex_ptr create_mutex ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -2124,7 +2553,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void destroy_mutex ( ::RTCORBA::Mutex_ptr the_mutex @@ -2135,7 +2564,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_exception/exception_ch.cpp:51 + // be/be_visitor_exception/exception_ch.cpp:51 #if !defined (_RTCORBA_RTORB_MUTEXNOTFOUND_CH_) #define _RTCORBA_RTORB_MUTEXNOTFOUND_CH_ @@ -2170,20 +2599,20 @@ namespace RTCORBA ); // TAO_IDL - Generated from - // be\be_visitor_exception/exception_ch.cpp:125 + // be/be_visitor_exception/exception_ch.cpp:125 virtual CORBA::TypeCode_ptr _type (void) const; }; // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 static ::CORBA::TypeCode_ptr _tc_MutexNotFound; #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::Mutex_ptr create_named_mutex ( const char * name, @@ -2195,7 +2624,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::Mutex_ptr open_named_mutex ( const char * name @@ -2207,7 +2636,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::TCPProtocolProperties_ptr create_tcp_protocol_properties ( ::CORBA::Long send_buffer_size, @@ -2223,7 +2652,64 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_exception/exception_ch.cpp:51 + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual ::RTCORBA::UnixDomainProtocolProperties_ptr create_unix_domain_protocol_properties ( + ::CORBA::Long send_buffer_size, + ::CORBA::Long recv_buffer_size + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual ::RTCORBA::SharedMemoryProtocolProperties_ptr create_shared_memory_protocol_properties ( + ::CORBA::Long send_buffer_size, + ::CORBA::Long recv_buffer_size, + ::CORBA::Boolean keep_alive, + ::CORBA::Boolean dont_route, + ::CORBA::Boolean no_delay, + ::CORBA::Long preallocate_buffer_size, + const char * mmap_filename, + const char * mmap_lockname + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual ::RTCORBA::UserDatagramProtocolProperties_ptr create_user_datagram_protocol_properties ( + ::CORBA::Boolean enable_network_priority + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual ::RTCORBA::StreamControlProtocolProperties_ptr create_stream_control_protocol_properties ( + ::CORBA::Long send_buffer_size, + ::CORBA::Long recv_buffer_size, + ::CORBA::Boolean keep_alive, + ::CORBA::Boolean dont_route, + ::CORBA::Boolean no_delay, + ::CORBA::Boolean enable_network_priority + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_exception/exception_ch.cpp:51 #if !defined (_RTCORBA_RTORB_INVALIDTHREADPOOL_CH_) #define _RTCORBA_RTORB_INVALIDTHREADPOOL_CH_ @@ -2258,20 +2744,20 @@ namespace RTCORBA ); // TAO_IDL - Generated from - // be\be_visitor_exception/exception_ch.cpp:125 + // be/be_visitor_exception/exception_ch.cpp:125 virtual CORBA::TypeCode_ptr _type (void) const; }; // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 static ::CORBA::TypeCode_ptr _tc_InvalidThreadpool; #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual RTCORBA::ThreadpoolId create_threadpool ( ::CORBA::ULong stacksize, @@ -2288,7 +2774,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual RTCORBA::ThreadpoolId create_threadpool_with_lanes ( ::CORBA::ULong stacksize, @@ -2304,7 +2790,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual void destroy_threadpool ( ::RTCORBA::ThreadpoolId threadpool @@ -2316,7 +2802,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::PriorityModelPolicy_ptr create_priority_model_policy ( ::RTCORBA::PriorityModel priority_model, @@ -2328,7 +2814,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::ThreadpoolPolicy_ptr create_threadpool_policy ( ::RTCORBA::ThreadpoolId threadpool @@ -2339,7 +2825,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::PriorityBandedConnectionPolicy_ptr create_priority_banded_connection_policy ( const ::RTCORBA::PriorityBands & priority_bands @@ -2350,7 +2836,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::ServerProtocolPolicy_ptr create_server_protocol_policy ( const ::RTCORBA::ProtocolList & protocols @@ -2361,7 +2847,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::ClientProtocolPolicy_ptr create_client_protocol_policy ( const ::RTCORBA::ProtocolList & protocols @@ -2372,7 +2858,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_operation/operation_ch.cpp:46 + // be/be_visitor_operation/operation_ch.cpp:46 virtual ::RTCORBA::PrivateConnectionPolicy_ptr create_private_connection_policy ( ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS @@ -2382,7 +2868,7 @@ namespace RTCORBA )) = 0; // TAO_IDL - Generated from - // be\be_visitor_interface/interface_ch.cpp:208 + // be/be_visitor_interface/interface_ch.cpp:208 virtual CORBA::Boolean _is_a ( const char *type_id @@ -2408,17 +2894,17 @@ namespace RTCORBA #endif /* end #if !defined */ // TAO_IDL - Generated from - // be\be_visitor_typecode/typecode_decl.cpp:44 + // be/be_visitor_typecode/typecode_decl.cpp:44 TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_RTORB; // TAO_IDL - Generated from -// be\be_visitor_module/module_ch.cpp:66 +// be/be_visitor_module/module_ch.cpp:66 } // module RTCORBA // TAO_IDL - Generated from -// be\be_visitor_traits.cpp:59 +// be/be_visitor_traits.cpp:59 // Traits specializations. namespace TAO @@ -2634,6 +3120,48 @@ namespace TAO #endif /* end #if !defined */ +#if !defined (_RTCORBA_USERDATAGRAMPROTOCOLPROPERTIES__TRAITS_CH_) +#define _RTCORBA_USERDATAGRAMPROTOCOLPROPERTIES__TRAITS_CH_ + + ACE_TEMPLATE_SPECIALIZATION + struct TAO_RTCORBA_Export Objref_Traits< ::RTCORBA::UserDatagramProtocolProperties> + { + static ::RTCORBA::UserDatagramProtocolProperties_ptr duplicate ( + ::RTCORBA::UserDatagramProtocolProperties_ptr + ); + static void release ( + ::RTCORBA::UserDatagramProtocolProperties_ptr + ); + static ::RTCORBA::UserDatagramProtocolProperties_ptr nil (void); + static CORBA::Boolean marshal ( + ::RTCORBA::UserDatagramProtocolProperties_ptr p, + TAO_OutputCDR & cdr + ); + }; + +#endif /* end #if !defined */ + +#if !defined (_RTCORBA_STREAMCONTROLPROTOCOLPROPERTIES__TRAITS_CH_) +#define _RTCORBA_STREAMCONTROLPROTOCOLPROPERTIES__TRAITS_CH_ + + ACE_TEMPLATE_SPECIALIZATION + struct TAO_RTCORBA_Export Objref_Traits< ::RTCORBA::StreamControlProtocolProperties> + { + static ::RTCORBA::StreamControlProtocolProperties_ptr duplicate ( + ::RTCORBA::StreamControlProtocolProperties_ptr + ); + static void release ( + ::RTCORBA::StreamControlProtocolProperties_ptr + ); + static ::RTCORBA::StreamControlProtocolProperties_ptr nil (void); + static CORBA::Boolean marshal ( + ::RTCORBA::StreamControlProtocolProperties_ptr p, + TAO_OutputCDR & cdr + ); + }; + +#endif /* end #if !defined */ + #if !defined (_RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY__TRAITS_CH_) #define _RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY__TRAITS_CH_ @@ -2720,7 +3248,7 @@ namespace TAO } // TAO_IDL - Generated from -// be\be_visitor_structure/any_op_ch.cpp:52 +// be/be_visitor_structure/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, const RTCORBA::ThreadpoolLane &); // copying version TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::ThreadpoolLane*); // noncopying version @@ -2728,7 +3256,7 @@ TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::Thre TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, const RTCORBA::ThreadpoolLane *&); // TAO_IDL - Generated from -// be\be_visitor_sequence/any_op_ch.cpp:52 +// be/be_visitor_sequence/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, const RTCORBA::ThreadpoolLanes &); // copying version TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::ThreadpoolLanes*); // noncopying version @@ -2736,34 +3264,34 @@ TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::Thre TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, const RTCORBA::ThreadpoolLanes *&); // TAO_IDL - Generated from -// be\be_visitor_enum/any_op_ch.cpp:51 +// be/be_visitor_enum/any_op_ch.cpp:51 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::PriorityModel); TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::PriorityModel &); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::PriorityModelPolicy_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::PriorityModelPolicy_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::PriorityModelPolicy_ptr &); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::ThreadpoolPolicy_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::ThreadpoolPolicy_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::ThreadpoolPolicy_ptr &); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::ProtocolProperties_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::ProtocolProperties_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::ProtocolProperties_ptr &); // TAO_IDL - Generated from -// be\be_visitor_structure/any_op_ch.cpp:52 +// be/be_visitor_structure/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, const RTCORBA::Protocol &); // copying version TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::Protocol*); // noncopying version @@ -2771,7 +3299,7 @@ TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::Prot TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, const RTCORBA::Protocol *&); // TAO_IDL - Generated from -// be\be_visitor_sequence/any_op_ch.cpp:52 +// be/be_visitor_sequence/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, const RTCORBA::ProtocolList &); // copying version TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::ProtocolList*); // noncopying version @@ -2779,56 +3307,70 @@ TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::Prot TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, const RTCORBA::ProtocolList *&); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::ServerProtocolPolicy_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::ServerProtocolPolicy_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::ServerProtocolPolicy_ptr &); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::ClientProtocolPolicy_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::ClientProtocolPolicy_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::ClientProtocolPolicy_ptr &); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::PrivateConnectionPolicy_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::PrivateConnectionPolicy_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::PrivateConnectionPolicy_ptr &); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::TCPProtocolProperties_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::TCPProtocolProperties_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::TCPProtocolProperties_ptr &); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::GIOPProtocolProperties_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::GIOPProtocolProperties_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::GIOPProtocolProperties_ptr &); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::UnixDomainProtocolProperties_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::UnixDomainProtocolProperties_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::UnixDomainProtocolProperties_ptr &); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::SharedMemoryProtocolProperties_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::SharedMemoryProtocolProperties_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::SharedMemoryProtocolProperties_ptr &); // TAO_IDL - Generated from -// be\be_visitor_structure/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 + +TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::UserDatagramProtocolProperties_ptr); // copying +TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::UserDatagramProtocolProperties_ptr *); // non-copying +TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::UserDatagramProtocolProperties_ptr &); + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_ch.cpp:52 + +TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::StreamControlProtocolProperties_ptr); // copying +TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::StreamControlProtocolProperties_ptr *); // non-copying +TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::StreamControlProtocolProperties_ptr &); + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, const RTCORBA::PriorityBand &); // copying version TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::PriorityBand*); // noncopying version @@ -2836,7 +3378,7 @@ TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::Prio TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, const RTCORBA::PriorityBand *&); // TAO_IDL - Generated from -// be\be_visitor_sequence/any_op_ch.cpp:52 +// be/be_visitor_sequence/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, const RTCORBA::PriorityBands &); // copying version TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::PriorityBands*); // noncopying version @@ -2844,35 +3386,35 @@ TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::Prio TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, const RTCORBA::PriorityBands *&); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::PriorityBandedConnectionPolicy_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::PriorityBandedConnectionPolicy_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::PriorityBandedConnectionPolicy_ptr &); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::Current_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::Current_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::Current_ptr &); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::Mutex_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::Mutex_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::Mutex_ptr &); // TAO_IDL - Generated from -// be\be_visitor_interface/any_op_ch.cpp:52 +// be/be_visitor_interface/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::RTORB_ptr); // copying TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::RTORB_ptr *); // non-copying TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::RTORB_ptr &); // TAO_IDL - Generated from -// be\be_visitor_exception/any_op_ch.cpp:52 +// be/be_visitor_exception/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, const RTCORBA::RTORB::MutexNotFound &); // copying version TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::RTORB::MutexNotFound*); // noncopying version @@ -2880,7 +3422,7 @@ TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::RTOR TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, const RTCORBA::RTORB::MutexNotFound *&); // TAO_IDL - Generated from -// be\be_visitor_exception/any_op_ch.cpp:52 +// be/be_visitor_exception/any_op_ch.cpp:52 TAO_RTCORBA_Export void operator<<= (CORBA::Any &, const RTCORBA::RTORB::InvalidThreadpool &); // copying version TAO_RTCORBA_Export void operator<<= (CORBA::Any &, RTCORBA::RTORB::InvalidThreadpool*); // noncopying version @@ -2888,13 +3430,13 @@ TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::RTOR TAO_RTCORBA_Export CORBA::Boolean operator>>= (const CORBA::Any &, const RTCORBA::RTORB::InvalidThreadpool *&); // TAO_IDL - Generated from -// be\be_visitor_structure/cdr_op_ch.cpp:54 +// be/be_visitor_structure/cdr_op_ch.cpp:54 TAO_RTCORBA_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const RTCORBA::ThreadpoolLane &); TAO_RTCORBA_Export CORBA::Boolean operator>> (TAO_InputCDR &, RTCORBA::ThreadpoolLane &); // TAO_IDL - Generated from -// be\be_visitor_sequence/cdr_op_ch.cpp:71 +// be/be_visitor_sequence/cdr_op_ch.cpp:71 #if !defined _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_H_ #define _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_H_ @@ -2911,19 +3453,19 @@ TAO_RTCORBA_Export CORBA::Boolean operator>> ( #endif /* _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_H_ */ // TAO_IDL - Generated from -// be\be_visitor_enum/cdr_op_ch.cpp:50 +// be/be_visitor_enum/cdr_op_ch.cpp:50 TAO_RTCORBA_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const RTCORBA::PriorityModel &); TAO_RTCORBA_Export CORBA::Boolean operator>> (TAO_InputCDR &, RTCORBA::PriorityModel &); // TAO_IDL - Generated from -// be\be_visitor_structure/cdr_op_ch.cpp:54 +// be/be_visitor_structure/cdr_op_ch.cpp:54 TAO_RTCORBA_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const RTCORBA::PriorityBand &); TAO_RTCORBA_Export CORBA::Boolean operator>> (TAO_InputCDR &, RTCORBA::PriorityBand &); // TAO_IDL - Generated from -// be\be_visitor_sequence/cdr_op_ch.cpp:71 +// be/be_visitor_sequence/cdr_op_ch.cpp:71 #if !defined _TAO_CDR_OP_RTCORBA_PriorityBands_H_ #define _TAO_CDR_OP_RTCORBA_PriorityBands_H_ @@ -2940,7 +3482,7 @@ TAO_RTCORBA_Export CORBA::Boolean operator>> ( #endif /* _TAO_CDR_OP_RTCORBA_PriorityBands_H_ */ // TAO_IDL - Generated from -// be\be_codegen.cpp:964 +// be/be_codegen.cpp:964 #if defined (__ACE_INLINE__) #include "RTCORBAC.inl" diff --git a/TAO/tao/RTCORBA/RT_Current.cpp b/TAO/tao/RTCORBA/RT_Current.cpp index 80a4d36d132..489fd68e022 100644 --- a/TAO/tao/RTCORBA/RT_Current.cpp +++ b/TAO/tao/RTCORBA/RT_Current.cpp @@ -35,13 +35,14 @@ RTCORBA::Priority TAO_RT_Current::the_priority (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - RTCORBA::Priority priority; + TAO_Protocols_Hooks *tph = + this->orb_core_->get_protocols_hooks (); - TAO_Protocols_Hooks *tph = this->orb_core_->get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK_RETURN (-1); + RTCORBA::Priority priority; - int result = tph->get_thread_CORBA_priority (priority - ACE_ENV_ARG_PARAMETER); + int result = + tph->get_thread_CORBA_priority (priority + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (result == -1) @@ -56,11 +57,12 @@ TAO_RT_Current::the_priority (RTCORBA::Priority the_priority ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_Protocols_Hooks *tph = this->orb_core_->get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK; + TAO_Protocols_Hooks *tph = + this->orb_core_->get_protocols_hooks (); - int result = tph->set_thread_CORBA_priority (the_priority - ACE_ENV_ARG_PARAMETER); + int result = + tph->set_thread_CORBA_priority (the_priority + ACE_ENV_ARG_PARAMETER); ACE_CHECK; if (result == -1) diff --git a/TAO/tao/RTCORBA/RT_Endpoint_Utils.cpp b/TAO/tao/RTCORBA/RT_Endpoint_Utils.cpp index 2b9cfc163ce..ca60584e165 100644 --- a/TAO/tao/RTCORBA/RT_Endpoint_Utils.cpp +++ b/TAO/tao/RTCORBA/RT_Endpoint_Utils.cpp @@ -15,19 +15,18 @@ ACE_RCSID (RTCORBA, // **************************************************************** CORBA::Policy * -TAO_RT_Endpoint_Utils::priority_bands_policy (TAO::Profile_Transport_Resolver &r - ACE_ENV_ARG_DECL) +TAO_RT_Endpoint_Utils::policy (TAO_Cached_Policy_Type type, + TAO::Profile_Transport_Resolver &r + ACE_ENV_ARG_DECL) { - CORBA::Policy *bands_policy = CORBA::Policy::_nil (); + CORBA::Policy *policy = CORBA::Policy::_nil (); TAO_RT_Stub *rt_stub = dynamic_cast<TAO_RT_Stub *> (r.stub ()); ACE_TRY { - bands_policy = - rt_stub->effective_priority_banded_connection ( - ACE_ENV_SINGLE_ARG_PARAMETER - ); + policy = + rt_stub->get_cached_policy (type); ACE_TRY_CHECK; } ACE_CATCH (CORBA::INV_POLICY, ex) @@ -36,7 +35,7 @@ TAO_RT_Endpoint_Utils::priority_bands_policy (TAO::Profile_Transport_Resolver &r { CORBA::PolicyList *p = r.inconsistent_policies (); p->length (1); - (*p)[0u] = rt_stub->priority_banded_connection (); + (*p)[0u] = rt_stub->TAO_Stub::get_cached_policy (type); } ACE_RE_THROW; @@ -44,44 +43,7 @@ TAO_RT_Endpoint_Utils::priority_bands_policy (TAO::Profile_Transport_Resolver &r ACE_ENDTRY; ACE_CHECK_RETURN (CORBA::Policy::_nil ()); - return bands_policy; -} - -/*static*/ CORBA::Policy * -TAO_RT_Endpoint_Utils::client_protocol_policy ( - TAO::Profile_Transport_Resolver &r - ACE_ENV_ARG_DECL) -{ - CORBA::Policy *retval = 0; - - TAO_RT_Stub *rt_stub = dynamic_cast<TAO_RT_Stub *> (r.stub ()); - - if (rt_stub == 0) - { - return 0; - } - - ACE_TRY - { - retval = - rt_stub->effective_client_protocol (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - } - ACE_CATCH (CORBA::INV_POLICY, ex) - { - if (r.inconsistent_policies ()) - { - CORBA::PolicyList *p = r.inconsistent_policies (); - p->length (1); - (*p)[0u] = rt_stub->client_protocol (); - } - - ACE_RE_THROW; - } - ACE_ENDTRY; - ACE_CHECK_RETURN (CORBA::Policy::_nil ()); - - return retval; + return policy; } #endif /* TAO_HAS_CORBA_MESSAGING && TAO_HAS_CORBA_MESSAGING != 0 */ diff --git a/TAO/tao/RTCORBA/RT_Endpoint_Utils.h b/TAO/tao/RTCORBA/RT_Endpoint_Utils.h index 8f07301babb..d918ef4a12b 100644 --- a/TAO/tao/RTCORBA/RT_Endpoint_Utils.h +++ b/TAO/tao/RTCORBA/RT_Endpoint_Utils.h @@ -43,15 +43,10 @@ namespace TAO class TAO_RTCORBA_Export TAO_RT_Endpoint_Utils { public: - static CORBA::Policy *priority_bands_policy ( - TAO::Profile_Transport_Resolver &r - ACE_ENV_ARG_DECL - ); - - static CORBA::Policy *client_protocol_policy ( - TAO::Profile_Transport_Resolver &r - ACE_ENV_ARG_DECL - ); + static + CORBA::Policy *policy (TAO_Cached_Policy_Type type, + TAO::Profile_Transport_Resolver &r + ACE_ENV_ARG_DECL); private: /// ctor. diff --git a/TAO/tao/RTCORBA/RT_Invocation_Endpoint_Selectors.cpp b/TAO/tao/RTCORBA/RT_Invocation_Endpoint_Selectors.cpp index 944dbeddb83..0855ad52bae 100644 --- a/TAO/tao/RTCORBA/RT_Invocation_Endpoint_Selectors.cpp +++ b/TAO/tao/RTCORBA/RT_Invocation_Endpoint_Selectors.cpp @@ -37,8 +37,9 @@ TAO_RT_Invocation_Endpoint_Selector::select_endpoint ( ACE_THROW (CORBA::INTERNAL ()); CORBA::Policy_var client_protocol_policy_base = - TAO_RT_Endpoint_Utils::client_protocol_policy (*r - ACE_ENV_ARG_PARAMETER); + TAO_RT_Endpoint_Utils::policy (TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL, + *r + ACE_ENV_ARG_PARAMETER); ACE_CHECK; if (client_protocol_policy_base.ptr () == 0) @@ -173,27 +174,17 @@ TAO_RT_Invocation_Endpoint_Selector::endpoint_from_profile ( TAO_RT_Stub *rt_stub = dynamic_cast <TAO_RT_Stub *> (r.stub ()); - if (rt_stub == 0) - { - ACE_DEBUG ((LM_DEBUG, "Unexpected error narrowing stub to TAO_RT_Stub")); - - ACE_THROW_RETURN (CORBA::INTERNAL ( - CORBA::SystemException::_tao_minor_code ( - TAO_DEFAULT_MINOR_CODE, - EINVAL), - CORBA::COMPLETED_NO), - 0); - } - // Get the priority model policy. CORBA::Policy_var priority_model_policy = - rt_stub->exposed_priority_model (ACE_ENV_SINGLE_ARG_PARAMETER); + rt_stub->get_cached_policy (TAO_CACHED_POLICY_PRIORITY_MODEL + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); // Get the bands policy. CORBA::Policy_var bands_policy = - TAO_RT_Endpoint_Utils::priority_bands_policy (r - ACE_ENV_ARG_PARAMETER); + TAO_RT_Endpoint_Utils::policy (TAO_CACHED_POLICY_RT_PRIORITY_BANDED_CONNECTION, + r + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); int all_endpoints_are_valid = 0; @@ -232,8 +223,7 @@ TAO_RT_Invocation_Endpoint_Selector::endpoint_from_profile ( { // Get the protocol hooks. TAO_Protocols_Hooks *protocol_hooks = - r.stub ()->orb_core ()->get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK_RETURN (0); + r.stub ()->orb_core ()->get_protocols_hooks (); CORBA::Short server_priority = 0; CORBA::Boolean is_client_propagated = 0; @@ -350,7 +340,10 @@ TAO_RT_Invocation_Endpoint_Selector::endpoint_from_profile ( TAO_RT_Transport_Descriptor rt_transport_descriptor (ep); - if (rt_stub->private_connection ()) + CORBA::Policy_var private_connection_policy = + rt_stub->get_cached_policy (TAO_CACHED_POLICY_RT_PRIVATE_CONNECTION); + + if (!CORBA::is_nil (private_connection_policy.in ())) { private_connection_descriptor_property.init (ACE_static_cast (long, diff --git a/TAO/tao/RTCORBA/RT_ORB.cpp b/TAO/tao/RTCORBA/RT_ORB.cpp index 3a7668facc8..71f8bbffac0 100644 --- a/TAO/tao/RTCORBA/RT_ORB.cpp +++ b/TAO/tao/RTCORBA/RT_ORB.cpp @@ -244,9 +244,9 @@ TAO_RT_ORB::create_tcp_protocol_properties (CORBA::Long send_buffer_size, ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException )) { - TAO_TCP_Properties *tmp; + TAO_TCP_Protocol_Properties *tmp; ACE_NEW_THROW_EX (tmp, - TAO_TCP_Properties (send_buffer_size, + TAO_TCP_Protocol_Properties (send_buffer_size, recv_buffer_size, keep_alive, dont_route, @@ -259,6 +259,99 @@ TAO_RT_ORB::create_tcp_protocol_properties (CORBA::Long send_buffer_size, return tmp; } +RTCORBA::UnixDomainProtocolProperties_ptr +TAO_RT_ORB::create_unix_domain_protocol_properties ( + CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + TAO_UnixDomain_Protocol_Properties *tmp; + ACE_NEW_THROW_EX (tmp, + TAO_UnixDomain_Protocol_Properties ( + send_buffer_size, + recv_buffer_size), + CORBA::NO_MEMORY (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_NO)); + ACE_CHECK_RETURN (RTCORBA::UnixDomainProtocolProperties::_nil ()); + + return tmp; +} + +RTCORBA::SharedMemoryProtocolProperties_ptr +TAO_RT_ORB::create_shared_memory_protocol_properties ( + CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Long preallocate_buffer_size, + const char *mmap_filename, + const char *mmap_lockname + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + TAO_SharedMemory_Protocol_Properties *tmp; + ACE_NEW_THROW_EX (tmp, + TAO_SharedMemory_Protocol_Properties (send_buffer_size, + recv_buffer_size, + keep_alive, + dont_route, + no_delay, + preallocate_buffer_size, + mmap_filename, + mmap_lockname), + CORBA::NO_MEMORY (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_NO)); + ACE_CHECK_RETURN (RTCORBA::SharedMemoryProtocolProperties::_nil ()); + + return tmp; +} + +RTCORBA::UserDatagramProtocolProperties_ptr +TAO_RT_ORB::create_user_datagram_protocol_properties ( + CORBA::Boolean enable_network_priority + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + TAO_UserDatagram_Protocol_Properties *tmp; + ACE_NEW_THROW_EX (tmp, + TAO_UserDatagram_Protocol_Properties ( + enable_network_priority), + CORBA::NO_MEMORY (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_NO)); + ACE_CHECK_RETURN (RTCORBA::UserDatagramProtocolProperties::_nil ()); + + return tmp; +} + +RTCORBA::StreamControlProtocolProperties_ptr +TAO_RT_ORB::create_stream_control_protocol_properties ( + CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Boolean enable_network_priority + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + TAO_StreamControl_Protocol_Properties *tmp; + ACE_NEW_THROW_EX (tmp, + TAO_StreamControl_Protocol_Properties ( + send_buffer_size, + recv_buffer_size, + keep_alive, + dont_route, + no_delay, + enable_network_priority), + CORBA::NO_MEMORY (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_NO)); + ACE_CHECK_RETURN (RTCORBA::StreamControlProtocolProperties::_nil ()); + + return tmp; +} + RTCORBA::ThreadpoolId TAO_RT_ORB::create_threadpool (CORBA::ULong stacksize, CORBA::ULong static_threads, @@ -401,11 +494,17 @@ TAO_RT_ORB::create_client_protocol_policy (const RTCORBA::ProtocolList & protoco } TAO_Thread_Pool_Manager & -TAO_RT_ORB::tp_manager (void) +TAO_RT_ORB::tp_manager (void) const { return *this->tp_manager_; } +TAO_ORB_Core * +TAO_RT_ORB::orb_core (void) const +{ + return this->orb_core_; +} + /* static */ int TAO_RT_ORB::modify_thread_scheduling_policy (CORBA::ORB_ptr orb) diff --git a/TAO/tao/RTCORBA/RT_ORB.h b/TAO/tao/RTCORBA/RT_ORB.h index dc1c275f057..07fddcde91d 100644 --- a/TAO/tao/RTCORBA/RT_ORB.h +++ b/TAO/tao/RTCORBA/RT_ORB.h @@ -149,7 +149,7 @@ public: * Create and return a TCPProtocolProperties instance with the specified * parameters. */ - virtual RTCORBA::TCPProtocolProperties_ptr + RTCORBA::TCPProtocolProperties_ptr create_tcp_protocol_properties ( CORBA::Long send_buffer_size, CORBA::Long recv_buffer_size, @@ -160,6 +160,43 @@ public: ACE_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException )); + RTCORBA::UnixDomainProtocolProperties_ptr + create_unix_domain_protocol_properties ( + CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + RTCORBA::SharedMemoryProtocolProperties_ptr + create_shared_memory_protocol_properties ( + CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Long preallocate_buffer_size, + const char *mmap_filename, + const char *mmap_lockname + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + RTCORBA::UserDatagramProtocolProperties_ptr + create_user_datagram_protocol_properties ( + CORBA::Boolean enable_network_priority + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + RTCORBA::StreamControlProtocolProperties_ptr + create_stream_control_protocol_properties ( + CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Boolean enable_network_priority + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + /// Create a RTCORBA threadpool to manage a set of threads without lanes. virtual RTCORBA::ThreadpoolId create_threadpool (CORBA::ULong stacksize, @@ -243,8 +280,11 @@ public: ACE_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); + /// Reference to our creating ORB Core. + TAO_ORB_Core *orb_core (void) const; + /// Get the Thread Pool Manager. - TAO_Thread_Pool_Manager &tp_manager (void); + TAO_Thread_Pool_Manager &tp_manager (void) const; /** * This method changes the scheduling policy of the calling thread @@ -268,7 +308,7 @@ protected: /// reference counted object. virtual ~TAO_RT_ORB (void); - /// Reference to our creating ORB. + /// Reference to our creating ORB Core. TAO_ORB_Core *orb_core_; /// mutex_mgr_ manages the names associated with named mutexes. diff --git a/TAO/tao/RTCORBA/RT_ORBInitializer.cpp b/TAO/tao/RTCORBA/RT_ORBInitializer.cpp index bd85054a4d8..f1a1b3a8433 100644 --- a/TAO/tao/RTCORBA/RT_ORBInitializer.cpp +++ b/TAO/tao/RTCORBA/RT_ORBInitializer.cpp @@ -81,14 +81,6 @@ TAO_RT_ORBInitializer::pre_init ( TAO_ORB_Core::set_poa_factory (rt_poa_factory_name, rt_poa_factory_directive); - // Sets the client_protocol policy. - TAO_RT_Protocols_Hooks::set_client_protocols_hook - (TAO_ClientProtocolPolicy::hook); - - // Sets the server_protocol policy. - TAO_RT_Protocols_Hooks::set_server_protocols_hook - (TAO_ServerProtocolPolicy::hook); - // Create the initial priority mapping instance. TAO_Priority_Mapping *pm; switch (this->priority_mapping_type_) diff --git a/TAO/tao/RTCORBA/RT_Policy_i.cpp b/TAO/tao/RTCORBA/RT_Policy_i.cpp index c2bd94a1566..a87968a0436 100644 --- a/TAO/tao/RTCORBA/RT_Policy_i.cpp +++ b/TAO/tao/RTCORBA/RT_Policy_i.cpp @@ -533,180 +533,6 @@ TAO_ServerProtocolPolicy::destroy (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) { } -int -TAO_ServerProtocolPolicy::hook (TAO_ORB_Core *orb_core, - int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char *protocol_type) -{ - RTCORBA::ProtocolProperties_var properties = - RTCORBA::ProtocolProperties::_nil (); - - // ServerProtocolProperties policy controls protocols configuration. - // Look for protocol properties in the effective ServerProtocolPolicy. - CORBA::Policy_var policy = - orb_core->get_cached_policy (TAO_CACHED_POLICY_RT_SERVER_PROTOCOL); - - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - RTCORBA::ServerProtocolPolicy_var server_protocols_policy; - TAO_ServerProtocolPolicy *server_protocols = 0; - - if (!CORBA::is_nil (policy.in ())) - { - server_protocols_policy = - RTCORBA::ServerProtocolPolicy::_narrow (policy.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - server_protocols = - ACE_dynamic_cast (TAO_ServerProtocolPolicy *, - server_protocols_policy.in ()); - - if (server_protocols != 0) - { - RTCORBA::ProtocolList & protocols = - server_protocols->protocols_rep (); - - // Find protocol properties. - for (CORBA::ULong j = 0; j < protocols.length (); ++j) - { - if (protocols[j].protocol_type == IOP::TAG_INTERNET_IOP) - { - properties = - RTCORBA::ProtocolProperties::_narrow ( - protocols[j].transport_protocol_properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (ACE_OS::strcmp (protocol_type, - "iiop") == 0) - break; - } - else if (protocols[j].protocol_type == TAO_TAG_UIOP_PROFILE) - { - properties = - RTCORBA::ProtocolProperties::_narrow ( - protocols[j].transport_protocol_properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (ACE_OS::strcmp (protocol_type, "uiop") == 0) - break; - } - } - } - } - - if (CORBA::is_nil (properties.in ())) - { - // TCP/UIOP/SHMIOP Properties were not specified in the - // effective policy. - // We must use ORB defaults. - policy = orb_core->get_default_policies ()->get_cached_policy (TAO_CACHED_POLICY_RT_SERVER_PROTOCOL); - - if (!CORBA::is_nil (policy.in ())) - { - server_protocols_policy = - RTCORBA::ServerProtocolPolicy::_narrow (policy.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - server_protocols = - ACE_dynamic_cast (TAO_ServerProtocolPolicy *, - server_protocols_policy.in ()); - - if (!CORBA::is_nil (server_protocols)) - { - // Find protocol properties for IIOP. - RTCORBA::ProtocolList & protocols = - server_protocols->protocols_rep (); - - for (CORBA::ULong j = 0; j < protocols.length (); ++j) - { - if (protocols[j].protocol_type == IOP::TAG_INTERNET_IOP) - { - properties = - RTCORBA::ProtocolProperties::_narrow ( - protocols[j].transport_protocol_properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (ACE_OS::strcmp (protocol_type, "iiop") == 0) - break; - } - else if (protocols[j].protocol_type == - TAO_TAG_UIOP_PROFILE) - { - properties = - RTCORBA::ProtocolProperties::_narrow ( - protocols[j].transport_protocol_properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (ACE_OS::strcmp (protocol_type, "uiop") == 0) - break; - } - } - } - } - } - - if (ACE_OS::strcmp (protocol_type, "iiop") == 0) - { - RTCORBA::TCPProtocolProperties_var tcp_properties = - RTCORBA::TCPProtocolProperties::_narrow (properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - send_buffer_size = - tcp_properties->send_buffer_size (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - recv_buffer_size = - tcp_properties->recv_buffer_size (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - no_delay = tcp_properties->no_delay (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - enable_network_priority = - tcp_properties->enable_network_priority (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - } - - if (ACE_OS::strcmp (protocol_type, "uiop") == 0) - { - RTCORBA::UnixDomainProtocolProperties_var uiop_properties = - RTCORBA::UnixDomainProtocolProperties::_narrow (properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (!CORBA::is_nil (uiop_properties.in ())) - { - // Extract and locally store properties of interest. - send_buffer_size = - uiop_properties->send_buffer_size (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - recv_buffer_size = - uiop_properties->recv_buffer_size (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - } - } - } - ACE_CATCHANY - { - if (TAO_debug_level > 4) - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "TAO_ServerProtocolPolicy::hook"); - - return -1; - } - ACE_ENDTRY; - - return 0; -} - TAO_Cached_Policy_Type TAO_ServerProtocolPolicy::_tao_cached_type (void) const { @@ -818,177 +644,6 @@ TAO_ClientProtocolPolicy::destroy (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) { } -int -TAO_ClientProtocolPolicy::hook (TAO_ORB_Core *orb_core, - int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char *protocol_type) -{ - RTCORBA::ProtocolProperties_var properties = - RTCORBA::ProtocolProperties::_nil (); - - // Check ORB-level override for properties. - CORBA::Policy_var policy = - orb_core->policy_manager ()->get_cached_policy (TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL); - - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - RTCORBA::ClientProtocolPolicy_var client_protocols_policy; - TAO_ClientProtocolPolicy *client_protocols = 0; - - if (!CORBA::is_nil (policy.in ())) - { - client_protocols_policy = - RTCORBA::ClientProtocolPolicy::_narrow (policy.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - client_protocols = - ACE_dynamic_cast (TAO_ClientProtocolPolicy *, - client_protocols_policy.in ()); - - if (client_protocols != 0) - { - //TAO_ClientProtocolPolicy - RTCORBA::ProtocolList & protocols = - client_protocols->protocols_rep (); - - for (CORBA::ULong j = 0; j < protocols.length (); ++j) - { - if (protocols[j].protocol_type == IOP::TAG_INTERNET_IOP) - { - properties = - RTCORBA::ProtocolProperties::_narrow ( - protocols[j].transport_protocol_properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (ACE_OS::strcmp (protocol_type, "iiop") == 0) - break; - } - else if (protocols[j].protocol_type == TAO_TAG_UIOP_PROFILE) - { - properties = - RTCORBA::ProtocolProperties::_narrow ( - protocols[j].transport_protocol_properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (ACE_OS::strcmp (protocol_type, "uiop") == 0) - break; - } - } - } - } - - if (CORBA::is_nil (properties.in ())) - { - // No tcp/uiop properties in ORB-level override. Use ORB - // defaults. ORB defaults should never be null - they were - // initialized by the ORB_Core. - policy = - orb_core->get_default_policies ()->get_cached_policy (TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL); - - if (!CORBA::is_nil (policy.in ())) - { - client_protocols_policy = - RTCORBA::ClientProtocolPolicy::_narrow (policy.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - client_protocols = - ACE_dynamic_cast (TAO_ClientProtocolPolicy *, - client_protocols_policy.in ()); - - if (client_protocols != 0) - { - RTCORBA::ProtocolList & protocols = - client_protocols->protocols_rep (); - - for (CORBA::ULong j = 0; j < protocols.length (); ++j) - { - if (protocols[j].protocol_type == IOP::TAG_INTERNET_IOP) - { - properties = - RTCORBA::ProtocolProperties::_narrow ( - protocols[j].transport_protocol_properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (ACE_OS::strcmp (protocol_type, "iiop") == 0) - break; - } - else if (protocols[j].protocol_type == - TAO_TAG_UIOP_PROFILE) - { - properties = - RTCORBA::ProtocolProperties::_narrow ( - protocols[j].transport_protocol_properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (ACE_OS::strcmp (protocol_type, "uiop") == 0) - break; - } - } - } - } - } - - if (ACE_OS::strcmp (protocol_type, "iiop") == 0) - { - RTCORBA::TCPProtocolProperties_var tcp_properties = - RTCORBA::TCPProtocolProperties::_narrow (properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - send_buffer_size = - tcp_properties->send_buffer_size (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - recv_buffer_size = - tcp_properties->recv_buffer_size (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - no_delay = tcp_properties->no_delay (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - enable_network_priority = - tcp_properties->enable_network_priority (ACE_ENV_SINGLE_ARG_PARAMETER); - } - - if (ACE_OS::strcmp (protocol_type, "uiop") == 0) - { - RTCORBA::UnixDomainProtocolProperties_var uiop_properties = - RTCORBA::UnixDomainProtocolProperties::_narrow (properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (!CORBA::is_nil (uiop_properties.in ())) - { - // Extract and locally store properties of interest. - send_buffer_size = - uiop_properties->send_buffer_size (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - recv_buffer_size = - uiop_properties->recv_buffer_size (); - ACE_TRY_CHECK; - } - } - } - ACE_CATCHANY - { - if (TAO_debug_level > 4) - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "TAO_ClientProtocolPolicy::hook"); - - return -1; - } - ACE_ENDTRY; - - return 0; -} - TAO_Cached_Policy_Type TAO_ClientProtocolPolicy::_tao_cached_type (void) const { @@ -1041,7 +696,7 @@ TAO_ClientProtocolPolicy::_tao_decode (TAO_InputCDR &in_cdr) this->protocols_[i].transport_protocol_properties = TAO_Protocol_Properties_Factory::create_transport_protocol_property - (this->protocols_[i].protocol_type); + (this->protocols_[i].protocol_type, in_cdr.orb_core ()); if (is_read_ok && (this->protocols_[i].orb_protocol_properties.ptr () != 0)) @@ -1066,12 +721,12 @@ TAO_ClientProtocolPolicy::protocols_rep (void) // **************************************************************** -TAO_TCP_Properties::TAO_TCP_Properties (CORBA::Long send_buffer_size, - CORBA::Long recv_buffer_size, - CORBA::Boolean keep_alive, - CORBA::Boolean dont_route, - CORBA::Boolean no_delay, - CORBA::Boolean enable_network_priority) +TAO_TCP_Protocol_Properties::TAO_TCP_Protocol_Properties (CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Boolean enable_network_priority) : send_buffer_size_ (send_buffer_size), recv_buffer_size_ (recv_buffer_size), keep_alive_ (keep_alive), @@ -1081,101 +736,101 @@ TAO_TCP_Properties::TAO_TCP_Properties (CORBA::Long send_buffer_size, { } -TAO_TCP_Properties::~TAO_TCP_Properties (void) +TAO_TCP_Protocol_Properties::~TAO_TCP_Protocol_Properties (void) { } CORBA::Long -TAO_TCP_Properties::send_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) +TAO_TCP_Protocol_Properties::send_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->send_buffer_size_; } void -TAO_TCP_Properties::send_buffer_size (CORBA::Long send_buffer_size - ACE_ENV_ARG_DECL_NOT_USED) +TAO_TCP_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->send_buffer_size_ = send_buffer_size; } CORBA::Long -TAO_TCP_Properties::recv_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) +TAO_TCP_Protocol_Properties::recv_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->recv_buffer_size_; } void -TAO_TCP_Properties::recv_buffer_size (CORBA::Long recv_buffer_size - ACE_ENV_ARG_DECL_NOT_USED) +TAO_TCP_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->recv_buffer_size_ = recv_buffer_size; } CORBA::Boolean -TAO_TCP_Properties::keep_alive (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) +TAO_TCP_Protocol_Properties::keep_alive (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->keep_alive_; } void -TAO_TCP_Properties::keep_alive (CORBA::Boolean keep_alive - ACE_ENV_ARG_DECL_NOT_USED) +TAO_TCP_Protocol_Properties::keep_alive (CORBA::Boolean keep_alive + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->keep_alive_ = keep_alive; } CORBA::Boolean -TAO_TCP_Properties::dont_route (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) +TAO_TCP_Protocol_Properties::dont_route (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->dont_route_; } void -TAO_TCP_Properties::dont_route (CORBA::Boolean dont_route - ACE_ENV_ARG_DECL_NOT_USED) +TAO_TCP_Protocol_Properties::dont_route (CORBA::Boolean dont_route + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->dont_route_ = dont_route; } -CORBA::Boolean TAO_TCP_Properties::no_delay (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) +CORBA::Boolean TAO_TCP_Protocol_Properties::no_delay (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->no_delay_; } void -TAO_TCP_Properties::no_delay (CORBA::Boolean no_delay - ACE_ENV_ARG_DECL_NOT_USED) +TAO_TCP_Protocol_Properties::no_delay (CORBA::Boolean no_delay + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->no_delay_ = no_delay; } CORBA::Boolean -TAO_TCP_Properties::enable_network_priority (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) +TAO_TCP_Protocol_Properties::enable_network_priority (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->enable_network_priority_; } void -TAO_TCP_Properties::enable_network_priority (CORBA::Boolean enable - ACE_ENV_ARG_DECL_NOT_USED) +TAO_TCP_Protocol_Properties::enable_network_priority (CORBA::Boolean enable + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->enable_network_priority_ = enable; } CORBA::Boolean -TAO_TCP_Properties::_tao_encode (TAO_OutputCDR & out_cdr) +TAO_TCP_Protocol_Properties::_tao_encode (TAO_OutputCDR & out_cdr) { return ((out_cdr << this->send_buffer_size_) && @@ -1189,7 +844,7 @@ TAO_TCP_Properties::_tao_encode (TAO_OutputCDR & out_cdr) } CORBA::Boolean -TAO_TCP_Properties::_tao_decode (TAO_InputCDR &in_cdr) +TAO_TCP_Protocol_Properties::_tao_decode (TAO_InputCDR &in_cdr) { return ((in_cdr >> this->send_buffer_size_) && @@ -1204,7 +859,7 @@ TAO_TCP_Properties::_tao_decode (TAO_InputCDR &in_cdr) // **************************************************************** -TAO_Unix_Domain_Properties::TAO_Unix_Domain_Properties +TAO_UnixDomain_Protocol_Properties::TAO_UnixDomain_Protocol_Properties (CORBA::Long send_buffer_size, CORBA::Long recv_buffer_size) : send_buffer_size_ (send_buffer_size), @@ -1212,50 +867,49 @@ TAO_Unix_Domain_Properties::TAO_Unix_Domain_Properties { } -TAO_Unix_Domain_Properties::~TAO_Unix_Domain_Properties (void) +TAO_UnixDomain_Protocol_Properties::~TAO_UnixDomain_Protocol_Properties (void) { } CORBA::Long -TAO_Unix_Domain_Properties::send_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) +TAO_UnixDomain_Protocol_Properties::send_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->send_buffer_size_; } void -TAO_Unix_Domain_Properties::send_buffer_size (CORBA::Long send_buffer_size - ACE_ENV_ARG_DECL_NOT_USED) +TAO_UnixDomain_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->send_buffer_size_ = send_buffer_size; } CORBA::Long -TAO_Unix_Domain_Properties::recv_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) +TAO_UnixDomain_Protocol_Properties::recv_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->recv_buffer_size_; } void -TAO_Unix_Domain_Properties::recv_buffer_size (CORBA::Long recv_buffer_size - ACE_ENV_ARG_DECL_NOT_USED) +TAO_UnixDomain_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->recv_buffer_size_ = recv_buffer_size; } - CORBA::Boolean -TAO_Unix_Domain_Properties::_tao_encode (TAO_OutputCDR &out_cdr) +TAO_UnixDomain_Protocol_Properties::_tao_encode (TAO_OutputCDR &out_cdr) { return ((out_cdr << this->send_buffer_size_) && (out_cdr << this->recv_buffer_size_)); } CORBA::Boolean -TAO_Unix_Domain_Properties::_tao_decode (TAO_InputCDR &in_cdr) +TAO_UnixDomain_Protocol_Properties::_tao_decode (TAO_InputCDR &in_cdr) { return ((in_cdr >> this->send_buffer_size_) && (in_cdr >> this->recv_buffer_size_)); @@ -1263,67 +917,164 @@ TAO_Unix_Domain_Properties::_tao_decode (TAO_InputCDR &in_cdr) // **************************************************************** -TAO_SMEM_Properties::TAO_SMEM_Properties (void) - : preallocate_buffer_size_ (0), - mmap_filename_ (), - mmap_lockname_ () +TAO_SharedMemory_Protocol_Properties::TAO_SharedMemory_Protocol_Properties (CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Long preallocate_buffer_size, + const char *mmap_filename, + const char *mmap_lockname) + : send_buffer_size_ (send_buffer_size), + recv_buffer_size_ (recv_buffer_size), + keep_alive_ (keep_alive), + dont_route_ (dont_route), + no_delay_ (no_delay), + preallocate_buffer_size_ (preallocate_buffer_size), + mmap_filename_ (mmap_filename), + mmap_lockname_ (mmap_lockname) +{ +} + +TAO_SharedMemory_Protocol_Properties::~TAO_SharedMemory_Protocol_Properties (void) +{ +} + + +CORBA::Long +TAO_SharedMemory_Protocol_Properties::send_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->send_buffer_size_; +} + +void +TAO_SharedMemory_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->send_buffer_size_ = send_buffer_size; +} + +CORBA::Long +TAO_SharedMemory_Protocol_Properties::recv_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->recv_buffer_size_; +} + +void +TAO_SharedMemory_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->recv_buffer_size_ = recv_buffer_size; +} + +CORBA::Boolean +TAO_SharedMemory_Protocol_Properties::keep_alive (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->keep_alive_; +} + +void +TAO_SharedMemory_Protocol_Properties::keep_alive (CORBA::Boolean keep_alive + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->keep_alive_ = keep_alive; +} + +CORBA::Boolean +TAO_SharedMemory_Protocol_Properties::dont_route (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) { + return this->dont_route_; } -TAO_SMEM_Properties::~TAO_SMEM_Properties (void) +void +TAO_SharedMemory_Protocol_Properties::dont_route (CORBA::Boolean dont_route + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) { + this->dont_route_ = dont_route; } +CORBA::Boolean +TAO_SharedMemory_Protocol_Properties::no_delay (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->no_delay_; +} + +void +TAO_SharedMemory_Protocol_Properties::no_delay (CORBA::Boolean no_delay + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->no_delay_ = no_delay; +} CORBA::Long -TAO_SMEM_Properties::preallocate_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) +TAO_SharedMemory_Protocol_Properties::preallocate_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->preallocate_buffer_size_; } void -TAO_SMEM_Properties::preallocate_buffer_size (CORBA::Long preallocate_buffer_size - ACE_ENV_ARG_DECL_NOT_USED) +TAO_SharedMemory_Protocol_Properties::preallocate_buffer_size (CORBA::Long preallocate_buffer_size + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->preallocate_buffer_size_ = preallocate_buffer_size; } char * -TAO_SMEM_Properties::mmap_filename (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) +TAO_SharedMemory_Protocol_Properties::mmap_filename (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->mmap_filename_.rep (); } void -TAO_SMEM_Properties::mmap_filename (const char * mmap_filename - ACE_ENV_ARG_DECL_NOT_USED) +TAO_SharedMemory_Protocol_Properties::mmap_filename (const char * mmap_filename + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->mmap_filename_.set (mmap_filename); } char * -TAO_SMEM_Properties::mmap_lockname (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) +TAO_SharedMemory_Protocol_Properties::mmap_lockname (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->mmap_lockname_.rep (); } void -TAO_SMEM_Properties::mmap_lockname (const char * mmap_lockname - ACE_ENV_ARG_DECL_NOT_USED) +TAO_SharedMemory_Protocol_Properties::mmap_lockname (const char * mmap_lockname + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->mmap_lockname_.set (mmap_lockname); } CORBA::Boolean -TAO_SMEM_Properties::_tao_encode (TAO_OutputCDR &out_cdr) +TAO_SharedMemory_Protocol_Properties::_tao_encode (TAO_OutputCDR &out_cdr) { - return ((out_cdr << this->preallocate_buffer_size_) + return ((out_cdr << this->send_buffer_size_) + && + (out_cdr << this->recv_buffer_size_) + && + (out_cdr.write_boolean (this->keep_alive_)) + && + (out_cdr.write_boolean (this->dont_route_)) + && + (out_cdr.write_boolean (this->no_delay_)) + && + (out_cdr << this->preallocate_buffer_size_) && (out_cdr << this->mmap_filename_) && @@ -1331,9 +1082,19 @@ TAO_SMEM_Properties::_tao_encode (TAO_OutputCDR &out_cdr) } CORBA::Boolean -TAO_SMEM_Properties::_tao_decode (TAO_InputCDR &in_cdr) +TAO_SharedMemory_Protocol_Properties::_tao_decode (TAO_InputCDR &in_cdr) { - return ((in_cdr >> this->preallocate_buffer_size_) + return ((in_cdr >> this->send_buffer_size_) + && + (in_cdr >> this->recv_buffer_size_) + && + (in_cdr.read_boolean (this->keep_alive_)) + && + (in_cdr.read_boolean (this->dont_route_)) + && + (in_cdr.read_boolean (this->no_delay_)) + && + (in_cdr >> this->preallocate_buffer_size_) && (in_cdr >> this->mmap_filename_) && @@ -1342,49 +1103,291 @@ TAO_SMEM_Properties::_tao_decode (TAO_InputCDR &in_cdr) // **************************************************************** -TAO_GIOP_Properties::TAO_GIOP_Properties (void) +TAO_UserDatagram_Protocol_Properties::TAO_UserDatagram_Protocol_Properties (CORBA::Boolean enable_network_priority) + : enable_network_priority_ (enable_network_priority) +{ +} + +TAO_UserDatagram_Protocol_Properties::~TAO_UserDatagram_Protocol_Properties (void) +{ +} + +CORBA::Boolean +TAO_UserDatagram_Protocol_Properties::enable_network_priority (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->enable_network_priority_; +} + +void +TAO_UserDatagram_Protocol_Properties::enable_network_priority (CORBA::Boolean enable + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->enable_network_priority_ = enable; +} + +CORBA::Boolean +TAO_UserDatagram_Protocol_Properties::_tao_encode (TAO_OutputCDR &) +{ + return true; +} + +CORBA::Boolean +TAO_UserDatagram_Protocol_Properties::_tao_decode (TAO_InputCDR &) +{ + return true; +} + +// **************************************************************** + +TAO_StreamControl_Protocol_Properties::TAO_StreamControl_Protocol_Properties (CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Boolean enable_network_priority) + : send_buffer_size_ (send_buffer_size), + recv_buffer_size_ (recv_buffer_size), + keep_alive_ (keep_alive), + dont_route_ (dont_route), + no_delay_ (no_delay), + enable_network_priority_ (enable_network_priority) +{ +} + +TAO_StreamControl_Protocol_Properties::~TAO_StreamControl_Protocol_Properties (void) +{ +} + +CORBA::Long +TAO_StreamControl_Protocol_Properties::send_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->send_buffer_size_; +} + +void +TAO_StreamControl_Protocol_Properties::send_buffer_size (CORBA::Long send_buffer_size + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->send_buffer_size_ = send_buffer_size; +} + +CORBA::Long +TAO_StreamControl_Protocol_Properties::recv_buffer_size (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->recv_buffer_size_; +} + +void +TAO_StreamControl_Protocol_Properties::recv_buffer_size (CORBA::Long recv_buffer_size + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->recv_buffer_size_ = recv_buffer_size; +} + +CORBA::Boolean +TAO_StreamControl_Protocol_Properties::keep_alive (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->keep_alive_; +} + +void +TAO_StreamControl_Protocol_Properties::keep_alive (CORBA::Boolean keep_alive + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->keep_alive_ = keep_alive; +} + +CORBA::Boolean +TAO_StreamControl_Protocol_Properties::dont_route (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->dont_route_; +} + +void +TAO_StreamControl_Protocol_Properties::dont_route (CORBA::Boolean dont_route + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->dont_route_ = dont_route; +} + +CORBA::Boolean TAO_StreamControl_Protocol_Properties::no_delay (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->no_delay_; +} + +void +TAO_StreamControl_Protocol_Properties::no_delay (CORBA::Boolean no_delay + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->no_delay_ = no_delay; +} + +CORBA::Boolean +TAO_StreamControl_Protocol_Properties::enable_network_priority (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->enable_network_priority_; +} + +void +TAO_StreamControl_Protocol_Properties::enable_network_priority (CORBA::Boolean enable + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->enable_network_priority_ = enable; +} + +CORBA::Boolean +TAO_StreamControl_Protocol_Properties::_tao_encode (TAO_OutputCDR & out_cdr) +{ + return ((out_cdr << this->send_buffer_size_) + && + (out_cdr << this->recv_buffer_size_) + && + (out_cdr.write_boolean (this->keep_alive_)) + && + (out_cdr.write_boolean (this->dont_route_)) + && + (out_cdr.write_boolean (this->no_delay_))); +} + +CORBA::Boolean +TAO_StreamControl_Protocol_Properties::_tao_decode (TAO_InputCDR &in_cdr) +{ + return ((in_cdr >> this->send_buffer_size_) + && + (in_cdr >> this->recv_buffer_size_) + && + (in_cdr.read_boolean (this->keep_alive_)) + && + (in_cdr.read_boolean (this->dont_route_)) + && + (in_cdr.read_boolean (this->no_delay_))); +} + +// **************************************************************** + +TAO_GIOP_Protocol_Properties::TAO_GIOP_Protocol_Properties (void) { } -TAO_GIOP_Properties::~TAO_GIOP_Properties (void) +TAO_GIOP_Protocol_Properties::~TAO_GIOP_Protocol_Properties (void) { } CORBA::Boolean -TAO_GIOP_Properties::_tao_encode (TAO_OutputCDR &) +TAO_GIOP_Protocol_Properties::_tao_encode (TAO_OutputCDR &) { return 1; } CORBA::Boolean -TAO_GIOP_Properties::_tao_decode (TAO_InputCDR &) +TAO_GIOP_Protocol_Properties::_tao_decode (TAO_InputCDR &) { return 1; } // **************************************************************** -RTCORBA::ProtocolProperties* -TAO_Protocol_Properties_Factory::create_transport_protocol_property ( - IOP::ProfileId id) +RTCORBA::ProtocolProperties * +TAO_Protocol_Properties_Factory::create_transport_protocol_property (IOP::ProfileId id, + TAO_ORB_Core *orb_core) { RTCORBA::ProtocolProperties* property = 0; if (id == IOP::TAG_INTERNET_IOP) + { + int send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0; + int recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0; + int no_delay = orb_core ? orb_core->orb_params ()->nodelay () : 0; + CORBA::Boolean keep_alive = 1; + CORBA::Boolean dont_route = 0; + CORBA::Boolean enable_network_priority = 0; + + ACE_NEW_RETURN (property, + TAO_TCP_Protocol_Properties (send_buffer_size, + recv_buffer_size, + keep_alive, + dont_route, + no_delay, + enable_network_priority), + 0); + } + + else if (id == TAO_TAG_SHMEM_PROFILE) + { + int send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0; + int recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0; + int no_delay = orb_core ? orb_core->orb_params ()->nodelay () : 0; + CORBA::Boolean keep_alive = 1; + CORBA::Boolean dont_route = 0; + CORBA::Long preallocate_buffer_size = 0; + const char *mmap_filename = ""; + const char *mmap_lockname = ""; + + ACE_NEW_RETURN (property, + TAO_SharedMemory_Protocol_Properties (send_buffer_size, + recv_buffer_size, + keep_alive, + dont_route, + no_delay, + preallocate_buffer_size, + mmap_filename, + mmap_lockname), + 0); + } - ACE_NEW_RETURN (property, - TAO_TCP_Properties, - 0); + else if (id == TAO_TAG_UIOP_PROFILE) + { + int send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0; + int recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0; - else if(id == TAO_TAG_SHMEM_PROFILE) - ACE_NEW_RETURN (property, - TAO_SMEM_Properties, - 0); + ACE_NEW_RETURN (property, + TAO_UnixDomain_Protocol_Properties (send_buffer_size, + recv_buffer_size), + 0); + } + + else if (id == TAO_TAG_UDP_PROFILE) + { + CORBA::Boolean enable_network_priority = 0; + + ACE_NEW_RETURN (property, + TAO_UserDatagram_Protocol_Properties (enable_network_priority), + 0); + } + + else if (id == TAO_TAG_SCIOP_PROFILE) + { + int send_buffer_size = orb_core ? orb_core->orb_params ()->sock_sndbuf_size () : 0; + int recv_buffer_size = orb_core ? orb_core->orb_params ()->sock_rcvbuf_size () : 0; + int no_delay = orb_core ? orb_core->orb_params ()->nodelay () : 0; + CORBA::Boolean keep_alive = 1; + CORBA::Boolean dont_route = 0; + CORBA::Boolean enable_network_priority = 0; + + ACE_NEW_RETURN (property, + TAO_StreamControl_Protocol_Properties (send_buffer_size, + recv_buffer_size, + keep_alive, + dont_route, + no_delay, + enable_network_priority), + 0); + } - else if (id == TAO_TAG_UIOP_PROFILE) - ACE_NEW_RETURN (property, - TAO_Unix_Domain_Properties, - 0); return property; } @@ -1395,7 +1398,7 @@ TAO_Protocol_Properties_Factory::create_orb_protocol_property (IOP::ProfileId id if (id == IOP::TAG_INTERNET_IOP) ACE_NEW_RETURN (property, - TAO_GIOP_Properties, + TAO_GIOP_Protocol_Properties, 0); // Right now the only supported ORB protocol is GIOP @@ -1406,9 +1409,9 @@ TAO_Protocol_Properties_Factory::create_orb_protocol_property (IOP::ProfileId id // should be considered. else ACE_NEW_RETURN (property, - TAO_GIOP_Properties, + TAO_GIOP_Protocol_Properties, 0); - return property; + return property; } #endif /* TAO_HAS_CORBA_MESSAGING && TAO_HAS_CORBA_MESSAGING != 0 */ diff --git a/TAO/tao/RTCORBA/RT_Policy_i.h b/TAO/tao/RTCORBA/RT_Policy_i.h index a68f25e42da..fcc8a78dd7f 100644 --- a/TAO/tao/RTCORBA/RT_Policy_i.h +++ b/TAO/tao/RTCORBA/RT_Policy_i.h @@ -341,13 +341,6 @@ public: void destroy (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - static int hook (TAO_ORB_Core *orb_core, - int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char *protocol_type); - // Return the cached policy type for this policy. TAO_Cached_Policy_Type _tao_cached_type (void) const; @@ -409,13 +402,6 @@ public: CORBA::Policy_ptr copy (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - static int hook (TAO_ORB_Core *orb_core, - int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char* protocol_type); - void destroy (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); @@ -458,26 +444,24 @@ private: //************************************************************************* /** - * @class TAO_TCP_Properties + * @class TAO_TCP_Protocol_Properties * * @brief RTCORBA::TCPProtocolProperties implementation * * Stores TCP Protocol configuration properties. */ -class TAO_RTCORBA_Export TAO_TCP_Properties +class TAO_RTCORBA_Export TAO_TCP_Protocol_Properties : public RTCORBA::TCPProtocolProperties, public TAO_Local_RefCounted_Object { public: /// Constructor. - TAO_TCP_Properties (CORBA::Long send_buffer_size = - ACE_DEFAULT_MAX_SOCKET_BUFSIZ, - CORBA::Long recv_buffer_size = - ACE_DEFAULT_MAX_SOCKET_BUFSIZ, - CORBA::Boolean keep_alive = 1, - CORBA::Boolean dont_route = 0, - CORBA::Boolean no_delay = 1, - CORBA::Boolean enable_network_priority = 0); + TAO_TCP_Protocol_Properties (CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Boolean enable_network_priority); CORBA::Long send_buffer_size (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); @@ -514,13 +498,6 @@ public: ACE_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - - /// This method writes a CDR representation of TCPProtocolProperties. - CORBA::Boolean _tao_encode (TAO_OutputCDR &out_cdr); - - /// This method reads the object state from a CDR representation. - CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr); - CORBA::Boolean enable_network_priority (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); @@ -528,11 +505,17 @@ public: ACE_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); + /// This method writes a CDR representation of TCPProtocolProperties. + CORBA::Boolean _tao_encode (TAO_OutputCDR &out_cdr); + + /// This method reads the object state from a CDR representation. + CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr); + protected: /// Protected destructor to enforce proper memory management of this /// reference counted object. - virtual ~TAO_TCP_Properties (void); + virtual ~TAO_TCP_Protocol_Properties (void); private: // = Attributes. @@ -548,22 +531,22 @@ private: //************************************************************************* /** - * @class TAO_Unix_Domain_Properties + * @class TAO_UnixDomain_Protocol_Properties * * @brief RTCORBA::UnixDomainProtocolProperties implementation. * * Stores Unix Domain Sockets (Local IPC) Protocol configuration * properties. */ -class TAO_RTCORBA_Export TAO_Unix_Domain_Properties +class TAO_RTCORBA_Export TAO_UnixDomain_Protocol_Properties : public RTCORBA::UnixDomainProtocolProperties, public TAO_Local_RefCounted_Object { public: /// Constructor - TAO_Unix_Domain_Properties (CORBA::Long send_buffer_size = ACE_DEFAULT_MAX_SOCKET_BUFSIZ, - CORBA::Long recv_buffer_size = ACE_DEFAULT_MAX_SOCKET_BUFSIZ); + TAO_UnixDomain_Protocol_Properties (CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size); CORBA::Long send_buffer_size (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); @@ -602,7 +585,7 @@ protected: /// Protected destructor to enforce proper memory management of this /// reference counted object. - virtual ~TAO_Unix_Domain_Properties (void); + virtual ~TAO_UnixDomain_Protocol_Properties (void); private: @@ -614,23 +597,68 @@ private: //************************************************************************* /** - * @class TAO_SMEM_Properties + * @class TAO_SharedMemory_Protocol_Properties * * @brief RTCORBA::SharedMemoryProtocolProperties implementation. * * Stores Shared Memory Protocol configuration * properties. */ -class TAO_RTCORBA_Export TAO_SMEM_Properties +class TAO_RTCORBA_Export TAO_SharedMemory_Protocol_Properties : public RTCORBA::SharedMemoryProtocolProperties, public TAO_Local_RefCounted_Object { public: /// Constructor. - TAO_SMEM_Properties (void); + TAO_SharedMemory_Protocol_Properties (CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Long preallocate_buffer_size, + const char *mmap_filename, + const char *mmap_lockname); // = IDL interface methods. + CORBA::Long send_buffer_size (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void send_buffer_size (CORBA::Long send_buffer_size + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + CORBA::Long recv_buffer_size (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void recv_buffer_size (CORBA::Long recv_buffer_size + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + CORBA::Boolean keep_alive (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void keep_alive (CORBA::Boolean keep_alive + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + CORBA::Boolean dont_route (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void dont_route (CORBA::Boolean dont_route + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + CORBA::Boolean no_delay (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void no_delay (CORBA::Boolean no_delay + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + CORBA::Boolean enable_network_priority (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + CORBA::Long preallocate_buffer_size (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); @@ -654,7 +682,7 @@ public: /** * This method writes the CDR encapsulation of an instance of - * SMEMProperties. This Protocol Property in TAO specific, + * SharedMemoryProperties. This Protocol Property in TAO specific, * so there is no order of encapsulation specified in the * RT CORBA Spec. The current implementation encodes the field * according to the order of declaration. @@ -662,7 +690,7 @@ public: CORBA::Boolean _tao_encode (TAO_OutputCDR &out_cdr); /** - * This method reads an instance of SMEMProperties from + * This method reads an instance of SharedMemoryProperties from * a CDR encapsulation. This Protocol Property in TAO specific, * so there is no order of encapsulation specified in the * RT CORBA Spec. The current implementation expect the field @@ -674,11 +702,16 @@ protected: /// Protected destructor to enforce proper memory management of this /// reference counted object. - virtual ~TAO_SMEM_Properties (void); + virtual ~TAO_SharedMemory_Protocol_Properties (void); private: // = Attributes. + CORBA::Long send_buffer_size_; + CORBA::Long recv_buffer_size_; + CORBA::Boolean keep_alive_; + CORBA::Boolean dont_route_; + CORBA::Boolean no_delay_; CORBA::Long preallocate_buffer_size_; ACE_CString mmap_filename_; ACE_CString mmap_lockname_; @@ -686,7 +719,136 @@ private: //************************************************************************* -class TAO_RTCORBA_Export TAO_GIOP_Properties +/** + * @class TAO_UserDatagram_Protocol_Properties + * + * @brief RTCORBA::UserDatagramProtocolProperties implementation + * + * Stores UserDatagram Protocol configuration properties. + */ +class TAO_RTCORBA_Export TAO_UserDatagram_Protocol_Properties + : public RTCORBA::UserDatagramProtocolProperties, + public TAO_Local_RefCounted_Object +{ +public: + /// Constructor. + TAO_UserDatagram_Protocol_Properties (CORBA::Boolean enable_network_priority); + + CORBA::Boolean enable_network_priority (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void enable_network_priority (CORBA::Boolean enable + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + /// This method writes a CDR representation of UserDatagramProtocolProperties. + CORBA::Boolean _tao_encode (TAO_OutputCDR &out_cdr); + + /// This method reads the object state from a CDR representation. + CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr); + +protected: + + /// Protected destructor to enforce proper memory management of this + /// reference counted object. + virtual ~TAO_UserDatagram_Protocol_Properties (void); + +private: + // = Attributes. + + CORBA::Boolean enable_network_priority_; +}; + +//************************************************************************* + +/** + * @class TAO_StreamControl_Protocol_Properties + * + * @brief RTCORBA::StreamControlProtocolProperties implementation + * + * Stores StreamControl Protocol configuration properties. + */ +class TAO_RTCORBA_Export TAO_StreamControl_Protocol_Properties + : public RTCORBA::StreamControlProtocolProperties, + public TAO_Local_RefCounted_Object +{ +public: + /// Constructor. + TAO_StreamControl_Protocol_Properties (CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Boolean enable_network_priority); + + CORBA::Long send_buffer_size (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void send_buffer_size (CORBA::Long send_buffer_size + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + CORBA::Long recv_buffer_size (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void recv_buffer_size (CORBA::Long recv_buffer_size + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + CORBA::Boolean keep_alive (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void keep_alive (CORBA::Boolean keep_alive + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + CORBA::Boolean dont_route (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void dont_route (CORBA::Boolean dont_route + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + CORBA::Boolean no_delay (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void no_delay (CORBA::Boolean no_delay + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + CORBA::Boolean enable_network_priority (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void enable_network_priority (CORBA::Boolean enable + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + /// This method writes a CDR representation of StreamControlProtocolProperties. + CORBA::Boolean _tao_encode (TAO_OutputCDR &out_cdr); + + /// This method reads the object state from a CDR representation. + CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr); + +protected: + + /// Protected destructor to enforce proper memory management of this + /// reference counted object. + virtual ~TAO_StreamControl_Protocol_Properties (void); + +private: + // = Attributes. + + CORBA::Long send_buffer_size_; + CORBA::Long recv_buffer_size_; + CORBA::Boolean keep_alive_; + CORBA::Boolean dont_route_; + CORBA::Boolean no_delay_; + CORBA::Boolean enable_network_priority_; +}; + +//************************************************************************* + +class TAO_RTCORBA_Export TAO_GIOP_Protocol_Properties : public RTCORBA::GIOPProtocolProperties, public TAO_Local_RefCounted_Object { @@ -700,10 +862,10 @@ protected: /// Protected destructor to enforce proper memory management of this /// reference counted object. - virtual ~TAO_GIOP_Properties (); + virtual ~TAO_GIOP_Protocol_Properties (); friend class TAO_Protocol_Properties_Factory; - TAO_GIOP_Properties (void); + TAO_GIOP_Protocol_Properties (void); }; //************************************************************************* @@ -719,7 +881,8 @@ public: * properties: one describes the transport protocol and the other * describes the ORB messaging protocol. */ - static RTCORBA::ProtocolProperties *create_transport_protocol_property (IOP::ProfileId id); + static RTCORBA::ProtocolProperties *create_transport_protocol_property (IOP::ProfileId id, + TAO_ORB_Core *orb_core); /** * Creates the proper orb ProtocolProperties subclass for @@ -728,7 +891,7 @@ public: * properties: one describes the transport protocol and the other * describes the ORB messaging protocol. */ - static RTCORBA::ProtocolProperties*create_orb_protocol_property (IOP::ProfileId id); + static RTCORBA::ProtocolProperties *create_orb_protocol_property (IOP::ProfileId id); protected: TAO_Protocol_Properties_Factory (void); diff --git a/TAO/tao/RTCORBA/RT_Protocols_Hooks.cpp b/TAO/tao/RTCORBA/RT_Protocols_Hooks.cpp index d78920ec478..efef8d654fc 100644 --- a/TAO/tao/RTCORBA/RT_Protocols_Hooks.cpp +++ b/TAO/tao/RTCORBA/RT_Protocols_Hooks.cpp @@ -16,7 +16,6 @@ #include "tao/Transport_Acceptor.h" #include "tao/Transport_Connector.h" #include "tao/Policy_Set.h" -#include "tao/IIOP_Transport.h" #include "tao/debug.h" #include "tao/CDR.h" @@ -29,11 +28,6 @@ ACE_RCSID (RTCORBA, "$Id$") -TAO_RT_Protocols_Hooks::Client_Protocols_Hook - TAO_RT_Protocols_Hooks::client_protocols_hook_ = 0; -TAO_RT_Protocols_Hooks::Server_Protocols_Hook - TAO_RT_Protocols_Hooks::server_protocols_hook_ = 0; - TAO_RT_Protocols_Hooks::TAO_RT_Protocols_Hooks (void) { } @@ -50,10 +44,8 @@ TAO_RT_Protocols_Hooks::init_hooks (TAO_ORB_Core *orb_core // Save a reference to the priority mapping manager. CORBA::Object_var obj = - orb_core->object_ref_table ().resolve_initial_references ( - TAO_OBJID_PRIORITYMAPPINGMANAGER - ACE_ENV_ARG_PARAMETER - ); + orb_core->object_ref_table ().resolve_initial_references (TAO_OBJID_PRIORITYMAPPINGMANAGER + ACE_ENV_ARG_PARAMETER); ACE_CHECK; this->mapping_manager_ = @@ -63,10 +55,8 @@ TAO_RT_Protocols_Hooks::init_hooks (TAO_ORB_Core *orb_core // Save a reference to the priority mapping manager. CORBA::Object_var object = - orb_core->object_ref_table ().resolve_initial_references ( - TAO_OBJID_NETWORKPRIORITYMAPPINGMANAGER - ACE_ENV_ARG_PARAMETER - ); + orb_core->object_ref_table ().resolve_initial_references (TAO_OBJID_NETWORKPRIORITYMAPPINGMANAGER + ACE_ENV_ARG_PARAMETER); ACE_CHECK; this->network_mapping_manager_ = @@ -75,10 +65,8 @@ TAO_RT_Protocols_Hooks::init_hooks (TAO_ORB_Core *orb_core ACE_CHECK; object = - this->orb_core_->object_ref_table ().resolve_initial_references ( - "RTCurrent" - ACE_ENV_ARG_PARAMETER - ); + this->orb_core_->object_ref_table ().resolve_initial_references ("RTCurrent" + ACE_ENV_ARG_PARAMETER); ACE_CHECK; this->current_ = @@ -88,313 +76,439 @@ TAO_RT_Protocols_Hooks::init_hooks (TAO_ORB_Core *orb_core } -int -TAO_RT_Protocols_Hooks::call_client_protocols_hook ( - int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char *protocol_type - ) +RTCORBA::ProtocolProperties_ptr +TAO_RT_Protocols_Hooks::server_protocol_properties (IOP::ProfileId protocol_tag, + CORBA::Policy_ptr policy + ACE_ENV_ARG_DECL) { - if (TAO_RT_Protocols_Hooks::client_protocols_hook_ == 0) - return -1; + if (CORBA::is_nil (policy)) + return 0; + + RTCORBA::ServerProtocolPolicy_var server_protocol_policy = + RTCORBA::ServerProtocolPolicy::_narrow (policy + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + if (CORBA::is_nil (server_protocol_policy.in ())) + return 0; + + TAO_ServerProtocolPolicy *server_protocols = + ACE_dynamic_cast (TAO_ServerProtocolPolicy *, + server_protocol_policy.in ()); + + if (server_protocols == 0) + return 0; + + // TAO_ServerProtocolPolicy + RTCORBA::ProtocolList &protocols = + server_protocols->protocols_rep (); + + for (CORBA::ULong j = 0; j < protocols.length (); ++j) + { + if (protocols[j].protocol_type == protocol_tag) + { + return RTCORBA::ProtocolProperties::_duplicate (protocols[j].transport_protocol_properties.in ()); + } + } - (*TAO_RT_Protocols_Hooks::client_protocols_hook_) (this->orb_core_, - send_buffer_size, - recv_buffer_size, - no_delay, - enable_network_priority, - protocol_type); + return 0; +} + +RTCORBA::ProtocolProperties_ptr +TAO_RT_Protocols_Hooks::client_protocol_properties (IOP::ProfileId protocol_tag, + CORBA::Policy_ptr policy + ACE_ENV_ARG_DECL) +{ + if (CORBA::is_nil (policy)) + return 0; + + RTCORBA::ClientProtocolPolicy_var client_protocol_policy = + RTCORBA::ClientProtocolPolicy::_narrow (policy + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + if (CORBA::is_nil (client_protocol_policy.in ())) + return 0; + + TAO_ClientProtocolPolicy *client_protocols = + ACE_dynamic_cast (TAO_ClientProtocolPolicy *, + client_protocol_policy.in ()); + + if (client_protocols == 0) + return 0; + + // TAO_ClientProtocolPolicy + RTCORBA::ProtocolList &protocols = + client_protocols->protocols_rep (); + + for (CORBA::ULong j = 0; j < protocols.length (); ++j) + { + if (protocols[j].protocol_type == protocol_tag) + { + return RTCORBA::ProtocolProperties::_duplicate (protocols[j].transport_protocol_properties.in ()); + } + } return 0; } +RTCORBA::ProtocolProperties_ptr +TAO_RT_Protocols_Hooks::server_protocol_properties_at_orb_level (IOP::ProfileId protocol_tag + ACE_ENV_ARG_DECL) +{ + CORBA::Policy_var policy = + this->orb_core_->get_cached_policy (TAO_CACHED_POLICY_RT_SERVER_PROTOCOL + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return this->server_protocol_properties (protocol_tag, + policy.in () + ACE_ENV_ARG_PARAMETER); +} + +RTCORBA::ProtocolProperties_ptr +TAO_RT_Protocols_Hooks::client_protocol_properties_at_orb_level (IOP::ProfileId protocol_tag + ACE_ENV_ARG_DECL) +{ + CORBA::Policy_var policy = + this->orb_core_->get_cached_policy (TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return this->client_protocol_properties (protocol_tag, + policy.in () + ACE_ENV_ARG_PARAMETER); +} + +RTCORBA::ProtocolProperties_ptr +TAO_RT_Protocols_Hooks::client_protocol_properties_at_object_level (IOP::ProfileId protocol_tag, + TAO_Stub *stub + ACE_ENV_ARG_DECL) +{ + CORBA::Policy_var policy = + stub->get_cached_policy (TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (0); + + return this->client_protocol_properties (protocol_tag, + policy.in () + ACE_ENV_ARG_PARAMETER); +} + void -TAO_RT_Protocols_Hooks::set_client_protocols_hook (Client_Protocols_Hook hook) +TAO_RT_Protocols_Hooks::extract_protocol_properties (TAO_IIOP_Protocol_Properties &to, + RTCORBA::ProtocolProperties_ptr from + ACE_ENV_ARG_DECL) { - TAO_RT_Protocols_Hooks::client_protocols_hook_ = hook; - // Saving the hook pointer so that we can use it later when needed. + RTCORBA::TCPProtocolProperties_var protocol_properties = + RTCORBA::TCPProtocolProperties::_narrow (from + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + to.send_buffer_size_ = protocol_properties->send_buffer_size (); + to.recv_buffer_size_ = protocol_properties->recv_buffer_size (); + to.keep_alive_ = protocol_properties->keep_alive (); + to.dont_route_ = protocol_properties->dont_route (); + to.no_delay_ = protocol_properties->no_delay (); + to.enable_network_priority_ = protocol_properties->enable_network_priority (); } -int -TAO_RT_Protocols_Hooks::call_server_protocols_hook ( - int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char *protocol_type - ) +void +TAO_RT_Protocols_Hooks::server_protocol_properties_at_orb_level (TAO_IIOP_Protocol_Properties &to + ACE_ENV_ARG_DECL) { - if (TAO_RT_Protocols_Hooks::server_protocols_hook_ == 0) - { - return -1; - } + RTCORBA::ProtocolProperties_var from = + this->server_protocol_properties_at_orb_level (IOP::TAG_INTERNET_IOP + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; - int result_value = - (*TAO_RT_Protocols_Hooks::server_protocols_hook_) (this->orb_core_, - send_buffer_size, - recv_buffer_size, - no_delay, - enable_network_priority, - protocol_type); + if (!CORBA::is_nil (from.in ())) + this->extract_protocol_properties (to, + from.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} - if (result_value != 0) - { - return -1; - } +void +TAO_RT_Protocols_Hooks::client_protocol_properties_at_orb_level (TAO_IIOP_Protocol_Properties &to + ACE_ENV_ARG_DECL) +{ + RTCORBA::ProtocolProperties_var from = + this->client_protocol_properties_at_orb_level (IOP::TAG_INTERNET_IOP + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; - return 0; + if (!CORBA::is_nil (from.in ())) + this->extract_protocol_properties (to, + from.in () + ACE_ENV_ARG_PARAMETER); } void -TAO_RT_Protocols_Hooks::set_server_protocols_hook (Server_Protocols_Hook hook) +TAO_RT_Protocols_Hooks::extract_protocol_properties (TAO_UIOP_Protocol_Properties &to, + RTCORBA::ProtocolProperties_ptr from + ACE_ENV_ARG_DECL) { - TAO_RT_Protocols_Hooks::server_protocols_hook_ = hook; - // Saving the hook pointer so that we can use it later when needed. + RTCORBA::UnixDomainProtocolProperties_var protocol_properties = + RTCORBA::UnixDomainProtocolProperties::_narrow (from + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + to.send_buffer_size_ = protocol_properties->send_buffer_size (); + to.recv_buffer_size_ = protocol_properties->recv_buffer_size (); } -int -TAO_RT_Protocols_Hooks::update_client_protocol_properties ( - TAO_Stub *stub, - TAO_Transport *transport, - const char *protocol_type - ) +void +TAO_RT_Protocols_Hooks::server_protocol_properties_at_orb_level (TAO_UIOP_Protocol_Properties &to + ACE_ENV_ARG_DECL) { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - "TAO_RT_Protocols_Hooks::" - "get_effective_client_protocol_properties\n")); + RTCORBA::ProtocolProperties_var from = + this->server_protocol_properties_at_orb_level (TAO_TAG_UIOP_PROFILE + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; - ACE_TRY_NEW_ENV - { - RTCORBA::ProtocolProperties_var properties = - RTCORBA::ProtocolProperties::_nil (); + if (!CORBA::is_nil (from.in ())) + this->extract_protocol_properties (to, + from.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} - TAO_RT_Stub *rt_stub = ACE_dynamic_cast (TAO_RT_Stub *, - stub); +void +TAO_RT_Protocols_Hooks::client_protocol_properties_at_orb_level (TAO_UIOP_Protocol_Properties &to + ACE_ENV_ARG_DECL) +{ + RTCORBA::ProtocolProperties_var from = + this->client_protocol_properties_at_orb_level (TAO_TAG_UIOP_PROFILE + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; - CORBA::Policy* policy = rt_stub->client_protocol (); + if (!CORBA::is_nil (from.in ())) + this->extract_protocol_properties (to, + from.in () + ACE_ENV_ARG_PARAMETER); +} - RTCORBA::ClientProtocolPolicy_var client_protocols_policy; - TAO_ClientProtocolPolicy *client_protocols = 0; +void +TAO_RT_Protocols_Hooks::extract_protocol_properties (TAO_SHMIOP_Protocol_Properties &to, + RTCORBA::ProtocolProperties_ptr from + ACE_ENV_ARG_DECL) +{ + RTCORBA::SharedMemoryProtocolProperties_var protocol_properties = + RTCORBA::SharedMemoryProtocolProperties::_narrow (from + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + to.preallocate_buffer_size_ = protocol_properties->preallocate_buffer_size (); + to.mmap_filename_ = protocol_properties->mmap_filename (); + to.mmap_lockname_ = protocol_properties->mmap_lockname (); +} - if (!CORBA::is_nil (policy)) - { - client_protocols_policy = - RTCORBA::ClientProtocolPolicy::_narrow (policy - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; +void +TAO_RT_Protocols_Hooks::server_protocol_properties_at_orb_level (TAO_SHMIOP_Protocol_Properties &to + ACE_ENV_ARG_DECL) +{ + RTCORBA::ProtocolProperties_var from = + this->server_protocol_properties_at_orb_level (TAO_TAG_SHMEM_PROFILE + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; - client_protocols = - ACE_dynamic_cast (TAO_ClientProtocolPolicy *, - client_protocols_policy.in ()); + if (!CORBA::is_nil (from.in ())) + this->extract_protocol_properties (to, + from.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} - if (client_protocols != 0) - { - // TAO_ClientProtocolPolicy - RTCORBA::ProtocolList & protocols = - client_protocols->protocols_rep (); - - for (CORBA::ULong j = 0; j < protocols.length (); ++j) - { - if (protocols[j].protocol_type == IOP::TAG_INTERNET_IOP) - { - properties = - RTCORBA::ProtocolProperties::_narrow ( - protocols[j].transport_protocol_properties.in () - ACE_ENV_ARG_PARAMETER - ); - ACE_TRY_CHECK; - - if (ACE_OS::strcmp (protocol_type, "iiop") == 0) - { - break; - } - } - } - } +void +TAO_RT_Protocols_Hooks::client_protocol_properties_at_orb_level (TAO_SHMIOP_Protocol_Properties &to + ACE_ENV_ARG_DECL) +{ + RTCORBA::ProtocolProperties_var from = + this->client_protocol_properties_at_orb_level (TAO_TAG_SHMEM_PROFILE + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; - if (ACE_OS::strcmp (protocol_type, "iiop") == 0) - { - if (!CORBA::is_nil (properties.in ())) - { - RTCORBA::TCPProtocolProperties_var tcp_properties = - RTCORBA::TCPProtocolProperties::_narrow ( - properties.in () - ACE_ENV_ARG_PARAMETER - ); - ACE_TRY_CHECK; - - const int send_buffer_size = - tcp_properties->send_buffer_size ( - ACE_ENV_SINGLE_ARG_PARAMETER - ); - ACE_TRY_CHECK; - - const int recv_buffer_size = - tcp_properties->recv_buffer_size ( - ACE_ENV_SINGLE_ARG_PARAMETER - ); - ACE_TRY_CHECK; - - const int no_delay = - tcp_properties->no_delay ( - ACE_ENV_SINGLE_ARG_PARAMETER - ); - ACE_TRY_CHECK; - - const int enable_network_priority = - tcp_properties->enable_network_priority ( - ACE_ENV_SINGLE_ARG_PARAMETER - ); - ACE_TRY_CHECK; - - TAO_IIOP_Transport *iiop_transport = - ACE_dynamic_cast (TAO_IIOP_Transport *, - transport); - - iiop_transport->update_protocol_properties ( - send_buffer_size, - recv_buffer_size, - no_delay, - enable_network_priority - ); - } - } - } - } - ACE_CATCHANY - { - if (TAO_debug_level > 4) - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "TAO_RT_Protocols_Hooks::" - "get_effective_client_protocol_properties"); + if (!CORBA::is_nil (from.in ())) + this->extract_protocol_properties (to, + from.in () + ACE_ENV_ARG_PARAMETER); +} - return -1; - } - ACE_ENDTRY; +void +TAO_RT_Protocols_Hooks::extract_protocol_properties (TAO_DIOP_Protocol_Properties &to, + RTCORBA::ProtocolProperties_ptr from + ACE_ENV_ARG_DECL) +{ + RTCORBA::UserDatagramProtocolProperties_var protocol_properties = + RTCORBA::UserDatagramProtocolProperties::_narrow (from + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + to.enable_network_priority_ = protocol_properties->enable_network_priority (); +} - return 0; +void +TAO_RT_Protocols_Hooks::server_protocol_properties_at_orb_level (TAO_DIOP_Protocol_Properties &to + ACE_ENV_ARG_DECL) +{ + RTCORBA::ProtocolProperties_var from = + this->server_protocol_properties_at_orb_level (TAO_TAG_UDP_PROFILE + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + if (!CORBA::is_nil (from.in ())) + this->extract_protocol_properties (to, + from.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; } -int -TAO_RT_Protocols_Hooks::update_server_protocol_properties ( - CORBA::Policy *policy, - TAO_Transport *transport, - const char *protocol_type - ) +void +TAO_RT_Protocols_Hooks::client_protocol_properties_at_orb_level (TAO_DIOP_Protocol_Properties &to + ACE_ENV_ARG_DECL) { + RTCORBA::ProtocolProperties_var from = + this->client_protocol_properties_at_orb_level (TAO_TAG_UDP_PROFILE + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - "TAO_RT_Protocols_Hooks::" - "get_effective_server_protocol_properties\n")); + if (!CORBA::is_nil (from.in ())) + this->extract_protocol_properties (to, + from.in () + ACE_ENV_ARG_PARAMETER); +} - ACE_TRY_NEW_ENV - { - RTCORBA::ProtocolProperties_var properties = - RTCORBA::ProtocolProperties::_nil (); +void +TAO_RT_Protocols_Hooks::extract_protocol_properties (TAO_SCIOP_Protocol_Properties &to, + RTCORBA::ProtocolProperties_ptr from + ACE_ENV_ARG_DECL) +{ + RTCORBA::StreamControlProtocolProperties_var protocol_properties = + RTCORBA::StreamControlProtocolProperties::_narrow (from + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + to.send_buffer_size_ = protocol_properties->send_buffer_size (); + to.recv_buffer_size_ = protocol_properties->recv_buffer_size (); + to.keep_alive_ = protocol_properties->keep_alive (); + to.dont_route_ = protocol_properties->dont_route (); + to.no_delay_ = protocol_properties->no_delay (); + to.enable_network_priority_ = protocol_properties->enable_network_priority (); +} - RTCORBA::ServerProtocolPolicy_var server_protocols_policy; - TAO_ServerProtocolPolicy *server_protocols = 0; +void +TAO_RT_Protocols_Hooks::server_protocol_properties_at_orb_level (TAO_SCIOP_Protocol_Properties &to + ACE_ENV_ARG_DECL) +{ + RTCORBA::ProtocolProperties_var from = + this->server_protocol_properties_at_orb_level (TAO_TAG_SCIOP_PROFILE + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; - if (!CORBA::is_nil (policy)) - { - server_protocols_policy = - RTCORBA::ServerProtocolPolicy::_narrow (policy - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; + if (!CORBA::is_nil (from.in ())) + this->extract_protocol_properties (to, + from.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} - server_protocols = - ACE_dynamic_cast (TAO_ServerProtocolPolicy *, - server_protocols_policy.in ()); +void +TAO_RT_Protocols_Hooks::client_protocol_properties_at_orb_level (TAO_SCIOP_Protocol_Properties &to + ACE_ENV_ARG_DECL) +{ + RTCORBA::ProtocolProperties_var from = + this->client_protocol_properties_at_orb_level (TAO_TAG_SCIOP_PROFILE + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; - if (server_protocols != 0) - { - // TAO_ServerProtocolPolicy - RTCORBA::ProtocolList & protocols = - server_protocols->protocols_rep (); - - for (CORBA::ULong j = 0; j < protocols.length (); ++j) - { - if (protocols[j].protocol_type == IOP::TAG_INTERNET_IOP) - { - properties = - RTCORBA::ProtocolProperties::_narrow ( - protocols[j].transport_protocol_properties.in () - ACE_ENV_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (ACE_OS::strcmp (protocol_type, "iiop") == 0) - { - break; - } - } - } - } + if (!CORBA::is_nil (from.in ())) + this->extract_protocol_properties (to, + from.in () + ACE_ENV_ARG_PARAMETER); +} - if (ACE_OS::strcmp (protocol_type, "iiop") == 0) - { - if (!CORBA::is_nil (properties.in ())) - { - RTCORBA::TCPProtocolProperties_var tcp_properties = - RTCORBA::TCPProtocolProperties::_narrow ( - properties.in () - ACE_ENV_ARG_PARAMETER - ); - ACE_TRY_CHECK; - - const int send_buffer_size = - tcp_properties->send_buffer_size ( - ACE_ENV_SINGLE_ARG_PARAMETER - ); - ACE_TRY_CHECK; - - const int recv_buffer_size = - tcp_properties->recv_buffer_size ( - ACE_ENV_SINGLE_ARG_PARAMETER - ); - ACE_TRY_CHECK; - - const int no_delay = - tcp_properties->no_delay ( - ACE_ENV_SINGLE_ARG_PARAMETER - ); - ACE_TRY_CHECK; - - const int enable_network_priority = - tcp_properties->enable_network_priority ( - ACE_ENV_SINGLE_ARG_PARAMETER - ); - ACE_TRY_CHECK; - - TAO_IIOP_Transport *iiop_transport = - ACE_dynamic_cast (TAO_IIOP_Transport *, - transport); - - iiop_transport->update_protocol_properties ( - send_buffer_size, - recv_buffer_size, - no_delay, - enable_network_priority - ); - } - } - } +CORBA::Boolean +TAO_RT_Protocols_Hooks::set_network_priority (IOP::ProfileId protocol_tag, + RTCORBA::ProtocolProperties_ptr protocol_properties + ACE_ENV_ARG_DECL) +{ + if (CORBA::is_nil (protocol_properties)) + return false; + + if (protocol_tag == IOP::TAG_INTERNET_IOP) + { + RTCORBA::TCPProtocolProperties_var tcp_protocol_properties = + RTCORBA::TCPProtocolProperties::_narrow (protocol_properties + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (false); + + return tcp_protocol_properties->enable_network_priority (); } - ACE_CATCHANY + + if (protocol_tag == TAO_TAG_UDP_PROFILE) { - if (TAO_debug_level > 4) - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "TAO_RT_Protocols_Hooks::" - "get_effective_client_protocol_properties"); + RTCORBA::UserDatagramProtocolProperties_var udp_protocol_properties = + RTCORBA::UserDatagramProtocolProperties::_narrow (protocol_properties + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (false); - return -1; + return udp_protocol_properties->enable_network_priority (); } - ACE_ENDTRY; - return 0; + if (protocol_tag == TAO_TAG_SCIOP_PROFILE) + { + RTCORBA::StreamControlProtocolProperties_var sctp_protocol_properties = + RTCORBA::StreamControlProtocolProperties::_narrow (protocol_properties + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (false); + + return sctp_protocol_properties->enable_network_priority (); + } + + return false; +} + +CORBA::Boolean +TAO_RT_Protocols_Hooks::set_client_network_priority (IOP::ProfileId protocol_tag, + TAO_Stub *stub + ACE_ENV_ARG_DECL) +{ + if (protocol_tag != IOP::TAG_INTERNET_IOP && + protocol_tag != TAO_TAG_UDP_PROFILE && + protocol_tag != TAO_TAG_SCIOP_PROFILE) + return false; + + RTCORBA::ProtocolProperties_var protocol_properties = + this->client_protocol_properties_at_object_level (protocol_tag, + stub + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (false); + + return this->set_network_priority (protocol_tag, + protocol_properties.in () + ACE_ENV_ARG_PARAMETER); +} + +CORBA::Boolean +TAO_RT_Protocols_Hooks::set_server_network_priority (IOP::ProfileId protocol_tag, + CORBA::Policy *policy + ACE_ENV_ARG_DECL) +{ + if (protocol_tag != IOP::TAG_INTERNET_IOP && + protocol_tag != TAO_TAG_UDP_PROFILE && + protocol_tag != TAO_TAG_SCIOP_PROFILE) + return false; + + RTCORBA::ProtocolProperties_var protocol_properties = + this->server_protocol_properties (protocol_tag, + policy + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (false); + + return this->set_network_priority (protocol_tag, + protocol_properties.in () + ACE_ENV_ARG_PARAMETER); } CORBA::Long @@ -461,28 +575,27 @@ TAO_RT_Protocols_Hooks::rt_service_context ( // again. We can use the already existing one. if (!restart) { - TAO_RT_Stub *rt_stub = ACE_dynamic_cast (TAO_RT_Stub *, - stub); - CORBA::Policy *priority_model_policy = - rt_stub->exposed_priority_model (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK; - if (priority_model_policy) - { + TAO_RT_Stub *rt_stub = + ACE_dynamic_cast (TAO_RT_Stub *, + stub); - CORBA::Policy *priority_model_policy = - rt_stub->exposed_priority_model (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK; + CORBA::Policy_var priority_model_policy = + rt_stub->get_cached_policy (TAO_CACHED_POLICY_PRIORITY_MODEL + ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + if (!CORBA::is_nil (priority_model_policy.in ())) + { CORBA::Short client_priority; + int status = this->get_thread_CORBA_priority (client_priority ACE_ENV_ARG_PARAMETER); if (status == -1) ACE_THROW (CORBA::DATA_CONVERSION (1, CORBA::COMPLETED_NO)); - this->add_rt_service_context_hook (service_context, - priority_model_policy, + priority_model_policy.in (), client_priority ACE_ENV_ARG_PARAMETER); ACE_CHECK; @@ -705,74 +818,6 @@ TAO_RT_Protocols_Hooks::set_thread_native_priority ( } int -TAO_RT_Protocols_Hooks::set_default_policies (ACE_ENV_SINGLE_ARG_DECL) -{ - // Set RTCORBA policy defaults. - // Set RTCORBA::ServerProtocolPolicy and - // RTCORBA::ClientProtocolPolicy defaults to include all protocols - // that were loaded into this ORB. - // First, create a protocol list. - - TAO_ProtocolFactorySet *pfs = this->orb_core_->protocol_factories (); - - RTCORBA::ProtocolList protocols; - protocols.length (ACE_static_cast (CORBA::ULong, pfs->size ())); - - int i = 0; - for (TAO_ProtocolFactorySetItor factory = pfs->begin (); - factory != pfs->end (); - ++factory, ++i) - { - CORBA::ULong protocol_type = (*factory)->factory ()->tag (); - protocols[i].protocol_type = protocol_type; - protocols[i].orb_protocol_properties = - RTCORBA::ProtocolProperties::_nil (); - // @@ Later, we will likely migrate to using RTCORBA protocol - // policies for configuration of protocols in nonRT use cases. - // Then, the code below will change to each protocol factory - // being responsible for creation of its own default protocol - // properties. - protocols[i].transport_protocol_properties = - TAO_Protocol_Properties_Factory::create_transport_protocol_property - (protocol_type); - } - - // Set ServerProtocolPolicy. - TAO_ServerProtocolPolicy *server_protocol_policy = 0; - ACE_NEW_RETURN (server_protocol_policy, - TAO_ServerProtocolPolicy (protocols), - -1); - - RTCORBA::ServerProtocolPolicy_var safe_server_protocol_policy = - server_protocol_policy; - - this->orb_core_->get_default_policies ()->set_policy (server_protocol_policy - ACE_ENV_ARG_PARAMETER); - ACE_CHECK_RETURN (-1); - - // Set ClientProtocolPolicy. - // NOTE: ClientProtocolPolicy default is used ONLY for protocol - // configuration (not protocol preference) IF there is no ORB-level - // override. It is not used when computing effective policy value - // for preferencing protocols. - TAO_ClientProtocolPolicy *client_protocol_policy = 0; - ACE_NEW_RETURN (client_protocol_policy, - TAO_ClientProtocolPolicy (protocols), - -1); - - RTCORBA::ClientProtocolPolicy_var safe_client_protocol_policy = - client_protocol_policy; - - this->orb_core_->get_default_policies ()->set_policy ( - client_protocol_policy - ACE_ENV_ARG_PARAMETER - ); - ACE_CHECK_RETURN (-1); - - return 0; -} - -int TAO_RT_Protocols_Hooks::set_default_server_protocol_policy ( TAO_Acceptor_Registry &acceptor_registry ACE_ENV_ARG_DECL @@ -808,9 +853,8 @@ TAO_RT_Protocols_Hooks::set_default_server_protocol_policy ( // being responsible for creation of its own default protocol // properties. protocols[current_length].transport_protocol_properties = - TAO_Protocol_Properties_Factory::create_transport_protocol_property ( - (*acceptor)->tag () - ); + TAO_Protocol_Properties_Factory::create_transport_protocol_property ((*acceptor)->tag (), + this->orb_core_); } // Set ServerProtocolPolicy. @@ -842,7 +886,7 @@ ACE_STATIC_SVC_DEFINE (TAO_RT_Protocols_Hooks, #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) - template class ACE_Dynamic_Service<TAO_RT_Protocols_Hooks>; +template class ACE_Dynamic_Service<TAO_RT_Protocols_Hooks>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) diff --git a/TAO/tao/RTCORBA/RT_Protocols_Hooks.h b/TAO/tao/RTCORBA/RT_Protocols_Hooks.h index bcb13cb9640..a61a34826f4 100644 --- a/TAO/tao/RTCORBA/RT_Protocols_Hooks.h +++ b/TAO/tao/RTCORBA/RT_Protocols_Hooks.h @@ -42,95 +42,69 @@ public: virtual ~TAO_RT_Protocols_Hooks (void); /// Initialize the protocols hooks instance. - virtual void init_hooks (TAO_ORB_Core *orb_core + void init_hooks (TAO_ORB_Core *orb_core + ACE_ENV_ARG_DECL); + + CORBA::Boolean set_client_network_priority (IOP::ProfileId protocol_tag, + TAO_Stub *stub + ACE_ENV_ARG_DECL); + + CORBA::Boolean set_server_network_priority (IOP::ProfileId protocol_tag, + CORBA::Policy *policy + ACE_ENV_ARG_DECL); + + void server_protocol_properties_at_orb_level (TAO_IIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void client_protocol_properties_at_orb_level (TAO_IIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void server_protocol_properties_at_orb_level (TAO_UIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void client_protocol_properties_at_orb_level (TAO_UIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void server_protocol_properties_at_orb_level (TAO_SHMIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void client_protocol_properties_at_orb_level (TAO_SHMIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void server_protocol_properties_at_orb_level (TAO_DIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void client_protocol_properties_at_orb_level (TAO_DIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void server_protocol_properties_at_orb_level (TAO_SCIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + void client_protocol_properties_at_orb_level (TAO_SCIOP_Protocol_Properties &protocol_properties + ACE_ENV_ARG_DECL); + + CORBA::Long get_dscp_codepoint (void); + + void rt_service_context (TAO_Stub *stub, + TAO_Service_Context &service_context, + CORBA::Boolean restart ACE_ENV_ARG_DECL); - /// Invoke the client_protocols hook if present. - /** - * The timeout hook is used to determine if the client_protocols policy is - * set and with what value. If the ORB is compiled without support - * for RTCORBA this feature does not take effect - * @param tcp_properties returns the Protocol List set - */ - virtual int call_client_protocols_hook (int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char *protocol_type); - - /// Define the Client_Protocols_TCP_Hook signature - typedef int (*Client_Protocols_Hook) (TAO_ORB_Core *, - int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char *); - - static void set_client_protocols_hook (Client_Protocols_Hook hook); - - /// The hook to be set for the ClientProtocolPolicy. - static Client_Protocols_Hook client_protocols_hook_; - - /// Invoke the server_protocols hook if present. - /** - * The timeout hook is used to determine if the client_protocols policy is - * set and with what value. If the ORB is compiled without support - * for RTCORBA this feature does not take effect - * @param tcp_properties returns the Protocol List set - */ - virtual int call_server_protocols_hook (int &send_buffer_size, - int &recv_buffer_size, - int &no_delay, - int &enable_network_priority, - const char *protocol_type); - - /// Define the Server_Protocols_Hook signature - typedef int (*Server_Protocols_Hook) (TAO_ORB_Core *, - int &, - int &, - int &, - int &, - const char *); - - static void set_server_protocols_hook (Server_Protocols_Hook hook); - // static void set_server_protocols_uiop_hook (Server_Protocols_UIOP_Hook hook); - - /// The hook to be set for the ServerProtocolPolicy. - static Server_Protocols_Hook server_protocols_hook_; - - - - virtual int update_client_protocol_properties (TAO_Stub *stub, - TAO_Transport *t, - const char *protocol_type); - - - virtual int update_server_protocol_properties (CORBA::Policy *server_policy, - TAO_Transport *t, - const char *protocol_type); - - virtual CORBA::Long get_dscp_codepoint (void); - - virtual void rt_service_context (TAO_Stub *stub, - TAO_Service_Context &service_context, - CORBA::Boolean restart - ACE_ENV_ARG_DECL); - - virtual void add_rt_service_context_hook (TAO_Service_Context &service_context, - CORBA::Policy *model_policy, - CORBA::Short &client_priority - ACE_ENV_ARG_DECL); - - virtual void get_selector_hook (CORBA::Policy *model_policy, - CORBA::Boolean - &is_client_propagated, - CORBA::Short &server_priority); - - virtual void get_selector_bands_policy_hook (CORBA::Policy *bands_policy, - CORBA::Short priority, - CORBA::Short &min_priority, - CORBA::Short &max_priority, - int &in_range); + void add_rt_service_context_hook (TAO_Service_Context &service_context, + CORBA::Policy *model_policy, + CORBA::Short &client_priority + ACE_ENV_ARG_DECL); + + void get_selector_hook (CORBA::Policy *model_policy, + CORBA::Boolean + &is_client_propagated, + CORBA::Short &server_priority); + + void get_selector_bands_policy_hook (CORBA::Policy *bands_policy, + CORBA::Short priority, + CORBA::Short &min_priority, + CORBA::Short &max_priority, + int &in_range); /** * Accessor and modifier to the current thread priority, used to @@ -138,32 +112,71 @@ public: * some critical components. */ //@{ - virtual int get_thread_CORBA_priority (CORBA::Short & - ACE_ENV_ARG_DECL_NOT_USED); - - virtual int get_thread_native_priority (CORBA::Short & - ACE_ENV_ARG_DECL_NOT_USED); - - virtual int get_thread_CORBA_and_native_priority (CORBA::Short &, - CORBA::Short & - ACE_ENV_ARG_DECL_NOT_USED); - - virtual int set_thread_CORBA_priority (CORBA::Short - ACE_ENV_ARG_DECL_NOT_USED); - - virtual int set_thread_native_priority (CORBA::Short - ACE_ENV_ARG_DECL_NOT_USED); - + int get_thread_CORBA_priority (CORBA::Short & + ACE_ENV_ARG_DECL); + + int get_thread_native_priority (CORBA::Short & + ACE_ENV_ARG_DECL); + + int get_thread_CORBA_and_native_priority (CORBA::Short &, + CORBA::Short & + ACE_ENV_ARG_DECL); + + int set_thread_CORBA_priority (CORBA::Short + ACE_ENV_ARG_DECL); + + int set_thread_native_priority (CORBA::Short + ACE_ENV_ARG_DECL); + //@} - /// 1. Sets ORB-level policy defaults for this ORB. Currently sets - /// default RTCORBA policies: ClientProtocolPolicy. - virtual int set_default_policies (ACE_ENV_SINGLE_ARG_DECL); - int set_default_server_protocol_policy (TAO_Acceptor_Registry &acceptor_registry ACE_ENV_ARG_DECL); protected: + + RTCORBA::ProtocolProperties_ptr server_protocol_properties (IOP::ProfileId protocol_tag, + CORBA::Policy_ptr policy + ACE_ENV_ARG_DECL); + + RTCORBA::ProtocolProperties_ptr client_protocol_properties (IOP::ProfileId protocol_tag, + CORBA::Policy_ptr policy + ACE_ENV_ARG_DECL); + + RTCORBA::ProtocolProperties_ptr server_protocol_properties_at_orb_level (IOP::ProfileId protocol_tag + ACE_ENV_ARG_DECL); + + RTCORBA::ProtocolProperties_ptr client_protocol_properties_at_orb_level (IOP::ProfileId protocol_tag + ACE_ENV_ARG_DECL); + + RTCORBA::ProtocolProperties_ptr client_protocol_properties_at_object_level (IOP::ProfileId protocol_tag, + TAO_Stub *stub + ACE_ENV_ARG_DECL); + + void extract_protocol_properties (TAO_IIOP_Protocol_Properties &to, + RTCORBA::ProtocolProperties_ptr from + ACE_ENV_ARG_DECL); + + void extract_protocol_properties (TAO_UIOP_Protocol_Properties &to, + RTCORBA::ProtocolProperties_ptr from + ACE_ENV_ARG_DECL); + + void extract_protocol_properties (TAO_SHMIOP_Protocol_Properties &to, + RTCORBA::ProtocolProperties_ptr from + ACE_ENV_ARG_DECL); + + void extract_protocol_properties (TAO_DIOP_Protocol_Properties &to, + RTCORBA::ProtocolProperties_ptr from + ACE_ENV_ARG_DECL); + + void extract_protocol_properties (TAO_SCIOP_Protocol_Properties &to, + RTCORBA::ProtocolProperties_ptr from + ACE_ENV_ARG_DECL); + + CORBA::Boolean set_network_priority (IOP::ProfileId protocol_tag, + RTCORBA::ProtocolProperties_ptr protocol_properties + ACE_ENV_ARG_DECL); + TAO_ORB_Core *orb_core_; // Save a reference to the priority mapping manager. diff --git a/TAO/tao/RTCORBA/RT_Stub.cpp b/TAO/tao/RTCORBA/RT_Stub.cpp index f81b3c697ab..9c4d51f5c41 100644 --- a/TAO/tao/RTCORBA/RT_Stub.cpp +++ b/TAO/tao/RTCORBA/RT_Stub.cpp @@ -123,8 +123,6 @@ TAO_RT_Stub::exposed_client_protocol (CORBA::Policy_ptr policy) this->client_protocol_policy_ = CORBA::Policy::_duplicate (policy); } - - #if (TAO_HAS_CORBA_MESSAGING == 1) CORBA::Policy_ptr @@ -146,23 +144,24 @@ TAO_RT_Stub::get_policy (CORBA::PolicyType type } CORBA::Policy_ptr -TAO_RT_Stub::get_client_policy (CORBA::PolicyType type +TAO_RT_Stub::get_cached_policy (TAO_Cached_Policy_Type type ACE_ENV_ARG_DECL) { // If we are dealing with a client exposed policy, check if any // value came in the IOR/reconcile IOR value and overrides. - if (type == RTCORBA::PRIORITY_MODEL_POLICY_TYPE) + if (type == TAO_CACHED_POLICY_PRIORITY_MODEL) return this->exposed_priority_model (ACE_ENV_SINGLE_ARG_PARAMETER); - if (type == RTCORBA::PRIORITY_BANDED_CONNECTION_POLICY_TYPE) + if (type == TAO_CACHED_POLICY_RT_PRIORITY_BANDED_CONNECTION) return this->effective_priority_banded_connection (ACE_ENV_SINGLE_ARG_PARAMETER); - if (type == RTCORBA::CLIENT_PROTOCOL_POLICY_TYPE) + if (type == TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL) return this->effective_client_protocol (ACE_ENV_SINGLE_ARG_PARAMETER); - return this->TAO_Stub::get_client_policy (type ACE_ENV_ARG_PARAMETER); + return this->TAO_Stub::get_cached_policy (type ACE_ENV_ARG_PARAMETER); } + TAO_Stub * TAO_RT_Stub::set_policy_overrides (const CORBA::PolicyList & policies, CORBA::SetOverrideType set_add @@ -194,117 +193,11 @@ TAO_RT_Stub::set_policy_overrides (const CORBA::PolicyList & policies, #endif /* TAO_HAS_CORBA_MESSAGING */ CORBA::Policy * -TAO_RT_Stub::private_connection (void) -{ - CORBA::Policy *result = 0; - - // No need to lock, the stub only changes its policies at - // construction time... - if (this->policies_ != 0) - result = this->policies_->get_cached_policy (TAO_CACHED_POLICY_RT_PRIVATE_CONNECTION); - - // No need to lock, the object is in TSS storage.... - if (result == 0) - { - TAO_Policy_Current &policy_current = - this->orb_core_->policy_current (); - result = policy_current.get_cached_policy (TAO_CACHED_POLICY_RT_PRIVATE_CONNECTION); - } - - // @@ Must lock, but is is harder to implement than just modifying - // this call: the ORB does take a lock to modify the policy - // manager - if (result == 0) - { - TAO_Policy_Manager *policy_manager = - this->orb_core_->policy_manager (); - if (policy_manager != 0) - result = policy_manager->get_cached_policy (TAO_CACHED_POLICY_RT_PRIVATE_CONNECTION); - } - - if (result == 0) - result = this->orb_core_->get_default_policies ()->get_cached_policy (TAO_CACHED_POLICY_RT_PRIVATE_CONNECTION); - - return result; -} - -CORBA::Policy * -TAO_RT_Stub::client_protocol (void) -{ - CORBA::Policy *result = 0; - - // No need to lock, the stub only changes its policies at - // construction time... - if (this->policies_ != 0) - result = this->policies_->get_cached_policy (TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL); - - // No need to lock, the object is in TSS storage.... - if (result == 0) - { - TAO_Policy_Current &policy_current = - this->orb_core_->policy_current (); - result = policy_current.get_cached_policy (TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL); - } - - // @@ Must lock, but is is harder to implement than just modifying - // this call: the ORB does take a lock to modify the policy - // manager - if (result == 0) - { - TAO_Policy_Manager *policy_manager = - this->orb_core_->policy_manager (); - if (policy_manager != 0) - result = policy_manager->get_cached_policy (TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL); - } - - // No default is used for client priority policy (default creates - // conflict in case the policy is also set for the object on the - // server side). - - return result; -} - -CORBA::Policy * -TAO_RT_Stub::priority_banded_connection (void) -{ - CORBA::Policy *result = 0; - - // No need to lock, the stub only changes its policies at - // construction time... - if (this->policies_ != 0) - result = this->policies_->get_cached_policy (TAO_CACHED_POLICY_RT_PRIORITY_BANDED_CONNECTION); - - // No need to lock, the object is in TSS storage.... - if (result == 0) - { - TAO_Policy_Current &policy_current = - this->orb_core_->policy_current (); - result = policy_current.get_cached_policy (TAO_CACHED_POLICY_RT_PRIORITY_BANDED_CONNECTION); - } - - // @@ Must lock, but is is harder to implement than just modifying - // this call: the ORB does take a lock to modify the policy - // manager - if (result == 0) - { - TAO_Policy_Manager *policy_manager = - this->orb_core_->policy_manager (); - if (policy_manager != 0) - result = policy_manager->get_cached_policy (TAO_CACHED_POLICY_RT_PRIORITY_BANDED_CONNECTION); - } - - if (result == 0) - result = this->orb_core_->get_default_policies ()->get_cached_policy (TAO_CACHED_POLICY_RT_PRIORITY_BANDED_CONNECTION); - - return result; -} - -CORBA::Policy * TAO_RT_Stub::effective_priority_banded_connection (ACE_ENV_SINGLE_ARG_DECL) { // Get effective override. CORBA::Policy_var override = - this->priority_banded_connection (); + this->TAO_Stub::get_cached_policy (TAO_CACHED_POLICY_RT_PRIORITY_BANDED_CONNECTION); // Get the value from the ior. CORBA::Policy_var exposed = @@ -355,7 +248,7 @@ TAO_RT_Stub::effective_client_protocol (ACE_ENV_SINGLE_ARG_DECL) { // Get effective override. CORBA::Policy_var override = - this->client_protocol (); + this->TAO_Stub::get_cached_policy (TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL); // Get the value from the ior. CORBA::Policy_var exposed = diff --git a/TAO/tao/RTCORBA/RT_Stub.h b/TAO/tao/RTCORBA/RT_Stub.h index a6595e92b12..630680d53d3 100644 --- a/TAO/tao/RTCORBA/RT_Stub.h +++ b/TAO/tao/RTCORBA/RT_Stub.h @@ -47,7 +47,6 @@ class TAO_RTCORBA_Export TAO_RT_Stub : public TAO_Stub { public: - // -- Ctor/Dtor -- TAO_RT_Stub (const char *repository_id, const TAO_MProfile &profiles, TAO_ORB_Core *orb_core); @@ -65,19 +64,25 @@ public: CORBA::Policy_ptr get_policy (CORBA::PolicyType type ACE_ENV_ARG_DECL_WITH_DEFAULTS); + CORBA::Policy_ptr get_cached_policy (TAO_Cached_Policy_Type type + ACE_ENV_ARG_DECL_WITH_DEFAULTS); + TAO_Stub* set_policy_overrides (const CORBA::PolicyList & policies, + CORBA::SetOverrideType set_add + ACE_ENV_ARG_DECL_WITH_DEFAULTS); - CORBA::Policy_ptr get_client_policy (CORBA::PolicyType type - ACE_ENV_ARG_DECL_WITH_DEFAULTS); +#endif /* TAO_HAS_CORBA_MESSAGING */ +private: - virtual TAO_Stub* set_policy_overrides (const CORBA::PolicyList & policies, - CORBA::SetOverrideType set_add - ACE_ENV_ARG_DECL_WITH_DEFAULTS); + /// Helper method used to parse the policies. + void parse_policies (ACE_ENV_SINGLE_ARG_DECL); -#endif /* TAO_HAS_CORBA_MESSAGING */ + void exposed_priority_model (CORBA::Policy_ptr policy); - /// Creates a Stub Object. + void exposed_priority_banded_connection (CORBA::Policy_ptr policy); + + void exposed_client_protocol (CORBA::Policy_ptr policy); /// Returns the CORBA::Policy (which will be narrowed to be /// used as RTCORBA::PriorityModelPolicy) exported @@ -94,13 +99,6 @@ public: /// in object's IOR. CORBA::Policy_ptr exposed_client_protocol (ACE_ENV_SINGLE_ARG_DECL); - - CORBA::Policy *private_connection (void); - - CORBA::Policy *priority_banded_connection (void); - - CORBA::Policy *client_protocol (void); - // = Methods for obtaining effective policies. // // Effective policy is the one that would be used if a request @@ -108,25 +106,8 @@ public: // override for a given policy type, and then reconciling it with // the policy value exported in the Object's IOR. - CORBA::Policy * - effective_priority_banded_connection (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); - CORBA::Policy * - effective_client_protocol (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); - - - -private: - - /// Helper method used to parse the policies. - void parse_policies (ACE_ENV_SINGLE_ARG_DECL); - - void exposed_priority_model (CORBA::Policy_ptr policy); - - void exposed_priority_banded_connection (CORBA::Policy_ptr policy); - - void exposed_client_protocol (CORBA::Policy_ptr policy); - -private: + CORBA::Policy *effective_priority_banded_connection (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); + CORBA::Policy *effective_client_protocol (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); // The following attribute are used to cache // the different kind of policies and avoid to @@ -141,8 +122,6 @@ private: CORBA::Boolean are_policies_parsed_; - - private: // = Disallow copy constructor and assignment operator. ACE_UNIMPLEMENTED_FUNC (TAO_RT_Stub (const TAO_RT_Stub &)) diff --git a/TAO/tao/RTCORBA/diffs/RTCORBA.diff b/TAO/tao/RTCORBA/diffs/RTCORBA.diff index 489856dc1ca..711f4cc1fcd 100644 --- a/TAO/tao/RTCORBA/diffs/RTCORBA.diff +++ b/TAO/tao/RTCORBA/diffs/RTCORBA.diff @@ -1,5 +1,6 @@ ---- orig/RTCORBAC.h 2004-09-16 12:52:02.885009600 +0200 -+++ RTCORBAC.h 2004-09-16 12:36:01.362408000 +0200 +// -*- C++ -*- +--- orig/RTCORBAC.h 2004-09-16 12:52:02.885009600 +0200 ++++ RTCORBAC.h 2004-09-16 12:36:01.362408000 +0200 @@ -36,12 +36,18 @@ #include "ace/config-all.h" @@ -46,10 +47,10 @@ protected: // Abstract or local interface only. ProtocolProperties (void); ---- orig/RTCORBAC.cpp 2004-09-16 12:52:02.885009600 +0200 -+++ RTCORBAC.cpp 2004-09-16 12:36:36.643139200 +0200 +--- orig/RTCORBAC.cpp 2004-09-16 12:52:02.885009600 +0200 ++++ RTCORBAC.cpp 2004-09-16 12:36:36.643139200 +0200 @@ -29,7 +29,7 @@ - // be\be_codegen.cpp:303 + // be/be_codegen.cpp:303 -#include "RTCORBAC.h" @@ -57,10 +58,10 @@ #include "tao/CDR.h" #include "tao/Typecode.h" #include "tao/Any_Impl_T.h" -@@ -57,7 +57,23 @@ +@@ -56,6 +56,22 @@ + { } - +////////////////////////////////////////////////////// +// CDR Encoding Support hand crafted + @@ -69,7 +70,7 @@ +{ + return 1; +} - // TAO_IDL - Generated from ++// TAO_IDL - Generated from +// be/be_visitor_arg_traits.cpp:60 + +CORBA::Boolean @@ -77,7 +78,6 @@ +{ + return 1; +} -+ - // be\be_visitor_typecode/typecode_defn.cpp:290 - static const CORBA::Long _oc_RTCORBA_NativePriority[] = + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_defn.cpp:290 diff --git a/TAO/tao/RTPortableServer/RT_POA.cpp b/TAO/tao/RTPortableServer/RT_POA.cpp index a52d3fd0cac..4118aa8a0ab 100644 --- a/TAO/tao/RTPortableServer/RT_POA.cpp +++ b/TAO/tao/RTPortableServer/RT_POA.cpp @@ -923,25 +923,6 @@ TAO_RT_POA::id (ACE_ENV_SINGLE_ARG_DECL) return this->TAO_POA::id (ACE_ENV_SINGLE_ARG_PARAMETER); } -CORBA::Policy * -TAO_RT_POA::server_protocol (void) -{ - CORBA::Policy *result = - this->policies ().get_cached_policy (TAO_CACHED_POLICY_RT_SERVER_PROTOCOL); - - if (result == 0) - { - TAO_Policy_Manager *policy_manager = - this->orb_core_.policy_manager (); - - if (policy_manager != 0) - result = - policy_manager->get_cached_policy (TAO_CACHED_POLICY_RT_SERVER_PROTOCOL); - } - - return result; -} - #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) diff --git a/TAO/tao/RTPortableServer/RT_POA.h b/TAO/tao/RTPortableServer/RT_POA.h index 9fbb2603074..197857215b9 100644 --- a/TAO/tao/RTPortableServer/RT_POA.h +++ b/TAO/tao/RTPortableServer/RT_POA.h @@ -269,8 +269,6 @@ public: void *thread_pool (void) const; - CORBA::Policy *server_protocol (void); - protected: /// Template method for creating new POA's of this type. diff --git a/TAO/tao/RTPortableServer/RT_Servant_Dispatcher.cpp b/TAO/tao/RTPortableServer/RT_Servant_Dispatcher.cpp index 80db1f6b779..1a35d927138 100644 --- a/TAO/tao/RTPortableServer/RT_Servant_Dispatcher.cpp +++ b/TAO/tao/RTPortableServer/RT_Servant_Dispatcher.cpp @@ -77,23 +77,7 @@ TAO_RT_Servant_Dispatcher::pre_invoke_remote_request ( // Remember current thread's priority. TAO_Protocols_Hooks *tph = - poa.orb_core ().get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK; - - if (req.transport ()->tag () == IOP::TAG_INTERNET_IOP) - { - CORBA::Policy_var policy = poa.server_protocol (); - - int result = - tph->update_server_protocol_properties ( - policy.in (), - req.transport (), - "iiop"); - - if (result != 0) - ACE_ERROR((LM_ERROR, - "Error in getting the effective protocol properties\n")); - } + poa.orb_core ().get_protocols_hooks (); const char *priority_model; RTCORBA::Priority target_priority = TAO_INVALID_PRIORITY; @@ -265,6 +249,20 @@ TAO_RT_Servant_Dispatcher::pre_invoke_remote_request ( } } } + + CORBA::Policy_var policy = + poa.policies ().get_cached_policy (TAO_CACHED_POLICY_RT_SERVER_PROTOCOL); + + CORBA::Boolean set_server_network_priority = + tph->set_server_network_priority (req.transport ()->tag (), + policy.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + TAO_Connection_Handler *connection_handler = + req.transport ()->connection_handler (); + + connection_handler->set_dscp_codepoint (set_server_network_priority); } void @@ -306,8 +304,7 @@ TAO_RT_Servant_Dispatcher::pre_invoke_collocated_request (TAO_POA &poa, // Remember current thread's priority. TAO_Protocols_Hooks *tph = - poa.orb_core ().get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK; + poa.orb_core ().get_protocols_hooks (); if (tph->get_thread_CORBA_and_native_priority (pre_invoke_state.original_CORBA_priority_, pre_invoke_state.original_native_priority_ @@ -349,8 +346,7 @@ TAO_RT_Servant_Dispatcher::post_invoke (TAO_POA &poa, // Reset the priority of the current thread back to its original // value. TAO_Protocols_Hooks *tph = - poa.orb_core ().get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; + poa.orb_core ().get_protocols_hooks (); if (tph->set_thread_native_priority ( pre_invoke_state.original_native_priority_ diff --git a/TAO/tao/Remote_Invocation.cpp b/TAO/tao/Remote_Invocation.cpp index 541262b7ff3..d3e8c70f688 100644 --- a/TAO/tao/Remote_Invocation.cpp +++ b/TAO/tao/Remote_Invocation.cpp @@ -4,8 +4,10 @@ #include "Profile_Transport_Resolver.h" #include "Stub.h" #include "Transport.h" +#include "Connection_Handler.h" #include "operation_details.h" #include "ORB_Core.h" +#include "Protocols_Hooks.h" #include "debug.h" ACE_RCSID (tao, @@ -137,6 +139,20 @@ namespace TAO ACE_Time_Value *max_wait_time ACE_ENV_ARG_DECL) { + TAO_Protocols_Hooks *tph = + this->resolver_.stub ()->orb_core ()->get_protocols_hooks (); + + CORBA::Boolean set_client_network_priority = + tph->set_client_network_priority (this->resolver_.transport ()->tag (), + this->resolver_.stub () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + TAO_Connection_Handler *connection_handler = + this->resolver_.transport ()->connection_handler (); + + connection_handler->set_dscp_codepoint (set_client_network_priority); + const int retval = this->resolver_.transport ()->send_request ( this->resolver_.stub (), diff --git a/TAO/tao/Strategies/DIOP_Acceptor.cpp b/TAO/tao/Strategies/DIOP_Acceptor.cpp index f8312d1acfe..e0243d0caf1 100644 --- a/TAO/tao/Strategies/DIOP_Acceptor.cpp +++ b/TAO/tao/Strategies/DIOP_Acceptor.cpp @@ -237,9 +237,6 @@ TAO_DIOP_Acceptor::open (TAO_ORB_Core *orb_core, { this->orb_core_ = orb_core; - if (this->init_tcp_properties () != 0) - return -1; - if (this->hosts_ != 0) { // The hostname cache has already been set! @@ -351,9 +348,6 @@ TAO_DIOP_Acceptor::open_default (TAO_ORB_Core *orb_core, { this->orb_core_ = orb_core; - if (this->init_tcp_properties () != 0) - return -1; - if (this->hosts_ != 0) { // The hostname cache has already been set! @@ -399,8 +393,7 @@ TAO_DIOP_Acceptor::open_i (const ACE_INET_Addr& addr, { ACE_NEW_RETURN (this->connection_handler_, TAO_DIOP_Connection_Handler (this->orb_core_, - this->lite_flag_, - 0 /* TAO_DIOP_Properties */), + this->lite_flag_), -1); this->connection_handler_->local_addr (addr); @@ -744,11 +737,4 @@ TAO_DIOP_Acceptor::parse_options (const char *str) return 0; } -int -TAO_DIOP_Acceptor::init_tcp_properties (void) -{ - // @@ Michael: We use UDP, so we do not set TCP settings. - return 0; -} - #endif /* TAO_HAS_DIOP && TAO_HAS_DIOP != 0 */ diff --git a/TAO/tao/Strategies/DIOP_Acceptor.h b/TAO/tao/Strategies/DIOP_Acceptor.h index 5a5368eab3a..4ff200dc543 100644 --- a/TAO/tao/Strategies/DIOP_Acceptor.h +++ b/TAO/tao/Strategies/DIOP_Acceptor.h @@ -127,10 +127,6 @@ protected: /// Parse protocol specific options. virtual int parse_options (const char *options); - /// Obtain tcp properties that must be used by this acceptor, i.e., - /// initialize <tcp_properties_>. - int init_tcp_properties (void); - /// Helper method to add a new profile to the mprofile for /// each endpoint. int create_new_profile (const TAO::ObjectKey &object_key, @@ -171,10 +167,6 @@ protected: /// ORB Core. TAO_ORB_Core *orb_core_; - /// TCP configuration properties to be used for all - /// connections opened by this acceptor. - TAO_DIOP_Properties tcp_properties_; - /// Should we use GIOP lite?? CORBA::Boolean lite_flag_; diff --git a/TAO/tao/Strategies/DIOP_Connection_Handler.cpp b/TAO/tao/Strategies/DIOP_Connection_Handler.cpp index 8854b94696e..e6a70f10bcf 100644 --- a/TAO/tao/Strategies/DIOP_Connection_Handler.cpp +++ b/TAO/tao/Strategies/DIOP_Connection_Handler.cpp @@ -13,6 +13,7 @@ #include "tao/Transport_Cache_Manager.h" #include "tao/Thread_Lane_Resources.h" #include "tao/Base_Transport_Property.h" +#include "tao/Protocols_Hooks.h" #include "tao/Resume_Handle.h" #include "DIOP_Transport.h" @@ -22,12 +23,15 @@ # include "DIOP_Connection_Handler.i" #endif /* ! __ACE_INLINE__ */ +#include "ace/os_include/netinet/os_tcp.h" +#include "ace/os_include/os_netdb.h" + ACE_RCSID(tao, DIOP_Connect, "$Id$") TAO_DIOP_Connection_Handler::TAO_DIOP_Connection_Handler (ACE_Thread_Manager *t) : TAO_DIOP_SVC_HANDLER (t, 0 , 0), TAO_Connection_Handler (0), - tcp_properties_ (0) + dscp_codepoint_ (IPDSFIELD_DSCP_DEFAULT << 2) { // This constructor should *never* get called, it is just here to // make the compiler happy: the default implementation of the @@ -39,16 +43,14 @@ TAO_DIOP_Connection_Handler::TAO_DIOP_Connection_Handler (ACE_Thread_Manager *t) TAO_DIOP_Connection_Handler::TAO_DIOP_Connection_Handler (TAO_ORB_Core *orb_core, - CORBA::Boolean flag, - void *arg) + CORBA::Boolean flag) : TAO_DIOP_SVC_HANDLER (orb_core->thr_mgr (), 0, 0), TAO_Connection_Handler (orb_core), - tcp_properties_ (ACE_static_cast - (TAO_DIOP_Properties *, arg)) + dscp_codepoint_ (IPDSFIELD_DSCP_DEFAULT << 2) { TAO_DIOP_Transport* specific_transport = 0; - ACE_NEW(specific_transport, - TAO_DIOP_Transport(this, orb_core, flag)); + ACE_NEW (specific_transport, + TAO_DIOP_Transport(this, orb_core, flag)); // store this pointer (indirectly increment ref count) this->transport (specific_transport); @@ -113,9 +115,24 @@ TAO_DIOP_Connection_Handler::open_handler (void *v) int TAO_DIOP_Connection_Handler::open (void*) { + // Currently, the DIOP properties are not used. This code is here + // for consistency with other protocols. + TAO_DIOP_Protocol_Properties protocol_properties; + + TAO_Protocols_Hooks *tph = + this->orb_core ()->get_protocols_hooks (); + + // @@ fix me + int client = 0; + + if (client) + tph->client_protocol_properties_at_orb_level (protocol_properties); + else + tph->server_protocol_properties_at_orb_level (protocol_properties); + this->udp_socket_.open (this->local_addr_); - if(TAO_debug_level > 5) + if (TAO_debug_level > 5) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\nTAO (%P|%t) TAO_DIOP_Connection_Handler::open -") @@ -218,7 +235,49 @@ TAO_DIOP_Connection_Handler::close (u_long) int TAO_DIOP_Connection_Handler::release_os_resources (void) { - return this->peer().close (); + return this->peer ().close (); +} + +int +TAO_DIOP_Connection_Handler::set_dscp_codepoint (CORBA::Boolean set_network_priority) +{ + int tos = IPDSFIELD_DSCP_DEFAULT << 2; + + if (set_network_priority) + { + TAO_Protocols_Hooks *tph = + this->orb_core ()->get_protocols_hooks (); + + CORBA::Long codepoint = + tph->get_dscp_codepoint (); + + tos = (int)(codepoint) << 2; + } + + if (tos != this->dscp_codepoint_) + { + int result = this->dgram ().set_option (IPPROTO_IP, + IP_TOS, + (int *) &tos , + (int) sizeof (tos)); + + if (TAO_debug_level) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - DIOP_Connection_Handler::" + "set_dscp_codepoint -> dscp: %x; result: %d; %s\n", + tos, + result, + result == -1 ? "try running as superuser" : "")); + } + + // On successful setting of TOS field. + if (result == 0) + this->dscp_codepoint_ = tos; + + } + + return 0; } // **************************************************************** diff --git a/TAO/tao/Strategies/DIOP_Connection_Handler.h b/TAO/tao/Strategies/DIOP_Connection_Handler.h index 064b40fe48e..ea8de503f81 100644 --- a/TAO/tao/Strategies/DIOP_Connection_Handler.h +++ b/TAO/tao/Strategies/DIOP_Connection_Handler.h @@ -39,27 +39,6 @@ class TAO_Pluggable_Messaging; // **************************************************************** /** - * @class TAO_DIOP_Properties - * - * @brief TCP protocol properties specification for a set of - * connections. - * - */ - -class TAO_Strategies_Export TAO_DIOP_Properties -{ - -public: - int send_buffer_size; - int recv_buffer_size; - int no_delay; -}; - - - -// **************************************************************** - -/** * @class TAO_DIOP_Connection_Handler * * @brief Handles requests on a single connection. @@ -78,12 +57,9 @@ public: TAO_DIOP_Connection_Handler (ACE_Thread_Manager* t = 0); - /// Constructor. <arg> parameter is used by the Acceptor to pass the - /// protocol configuration properties for this connection. + /// Constructor. TAO_DIOP_Connection_Handler (TAO_ORB_Core *orb_core, - CORBA::Boolean flag, - void *arg); - + CORBA::Boolean flag); /// Destructor. ~TAO_DIOP_Connection_Handler (void); @@ -151,6 +127,9 @@ public: //@} // DIOP Additions - End + /// Set Diff-Serv codepoint on outgoing packets. + int set_dscp_codepoint (CORBA::Boolean set_network_priority); + protected: //@{ @@ -177,8 +156,8 @@ protected: // DIOP Additions - End private: - /// TCP configuration for this connection. - TAO_DIOP_Properties *tcp_properties_; + /// Stores the type of service value. + int dscp_codepoint_; }; #if defined (__ACE_INLINE__) diff --git a/TAO/tao/Strategies/DIOP_Connector.cpp b/TAO/tao/Strategies/DIOP_Connector.cpp index a082ce439ed..9729b7f68e9 100644 --- a/TAO/tao/Strategies/DIOP_Connector.cpp +++ b/TAO/tao/Strategies/DIOP_Connector.cpp @@ -134,8 +134,7 @@ TAO_DIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *, TAO_DIOP_Connection_Handler *svc_handler_i = 0; ACE_NEW_RETURN (svc_handler_i, TAO_DIOP_Connection_Handler (this->orb_core (), - this->lite_flag_, - 0 /* TAO_DIOP_Properties */), + this->lite_flag_), 0); svc_handler_i->local_addr (ACE_sap_any_cast (ACE_INET_Addr &)); @@ -235,13 +234,6 @@ TAO_DIOP_Connector::object_key_delimiter (void) const return TAO_DIOP_Profile::object_key_delimiter_; } -int -TAO_DIOP_Connector::init_tcp_properties (void) -{ - // @@ Michael: We have not TCP, so we have no TCP properties. - return 0; -} - TAO_DIOP_Endpoint * TAO_DIOP_Connector::remote_endpoint (TAO_Endpoint *endpoint) { diff --git a/TAO/tao/Strategies/DIOP_Connector.h b/TAO/tao/Strategies/DIOP_Connector.h index 389875fa03a..5cec9dbd0c8 100644 --- a/TAO/tao/Strategies/DIOP_Connector.h +++ b/TAO/tao/Strategies/DIOP_Connector.h @@ -85,19 +85,11 @@ protected: virtual TAO_Profile * make_profile (ACE_ENV_SINGLE_ARG_DECL); //@} - /// Obtain tcp properties that must be used by this connector, i.e., - /// initialize <tcp_properties_>. - int init_tcp_properties (void); - /// Cancel the passed cvs handler from the connector int cancel_svc_handler (TAO_Connection_Handler * svc_handler); protected: - /// TCP configuration properties to be used for all - /// connections established by this connector. - TAO_DIOP_Properties tcp_properties_; - /// Do we need to use a GIOP_Lite for sending messages? CORBA::Boolean lite_flag_; diff --git a/TAO/tao/Strategies/DIOP_Transport.cpp b/TAO/tao/Strategies/DIOP_Transport.cpp index 1887f9e3993..f10c2eb1c80 100644 --- a/TAO/tao/Strategies/DIOP_Transport.cpp +++ b/TAO/tao/Strategies/DIOP_Transport.cpp @@ -260,6 +260,7 @@ TAO_DIOP_Transport::send_request (TAO_Stub *stub, max_wait_time) == -1) return -1; + this->first_request_sent(); return 0; @@ -299,7 +300,29 @@ TAO_DIOP_Transport::send_message (TAO_OutputCDR &stream, return 1; } +int +TAO_DIOP_Transport::send_message_shared (TAO_Stub *stub, + int message_semantics, + const ACE_Message_Block *message_block, + ACE_Time_Value *max_wait_time) +{ + int result; + + { + ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->handler_lock_, -1); + + result = + this->send_message_shared_i (stub, message_semantics, + message_block, max_wait_time); + } + if (result == -1) + { + this->close_connection (); + } + + return result; +} int TAO_DIOP_Transport::messaging_init (CORBA::Octet major, diff --git a/TAO/tao/Strategies/DIOP_Transport.h b/TAO/tao/Strategies/DIOP_Transport.h index e19b75a623f..423b23a9317 100644 --- a/TAO/tao/Strategies/DIOP_Transport.h +++ b/TAO/tao/Strategies/DIOP_Transport.h @@ -87,6 +87,10 @@ protected: size_t len, const ACE_Time_Value *s = 0); + virtual int send_message_shared (TAO_Stub *stub, + int message_semantics, + const ACE_Message_Block *message_block, + ACE_Time_Value *max_wait_time); virtual int register_handler (void); diff --git a/TAO/tao/Strategies/SCIOP_Acceptor.cpp b/TAO/tao/Strategies/SCIOP_Acceptor.cpp index a32a631e276..8ebda1efd8c 100644 --- a/TAO/tao/Strategies/SCIOP_Acceptor.cpp +++ b/TAO/tao/Strategies/SCIOP_Acceptor.cpp @@ -108,8 +108,8 @@ TAO_SCIOP_Acceptor::create_profile (const TAO::ObjectKey &object_key, int TAO_SCIOP_Acceptor::create_new_profile (const TAO::ObjectKey &object_key, - TAO_MProfile &mprofile, - CORBA::Short priority) + TAO_MProfile &mprofile, + CORBA::Short priority) { // Adding this->endpoint_count_ to the TAO_MProfile. int count = mprofile.profile_count (); @@ -149,8 +149,8 @@ TAO_SCIOP_Acceptor::create_new_profile (const TAO::ObjectKey &object_key, int TAO_SCIOP_Acceptor::create_shared_profile (const TAO::ObjectKey &object_key, - TAO_MProfile &mprofile, - CORBA::Short priority) + TAO_MProfile &mprofile, + CORBA::Short priority) { CORBA::ULong index = 0; TAO_SCIOP_Profile *sciop_profile = 0; @@ -245,9 +245,6 @@ TAO_SCIOP_Acceptor::open (TAO_ORB_Core *orb_core, this->orb_core_ = orb_core; - if (this->init_tcp_properties () != 0) - return -1; - if (this->hosts_ != 0) { // The hostname cache has already been set! @@ -485,9 +482,6 @@ TAO_SCIOP_Acceptor::open_default (TAO_ORB_Core *orb_core, { this->orb_core_ = orb_core; - if (this->init_tcp_properties () != 0) - return -1; - if (this->hosts_ != 0) { // The hostname cache has already been set! @@ -531,7 +525,6 @@ TAO_SCIOP_Acceptor::open_i (const ACE_Multihomed_INET_Addr& addr, { ACE_NEW_RETURN (this->creation_strategy_, TAO_SCIOP_CREATION_STRATEGY (this->orb_core_, - &(this->tcp_properties_), this->lite_flag_), -1); @@ -1061,71 +1054,4 @@ TAO_SCIOP_Acceptor::parse_options (const char *str) return 0; } -int -TAO_SCIOP_Acceptor::init_tcp_properties (void) -{ - // @@ Currently (in the code below), we obtain protocol properties from - // ORB-level ServerProtocol, even though the policy may - // have been overridden on POA level. That's because currently all - // endpoints (acceptors) are global. Once endpoints become per POA, - // the code below will have to be changed to look at the POA-level - // ServerProtocol policy first. - - // @@ Later we may want to factor some of the code below - // among different protocols and place it into TAO_Acceptor, for - // example. - - // ServerProtocolProperties policy controls protocols configuration. - // Look for protocol properties in the effective ServerProtocolPolicy. - - ACE_DECLARE_NEW_CORBA_ENV; - - // Initialize the parameters to their defaults. If RTCORBA is loaded, - // the server_protocols_hook will override any of the values if they - // have been set by a ServerProtocolProperties policy. - - int send_buffer_size = this->orb_core_->orb_params ()->sock_sndbuf_size (); - int recv_buffer_size = this->orb_core_->orb_params ()->sock_rcvbuf_size (); - int no_delay = this->orb_core_->orb_params ()->nodelay (); - int enable_network_priority = 0; - - TAO_Protocols_Hooks *tph = this->orb_core_->get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK_RETURN (-1); - - if (tph != 0) - { - const char protocol [] = "sciop"; - const char *protocol_type = protocol; - - int hook_return = - tph->call_server_protocols_hook (send_buffer_size, - recv_buffer_size, - no_delay, - enable_network_priority, - protocol_type); - - if (hook_return == -1) - return -1; - } - - this->tcp_properties_.send_buffer_size = - send_buffer_size; - this->tcp_properties_.recv_buffer_size = - recv_buffer_size; - this->tcp_properties_.no_delay = - no_delay; - this->tcp_properties_.enable_network_priority = - enable_network_priority; - - - // @@ NOTE. RTCORBA treats a combination of transport+messaging - // as a single protocol. Keep this in mind for when we adopt - // RTCORBA approach to protocols configuration for nonRT use. In - // particular, what are the semantics of independent variation of - // messaging and transport layers, when one transport appears in - // combination with several messaging protocols, for example. - - return 0; -} - #endif /* TAO_HAS_SCIOP == 1 */ diff --git a/TAO/tao/Strategies/SCIOP_Acceptor.h b/TAO/tao/Strategies/SCIOP_Acceptor.h index a706df851a4..a62f9e9d395 100644 --- a/TAO/tao/Strategies/SCIOP_Acceptor.h +++ b/TAO/tao/Strategies/SCIOP_Acceptor.h @@ -203,10 +203,6 @@ protected: /// ORB Core. TAO_ORB_Core *orb_core_; - /// TCP configuration properties to be used for all - /// connections opened by this acceptor. - TAO_SCIOP_Properties tcp_properties_; - /// Should we use GIOP lite?? CORBA::Boolean lite_flag_; diff --git a/TAO/tao/Strategies/SCIOP_Connection_Handler.cpp b/TAO/tao/Strategies/SCIOP_Connection_Handler.cpp index 60d586cef75..e1e615bdd39 100644 --- a/TAO/tao/Strategies/SCIOP_Connection_Handler.cpp +++ b/TAO/tao/Strategies/SCIOP_Connection_Handler.cpp @@ -41,7 +41,7 @@ ACE_RCSID (tao, TAO_SCIOP_Connection_Handler::TAO_SCIOP_Connection_Handler (ACE_Thread_Manager *t) : TAO_SCIOP_SVC_HANDLER (t, 0 , 0), TAO_Connection_Handler (0), - dscp_codepoint_ (0) + dscp_codepoint_ (IPDSFIELD_DSCP_DEFAULT << 2) { // This constructor should *never* get called, it is just here to // make the compiler happy: the default implementation of the @@ -53,12 +53,10 @@ TAO_SCIOP_Connection_Handler::TAO_SCIOP_Connection_Handler (ACE_Thread_Manager * TAO_SCIOP_Connection_Handler::TAO_SCIOP_Connection_Handler (TAO_ORB_Core *orb_core, - CORBA::Boolean flag, - void *arg) + CORBA::Boolean flag) : TAO_SCIOP_SVC_HANDLER (orb_core->thr_mgr (), 0, 0), TAO_Connection_Handler (orb_core), - tcp_properties_ (*(ACE_static_cast - (TAO_SCIOP_Properties *, arg))) + dscp_codepoint_ (IPDSFIELD_DSCP_DEFAULT << 2) { TAO_SCIOP_Transport* specific_transport = 0; ACE_NEW (specific_transport, @@ -68,13 +66,10 @@ TAO_SCIOP_Connection_Handler::TAO_SCIOP_Connection_Handler (TAO_ORB_Core *orb_co this->transport (specific_transport); } -TAO_SCIOP_Connection_Handler::TAO_SCIOP_Connection_Handler (TAO_ORB_Core *orb_core, - void *arg) +TAO_SCIOP_Connection_Handler::TAO_SCIOP_Connection_Handler (TAO_ORB_Core *orb_core) : TAO_SCIOP_SVC_HANDLER (orb_core->thr_mgr (), 0, 0), TAO_Connection_Handler (orb_core), - tcp_properties_ (*(ACE_static_cast - (TAO_SCIOP_Properties *, arg))), - dscp_codepoint_ (0) + dscp_codepoint_ (IPDSFIELD_DSCP_DEFAULT << 2) { } @@ -93,16 +88,37 @@ TAO_SCIOP_Connection_Handler::open_handler (void *v) int TAO_SCIOP_Connection_Handler::open (void*) { + TAO_SCIOP_Protocol_Properties protocol_properties; + + // Initialize values from ORB params. + protocol_properties.send_buffer_size_ = + this->orb_core ()->orb_params ()->sock_sndbuf_size (); + protocol_properties.recv_buffer_size_ = + this->orb_core ()->orb_params ()->sock_rcvbuf_size (); + protocol_properties.no_delay_ = + this->orb_core ()->orb_params ()->nodelay (); + + TAO_Protocols_Hooks *tph = + this->orb_core ()->get_protocols_hooks (); + + // @@ fix me + int client = 0; + + if (client) + tph->client_protocol_properties_at_orb_level (protocol_properties); + else + tph->server_protocol_properties_at_orb_level (protocol_properties); + if (this->set_socket_option (this->peer (), - this->tcp_properties_.send_buffer_size, - this->tcp_properties_.recv_buffer_size) == -1) + protocol_properties.send_buffer_size_, + protocol_properties.recv_buffer_size_) == -1) return -1; #if !defined (ACE_LACKS_TCP_NODELAY) if (this->peer ().set_option (IPPROTO_SCTP, SCTP_NODELAY, - (void *) &tcp_properties_.no_delay, + (void *) &protocol_properties.no_delay_, sizeof (int)) == -1) return -1; #endif /* ! ACE_LACKS_TCP_NODELAY */ @@ -303,111 +319,43 @@ TAO_SCIOP_Connection_Handler::process_listen_point_list ( return 0; } -void -TAO_SCIOP_Connection_Handler::update_protocol_properties ( - int send_buffer_size, - int recv_buffer_size, - int no_delay, - int enable_network_priority) - /* @todo Properties should be those of SCIOP ilk. - TimeBase::TimeT rto_initial, - TimeBase::TimeT rto_min, - TimeBase::TimeT rto_max, - CORBA::Float rto_alpha, - CORBA::Float rto_beta, - TimeBase::TimeT valid_cookie_life, - CORBA::Short association_max_retrans, - CORBA::Short path_max_retrans, - CORBA::Short max_init_retransmits, - TimeBase::TimeT hb_interval, - CORBA::Short association_max_retrans) - */ -{ - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - "TAO_SCIOP_Connection_Handler::update_protocol_properties\n" - "enable_network_priority = %d\n", - enable_network_priority)); - - if (this->tcp_properties_.send_buffer_size != send_buffer_size) - this->tcp_properties_.send_buffer_size = send_buffer_size; - - if (this->tcp_properties_.recv_buffer_size != recv_buffer_size) - this->tcp_properties_.recv_buffer_size = recv_buffer_size; - - if (this->tcp_properties_.no_delay != no_delay) - this->tcp_properties_.no_delay = no_delay; - - if (this->tcp_properties_.enable_network_priority != enable_network_priority) - this->tcp_properties_.enable_network_priority = enable_network_priority; - -} - int -TAO_SCIOP_Connection_Handler::enable_network_priority (void) +TAO_SCIOP_Connection_Handler::set_dscp_codepoint (CORBA::Boolean set_network_priority) { - return this->tcp_properties_.enable_network_priority; -} + int tos = IPDSFIELD_DSCP_DEFAULT << 2; -int -TAO_SCIOP_Connection_Handler::set_dscp_codepoint (void) -{ - int tos; - if (this->enable_network_priority ()) + if (set_network_priority) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - TAO_Protocols_Hooks *tph = - this->orb_core ()->get_protocols_hooks ( - ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (tph != 0) - { - CORBA::Long codepoint = - tph->get_dscp_codepoint (); - - tos = (int)(codepoint) << 2; - } - } - ACE_CATCHANY - { - if (TAO_debug_level > 0) - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "TAO_SCIOP_Connection_Handler::" - "set_dscp_codepoint - " - "get_protocol_hooks"); - - return -1; - } - ACE_ENDTRY; - ACE_CHECK_RETURN (-1); + TAO_Protocols_Hooks *tph = + this->orb_core ()->get_protocols_hooks (); + + CORBA::Long codepoint = + tph->get_dscp_codepoint (); + + tos = (int)(codepoint) << 2; } - else - tos = IPDSFIELD_DSCP_DEFAULT << 2; if (tos != this->dscp_codepoint_) { - int ret = this->peer ().set_option (IPPROTO_SCTP, - IP_TOS, - (int *) &tos , - (int) sizeof (tos)); - - if(TAO_debug_level) + int result = this->peer ().set_option (IPPROTO_IP, + IP_TOS, + (int *) &tos , + (int) sizeof (tos)); + + if (TAO_debug_level) { ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - SCIOP_Connection_Handler::" - "set_dscp_codepoint, failed to set Diffserv" - " codepoint - try running as superuser\n")); - - ACE_DEBUG((LM_DEBUG, - "TAO (%P|%t) - SCIOP_Connection_Handler::" - "set_dscp_codepoint, set tos: ret: %d %x\n", - ret, tos)); + "set_dscp_codepoint -> dscp: %x; result: %d; %s\n", + tos, + result, + result == -1 ? "try running as superuser" : "")); } + + // On successful setting of TOS field. + if (result == 0) + this->dscp_codepoint_ = tos; - this->dscp_codepoint_ = tos; } return 0; diff --git a/TAO/tao/Strategies/SCIOP_Connection_Handler.h b/TAO/tao/Strategies/SCIOP_Connection_Handler.h index 7af9afeb349..f37b40d05e2 100644 --- a/TAO/tao/Strategies/SCIOP_Connection_Handler.h +++ b/TAO/tao/Strategies/SCIOP_Connection_Handler.h @@ -50,44 +50,6 @@ class TAO_Pluggable_Messaging; // **************************************************************** /** - * @class TAO_SCIOP_Properties - * - * @brief TCP protocol properties specification for a set of - * connections. - * - */ - -#define IPDSFIELD_DSCP_DEFAULT 0x00 - -class TAO_Strategies_Export TAO_SCIOP_Properties -{ - -public: - int send_buffer_size; - int recv_buffer_size; - int no_delay; - int enable_network_priority; - - /* - TimeBase::TimeT rto_initial; - TimeBase::TimeT rto_min; - TimeBase::TimeT rto_max; - float rto_alpha; - float rto_beta; - TimeBase::TimeT valid_cookie_life; - short associaion_max_retrans; - short path_max_retrans; - short max_init_retransmits; - TimeBase::TimeT hb_interval; - short desired_streams; - */ -}; - - - -// **************************************************************** - -/** * @class TAO_SCIOP_Connection_Handler * * @brief Handles requests on a single connection. @@ -106,12 +68,9 @@ public: TAO_SCIOP_Connection_Handler (ACE_Thread_Manager* t = 0); - /// Constructor. <arg> parameter is used by the Acceptor to pass the - /// protocol configuration properties for this connection. + /// Constructor. TAO_SCIOP_Connection_Handler (TAO_ORB_Core *orb_core, - CORBA::Boolean flag, - void *arg); - + CORBA::Boolean flag); /// Destructor. ~TAO_SCIOP_Connection_Handler (void); @@ -149,20 +108,8 @@ public: /// Process the <listen_list> int process_listen_point_list (IIOP::ListenPointList &listen_list); - ///Check if network priority needs to be enabled - int enable_network_priority (void); - - ///Set the Diff-Serv codepoint if the Policy dicates the setting of Network Priority - int set_dscp_codepoint (void); - - int set_dscp_codepoint (int tos); - - /// Update the tcp properties of the hanlder to the most recent - /// properties set after the last invocation - virtual void update_protocol_properties (int send_buffer_size, - int recv_buffer_size, - int no_delay, - int enable_network_priority); + /// Set Diff-Serv codepoint on outgoing packets. + int set_dscp_codepoint (CORBA::Boolean set_network_priority); protected: @@ -174,8 +121,7 @@ protected: * constructor just initializes its base class and sets all of its * contents to the default value, if any */ - TAO_SCIOP_Connection_Handler (TAO_ORB_Core *orb_core, - void *arg); + TAO_SCIOP_Connection_Handler (TAO_ORB_Core *orb_core); //@{ /** @@ -186,8 +132,6 @@ protected: //@} private: - /// TCP configuration for this connection. - TAO_SCIOP_Properties tcp_properties_; /// Stores the type of service value. int dscp_codepoint_; diff --git a/TAO/tao/Strategies/SCIOP_Connector.cpp b/TAO/tao/Strategies/SCIOP_Connector.cpp index 2911873f0cd..3b49f84ae57 100644 --- a/TAO/tao/Strategies/SCIOP_Connector.cpp +++ b/TAO/tao/Strategies/SCIOP_Connector.cpp @@ -85,9 +85,6 @@ TAO_SCIOP_Connector::open (TAO_ORB_Core *orb_core) if (this->create_connect_strategy () == -1) return -1; - if (this->init_tcp_properties () != 0) - return -1; - /// Our connect creation strategy TAO_SCIOP_CONNECT_CREATION_STRATEGY *connect_creation_strategy = 0; @@ -95,7 +92,6 @@ TAO_SCIOP_Connector::open (TAO_ORB_Core *orb_core) TAO_SCIOP_CONNECT_CREATION_STRATEGY (orb_core->thr_mgr (), orb_core, - &(this->tcp_properties_), this->lite_flag_), -1); @@ -216,9 +212,12 @@ TAO_SCIOP_Connector::make_connection_i (TAO::Profile_Transport_Resolver *r, remote_address.get_ip_address())) return 0; + ACE_Multihomed_INET_Addr local_address; + int result = this->base_connector_.connect (svc_handler, multihomed, - synch_options); + synch_options, + local_address); // This call creates the service handler and bumps the #REFCOUNT# up // one extra. There are three possibilities: (a) connection @@ -413,61 +412,6 @@ TAO_SCIOP_Connector::object_key_delimiter (void) const return TAO_SCIOP_Profile::object_key_delimiter_; } -int -TAO_SCIOP_Connector::init_tcp_properties (void) -{ - // Connector protocol properties are obtained from ORB-level - // RTCORBA::ClientProtocolProperties policy override. - // If the override doesn't exist or doesn't contain the - // properties, we use ORB default. - // - // Currently, we do not use Object-level and Current-level policy - // overrides for protocol configuration because connection - // lookup and caching are not done based on protocol - // properties. - - ACE_DECLARE_NEW_CORBA_ENV; - - // Initialize the settings to the ORB defaults. If RT CORBA is enabled, - // it may override these. - int send_buffer_size = this->orb_core ()->orb_params ()->sock_sndbuf_size (); - int recv_buffer_size = this->orb_core ()->orb_params ()->sock_rcvbuf_size (); - int no_delay = this->orb_core ()->orb_params ()->nodelay (); - int enable_network_priority = 0; - - TAO_Protocols_Hooks *tph = this->orb_core ()->get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK_RETURN (-1); - - if (tph != 0) - { - const char protocol [] = "sciop"; - const char *protocol_type = protocol; - - int hook_result = - tph->call_client_protocols_hook (send_buffer_size, - recv_buffer_size, - no_delay, - enable_network_priority, - protocol_type); - - if(hook_result == -1) - return -1; - } - - // Extract and locally store properties of interest. - this->tcp_properties_.send_buffer_size = - send_buffer_size; - this->tcp_properties_.recv_buffer_size = - recv_buffer_size; - this->tcp_properties_.no_delay = - no_delay; - this->tcp_properties_.enable_network_priority = - enable_network_priority; - - return 0; -} - - TAO_SCIOP_Endpoint * TAO_SCIOP_Connector::remote_endpoint (TAO_Endpoint *endpoint) { diff --git a/TAO/tao/Strategies/SCIOP_Connector.h b/TAO/tao/Strategies/SCIOP_Connector.h index f307f27bc00..dd6aa57d8c2 100644 --- a/TAO/tao/Strategies/SCIOP_Connector.h +++ b/TAO/tao/Strategies/SCIOP_Connector.h @@ -96,19 +96,11 @@ protected: /// Transport_Connector.h virtual TAO_Profile *make_profile (ACE_ENV_SINGLE_ARG_DECL); - /// Obtain tcp properties that must be used by this connector, i.e., - /// initialize <tcp_properties_>. - int init_tcp_properties (void); - /// Cancel the passed cvs handler from the connector int cancel_svc_handler (TAO_Connection_Handler * svc_handler); protected: - /// TCP configuration properties to be used for all - /// connections established by this connector. - TAO_SCIOP_Properties tcp_properties_; - /// Do we need to use a GIOP_Lite for sending messages? CORBA::Boolean lite_flag_; diff --git a/TAO/tao/Strategies/SCIOP_Transport.cpp b/TAO/tao/Strategies/SCIOP_Transport.cpp index f5664f2e4af..4c7ae666b5f 100644 --- a/TAO/tao/Strategies/SCIOP_Transport.cpp +++ b/TAO/tao/Strategies/SCIOP_Transport.cpp @@ -144,37 +144,6 @@ TAO_SCIOP_Transport::send_request (TAO_Stub *stub, int message_semantics, ACE_Time_Value *max_wait_time) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY - { - TAO_Protocols_Hooks *tph = - this->orb_core_->get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_TRY_CHECK; - - if (tph != 0) - { - - int result = - tph->update_client_protocol_properties (stub, - this, - "sciop"); - - if (result == -1) - return -1; - } - } - ACE_CATCHANY - { - if (TAO_debug_level > 0) - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "TAO (%P|%t) - TAO_SCIOP_Transport::send_request - " - "get_protocol_hooks"); - - return -1; - } - ACE_ENDTRY; - ACE_CHECK_RETURN (-1); - if (this->ws_->sending_request (orb_core, message_semantics) == -1) @@ -231,16 +200,6 @@ TAO_SCIOP_Transport::send_message_shared (TAO_Stub *stub, { ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->handler_lock_, -1); - if (TAO_debug_level > 6) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t) - ") - ACE_TEXT ("SCIOP_Transport::send_message_shared, ") - ACE_TEXT ("enable_network_priority = %d\n"), - this->connection_handler_->enable_network_priority ())); - - if (this->connection_handler_ != 0) - this->connection_handler_->set_dscp_codepoint (); - r = this->send_message_shared_i (stub, message_semantics, message_block, max_wait_time); } diff --git a/TAO/tao/Strategies/SHMIOP_Acceptor.cpp b/TAO/tao/Strategies/SHMIOP_Acceptor.cpp index ec57d039b4e..43f795799a6 100644 --- a/TAO/tao/Strategies/SHMIOP_Acceptor.cpp +++ b/TAO/tao/Strategies/SHMIOP_Acceptor.cpp @@ -289,7 +289,6 @@ TAO_SHMIOP_Acceptor::open_i (TAO_ORB_Core* orb_core, ACE_NEW_RETURN (this->creation_strategy_, TAO_SHMIOP_CREATION_STRATEGY (this->orb_core_, - 0, this->lite_flag_), -1); diff --git a/TAO/tao/Strategies/SHMIOP_Acceptor.h b/TAO/tao/Strategies/SHMIOP_Acceptor.h index e1a2b8f04db..8fc343bbaba 100644 --- a/TAO/tao/Strategies/SHMIOP_Acceptor.h +++ b/TAO/tao/Strategies/SHMIOP_Acceptor.h @@ -36,7 +36,7 @@ #include "ace/Acceptor.h" #include "ace/MEM_Acceptor.h" #include "tao/GIOP_Message_Version.h" -// TAO SHMIOP_Acceptor concrete call defination +// TAO SHMIOP_Acceptor concrete call definitions /** * @class TAO_SHMIOP_Acceptor diff --git a/TAO/tao/Strategies/SHMIOP_Connection_Handler.cpp b/TAO/tao/Strategies/SHMIOP_Connection_Handler.cpp index cc3a4ae8b9d..0b0d962a9b0 100644 --- a/TAO/tao/Strategies/SHMIOP_Connection_Handler.cpp +++ b/TAO/tao/Strategies/SHMIOP_Connection_Handler.cpp @@ -15,6 +15,7 @@ #include "tao/Thread_Lane_Resources.h" #include "SHMIOP_Endpoint.h" #include "tao/Resume_Handle.h" +#include "tao/Protocols_Hooks.h" #if !defined (__ACE_INLINE__) # include "SHMIOP_Connection_Handler.inl" @@ -22,11 +23,10 @@ #include "ace/os_include/netinet/os_tcp.h" #include "ace/os_include/os_netdb.h" -#include "ace/os_include/netinet/os_tcp.h" ACE_RCSID (Strategies, - SHMIOP_Connection_Handler, - "$Id$") + SHMIOP_Connection_Handler, + "$Id$") TAO_SHMIOP_Connection_Handler::TAO_SHMIOP_Connection_Handler (ACE_Thread_Manager *t) : TAO_SHMIOP_SVC_HANDLER (t, 0 , 0), @@ -42,8 +42,7 @@ TAO_SHMIOP_Connection_Handler::TAO_SHMIOP_Connection_Handler (ACE_Thread_Manager TAO_SHMIOP_Connection_Handler::TAO_SHMIOP_Connection_Handler (TAO_ORB_Core *orb_core, - CORBA::Boolean flag, - void *) + CORBA::Boolean flag) : TAO_SHMIOP_SVC_HANDLER (orb_core->thr_mgr (), 0, 0), TAO_Connection_Handler (orb_core) { @@ -70,21 +69,40 @@ TAO_SHMIOP_Connection_Handler::open_handler (void *v) int TAO_SHMIOP_Connection_Handler::open (void*) { + TAO_SHMIOP_Protocol_Properties protocol_properties; + + // Initialize values from ORB params. + protocol_properties.send_buffer_size_ = + this->orb_core ()->orb_params ()->sock_sndbuf_size (); + protocol_properties.recv_buffer_size_ = + this->orb_core ()->orb_params ()->sock_rcvbuf_size (); + protocol_properties.no_delay_ = + this->orb_core ()->orb_params ()->nodelay (); + + TAO_Protocols_Hooks *tph = + this->orb_core ()->get_protocols_hooks (); + + // @@ fix me + int client = 0; + + if (client) + tph->client_protocol_properties_at_orb_level (protocol_properties); + else + tph->server_protocol_properties_at_orb_level (protocol_properties); + if (this->set_socket_option (this->peer (), - this->orb_core ()->orb_params ()->sock_sndbuf_size (), - this->orb_core ()->orb_params ()->sock_rcvbuf_size ()) - == -1) + protocol_properties.send_buffer_size_, + protocol_properties.recv_buffer_size_) == -1) return -1; -#if !defined (ACE_LACKS_TCP_NODELAY) - int nodelay = - this->orb_core ()->orb_params ()->nodelay (); +#if !defined (ACE_LACKS_TCP_NODELAY) if (this->peer ().set_option (ACE_IPPROTO_TCP, TCP_NODELAY, - (void *) &nodelay, + (void *) &protocol_properties.no_delay_, sizeof (int)) == -1) return -1; + #endif /* ! ACE_LACKS_TCP_NODELAY */ if (this->transport ()->wait_strategy ()->non_blocking ()) @@ -97,14 +115,14 @@ TAO_SHMIOP_Connection_Handler::open (void*) // completely connected. ACE_INET_Addr addr; - ACE_TCHAR client[MAXHOSTNAMELEN + 16]; + ACE_TCHAR local_as_string[MAXHOSTNAMELEN + 16]; // Get the peername. if (this->peer ().get_remote_addr (addr) == -1) return -1; // Verify that we can resolve the peer hostname. - else if (addr.addr_to_string (client, sizeof (client)) == -1) + else if (addr.addr_to_string (local_as_string, sizeof (local_as_string)) == -1) return -1; if (TAO_debug_level > 0) @@ -112,7 +130,7 @@ TAO_SHMIOP_Connection_Handler::open (void*) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) SHMIOP connection from client") ACE_TEXT ("<%s> on %d\n"), - client, this->peer ().get_handle ())); + local_as_string, this->peer ().get_handle ())); } // Set that the transport is now connected, if fails we return -1 @@ -215,6 +233,12 @@ TAO_SHMIOP_Connection_Handler::add_transport_to_cache (void) this->transport ()); } +int +TAO_SHMIOP_Connection_Handler::set_dscp_codepoint (CORBA::Boolean) +{ + return 0; +} + // **************************************************************** #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) diff --git a/TAO/tao/Strategies/SHMIOP_Connection_Handler.h b/TAO/tao/Strategies/SHMIOP_Connection_Handler.h index 152b8ad66c8..0439090b123 100644 --- a/TAO/tao/Strategies/SHMIOP_Connection_Handler.h +++ b/TAO/tao/Strategies/SHMIOP_Connection_Handler.h @@ -50,12 +50,9 @@ public: /// Constructor. TAO_SHMIOP_Connection_Handler (ACE_Thread_Manager* t = 0); - /// Constructor. <arg> parameter is used by the Acceptor to pass the - /// protocol configuration properties for this connection. + /// Constructor. TAO_SHMIOP_Connection_Handler (TAO_ORB_Core *orb_core, - CORBA::Boolean flag, - void *arg); - + CORBA::Boolean flag); /// Destructor. ~TAO_SHMIOP_Connection_Handler (void); @@ -90,6 +87,9 @@ public: /// Add ourselves to Cache. int add_transport_to_cache (void); + /// No-op since this is a local protocol. + int set_dscp_codepoint (CORBA::Boolean set_network_priority); + protected: //@{ diff --git a/TAO/tao/Strategies/SHMIOP_Connector.cpp b/TAO/tao/Strategies/SHMIOP_Connector.cpp index eb1c042934b..ddce3839d9d 100644 --- a/TAO/tao/Strategies/SHMIOP_Connector.cpp +++ b/TAO/tao/Strategies/SHMIOP_Connector.cpp @@ -77,7 +77,6 @@ TAO_SHMIOP_Connector::open (TAO_ORB_Core *orb_core) TAO_SHMIOP_CONNECT_CREATION_STRATEGY (orb_core->thr_mgr (), orb_core, - 0, this->lite_flag_), -1); diff --git a/TAO/tao/Strategies/UIOP_Acceptor.cpp b/TAO/tao/Strategies/UIOP_Acceptor.cpp index 5f3401d6ff3..afe3cce5866 100644 --- a/TAO/tao/Strategies/UIOP_Acceptor.cpp +++ b/TAO/tao/Strategies/UIOP_Acceptor.cpp @@ -224,9 +224,6 @@ TAO_UIOP_Acceptor::open (TAO_ORB_Core *orb_core, { this->orb_core_ = orb_core; - if (this->init_uiop_properties () != 0) - return -1; - if (address == 0) return -1; @@ -250,9 +247,6 @@ TAO_UIOP_Acceptor::open_default (TAO_ORB_Core *orb_core, { this->orb_core_ = orb_core; - if (this->init_uiop_properties () != 0) - return -1; - if (major >= 0 && minor >= 0) this->version_.set_version (static_cast<CORBA::Octet> (major), static_cast<CORBA::Octet> (minor)); @@ -276,7 +270,6 @@ TAO_UIOP_Acceptor::open_i (const char *rendezvous, { ACE_NEW_RETURN (this->creation_strategy_, TAO_UIOP_CREATION_STRATEGY (this->orb_core_, - &(this->uiop_properties_), this->lite_flag_), -1); @@ -511,54 +504,4 @@ TAO_UIOP_Acceptor::parse_options (const char *str) return 0; } -int -TAO_UIOP_Acceptor::init_uiop_properties (void) -{ - // @@ Currently (in the code below), we obtain protocol properties from - // ORB-level ServerProtocol, even though the policy may - // have been overridden on POA level. That's because currently all - // endpoints (acceptors) are global. Once endpoints become per POA, - // the code below will have to be changed to look at the POA-level - // ServerProtocol policy first. - - // ServerProtocolProperties policy controls protocols configuration. - // Look for protocol properties in the effective - // ServerProtocolPolicy. - ACE_DECLARE_NEW_CORBA_ENV; - - // Initialize the settings to the ORB defaults. If RT CORBA is enabled, - // it may override these. - int send_buffer_size = this->orb_core_->orb_params ()->sock_sndbuf_size (); - int recv_buffer_size = this->orb_core_->orb_params ()->sock_rcvbuf_size (); - int no_delay = 0; - int enable_network_priority = 0; - - TAO_Protocols_Hooks *tph = this->orb_core_->get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK_RETURN (-1); - - if (tph != 0) - { - static const char protocol[] = "uiop"; - const char *protocol_type = protocol; - - int hook_result = - tph->call_server_protocols_hook (send_buffer_size, - recv_buffer_size, - no_delay, - enable_network_priority, - protocol_type); - - if(hook_result == -1) - return -1; - } - - // Extract and locally store properties of interest. - this->uiop_properties_.send_buffer_size = - send_buffer_size; - this->uiop_properties_.recv_buffer_size = - recv_buffer_size; - - return 0; -} - #endif /* TAO_HAS_UIOP == 1 */ diff --git a/TAO/tao/Strategies/UIOP_Acceptor.h b/TAO/tao/Strategies/UIOP_Acceptor.h index d6feeb9c678..7610ce7f277 100644 --- a/TAO/tao/Strategies/UIOP_Acceptor.h +++ b/TAO/tao/Strategies/UIOP_Acceptor.h @@ -133,9 +133,6 @@ private: /// Should we use GIOP lite?? const bool lite_flag_; - - /// Properties for all connections accepted by this acceptor. - TAO_UIOP_Properties uiop_properties_; }; # endif /* TAO_HAS_UIOP == 1 */ diff --git a/TAO/tao/Strategies/UIOP_Connection_Handler.cpp b/TAO/tao/Strategies/UIOP_Connection_Handler.cpp index f3ad70d0fcd..4ffefd60d7a 100644 --- a/TAO/tao/Strategies/UIOP_Connection_Handler.cpp +++ b/TAO/tao/Strategies/UIOP_Connection_Handler.cpp @@ -17,6 +17,7 @@ #include "tao/Transport_Cache_Manager.h" #include "tao/Resume_Handle.h" #include "tao/Thread_Lane_Resources.h" +#include "tao/Protocols_Hooks.h" #if !defined (__ACE_INLINE__) # include "UIOP_Connection_Handler.inl" @@ -30,8 +31,7 @@ ACE_RCSID (Strategies, TAO_UIOP_Connection_Handler::TAO_UIOP_Connection_Handler (ACE_Thread_Manager *t) : TAO_UIOP_SVC_HANDLER (t, 0 , 0), - TAO_Connection_Handler (0), - uiop_properties_ (0) + TAO_Connection_Handler (0) { // This constructor should *never* get called, it is just here to // make the compiler happy: the default implementation of the @@ -44,15 +44,13 @@ TAO_UIOP_Connection_Handler::TAO_UIOP_Connection_Handler (ACE_Thread_Manager *t) TAO_UIOP_Connection_Handler::TAO_UIOP_Connection_Handler ( TAO_ORB_Core *orb_core, - CORBA::Boolean flag, - void *arg) + CORBA::Boolean flag) : TAO_UIOP_SVC_HANDLER (orb_core->thr_mgr (), 0, 0), - TAO_Connection_Handler (orb_core), - uiop_properties_ (static_cast<TAO_UIOP_Properties *> (arg)) + TAO_Connection_Handler (orb_core) { TAO_UIOP_Transport* specific_transport = 0; ACE_NEW (specific_transport, - TAO_UIOP_Transport(this, orb_core, flag)); + TAO_UIOP_Transport (this, orb_core, flag)); // store this pointer (indirectly increment ref count) this->transport (specific_transport); @@ -73,9 +71,28 @@ TAO_UIOP_Connection_Handler::open_handler (void *v) int TAO_UIOP_Connection_Handler::open (void*) { + TAO_UIOP_Protocol_Properties protocol_properties; + + // Initialize values from ORB params. + protocol_properties.send_buffer_size_ = + this->orb_core ()->orb_params ()->sock_sndbuf_size (); + protocol_properties.recv_buffer_size_ = + this->orb_core ()->orb_params ()->sock_rcvbuf_size (); + + TAO_Protocols_Hooks *tph = + this->orb_core ()->get_protocols_hooks (); + + // @@ fix me + int client = 0; + + if (client) + tph->client_protocol_properties_at_orb_level (protocol_properties); + else + tph->server_protocol_properties_at_orb_level (protocol_properties); + if (this->set_socket_option (this->peer (), - this->uiop_properties_->send_buffer_size, - this->uiop_properties_->recv_buffer_size) == -1) + protocol_properties.send_buffer_size_, + protocol_properties.recv_buffer_size_) == -1) return -1; if (this->transport ()->wait_strategy ()->non_blocking ()) @@ -194,6 +211,12 @@ TAO_UIOP_Connection_Handler::add_transport_to_cache (void) this->transport ()); } +int +TAO_UIOP_Connection_Handler::set_dscp_codepoint (CORBA::Boolean) +{ + return 0; +} + #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) template class ACE_Svc_Handler<ACE_LSOCK_STREAM, ACE_NULL_SYNCH>; diff --git a/TAO/tao/Strategies/UIOP_Connection_Handler.h b/TAO/tao/Strategies/UIOP_Connection_Handler.h index 8dd9459919d..09598d6db1d 100644 --- a/TAO/tao/Strategies/UIOP_Connection_Handler.h +++ b/TAO/tao/Strategies/UIOP_Connection_Handler.h @@ -37,20 +37,6 @@ // Forward Decls class TAO_Pluggable_Messaging; -/** - * @class TAO_UIOP_Properties - * - * @brief Unix Domain Sockets protocol properties specification for a - * set of connections. - */ -class TAO_Strategies_Export TAO_UIOP_Properties -{ -public: - - int send_buffer_size; - int recv_buffer_size; -}; - // **************************************************************** /** @@ -69,17 +55,13 @@ public: TAO_UIOP_Connection_Handler (ACE_Thread_Manager* t = 0); - /// Constructor. <arg> parameter is used by the Acceptor to pass the - /// protocol configuration properties for this connection. + /// Constructor. TAO_UIOP_Connection_Handler (TAO_ORB_Core *orb_core, - CORBA::Boolean flag, - void *arg); - + CORBA::Boolean flag); /// Destructor. ~TAO_UIOP_Connection_Handler (void); - //@{ /** * Connection_Handler overloads @@ -108,6 +90,8 @@ public: /// Add ourselves to Cache. int add_transport_to_cache (void); + /// No-op since this is a local protocol. + int set_dscp_codepoint (CORBA::Boolean set_network_priority); protected: @@ -117,11 +101,6 @@ protected: */ virtual int release_os_resources (void); //@} - -private: - - /// TCP configuration for this connection. - TAO_UIOP_Properties *uiop_properties_; }; diff --git a/TAO/tao/Strategies/UIOP_Connector.cpp b/TAO/tao/Strategies/UIOP_Connector.cpp index bc39c9c89dc..9258c6ddf11 100644 --- a/TAO/tao/Strategies/UIOP_Connector.cpp +++ b/TAO/tao/Strategies/UIOP_Connector.cpp @@ -68,9 +68,6 @@ TAO_UIOP_Connector::open (TAO_ORB_Core *orb_core) if (this->create_connect_strategy () == -1) return -1; - if (this->init_uiop_properties () != 0) - return -1; - // Our connect creation strategy TAO_UIOP_CONNECT_CREATION_STRATEGY *connect_creation_strategy = 0; @@ -78,7 +75,6 @@ TAO_UIOP_Connector::open (TAO_ORB_Core *orb_core) TAO_UIOP_CONNECT_CREATION_STRATEGY (orb_core->thr_mgr (), orb_core, - &(this->uiop_properties_), this->lite_flag_), -1); @@ -405,51 +401,6 @@ TAO_UIOP_Connector::object_key_delimiter (void) const return TAO_UIOP_Profile::object_key_delimiter_; } -int -TAO_UIOP_Connector::init_uiop_properties (void) -{ - // Connector protocol properties are obtained from ORB-level - // RTCORBA::ClientProtocolProperties policy override. - // If the override doesn't exist or doesn't contain the - // properties, we use ORB default. - // - // Currently, we do not use Object-level and Current-level policy - // overrides for protocol configuration because connection - // lookup and caching are not done based on protocol - // properties. - - ACE_DECLARE_NEW_CORBA_ENV; - - int send_buffer_size = this->orb_core ()->orb_params ()->sock_sndbuf_size (); - int recv_buffer_size = this->orb_core ()->orb_params ()->sock_rcvbuf_size (); - int no_delay = 0; - int enable_network_priority = 0; - - TAO_Protocols_Hooks *tph = this->orb_core ()->get_protocols_hooks (ACE_ENV_SINGLE_ARG_PARAMETER); - ACE_CHECK_RETURN (-1); - - if (tph != 0) - { - static const char protocol[] = "uiop"; - const char *protocol_type = protocol; - const int hook_result = - tph->call_client_protocols_hook (send_buffer_size, - recv_buffer_size, - no_delay, - enable_network_priority, - protocol_type); - - if(hook_result == -1) - return -1; - } - - // Extract and locally store properties of interest. - this->uiop_properties_.send_buffer_size = send_buffer_size; - this->uiop_properties_.recv_buffer_size = recv_buffer_size; - - return 0; -} - TAO_UIOP_Endpoint * TAO_UIOP_Connector::remote_endpoint (TAO_Endpoint *endpoint) { diff --git a/TAO/tao/Strategies/UIOP_Connector.h b/TAO/tao/Strategies/UIOP_Connector.h index f86ad350719..e53b09b3295 100644 --- a/TAO/tao/Strategies/UIOP_Connector.h +++ b/TAO/tao/Strategies/UIOP_Connector.h @@ -35,7 +35,6 @@ #include "tao/Resource_Factory.h" #include "tao/Connector_Impl.h" - class TAO_UIOP_Endpoint; class TAO_Endpoint; @@ -113,9 +112,6 @@ protected: virtual TAO_Profile *make_profile (ACE_ENV_SINGLE_ARG_DECL); - /// Obtains uiop properties that must be used by this connector, i.e., - /// initializes <uiop_properties_>. - int init_uiop_properties (void); //@} private: @@ -133,10 +129,6 @@ private: /// Do we need to use a GIOP_Lite for sending messages? const bool lite_flag_; - - /// UIOP configuration properties for all connections established by - /// this connector. - TAO_UIOP_Properties uiop_properties_; }; # endif /* TAO_HAS_UIOP == 1 */ diff --git a/TAO/tao/Stub.cpp b/TAO/tao/Stub.cpp index eedc383446b..5f3004210aa 100644 --- a/TAO/tao/Stub.cpp +++ b/TAO/tao/Stub.cpp @@ -469,75 +469,50 @@ private: #if (TAO_HAS_CORBA_MESSAGING == 1) +// Some policies can only be set locally on the client, while others +// can only be exported in the IOR by the server, and yet others can +// be set by both by client and server. Furthermore, reconciliation +// between client-set values and the ones exported in the IOR is +// policy-specific. Therefore, with the current state of things, it +// isn't possible to write generic code for <get_policy> that will +// work for any policy type. Currently, we take specific action for +// each of the known client-exposed policies (above), and simply look +// up effective override for any other policy type (below). Later, if +// there is a need/desire for generic code, it can be done by pushing +// the smarts into the policies implementations, and will involve +// modifying PolicyC* and friends, e.g., to add methods for policy +// specific reconciliation, etc. + CORBA::Policy_ptr TAO_Stub::get_policy (CORBA::PolicyType type - ACE_ENV_ARG_DECL) + ACE_ENV_ARG_DECL_NOT_USED) { - // Some policies can only be set locally on the client, while others - // can only be exported in the IOR by the server, and yet others can - // be set by both by client and server. Furthermore, reconciliation - // between client-set values and the ones exported in the IOR is - // policy-specific. Therefore, with the current state of things, it - // isn't possible to write generic code for <get_policy> that will - // work for any policy type. - // Currently, we take specific action - // for each of the known client-exposed policies (above), and simply - // look up effective override for any other policy type (below). - // Later, if there is a need/desire for generic code, it can be - // done by pushing the smarts into the policies - // implementations, and will involve modifying PolicyC* and friends, - // e.g., to add methods for policy specific reconciliation, etc. - - return this->get_client_policy (type - ACE_ENV_ARG_PARAMETER); + // No need to lock, the stub only changes its policies at + // construction time... + + CORBA::Policy_var result; + if (this->policies_ != 0) + result = this->policies_->get_policy (type); + + if (CORBA::is_nil (result.in ())) + result = this->orb_core_->get_policy_including_current (type); + + return result._retn (); } CORBA::Policy_ptr -TAO_Stub::get_client_policy (CORBA::PolicyType type - ACE_ENV_ARG_DECL) +TAO_Stub::get_cached_policy (TAO_Cached_Policy_Type type + ACE_ENV_ARG_DECL_NOT_USED) { // No need to lock, the stub only changes its policies at // construction time... - CORBA::Policy_var result; if (this->policies_ != 0) - { - result = this->policies_->get_policy (type - ACE_ENV_ARG_PARAMETER); - ACE_CHECK_RETURN (CORBA::Policy::_nil ()); - } + result = this->policies_->get_cached_policy (type); if (CORBA::is_nil (result.in ())) - { - TAO_Policy_Current &policy_current = this->orb_core_->policy_current (); - result = policy_current.get_policy (type - ACE_ENV_ARG_PARAMETER); - ACE_CHECK_RETURN (CORBA::Policy::_nil ()); - } - - if (CORBA::is_nil (result.in ())) - { - // @@ Must lock, but is is harder to implement than just modifying - // this call: the ORB does take a lock to modify the policy - // manager - TAO_Policy_Manager *policy_manager = - this->orb_core_->policy_manager (); - if (policy_manager != 0) - { - result = policy_manager->get_policy (type - ACE_ENV_ARG_PARAMETER); - ACE_CHECK_RETURN (CORBA::Policy::_nil ()); - } - } - - if (CORBA::is_nil (result.in ())) - { - result = this->orb_core_-> - get_default_policies ()->get_policy (type - ACE_ENV_ARG_PARAMETER); - ACE_CHECK_RETURN (CORBA::Policy::_nil ()); - } + result = this->orb_core_->get_cached_policy_including_current (type); return result._retn (); } @@ -555,14 +530,14 @@ TAO_Stub::set_policy_overrides (const CORBA::PolicyList & policies, { policy_manager->set_policy_overrides (policies, set_add - ACE_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); } else if (this->policies_ == 0) { policy_manager->set_policy_overrides (policies, CORBA::SET_OVERRIDE - ACE_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); } else @@ -573,13 +548,13 @@ TAO_Stub::set_policy_overrides (const CORBA::PolicyList & policies, policy_manager->set_policy_overrides (policies, set_add - ACE_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); } TAO_Stub* stub = this->orb_core_->create_stub (this->type_id.in (), this->base_profiles_ - ACE_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); stub->policies_ = policy_manager.release (); @@ -624,169 +599,6 @@ TAO_Stub::sync_strategy (void) return this->orb_core_->transport_sync_strategy (); } -#if (TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1) - -CORBA::Policy_ptr -TAO_Stub::relative_roundtrip_timeout (void) -{ - CORBA::Policy_var p; - - // No need to lock, the stub only changes its policies at - // construction time... - if (this->policies_ != 0) - p = this->policies_->get_cached_policy ( - TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT); - - // No need to lock, the object is in TSS storage.... - if (CORBA::is_nil (p.in ())) - { - TAO_Policy_Current &policy_current = - this->orb_core_->policy_current (); - p = policy_current.get_cached_policy ( - TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT); - } - - // @@ Must lock, but is is harder to implement than just modifying - // this call: the ORB does take a lock to modify the policy - // manager - if (CORBA::is_nil (p.in ())) - { - TAO_Policy_Manager *policy_manager = - this->orb_core_->policy_manager (); - if (policy_manager != 0) - p = policy_manager->get_cached_policy ( - TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT); - } - - if (CORBA::is_nil (p.in ())) - p = this->orb_core_->get_default_policies ()->get_cached_policy ( - TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT); - - return p._retn (); -} - -#endif /* TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */ - - -#if (TAO_HAS_SYNC_SCOPE_POLICY == 1) - -CORBA::Policy_ptr -TAO_Stub::sync_scope (void) -{ - CORBA::Policy_var p; - - // No need to lock, the stub only changes its policies at - // construction time... - if (this->policies_ != 0) - p = this->policies_->get_cached_policy (TAO_CACHED_POLICY_SYNC_SCOPE); - - // If there are no cached policies, look at the thread or ORB level - // for the policy. - if (CORBA::is_nil (p.in ())) - p = this->orb_core_->stubless_sync_scope (); - - return p._retn (); -} - -#endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */ - - -#if (TAO_HAS_CONNECTION_TIMEOUT_POLICY == 1) -CORBA::Policy_ptr -TAO_Stub::connection_timeout (void) -{ - CORBA::Policy_var p; - - // No need to lock, the stub only changes its policies at - // construction time... - if (this->policies_ != 0) - p = this->policies_->get_cached_policy ( - TAO_CACHED_POLICY_CONNECTION_TIMEOUT); - - // No need to lock, the object is in TSS storage.... - if (CORBA::is_nil (p.in ())) - { - TAO_Policy_Current &policy_current = - this->orb_core_->policy_current (); - p = policy_current.get_cached_policy ( - TAO_CACHED_POLICY_CONNECTION_TIMEOUT); - } - - // @@ Must lock, but is is harder to implement than just modifying - // this call: the ORB does take a lock to modify the policy - // manager - if (CORBA::is_nil (p.in ())) - { - TAO_Policy_Manager *policy_manager = - this->orb_core_->policy_manager (); - if (policy_manager != 0) - p = policy_manager->get_cached_policy ( - TAO_CACHED_POLICY_CONNECTION_TIMEOUT); - } - - if (CORBA::is_nil (p.in ())) - p = this->orb_core_->get_default_policies ()->get_cached_policy ( - TAO_CACHED_POLICY_CONNECTION_TIMEOUT); - - return p._retn (); -} - -#endif /* TAO_HAS_CONNECTION_TIMEOUT_POLICY == 1 */ - - -#if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) - -CORBA::Policy_ptr -TAO_Stub::buffering_constraint (void) -{ - CORBA::Policy_var p; - - // No need to lock, the stub only changes its policies at - // construction time... - - if (this->policies_ != 0) - { - p = - this->policies_->get_cached_policy ( - TAO_CACHED_POLICY_BUFFERING_CONSTRAINT); - } - - // No need to lock, the object is in TSS storage.... - if (CORBA::is_nil (p.in ())) - { - TAO_Policy_Current &policy_current = - this->orb_core_->policy_current (); - - p = - policy_current.get_cached_policy ( - TAO_CACHED_POLICY_BUFFERING_CONSTRAINT); - } - - // @@ Must lock, but is is harder to implement than just modifying - // this call: the ORB does take a lock to modify the policy - // manager - if (CORBA::is_nil (p.in ())) - { - TAO_Policy_Manager *policy_manager = - this->orb_core_->policy_manager (); - if (policy_manager != 0) - { - p = - policy_manager->get_cached_policy ( - TAO_CACHED_POLICY_BUFFERING_CONSTRAINT); - } - } - - if (CORBA::is_nil (p.in ())) - p = this->orb_core_->default_buffering_constraint (); - - return p._retn (); -} - -#endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */ - - - #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) #if (TAO_HAS_CORBA_MESSAGING == 1) diff --git a/TAO/tao/Stub.h b/TAO/tao/Stub.h index 45fb155b548..69902d7e125 100644 --- a/TAO/tao/Stub.h +++ b/TAO/tao/Stub.h @@ -79,54 +79,19 @@ public: virtual CORBA::Policy_ptr get_policy (CORBA::PolicyType type ACE_ENV_ARG_DECL_WITH_DEFAULTS); - - virtual CORBA::Policy_ptr get_client_policy (CORBA::PolicyType type + virtual CORBA::Policy_ptr get_cached_policy (TAO_Cached_Policy_Type type ACE_ENV_ARG_DECL_WITH_DEFAULTS); virtual TAO_Stub* set_policy_overrides (const CORBA::PolicyList & policies, CORBA::SetOverrideType set_add ACE_ENV_ARG_DECL_WITH_DEFAULTS); - virtual CORBA::PolicyList * get_policy_overrides ( + virtual CORBA::PolicyList *get_policy_overrides ( const CORBA::PolicyTypeSeq & types ACE_ENV_ARG_DECL_WITH_DEFAULTS); #endif /* TAO_HAS_CORBA_MESSAGING == 1 */ - - // = Methods for obtaining effective overrides. - // - // Same functionality as <get_client_policy>, but more efficient. - // Each of the methods below returns effective override for the - // corresponding policy. The effective override is obtained by - // first checking for an override of the given policy type at the - // Object scope, then at the Current scope, then at the ORB scope, - // and, finally, ORB default values are checked. - -#if (TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1) - - CORBA::Policy_ptr relative_roundtrip_timeout (void); - -#endif /* TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */ - -#if (TAO_HAS_SYNC_SCOPE_POLICY == 1) - - CORBA::Policy_ptr sync_scope (void); - -#endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */ - -#if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) - - CORBA::Policy_ptr buffering_constraint (void); - -#endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */ - -#if (TAO_HAS_CONNECTION_TIMEOUT_POLICY == 1) - - CORBA::Policy_ptr connection_timeout (void); - -#endif /* TAO_HAS_CONNECTION_TIMEOUT_POLICY == 1 */ - /// Return the sync strategy to be used in by the transport. /// Selection will be based on the SyncScope policies. TAO_Sync_Strategy &sync_strategy (void); diff --git a/TAO/tao/Sync_Strategies.cpp b/TAO/tao/Sync_Strategies.cpp index 994f9ff0fb9..91b4ef1e947 100644 --- a/TAO/tao/Sync_Strategies.cpp +++ b/TAO/tao/Sync_Strategies.cpp @@ -66,7 +66,7 @@ TAO_Eager_Buffering_Sync_Strategy::buffering_constraints_reached ( must_flush = 0; set_timer = 0; - CORBA::Policy_var bcp_policy = stub->buffering_constraint (); + CORBA::Policy_var bcp_policy = stub->get_cached_policy (TAO_CACHED_POLICY_BUFFERING_CONSTRAINT); TAO::BufferingConstraintPolicy_var bcp = TAO::BufferingConstraintPolicy::_narrow (bcp_policy.in()); diff --git a/TAO/tao/default_resource.cpp b/TAO/tao/default_resource.cpp index 57a1aed7da4..476b89743f2 100644 --- a/TAO/tao/default_resource.cpp +++ b/TAO/tao/default_resource.cpp @@ -179,7 +179,8 @@ TAO_Default_Resource_Factory::init (int argc, ACE_TCHAR *argv[]) char **endPtr =0; ncs = ACE_OS::strtoul(ACE_TEXT_ALWAYS_CHAR(argv[curarg]), endPtr, 0); - } + } + // Validate the CodesetId if (ACE_Codeset_Registry::get_max_bytes(ncs) == 0) { diff --git a/TAO/tao/orbconf.h b/TAO/tao/orbconf.h index 58989df1f2a..49564b39bdc 100644 --- a/TAO/tao/orbconf.h +++ b/TAO/tao/orbconf.h @@ -717,26 +717,10 @@ const size_t TAO_DEFAULT_VALUE_FACTORY_TABLE_SIZE = 128; # define TAO_HAS_EXTENDED_FT_INTERCEPTORS 0 #endif /* !TAO_HAS_EXTENEDED_FT_INTERCEPTORS */ -// Define the policy types as literals, so they can be used in switch -// statements - -#define TAO_CLIENT_PRIORITY_POLICY_TYPE 0x54410000 -#define TAO_BUFFERING_CONSTRAINT_POLICY_TYPE 0x54410001 -#define TAO_CONNECTION_TIMEOUT_POLICY_TYPE 0x54410008 - -// #define TAO_RT_PRIORITY_MODEL_POLICY_TYPE 0x54410002 -// #define TAO_RT_THREADPOOL_POLICY_TYPE 0x54410003 -// #define TAO_RT_PRIVATE_CONNECTION_POLICY_TYPE 0x54410006 -// #define TAO_RT_PRIORITY_BANDED_CONNECTION_POLICY_TYPE 0x54410007 -// #define TAO_RT_SERVER_PROTOCOL_POLICY_TYPE 0x54410004 -// #define TAO_RT_CLIENT_PROTOCOL_POLICY_TYPE 0x54410005 - -#define TAO_RT_PRIORITY_MODEL_POLICY_TYPE 40 -#define TAO_RT_THREADPOOL_POLICY_TYPE 41 +// This is needed for a check in the Policy Set; Should really not be +// here though; We should find a different way to handle the check in +// the Policy Set. #define TAO_RT_SERVER_PROTOCOL_POLICY_TYPE 42 -#define TAO_RT_CLIENT_PROTOCOL_POLICY_TYPE 43 -#define TAO_RT_PRIVATE_CONNECTION_POLICY_TYPE 44 -#define TAO_RT_PRIORITY_BANDED_CONNECTION_POLICY_TYPE 45 /// Policies that are accessed on the critical path and need to be /// incur minimal retrieval overhead. diff --git a/TAO/tests/RTCORBA/Client_Protocol/server.cpp b/TAO/tests/RTCORBA/Client_Protocol/server.cpp index 09e5222b5ae..6b4cc59125f 100644 --- a/TAO/tests/RTCORBA/Client_Protocol/server.cpp +++ b/TAO/tests/RTCORBA/Client_Protocol/server.cpp @@ -198,7 +198,7 @@ main (int argc, char *argv[]) (protocol_type); protocols[0].transport_protocol_properties = TAO_Protocol_Properties_Factory::create_transport_protocol_property - (protocol_type); + (protocol_type, orb->orb_core ()); CORBA::PolicyList poa_policy_list; poa_policy_list.length (1); diff --git a/TAO/tests/RTCORBA/Diffserv/README b/TAO/tests/RTCORBA/Diffserv/README index a72f2d7de4c..f1a80b25b34 100644 --- a/TAO/tests/RTCORBA/Diffserv/README +++ b/TAO/tests/RTCORBA/Diffserv/README @@ -1,6 +1,8 @@ $Id$ -This is a unit test for setting DiffServ Codepoint both in the requests sent and the replies received. It also illustrates how a Custom Network Priority Mapping can be plugged in. +This is a unit test for setting DiffServ Codepoint both in the +requests sent and the replies received. It also illustrates how a +Custom Network Priority Mapping can be plugged in. Scenario: -------- @@ -25,17 +27,16 @@ reference. Client then performs several invocations on the object. To run (on Unix): ----------------- -$./server -$./client +$ ./server -ORBdebuglevel 1 -p 20000 +$ ./client -ORBdebuglevel 1 -n 10 -p 10000 -k file://simple_servant.ior +$ ./client -ORBdebuglevel 1 -n 10 -p 10000 -k file://diffserv_servant.ior -Options: --------- - -server [-k ior_output_file2] [-o ior_output_file2] [-p corba_priority] [-s {test_server} ] [-c {test_client}] - -client [-k server_ior] [-n number_of_iterations] [-p corba_priority] [-s {test_server}] [-c {test_client}] +Both client executions set diffserv codepoints on outbound +packets. When the client invokes on the diffserv_servant, reply +packets also have diffserv codepoints set on them. -NOTE: The iterations have to be >=6 in order to test set/unset at the ORB, THREAD and OBJECT levels. +NOTE: The iterations have to be >=6 in order to test set/unset at the +ORB, THREAD and OBJECT levels. diff --git a/TAO/tests/RTCORBA/Server_Protocol/run_test.pl b/TAO/tests/RTCORBA/Server_Protocol/run_test.pl index 6c2abab3d58..a930bec5b03 100755 --- a/TAO/tests/RTCORBA/Server_Protocol/run_test.pl +++ b/TAO/tests/RTCORBA/Server_Protocol/run_test.pl @@ -13,21 +13,24 @@ $iorfile = PerlACE::LocalFile ("test.ior"); unlink $iorfile; $status = 0; -$server_reverse_conf = PerlACE::LocalFile ("server_reverse$PerlACE::svcconf_ext"); -$server_iiop_conf = PerlACE::LocalFile ("server_iiop$PerlACE::svcconf_ext"); -$server_uiop_conf = PerlACE::LocalFile ("server_uiop$PerlACE::svcconf_ext"); -$server_shmiop_conf = PerlACE::LocalFile ("server_shmiop$PerlACE::svcconf_ext"); -$server_reverse_nt_conf = PerlACE::LocalFile ("server_reverse_nt$PerlACE::svcconf_ext"); +$server_reverse_conf = PerlACE::LocalFile ("server_reverse$PerlACE::svcconf_ext"); +$server_iiop_conf = PerlACE::LocalFile ("server_iiop$PerlACE::svcconf_ext"); +$server_uiop_conf = PerlACE::LocalFile ("server_uiop$PerlACE::svcconf_ext"); +$server_shmiop_conf = PerlACE::LocalFile ("server_shmiop$PerlACE::svcconf_ext"); +$server_iiop_uiop_conf = PerlACE::LocalFile ("server_iiop_uiop$PerlACE::svcconf_ext"); +$server_iiop_shmiop_conf = PerlACE::LocalFile ("server_iiop_shmiop$PerlACE::svcconf_ext"); +$server_reverse_nt_conf = PerlACE::LocalFile ("server_reverse_nt$PerlACE::svcconf_ext"); # Configurations for all tests to be run. @server_opts = - ("-ORBendpoint iiop://", + ("-ORBSndSock 54321 -ORBendpoint iiop://", "-ORBsvcconf $server_reverse_conf " - ."-ORBEndpoint uiop:// -ORBendpoint iiop://", + ."-ORBEndpoint shmiop:// -ORBEndpoint uiop:// -ORBendpoint iiop://", - "-ORBEndpoint uiop:// " - ." -ORBsvcconf $server_uiop_conf -p 1413566208"); + "-ORBRcvSock 12345 -ORBsvcconf $server_iiop_uiop_conf " + ."-ORBEndpoint iiop:// -ORBEndpoint uiop:// " + ."-p 1413566208"); @comments = ("* ORB Default Server Protocol Policy Test\n " ."(TAO's default behavior without config files): \n", @@ -44,14 +47,15 @@ if ($^O eq "MSWin32") { ("-ORBendpoint iiop://", "-ORBsvcconf $server_reverse_nt_conf " - ."-ORBendpoint iiop://", + ."-ORBEndpoint shmiop:// -ORBendpoint iiop://", - "-ORBendpoint iiop://" - ." -ORBsvcconf $server_iiop_conf -p 0"); + "-ORBsvcconf $server_iiop_shmiop_conf " + ."-ORBEndpoint iiop:// -ORBEndpoint shmiop:// " + ."-p 1413566210"); - $comments[3] = + $comments[2] = "* Overriding ORB Default Server Protocol Policy in the POA\n" - ." (POA Server Protocol set to IIOP only): \n"; + ." (POA Server Protocol set to SMHIOP only): \n"; } @@ -90,7 +94,7 @@ foreach $o (@server_opts) { $status = 1; } - $server = $SV->TerminateWaitKill (60); + $server = $SV->WaitKill (60); if ($server != 0) { print STDERR "ERROR: server returned $server\n"; diff --git a/TAO/tests/RTCORBA/Server_Protocol/server.cpp b/TAO/tests/RTCORBA/Server_Protocol/server.cpp index 21f9f7e7ebc..3b35439b0ce 100644 --- a/TAO/tests/RTCORBA/Server_Protocol/server.cpp +++ b/TAO/tests/RTCORBA/Server_Protocol/server.cpp @@ -128,8 +128,7 @@ check_default_server_protocol (CORBA::ORB_ptr orb if (protocol_type == IOP::TAG_INTERNET_IOP) { RTCORBA::TCPProtocolProperties_var tcp_properties = - RTCORBA::TCPProtocolProperties::_narrow (properties.in - () + RTCORBA::TCPProtocolProperties::_narrow (properties.in () ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); @@ -138,20 +137,24 @@ check_default_server_protocol (CORBA::ORB_ptr orb " Properties: \n" " send_buffer_size = %d\n" " receive_buffer_size = %d\n" - " no_delay = %d\n", + " keep_alive = %d\n" + " dont_route = %d\n" + " no_delay = %d\n" + " enable_network_priority = %d\n", tcp_properties->send_buffer_size (), tcp_properties->recv_buffer_size (), - tcp_properties->no_delay ())); + tcp_properties->keep_alive (), + tcp_properties->dont_route (), + tcp_properties->no_delay (), + tcp_properties->enable_network_priority ())); } else if (protocol_type == TAO_TAG_UIOP_PROFILE) { RTCORBA::UnixDomainProtocolProperties_var uiop_properties = - RTCORBA::UnixDomainProtocolProperties::_narrow (properties.in - () + RTCORBA::UnixDomainProtocolProperties::_narrow (properties.in () ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - if (!CORBA::is_nil (uiop_properties.in ())) ACE_DEBUG ((LM_DEBUG, " Properties: \n" @@ -159,7 +162,69 @@ check_default_server_protocol (CORBA::ORB_ptr orb " receive_buffer_size = %d\n", uiop_properties->send_buffer_size (), uiop_properties->recv_buffer_size ())); + } + else if (protocol_type == TAO_TAG_SHMEM_PROFILE) + { + RTCORBA::SharedMemoryProtocolProperties_var shmem_properties = + RTCORBA::SharedMemoryProtocolProperties::_narrow (properties.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + if (!CORBA::is_nil (shmem_properties.in ())) + ACE_DEBUG ((LM_DEBUG, + " Properties: \n" + " send_buffer_size = %d\n" + " receive_buffer_size = %d\n" + " keep_alive = %d\n" + " dont_route = %d\n" + " no_delay = %d\n" + " preallocate_buffer_size = %d\n" + " mmap_filename = %s\n" + " mmap_lockname = %s\n", + shmem_properties->send_buffer_size (), + shmem_properties->recv_buffer_size (), + shmem_properties->keep_alive (), + shmem_properties->dont_route (), + shmem_properties->no_delay (), + shmem_properties->preallocate_buffer_size (), + shmem_properties->mmap_filename (), + shmem_properties->mmap_lockname ())); + } + else if (protocol_type == TAO_TAG_UDP_PROFILE) + { + RTCORBA::UserDatagramProtocolProperties_var diop_properties = + RTCORBA::UserDatagramProtocolProperties::_narrow (properties.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + if (!CORBA::is_nil (diop_properties.in ())) + ACE_DEBUG ((LM_DEBUG, + " Properties: \n" + " enable_network_priority = %d\n", + diop_properties->enable_network_priority ())); + } + else if (protocol_type == TAO_TAG_SCIOP_PROFILE) + { + RTCORBA::StreamControlProtocolProperties_var sciop_properties = + RTCORBA::StreamControlProtocolProperties::_narrow (properties.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + if (!CORBA::is_nil (sciop_properties.in ())) + ACE_DEBUG ((LM_DEBUG, + " Properties: \n" + " send_buffer_size = %d\n" + " receive_buffer_size = %d\n" + " keep_alive = %d\n" + " dont_route = %d\n" + " no_delay = %d\n" + " enable_network_priority = %d\n", + sciop_properties->send_buffer_size (), + sciop_properties->recv_buffer_size (), + sciop_properties->keep_alive (), + sciop_properties->dont_route (), + sciop_properties->no_delay (), + sciop_properties->enable_network_priority ())); } } diff --git a/TAO/tests/RTCORBA/Server_Protocol/server_iiop_shmiop.conf b/TAO/tests/RTCORBA/Server_Protocol/server_iiop_shmiop.conf new file mode 100644 index 00000000000..e93d62ad565 --- /dev/null +++ b/TAO/tests/RTCORBA/Server_Protocol/server_iiop_shmiop.conf @@ -0,0 +1,2 @@ +# Protocol options +static Advanced_Resource_Factory "-ORBProtocolFactory IIOP_Factory -ORBProtocolFactory SHMIOP_Factory " diff --git a/TAO/tests/RTCORBA/Server_Protocol/server_iiop_uiop.conf b/TAO/tests/RTCORBA/Server_Protocol/server_iiop_uiop.conf new file mode 100644 index 00000000000..8278e468550 --- /dev/null +++ b/TAO/tests/RTCORBA/Server_Protocol/server_iiop_uiop.conf @@ -0,0 +1,2 @@ +# Protocol options +static Advanced_Resource_Factory "-ORBProtocolFactory IIOP_Factory -ORBProtocolFactory UIOP_Factory " diff --git a/ace/Basic_Stats.cpp b/ace/Basic_Stats.cpp index 3ed5dc739ad..eaf51d04a17 100644 --- a/ace/Basic_Stats.cpp +++ b/ace/Basic_Stats.cpp @@ -17,24 +17,28 @@ ACE_Basic_Stats::accumulate (const ACE_Basic_Stats &rhs) if (this->samples_count_ == 0) { - this->samples_count_ = rhs.samples_count_; + this->min_ = rhs.min_; + this->min_at_ = rhs.min_at_; - this->min_ = rhs.min_; - this->max_ = rhs.max_; - this->sum_ = rhs.sum_; - this->sum2_ = rhs.sum2_; - - return; + this->max_ = rhs.max_; + this->max_at_ = rhs.max_at_; + } + else + { + if (this->min_ > rhs.min_) + { + this->min_ = rhs.min_; + this->min_at_ = rhs.min_at_; + } + if (this->max_ < rhs.max_) + { + this->max_ = rhs.max_; + this->max_at_ = rhs.max_at_; + } } - this->samples_count_ += rhs.samples_count_; - - if (this->min_ > rhs.min_) - this->min_ = rhs.min_; - if (this->max_ < rhs.max_) - this->max_ = rhs.max_; - this->sum_ += rhs.sum_; - this->sum2_ += rhs.sum2_; + this->samples_count_ += rhs.samples_count_; + this->sum_ += rhs.sum_; } void @@ -49,27 +53,18 @@ ACE_Basic_Stats::dump_results (const ACE_TCHAR *msg, return; } - const ACE_UINT64 avg = this->sum_ / this->samples_count_; - ACE_UINT64 dev = -# if defined ACE_LACKS_LONGLONG_T - static_cast<ACE_U_LongLong> (this->sum2_ / this->samples_count_) - - avg * ACE_U64_TO_U32(avg); -# else /* ! ACE_LACKS_LONGLONG_T */ - this->sum2_ / this->samples_count_ - avg * avg; -# endif /* ! ACE_LACKS_LONGLONG_T */ + ACE_UINT64 avg = this->sum_ / this->samples_count_; - const double l_min = ACE_CU64_TO_CU32 (this->min_) / sf; - const double l_max = ACE_CU64_TO_CU32 (this->max_) / sf; - const double l_avg = ACE_CU64_TO_CU32 (avg) / sf; - const double l_dev = ACE_CU64_TO_CU32 (dev) / (sf * sf); + ACE_UINT64 l_min = this->min_ / sf; + ACE_UINT64 l_max = this->max_ / sf; + ACE_UINT64 l_avg = avg / sf; ACE_DEBUG ((LM_DEBUG, - ACE_LIB_TEXT ("%s latency : %.2f[%d]/%.2f/%.2f[%d]/%.2f (min/avg/max/var^2)\n"), + ACE_LIB_TEXT ("%s latency : %Q[%d]/%Q/%Q[%d] (min/avg/max)\n"), msg, l_min, this->min_at_, l_avg, - l_max, this->max_at_, - l_dev)); + l_max, this->max_at_)); #endif /* ACE_NLOGGING */ } diff --git a/ace/Basic_Stats.h b/ace/Basic_Stats.h index 6e5b5b32a4c..7a6c7fd8ab6 100644 --- a/ace/Basic_Stats.h +++ b/ace/Basic_Stats.h @@ -56,7 +56,6 @@ public: void dump_results (const ACE_TCHAR *msg, ACE_UINT32 scale_factor) const; -private: /// The number of samples ACE_UINT32 samples_count_; @@ -74,9 +73,6 @@ private: /// The sum of all the values ACE_UINT64 sum_; - - /// The sum of the square of all the values - ACE_UINT64 sum2_; }; #if defined (__ACE_INLINE__) diff --git a/ace/Basic_Stats.inl b/ace/Basic_Stats.inl index 4ed1baca459..b2fd80d121a 100644 --- a/ace/Basic_Stats.inl +++ b/ace/Basic_Stats.inl @@ -8,7 +8,6 @@ ACE_Basic_Stats::ACE_Basic_Stats (void) , max_ (0) , max_at_ (0) , sum_ (0) - , sum2_ (0) { } @@ -29,12 +28,6 @@ ACE_Basic_Stats::sample (ACE_UINT64 value) this->min_at_ = this->samples_count_; this->max_ = value; this->max_at_ = this->samples_count_; - this->sum_ = value; -#if defined ACE_LACKS_LONGLONG_T - this->sum2_ = value * ACE_U64_TO_U32 (value); -#else /* ! ACE_LACKS_LONGLONG_T */ - this->sum2_ = value * value; -#endif /* ! ACE_LACKS_LONGLONG_T */ } else { @@ -48,12 +41,7 @@ ACE_Basic_Stats::sample (ACE_UINT64 value) this->max_ = value; this->max_at_ = this->samples_count_; } - - this->sum_ += value; -#if defined ACE_LACKS_LONGLONG_T - this->sum2_ += value * ACE_U64_TO_U32 (value); -#else /* ! ACE_LACKS_LONGLONG_T */ - this->sum2_ += value * value; -#endif /* ! ACE_LACKS_LONGLONG_T */ } + + this->sum_ += value; } diff --git a/ace/DLL_Manager.cpp b/ace/DLL_Manager.cpp index 8d1e75c6660..c5f81f9ade4 100644 --- a/ace/DLL_Manager.cpp +++ b/ace/DLL_Manager.cpp @@ -126,6 +126,12 @@ ACE_DLL_Handle::open (const ACE_TCHAR *dll_name, ACE_TString *name = 0; while (name_iter.next (name)) { + if (ACE::debug ()) + ACE_DEBUG ((LM_DEBUG, + ACE_LIB_TEXT ("ACE_DLL_Handle::open: Trying to open DLL %s with %s name\n"), + this->dll_name_, + name->c_str ())); + // The ACE_SHLIB_HANDLE object is obtained. this->handle_ = ACE_OS::dlopen (name->c_str (), open_mode); diff --git a/bin/tao_other_tests.lst b/bin/tao_other_tests.lst index 9be78dfecc9..816aebbc7e6 100644 --- a/bin/tao_other_tests.lst +++ b/bin/tao_other_tests.lst @@ -30,6 +30,7 @@ TAO/performance-tests/Sequence_Latency/Deferred/run_test.pl: !MINIMUM TAO/performance-tests/Throughput/run_test.pl TAO/performance-tests/POA/Object_Creation_And_Registration/run_test.pl TAO/performance-tests/RTCorba/Oneways/Reliable/run_test.pl: !MINIMUM +TAO/performance-tests/Protocols/run_test.pl TAO/examples/POA/Adapter_Activator/run_test.pl: !MINIMUM !SUNCC5_1 TAO/examples/POA/POA_BiDir/run_test.pl: !MINIMUM !DISABLE_BIDIR TAO/examples/POA/DSI/run_test.pl: !MINIMUM diff --git a/performance-tests/SCTP/SOCK_SEQPACK_srv.cpp b/performance-tests/SCTP/SOCK_SEQPACK_srv.cpp index 0191628c60c..2e34329f788 100644 --- a/performance-tests/SCTP/SOCK_SEQPACK_srv.cpp +++ b/performance-tests/SCTP/SOCK_SEQPACK_srv.cpp @@ -283,7 +283,7 @@ int main(int argc, char **argv){ ACE_OS::inet_ntoa( addresses[0].sin_addr) )); unsigned int i; - for(i=1; i < serverAddr.get_num_secondary_addresses() ; ++i ) { + for(i=1; i <= serverAddr.get_num_secondary_addresses() ; ++i ) { ACE_DEBUG((LM_DEBUG, " and %s", ACE_OS::inet_ntoa( addresses[i].sin_addr) )); } ACE_DEBUG((LM_DEBUG, "\n" )); |