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);
}
void
Echo_Server_Request_Interceptor::receive_request_service_contexts (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::String_var operation = ri->operation ();
ACE_DEBUG ((LM_DEBUG,
"%C.receive_request_service_contexts from "
"\"%C\"\n",
this->myname_,
operation.in ()));
// 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.
// Same goes for the shutdown call
if (ACE_OS_String::strcmp ("shutdown", operation.in ()) == 0)
return;
IOP::ServiceId id = ::service_id;
IOP::ServiceContext_var sc =
ri->get_request_service_context (id);
const char *buf =
reinterpret_cast<const char *> (sc->context_data.get_buffer ());
ACE_DEBUG ((LM_DEBUG,
" Received service context: %C\n",
buf));
if (ACE_OS::strcmp (buf, request_msg) == 0)
{
ACE_DEBUG ((LM_DEBUG, "Sending LOCATION_FORWARD\n"));
throw PortableInterceptor::ForwardRequest (this->forward_location_.in ());
}
else if (ACE_OS::strcmp (buf, forward_msg) == 0)
{
// Make the context to send the context to the client
IOP::ServiceContext scc;
scc.context_id = ::service_id;
CORBA::ULong string_len = ACE_OS::strlen (reply_msg) + 1;
CORBA::Octet *buff = CORBA::OctetSeq::allocbuf (string_len);
ACE_OS::strcpy (reinterpret_cast<char *> (buff), reply_msg);
scc.context_data.replace (string_len, string_len, buff, 1);
// Add this context to the service context list.
ri->add_reply_service_context (scc, 0);
}
else
{
ACE_ERROR ((LM_ERROR,
"ERROR: Echo_Server_Request_Interceptor::receive_request_service_contexts: "
"Expected request service context to be: %C or %C\n",
request_msg,
forward_msg));
}
}
void
ServerRequest_Interceptor2::receive_request (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::String_var op = ri->operation ();
if (ACE_OS::strcmp (op.in (), "has_ft_request_service_context"))
{
// bail if not the op we are interested in -
// avoid excess spurious error clutter when client calls ::shutdown; ::ping etc..
return;
}
try
{
IOP::ServiceContext_var sc =
ri->get_request_service_context (IOP::FT_REQUEST);
// No exception therefore there was a context
has_ft_request_sc_ = true;
}
catch (const CORBA::BAD_PARAM& ex)
{
ACE_UNUSED_ARG (ex);
// No group version context
has_ft_request_sc_ = false;
}
catch (const CORBA::Exception&)
{
throw;
}
}
void
Echo_Server_Request_Interceptor::receive_request_service_contexts (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::String_var operation = ri->operation ();
ACE_DEBUG ((LM_DEBUG,
"%C.receive_request_service_contexts from "
"\"%C\"\n",
this->myname_,
operation.in ()));
IOP::ServiceId id = ::service_id;
IOP::ServiceContext_var sc =
ri->get_request_service_context (id);
const char *buf =
reinterpret_cast<const char *> (sc->context_data.get_buffer ());
#if 0
ACE_DEBUG ((LM_DEBUG,
" Received service context: %C\n",
buf));
#endif /*if 0*/
if (ACE_OS::strcmp (buf, request_msg) != 0)
{
ACE_ERROR ((LM_ERROR,
"ERROR: Echo_Server_Request_Interceptor::receive_request_service_contexts: "
"Expected request service context to be: %C\n",
request_msg));
}
}
void
ServerInterceptor::receive_request (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
bool permission_granted = false;
std::cout << "Calling receive_request()." << std::endl;
if (ri->target_is_a(restricted_interfaces[0])){
IOP::ServiceId id = service_id;
// Check that the request service context can be retrieved.
IOP::ServiceContext_var sc =
ri->get_request_service_context (id);
CORBA::OctetSeq ocSeq = sc->context_data;
const char * buf =
reinterpret_cast<const char *> (ocSeq.get_buffer ());
for (unsigned int i=0; i<num_allowed_users; ++i) {
if (ACE_OS::strcmp (buf, allowed_users[i]) == 0)
{
permission_granted = true;
}
}
}
if (permission_granted == true) {
std::cout << "Permission Granted " << std::endl;
}
else {
std::cout << "Permission Denied " << std::endl;;
}
}
void
Echo_Server_Request_Interceptor::receive_request_service_contexts (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::String_var operation = ri->operation ();
ACE_DEBUG ((LM_DEBUG,
"%C.receive_request_service_contexts from "
"\"%C\"\n",
this->myname_,
operation.in ()));
// Ignore the shutdown operation.
if (ACE_OS_String::strcmp ("shutdown", operation.in ()) == 0)
return;
// retrieve the context
IOP::ServiceId id = ::service_id;
IOP::ServiceContext_var sc =
ri->get_request_service_context (id);
const char *buf =
reinterpret_cast<const char *> (sc->context_data.get_buffer ());
ACE_DEBUG ((LM_DEBUG,
" Received service context: %C\n",
buf));
if (ACE_OS::strcmp (buf, request_msg) != 0)
{
ACE_ERROR ((LM_ERROR,
"ERROR: Echo_Server_Request_Interceptor::receive_request_service_contexts: "
"Expected request service context to be: %C\n",
request_msg ));
}
else
{
// put the context into s slot
CORBA::Any data;
data <<= buf;
try
{
ri->set_slot (slotId, data);
ACE_DEBUG ((LM_DEBUG, "receive_request_service_contexts filled Slot %d\n",(int)slotId));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
"Exception thrown in receive_request_service_contexts()\n");
throw CORBA::INTERNAL ();
}
}
}
void
Echo_Server_Request_Interceptor::send_exception (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::String_var operation = ri->operation ();
#if 0
ACE_DEBUG ((LM_DEBUG,
"%C.send_exception from \"%C\"\n",
this->myname_,
operation.in ()));
#endif /*if 0*/
// Check that the reply service context is set as expected.
IOP::ServiceContext_var sc =
ri->get_reply_service_context (::service_id);
const char *buf = reinterpret_cast<const char *> (sc->context_data.get_buffer ());
#if 0
ACE_DEBUG ((LM_DEBUG,
" Reply service context: %C\n",
buf));
#endif /*if 0*/
if (ACE_OS::strcmp (buf, reply_msg) != 0)
{
ACE_ERROR ((LM_ERROR,
"ERROR: Echo_Server_Request_Interceptor::send_exception: "
"Expected reply service context to be: %C\n",
reply_msg));
}
// Check that the request service context hasn't been changed.
IOP::ServiceContext_var sc2 =
ri->get_request_service_context (::service_id);
const char *buf2 = reinterpret_cast<const char *> (sc2->context_data.get_buffer ());
if (ACE_OS::strcmp (buf2, request_msg) != 0)
{
ACE_ERROR ((LM_ERROR,
"ERROR: Echo_Server_Request_Interceptor::send_exception: "
"Expected request service context to be: %C.\n"
" Got: %C\n",
request_msg,
buf2));
}
}
void
Echo_Server_Request_Interceptor::receive_request_service_contexts (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::String_var operation = ri->operation ();
ACE_DEBUG ((LM_DEBUG,
"%C.receive_request_service_contexts from "
"\"%C\"\n",
this->myname_,
operation.in ()));
IOP::ServiceId id = ::service_id;
IOP::ServiceContext_var sc =
ri->get_request_service_context (id);
const char *buf =
reinterpret_cast<const char *> (sc->context_data.get_buffer ());
#if 0
ACE_DEBUG ((LM_DEBUG,
" Received service context: %C\n",
buf));
#endif /*if 0*/
if (ACE_OS::strcmp (buf, request_msg) != 0)
{
ACE_ERROR ((LM_ERROR,
"ERROR: Echo_Server_Request_Interceptor::receive_request_service_contexts: "
"Expected request service context to be: %C\n",
request_msg));
}
// Make the context to send the context to the client
IOP::ServiceContext scc;
scc.context_id = ::service_id;
CORBA::ULong string_len = ACE_OS::strlen (reply_msg) + 1;
CORBA::Octet *buff = CORBA::OctetSeq::allocbuf (string_len);
ACE_OS::strcpy (reinterpret_cast<char *> (buff), reply_msg);
scc.context_data.replace (string_len, string_len, buff, 1);
// Add this context to the service context list.
ri->add_reply_service_context (scc, 0);
}
void
Server_Request_Interceptor::receive_request_service_contexts (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
this->request_count_++;
CORBA::Boolean response_expected =
ri->response_expected ();
if (!response_expected) // A one-way request.
return;
// Request 1 -- non-forwarded
// Request 2 -- forwarded by client request interceptor
// Request 3 -- forwarded by this interception point
if (this->request_count_ == 3)
{
// The client request interceptor should have already forwarded
// the request to obj_[1], so we re-forward the request back to
// obj_[0].
ACE_DEBUG ((LM_DEBUG,
"SERVER (%P|%t) Request %d will be forwarded "
"to object 1\n" // "object 1" as in "obj_[0]"
"SERVER (%P|%t) via "
"receive_request_service_contexts().\n",
this->request_count_));
throw PortableInterceptor::ForwardRequest (this->obj_[0]);
}
}
void
ForwardTest_Request_Interceptor::receive_request_service_contexts (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::String_var operation = ri->operation ();
ACE_DEBUG ((LM_DEBUG,
"%C.receive_request_service_contexts from "
"\"%C\"\n",
this->myname_,
operation.in ()));
// 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.
// Same goes for the shutdown call
if (ACE_OS_String::strcmp ("_is_a", operation.in ()) == 0 ||
ACE_OS_String::strcmp ("shutdown", operation.in ()) == 0)
return;
if (!forward_location_done_)
{
forward_location_done_ = true;
ACE_DEBUG ((LM_DEBUG,
"Sending LOCATION_FORWARD, current thread %i\n",
ACE_Thread::self ()));
throw PortableInterceptor::ForwardRequest (
CORBA::Object::_duplicate (this->forward_location_.in ()));
}
}
void
Server_Request_Interceptor::send_other (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::Boolean response_expected =
ri->response_expected ();
if (!response_expected) // A one-way request.
return;
// If we get this far then we should have received a
// LOCATION_FORWARD reply.
// This will throw an exception if a location forward has not
// occured. If an exception is thrown then something is wrong with
// the PortableInterceptor::ForwardRequest support.
CORBA::Object_var forward = ri->forward_reference ();
if (CORBA::is_nil (forward.in ()))
throw CORBA::INTERNAL ();
}
void
IIOP_Server_Request_Interceptor::outbound_process_context (PortableInterceptor::ServerRequestInfo_ptr ri)
{
IOP::ServiceId id = Test::Transport::CurrentTest::ContextTag;
IOP::ServiceContext_var sc =
ri->get_request_service_context (id);
const char *buf =
reinterpret_cast <const char *> (sc->context_data.get_buffer ());
this->pop_request_info (ACE_OS::atoi (buf));
}
void
ForwardTest_Request_Interceptor::send_other (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
// This will throw an exception if a location forward has not
// occured. If an exception is thrown then something is wrong with
// the PortableInterceptor::ForwardRequest support.
CORBA::Object_var forward = ri->forward_reference ();
if (CORBA::is_nil (forward.in ()))
throw CORBA::INTERNAL ();
}
void
Echo_Server_Request_Interceptor::receive_request_service_contexts (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::String_var operation =
ri->operation ();
if (ACE_OS::strcmp ("_is_a", operation.in ()) == 0)
return;
IOP::ServiceId id = ::service_id;
IOP::ServiceContext_var sc =
ri->get_request_service_context (id);
if (sc->context_data.length() != magic_cookie_len
|| ACE_OS::memcmp(
magic_cookie, sc->context_data.get_buffer(),
magic_cookie_len) != 0)
{
throw CORBA::BAD_PARAM();
}
}
void
Server_Request_Interceptor::receive_request (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::Boolean response_expected =
ri->response_expected ();
if (!response_expected) // A one-way request.
return;
// Request 1 -- non-forwarded
// Request 2 -- forwarded by client request interceptor
// Request 3 -- forwarded by receive_request_service_contexts()
// Request 4 -- non-forwarded (give client chance to print result)
// Request 5 -- forwarded by this interception point
// Request 6 -- non-forwarded (request 5 gets forwarded here)
// Request 7 -- throw exception to initiate forwarding from sent_exception
if (this->request_count_ == 5)
{
// This interceptor should have already forwarded the request to
// obj_[0] so re-forward it to obj_[1]. This will be the last
// location forward.
ACE_DEBUG ((LM_DEBUG,
"SERVER (%P|%t) Request %d will be forwarded "
"to object 2\n" // "object 2" as in "obj_[1]"
"SERVER (%P|%t) via receive_request().\n",
this->request_count_ - 1));
// "request_count_ - 1" is used above since there was a location
// forward.
throw PortableInterceptor::ForwardRequest (this->obj_[1]);
}
if (this->request_count_ == 7)
{
// Throw an exception to force the invocation of send_exception.
ACE_DEBUG ((LM_DEBUG,
"SERVER (%P|%t) OBJ_NOT_EXIST exception thrown for request %d\n"
"SERVER (%P|%t) via receive_request().\n",
this->request_count_ - 2));
throw CORBA::OBJECT_NOT_EXIST (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
EINVAL),
CORBA::COMPLETED_NO);
}
}
void
Echo_Server_Request_Interceptor::send_other (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::String_var operation = ri->operation ();
ACE_DEBUG ((LM_DEBUG,
"%C.send_other from \"%C\"\n",
this->myname_,
operation.in ()));
// Check that the request service context hasn't been changed.
IOP::ServiceContext_var sc =
ri->get_request_service_context (::service_id);
const char *buf = reinterpret_cast<const char *> (sc->context_data.get_buffer ());
if (ACE_OS::strcmp (buf, request_msg) != 0)
{
ACE_ERROR ((LM_ERROR,
"ERROR: Echo_Server_Request_Interceptor::send_reply: "
"Expected request service context to be: %C.\n"
" Got: %C\n",
request_msg,
buf));
}
// If we get this far then we should have received a
// LOCATION_FORWARD reply.
// This will throw an exception if a location forward has not
// occurred. If an exception is thrown then something is wrong with
// the PortableInterceptor::ForwardRequest support.
CORBA::Object_var forward = ri->forward_reference ();
if (CORBA::is_nil (forward.in ()))
throw CORBA::INTERNAL ();
}
void
IIOP_Server_Request_Interceptor::inbound_process_context (PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::String_var name (this->name ());
CORBA::String_var op (ri->operation());
if (TAO_debug_level >=1)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT("%C (%P|%t) Intercepted operation %C ()\n"),
name.in (),
op.in ()));
try
{
IOP::ServiceId id = Test::Transport::CurrentTest::ContextTag;
IOP::ServiceContext_var sc =
ri->get_request_service_context (id);
const char *buf =
reinterpret_cast <const char *> (sc->context_data.get_buffer ());
long requestID = ACE_OS::atoi (buf);
this->push_request_info (requestID);
}
catch (const CORBA::Exception&)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("%C (%P|%t) Service context")
ACE_TEXT (" is unavailable when invoking %C (). ")
ACE_TEXT ("A colocated invocation would have ")
ACE_TEXT ("no service context.\n"),
name.in (),
op.in ()));
}
}
void
TAO_LB_ServerRequestInterceptor::send_other (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
if (TAO_debug_level > 0)
{
// A location forward occurs when the LoadManager informs the
// LoadAlert object that its member is overloaded, for example.
const PortableInterceptor::ReplyStatus status =
ri->reply_status ();
if (status == PortableInterceptor::LOCATION_FORWARD)
ORBSVCS_DEBUG ((LM_INFO,
ACE_TEXT ("TAO_LB_ServerRequestInterceptor -- ")
ACE_TEXT ("LOCATION FORWARDED\n")));
}
}
void
TAO_Scheduler::receive_request (PortableInterceptor::ServerRequestInfo_ptr request_info,
RTScheduling::Current::IdType_out guid_out,
CORBA::String_out /*name*/,
CORBA::Policy_out /*sched_param*/,
CORBA::Policy_out /*implicit_sched_param*/)
{
IOP::ServiceContext_var serv_cxt;
try
{
serv_cxt = request_info->get_request_service_context (Server_Interceptor::SchedulingInfo);
size_t gu_id;
ACE_OS::memcpy (&gu_id,
serv_cxt->context_data.get_buffer (),
serv_cxt->context_data.length ());
ACE_DEBUG ((LM_DEBUG,
"The Guid is %d\n",
gu_id));
RTScheduling::Current::IdType* guid;
ACE_NEW (guid,
RTScheduling::Current::IdType);
guid->length (sizeof (size_t));
ACE_OS::memcpy (guid->get_buffer (),
serv_cxt->context_data.get_buffer (),
sizeof (size_t));
guid_out = guid;
}
catch (const CORBA::Exception&)
{
ACE_DEBUG ((LM_DEBUG,
"Invalid Service Context\n"));
}
}
void
Server_Request_Interceptor::send_exception (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::Any_var exception = ri->sending_exception ();
CORBA::TypeCode_var tc = exception->type ();
const char *id = tc->id ();
CORBA::OBJECT_NOT_EXIST nonexist_exception;
if (ACE_OS::strcmp (id, nonexist_exception._rep_id ()) == 0)
{
ACE_DEBUG ((LM_DEBUG,
"SERVER (%P|%t) OBJ_NOT_EXIST exception caught for request %d\n"
"SERVER (%P|%t) will be forwarded to object 1\n"
"SERVER (%P|%t) via send_exception().\n",
this->request_count_ - 2));
throw PortableInterceptor::ForwardRequest (this->obj_[0]);
}
}
void
ServerRequestInterceptor::receive_request (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
// If no response is expected, then we're invoking the oneway
// shutdown operation. Don't bother displaying output a second
// time.
CORBA::Boolean response_expected =
ri->response_expected ();
if (!response_expected)
return;
PortableServer::POA_var poa;
try
{
poa = this->poa_current_->get_POA ();
}
catch (const PortableServer::Current::NoContext& ex)
{
ex._tao_print_exception ("ServerRequestInterceptor::receive_request");
throw CORBA::INTERNAL ();
}
PortableServer::POA_var parent_poa =
poa->the_parent ();
// Make sure there is more than one POA in the POA hierarchy since
// the servant should have been registered with a child POA, not the
// RootPOA.
ACE_ASSERT (!CORBA::is_nil (parent_poa.in ()));
PortableInterceptor::AdapterName_var name =
ri->adapter_name ();
ACE_DEBUG ((LM_INFO,
"POA Hierarchy:\n"
"==============\n"));
const CORBA::ULong len = name->length ();
// Make sure there is more than one AdapterName in the AdapterName
// sequence since the servant should have been registered with a
// child POA, not the RootPOA.
ACE_ASSERT (len > 1);
for (CORBA::ULong i = 0; i < len; ++i)
{
for (CORBA::ULong j = 0; j < i; ++j)
ACE_DEBUG ((LM_INFO, "\t"));
ACE_DEBUG ((LM_INFO,
"%C\n",
static_cast<char const*>(name[i])));
}
ACE_DEBUG ((LM_INFO,
"\n"
"==============\n"));
// Make sure the name of the RootPOA is the first in the AdapterName
// sequence.
ACE_ASSERT (ACE_OS::strcmp ("RootPOA", name[(CORBA::ULong) 0]) == 0);
CORBA::String_var orb_id = ri->orb_id ();
ACE_ASSERT (ACE_OS::strcmp (this->orb_id_.in (), orb_id.in ()) == 0);
CORBA::String_var server_id = ri->server_id ();
ACE_ASSERT (ACE_OS::strcmp (server_id.in (), "ORT_test_server") == 0);
}
void
EDF_Scheduler::send_reply (PortableInterceptor::ServerRequestInfo_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_SEND_REPLY, 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_reply from \"%s\"\n",
ri->operation ()));
#endif
// Make the context to send the context to the target
IOP::ServiceContext sc;
sc.context_id = Server_Interceptor::SchedulingInfo;
CORBA::Long importance;
TimeBase::TimeT deadline;
CORBA::Policy_var sched_policy =
this->current_->scheduling_parameter();
if (CORBA::is_nil (sched_policy))
{
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): sched_policy nil.\n"));
#endif
//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
{
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T):sched_policy not nil. ",
"sched params set\n"));
#endif
EDF_Scheduling::SchedulingParameterPolicy_var sched_param_policy =
EDF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy);
EDF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value ();
sc_qos.guid.length (guid->length ());
guid_copy (sc_qos.guid, guid.in ());
deadline = sched_param->deadline;
importance = sched_param->importance;
sc_qos.deadline = deadline;
sc_qos.importance = importance;
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 ();
// Add this context to the service context list.
ri->add_reply_service_context (sc, 1);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T):reply sc added\n"));
#endif
}
kokyu_dispatcher_->update_schedule (guid.in (),
Kokyu::BLOCK);
DSUI_EVENT_LOG (EDF_SCHED_FAM, EXIT_SEND_REPLY, int_guid, 0, 0);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T): send_reply interceptor done\n"));
#endif
}
void
MIF_Scheduler::send_reply (PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::Short importance = 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_reply from \"%s\"\n",
ri->operation ()));
#endif
// Make the context to send the context to the target
IOP::ServiceContext sc;
sc.context_id = Server_Interceptor::SchedulingInfo;
CORBA::Policy_var sched_policy =
this->current_->scheduling_parameter();
RTScheduling::Current::IdType_var guid = this->current_->id ();
if (CORBA::is_nil (sched_policy.in ()))
{
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): sched_policy nil. ",
"importance not set in sched params\n"));
#endif
importance = 0;
}
else
{
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T):sched_policy not nil. ",
"importance set in sched params\n"));
#endif
MIF_Scheduling::SchedulingParameterPolicy_var sched_param_policy =
MIF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy.in ());
MIF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value ();
importance = sched_param->importance;
//Fill the guid in the SC Qos struct
sc_qos.guid.length (guid->length ());
guid_copy (sc_qos.guid, guid.in ());
sc_qos.importance = importance;
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 ();
// Add this context to the service context list.
ri->add_reply_service_context (sc, 1);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T):reply sc added\n"));
#endif
}
kokyu_dispatcher_->update_schedule (guid.in (),
Kokyu::BLOCK);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T): send_reply interceptor done\n"));
#endif
}
void
TAO_LB_ServerRequestInterceptor::receive_request_service_contexts (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
if (this->load_alert_.alerted ())
{
CORBA::String_var op = ri->operation ();
if (ACE_OS::strcmp (op.in (), "_get_loads") == 0 // LoadMonitor
|| ACE_OS::strcmp (op.in (), "disable_alert") == 0 // LoadAlert
|| ACE_OS::strcmp (op.in (), "enable_alert") == 0) // LoadAlert
return; // Do not redirect.
#if 0
try
{
IOP::ServiceContext_var service_context =
ri->get_request_service_context (CosLoadBalancing::LOAD_MANAGED);
/*
// Use TAO-specific "compiled marshaling" instead of
// standard interpretive marshaling via a CDR encapsulation
// Codec for efficiency reasons.
const char * buf =
reinterpret_cast<const char *> (service_context->context_data.get_buffer ());
TAO_InputCDR cdr (buf,
service_context->context_data.length ());
CORBA::Boolean byte_order;
if ((cdr >> ACE_InputCDR::to_boolean (byte_order)) == 0)
throw CORBA::BAD_PARAM ();
cdr.reset_byte_order (static_cast<int> (byte_order));
CORBA::Object_var object_group;
if (cdr >> object_group.out ())
throw PortableInterceptor::ForwardRequest (object_group.in (,
0));
else
throw CORBA::BAD_PARAM ();
*/
// A ServiceContext of the given ServiceId exists. This
// means that the target is load balanced. Force the client
// to try another profile since this location is currently
// overloaded.
throw CORBA::TRANSIENT ();
}
catch (const CORBA::BAD_PARAM& ex)
{
// No CosLoadBalancing::LB_GROUP_REF ServiceContext. This
// probably means that the target object is not
// LoadBalanced.
// There is a huge DoS attack vulnerability with this load
// shedding model. The model relies on the client behaving
// correctly. In particular, it relies on the client to
// send the forward object group reference in the
// ServiceContextList. Any "misbehaving" client can avoid
// that, in which case no load will ever be shed!
// Make sure we get a CORBA::BAD_PARAM for the right
// reason.
if (ex.minor () != (CORBA::OMGVMCID | 26))
throw;
}
#else
// Force the client to try another profile since this location
// is currently overloaded.
//
// NOTE: This applies to both load balanced and non-load
// balanced targets.
throw CORBA::TRANSIENT ();
#endif /* 0 */
}
}
void
MIF_Scheduler::receive_request (PortableInterceptor::ServerRequestInfo_ptr request_info,
RTScheduling::Current::IdType_out guid_out,
CORBA::String_out,
CORBA::Policy_out sched_param_out,
CORBA::Policy_out /*implicit_sched_param*/)
{
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"MIF_Scheduler::receive_request\n"));
IOP::ServiceContext_var serv_cxt =
request_info->get_request_service_context (Server_Interceptor::SchedulingInfo);
if (serv_cxt != 0)
{
ACE_DEBUG ((LM_DEBUG,
"Got scheduling info\n"));
RTScheduling::Current::IdType* guid;
ACE_NEW (guid,
RTScheduling::Current::IdType);
guid->length (sizeof(size_t));
ACE_OS::memcpy (guid->get_buffer (),
serv_cxt->context_data.get_buffer (),
sizeof (size_t));
size_t gu_id;
ACE_OS::memcpy (&gu_id,
guid->get_buffer (),
guid->length ());
ACE_DEBUG ((LM_DEBUG,
"MIF_Scheduler::receive_request %d\n",
gu_id));
CORBA::OctetSeq int_buf (sizeof (long));
int_buf.length (int_buf.maximum ());
int i = sizeof (long);
for (unsigned int j = 0;j < sizeof (int);j++)
{
int_buf [j] = serv_cxt->context_data [i++];
}
int importance = 0;
ACE_OS::memcpy (&importance,
int_buf.get_buffer (),
sizeof (importance));
guid_out = guid;
sched_param_out = DT_TEST::instance ()->scheduler ()->create_segment_scheduling_parameter (importance);
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"%t The Guid is %d Importance is %d\n",
gu_id,
importance));
DT* new_dt;
ACE_NEW (new_dt,
DT (this->lock_,
gu_id));
new_dt->msg_priority (importance);
lock_.acquire ();
ready_que_.enqueue_prio (new_dt);
new_dt->suspend ();
lock_.release ();
}
}
void
TAO::SSLIOP::Server_Invocation_Interceptor::receive_request (
PortableInterceptor::ServerRequestInfo_ptr ri )
{
SecurityLevel2::AccessDecision_var ad_tmp =
this->sec2manager_->access_decision ();
TAO::SL2::AccessDecision_var ad =
TAO::SL2::AccessDecision::_narrow (ad_tmp.in ());
CORBA::Boolean const no_ssl =
this->ssliop_current_->no_context ();
if (TAO_debug_level >= 3)
ORBSVCS_DEBUG ((LM_DEBUG, "SSLIOP (%P|%t) Interceptor (context), ssl=%d\n", !(no_ssl)));
// if
// (1) no SSL session state is available (which means that the
// invocation is received across a non-SSL transport)
// AND
// (2) the required Quality of Protection is something other
// than SecQOPNoProtection (set via -SSLNoProtection)
if (no_ssl && this->qop_ != ::Security::SecQOPNoProtection)
{
/*
* Set up all the arguments needed by the call
* to AccessDecision::access_allowed()
*/
/* Get the credentials from SSLIOP */
SecurityLevel2::CredentialsList cred_list; // initial empty?
#if 0
try {
SecurityLevel2::ReceivedCredentials_var rcvd_creds =
this->sec2_current_->received_credentials ();
// this gets the credentials received from the other side. We
// should be able to put this into a CredentialsList with no
// problem.
//
// Do I really need to implement a sec2_current, or can I hack
// the conversion at this level? I probably ought to do it as
// a real sec2_current with the conversion from sec3->sec2
// happening at a lower level.
cred_list.length(1);
cred_list[0] = rcvd_creds.in ();
/*
So, in looking for how we can do this, I find that the
SL3_SecurityCurrent::client_credentials() delegates to SL3_SecurityCurrent_Impl::client_credentials(),
which is pure virtual.
*/
}
catch (...) {
}
#endif
/* Gather the elements that uniquely identify the target object */
CORBA::ORBid_var orb_id = ri->orb_id ();
CORBA::OctetSeq_var adapter_id = ri->adapter_id ();
CORBA::OctetSeq_var object_id = ri->object_id ();
CORBA::String_var operation_name = ri->operation ();
CORBA::Boolean it_should_happen = false;
it_should_happen = ad->access_allowed_ex (orb_id.in (),
adapter_id.in (),
object_id.in (),
cred_list,
operation_name.in());
if (TAO_debug_level >= 3)
{
ORBSVCS_DEBUG ((LM_DEBUG,
"TAO (%P|%t) SL2::access_allowed_ex returned %s\n",
it_should_happen ? "true" : "false"));
}
if (! it_should_happen)
throw CORBA::NO_PERMISSION ();
}
}
void
MIF_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;
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T):entered MIF_Scheduler::receive_request\n"));
#endif
RTScheduling::Current::IdType guid;
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::Short importance;
if (sc.ptr () == 0)
{
importance = 0;
}
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;
importance = sc_qos_ptr->importance;
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;
#ifdef KOKYU_DSRT_LOGGING
int int_guid;
ACE_OS::memcpy (&int_guid,
guid.get_buffer (),
guid.length ());
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): Importance = %d, guid = %d in recvd service context\n",
importance, int_guid));
#endif
MIF_Scheduling::SchedulingParameter sched_param;
sched_param.importance = importance;
sched_param_out = this->create_scheduling_parameter (sched_param);
}
MIF_Scheduler_Traits::QoSDescriptor_t qos;
qos.importance_ = importance;
this->kokyu_dispatcher_->schedule (guid, qos);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T): receive_request interceptor done\n"));
#endif
}
void
ServerInterceptorDispatcher::receive_request(PortableInterceptor::ServerRequestInfo_ptr info)
throw(PortableInterceptor::ForwardRequest, CORBA::SystemException)
{
DEBUG_OUT ("ServerInterceptorDispatcher: receive_request");
// call for regsitered COPI
const Components::ConfigValues* temp_config=0;
//call for all interceptors
// determine the id
// all containers
Qedo::ContainerList* temp_container_list = component_server_ -> get_all_containers();
std::list <ContainerInterfaceImpl*>::iterator container_iter;
//identify the id
const char* id = 0;
for (container_iter = temp_container_list->begin(); container_iter != temp_container_list->end(); container_iter++)
{
for (unsigned int i = 0; i < (*container_iter) -> installed_homes_.size(); i++)
{
for (unsigned int j = 0; j < (((*container_iter) -> installed_homes_)[i].home_servant_->component_instances_.size()); j++)
{
// search for the oid
if (Qedo::compare_OctetSeqs((*info->object_id()),((*container_iter) -> installed_homes_)[i].home_servant_->component_instances_[j].object_id_))
{
temp_config = ((*container_iter)->installed_homes_)[i].home_servant_->component_instances_[j].config_;
if (temp_config != 0)
{
// std::cout << temp_config->length() << std::endl;
Components::ConfigValue* value;
for (CORBA::ULong k = 0; k < temp_config->length(); k++)
{
value = (*temp_config)[k];
if (! strcmp ((*temp_config)[k]->name(), "id"))
{
(*temp_config)[k]->value() >>= id;
break;
}
}
}
}
// current call could be the call on a facet
// search for facets
for (unsigned int k = 0; k < ((*container_iter)->installed_homes_)[i].home_servant_->component_instances_[j].ccm_object_executor_->facets_.size(); k++)
{
if (Qedo::compare_OctetSeqs((*info->object_id()),*((*container_iter) -> installed_homes_)[i].home_servant_->reference_to_oid(((*container_iter) -> installed_homes_)[i].home_servant_->component_instances_[j].ccm_object_executor_->facets_[k].facet_ref())))
{
temp_config = ((*container_iter)->installed_homes_)[i].home_servant_->component_instances_[j].config_;
if (temp_config != 0)
{
// std::cout << temp_config->length() << std::endl;
Components::ConfigValue* value;
for (CORBA::ULong k = 0; k < temp_config->length(); k++)
{
value = (*temp_config)[k];
if (! strcmp ((*temp_config)[k]->name(), "id"))
{
(*temp_config)[k]->value() >>= id;
break;
}
}
}
void
ReplicaController::send_reply (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
FT::FTRequestServiceContext_var ftr (
extract_context (ri));
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Sending reply for %s with rid %i\n",
ftr->client_id.in (),
ftr->retention_id));
// Prepare reply for logging.
CORBA::Any_var result =
ri->result ();
TAO_OutputCDR cdr;
result->impl ()->marshal_value (cdr);
Dynamic::ParameterList_var pl =
ri->arguments ();
CORBA::ULong len = pl->length ();
for (CORBA::ULong index = 0; index != len ; ++index)
{
//@@ No chance for PARAM_OUT
if ((*pl)[index].mode == CORBA::PARAM_INOUT)
{
(*pl)[index].argument.impl ()->marshal_value (cdr);
}
}
CORBA::OctetSeq_var reply;
ACE_NEW (reply.out (), CORBA::OctetSeq (cdr.total_length ()));
reply->length (cdr.total_length ());
CORBA::Octet* buf = reply->get_buffer ();
// @@ What if this throws an exception?? We don't have any way to
// check whether this succeeded
for (ACE_Message_Block const* mb = cdr.begin ();
mb != 0;
mb = mb->cont ())
{
ACE_OS::memcpy (buf, mb->rd_ptr (), mb->length ());
buf += mb->length ();
}
// Logging the reply and state update.
//
// First send message to members.
//
{
// Extract state update.
CORBA::OctetSeq_var oid = ri->object_id ();
PortableInterceptor::AdapterName_var an = ri->adapter_name ();
CORBA::Any_var state = ri->get_slot (state_slot_id ());
CORBA::TypeCode_var tc = state->type ();
if (tc->kind () == CORBA::tk_null)
{
ACE_DEBUG ((LM_DEBUG, "Slot update is void\n"));
PortableServer::POA_var poa = resolve_poa (an.in ());
PortableServer::ServantBase_var servant =
poa->id_to_servant (oid.in ());
Checkpointable* target =
dynamic_cast<Checkpointable*> (servant.in ());
if (target)
{
CORBA::Any_var tmp = target->get_state ();
if (tmp.ptr () != 0) state = tmp._retn ();
}
}
TAO_OutputCDR cdr;
cdr << oid.in ();
cdr << an.in ();
cdr << ftr->client_id.in ();
cdr << ftr->retention_id;
cdr << reply.in ();
cdr << state.in ();
size_t size = cdr.total_length ();
CORBA::OctetSeq_var msg;
ACE_NEW (msg.out (), CORBA::OctetSeq (size));
msg->length (size);
{
CORBA::Octet* buf = msg->get_buffer ();
for (ACE_Message_Block const* mb = cdr.begin ();
mb != 0;
mb = mb->cont ())
{
ACE_OS::memcpy (buf, mb->rd_ptr (), mb->length ());
buf += mb->length ();
}
}
CORBA::Octet* buf = msg->get_buffer ();
// Crash point 1.
//
if (crash_point == 1 && ftr->retention_id > 2) ACE_OS::exit (1);
try
{
while (true)
{
try
{
group_->send (buf, size);
ACE_DEBUG ((LM_DEBUG, "Sent log record of length %i\n", size));
break;
}
catch (ACE_TMCast::Group::Aborted const&)
{
ACE_DEBUG ((LM_DEBUG, "Retrying to send log record.\n"));
}
}
}
catch (ACE_TMCast::Group::Failed const&)
{
ACE_DEBUG ((LM_DEBUG,
"Group failure. Perhaps, I am alone in the group.\n"));
}
}
// Now perform local logging.
//
RecordId rid (ftr->client_id.in (), ftr->retention_id);
// This is slow but eh-safe ;-).
//
log_.insert (rid, reply);
// Crash point 2.
//
if (crash_point == 2 && ftr->retention_id > 2) ACE_OS::exit (1);
}