test_i::test_i (CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
RTCORBA::RTORB_ptr rtorb,
CORBA::PolicyManager_ptr policy_manager,
test_ptr receiver)
: orb_ (CORBA::ORB::_duplicate (orb)),
poa_ (PortableServer::POA::_duplicate (poa)),
rtorb_ (RTCORBA::RTORB::_duplicate (rtorb)),
policy_manager_ (CORBA::PolicyManager::_duplicate (policy_manager)),
receiver_ (test::_duplicate (receiver))
{
// 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::ProtocolList protocols;
protocols.length (1);
protocols[0].transport_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
protocols[0].orb_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
// IIOP is always used for the base protocol.
protocols[0].protocol_type = 0;
// User decides the test protocol.
this->base_protocol_policy_[0] =
this->rtorb_->create_client_protocol_policy (protocols);
}
/* static */
void
TAO_POA_RT_Policy_Validator::server_protocol_policy_from_acceptor_registry (RTCORBA::ProtocolList &protocols,
TAO_Acceptor_Registry &acceptor_registry,
TAO_ORB_Core &orb_core)
{
TAO_AcceptorSetIterator end = acceptor_registry.end ();
for (TAO_AcceptorSetIterator acceptor = acceptor_registry.begin ();
acceptor != end;
++acceptor)
{
if (*acceptor == 0)
continue;
CORBA::ULong current_length = protocols.length ();
// Make sure that this protocol is not already in the protocol
// list.
bool protocol_already_present = false;
for (CORBA::ULong i = 0;
i < current_length && !protocol_already_present;
++i)
{
if (protocols[i].protocol_type == (*acceptor)->tag ())
protocol_already_present = true;
}
if (protocol_already_present)
continue;
protocols.length (current_length + 1);
protocols[current_length].protocol_type =
(*acceptor)->tag ();
protocols[current_length].orb_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
protocols[current_length].transport_protocol_properties =
TAO_Protocol_Properties_Factory::create_transport_protocol_property ((*acceptor)->tag (),
&orb_core);
}
}
int
Worker_Thread::svc (void)
{
try
{
// RTORB.
CORBA::Object_var object =
this->orb_->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in ());
if (check_for_nil (rt_orb.in (), "RTORB") == -1)
return 0;
// PolicyCurrent.
object =
this->orb_->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
if (check_for_nil (policy_current.in (), "PolicyCurrent")
== -1)
return 0;
object =
this->orb_->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (object.in ());
// We need to set the client thread CORBA priority
current->the_priority (get_implicit_thread_CORBA_priority (this->orb_));
// Set ClientProtocolPolicy override on the Current.
RTCORBA::ProtocolList protocols;
protocols.length (1);
protocols[0].protocol_type = this->protocol_type_;
protocols[0].transport_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
protocols[0].orb_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
CORBA::PolicyList policy_list;
policy_list.length (1);
policy_list[0] =
rt_orb->create_client_protocol_policy (protocols);
policy_current->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
// Wait for other threads.
this->synchronizer_->wait ();
for (int i = 0; i < iterations; ++i)
{
// Invoke method.
this->server_->test_method ();
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Worker Thread exception:");
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::Object_var object;
// ORB.
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Parse arguments.
if (parse_args (argc, argv) != 0)
return -1;
// RootPOA.
object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (object.in ());
// POAManager.
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Servant.
Test_i servant (orb.in ());
// Create the first object in Root POA
create_object (root_poa.in (),
orb.in (),
&servant,
simple_servant_ior_file);
object =
orb->resolve_initial_references ("NetworkPriorityMappingManager");
RTCORBA::NetworkPriorityMappingManager_var mapping_manager =
RTCORBA::NetworkPriorityMappingManager::_narrow (object.in ());
Custom_Network_Priority_Mapping *cnpm = 0;
ACE_NEW_RETURN (cnpm,
Custom_Network_Priority_Mapping,
-1);
cnpm->corba_priority (corba_priority);
mapping_manager->mapping (cnpm);
// RTORB.
object =
orb->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb =
RTCORBA::RTORB::_narrow (object.in ());
// Set transport protocol properties
RTCORBA::TCPProtocolProperties_var tcp_properties =
rt_orb->create_tcp_protocol_properties (ACE_DEFAULT_MAX_SOCKET_BUFSIZ,
ACE_DEFAULT_MAX_SOCKET_BUFSIZ,
1,
0,
1,
1);
RTCORBA::ProtocolList protocols;
protocols.length (1);
protocols[0].protocol_type = 0;
protocols[0].transport_protocol_properties =
RTCORBA::ProtocolProperties::_duplicate (tcp_properties.in ());
protocols[0].orb_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
CORBA::PolicyList policy_list;
policy_list.length (1);
policy_list[0] =
rt_orb->create_server_protocol_policy (protocols);
// Create POA with Diffserv enabled
PortableServer::POA_var poa_with_diffserv =
root_poa->create_POA ("POA_WITH_DS",
poa_manager.in (),
policy_list);
// Create object 2.
create_object (poa_with_diffserv.in (),
orb.in (),
&servant,
diffserv_servant_ior_file);
// Activate POA manager.
poa_manager->activate ();
// Start ORB event loop.
orb->run ();
ACE_DEBUG ((LM_DEBUG, "Server ORB event loop finished\n\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Unexpected exception caught:");
return -1;
}
return 0;
}
void
test_i::start_test (CORBA::Long session_id,
const char *protocol,
CORBA::ULong invocation_rate,
CORBA::ULong message_size,
CORBA::ULong iterations)
{
RTCORBA::ProtocolList protocols;
protocols.length (1);
protocols[0].transport_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
protocols[0].orb_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
if (ACE_OS::strcmp (protocol, "DIOP") == 0)
{
if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "test protocol is DIOP\n"));
protocols[0].protocol_type = TAO_TAG_DIOP_PROFILE;
}
else if (ACE_OS::strcmp (protocol, "SCIOP") == 0)
{
if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "test protocol is SCIOP\n"));
protocols[0].protocol_type = TAO_TAG_SCIOP_PROFILE;
}
else
{
if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "test protocol is IIOP\n"));
protocols[0].protocol_type = 0;
}
this->test_protocol_policy_[0] =
this->rtorb_->create_client_protocol_policy (protocols);
// Make sure we have a connection to the server using the test
// protocol.
this->policy_manager_->set_policy_overrides (this->test_protocol_policy_,
CORBA::SET_OVERRIDE);
// Since the network maybe unavailable temporarily, make sure to try
// for a few times before giving up.
for (int j = 0;;)
{
test_protocol_setup:
try
{
// Send a message to ensure that the connection is setup.
this->receiver_->oneway_sync ();
goto test_protocol_success;
}
catch (const CORBA::TRANSIENT&)
{
++j;
if (j < number_of_connection_attempts)
{
ACE_OS::sleep (1);
goto test_protocol_setup;
}
}
ACE_ERROR ((LM_ERROR,
"Cannot setup test protocol\n"));
throw CORBA::TRANSIENT (CORBA::OMGVMCID | 2, CORBA::COMPLETED_NO);
}
test_protocol_success:
// Use IIOP for setting up the test since the test protocol maybe
// unreliable.
this->policy_manager_->set_policy_overrides (this->base_protocol_policy_,
CORBA::SET_OVERRIDE);
// Since the network maybe unavailable temporarily, make sure to try
// for a few times before giving up.
for (int k = 0;;)
{
base_protocol_setup:
try
{
// Let the server know what to expect..
this->receiver_->start_test (session_id,
protocol,
invocation_rate,
message_size,
iterations);
goto base_protocol_success;
}
catch (const CORBA::TRANSIENT&)
{
ACE_OS::sleep (1);
if (k < number_of_connection_attempts)
{
ACE_OS::sleep (1);
goto base_protocol_setup;
}
}
ACE_ERROR ((LM_ERROR,
"Cannot setup base protocol\n"));
throw CORBA::TRANSIENT (CORBA::OMGVMCID | 2, CORBA::COMPLETED_NO);
}
base_protocol_success:
// Select the test protocol for these invocation.
this->policy_manager_->set_policy_overrides (this->test_protocol_policy_,
CORBA::SET_OVERRIDE);
}
Worker::Worker (CORBA::ORB_ptr orb,
RTCORBA::RTORB_ptr rtorb,
CORBA::PolicyManager_ptr policy_manager,
Protocols::test_ptr test,
::CORBA::ULong iterations,
::CORBA::ULong invocation_rate,
::CORBA::Boolean count_missed_end_deadlines,
::CORBA::Boolean do_dump_history,
::CORBA::Boolean print_missed_invocations,
::CORBA::ULong message_size,
::CORBA::ULong test_protocol_tag,
::CORBA::ULong number_of_connection_attempts,
::CORBA::Boolean enable_diffserv_code_points,
::Protocols::Sender_Controller::Test_Type test_type)
: rtorb_ (RTCORBA::RTORB::_duplicate (rtorb)),
policy_manager_ (CORBA::PolicyManager::_duplicate (policy_manager)),
test_ (Protocols::test::_duplicate (test)),
history_ (iterations),
interval_between_calls_ (),
missed_start_deadlines_ (0),
missed_end_deadlines_ (0),
missed_start_invocations_ (iterations),
missed_end_invocations_ (iterations),
iterations_ (iterations),
invocation_rate_ (invocation_rate),
count_missed_end_deadlines_ (count_missed_end_deadlines),
do_dump_history_ (do_dump_history),
print_missed_invocations_ (print_missed_invocations),
message_size_ (message_size),
test_protocol_tag_ (test_protocol_tag),
number_of_connection_attempts_ (number_of_connection_attempts),
enable_diffserv_code_points_ (enable_diffserv_code_points),
test_type_ (test_type)
{
// Each sender will have a random session id. This helps in
// identifying late packets arriving at the server.
ACE_OS::srand ((unsigned) ACE_OS::time (0));
this->session_id_ = ACE_OS::rand ();
// Interval is inverse of rate.
this->interval_between_calls_ =
to_hrtime (1 / double (this->invocation_rate_), gsf);
// 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 (this->enable_diffserv_code_points_);
RTCORBA::ProtocolList protocols;
protocols.length (1);
protocols[0].transport_protocol_properties =
base_transport_protocol_properties;
protocols[0].orb_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
// IIOP is always used for the base protocol.
protocols[0].protocol_type = IOP::TAG_INTERNET_IOP;
this->base_protocol_policy_[0] =
this->rtorb_->create_client_protocol_policy (protocols);
// User decides the test protocol.
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,
orb->orb_core ());
if (protocols[0].protocol_type == TAO_TAG_DIOP_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);
}
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);
}
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);
}
protocols[0].transport_protocol_properties =
test_transport_protocol_properties;
this->test_protocol_policy_[0] =
this->rtorb_->create_client_protocol_policy (protocols);
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
orb = CORBA::ORB_init (argc, argv);
CORBA::Object_var object =
orb->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb =
RTCORBA::RTORB::_narrow (object.in ());
// Set the tcp protocol properties
RTCORBA::TCPProtocolProperties_var tcp_properties =
rt_orb->create_tcp_protocol_properties (ACE_DEFAULT_MAX_SOCKET_BUFSIZ,
ACE_DEFAULT_MAX_SOCKET_BUFSIZ,
1, 0, 1, 0);
RTCORBA::ProtocolList protocols;
protocols.length (1);
protocols[0].protocol_type = 0;
protocols[0].transport_protocol_properties =
RTCORBA::ProtocolProperties::_duplicate (tcp_properties.in ());
protocols[0].orb_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
CORBA::PolicyList policy_list;
policy_list.length (1);
policy_list[0] =
rt_orb->create_client_protocol_policy (protocols);
object = orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow (object.in ());
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
// start the failsafe thread. It will expire in 10 seconds and
// terminate with a failure if the following does not complete.
ACE_Thread::spawn (failsafe);
object = orb->string_to_object ("corbaloc::localhost:5678/Test");
Test::Hello_var hello = Test::Hello::_narrow(object.in());
is_ok = true;
test_lock.acquire ();
cond.signal();
test_lock.release ();
ACE_DEBUG ((LM_DEBUG, "SUCCESS: test did not spin.\n"));
CORBA::String_var the_string = hello->get_string ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C>\n",
the_string.in ()));
hello->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
void
TAO_RT_Invocation_Endpoint_Selector::select_endpoint_based_on_client_protocol_policy (
TAO::Profile_Transport_Resolver &r,
RTCORBA::ClientProtocolPolicy_ptr client_protocol_policy,
RTCORBA::ProtocolList &client_protocols,
ACE_Time_Value *val)
{
CORBA::Boolean valid_profile_found = false;
// Even though cycling through all the protocols is the correct
// things to do to find a match, starting from the start of the
// profile list is not. In addition, this code is also ignoring the
// forwarded reference (if it exists). This behavior is caused by
// problems with the profile management in TAO which are documented
// in bugzilla bugs 1237, 1238, and 1239. Once the above problems
// are fixed, this behavior should be fixed to do the right thing.
for (CORBA::ULong protocol_index = 0;
protocol_index < client_protocols.length ();
++protocol_index)
{
// Find the profiles that match the current protocol.
TAO_Profile *profile = 0;
TAO_MProfile &mprofile = (r.stub ()->forward_profiles() == 0) ?
r.stub ()->base_profiles () : *r.stub ()->forward_profiles();
for (TAO_PHandle i = 0;
i < mprofile.profile_count ();
++i)
{
profile = mprofile.get_profile (i);
if (profile->tag () == client_protocols[protocol_index].protocol_type)
{
valid_profile_found = true;
r.profile (profile);
if (this->endpoint_from_profile (r, val) == 1)
return;
// @@ Else we should check for potential forwarding here.
}
}
}
// We have tried all the profiles specified in the client protocol
// policy with no success. Throw exception.
if (!valid_profile_found)
{
CORBA::PolicyList *p = r.inconsistent_policies ();
if (p)
{
p->length (1);
(*p)[0u] = CORBA::Policy::_duplicate (client_protocol_policy);
}
throw ::CORBA::INV_POLICY ();
}
// If we get here, we completely failed to find an endpoint
// that we know how to use. We used to throw an exception
// but that would prevent any request interception points
// being called. They may know how to fix the problem so
// we wait to throw the exception in
// Synch_Twoway_Invocation::remote_twoway and
// Synch_Oneway_Invocation::remote_oneway instead.
}