331d14d16c589afd6d9cc1d5c40a86a9a226b114
[ric-plt/submgr.git] / pkg / control / ut_stub_xapp_test.go
1 /*
2 ==================================================================================
3   Copyright (c) 2019 AT&T Intellectual Property.
4   Copyright (c) 2019 Nokia
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 package control
21
22 import (
23         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
24         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
25         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/packer"
26         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
27         "strconv"
28         "strings"
29         "testing"
30         "time"
31 )
32
33 //-----------------------------------------------------------------------------
34 //
35 //-----------------------------------------------------------------------------
36 var xapp_e2asnpacker e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
37
38 //-----------------------------------------------------------------------------
39 //
40 //-----------------------------------------------------------------------------
41 type xappTransaction struct {
42         tc   *testingXappStub
43         xid  string
44         meid *xapp.RMRMeid
45 }
46
47 type testingXappStub struct {
48         testingRmrStubControl
49         xid_seq uint64
50 }
51
52 //-----------------------------------------------------------------------------
53 //
54 //-----------------------------------------------------------------------------
55 func createNewXappStub(desc string, rtfile string, port string, stat string) *testingXappStub {
56         xappCtrl := &testingXappStub{}
57         xappCtrl.testingRmrStubControl.init(desc, rtfile, port, stat, xappCtrl)
58         xappCtrl.xid_seq = 1
59         return xappCtrl
60 }
61
62 //-----------------------------------------------------------------------------
63 //
64 //-----------------------------------------------------------------------------
65 func (tc *testingXappStub) newXid() string {
66         var xid string
67         xid = tc.desc + "_XID_" + strconv.FormatUint(uint64(tc.xid_seq), 10)
68         tc.xid_seq++
69         return xid
70 }
71
72 //-----------------------------------------------------------------------------
73 //
74 //-----------------------------------------------------------------------------
75 func (tc *testingXappStub) newXappTransaction(xid *string, ranname string) *xappTransaction {
76         trans := &xappTransaction{}
77         trans.tc = tc
78         if xid == nil {
79                 trans.xid = tc.newXid()
80         } else {
81                 trans.xid = *xid
82         }
83         trans.meid = &xapp.RMRMeid{RanName: ranname}
84         return trans
85 }
86
87 //-----------------------------------------------------------------------------
88 //
89 //-----------------------------------------------------------------------------
90 func (tc *testingXappStub) Consume(params *xapp.RMRParams) (err error) {
91         xapp.Rmr.Free(params.Mbuf)
92         params.Mbuf = nil
93         msg := &RMRParams{params}
94
95         if params.Mtype == 55555 {
96                 xapp.Logger.Info("(%s) Testing message ignore %s", tc.desc, msg.String())
97                 tc.active = true
98                 return
99         }
100
101         if strings.Contains(msg.Xid, tc.desc) {
102                 xapp.Logger.Info("(%s) Consume %s", tc.desc, msg.String())
103                 tc.IncMsgCnt()
104                 tc.rmrConChan <- msg
105         } else {
106                 xapp.Logger.Info("(%s) Ignore %s", tc.desc, msg.String())
107         }
108         return
109 }
110
111 //-----------------------------------------------------------------------------
112 //
113 //-----------------------------------------------------------------------------
114 type test_subs_req_params struct {
115         req *e2ap.E2APSubscriptionRequest
116 }
117
118 func (p *test_subs_req_params) Init() {
119         p.req = &e2ap.E2APSubscriptionRequest{}
120
121         p.req.RequestId.Id = 1
122         p.req.RequestId.Seq = 0
123         p.req.FunctionId = 1
124
125         p.req.EventTriggerDefinition.InterfaceId.GlobalEnbId.Present = true
126         p.req.EventTriggerDefinition.InterfaceId.GlobalEnbId.PlmnIdentity.StringPut("310150")
127         p.req.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Id = 123
128         p.req.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Bits = e2ap.E2AP_ENBIDHomeBits28
129
130         // gnb -> enb outgoing
131         // enb -> gnb incoming
132         // X2 36423-f40.doc
133         p.req.EventTriggerDefinition.InterfaceDirection = e2ap.E2AP_InterfaceDirectionIncoming
134         p.req.EventTriggerDefinition.ProcedureCode = 5 //28 35
135         p.req.EventTriggerDefinition.TypeOfMessage = e2ap.E2AP_InitiatingMessage
136
137         p.req.ActionSetups = make([]e2ap.ActionToBeSetupItem, 1)
138         p.req.ActionSetups[0].ActionId = 0
139         p.req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeReport
140         p.req.ActionSetups[0].ActionDefinition.Present = false
141         //p.req.ActionSetups[index].ActionDefinition.StyleId = 255
142         //p.req.ActionSetups[index].ActionDefinition.ParamId = 222
143         p.req.ActionSetups[0].SubsequentAction.Present = true
144         p.req.ActionSetups[0].SubsequentAction.Type = e2ap.E2AP_SubSeqActionTypeContinue
145         p.req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitZero
146
147 }
148
149 func (xappConn *testingXappStub) handle_xapp_subs_req(t *testing.T, rparams *test_subs_req_params, oldTrans *xappTransaction) *xappTransaction {
150         xapp.Logger.Info("(%s) handle_xapp_subs_req", xappConn.desc)
151         e2SubsReq := xapp_e2asnpacker.NewPackerSubscriptionRequest()
152
153         //---------------------------------
154         // xapp activity: Send Subs Req
155         //---------------------------------
156         xapp.Logger.Info("(%s) Send Subs Req", xappConn.desc)
157
158         myparams := rparams
159
160         if myparams == nil {
161                 myparams = &test_subs_req_params{}
162                 myparams.Init()
163         }
164
165         e2SubsReq.Set(myparams.req)
166         xapp.Logger.Debug("%s", e2SubsReq.String())
167         err, packedMsg := e2SubsReq.Pack(nil)
168         if err != nil {
169                 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
170                 return nil
171         }
172
173         var trans *xappTransaction = oldTrans
174         if trans == nil {
175                 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
176         }
177
178         params := &RMRParams{&xapp.RMRParams{}}
179         params.Mtype = xapp.RIC_SUB_REQ
180         params.SubId = -1
181         params.Payload = packedMsg.Buf
182         params.Meid = trans.meid
183         params.Xid = trans.xid
184         params.Mbuf = nil
185
186         snderr := xappConn.RmrSend(params)
187         if snderr != nil {
188                 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
189                 return nil
190         }
191         return trans
192 }
193
194 //-----------------------------------------------------------------------------
195 //
196 //-----------------------------------------------------------------------------
197 func (xappConn *testingXappStub) handle_xapp_subs_resp(t *testing.T, trans *xappTransaction) int {
198         xapp.Logger.Info("(%s) handle_xapp_subs_resp", xappConn.desc)
199         e2SubsResp := xapp_e2asnpacker.NewPackerSubscriptionResponse()
200         var e2SubsId int
201
202         //---------------------------------
203         // xapp activity: Recv Subs Resp
204         //---------------------------------
205         select {
206         case msg := <-xappConn.rmrConChan:
207                 xappConn.DecMsgCnt()
208                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] {
209                         testError(t, "(%s) Received RIC_SUB_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_RESP", xapp.RicMessageTypeToName[msg.Mtype])
210                         return -1
211                 } else if msg.Xid != trans.xid {
212                         testError(t, "(%s) Received RIC_SUB_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
213                         return -1
214                 } else {
215                         packedData := &packer.PackedData{}
216                         packedData.Buf = msg.Payload
217                         e2SubsId = msg.SubId
218                         unpackerr := e2SubsResp.UnPack(packedData)
219
220                         if unpackerr != nil {
221                                 testError(t, "(%s) RIC_SUB_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
222                         }
223                         geterr, resp := e2SubsResp.Get()
224                         if geterr != nil {
225                                 testError(t, "(%s) RIC_SUB_RESP get failed err: %s", xappConn.desc, geterr.Error())
226                         }
227
228                         xapp.Logger.Info("(%s) Recv Subs Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
229                         return e2SubsId
230                 }
231         case <-time.After(15 * time.Second):
232                 testError(t, "(%s) Not Received RIC_SUB_RESP within 15 secs", xappConn.desc)
233                 return -1
234         }
235         return -1
236 }
237
238 //-----------------------------------------------------------------------------
239 //
240 //-----------------------------------------------------------------------------
241 func (xappConn *testingXappStub) handle_xapp_subs_fail(t *testing.T, trans *xappTransaction) int {
242         xapp.Logger.Info("(%s) handle_xapp_subs_fail", xappConn.desc)
243         e2SubsFail := xapp_e2asnpacker.NewPackerSubscriptionFailure()
244         var e2SubsId int
245
246         //-------------------------------
247         // xapp activity: Recv Subs Fail
248         //-------------------------------
249         select {
250         case msg := <-xappConn.rmrConChan:
251                 xappConn.DecMsgCnt()
252                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_FAILURE"] {
253                         testError(t, "(%s) Received RIC_SUB_FAILURE wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_FAILURE", xapp.RicMessageTypeToName[msg.Mtype])
254                         return -1
255                 } else if msg.Xid != trans.xid {
256                         testError(t, "(%s) Received RIC_SUB_FAILURE wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
257                         return -1
258                 } else {
259                         packedData := &packer.PackedData{}
260                         packedData.Buf = msg.Payload
261                         e2SubsId = msg.SubId
262                         unpackerr := e2SubsFail.UnPack(packedData)
263
264                         if unpackerr != nil {
265                                 testError(t, "(%s) RIC_SUB_FAILURE unpack failed err: %s", xappConn.desc, unpackerr.Error())
266                         }
267                         geterr, resp := e2SubsFail.Get()
268                         if geterr != nil {
269                                 testError(t, "(%s) RIC_SUB_FAILURE get failed err: %s", xappConn.desc, geterr.Error())
270                         }
271
272                         xapp.Logger.Info("(%s) Recv Subs Fail rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
273                         return e2SubsId
274                 }
275         case <-time.After(15 * time.Second):
276                 testError(t, "(%s) Not Received RIC_SUB_FAILURE within 15 secs", xappConn.desc)
277                 return -1
278         }
279         return -1
280 }
281
282 //-----------------------------------------------------------------------------
283 //
284 //-----------------------------------------------------------------------------
285 func (xappConn *testingXappStub) handle_xapp_subs_del_req(t *testing.T, oldTrans *xappTransaction, e2SubsId int) *xappTransaction {
286         xapp.Logger.Info("(%s) handle_xapp_subs_del_req", xappConn.desc)
287         e2SubsDelReq := xapp_e2asnpacker.NewPackerSubscriptionDeleteRequest()
288
289         //---------------------------------
290         // xapp activity: Send Subs Del Req
291         //---------------------------------
292         xapp.Logger.Info("(%s) Send Subs Del Req", xappConn.desc)
293
294         req := &e2ap.E2APSubscriptionDeleteRequest{}
295         req.RequestId.Id = 1
296         req.RequestId.Seq = uint32(e2SubsId)
297         req.FunctionId = 1
298
299         e2SubsDelReq.Set(req)
300         xapp.Logger.Debug("%s", e2SubsDelReq.String())
301         err, packedMsg := e2SubsDelReq.Pack(nil)
302         if err != nil {
303                 testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error())
304                 return nil
305         }
306
307         var trans *xappTransaction = oldTrans
308         if trans == nil {
309                 trans = xappConn.newXappTransaction(nil, "RAN_NAME_1")
310         }
311
312         params := &RMRParams{&xapp.RMRParams{}}
313         params.Mtype = xapp.RIC_SUB_DEL_REQ
314         params.SubId = e2SubsId
315         params.Payload = packedMsg.Buf
316         params.Meid = trans.meid
317         params.Xid = trans.xid
318         params.Mbuf = nil
319
320         snderr := xappConn.RmrSend(params)
321         if snderr != nil {
322                 testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error())
323                 return nil
324         }
325         return trans
326 }
327
328 //-----------------------------------------------------------------------------
329 //
330 //-----------------------------------------------------------------------------
331 func (xappConn *testingXappStub) handle_xapp_subs_del_resp(t *testing.T, trans *xappTransaction) {
332         xapp.Logger.Info("(%s) handle_xapp_subs_del_resp", xappConn.desc)
333         e2SubsDelResp := xapp_e2asnpacker.NewPackerSubscriptionDeleteResponse()
334
335         //---------------------------------
336         // xapp activity: Recv Subs Del Resp
337         //---------------------------------
338         select {
339         case msg := <-xappConn.rmrConChan:
340                 xappConn.DecMsgCnt()
341                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] {
342                         testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_DEL_RESP", xapp.RicMessageTypeToName[msg.Mtype])
343                         return
344                 } else if trans != nil && msg.Xid != trans.xid {
345                         testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid)
346                         return
347                 } else {
348                         packedData := &packer.PackedData{}
349                         packedData.Buf = msg.Payload
350                         unpackerr := e2SubsDelResp.UnPack(packedData)
351                         if unpackerr != nil {
352                                 testError(t, "(%s) RIC_SUB_DEL_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error())
353                         }
354                         geterr, resp := e2SubsDelResp.Get()
355                         if geterr != nil {
356                                 testError(t, "(%s) RIC_SUB_DEL_RESP get failed err: %s", xappConn.desc, geterr.Error())
357                         }
358                         xapp.Logger.Info("(%s) Recv Subs Del Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq)
359                         return
360                 }
361         case <-time.After(15 * time.Second):
362                 testError(t, "(%s) Not Received RIC_SUB_DEL_RESP within 15 secs", xappConn.desc)
363         }
364 }