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 {
}
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) {
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");
}
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;
}
srvr_thread->start();
}
else {
- cerr << "Failed to add event listener, listener NULL.\n";
+ log_error("Failed to add event listener, listener NULL.\n");
}
}
{
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");
}
}
_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;
}
//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;
PortableServer::POA_var rootpoa;
ret_val = NULL;
+ log_debug("started");
poa_obj = orb->resolve_initial_references(CONST_ROOT_POA_NAME);
if (poa_obj != NULL) {
+ 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();
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,
+ 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 {
+ log_error("Failed to create RootPOA, could not create POAManager for the root poa %s\n", CONST_ROOT_POA_NAME);
}
}
+ else {
+ log_error("Failed to create RootPOA, could not narrow root poa: %s\n", CONST_ROOT_POA_NAME);
+ }
}
else {
- cerr << "Failed to create RootPOA." << endl;
+ log_error("Failed to create RootPOA, could not resolve initial reference to %s.\n", CONST_ROOT_POA_NAME);
}
return ret_val;
}
ret_val = NULL;
try {
// get nameservice reference
- ns_obj = _orb->resolve_initial_references(CONST_NAME_SERVICE_NAME);
- // get nameservice context
- ns_context = CosNaming::NamingContext::_narrow(ns_obj);
- 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;
- try {
- service_obj = ns_context->resolve(context_data);
- if (CORBA::is_nil(service_obj)) {
- // not found, try to bind the new context to name service
- ret_val = ns_context->bind_new_context(context_data);
- if (CORBA::is_nil(ret_val) ) {
- cerr << "Failed to create new context to name service for " << service_name_param << "." << endl;
- }
+ log_debug("get_service_naming_context() 1\n");
+ ns_obj = _orb->resolve_initial_references(CONST_NAME_SERVICE_NAME);
+ if (CORBA::is_nil(ns_obj) == false) {
+ 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);
}
- 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;
+ 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);
+ }
+ }
+ else {
+ ret_val = CosNaming::NamingContext::_narrow(service_obj);
+ if (CORBA::is_nil(ret_val) ) {
+ 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;
+ 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);
+ }
}
}
}
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;
}
* 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;
}
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;
}
}
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");
}
}