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 }