X-Git-Url: http://pilppa.org/gitweb/?a=blobdiff_plain;f=src%2Fplpbus%2FOrbServerImpl.cc;h=9a48aba32fd12eba13b916924b871c9bcec902c4;hb=741398826280fe8ea212a0001f9b3d655fff6de9;hp=d12846e206c7f4b27637915c20a1b04696b5b9b2;hpb=a4cadd50e661871c819f9f253f3595cfba647aed;p=libplpbus.git diff --git a/src/plpbus/OrbServerImpl.cc b/src/plpbus/OrbServerImpl.cc index d12846e..9a48aba 100644 --- a/src/plpbus/OrbServerImpl.cc +++ b/src/plpbus/OrbServerImpl.cc @@ -5,6 +5,8 @@ * Author: lamikr */ +#include + #include "ServerEventThread.hh" #include "OrbServerImpl.hh" #include "ClientServerCommon.hh" @@ -28,82 +30,100 @@ OrbServerImpl::OrbServerImpl() OrbServerImpl::~OrbServerImpl() { - cout << "OrbServerImpl destroyed." << endl; + log_info("OrbServerImpl destroyed.\n"); } void OrbServerImpl::send_message_and_request_response(OrbClient_ptr response_listener_param, const char* msg_req) { - char *msg_rsp; + const char *msg_rsp; msg_rsp = NULL; if (CORBA::is_nil(response_listener_param) == false) { if (_listener != NULL) { - cout << "send_message_and_request_response(): " << msg_req << ", server_callback != NULL" << endl; + log_debug("send_message_and_request_response(): %s, server callback != NULL\n", msg_req); _listener->request_received(msg_req, &msg_rsp); + log_debug("send_message_and_request_response(), request_received\n"); response_listener_param->receive_response_message(msg_rsp); } else { - cout << "send_message_and_request_response() error! " << msg_req << ", server_callback == NULL" << endl; + log_error("send_message_and_request_response() error, server callback == NULL\n"); } } else { - cerr << "invalid callback object received.\n"; + log_error("invalid callback object received.\n"); } } char *OrbServerImpl::send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg) { - char *msg_rsp; - char *ret_val; + const char *msg_rsp; + char *ret_val; err_flg = 0; msg_rsp = NULL; if (_listener != NULL) { - cout << "send_message_and_wait_response(): " << msg_req_param << ", server_callback != NULL" << endl; + log_debug("send_message_and_wait_response(): %s, server_callback != NULL\n", msg_req_param); _listener->request_received(msg_req_param, &msg_rsp); + //ret_val = CORBA::string_dup(msg_rsp); + ret_val = CORBA::string_dup(msg_rsp); } else { - cout << "send_message_and_wait_response() error! " << msg_req_param << ", server_callback == NULL" << endl; - msg_rsp = strdup(msg_req_param); + log_error("send_message_and_wait_response() error, server callback == NULL\n"); + ret_val = CORBA::string_dup(msg_req_param); err_flg = -1; } - ret_val = CORBA::string_dup(msg_rsp); return ret_val; } void OrbServerImpl::send_dataitem_message_and_request_response(OrbClient_ptr response_listener_param, const ::DataItemSequence& msg_req_param) { - BusMessage *msg_req; - BusMessage *msg_rsp; + BusMessage *msg_req; + BusMessage *msg_rsp; + DataItemSequence *seq; + int err_flg; if (CORBA::is_nil(response_listener_param) == false) { if (_listener != NULL) { msg_req = new BusMessageInternal(msg_req_param); - cout << "send_dataitem_message_and_request_response(), server_callback != NULL" << endl; - cout << "msg_req:" << endl; + log_debug("send_dataitem_message_and_request_response(), server_callback != NULL\n"); + log_debug("msg_req:\n"); msg_req->printout(); msg_rsp = NULL; - _listener->request_received(msg_req, &msg_rsp); - cout << "msg_rsp length:" << msg_rsp->_dataItemSeq.length() << endl; + err_flg = 0; + msg_rsp = new BusMessage(msg_req->get_type(&err_flg)); + _listener->request_received(msg_req, msg_rsp); + seq = (DataItemSequence *)msg_rsp->_dataItemSeq; + log_debug("msg_rsp length: %ld\n", seq->length()); msg_rsp->printout(); - response_listener_param->receive_response_dataitem_sequence(msg_rsp->_dataItemSeq); + response_listener_param->receive_response_dataitem_sequence(*seq); + delete(msg_req); + delete(msg_rsp); } else { - cout << "send_dataitem_message_and_request_response() error, server_callback == NULL" << endl; + log_error("send_dataitem_message_and_request_response() error, server_callback == NULL\n"); } } } CORBA::Long OrbServerImpl::send_dataitem_message_and_wait_response(const DataItemSequence& req_seq_param, - DataItemSequence_out rsp_seq_param) { - BusMessage *msg_req; - BusMessage *msg_rsp; + DataItemSequence_out rsp_seq_param) { + BusMessage *msg_req; + BusMessage *msg_rsp; + DataItemSequence *seq; + int err_flg; - msg_req = new BusMessageInternal(req_seq_param); + seq = NULL; msg_rsp = NULL; - _listener->request_received(msg_req, &msg_rsp); - //rsp_seq_param = new DataItemSequence_out(msg_rsp._dataItemSeq); - rsp_seq_param._data = &(msg_rsp->_dataItemSeq); + msg_req = new BusMessageInternal(req_seq_param); + msg_rsp = new BusMessage(msg_req->get_type(&err_flg)); + _listener->request_received(msg_req, msg_rsp); + if (msg_rsp != NULL) { + seq = (DataItemSequence *)msg_rsp->_dataItemSeq; + } + else { + seq = new DataItemSequence(); + } + rsp_seq_param._data = seq; return 0; } @@ -115,7 +135,7 @@ void OrbServerImpl::add_event_listener(OrbClient_ptr client_param, ServerEventThread *srvr_thread; if (CORBA::is_nil(client_param) == false) { - cout << "add_event_listener()" << endl; + log_debug("add_event_listener()\n"); server_thread_mutex.lock(); _server_thread_count++; server_thread_mutex.unlock(); @@ -123,7 +143,7 @@ void OrbServerImpl::add_event_listener(OrbClient_ptr client_param, srvr_thread->start(); } else { - cerr << "Failed to add event listener, listener NULL.\n"; + log_error("Failed to add event listener, listener NULL.\n"); } } @@ -131,15 +151,18 @@ void OrbServerImpl::shutdown() { omni_mutex_lock sync(server_thread_mutex); if (is_shutdown_pending() == 0) { - cout << "shutdown request received!" << endl; + log_debug("shutdown request received!\n"); // Tell the servers to exit, and wait for them to do so. _shutdown_pending = 1; while(_server_thread_count > 0) { - server_thread_shutdown_signal.wait(); + server_thread_shutdown_signal.timedwait(5, 0); + log_debug("signal received\n"); } // Shutdown the ORB (but do not wait for completion). This also // causes the main thread to unblock from CORBA::ORB::run(). + log_debug("calling orb shutdown\n"); _orb->shutdown(0); + log_debug("orb shutdown called\n"); } } @@ -157,7 +180,7 @@ int OrbServerImpl::init() { retVal = 0; } else { - cout << "init() failed" << endl; + log_error("init() failed\n"); } return retVal; } @@ -177,14 +200,17 @@ int OrbServerImpl::launch(const char *server_name) //this->_remove_ref(); naming_context = get_service_naming_context(CONST_CONTEXT_NAME__PLPBUS, CONST_CONTEXT_KIND__PLPBUS); if (naming_context != NULL) { - ok_flg = bind_naming_context_and_service(naming_context, server_ref, server_name, CONST_CONTEXT_KIND__PLPBUS); + ok_flg = bind_naming_context_and_service(naming_context, + server_ref, + server_name, + CONST_CONTEXT_KIND__PLPBUS); if (ok_flg == true) { - cout << "Registered to naming service: " << server_name << endl; + log_debug("Registered to naming service: %s\n", server_name); _orb->run(); ret_val = 0; } else { - cout << "Failed to register to naming service: " << server_name << endl; + log_error("Failed to register to naming service: %s\n", server_name); } } return ret_val; @@ -217,7 +243,7 @@ PortableServer::POA_var OrbServerImpl::create_poa(CORBA::ORB_var orb) { } } else { - cerr << "Failed to create RootPOA." << endl; + log_error("Failed to create RootPOA.\n"); } return ret_val; } @@ -234,47 +260,64 @@ CosNaming::NamingContext_var OrbServerImpl::get_service_naming_context(const cha ret_val = NULL; try { // get nameservice reference + log_debug("get_service_naming_context() 1\n"); ns_obj = _orb->resolve_initial_references(CONST_NAME_SERVICE_NAME); - // get nameservice context + log_debug("get_service_naming_context() 2\n"); + // get name service context ns_context = CosNaming::NamingContext::_narrow(ns_obj); + log_debug("get_service_naming_context() 3\n"); if (CORBA::is_nil(ns_context) == false) { context_data.length(1); - context_data[0].id = service_name_param; - context_data[0].kind = service_kind_param; + context_data[0].id = service_name_param; + context_data[0].kind = service_kind_param; + log_debug("get_service_naming_context() 4\n"); try { service_obj = ns_context->resolve(context_data); + } + catch(CosNaming::NamingContext::NotFound& ex) { + log_error("Failed to get context from name service for %s. Context does not yet exist, but will try to create.\n", service_name_param); + } + try { + log_debug("get_service_naming_context() 5\n"); if (CORBA::is_nil(service_obj)) { // not found, try to bind the new context to name service + log_debug("get_service_naming_context() 6\n"); ret_val = ns_context->bind_new_context(context_data); + log_debug("get_service_naming_context() 7\n"); if (CORBA::is_nil(ret_val) ) { - cerr << "Failed to create new context to name service for " << service_name_param << "." << endl; + log_error("Failed to create new context to name service for %s.\n", service_name_param); } } else { ret_val = CosNaming::NamingContext::_narrow(service_obj); if (CORBA::is_nil(ret_val) ) { - cerr << "Failed to get existing context from name service for " << service_name_param << ", narrowing failed." << endl; + log_error("Failed to get existing context from name service for %s, narrowing failed.\n", service_name_param); } } } catch(CosNaming::NamingContext::AlreadyBound& ex) { - cerr << "Could not get context from nameservice for " << service_name_param << ". Context with same name already existed."<< endl; + log_error("Failed to get context from name service for %s. Context with same name already exist.\n", service_name_param); } } } catch (CORBA::ORB::InvalidName&) { // This should not happen! - cerr << "Could not get context from name service for " << service_name_param << ", name service does not exist." << endl; + log_error("Failed to get context from name service for %s, name service does not exist.\n", service_name_param); } catch(CORBA::TRANSIENT& ex) { - cerr << "Could not get context from name service for " << service_name_param << ", verify that name service is running. " << service_name_param << endl; + log_error("Failed to get context from name service for %s, verify that name service is running.\n", service_name_param); } catch (CORBA::NO_RESOURCES&) { - cerr << "Could not get context from name service for " << service_name_param << ". Name service is not running or has configuration problem." << endl; + log_error("Failed to get context from name service for %s, Name service is not running or has configuration problem.\n", service_name_param); + log_error("Check-list:\n"); + log_error("If you have OMNIORB_CONFIG environment variable defined, verify that omniORB.cfg file exist in that location.\n"); + log_error("If you do not have OMNIORB_CONFIG environment variable defined, verify that you have /etc/omniORB.cfg file\n"); + log_error("Verify that InitRef line is defined in omniORB.cfg file.\n"); } catch(CORBA::SystemException& ex) { - cerr << "Could not get context from name service for " << service_name_param << ", could not determine reason." << endl; + log_error("Failed to get context from name service for %s, system error.\n", service_name_param); } + log_debug("get_service_naming_context() done\n"); return ret_val; } @@ -300,23 +343,23 @@ bool OrbServerImpl::bind_naming_context_and_service(CosNaming::NamingContext_var * service existed already for the naming context with similar description. * Replace the existing one with a new one. */ - cout << "service " << service_name_param << " existed, replacing it." << endl; + log_warning("service %s exist, replacing it\n", service_name_param); service_context_param->rebind(context_data, service_ref_param); retVal = true; } } catch (CosNaming::NamingContext::InvalidName&) { - cerr << "Could not register service to name server, invalid service name." << endl; + log_error("Could not register service to name server, invalid service name.\n"); } catch (CosNaming::NamingContext::NotFound&) { - cerr << "Could not register service to name server, service object reference is invalid." << endl; + log_error("Could not register service to name server, service object reference is invalid.\n"); } catch (CosNaming::NamingContext::CannotProceed&) { // This should not happen! - cerr << "Could not register service to name server, unknown error." << endl; + log_error("Could not register service to name server, unknown error.\n"); } catch(CORBA::SystemException& ex) { - cerr << "Could not register service to name server, unknown error." << endl; + log_error("Could not register service to name server, unknown error.\n"); } return retVal; } @@ -326,9 +369,8 @@ int OrbServerImpl::add_server_listener(IServerListener *listener_param) int retVal; retVal = 0; - cout << "register_request_received_callback() started" << endl; + log_debug("register_request_received_callback() started\n"); _listener = listener_param; - cout << "register_callback() done" << endl; return retVal; } @@ -337,15 +379,20 @@ int OrbServerImpl::is_shutdown_pending() { } void OrbServerImpl::server_thread_closed() { - bool send_signal = false; + bool send_signal; + log_debug("server_thread_closed() started\n"); + send_signal = false; server_thread_mutex.lock(); + log_debug("server_thread_closed(), server_thread_count: %d\n", _server_thread_count); _server_thread_count--; if (_server_thread_count == 0) { send_signal = true; } server_thread_mutex.unlock(); if (send_signal == true) { + log_debug("server_thread_closed(), sending signal\n"); server_thread_shutdown_signal.signal(); + log_debug("server_thread_closed(), signal send\n"); } }