src/plpbus/BusClient.cc

   1 /*
   2  * BusClient.cc
   3  *
   4  *  Created on: Jun 7, 2010
   5  *      Author: lamikr
   6  */
   7
   8 #include "BusClient.hh"
   9 #include "BusMessageInternal.hh"
  10
  11 using namespace std;
  12 using namespace plpbus;
  13
  14 class OrbClientImpl : public virtual POA_plpbus_orb::OrbClient
  15 {
  16         private:
  17                 IClientListener *listener;
  18         public:
  19                 OrbClientImpl(IClientListener *listener_param)  {
  20                         listener        = listener_param;
  21                 }
  22                 virtual ~OrbClientImpl() {}
  23
  24                 virtual void receive_event_message(const char *event_param) {
  25                         if (listener != NULL) {
  26                                 listener->event_received(event_param);
  27                         }
  28                 }
  29
  30                 virtual void receive_event_dataitem_sequence(const ::plpbus_orb::DataItemSequence& event_param) {
  31                         BusMessageInternal      *bus_msg;
  32
  33                         if (listener != NULL) {
  34                                 bus_msg = new BusMessageInternal(event_param);
  35                                 listener->event_received(bus_msg);
  36                         }
  37                 }
  38
  39                 virtual void receive_response_message(const char *msg_rsp_param) {
  40                         if (listener != NULL) {
  41                                 listener->response_received(msg_rsp_param);
  42                         }
  43                 }
  44
  45                 virtual void receive_response_dataitem_sequence(const ::plpbus_orb::DataItemSequence& msg_rsp_param) {
  46                         BusMessageInternal      *bus_msg;
  47
  48                         if (listener != NULL) {
  49                                 bus_msg = new BusMessageInternal(msg_rsp_param);
  50                                 listener->response_received(bus_msg);
  51                         }
  52                 }
  53 };
  54
  55 BusClient::BusClient()
  56 {
  57         cout << "created" << endl;
  58         _orb            = NULL;
  59         _poa            = NULL;
  60 }
  61
  62 BusClient::~BusClient()
  63 {
  64         if (_orb != NULL) {
  65                 _orb->destroy();
  66                 _orb    = NULL;
  67         }
  68         cout << "destroyed" << endl;
  69 }
  70
  71 int BusClient::init(const char *server_name) {
  72         int                     argc;
  73         char                    **argv;
  74         CORBA::Object_var       server_obj;
  75
  76         argc    = 0;
  77         argv    = NULL;
  78         cout << "init() started"  << endl;
  79         _orb    = CORBA::ORB_init(argc, argv);
  80         if (_orb != NULL) {
  81                 cout << "ORB_init() done, finding server: " << server_name << endl;
  82                 server_obj      = find_server_object_by_name(_orb,
  83                                                         CONST_CONTEXT_NAME__PLPBUS,
  84                                                         CONST_CONTEXT_KIND__PLPBUS,
  85                                                         server_name,
  86                                                         CONST_CONTEXT_NAME__PLPBUS);
  87                 if (CORBA::is_nil(server_obj) == false) {
  88                         _server         = plpbus_orb::OrbServer::_narrow(server_obj);
  89                         cout << "Server object found: " << server_name << endl;
  90                 }
  91                 else {
  92                         cerr << "Could not find server object: " << server_name << endl;
  93                 }
  94         }
  95         return 0;
  96 }
  97
  98 int BusClient::add_client_listener(IClientListener *listener_param) {
  99         cout << "add_client_listener() started"  << endl;
 100         if (_poa == NULL) {
 101                 OrbClientImpl                   *client_cb;
 102                 PortableServer::ObjectId_var    oid;
 103
 104                 cout << "register_callback() 1"  << endl;
 105                 _poa            = create_poa(_orb);
 106                 client_cb       = new OrbClientImpl(listener_param);
 107                 oid             = _poa->activate_object(client_cb);
 108                 _client         = client_cb->_this();
 109                 client_cb->_remove_ref();
 110                 _server->add_event_listener(_client, "event_message", CONST_DEFAULT_EVENT_INTERVAL);
 111         }
 112         cout << "add_client_listener() done"  << endl;
 113         return 0;
 114 }
 115
 116 int BusClient::send_message_and_request_response(const char *msg_req_param) {
 117         _server->send_message_and_request_response(_client, msg_req_param);
 118         return 0;
 119 }
 120
 121 int BusClient::send_message_and_wait_response(const char *msg_req_param, char **msg_rsp_param) {
 122         CORBA::Long     ret_val;
 123
 124         *msg_rsp_param  = _server->send_message_and_wait_response(msg_req_param, ret_val);
 125         return ret_val;
 126 }
 127
 128 int BusClient::send_message_and_request_response(BusMessage *msg_req_param) {
 129         _server->send_dataitem_message_and_request_response(_client, msg_req_param->_dataItemSeq);
 130         return 0;
 131 }
 132
 133 int BusClient::send_message_and_wait_response(BusMessage *msg_req_param, BusMessage **msg_rsp_param) {
 134         plpbus_orb::DataItemSequence    *seq_rsp;
 135
 136         seq_rsp = NULL;
 137         _server->send_dataitem_message_and_wait_response(msg_req_param->_dataItemSeq, seq_rsp);
 138 }
 139
 140 void BusClient::request_shutdown() {
 141         if (CORBA::is_nil(_server) == false) {
 142                 _server->shutdown();
 143         }
 144 }
 145
 146 PortableServer::POA_var BusClient::create_poa(CORBA::ORB_var orb) {
 147         PortableServer::POA_var         ret_val;
 148         CORBA::Object_var               poa_obj;
 149         CORBA::PolicyList               policy_list;
 150         CORBA::Any                      policyVal;
 151         PortableServer::POAManager_var  poa_man;
 152         PortableServer::POA_var         rootpoa;
 153
 154         ret_val = NULL;
 155         poa_obj = orb->resolve_initial_references(CONST_ROOT_POA_NAME);
 156         if (poa_obj != NULL) {
 157                 rootpoa = PortableServer::POA::_narrow(poa_obj);
 158                 if (rootpoa != NULL) {
 159                         poa_man = rootpoa->the_POAManager();
 160                         if (poa_man != NULL) {
 161                                 poa_man->activate();
 162                                 // bidirectional policy
 163                                 policy_list.length(1);
 164                                 policyVal       <<= BiDirPolicy::BOTH;
 165                                 policy_list[0] = orb->create_policy(BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, policyVal);
 166                                 ret_val = rootpoa->create_POA(CONST_ROOT_POA_BIDIR_POLICY_NAME,
 167                                                         poa_man,
 168                                                         policy_list);
 169                         }
 170                 }
 171         }
 172         else {
 173                 cerr << "Failed to create RootPOA." << endl;
 174         }
 175         return ret_val;
 176 }
 177
 178 CosNaming::NamingContext_var BusClient::get_name_service_context(CORBA::ORB_var orb_param) {
 179         CORBA::Object_var               ns_obj;
 180         CosNaming::NamingContext_var    ret_val;
 181
 182         ret_val = NULL;
 183         try {
 184                 ns_obj  = orb_param->resolve_initial_references(CONST_NAME_SERVICE_NAME);
 185                 if (CORBA::is_nil(ns_obj) == false) {
 186                         // narrow the object reference
 187                         ret_val = CosNaming::NamingContext::_narrow(ns_obj);
 188                 }
 189         }
 190         catch (CORBA::ORB::InvalidName&) {
 191                 // This should not happen!
 192                 cerr << "Could not find name service." << endl;
 193         }
 194         catch(CORBA::TRANSIENT& ex) {
 195                 cerr << "Could not find name service, verify that name service is running. " << endl;
 196         }
 197         catch (CORBA::NO_RESOURCES&) {
 198                 cerr << "Could not find name service, verify that name service is running. " << endl;
 199         }
 200         catch(CORBA::SystemException& ex) {
 201                 cerr << "Could not find name service, unknown reason. " << endl;
 202         }
 203         return ret_val;
 204 }
 205
 206 CORBA::Object_var BusClient::find_server_object_by_name(CORBA::ORB_var orb_param,
 207                                                         const char *leaf_name_param,
 208                                                         const char *leaf_kind_param,
 209                                                         const char *service_name_param,
 210                                                         const char *service_kind_param)
 211 {
 212         CORBA::Object_var               ret_val;
 213         CosNaming::NamingContext_var    ns_root_context;
 214         CosNaming::Name                 service_data;
 215
 216         ret_val         = CORBA::Object::_nil();
 217         ns_root_context = get_name_service_context(orb_param);
 218         if (CORBA::is_nil(ns_root_context) == false) {
 219                 // define search criteria
 220                 service_data.length(2);
 221                 service_data[0].id   = leaf_name_param;
 222                 service_data[0].kind = leaf_kind_param;
 223                 service_data[1].id   = service_name_param;
 224                 service_data[1].kind = service_kind_param;
 225                 try {
 226                         ret_val = ns_root_context->resolve(service_data);
 227                 }
 228                 catch(CosNaming::NamingContext::NotFound& ex) {
 229                         cerr << "Could not find service from the name server. " << endl;
 230                 }
 231                 catch(CORBA::TRANSIENT& ex) {
 232                         cerr << "Could not find service from the name server. " << endl;
 233                 }
 234                 catch(CORBA::SystemException& ex) {
 235                         cerr << "Could not find service from the name server, unknown error." << endl;
 236                 }
 237         }
 238         else {
 239                 cerr << "Could not find naming service. " << endl;
 240         }
 241         return ret_val;
 242 }