X-Git-Url: http://pilppa.org/gitweb/?p=libplpbus.git;a=blobdiff_plain;f=src%2Fplpbus%2FOrbServerImpl.cc;fp=src%2Fplpbus%2FOrbServerImpl.cc;h=6e097486f5e7571effb81d332957bbed22393a3c;hp=3fa74a005dd95e1e05e5607617d68c8dcd4ddd2a;hb=827ba77fe55e4587ef605068ab092216cfffad2c;hpb=14952f0047c37298f20c5c084c60a8be344cb446 diff --git a/src/plpbus/OrbServerImpl.cc b/src/plpbus/OrbServerImpl.cc index 3fa74a0..6e09748 100644 --- a/src/plpbus/OrbServerImpl.cc +++ b/src/plpbus/OrbServerImpl.cc @@ -36,7 +36,7 @@ OrbServerImpl::~OrbServerImpl() 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) { @@ -56,8 +56,8 @@ void OrbServerImpl::send_message_and_request_response(OrbClient_ptr response_lis } 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; @@ -79,6 +79,7 @@ void OrbServerImpl::send_dataitem_message_and_request_response(OrbClient_ptr res BusMessage *msg_req; BusMessage *msg_rsp; DataItemSequence *seq; + int err_flg; if (CORBA::is_nil(response_listener_param) == false) { if (_listener != NULL) { @@ -87,11 +88,15 @@ void OrbServerImpl::send_dataitem_message_and_request_response(OrbClient_ptr res log_debug("msg_req:\n"); msg_req->printout(); msg_rsp = NULL; - _listener->request_received(msg_req, &msg_rsp); + 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(*seq); + delete(msg_req); + delete(msg_rsp); } else { log_error("send_dataitem_message_and_request_response() error, server_callback == NULL\n"); @@ -104,11 +109,13 @@ CORBA::Long OrbServerImpl::send_dataitem_message_and_wait_response(const DataIte BusMessage *msg_req; BusMessage *msg_rsp; DataItemSequence *seq; + int err_flg; seq = NULL; msg_rsp = NULL; msg_req = new BusMessageInternal(req_seq_param); - _listener->request_received(msg_req, &msg_rsp); + 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; } @@ -135,7 +142,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"); } } @@ -143,15 +150,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"); } } @@ -169,7 +179,7 @@ int OrbServerImpl::init() { retVal = 0; } else { - cout << "init() failed" << endl; + log_error("init() failed\n"); } return retVal; } @@ -194,12 +204,12 @@ int OrbServerImpl::launch(const char *server_name) 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; @@ -232,7 +242,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; } @@ -334,23 +344,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; } @@ -360,9 +370,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; } @@ -371,15 +380,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"); } }