#include <Forwarder.h>
Inheritance diagram for ImR_Forwarder:
Public Member Functions | |
| ImR_Forwarder (ImR_Locator_i &imr_impl) | |
| virtual PortableServer::Servant | preinvoke (const PortableServer::ObjectId &oid, PortableServer::POA_ptr poa, const char *operation, PortableServer::ServantLocator::Cookie &cookie) |
| Called before the invocation begins. | |
| virtual void | postinvoke (const PortableServer::ObjectId &oid, PortableServer::POA_ptr adapter, const char *operation, PortableServer::ServantLocator::Cookie the_cookie, PortableServer::Servant the_servant) |
| void | init (CORBA::ORB_ptr orb) |
Private Attributes | |
| ImR_Locator_i & | locator_ |
| Where we find out where to forward to. | |
| PortableServer::Current_var | poa_current_var_ |
| POA reference. | |
| CORBA::ORB_ptr | orb_ |
| Variable to save the ORB reference passed to the constr. | |
This class provides a ServantLocator implementation that is used to handle arbitrary calls and forward them to the correct place.
Definition at line 39 of file Forwarder.h.
|
|
This constructor takes in orb and ImR_Locator_i pointers to store for later use. It also grabs a reference to the POACurrent object for use in preinvoke. Definition at line 30 of file Forwarder.cpp.
00031 : locator_ (imr_impl) 00032 { 00033 } |
|
|
Definition at line 36 of file Forwarder.cpp. References ACE_ASSERT, ACE_DEBUG, LM_DEBUG, and poa_current_var_. Referenced by ImR_Locator_i::init_with_orb().
00037 {
00038 ACE_ASSERT (! CORBA::is_nil(orb));
00039 this->orb_ = orb;
00040 try
00041 {
00042 CORBA::Object_var tmp =
00043 orb->resolve_initial_references ("POACurrent");
00044
00045 this->poa_current_var_ =
00046 PortableServer::Current::_narrow (tmp.in ());
00047 }
00048 catch (const CORBA::Exception&)
00049 {
00050 ACE_DEBUG ((LM_DEBUG, "ImR_Forwarder::init() Exception ignored.\n"));
00051 }
00052 ACE_ASSERT (!CORBA::is_nil (this->poa_current_var_.in ()));
00053 }
|
|
||||||||||||||||||||||||
|
Definition at line 153 of file Forwarder.cpp.
00158 {
00159 }
|
|
||||||||||||||||||||
|
Called before the invocation begins. We figure out the intended recipient from the POA name. After activating the server, we throw a forwarding exception to the correct server. The big complicated thing here is that we have to create the forwarding ior based on what we already have. So we combine the endpoint received from activate_server_i and append the objectid from the request to it. Definition at line 64 of file Forwarder.cpp. References ACE_ASSERT, ACE_CString, ACE_DEBUG, ACE_ERROR, ImR_Locator_i::activate_server_by_name(), ImR_Locator_i::debug(), TAO::ObjectKey::encode_sequence_to_string(), TAO::Portable_Server::POA_Current::implementation(), CORBA::is_nil(), LM_DEBUG, LM_ERROR, TAO::Portable_Server::POA_Current_Impl::object_key(), poa_current_var_, and TAO_IMPLREPO_MINOR_CODE.
00068 {
00069 ACE_ASSERT (! CORBA::is_nil(poa));
00070 CORBA::Object_var forward_obj;
00071
00072 try
00073 {
00074 CORBA::String_var server_name = poa->the_name();
00075
00076 if (locator_.debug() > 1)
00077 ACE_DEBUG ((LM_DEBUG, "ImR: Activating server <%s>.\n", server_name.in()));
00078
00079 // The activator stores a partial ior with each server. We can
00080 // just tack on the current ObjectKey to get a valid ior for
00081 // the desired server.
00082 CORBA::String_var pior = locator_.activate_server_by_name (server_name.in (), false);
00083
00084 ACE_CString ior = pior.in ();
00085
00086 // Check that the returned ior is the expected partial ior with
00087 // missing ObjectKey.
00088 if (ior.find ("corbaloc:") != 0 || ior[ior.length () - 1] != '/')
00089 {
00090 ACE_ERROR ((LM_ERROR, "ImR_Forwarder::preinvoke () Invalid corbaloc ior.\n\t<%s>\n", ior.c_str()));
00091 throw CORBA::OBJECT_NOT_EXIST (
00092 CORBA::SystemException::_tao_minor_code (
00093 TAO_IMPLREPO_MINOR_CODE,
00094 0),
00095 CORBA::COMPLETED_NO);
00096 }
00097
00098 CORBA::String_var key_str;
00099 // Unlike POA Current, this implementation cannot be cached.
00100 TAO::Portable_Server::POA_Current* tao_current =
00101 dynamic_cast <TAO::Portable_Server::POA_Current*> (this->poa_current_var_.in ());
00102
00103 ACE_ASSERT(tao_current != 0);
00104 TAO::Portable_Server::POA_Current_Impl* impl = tao_current->implementation ();
00105 TAO::ObjectKey::encode_sequence_to_string (key_str.out (), impl->object_key ());
00106
00107 ior += key_str.in();
00108
00109 if (locator_.debug() > 0)
00110 ACE_DEBUG ((LM_DEBUG, "ImR: Forwarding invocation on <%s> to <%s>\n", server_name.in(), ior.c_str()));
00111
00112 forward_obj =
00113 this->orb_->string_to_object (ior.c_str ());
00114 }
00115 catch (const ImplementationRepository::CannotActivate&)
00116 {
00117 throw CORBA::TRANSIENT (
00118 CORBA::SystemException::_tao_minor_code (
00119 TAO_IMPLREPO_MINOR_CODE,
00120 0),
00121 CORBA::COMPLETED_NO);
00122 }
00123 catch (const ImplementationRepository::NotFound&)
00124 {
00125 throw CORBA::TRANSIENT (
00126 CORBA::SystemException::_tao_minor_code (
00127 TAO_IMPLREPO_MINOR_CODE,
00128 0),
00129 CORBA::COMPLETED_NO);
00130 }
00131 catch (const CORBA::Exception& ex)
00132 {
00133 ex._tao_print_exception ("Forwarder");
00134 throw CORBA::TRANSIENT (
00135 CORBA::SystemException::_tao_minor_code (
00136 TAO_IMPLREPO_MINOR_CODE,
00137 0),
00138 CORBA::COMPLETED_NO);
00139 }
00140
00141 if (!CORBA::is_nil (forward_obj.in ()))
00142 throw PortableServer::ForwardRequest (forward_obj.in ());
00143
00144 ACE_ERROR ((LM_ERROR, "Error: Forward_to reference is nil.\n"));
00145 throw CORBA::OBJECT_NOT_EXIST (
00146 CORBA::SystemException::_tao_minor_code (
00147 TAO_IMPLREPO_MINOR_CODE,
00148 0),
00149 CORBA::COMPLETED_NO);
00150 }
|
|
|
Where we find out where to forward to.
Definition at line 64 of file Forwarder.h. |
|
|
Variable to save the ORB reference passed to the constr.
Definition at line 70 of file Forwarder.h. |
|
|
POA reference.
Definition at line 67 of file Forwarder.h. Referenced by init(), and preinvoke(). |
1.3.6