Release push 1.0.2
[ric-app/hw.git] / src / xapp.cc
1 /*
2 ==================================================================================
3
4         Copyright (c) 2019-2020 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  * xapp.cc
21  *
22  *  Mar, 2020 (Shraboni Jana)
23  */
24
25 #include "xapp.hpp"
26 #define BUFFER_SIZE 1024
27
28  Xapp::Xapp(XappSettings &config, XappRmr &rmr){
29
30           rmr_ref = &rmr;
31           config_ref = &config;
32           xapp_mutex = NULL;
33           subhandler_ref = NULL;
34           return;
35   }
36
37 Xapp::~Xapp(void){
38
39         //Joining the threads
40         int threadcnt = xapp_rcv_thread.size();
41                 for(int i=0; i<threadcnt; i++){
42                         if(xapp_rcv_thread[i].joinable())
43                                 xapp_rcv_thread[i].join();
44         }
45         xapp_rcv_thread.clear();
46
47         if(xapp_mutex!=NULL){
48                 xapp_mutex->~mutex();
49                 delete xapp_mutex;
50         }
51 };
52
53 //Stop the xapp. Note- To be run only from unit test scripts.
54 void Xapp::stop(void){
55   // Get the mutex lock
56         std::lock_guard<std::mutex> guard(*xapp_mutex);
57         rmr_ref->set_listen(false);
58         rmr_ref->~XappRmr();
59
60         //Detaching the threads....not sure if this is the right way to stop the receiver threads.
61         //Hence function should be called only in Unit Tests
62         int threadcnt = xapp_rcv_thread.size();
63         for(int i=0; i<threadcnt; i++){
64                 xapp_rcv_thread[i].detach();
65         }
66         sleep(10);
67 }
68
69 void Xapp::startup(SubscriptionHandler &sub_ref) {
70
71         subhandler_ref = &sub_ref;
72         set_rnib_gnblist();
73
74         //send subscriptions.
75         startup_subscribe_requests();
76
77         //read A1 policies
78         startup_get_policies();
79         return;
80 }
81 void Xapp::Run(){
82         rmr_ref->set_listen(true);
83         if(xapp_mutex == NULL){
84                 xapp_mutex = new std::mutex();
85         }
86         std::lock_guard<std::mutex> guard(*xapp_mutex);
87
88         for(int j=0; j < _callbacks.size(); j++){
89                 std::thread th_recv([&](){ rmr_ref->xapp_rmr_receive(std::move(_callbacks[j]), rmr_ref);});
90                 xapp_rcv_thread.push_back(std::move(th_recv));
91         }
92
93         return;
94 }
95 //Starting a seperate single receiver
96 void Xapp::start_xapp_receiver(XappMsgHandler& mp_handler){
97         //start a receiver thread. Can be multiple receiver threads for more than 1 listening port.
98         rmr_ref->set_listen(true);
99         if(xapp_mutex == NULL){
100                 xapp_mutex = new std::mutex();
101         }
102
103         mdclog_write(MDCLOG_INFO,"Receiver Thread file= %s, line=%d",__FILE__,__LINE__);
104         std::lock_guard<std::mutex> guard(*xapp_mutex);
105         std::thread th_recv([&](){ rmr_ref->xapp_rmr_receive(std::move(mp_handler), rmr_ref);});
106         xapp_rcv_thread.push_back(std::move(th_recv));
107         return;
108
109
110
111 }
112 void Xapp::shutdown(){
113
114         return;
115
116 }
117
118
119 void Xapp::startup_subscribe_requests(void ){
120
121    bool res;
122    size_t data_size = ASN_BUFF_MAX_SIZE;
123    unsigned char        data[data_size];
124    unsigned char meid[RMR_MAX_MEID];
125    std::string xapp_id = config_ref->operator [](XappSettings::SettingName::XAPP_ID);
126
127    mdclog_write(MDCLOG_INFO,"Preparing to send subscription in file= %s, line=%d",__FILE__,__LINE__);
128
129    auto gnblist = get_rnib_gnblist();
130
131    int sz = gnblist.size();
132
133    if(sz <= 0)
134            mdclog_write(MDCLOG_INFO,"Subscriptions cannot be sent as GNBList in RNIB is NULL");
135
136    for(int i = 0; i<sz; i++){
137
138          //give the message to subscription handler, along with the transmitter.
139          strcpy((char*)meid,gnblist[i].c_str());
140
141         // char *strMsg = "Subscription Request from HelloWorld XApp\0";
142         // strncpy((char *)data,strMsg,strlen(strMsg));
143         // data_size = strlen(strMsg);
144
145          subscription_helper  din;
146          subscription_helper  dout;
147
148          subscription_request sub_req;
149          subscription_request sub_recv;
150
151          unsigned char buf[BUFFER_SIZE];
152          size_t buf_size = BUFFER_SIZE;
153          bool res;
154
155
156          //Random Data  for request
157          int request_id = 1;
158          int function_id = 0;
159          std::string event_def = "HelloWorld Event Definition";
160
161          din.set_request(request_id);
162          din.set_function_id(function_id);
163          din.set_event_def(event_def.c_str(), event_def.length());
164
165          std::string act_def = "HelloWorld Action Definition";
166
167          din.add_action(1,1,(void*)act_def.c_str(), act_def.length(), 0);
168
169          res = sub_req.encode_e2ap_subscription(&buf[0], &buf_size, din);
170
171          xapp_rmr_header rmr_header;
172          rmr_header.message_type = RIC_SUB_REQ;
173          rmr_header.payload_length = buf_size; //data_size
174          strcpy((char*)rmr_header.meid,gnblist[i].c_str());
175
176          mdclog_write(MDCLOG_INFO,"Sending subscription in file= %s, line=%d for MEID %s",__FILE__,__LINE__, meid);
177      auto transmitter = std::bind(&XappRmr::xapp_rmr_send,rmr_ref, &rmr_header, (void*)buf );//(void*)data);
178
179      int result = subhandler_ref->manage_subscription_request(meid, transmitter);
180      if(result){
181          mdclog_write(MDCLOG_INFO,"Subscription SUCCESSFUL in file= %s, line=%d for MEID %s",__FILE__,__LINE__, meid);
182
183      }
184    }
185
186 }
187
188 void Xapp::startup_get_policies(void){
189
190   int policy_id = HELLOWORLD_POLICY_ID;
191
192   std::string policy_query = "{\"policy_id\":" + std::to_string(policy_id) + "}";
193   unsigned char * message = (unsigned char *)calloc(policy_query.length(), sizeof(unsigned char));
194   memcpy(message, policy_query.c_str(),  policy_query.length());
195   xapp_rmr_header header;
196   header.payload_length = policy_query.length();
197   header.message_type = A1_POLICY_QUERY;
198   mdclog_write(MDCLOG_INFO, "Sending request for policy id %d\n", policy_id);
199   rmr_ref->xapp_rmr_send(&header, (void *)message);
200   free(message);
201
202 }
203
204 void Xapp::set_rnib_gnblist(void) {
205
206            openSdl();
207
208            void *result = getListGnbIds();
209            if(strlen((char*)result) < 1){
210                     mdclog_write(MDCLOG_ERR, "ERROR: no data from getListGnbIds\n");
211                 return;
212             }
213
214             mdclog_write(MDCLOG_INFO, "GNB List in R-NIB %s\n", (char*)result);
215
216
217             Document doc;
218             ParseResult parseJson = doc.Parse((char*)result);
219             if (!parseJson) {
220                 std::cerr << "JSON parse error: %s (%u)", GetParseErrorFunc(parseJson.Code());
221                 return;
222             }
223
224             if(!doc.HasMember("gnb_list")){
225                 mdclog_write(MDCLOG_INFO, "JSON Has No GNB List Object");
226                 return;
227             }
228             assert(doc.HasMember("gnb_list"));
229
230             const Value& gnblist = doc["gnb_list"];
231             if (gnblist.IsNull())
232               return;
233
234             if(!gnblist.IsArray()){
235                 mdclog_write(MDCLOG_INFO, "GNB List is not an array");
236                 return;
237             }
238
239
240                 assert(gnblist.IsArray());
241             for (SizeType i = 0; i < gnblist.Size(); i++) // Uses SizeType instead of size_t
242             {
243                 assert(gnblist[i].IsObject());
244                 const Value& gnbobj = gnblist[i];
245                 assert(gnbobj.HasMember("inventory_name"));
246                 assert(gnbobj["inventory_name"].IsString());
247                 std::string name = gnbobj["inventory_name"].GetString();
248                 rnib_gnblist.push_back(name);
249
250             }
251             closeSdl();
252             return;
253
254 }
255
256
257
258
259
260