int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc,
argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return -1;
test_i servant (orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&servant);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
test_var server =
test::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
FILE *output_file = ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
-1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
Event_Loop_Task event_loop_task (orb.in ());
if (event_loop_task.activate (THR_NEW_LWP | THR_JOINABLE,
number_of_event_loop_threads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate event_loop threads\n"),
-1);
event_loop_task.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG, "Server: Event loop finished\n"));
root_poa->destroy (1,
1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return -1;
}
return 0;
}
void
EDF_Scheduler::receive_request (PortableInterceptor::ServerRequestInfo_ptr ri,
RTScheduling::Current::IdType_out guid_out,
CORBA::String_out /*name*/,
CORBA::Policy_out sched_param_out,
CORBA::Policy_out /*implicit_sched_param_out*/)
{
Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr;
RTScheduling::Current::IdType guid;
int int_guid;
DSUI_EVENT_LOG (EDF_SCHED_FAM, ENTER_SERVER_SCHED_TIME, 0, 0, 0);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T):entered EDF_Scheduler::receive_request\n"));
#endif
CORBA::String_var operation = ri->operation ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): receive_request from "
"\"%s\"\n",
operation.in ()));
#endif
// Ignore the "_is_a" operation since it may have been invoked
// locally on the server side as a side effect of another call,
// meaning that the client hasn't added the service context yet.
if (ACE_OS::strcmp ("_is_a", operation.in ()) == 0)
return;
IOP::ServiceContext_var sc =
ri->get_request_service_context (Server_Interceptor::SchedulingInfo);
CORBA::Long importance;
TimeBase::TimeT deadline;
TimeBase::TimeT period;
CORBA::Long task_id=-1;
if (sc.ptr () == 0)
{
//Since send_request will add an QoS for any request, why can this case happen?
//24 hrs from now - infinity
ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0);
deadline = deadline_tv.sec ()*1000000 + deadline_tv.usec ()*10; //100s of nanoseconds for TimeBase::TimeT
importance = 0;
period = 0;
// task_id = ID_BEGIN ++;
}
else
{
CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (),
sc->context_data.length (),
sc->context_data.get_buffer (),
0);
CORBA::Any sc_qos_as_any;
CORBA::Any_var scqostmp = codec_->decode (oc_seq);
sc_qos_as_any = scqostmp.in ();
//Don't store in a _var, since >>= returns a pointer to an
//internal buffer and we are not supposed to free it.
sc_qos_as_any >>= sc_qos_ptr;
deadline = sc_qos_ptr->deadline;
importance = sc_qos_ptr->importance;
period = sc_qos_ptr->period;
task_id = sc_qos_ptr->task_id;
guid.length (sc_qos_ptr->guid.length ());
guid_copy (guid, sc_qos_ptr->guid);
ACE_NEW (guid_out.ptr (),
RTScheduling::Current::IdType);
guid_out.ptr ()->length (guid.length ());
*(guid_out.ptr ()) = guid;
ACE_OS::memcpy (&int_guid,
guid.get_buffer (),
guid.length ());
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): Importance = %d, guid = %d "
"in recvd service context\n",
importance,
int_guid));
#endif
EDF_Scheduling::SchedulingParameter sched_param;
sched_param.importance = importance;
sched_param.deadline = deadline;
sched_param.period = period;
sched_param.task_id = task_id;
sched_param_out = this->create_scheduling_parameter (sched_param);
}
EDF_Scheduler_Traits::QoSDescriptor_t qos;
qos.importance_ = importance;
qos.deadline_ = deadline;
qos.period_ = period;
qos.task_id_ = task_id;
DSUI_EVENT_LOG (EDF_SCHED_FAM, ENTER_SERVER_DISPATCH_SCHEDULE, int_guid, 0, 0);
/*DTTIME:
record the entering dispatcher time on the server side.
Tenth Time.
*/
#ifdef KOKYU_HAS_RELEASE_GUARD
this->kokyu_dispatcher_->release_guard (guid, qos);
#else
this->kokyu_dispatcher_->schedule (guid, qos);
#endif
/*DTTIME:
record the leaving dispatcher time on the server side.
Eleventh Time.
*/
DSUI_EVENT_LOG (EDF_SCHED_FAM, LEAVE_SERVER_DISPATCH_SCHEDULE, int_guid, 0, 0);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T): receive_request interceptor done\n"));
#endif
DSUI_EVENT_LOG (EDF_SCHED_FAM, LEAVE_SERVER_SCHED_TIME, 0, 0, 0);
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Policies for the childPOA to be created.
CORBA::PolicyList policies (1);
policies.length (1);
CORBA::Any pol;
pol <<= BiDirPolicy::BOTH;
policies[0] =
orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE,
pol);
// Create POA as child of RootPOA with the above policies. This POA
// will receive request in the same connection in which it sent
// the request
PortableServer::POA_var child_poa =
root_poa->create_POA ("childPOA",
poa_manager.in (),
policies);
// Creation of childPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return 1;
Simple_Server_i server_impl (orb.in (),
no_iterations);
PortableServer::ObjectId_var id =
PortableServer::string_to_ObjectId ("simple_server");
child_poa->activate_object_with_id (id.in (),
&server_impl);
CORBA::Object_var obj =
child_poa->id_to_reference (id.in ());
CORBA::String_var ior =
orb->object_to_string (obj.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
int retval = 0;
while (retval == 0)
{
// Just process one upcall. We know that we would get the
// clients IOR in that call.
CORBA::Boolean pending =
orb->work_pending();
if (pending)
{
orb->perform_work();
}
// Now that hopefully we have the clients IOR, just start
// making remote calls to the client.
retval = server_impl.call_client ();
}
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
root_poa->destroy (1, 1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
void
DDS_Write_T<CCM_TYPE, TYPED_WRITER, VALUE_TYPE, SEQ_VALUE_TYPE>::configuration_complete (
::DDS::Topic_ptr topic,
::DDS::Publisher_ptr publisher,
const char * qos_profile,
DDS_XML_QOS_PARSER_TYPE* qos_xml)
{
DDS4CCM_TRACE ("DDS_Write_T<CCM_TYPE, TYPED_WRITER, VALUE_TYPE, SEQ_VALUE_TYPE>::configuration_complete");
::DDS::DataWriter_var dw = this->dds_write_->get_dds_writer ();
if (::CORBA::is_nil (dw.in ()))
{
::DDS::DataWriter_var dwv_tmp;
#if (CIAO_DDS4CCM_NDDS==1)
if (qos_profile)
{
dwv_tmp = publisher->create_datawriter_with_profile (
topic,
qos_profile,
::DDS::DataWriterListener::_nil (),
0);
}
else
#endif
{
::DDS::DataWriterQos dwqos;
DDS::ReturnCode_t const retcode =
publisher->get_default_datawriter_qos (dwqos);
if (retcode != DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Write_T::configuration_complete - "
"Error: Unable to retrieve get_default_datawriter_qos: <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retcode)));
throw ::CCM_DDS::InternalError (retcode, 0);
}
if (qos_profile && qos_xml)
{
CORBA::String_var name = topic->get_name ();
DDS::ReturnCode_t const retcode_dw_qos = qos_xml->get_datawriter_qos (
dwqos,
qos_profile,
name.in ());
if (retcode_dw_qos != DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Write_T::configuration_complete - "
"Error: Unable to retrieve datawriter QOS from XML: <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retcode_dw_qos)));
throw ::CCM_DDS::InternalError (retcode_dw_qos, 0);
}
}
#if defined GEN_OSTREAM_OPS
if (DDS4CCM_debug_level >= DDS4CCM_LOG_LEVEL_DDS_STATUS)
{
std::stringstream output;
output << dwqos;
std::string message = output.str();
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_DDS_STATUS, (LM_INFO, DDS4CCM_INFO
ACE_TEXT ("DDS_Update_T::configuration_complete - ")
ACE_TEXT ("Using datawriter QOS <%C>\n"), message.c_str()));
}
#endif
dwv_tmp = publisher->create_datawriter (
topic,
dwqos,
::DDS::DataWriterListener::_nil (),
0);
}
if (!::CORBA::is_nil (dwv_tmp.in ()))
{
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_TRACE, DDS4CCM_INFO
"DDS_Write_T::configuration_complete - "
"Created datawriter "
DDS_ENTITY_FORMAT_SPECIFIER
" using publisher "
DDS_ENTITY_FORMAT_SPECIFIER
"\n",
DDS_ENTITY_LOG (dwv_tmp.in ()),
DDS_ENTITY_LOG (publisher)));
}
else
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
"DDS_Write_T::configuration_complete - "
"Error: DDS returned a nil datawriter.\n"));
throw ::CORBA::INTERNAL ();
}
this->dds_write_->set_dds_writer (dwv_tmp.in ());
this->ccm_data_writer_->set_dds_entity (dwv_tmp.in ());
DDS::ReturnCode_t const retcode = dwv_tmp->enable ();
if (retcode != ::DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Write_T::configuration_complete - "
"Error: Unable to enable the datawriter: <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retcode)));
throw ::CORBA::INTERNAL ();
}
}
}
CORBA::TypeCode_ptr
TAO_Repository_i::get_canonical_typecode_i (CORBA::TypeCode_ptr tc)
{
CORBA::TCKind kind = tc->kind ();
switch (kind)
{
// For all the TCKinds not covered below, no change is needed.
default:
return CORBA::TypeCode::_duplicate (tc);
case CORBA::tk_fixed:
throw CORBA::NO_IMPLEMENT ();
case CORBA::tk_array:
{
CORBA::ULong length = tc->length ();
CORBA::TypeCode_var ctype = tc->content_type ();
CORBA::TypeCode_var canon_ctype =
this->get_canonical_typecode_i (ctype.in ());
return this->tc_factory ()->create_array_tc (length,
canon_ctype.in ());
}
case CORBA::tk_sequence:
{
CORBA::ULong length = tc->length ();
CORBA::TypeCode_var ctype = tc->content_type ();
CORBA::TypeCode_var canon_ctype =
this->get_canonical_typecode_i (ctype.in ());
return this->tc_factory ()->create_sequence_tc (length,
canon_ctype.in ());
}
case CORBA::tk_alias:
case CORBA::tk_objref:
case CORBA::tk_struct:
case CORBA::tk_union:
case CORBA::tk_enum:
case CORBA::tk_except:
case CORBA::tk_value:
case CORBA::tk_value_box:
case CORBA::tk_native:
case CORBA::tk_abstract_interface:
case CORBA::tk_component:
case CORBA::tk_home:
{
CORBA::String_var id = tc->id ();
ACE_TString path;
int status =
this->config ()->get_string_value (this->repo_ids_key (),
id.in (),
path);
// TODO - something in case the repo id is an empty string,
// or if it is not found in this repository
if (status != 0)
{
return CORBA::TypeCode::_nil ();
}
ACE_Configuration_Section_Key key;
this->config ()->expand_path (this->root_key (),
path,
key,
0);
// An ExceptionDef is not an IDLType.
if (kind == CORBA::tk_except)
{
TAO_ExceptionDef_i impl (this->repo_);
impl.section_key (key);
return impl.type_i ();
}
else
{
TAO_IDLType_i *impl =
TAO_IFR_Service_Utils::path_to_idltype (path,
this);
impl->section_key (key);
return impl->type_i ();
}
}
}
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager = root_poa->the_POAManager ();
// Policies for the childPOA to be created.
CORBA::PolicyList policies (1);
policies.length (1);
CORBA::Any pol;
pol <<= BiDirPolicy::BOTH;
policies[0] =
orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, pol);
// Create POA as child of RootPOA with the above policies. This POA
// will receive request in the same connection in which it sent
// the request
PortableServer::POA_var child_poa =
root_poa->create_POA ("childPOA", poa_manager.in (), policies);
// Creation of childPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0; i < policies.length (); ++i)
{
policies[i]->destroy ();
}
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object = orb->string_to_object (ior);
Simple_Server_var server = Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%C> is nil\n",
ior),
1);
}
Callback_i callback_impl (orb.in ());
PortableServer::ObjectId_var id =
PortableServer::string_to_ObjectId ("client_callback");
child_poa->activate_object_with_id (id.in (), &callback_impl);
CORBA::Object_var callback_object =
child_poa->id_to_reference (id.in ());
Callback_var callback = Callback::_narrow (callback_object.in ());
CORBA::String_var ior = orb->object_to_string (callback.in ());
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Client callback activated as <%C>\n",
ior.in ()));
// Send the calback object to the server
server->callback_object (callback.in ());
int pre_call_connections =
orb->orb_core ()->lane_resources ().transport_cache ().current_size ();
// A method to kickstart callbacks from the server
CORBA::Long r = server->test_method (1);
if (r != 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) unexpected result = %d ",
r));
}
orb->run ();
int cur_connections =
orb->orb_core ()->lane_resources ().transport_cache ().current_size ();
if (cur_connections > pre_call_connections)
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) Expected %d "
"connections in the transport cache, but found "
"%d instead. Aborting.\n",
pre_call_connections,
cur_connections));
ACE_OS::abort ();
}
root_poa->destroy (1, 1);
}
catch (CORBA::Exception &excep)
{
excep._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
ACE_DEBUG ((LM_DEBUG,
"Middle (%P|%t) started\n"));
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc,
argv);
if ( ! parse_args (argc, argv))
{
return -1;
}
///////////////////////////////
// Prepare to be a CORBA server
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
///////////////////////////////
// Prepare to be a CORBA client
FILE *input_file = ACE_OS::fopen (ior_input_file, "r");
if (input_file == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open input IOR file: %s",
ior_input_file),
-1);
}
ACE_OS::fread (input_ior, 1, sizeof(input_ior), input_file);
ACE_OS::fclose (input_file);
// Convert the IOR to an object reference.
CORBA::Object_var object =
orb->string_to_object (input_ior);
// narrow the object reference to a ThreeTier reference
ThreeTier_var target = ThreeTier::_narrow (object.in ());
if (CORBA::is_nil (target.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"IOR does not refer to a ThreeTier implementation"),
-1);
}
// We should have a good connection now
// temporary: check it out
//target->tick();
//target->tock();
Middle_i middle (orb.in(), target.in ());
if (middle.parse_args (argc, argv) )
{
/////////////////////////////////
// Activate server side mechanism
PortableServer::ObjectId_var id =
root_poa->activate_object (&middle);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
ThreeTier_var server =
ThreeTier::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
FILE *output_file = ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
-1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
orb->run ();
}
}
catch (const CORBA::UserException& userex)
{
userex._tao_print_exception ("Middle: User Exception in main");
return -1;
}
catch (const CORBA::SystemException& sysex)
{
sysex._tao_print_exception ("Middle: System Exception in main");
return -1;
}
ACE_DEBUG ((LM_DEBUG,
"Middle (%P|%t) exits\n"));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv, "PerformanceServer");
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Install a persistent POA in order to achieve a persistent IOR
// for our object.
//*
CORBA::PolicyList policies;
policies.length (2);
policies[0] =
root_poa->create_lifespan_policy(PortableServer::PERSISTENT);
policies[1] =
root_poa->create_id_assignment_policy (PortableServer::USER_ID);
PortableServer::POA_var persistent_poa =
root_poa->create_POA("persistent",
poa_manager.in (),
policies);
policies[0]->destroy ();
policies[1]->destroy ();
if (parse_args (argc, argv) != 0)
return 1;
UDP_i udp_i;
udp_i.orb (orb.in ());
PortableServer::ObjectId_var id =
PortableServer::string_to_ObjectId ("UDP_Object");
persistent_poa->activate_object_with_id (id.in (),
&udp_i);
CORBA::Object_var obj =
persistent_poa->id_to_reference (id.in ());
UDP_var udp_var = UDP::_narrow (obj.in ());
if (CORBA::is_nil (udp_var.in ()))
ACE_DEBUG ((LM_DEBUG,
"Failed to narrow correct object reference.\n"));
CORBA::String_var ior =
orb->object_to_string (udp_var.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
poa_manager->activate ();
if (orb_threads > 1)
ACE_Thread_Manager::instance ()->spawn_n (orb_threads-1,
svc,
orb.in ());
orb->run ();
ACE_DEBUG ((LM_DEBUG, "ORB finished\n"));
root_poa->destroy (1, // ethernalize objects
0 // wait for completion
);
orb->destroy ();
ACE_Thread_Manager::instance ()->wait ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int
Server_Task::svc (void)
{
try
{
CORBA::Object_var poa_object =
this->sorb_->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
Visual_i *vi = 0;
ACE_NEW_RETURN (vi, Visual_i (sorb_.in ()), 1);
PortableServer::ServantBase_var server_impl = vi;
PortableServer::ObjectId_var id =
root_poa->activate_object (server_impl.in());
CORBA::Object_var test_obj =
root_poa->id_to_reference (id.in ());
Test_Interceptors::Visual_var server =
Test_Interceptors::Visual::_narrow (test_obj.in ());
CORBA::String_var ior =
sorb_->object_to_string (server.in ());
// If the ior_output_file exists, output the ior to it
if (output_ != 0)
{
FILE *output_file= ACE_OS::fopen (output_, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
output_),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
// Signal the main thread before we call orb->run ();
this->me_.signal ();
sorb_->run ();
struct timespec ts = {0,250000000}; // quarter second
ACE_OS::nanosleep (&ts);
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server task - event loop finished\n"));
root_poa->destroy (1, 1);
this->sorb_->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in server task:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
if (parse_args (argc, argv) != 0)
return 1;
PortableServer::Servant_var<Server> impl;
{
Server * tmp;
// ACE_NEW_RETURN is the worst possible way to handle
// exceptions (think: what if the constructor allocates memory
// and fails?), but I'm not in the mood to fight for a more
// reasonable way to handle allocation errors in ACE.
ACE_NEW_RETURN (tmp,
Server(orb.in()),
1);
impl = tmp;
}
PortableServer::ObjectId_var id =
root_poa->activate_object (impl.in ());
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
Test::Server_var server =
Test::Server::_narrow (object_act.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
// If the ior_output_file exists, output the ior to it
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
ORB_Task task(orb.in());
task.activate(THR_NEW_LWP | THR_JOINABLE, 4, 1);
task.wait();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
/// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc,
argv,
"gateway_server_orb");
if (parse_args (argc, argv) != 0)
return -1;
/// Resolve reference to RootPOA
CORBA::Object_var obj =
orb->resolve_initial_references ("RootPOA");
/// Narrow it down correctly.
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (obj.in ());
/// Check for nil references
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
"Unable to obtain RootPOA reference.\n"),
-1);
/// Get poa_manager reference
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
/// Activate it.
poa_manager->activate ();
///@}
CORBA::PolicyList policies (3);
policies.length (3);
policies [0] =
root_poa->create_servant_retention_policy (PortableServer::RETAIN);
policies [1] =
root_poa->create_request_processing_policy (PortableServer::USE_DEFAULT_SERVANT);
policies [2] =
root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID);
PortableServer::POA_var gateway_poa =
root_poa->create_POA ("Gateway_POA",
poa_manager.in (),
policies);
for (CORBA::ULong i = 0; i != policies.length (); ++i) {
policies[i]->destroy ();
}
// Get the POA Current object reference
obj =
orb->resolve_initial_references ("POACurrent");
// Narrow the object reference to a POA Current reference
PortableServer::Current_var poa_current =
PortableServer::Current::_narrow (obj.in ());
Gateway_i *gateway;
ACE_NEW_THROW_EX (gateway,
Gateway_i (orb.in (),
poa_current.in ()),
CORBA::NO_MEMORY ());
gateway_poa->set_servant (gateway);
/// Get the ObjectID
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId ("Object_Factory");
/// This class is used to create a object reference.
Object_Factory_i *object_factory;
ACE_NEW_THROW_EX (object_factory,
Object_Factory_i (orb.in (),
gateway_poa.in ()),
CORBA::NO_MEMORY ());
/// Activate the Object_Factory_i Object
gateway_poa->activate_object_with_id (oid.in (),
object_factory);
// Get the object reference.
CORBA::Object_var gateway_object_factory =
gateway_poa->id_to_reference (oid.in ());
/// Convert the object reference to a string format.
CORBA::String_var ior =
orb->object_to_string (gateway_object_factory.in ());
/// If the ior_output_file exists, output the IOR to it.
if (ior_output_file != 0)
{
FILE *output_file = ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing "
"IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
orb->run ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("ORT test (gateway_server):");
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
Server_ORBInitializer2 *temp_initializer = 0;
ACE_NEW_RETURN (temp_initializer,
Server_ORBInitializer2,
-1); // No exceptions yet!
PortableInterceptor::ORBInitializer_var orb_initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (orb_initializer.in ());
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
-1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
CORBA::PolicyList policies (2);
policies.length (2);
policies[0] =
root_poa->create_id_assignment_policy (PortableServer::USER_ID);
policies[1] =
root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
PortableServer::POA_var my_poa =
root_poa->create_POA ("my_poa",
poa_manager.in (),
policies);
// Creation of the new POA is over, so destroy the Policy_ptr's.
for (CORBA::ULong i = 0; i < policies.length (); ++i)
{
CORBA::Policy_ptr policy = policies[i];
policy->destroy ();
}
if (parse_args (argc, argv) != 0)
return -1;
Hello *hello_impl = 0;
ACE_NEW_RETURN (hello_impl,
Hello (orb.in (), Test::Hello::_nil (), my_id_number),
-1);
PortableServer::ServantBase_var owner (hello_impl);
PortableServer::ObjectId_var server_id =
PortableServer::string_to_ObjectId ("server_id");
my_poa->activate_object_with_id (server_id.in (),
hello_impl);
CORBA::Object_var hello =
my_poa->id_to_reference (server_id.in ());
CORBA::String_var ior =
orb->object_to_string (hello.in ());
// Output the IOR to the <ior_output_file>
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s\n",
ior_output_file),
-1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
orb->run ();
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int priority =
(ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
+ ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO,
priority);
// Enable FIFO scheduling, e.g., RT scheduling class on Solaris.
if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
priority,
ACE_SCOPE_PROCESS)) != 0)
{
if (ACE_OS::last_error () == EPERM)
{
ACE_DEBUG ((LM_DEBUG,
"server (%P|%t): user is not superuser, "
"test runs in time-shared class\n"));
}
else
ACE_ERROR ((LM_ERROR,
"server (%P|%t): sched_params failed\n"));
}
try
{
ORBInitializer *initializer = 0;
ACE_NEW_RETURN (initializer,
ORBInitializer,
-1); // No exceptions yet!
PortableInterceptor::ORBInitializer_var orb_initializer =
initializer;
PortableInterceptor::register_orb_initializer (orb_initializer.in ());
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
poa_manager->activate ();
CORBA::Object_var lm_object =
orb->resolve_initial_references ("LoadManager");
CosLoadBalancing::LoadManager_var load_manager =
CosLoadBalancing::LoadManager::_narrow (lm_object.in ());
TAO_LB_CPU_Utilization_Monitor * monitor_servant;
ACE_NEW_THROW_EX (monitor_servant,
TAO_LB_CPU_Utilization_Monitor,
CORBA::NO_MEMORY ());
PortableServer::ServantBase_var safe_monitor_servant (monitor_servant);
CosLoadBalancing::LoadMonitor_var load_monitor =
monitor_servant->_this ();
PortableGroup::Location_var location =
load_monitor->the_location ();
CORBA::Object_var roundtrip =
::join_object_group (orb.in (),
load_manager.in (),
location.in ());
TAO_LB_LoadAlert & alert_servant = initializer->load_alert ();
CosLoadBalancing::LoadAlert_var load_alert =
alert_servant._this ();
CORBA::String_var ior =
orb->object_to_string (roundtrip.in ());
// If the ior_output_file exists, output the ior to it
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s\n",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
load_manager->register_load_monitor (location.in (),
load_monitor.in ());
load_manager->register_load_alert (location.in (),
load_alert.in ());
orb->run ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
void
EDF_Scheduler::receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri)
{
int int_guid;
DSUI_EVENT_LOG (EDF_SCHED_FAM, ENTER_RECEIVE_REPLY, 0, 0, 0);
RTScheduling::Current::IdType guid;
CORBA::String_var operation = ri->operation ();
CORBA::Object_var target = ri->target ();
ACE_CString opname = operation.in ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T):receive_reply from "
"\"%s\"\n",
opname.c_str ()));
#endif
// Check that the reply service context was received as
// expected.
IOP::ServiceContext_var sc =
ri->get_reply_service_context (Client_Interceptor::SchedulingInfo);
CORBA::Long importance;
TimeBase::TimeT deadline;
if (sc.ptr () == 0)
{
ACE_DEBUG ((LM_DEBUG, "service context was not filled\n"));
//24 hrs from now - infinity
ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0);
deadline = deadline_tv.sec ()*1000000 + deadline_tv.usec ()*10; //100s of nanoseconds for TimeBase::TimeT
importance = 0;
}
else
{
CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (),
sc->context_data.length (),
sc->context_data.get_buffer (),
0);
//Don't store in a _var, since >>= returns a pointer to an internal buffer
//and we are not supposed to free it.
Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr;
CORBA::Any sc_qos_as_any;
CORBA::Any_var scqostmp = codec_->decode (oc_seq);
sc_qos_as_any = scqostmp.in ();
sc_qos_as_any >>= sc_qos_ptr;
deadline = sc_qos_ptr->deadline;
importance = sc_qos_ptr->importance;
guid.length (sc_qos_ptr->guid.length ());
guid_copy (guid, sc_qos_ptr->guid);
ACE_DEBUG ((LM_DEBUG,
"(%t|%T):Importance = %d in recvd service context\n",
importance));
}
ACE_OS::memcpy (&int_guid,
guid.get_buffer (),
guid.length ());
EDF_Scheduler_Traits::QoSDescriptor_t qos;
qos.deadline_ = qos.importance_ = importance;
qos.deadline_ = deadline;
this->kokyu_dispatcher_->schedule (guid, qos);
DSUI_EVENT_LOG (EDF_SCHED_FAM, EXIT_RECEIVE_REPLY, int_guid, 0, 0);
}
int
Server::svc (void)
{
ACE_hthread_t current;
ACE_Thread::self (current);
int native_priority;
ACE_Thread::getprio (current, native_priority);
ACE_DEBUG ((LM_DEBUG,
"Server orb thread (%t): corba_priority = %d"
" actual native priority = %d\n",
priority_,
native_priority));
try
{
char orb_name[64];
ACE_OS::sprintf (orb_name, "%d", this->priority_);
CORBA::ORB_var orb =
CORBA::ORB_init (argc_, argv_, orb_name);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
PortableServer::ObjectId_var oid =
root_poa->activate_object (this->server_);
CORBA::Object_var obj =
root_poa->id_to_reference (oid.in ());
CORBA::String_var ior =
orb->object_to_string (obj.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// Get the file name to store the ior.
char file_name[100];
ACE_OS::sprintf (file_name,
"%s_%d",
ACE_TEXT_ALWAYS_CHAR (ior_output_file_base),
this->priority_);
// Output the ior to a file.
FILE *output_file= ACE_OS::fopen (file_name, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
file_name),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
// Start orb event loop.
poa_manager->activate ();
orb->run ();
}
catch (const CORBA::Exception& ex)
{
char message[100];
ACE_OS::sprintf (message,
"ORB_per_Priority::server: Exception in thread with priority = %d",
this->priority_);
ex._tao_print_exception (message);
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
// create, activate and initialize AMI reply handler
Test_Reply_i test_i_rh_srv(orb.in (),
max_count,
mode_flag);
PortableServer::ObjectId_var id =
root_poa->activate_object (&test_i_rh_srv);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
A::AMI_TestHandler_var rh =
A::AMI_TestHandler::_narrow (object.in ());
test_i_rh_srv.test_handler ().set_reply_handler (rh.in ());
// create and activate test servant
Test_i test_i_srv (orb.in (), rh.in (), max_count, mode_flag);
id = root_poa->activate_object (&test_i_srv);
object = root_poa->id_to_reference (id.in ());
A::Test_var test_var =
A::Test::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (test_var.in ());
ACE_DEBUG ((LM_DEBUG, "Servant activated\n"));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
poa_manager->activate ();
A::Test_var opponent;
do {
if (mode_flag == A::RM_SLAVE)
ACE_OS::sleep (ACE_Time_Value (0, 100));
// get object reference for opponent
object = orb->string_to_object (input_ior);
opponent = A::Test::_narrow (object.in ());
} while (mode_flag == A::RM_SLAVE && CORBA::is_nil (opponent.in ()));
if (CORBA::is_nil (opponent.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot resolve opponent IOR: %s",
input_ior),
1);
}
// register opponent
test_i_srv.set_opponent (opponent.in ());
test_i_rh_srv.test_handler ().set_opponent (opponent.in ());
// start the show
if (mode_flag == A::RM_MASTER)
test_i_rh_srv.test_handler ().start ();
orb->run ();
root_poa->destroy (1, // ethernalize objects
0 // wait for completion
);
orb->destroy ();
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
TAO_EC_Default_Factory::init_svcs ();
/// Move the test to the real-time class if it is possible.
RT_Class rt_class;
try
{
ORB_Holder orb (argc, argv, "");
if (parse_args (argc, argv) != 0)
return 1;
RTServer_Setup rtserver_setup (use_rt_corba,
orb,
rt_class,
nthreads);
PortableServer::POA_var root_poa =
RIR_Narrow<PortableServer::POA>::resolve (orb,
"RootPOA");
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
PortableServer::POA_var ec_poa (rtserver_setup.poa ());
ORB_Task orb_task (orb);
ORB_Task_Activator orb_task_activator (rt_class.priority_high (),
rt_class.thr_sched_class (),
nthreads,
&orb_task);
ACE_DEBUG ((LM_DEBUG, "Finished ORB and POA configuration\n"));
Servant_var<TAO_EC_Event_Channel> ec_impl (
RTEC_Initializer::create (ec_poa.in (),
ec_poa.in (),
rtserver_setup.rtcorba_setup ())
);
ec_impl->activate ();
PortableServer::ObjectId_var ec_id =
ec_poa->activate_object (ec_impl.in ());
CORBA::Object_var ec_object =
ec_poa->id_to_reference (ec_id.in ());
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow (ec_object.in ());
CORBA::String_var ior =
orb->object_to_string (ec.in ());
// Output the ior to the <ior_output_file>
FILE *output_file = ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
do {
ACE_Time_Value tv (1, 0);
orb->run (tv);
} while (ec_impl->destroyed () == 0);
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try {
// Initialize orb
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
//Get reference to Root POA
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
// Activate POA Manager
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
// Find the Naming Service
obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root =
CosNaming::NamingContextExt::_narrow(obj.in());
if (CORBA::is_nil(root.in())) {
std::cerr << "Nil Naming Context reference" << std::endl;
return 1;
}
// Bind a new context.
CosNaming::Name name;
name.length( 1 );
name[0].id = CORBA::string_dup( "root.esc-dot" );
name[0].kind = CORBA::string_dup( "kind1" );
try {
obj = root->resolve(name);
}
catch(const CosNaming::NamingContext::NotFound&) {
CosNaming::NamingContext_var dummy = root->bind_new_context(name);
}
name.length( 2 );
name[1].id = CORBA::string_dup( "leaf/esc-slash" );
name[1].kind = CORBA::string_dup( "kind2" );
// Create an object
PortableServer::Servant_var<Messenger_i> servant = new Messenger_i;
PortableServer::ObjectId_var oid = poa->activate_object(servant.in());
CORBA::Object_var messenger_obj = poa->id_to_reference(oid.in());
root->rebind(name, messenger_obj.in());
// Also try rebinding to a simple path.
CosNaming::Name_var simp_name = root->to_name("Simple");
try {
obj = root->resolve(simp_name.in());
}
catch(const CosNaming::NamingContext::NotFound&) {
CosNaming::NamingContext_var dummy =
root->bind_new_context(simp_name.in());
}
simp_name = root->to_name("Simple/Messenger");
root->rebind(simp_name.in(), messenger_obj.in());
// Convert Name to String Name.
CORBA::String_var str_name = root->to_string(name);
std::cout << "str_name: " << str_name.in() << std::endl;
CORBA::String_var str_simple = root->to_string(simp_name.in());
std::cout << "simple: " << str_simple.in() << std::endl;
// Convert String Name to Name.
CosNaming::Name_var tname = root->to_name(str_name.in());
std::cout << "converted back to a CosNaming::Name: " << std::endl;
std::cout << " name[0] = " << (* tname)[0].id.in() << " , "
<< (* tname)[0].kind.in() << std::endl;
std::cout << " name[1] = " << (* tname)[1].id.in() << " , "
<< (* tname)[1].kind.in() << std::endl;
// Find the application object by resolve_str.
try {
obj = root->resolve_str(str_name.in());
}
catch(const CosNaming::NamingContext::NotFound&) {
std::cerr<<"Couldn't resolve the string name: " << str_name << std::endl;
return 1;
}
ACE_CString base_address (":");
base_address += ACE_TEXT_ALWAYS_CHAR (hostname);
base_address += ":";
base_address += ACE_TEXT_ALWAYS_CHAR (port);
ACE_CString addr ("");
addr = base_address + "/key/str";
// Create an URL string for application object.
CORBA::String_var address = CORBA::string_dup (addr.c_str());
std::cout << "call to_url(\"" << address.in() << "\"" << std::endl;
std::cout << " ,\"" << str_simple.in() << "\")"<< std::endl;
CORBA::String_var url_string = root->to_url(address.in(), str_simple.in());
std::cout << "to_url result: " << url_string.in() << std::endl;
// Write NS url to a file to let client read NS URL to get
// NamingContext reference.
CORBA::String_var ns_addr = CORBA::string_dup(base_address.c_str());
std::cout << "call to_url(\"" <<ns_addr.in() << "\",\""
<< str_simple.in() << "\")"<< std::endl;
CORBA::String_var url = root->to_url(ns_addr.in(), str_simple.in());
std::cout << "to_url result: " << url.in() << std::endl;
std::ofstream iorFile(ACE_TEXT_ALWAYS_CHAR (ior_output_file));
iorFile << url.in() << std::endl;
iorFile.close();
std::cout << "Naming Service URL written to file " << ior_output_file << std::endl;
// Accept requests
orb->run();
orb->destroy();
}
catch(const CORBA::Exception& ex) {
std::cerr << "Caught a CORBA::Exception: " << ex << std::endl;
return 1;
}
return 0;
}
int runTests(CORBA::ORB_var orb, First::IHello_ptr hello)
{
result = 0;
try
{
std::cout << " AddValue: ";
check(5 == hello->AddValue(2, 3));
}
catch (...)
{
check(false);
}
try
{
std::cout << " SayHello: ";
check(std::wstring(L"Hello, Andy. It's Bob.") == (wchar_t*)CORBA::WString_var(hello->SayHello(L"Andy")));
}
catch (...)
{
check(false);
}
try
{
std::cout << " SayHello2: ";
CORBA::String_var greeting;
hello->SayHello2("Andy", greeting.out());
check(std::string("Hello, Andy. It's Bob.") == (char*)greeting);
}
catch (...)
{
check(false);
}
try
{
std::cout << " Message: ";
CORBA::String_var message = "Hello, Bob";
hello->Message(message.inout());
check(std::string("Hello, Andy.") == (char*)message);
}
catch (...)
{
check(false);
}
try
{
std::cout << " MulComplex: ";
First::MyComplexNumber x, y;
x.re = 2, x.im = 3;
y.re = 5, y.im = 6;
First::MyComplexNumber expected;
expected.re = x.re * y.re - x.im * y.im;
expected.im = x.re * y.im + x.im - y.re;
First::MyComplexNumber result = hello->MulComplex(x, y);
check(equal(result, expected) && equal(result, y));
}
catch (...)
{
check(false);
}
try
{
std::cout << " MulComplexAsAny: ";
First::MyComplexNumber x, y;
x.re = 2, x.im = 3;
y.re = 5, y.im = 6;
First::MyComplexNumber expected;
expected.re = x.re * y.re - x.im * y.im;
expected.im = x.re * y.im + x.im - y.re;
CORBA::Any _x, _y;
_x <<= x;
_y <<= y;
CORBA::Any_var _result;
bool success = hello->MulComplexAsAny(_x, _y, _result.out());
First::MyComplexNumber* result;
_result >>= result;
check(success && result && equal(*result, expected));
}
catch (...)
{
check(false);
}
try
{
std::cout << " DataTimeTransfer: ";
SYSTEMTIME initial_systemtime = {};
initial_systemtime.wMilliseconds = 0;
initial_systemtime.wSecond = 0;
initial_systemtime.wMinute = 0;
initial_systemtime.wHour = 0;
initial_systemtime.wDay = 8;
initial_systemtime.wDayOfWeek = 1;
initial_systemtime.wMonth = 2;
initial_systemtime.wYear = 2016;
FILETIME initial_filetime;
SystemTimeToFileTime(&initial_systemtime, &initial_filetime);
__int64 val = SysytemTimeToInt64(initial_systemtime);
hello->DataTimeTransfer(val);
FILETIME return_filetime;
Int64ToFileTime(&val, &return_filetime);
check(CompareFileTime(&initial_filetime, &return_filetime) == 0);
}
catch (...)
{
check(false);
}
try
{
std::cout << " Install exceptions hadlers: ";
omniORB::installTransientExceptionHandler(hello, 0, transientExceptionHandler);
omniORB::installSystemExceptionHandler(hello, 0, systemExceptionHandler);
check(true);
}
catch (...)
{
check(false);
}
try
{
std::cout << " Catch NO_IMPLEMENT: ";
expectedExceptionType = SYSTEM_EXCEPTION_TYPE;
exceptionProperlyHandled = false;
hello->ThrowExceptions(0);
}
catch (CORBA::NO_IMPLEMENT& se)
{
check(exceptionProperlyHandled && 1 == se.minor());
}
catch (...)
{
check(false);
}
try
{
std::cout << " Catch TRANSIENT: ";
expectedExceptionType = TRANSIENT_EXCEPTION_TYPE;
exceptionProperlyHandled = false;
hello->ThrowExceptions(3);
}
catch (CORBA::TRANSIENT& se)
{
std::string ex_neame = se._name();
check(exceptionProperlyHandled && ex_neame.compare("TRANSIENT") == 0);
}
catch (...)
{
check(false);
}
try
{
std::cout << " Catch plain user exception: ";
hello->ThrowExceptions(1);
}
catch (First::IHello::UserExceptionS& ue)
{
check(std::string("UserExceptionS") == ue._name());
}
catch (...)
{
check(false);
}
try
{
std::cout << " Catch user exception with members: ";
hello->ThrowExceptions(2);
}
catch (First::IHello::UserExceptionExt& ue)
{
check((std::string("EXCEPTIONS_WORKS") == (char*)ue.reason) && (254 == ue.codeError));
}
catch (...)
{
check(false);
}
try
{
std::cout << " Catch unknown exception: ";
hello->ThrowExceptions(4);
}
catch (CORBA::UNKNOWN& se)
{
check(std::string("UNKNOWN") == (char*)se._name());
}
catch (...)
{
check(false);
}
try
{
std::cout << " Sequence reversed: ";
int row[] = { 1, 3, 5, 7, 10 };
int length = sizeof(row) / sizeof(row[0]);
First::SequenceLong_var sequence(new First::SequenceLong());
sequence->length(length);
for (int i = 0; i < length; ++i)
{
sequence[i] = row[i];
}
First::SequenceLong_var reversed = hello->Reverse(sequence.in());
if (5 == reversed->length())
{
check((reversed[0] == row[4]) && (reversed[1] == row[3]) && (reversed[2] == row[2]) && (reversed[3] == row[1]) && (reversed[4] == row[0]));
}
else
check(false);
}
catch (...)
{
check(false);
}
try
{
std::cout << " Callback: ";
PortableServer::POA_var poa = createBidirectionalPOA(orb);
TestCallBackImpl* pCallback = new TestCallBackImpl();
PortableServer::ObjectId_var oid = poa->activate_object(pCallback);
First::ITestCallBack_var callback(pCallback->_this());
pCallback->_remove_ref();
check(hello->CallMe(callback) && pCallback->Greeting() == "Hello from Server");
}
catch (...)
{
check(false);
}
try
{
std::cout << " Pass single dimensional array: ";
First::Vector4_var x = First::Vector4_alloc();
x[0] = 1.0; x[1] = 2.0; x[2] = 3; x[3] = -4.0;
First::Vector4_var y = First::Vector4_alloc();
y[0] = -1.0; y[1] = 12.0; y[2] = 4.1; y[3] = 0;
double expected[] = {
x[0] + y[0],
x[1] + y[1],
x[2] + y[2],
x[3] + y[3]
};
First::Vector4_slice* result = hello->AddVectors(x, y);
bool equal = result[0] == expected[0] && result[1] == expected[1] && result[2] == expected[2] && result[3] == expected[3];
First::Vector4_free(result);
check(equal);
}
catch (...)
{
check(false);
}
try
{
std::cout << " Pass multi dimensional array: ";
First::Matrix3x4_var x = First::Matrix3x4_alloc();
x[0][0] = 1.0; x[0][1] = -2.0; x[0][2] = 3; x[0][3] = 4.1;
x[1][0] = 2.0; x[1][1] = 4.0; x[1][2] = -6; x[1][3] = 8.1;
x[2][0] = -3.0; x[2][1] = -5.0; x[2][2] = 7; x[2][3] = -1;
First::Matrix3x4_var y = First::Matrix3x4_alloc();
y[0][0] = 3.0; y[0][1] = -2.4; y[0][2] = 3; y[0][3] = -0;
y[1][0] = 6.0; y[1][1] = 2.0; y[1][2] = -7; y[1][3] = 8.9;
y[2][0] = -7.0; y[2][1] = -1.0; y[2][2] = 7; y[2][3] = 1;
double expected[3][4] = {
{ x[0][0] + y[0][0], x[0][1] + y[0][1], x[0][2] + y[0][2], x[0][3] + y[0][3] },
{ x[1][0] + y[1][0], x[1][1] + y[1][1], x[1][2] + y[1][2], x[1][3] + y[1][3] },
{ x[2][0] + y[2][0], x[2][1] + y[2][1], x[2][2] + y[2][2], x[2][3] + y[2][3] }
};
First::Matrix3x4_slice* result = hello->AddMatrixes(x, y);
//check selectively
bool equal = result[0][0] == expected[0][0] && result[1][3] == expected[1][3] && result[2][0] == expected[2][0] && result[2][3] == expected[2][3];
First::Matrix3x4_free(result);
check(equal);
}
catch (...)
{
check(false);
}
try
{
std::cout << " Shutdown: ";
hello->Shutdown();
check(true);
}
catch (...)
{
check(false);
}
return result;
}
int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
{
try {
// Initialze the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
// Get a reference to the RootPOA.
CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA");
// Get the POA_var object from Object_var.
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (obj.in ());
// Get the POAManager of the RootPOA.
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
// Policies for the childPOA to be created.
CORBA::PolicyList policies;
policies.length (2);
policies[0] =
root_poa->create_id_assignment_policy (PortableServer::USER_ID);
policies[1] =
root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
// Create the childPOA under the RootPOA.
PortableServer::POA_var child_poa =
root_poa->create_POA ("childPOA",
poa_manager.in (),
policies);
// Destroy the policy objects
for (CORBA::ULong i = 0; i != policies.length (); ++i) {
policies[i]->destroy ();
}
// Create an instance of class Quoter_Stock_Factory_i.
Quoter_Stock_Factory_i stock_factory_i;
// Get the Object ID.
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId ("Stock_Factory");
// Activate the Stock_Factory object.
child_poa->activate_object_with_id (oid.in (),
&stock_factory_i);
// Get the object reference.
CORBA::Object_var stock_factory =
child_poa->id_to_reference (oid.in ());
CORBA::Object_var table_object =
orb->resolve_initial_references ("IORTable");
// Stringify all the object referencs.
CORBA::String_var ior = orb->object_to_string (stock_factory.in ());
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ACE_ERROR ((LM_ERROR, "Nil IORTable\n"));
}
else
{
CORBA::String_var ior =
orb->object_to_string (stock_factory.in ());
adapter->bind ("childPOA", ior.in ());
}
orb->run ();
// Destroy POA, waiting until the destruction terminates.
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception &) {
cerr << "CORBA exception raised !" << endl;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return 1;
Test_interfaceOne_i *ifo_impl;
ACE_NEW_RETURN (ifo_impl,
Test_interfaceOne_i (),
1);
PortableServer::ServantBase_var owner_transfer(ifo_impl);
Test::interfaceOne_var ifo = ifo_impl->_this ();
CORBA::String_var ior =
orb->object_to_string (ifo.in ());
// Output the IOR to the <ior_output_file>
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s\n",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
orb->run ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
// Create the ORB initializer.
Server_ORBInitializer *temp_initializer = 0;
ACE_NEW_RETURN (temp_initializer,
Server_ORBInitializer,
-1);
PortableInterceptor::ORBInitializer_var initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (initializer.in ());
// Now initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv,
"Remote_Server_ORB");
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n" ),
1);
}
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
{
return 1;
}
// Create the interceptor.
Echo_Server_Request_Interceptor * server_interceptor =
temp_initializer->server_interceptor();
if (server_interceptor == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Could not obtain reference to "
"server request interceptor.\n"),
-1);
}
// Pull in the ior from the remote server to use as the forward location.
CORBA::Object_var forward_location = orb->string_to_object (ior_input_file);
if (CORBA::is_nil (forward_location.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil\n",
ior_input_file),
1);
}
server_interceptor->forward_reference (forward_location.in ());
Bug1495_i server_impl (orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&server_impl);
CORBA::Object_var test_obj =
root_poa->id_to_reference (id.in ());
Bug1495_Regression::Bug1495_var server =
Bug1495_Regression::Bug1495::_narrow (test_obj.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
// Output the server IOR to a file
if (ior_output_file != 0)
{
FILE *output_file = ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing the "
"server IOR: %s", ior_output_file),
1);
}
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
ACE_Time_Value tv (15, 0);
orb->run (tv);
if (server_interceptor->forward_location_done() == false)
{
ACE_ERROR ((LM_ERROR, "ERROR: Forward location has not occurred!\n"));
}
ACE_DEBUG ((LM_DEBUG, "Threaded Server event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught an exception in server:");
return 1;
}
ACE_DEBUG ((LM_DEBUG, "Threaded Server ready\n"));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc,
argv);
if (parse_args (argc, argv) != 0)
return 1;
Test_i servant (orb.in ());
// Obtain RootPOA.
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (object.in ());
// Get the POAManager of the RootPOA.
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
PortableServer::ObjectId_var id =
root_poa->activate_object (&servant);
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
Test_var Test_object =
Test::_narrow (object_act.in ());
CORBA::String_var ior =
orb->object_to_string (Test_object.in ());
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
FILE *output_file =
ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file,
"%s",
ior.in ());
ACE_OS::fclose (output_file);
}
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG,
"event loop finished\n"));
root_poa->destroy (1,
1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception in setting up server");
ACE_ASSERT (0);
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc,
argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
}
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
test_i servant (orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&servant);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
test_var server =
test::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG,
"Activated as <%C>\n",
ior.in ()));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Can't open output file for writing IOR: %s",
ior_output_file),
1);
}
ACE_OS::fprintf (output_file,
"%s",
ior.in ());
ACE_OS::fclose (output_file);
}
poa_manager->activate ();
orb->run ();
root_poa->destroy (1, 1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Server: exception caught - ");
return 1;
}
return 0;
}
int
TAO_System_Id_With_Unique_Id_Strategy::bind_using_system_id (
PortableServer::Servant servant,
CORBA::Short priority,
TAO_Active_Object_Map_Entry *&entry)
{
ACE_NEW_RETURN (entry,
TAO_Active_Object_Map_Entry,
-1);
int result =
this->active_object_map_->user_id_map_->bind_create_key (entry,
entry->user_id_);
if (result == 0)
{
entry->servant_ = servant;
entry->priority_ = priority;
result = this->active_object_map_->id_hint_strategy_->bind (*entry);
if (result == 0)
{
if (servant != 0)
{
result =
this->active_object_map_->servant_map_->bind (entry->servant_,
entry);
}
if (result != 0)
{
this->active_object_map_->user_id_map_->unbind (entry->user_id_);
this->active_object_map_->id_hint_strategy_->unbind (*entry);
delete entry;
}
else
{
#if defined (TAO_HAS_MONITOR_POINTS) && (TAO_HAS_MONITOR_POINTS == 1)
this->active_object_map_->monitor_->receive (
this->active_object_map_->servant_map_->current_size ());
#endif /* TAO_HAS_MONITOR_POINTS==1 */
}
}
else
{
this->active_object_map_->user_id_map_->unbind (entry->user_id_);
delete entry;
}
}
else
{
delete entry;
}
#if (TAO_HAS_MINIMUM_CORBA == 0)
if (result == 0 && TAO_debug_level > 7)
{
CORBA::String_var idstr (
PortableServer::ObjectId_to_string (entry->user_id_));
CORBA::String_var repository_id (
servant ? servant->_repository_id () : 0);
ACE_CString hex_idstr;
hexstring (hex_idstr, idstr.in (), entry->user_id_.length ());
TAOLIB_DEBUG ((LM_DEBUG,
"TAO (%P|%t) - TAO_System_Id_With_Unique_Id_Strategy::"
"bind_using_system_id: type=%C, id=%C\n",
repository_id.in (),
hex_idstr.c_str()
));
}
#endif
return result;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
Simple_Server_i *server_impl = 0;
ACE_NEW_RETURN (server_impl,
Simple_Server_i (orb.in ()),
-1);
PortableServer::ServantBase_var owner_transfer(server_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (server_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
poa_manager->activate ();
Worker worker (orb.in ());
if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Cannot activate client threads\n"),
1);
SelfClient selfabuse (orb.in(), server.in(), niterations);
if (selfabuse.activate (THR_NEW_LWP | THR_JOINABLE,
nclient_threads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Cannot activate abusive threads\n"),
1);
selfabuse.thr_mgr()->wait();
worker.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) event loop finished\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
Test::Process_ptr
Process_Factory::create_new_process (void)
{
Startup_Callback *startup_callback_impl;
ACE_NEW_THROW_EX (startup_callback_impl,
Startup_Callback,
CORBA::NO_MEMORY ());
PortableServer::ServantBase_var owner_transfer(startup_callback_impl);
CORBA::Object_var poa_object =
this->orb_->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (startup_callback_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test::Startup_Callback_var startup_callback =
Test::Startup_Callback::_narrow (object.in ());
CORBA::String_var ior =
this->orb_->object_to_string (startup_callback.in ());
const ACE_TCHAR* argv[3] = {
ACE_TEXT("child"),
ACE_TEXT_CHAR_TO_TCHAR(ior.in ()),
0};
ACE_Process_Options options;
#if !defined(ACE_WIN32)
options.avoid_zombies (1);
#endif /* ACE_WIN32 */
options.command_line (argv);
ACE_Process child_process;
pid_t pid =
child_process.spawn (options);
if (pid == -1)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Process_Factory::create_new_process, "
" spawn call failed (%d)\n",
ACE_ERRNO_GET));
throw Test::Spawn_Failed ();
}
int process_has_started = 0;
Test::Process_var the_process;
for (int i = 0; i != 500 && !process_has_started; ++i)
{
ACE_Time_Value interval (0, 10000);
this->orb_->perform_work (interval);
process_has_started =
startup_callback_impl->process_has_started (the_process.out ());
}
try
{
PortableServer::POA_var poa =
startup_callback_impl->_default_POA ();
PortableServer::ObjectId_var id =
poa->servant_to_id (startup_callback_impl);
poa->deactivate_object (id.in ());
}
catch (const CORBA::Exception&)
{
}
if (process_has_started == 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Process_Factory::create_new_process, "
" timeout while waiting for child\n"));
(void) child_process.terminate ();
throw Test::Spawn_Failed ();
}
return the_process._retn ();
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("ERROR: wrong arguments\n")),
-1);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableGroup::GOA_var root_goa =
PortableGroup::GOA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_goa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("ERROR: nil RootPOA\n")),
-1);
PortableServer::POAManager_var poa_manager = root_goa->the_POAManager ();
// Create UIPMC reference.
CORBA::Object_var obj = orb->string_to_object (uipmc_url);
// Create id.
PortableServer::ObjectId_var id =
root_goa->create_id_for_reference (obj.in ());
// Activate UIPMC Object.
UIPMC_Object_Impl* uipmc_impl;
ACE_NEW_RETURN (uipmc_impl,
UIPMC_Object_Impl (orb.in (), threads),
-1);
PortableServer::ServantBase_var owner_transfer1 (uipmc_impl);
root_goa->activate_object_with_id (id.in (), uipmc_impl);
Test::UIPMC_Object_var uipmc_obj =
Test::UIPMC_Object::_unchecked_narrow (obj.in ());
if (CORBA::is_nil (uipmc_obj.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("ERROR: nil Hello object\n")),
-1);
CORBA::String_var ior = orb->object_to_string (obj.in ());
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("MIOP object is <%C>\n"), ior.in ()));
//obj = hello_impl->_this ();
// If the ior_output_file exists, output the ior to it.
if (ior_output_file != 0)
{
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Cannot open output file ")
ACE_TEXT ("for writing IOR: %s"),
ior_output_file),
-1);
}
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
poa_manager->activate ();
{
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting %u thread, thread pool\n"), (unsigned) threads));
// start server thread pool
OrbThread orb_thr (orb.in ());
orb_thr.activate (THR_NEW_LWP | THR_JOINABLE, threads);
orb_thr.wait ();
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Stopping thread pool\n")));
}
root_goa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in server main ():");
return -1;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\nServer finished successfully.\n")));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
#if TAO_HAS_INTERCEPTORS == 1
Server_ORBInitializer *temp_initializer = 0;
ACE_NEW_RETURN (temp_initializer,
Server_ORBInitializer,
-1); // No exceptions yet!
PortableInterceptor::ORBInitializer_var orb_initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (orb_initializer.in ());
#endif /* TAO_HAS_INTERCEPTORS == 1 */
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv, "Server ORB");
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (::parse_args (argc, argv) != 0)
return -1;
test_i *test_impl;
ACE_NEW_RETURN (test_impl, test_i (number, orb.in ()), 1);
PortableServer::ServantBase_var owner_transfer (test_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (test_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
RedirectionTest::test_var test =
RedirectionTest::test::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (test.in ());
FILE *output_file= ACE_OS::fopen (ior_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file <%s> for writing "
"IOR: %C\n",
ior_file, ior.in ()),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
if (server_number == 2)
ACE_OS::exit (1);
poa_manager->activate ();
// Run the ORB event loop.
orb->run ();
root_poa->destroy (1, 1);
orb->destroy ();
ACE_DEBUG ((LM_DEBUG, "Event loop finished.\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return -1;
}
return 0;
}
void
EDF_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr ri)
{
int int_guid;
RTScheduling::Current::IdType_var guid = this->current_->id ();
ACE_OS::memcpy (&int_guid,
guid->get_buffer (),
guid->length ());
DSUI_EVENT_LOG (EDF_SCHED_FAM, ENTER_CLIENT_SCHED_TIME, int_guid, 0, 0);
Kokyu::Svc_Ctxt_DSRT_QoS sc_qos;
CORBA::String_var operation = ri->operation ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): send_request "
"from \"%s\"\n",
operation.in ()));
#endif
// Make the context to send the context to the target
IOP::ServiceContext sc;
sc.context_id = Client_Interceptor::SchedulingInfo;
CORBA::Policy_var sched_policy =
this->current_->scheduling_parameter();
CORBA::Long importance;
TimeBase::TimeT deadline;
TimeBase::TimeT period;
int task_id=-1;
if (CORBA::is_nil (sched_policy))
{
//24 hrs from now - infinity
ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0);
deadline = deadline_tv.sec () * 10000000 + deadline_tv.usec () * 10; //100s of nanoseconds for TimeBase::TimeT
importance = 0;
period = 0; //set period 0 as default.
// task_id = ID_BEGIN ++;
}
else
{
EDF_Scheduling::SchedulingParameterPolicy_var sched_param_policy =
EDF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy);
EDF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value ();
deadline = sched_param->deadline;
importance = sched_param->importance;
period = sched_param->period;
task_id = sched_param->task_id;
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): send_request guid = %d\n",
int_guid));
#endif
}
//Fill the guid in the SC Qos struct
sc_qos.guid.length (guid->length ());
guid_copy (sc_qos.guid, guid.in ());
sc_qos.deadline = deadline;
sc_qos.importance = importance;
sc_qos.task_id = task_id;
sc_qos.period = period;
CORBA::Any sc_qos_as_any;
sc_qos_as_any <<= sc_qos;
CORBA::OctetSeq_var cdtmp = codec_->encode (sc_qos_as_any);
sc.context_data = cdtmp.in ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t|%T): send_request : about to add sched SC\n")));
#endif
// Add this context to the service context list.
ri->add_request_service_context (sc, 0);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t|%T): send_request : ")
ACE_TEXT ("about to call scheduler to inform block\n")
));
#endif
DSUI_EVENT_LOG (EDF_SCHED_FAM, CALL_KOKYU_DISPATCH_UPDATE_SCHEDULE,
int_guid, 0, 0);
kokyu_dispatcher_->update_schedule (guid.in (),
Kokyu::BLOCK);
DSUI_EVENT_LOG (EDF_SCHED_FAM, LEAVE_KOKYU_DISPATCH_UPDATE_SCHEDULE,
int_guid,0,0);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t|%T): send_request interceptor done\n")));
#endif
DSUI_EVENT_LOG (EDF_SCHED_FAM, LEAVE_CLIENT_SCHED_TIME, int_guid, 0, 0);
}