void
ReplicaController::tao_ft_interception_point (
PortableInterceptor::ServerRequestInfo_ptr ri,
CORBA::OctetSeq_out ocs)
{
FT::FTRequestServiceContext_var ftr (
extract_context (ri));
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Received request from %s with rid %i\n",
ftr->client_id.in (),
ftr->retention_id));
// Check if this request is eligible for replay.
RecordId rid (ftr->client_id.in (), ftr->retention_id);
if (log_.contains (rid))
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Replaying reply for %s with rid %i\n",
ftr->client_id.in (),
ftr->retention_id));
CORBA::OctetSeq_var copy (log_.lookup (rid)); // make a copy
ocs = copy._retn ();
}
return;
}
void
AssemblyImpl::installComponent
(Qedo_Components::Deployment::ComponentInstallation_ptr componentInstallation, HomeInstanceData data)
throw( Components::CreateFailure )
{
std::string package_file_ref = data.file;
std::string package_file = data_.implementationMap_[package_file_ref];
std::string impl_id = data.impl_id;
std::string location = std::string("PACKAGE=") + getFileName(package_file);
//
// install
//
try
{
DEBUG_OUT("..... install implementation ");
DEBUG_OUT2(".......... destination is ", data.dest);
DEBUG_OUT2(".......... implementation id is ", impl_id);
DEBUG_OUT2(".......... package is ", package_file);
componentInstallation->install(impl_id.c_str(), location.c_str());
}
catch(Components::Deployment::InvalidLocation&)
{
DEBUG_OUT( ".......... upload required " );
CORBA::OctetSeq_var octSeq = new CORBA::OctetSeq();
struct stat statbuff;
int rt = stat(package_file.c_str(), &statbuff);
long size = statbuff.st_size;
octSeq->length(size);
std::ifstream package_stream(package_file.c_str(), std::ios::binary|std::ios::in);
package_stream.read((char*)octSeq->get_buffer(), size);
package_stream.close();
//
// upload first and install afterwards
//
try
{
location = componentInstallation->upload(impl_id.c_str(), octSeq);
DEBUG_OUT( ".......... upload done, install now " );
componentInstallation->install(impl_id.c_str(), location.c_str());
}
catch(Components::Deployment::InstallationFailure&)
{
throw Components::CreateFailure();
}
}
catch(Components::Deployment::InstallationFailure&)
{
NORMAL_ERR( "AssemblyImpl: InstallationFailure during install()" );
throw Components::CreateFailure();
}
catch ( CORBA::SystemException& )
{
NORMAL_ERR( "AssemblyImpl: CORBA system exception during install()" );
NORMAL_ERR( "..... is ComponentInstallation running?" );
throw Components::CreateFailure();
}
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
CORBA::Object_var object =
orb->resolve_initial_references("CodecFactory");
IOP::CodecFactory_var codec_factory =
IOP::CodecFactory::_narrow(object.in ());
IOP::Encoding e = {IOP::ENCODING_CDR_ENCAPS,1,2};
IOP::Codec_var codec = codec_factory->create_codec(e);
CORBA::Any any_o;
Value* value = new OBV_Value;
any_o <<= &value;
CORBA::OctetSeq_var bin = codec->encode(any_o);
CORBA::Any_var any_n = codec->decode(bin.in ());
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught a CORBA exception\n");
return 1;
}
catch (...)
{
return 1;
}
return 0;
}
CORBA::OctetSeq *ossieSupport::strings_to_octet_sequence(std::vector<std::string> &values)
{
CORBA::OctetSeq_var result = new CORBA::OctetSeq;
result->length(values.size());
for (unsigned int i = 0; i < values.size(); ++i) {
result[i] = (short) atoi(values[i].c_str());
}
return result._retn();
}
void
ServerContainerInterceptor::send_other (Components::ContainerPortableInterceptor::ContainerServerRequestInfo_ptr csi) {
std::cout << "COPI: send_other: " << csi->request_info()->operation();
std::cout << " for id:" << csi->component_id() << std::endl;
#ifdef WIN32
org::coach::tracing::api::TraceEvent_var event = new org::coach::tracing::api::TraceEvent;
// set time_stamp
struct _timeb current_time;
_ftime(¤t_time);
CORBA::LongLong tm = current_time.time;
tm = tm * 1000 + current_time.millitm;
event->time_stamp = tm;
// set ineraction point
event->interaction_point = org::coach::tracing::api::POA_OUT_EXCEPTION;
event->trail_label= CORBA::string_dup ("");
unsigned long event_number = executor_ -> get_new_event_number();
char cnt[11];
sprintf (cnt, "__%08x", event_number);
std::string messageid = process_id_ + cnt;
event->message_id = CORBA::string_dup (messageid.c_str());
event->thread_id = CORBA::string_dup ("");
event->trail_id = CORBA::string_dup (messageid.c_str());
event->event_counter = event_number;
event->op_name = CORBA::string_dup (CORBA::string_dup(csi->request_info()->operation()));
event->identity.object_instance_id = CORBA::string_dup (csi->name());
event->identity.object_repository_id = CORBA::string_dup ("TE");
event->identity.cmp_name = CORBA::string_dup (csi->component_id());
event->identity.cmp_type = CORBA::string_dup ("UNKNOWN_COMPONENT_TYPE");
event->identity.cnt_name = CORBA::string_dup ("UNKNOW_CONTAINER_NAME");
event->identity.cnt_type = CORBA::string_dup ("UNKONWN_CONTAINER_TYPE");
event->identity.node_name = CORBA::string_dup (hostname_.c_str());
event->identity.node_ip = CORBA::string_dup (" e");
event->identity.process_id = CORBA::string_dup (process_id_.c_str());
// Dynamic::ParameterList_var parameters = new Dynamic::ParameterList();
// parameters->length(0);
event->parameters.length(0);
org::coach::tracing::api::TraceEvents_var trace = new org::coach::tracing::api::TraceEvents;
trace->length(1);
(*trace)[0] = event;
context_-> get_connection_to_trace_server() -> receiveEvent(trace.in());
CORBA::Any out_any;
out_any <<= messageid.c_str();
CORBA::OctetSeq_var data = executor_ -> get_cdr_codec_ptr() -> encode_value(out_any);
IOP::ServiceContext out_sc;
out_sc.context_id = 100;
out_sc.context_data.length(data->length());
memcpy(out_sc.context_data.get_buffer(), data->get_buffer(), data->length());
csi->request_info()->add_reply_service_context(out_sc, true);
#endif
}
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
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);
}
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);
}
int
TAO_Object_Adapter::dispatch (TAO::ObjectKey &key,
TAO_ServerRequest &request,
CORBA::Object_out forward_to)
{
if (key.length() < TAO_Root_POA::TAO_OBJECTKEY_PREFIX_SIZE
|| ACE_OS::memcmp (key.get_buffer (),
&TAO_Root_POA::objectkey_prefix[0],
TAO_Root_POA::TAO_OBJECTKEY_PREFIX_SIZE) != 0)
{
return TAO_Adapter::DS_MISMATCHED_KEY;
}
int result = 0;
#if TAO_HAS_INTERCEPTORS == 1
TAO::ServerRequestInterceptor_Adapter *sri_adapter =
orb_core_.serverrequestinterceptor_adapter ();
try
{
if (sri_adapter != 0)
{
#if TAO_HAS_EXTENDED_FT_INTERCEPTORS == 1
CORBA::OctetSeq_var ocs;
sri_adapter->tao_ft_interception_point (request,
0, // args
0, // nargs
0, // servant_upcall
0, // exceptions
0, // nexceptions
ocs.out ());
/// If we have a cached result, just go ahead and send the reply
/// and let us return
if (ocs.ptr () != 0)
{
// request.result_seq (
request.send_cached_reply (ocs.inout ());
return TAO_Adapter::DS_OK;
}
// If a PortableInterceptor::ForwardRequest exception was
// thrown, then set the forward_to object reference and return
// with the appropriate return status.
forward_to.ptr () = request.forward_location ();
if (request.is_forwarded ())
{
return TAO_Adapter::DS_FORWARD;
}
#endif /*TAO_HAS_EXTENDED_FT_INTERCEPTORS*/
// The receive_request_service_contexts() interception point
// must be invoked before the operation is dispatched to the
// servant.
sri_adapter->receive_request_service_contexts (request,
0, // args
0, // nargs
0, // servant_upcall
0, // exceptions
0); // nexceptions
// If a PortableInterceptor::ForwardRequest exception was
// thrown, then set the forward_to object reference and return
// with the appropriate return status.
forward_to.ptr () = request.forward_location ();
if (request.is_forwarded ())
{
return TAO_Adapter::DS_FORWARD;
}
}
#endif /* TAO_HAS_INTERCEPTORS == 1 */
result = this->dispatch_servant (key, request, forward_to);
#if TAO_HAS_INTERCEPTORS == 1
if (result == TAO_Adapter::DS_FORWARD)
{
request.reply_status (GIOP::LOCATION_FORWARD);
request.pi_reply_status (PortableInterceptor::LOCATION_FORWARD);
request.forward_location (forward_to.ptr ());
if (sri_adapter != 0)
{
sri_adapter->send_other (request,
0, // args
0, // nargs
0, // servant_upcall
0, // exceptions
0 // nexceptions
);
}
}
}
catch ( ::CORBA::Exception& ex)
{
// Just assume the current exception is a system exception, the
// status can only change when the interceptor changes this
// and this is only done when the sri_adapter is available. If we
// don't have an sri_adapter we just rethrow the exception
PortableInterceptor::ReplyStatus status =
PortableInterceptor::SYSTEM_EXCEPTION;
if (sri_adapter != 0)
{
request.caught_exception (&ex);
sri_adapter->send_exception (request,
0, // args
0, // nargs
0, // servant_upcall
0, // exceptions
0); // nexceptions
status = request.pi_reply_status ();
}
// Only re-throw the exception if it hasn't been transformed by
// the send_exception() interception point (e.g. to a
// LOCATION_FORWARD).
if (status == PortableInterceptor::SYSTEM_EXCEPTION
|| status == PortableInterceptor::USER_EXCEPTION)
{
throw;
}
}
#endif /* TAO_HAS_INTERCEPTORS == 1 */
return result;
}
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
MIF_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr ri)
{
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();
RTScheduling::Current::IdType_var guid = this->current_->id ();
/*
ACE_OS::memcpy (&guid,
guid->get_buffer (),
guid->length ());
*/
CORBA::Short importance;
if (CORBA::is_nil (sched_policy.in ()))
{
importance = 0;
}
else
{
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;
#ifdef KOKYU_DSRT_LOGGING
int int_guid;
ACE_OS::memcpy (&int_guid,
guid->get_buffer (),
guid->length ());
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): send_request importance from current = %d, guid = %d\n",
importance, 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.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 ();
#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
kokyu_dispatcher_->update_schedule (guid.in (),
Kokyu::BLOCK);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t|%T): send_request interceptor done\n")));
#endif
}
