X-Git-Url: http://pilppa.org/gitweb/?a=blobdiff_plain;f=src%2Fplpbus%2FOrbServerImpl.cc;h=0a037f26e23462ad1245b183d15a729d423defd1;hb=f6bd0d4fefd6459f2e8e5e7b813933be2d87dd47;hp=ea651a93a2c58fc6101efbdce69e889ede00c3c9;hpb=0fd166a47de97339450927147f81e12b9cf17a40;p=libplpbus.git

diff --git a/src/plpbus/OrbServerImpl.cc b/src/plpbus/OrbServerImpl.cc
index ea651a9..0a037f2 100644
--- a/src/plpbus/OrbServerImpl.cc
+++ b/src/plpbus/OrbServerImpl.cc
@@ -30,19 +30,20 @@ OrbServerImpl::OrbServerImpl()
 
 OrbServerImpl::~OrbServerImpl()
 {
-	log_info("OrbServerImpl destroyed.\n");
+	log_info("done\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) {
 			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 {
@@ -55,28 +56,31 @@ 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;
 	if (_listener != NULL) {
 		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 {
 		log_error("send_message_and_wait_response() error, server callback == NULL\n");
-		msg_rsp	= strdup(msg_req_param);
+		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) {
@@ -85,10 +89,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);
-			log_debug("msg_rsp length: %d\n", msg_rsp->_dataItemSeq.length());
+			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 {
 			log_error("send_dataitem_message_and_request_response() error, server_callback == NULL\n");
@@ -97,15 +106,24 @@ void OrbServerImpl::send_dataitem_message_and_request_response(OrbClient_ptr res
 }
 
 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;
 }
@@ -125,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");
 	}
 }
 
@@ -133,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");
 	}
 }
 
@@ -153,13 +174,20 @@ int OrbServerImpl::init() {
 	argc	= -1;
 	argv	= NULL;
 	retVal	= 0;
+	log_debug("started\n");
 	_orb	= CORBA::ORB_init(argc, argv);
 	if (_orb != NULL) {
 		_poa	= create_poa(_orb);
-		retVal	= 0;
+		if (CORBA::is_nil(_poa) == false) {
+			retVal	= 0;
+			log_info("init success\n");
+		}
+		else {
+			log_info("init failed\n");
+		}
 	}
 	else {
-		cout << "init() failed"  << endl;
+		log_error("init() failed\n");
 	}
 	return retVal;
 }
@@ -170,23 +198,27 @@ int OrbServerImpl::launch(const char *server_name)
 	PortableServer::ObjectId_var	server_id;
 	bool				ok_flg;
 	int				ret_val;
-	CosNaming::NamingContext_var	naming_context;
+	CosNaming::NamingContext_var	naming_cntx;
 
 	ret_val		= -1;
 	POA_plpbus_orb::OrbServer_tie<OrbServerImpl> server_impl(this);
 	server_id	= _poa->activate_object(&server_impl);
 	server_ref	= server_impl._this();
 	//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);
+	naming_cntx	= get_naming_service_context(CONST_CONTEXT_NAME__PLPBUS, CONST_CONTEXT_KIND__PLPBUS);
+	if (naming_cntx != NULL) {
+		ok_flg	= bind_naming_context_and_service(naming_cntx,
+							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();
+			log_debug("run stopped: %s\n", server_name);
 			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;
@@ -201,119 +233,130 @@ PortableServer::POA_var OrbServerImpl::create_poa(CORBA::ORB_var orb) {
 	PortableServer::POA_var 	rootpoa;
 
 	ret_val = NULL;
-	poa_obj	= orb->resolve_initial_references(CONST_ROOT_POA_NAME);
-	if (poa_obj != NULL) {
+	log_debug("started\n");
+	try {
+		poa_obj	= orb->resolve_initial_references(CONST_ROOT_POA_NAME);
+		log_debug("received initial reference to %s\n", CONST_ROOT_POA_NAME);
 		rootpoa	= PortableServer::POA::_narrow(poa_obj);
-		if (rootpoa != NULL) {
-			poa_man	= rootpoa->the_POAManager();
-			if (poa_man != NULL) {
-				poa_man->activate();
-				// bidirectional policy
-				policy_list.length(1);
-				policyVal	<<= BiDirPolicy::BOTH;
-				policy_list[0] = orb->create_policy(BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, policyVal);
-				ret_val = rootpoa->create_POA(CONST_ROOT_POA_BIDIR_POLICY_NAME,
-							poa_man,
-							policy_list);
-			}
+		poa_man	= rootpoa->the_POAManager();
+		poa_man->activate();
+		// bidirectional policy
+		policy_list.length(1);
+		policyVal	<<= BiDirPolicy::BOTH;
+		policy_list[0]	= orb->create_policy(BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, policyVal);
+		ret_val 	= rootpoa->create_POA(CONST_ROOT_POA_BIDIR_POLICY_NAME,
+					poa_man,
+					policy_list);
+		if (CORBA::is_nil(ret_val) == false) {
+			log_info("Created root poa %s\n", CONST_ROOT_POA_NAME);
+		}
+		else {
+			log_error("Failed to create RootPOA %s\n", CONST_ROOT_POA_NAME);
 		}
 	}
-	else {
-		cerr << "Failed to create RootPOA." << endl;
+	catch(CORBA::SystemException& ex) {
+		log_error("Failed to create RootPOA, received system exception CORBA::%s\n", ex._name());
+	}
+	catch(CORBA::Exception& ex) {
+		log_error("Failed to create RootPOA, received exception CORBA::%s\n", ex._name());
+	}
+	catch(omniORB::fatalException& ex) {
+		log_error("Failed to create RootPOA, received fatal exception CORBA::%s\n", ex.errmsg());
 	}
 	return ret_val;
 }
 
-CosNaming::NamingContext_var OrbServerImpl::get_service_naming_context(const char *service_name_param,
+CosNaming::NamingContext_var OrbServerImpl::get_naming_service_context(const char *service_name_param,
 								const char *service_kind_param)
 {
 	CosNaming::NamingContext_var	ret_val;
-	CosNaming::NamingContext_var	ns_context;
+	CosNaming::NamingContext_var	ns_cntx;
 	CORBA::Object_var		ns_obj;
 	CORBA::Object_var 		service_obj;
-	CosNaming::Name			context_data;
+	CosNaming::Name			cntx_dta;
 
 	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);
-		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;
-			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) ) {
-						log_error("Failed to create new context to name service for %s.\n", service_name_param);
-					}
+		log_debug("started\n");
+		ns_obj	= _orb->resolve_initial_references(CONST_NAME_SERVICE_NAME);
+		if (CORBA::is_nil(ns_obj) == false) {
+			// get naming service context
+			ns_cntx	= CosNaming::NamingContext::_narrow(ns_obj);
+			if (CORBA::is_nil(ns_cntx) == false) {
+				cntx_dta.length(1);
+				cntx_dta[0].id		= CORBA::string_dup(service_name_param);
+				cntx_dta[0].kind	= CORBA::string_dup(service_kind_param);
+				try {
+					service_obj	= ns_cntx->resolve(cntx_dta);
+				}
+				catch(CosNaming::NamingContext::NotFound& ex) {
+					log_error("Trying to create new naming service context %s.\n", service_name_param);
 				}
-				else {
-					log_debug("get_service_naming_context() 8\n");
-					ret_val = CosNaming::NamingContext::_narrow(service_obj);
-					log_debug("get_service_naming_context() 9\n");
-					if (CORBA::is_nil(ret_val) ) {
-						log_error("Failed to get existing context from name service for %s, narrowing failed.\n", service_name_param);
+				try {
+					if (CORBA::is_nil(service_obj)) {
+						// not found, try to bind new context from naming service
+						ret_val	= ns_cntx->bind_new_context(cntx_dta);
+						if (CORBA::is_nil(ret_val) ) {
+							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) ) {
+							log_error("Failed to get naming service context for  %s, narrowing failed for resolved service context.\n", service_name_param);
+						}
 					}
 				}
+				catch(CosNaming::NamingContext::AlreadyBound& ex) {
+					log_error("Failed to get naming service context for %s. Context with same name already exist.\n", service_name_param);
+				}
 			}
-			catch(CosNaming::NamingContext::AlreadyBound& ex) {
-				log_error("Failed to get context from name service for %s. Context with same name already exist.\n", service_name_param);
+			else {
+				log_error("Failed to get naming service context for %s. Could not narrow the name service.\n", service_name_param);
 			}
+			//CORBA::release(ns_obj);
+		}
+		else {
+			log_error("Failed to get naming service context for %s. Could not get reference to name service.\n", service_name_param);
 		}
 	}
 	catch (CORBA::ORB::InvalidName&) {
 		// This should not happen!
-		log_error("Failed to get context from name service for %s, name service does not exist.\n", service_name_param);
+		log_error("Failed to get naming service context for %s, name service does not exist.\n", service_name_param);
 	}
 	catch(CORBA::TRANSIENT& ex) {
-		log_error("Failed to get context from name service for %s, verify that name service is running.\n", service_name_param);
+		log_error("Failed to get naming service context for %s, verify that name service is running.\n", service_name_param);
 	}
 	catch (CORBA::NO_RESOURCES&) {
-		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("Things to check:\n", service_name_param);
-		log_error("If you have OMNIORB_CONFIG environment variable defined, verify that omniORB.cfg file exist in that location.\n", service_name_param);
-		log_error("If you do not have OMNIORB_CONFIG environment variable defined, verify that you have /etc/omniORB.cfg file\n", service_name_param);
-		log_error("Verify that InitRef line is defined in omniORB.cfg file.\n", service_name_param);
+		log_error("Failed to get context from name service for %s, Naming 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) {
-		log_error("Failed to get context from name service for %s, system error.\n", service_name_param);
+		log_error("Failed to get naming service context for %s, system error.\n", service_name_param);
 	}
-	log_debug("get_service_naming_context() done\n");
+	log_debug("done\n");
 	return ret_val;
 }
 
-bool OrbServerImpl::bind_naming_context_and_service(CosNaming::NamingContext_var service_context_param,
-					CORBA::Object_ptr service_ref_param,
-					const char *service_name_param,
-					const char *service_kind_param)
+bool OrbServerImpl::bind_naming_context_and_service(CosNaming::NamingContext_var srv_cntx_param,
+					CORBA::Object_ptr srv_ref_param,
+					const char *srv_name_param,
+					const char *srv_kind_param)
 {
 	bool		retVal;
-	CosNaming::Name	context_data;
+	CosNaming::Name	cntx_dta;
 
 	retVal = false;
 	try {
-		context_data.length(1);
-		context_data[0].id   = service_name_param;
-		context_data[0].kind = service_kind_param;
+		cntx_dta.length(1);
+		cntx_dta[0].id   = CORBA::string_dup(srv_name_param);
+		cntx_dta[0].kind = CORBA::string_dup(srv_kind_param);
 		try {
-			service_context_param->bind(context_data, service_ref_param);
+			srv_cntx_param->bind(cntx_dta, srv_ref_param);
 			retVal	= true;
 		}
 		catch(CosNaming::NamingContext::AlreadyBound& ex) {
@@ -321,23 +364,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;
-			service_context_param->rebind(context_data, service_ref_param);
+			log_warning("service %s exist, replacing it\n", srv_name_param);
+			srv_cntx_param->rebind(cntx_dta, srv_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;
 }
@@ -347,9 +390,8 @@ int OrbServerImpl::add_server_listener(IServerListener *listener_param)
 	int	retVal;
 
 	retVal		= 0;
-	cout << "register_request_received_callback() started"  << endl;
+	log_debug("started\n");
 	_listener	= listener_param;
-	cout << "register_callback() done"  << endl;
 	return retVal;
 }
 
@@ -358,15 +400,20 @@ int OrbServerImpl::is_shutdown_pending() {
 }
 
 void OrbServerImpl::server_thread_closed() {
-	bool send_signal = false;
+	bool	send_signal;
 
+	log_debug("started\n");
+	send_signal = false;
 	server_thread_mutex.lock();
+	log_debug("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("sending signal\n");
 		server_thread_shutdown_signal.signal();
+		log_debug("signal send\n");
 	}
 }