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); }