src/xapp-utils/xapp_rmr.hpp

   1 /*
   2 ==================================================================================
   3
   4         Copyright (c) 2018-2019 AT&T Intellectual Property.
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 ==================================================================================
  18 */
  19
  20 #ifndef XAPP_RMR_XAPP_RMR_H_
  21 #define XAPP_RMR_XAPP_RMR_H_
  22
  23
  24 #ifdef __GNUC__
  25 #define likely(x)  __builtin_expect((x), 1)
  26 #define unlikely(x) __builtin_expect((x), 0)
  27 #else
  28 #define likely(x) (x)
  29 #define unlikely(x) (x)
  30 #endif
  31
  32 #include <iostream>
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35 #include <string.h>
  36 #include <error.h>
  37 #include <assert.h>
  38 #include <sstream>
  39 #include <thread>
  40 #include <functional>
  41 #include <map>
  42 #include <mutex>
  43 #include <sys/epoll.h>
  44 #include <rmr/rmr.h>
  45 #include <rmr/RIC_message_types.h>
  46 #include <mdclog/mdclog.h>
  47 #include <vector>
  48
  49 typedef struct{
  50         struct timespec ts;
  51         int32_t message_type;
  52         int32_t state;
  53         int32_t payload_length;
  54         unsigned char xid[RMR_MAX_XID]; //space for user transaction id.
  55         unsigned char sid[RMR_MAX_SID]; //sender ID for return to sender needs.(ACKS required)
  56         unsigned char src[RMR_MAX_SRC]; //name of the sender (source)
  57 }  xapp_rmr_header;
  58
  59
  60 class XappRmr{
  61 private:
  62         std::string _proto_port;
  63         int _nattempts;
  64         bool _rmr_is_ready;
  65     bool _listen;
  66         void* _xapp_rmr_ctx;
  67         rmr_mbuf_t*             _xapp_send_buff;                                        // send buffer
  68         rmr_mbuf_t*             _xapp_received_buff;                                    // received buffer
  69
  70
  71 public:
  72
  73         XappRmr(std::string, int rmrattempts=10);
  74         ~XappRmr(void);
  75         void xapp_rmr_init(void);
  76
  77         template <class MessageProcessor>
  78         void xapp_rmr_receive(MessageProcessor&&, XappRmr *parent);
  79         bool xapp_rmr_send(xapp_rmr_header*, void*);
  80
  81         void set_listen(bool);
  82         bool get_listen(void);
  83         int get_is_ready(void);
  84         bool get_isRunning(void);
  85         void* get_rmr_context(void);
  86
  87 };
  88
  89 // main workhorse thread which does the listen->process->respond loop
  90 template <class MsgHandler>
  91 void XappRmr::xapp_rmr_receive(MsgHandler&& msgproc, XappRmr *parent){
  92
  93         bool* resend = new bool(false);
  94         // Get the thread id
  95         std::thread::id my_id = std::this_thread::get_id();
  96         std::stringstream thread_id;
  97         std::stringstream ss;
  98
  99         thread_id << my_id;
 100
 101         // Get the rmr context from parent (all threads and parent use same rmr context. rmr context is expected to be thread safe)
 102         if(!parent->get_is_ready()){
 103                         mdclog_write( MDCLOG_ERR, "RMR Shows Not Ready in RECEIVER, file= %s, line=%d ",__FILE__,__LINE__);
 104                         return;
 105         }
 106         void *rmr_context = parent->get_rmr_context();
 107         assert(rmr_context != NULL);
 108
 109         // Get buffer specific to this thread
 110         this->_xapp_received_buff = NULL;
 111         this->_xapp_received_buff = rmr_alloc_msg(rmr_context, RMR_DEF_SIZE);
 112         assert(this->_xapp_received_buff != NULL);
 113
 114         mdclog_write(MDCLOG_INFO, "Starting receiver thread %s",  thread_id.str().c_str());
 115
 116         while(parent->get_listen()) {
 117                 mdclog_write(MDCLOG_INFO, "Listening at Thread: %s",  thread_id.str().c_str());
 118
 119                 this->_xapp_received_buff = rmr_rcv_msg( rmr_context, this->_xapp_received_buff );
 120
 121
 122                 if( this->_xapp_received_buff->mtype < 0 || this->_xapp_received_buff->state != RMR_OK ) {
 123                         mdclog_write(MDCLOG_ERR, "bad msg:  state=%d  errno=%d, file= %s, line=%d", this->_xapp_received_buff->state, errno, __FILE__,__LINE__ );
 124                         return;
 125                 }
 126                 else
 127                 {
 128                         mdclog_write(MDCLOG_INFO,"RMR Received Message of Type: %d",this->_xapp_received_buff->mtype);
 129                         mdclog_write(MDCLOG_INFO,"RMR Received Message: %s",(char*)this->_xapp_received_buff->payload);
 130
 131                         //in case message handler returns true, need to resend the message.
 132                         msgproc(this->_xapp_received_buff, resend);
 133                         if(*resend){
 134                                 //mdclog_write(MDCLOG_INFO,"RMR Return to Sender Message of Type: %d",this->_xapp_received_buff->mtype);
 135                                 //mdclog_write(MDCLOG_INFO,"RMR Return to Sender Message: %s",(char*)this->_xapp_received_buff->payload);
 136                                 rmr_rts_msg(rmr_context, this->_xapp_received_buff );
 137                                 sleep(1);
 138                                 *resend = false;
 139                         }
 140                         continue;
 141
 142                 }
 143
 144         }
 145         // Clean up
 146         try{
 147                 delete resend;
 148                 rmr_free_msg(this->_xapp_received_buff);
 149         }
 150         catch(std::runtime_error &e){
 151                 std::string identifier = __FILE__ +  std::string(", Line: ") + std::to_string(__LINE__) ;
 152                 std::string error_string = identifier = " Error freeing RMR message ";
 153                 mdclog_write(MDCLOG_ERR, error_string.c_str(), "");
 154         }
 155
 156         return;
 157 }
 158
 159
 160
 161
 162 #endif /* XAPP_RMR_XAPP_RMR_H_ */