pkg/teststube2ap/stubE2.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 teststube2ap
  21
  22 import (
  23         "fmt"
  24         "strconv"
  25         "testing"
  26         "time"
  27
  28         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
  29         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
  30         "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststub"
  31         clientmodel "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/clientmodel"
  32         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  33 )
  34
  35 //-----------------------------------------------------------------------------
  36 //
  37 //-----------------------------------------------------------------------------
  38 var e2asnpacker e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
  39
  40 //-----------------------------------------------------------------------------
  41 //
  42 //-----------------------------------------------------------------------------
  43 type RmrTransactionId struct {
  44         xid  string
  45         meid *xapp.RMRMeid
  46 }
  47
  48 type E2RestIds struct {
  49         RestSubsId string
  50         E2SubsId   uint32
  51 }
  52
  53 func (trans *RmrTransactionId) String() string {
  54         meidstr := "N/A"
  55         if trans.meid != nil {
  56                 meidstr = trans.meid.String()
  57         }
  58         return "trans(" + trans.xid + "/" + meidstr + ")"
  59 }
  60
  61 type E2Stub struct {
  62         teststub.RmrStubControl
  63         xid_seq                     uint64
  64         subscriptionId              string
  65         requestCount                int
  66         CallBackNotification        chan int64
  67         RESTNotification            chan uint32
  68         CallBackListedNotifications chan E2RestIds
  69         ListedRESTNotifications     chan E2RestIds
  70         clientEndpoint              clientmodel.SubscriptionParamsClientEndpoint
  71         meid                        string
  72         restSubsIdList              []string
  73 }
  74
  75 //-----------------------------------------------------------------------------
  76 //
  77 //-----------------------------------------------------------------------------
  78 func CreateNewE2Stub(desc string, srcId teststub.RmrSrcId, rtgSvc teststub.RmrRtgSvc, stat string, mtypeseed int, ranName string, host string, RMRPort int64, HTTPPort int64) *E2Stub {
  79         tc := &E2Stub{}
  80         tc.RmrStubControl.Init(desc, srcId, rtgSvc, stat, mtypeseed)
  81         tc.xid_seq = 1
  82         tc.SetCheckXid(true)
  83         tc.CallBackNotification = make(chan int64)
  84         tc.RESTNotification = make(chan uint32)
  85         tc.CallBackListedNotifications = make(chan E2RestIds)
  86         tc.ListedRESTNotifications = make(chan E2RestIds, 2)
  87         var endPoint clientmodel.SubscriptionParamsClientEndpoint
  88         endPoint.Host = host
  89         endPoint.HTTPPort = &HTTPPort
  90         endPoint.RMRPort = &RMRPort
  91         tc.clientEndpoint = endPoint
  92         tc.meid = ranName
  93         return tc
  94 }
  95
  96 //-----------------------------------------------------------------------------
  97 //
  98 //-----------------------------------------------------------------------------
  99 func CreateNewE2termStub(desc string, srcId teststub.RmrSrcId, rtgSvc teststub.RmrRtgSvc, stat string, mtypeseed int) *E2Stub {
 100         tc := &E2Stub{}
 101         tc.RmrStubControl.Init(desc, srcId, rtgSvc, stat, mtypeseed)
 102         tc.xid_seq = 1
 103         tc.SetCheckXid(false)
 104         return tc
 105 }
 106
 107 //-----------------------------------------------------------------------------
 108 //
 109 //-----------------------------------------------------------------------------
 110 func (tc *E2Stub) NewRmrTransactionId(xid string, ranname string) *RmrTransactionId {
 111         trans := &RmrTransactionId{}
 112         if len(xid) == 0 {
 113                 trans.xid = tc.GetDesc() + "_XID_" + strconv.FormatUint(uint64(tc.xid_seq), 10)
 114                 tc.xid_seq++
 115         } else {
 116                 trans.xid = xid
 117         }
 118         trans.meid = &xapp.RMRMeid{RanName: ranname}
 119         tc.Info("New test %s", trans.String())
 120         return trans
 121 }
 122
 123 //-----------------------------------------------------------------------------
 124 //
 125 //-----------------------------------------------------------------------------
 126 type E2StubSubsReqParams struct {
 127         Req *e2ap.E2APSubscriptionRequest
 128 }
 129
 130 func (p *E2StubSubsReqParams) Init() {
 131         p.Req = &e2ap.E2APSubscriptionRequest{}
 132
 133         p.Req.RequestId.Id = 1
 134         p.Req.RequestId.InstanceId = 0
 135         p.Req.FunctionId = 1
 136
 137         // gnb -> enb outgoing
 138         // enb -> gnb incoming
 139         // X2 36423-f40.doc
 140         p.Req.EventTriggerDefinition.Data.Length = 1
 141         p.Req.EventTriggerDefinition.Data.Data = make([]uint8, p.Req.EventTriggerDefinition.Data.Length)
 142         p.Req.EventTriggerDefinition.Data.Data[0] = 1
 143
 144         p.Req.ActionSetups = make([]e2ap.ActionToBeSetupItem, 1)
 145
 146         p.Req.ActionSetups[0].ActionId = 0
 147         p.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeReport
 148         p.Req.ActionSetups[0].RicActionDefinitionPresent = true
 149
 150         p.Req.ActionSetups[0].ActionDefinitionChoice.Data.Length = 1
 151         p.Req.ActionSetups[0].ActionDefinitionChoice.Data.Data = make([]uint8, p.Req.ActionSetups[0].ActionDefinitionChoice.Data.Length)
 152         p.Req.ActionSetups[0].ActionDefinitionChoice.Data.Data[0] = 1
 153
 154         p.Req.ActionSetups[0].SubsequentAction.Present = true
 155         p.Req.ActionSetups[0].SubsequentAction.Type = e2ap.E2AP_SubSeqActionTypeContinue
 156         p.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitZero
 157 }
 158
 159 //-----------------------------------------------------------------------------
 160 //
 161 //-----------------------------------------------------------------------------
 162
 163 type E2StubSubsFailParams struct {
 164         Req  *e2ap.E2APSubscriptionRequest
 165         Fail *e2ap.E2APSubscriptionFailure
 166 }
 167
 168 func (p *E2StubSubsFailParams) Set(req *e2ap.E2APSubscriptionRequest) {
 169         p.Req = req
 170
 171         p.Fail = &e2ap.E2APSubscriptionFailure{}
 172         p.Fail.RequestId.Id = p.Req.RequestId.Id
 173         p.Fail.RequestId.InstanceId = p.Req.RequestId.InstanceId
 174         p.Fail.FunctionId = p.Req.FunctionId
 175         p.Fail.ActionNotAdmittedList.Items = make([]e2ap.ActionNotAdmittedItem, len(p.Req.ActionSetups))
 176         for index := int(0); index < len(p.Fail.ActionNotAdmittedList.Items); index++ {
 177                 p.Fail.ActionNotAdmittedList.Items[index].ActionId = p.Req.ActionSetups[index].ActionId
 178                 p.SetCauseVal(index, 5, 1)
 179         }
 180 }
 181
 182 func (p *E2StubSubsFailParams) SetCauseVal(ind int, content uint8, causeval uint8) {
 183
 184         if ind < 0 {
 185                 for index := int(0); index < len(p.Fail.ActionNotAdmittedList.Items); index++ {
 186                         p.Fail.ActionNotAdmittedList.Items[index].Cause.Content = content
 187                         p.Fail.ActionNotAdmittedList.Items[index].Cause.Value = causeval
 188                 }
 189                 return
 190         }
 191         p.Fail.ActionNotAdmittedList.Items[ind].Cause.Content = content
 192         p.Fail.ActionNotAdmittedList.Items[ind].Cause.Value = causeval
 193 }
 194
 195 //-----------------------------------------------------------------------------
 196 //
 197 //-----------------------------------------------------------------------------
 198
 199 func (tc *E2Stub) SendSubsReq(t *testing.T, rparams *E2StubSubsReqParams, oldTrans *RmrTransactionId) *RmrTransactionId {
 200
 201         trans := oldTrans
 202         if oldTrans == nil {
 203                 trans = tc.NewRmrTransactionId("", "RAN_NAME_1")
 204         }
 205
 206         tc.Info("SendSubsReq %s", trans.String())
 207         e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
 208
 209         //---------------------------------
 210         // xapp activity: Send Subs Req
 211         //---------------------------------
 212         myparams := rparams
 213
 214         if myparams == nil {
 215                 myparams = &E2StubSubsReqParams{}
 216                 myparams.Init()
 217         }
 218
 219         err, packedMsg := e2SubsReq.Pack(myparams.Req)
 220         if err != nil {
 221                 tc.TestError(t, "pack NOK %s %s", trans.String(), err.Error())
 222                 return nil
 223         }
 224         tc.Debug("%s %s", trans.String(), e2SubsReq.String())
 225
 226         params := &xapp.RMRParams{}
 227         params.Mtype = xapp.RIC_SUB_REQ
 228         params.SubId = -1
 229         params.Payload = packedMsg.Buf
 230         params.PayloadLen = len(packedMsg.Buf)
 231         params.Meid = trans.meid
 232         params.Xid = trans.xid
 233         params.Mbuf = nil
 234
 235         tc.Info("SEND SUB REQ: %s", params.String())
 236         snderr := tc.SendWithRetry(params, false, 5)
 237         if snderr != nil {
 238                 tc.TestError(t, "RMR SEND FAILED: %s %s", trans.String(), snderr.Error())
 239                 return nil
 240         }
 241         return trans
 242 }
 243
 244 //-----------------------------------------------------------------------------
 245 //
 246 //-----------------------------------------------------------------------------
 247 func (tc *E2Stub) RecvSubsReq(t *testing.T) (*e2ap.E2APSubscriptionRequest, *xapp.RMRParams) {
 248         tc.Info("RecvSubsReq")
 249         e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
 250
 251         //---------------------------------
 252         // e2term activity: Recv Subs Req
 253         //---------------------------------
 254         msg := tc.WaitMsg(15)
 255         if msg != nil {
 256                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] {
 257                         tc.TestError(t, "Received wrong mtype expected %s got %s, error", "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype])
 258                 } else {
 259                         tc.Info("Recv Subs Req")
 260                         packedData := &e2ap.PackedData{}
 261                         packedData.Buf = msg.Payload
 262                         unpackerr, req := e2SubsReq.UnPack(packedData)
 263                         if unpackerr != nil {
 264                                 tc.TestError(t, "RIC_SUB_REQ unpack failed err: %s", unpackerr.Error())
 265                         }
 266                         return req, msg
 267                 }
 268         } else {
 269                 tc.TestError(t, "Not Received msg within %d secs", 15)
 270         }
 271
 272         return nil, nil
 273 }
 274
 275 //-----------------------------------------------------------------------------
 276 //
 277 //-----------------------------------------------------------------------------
 278 func (tc *E2Stub) SendSubsResp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *xapp.RMRParams) {
 279         tc.Info("SendSubsResp")
 280         e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
 281
 282         //---------------------------------
 283         // e2term activity: Send Subs Resp
 284         //---------------------------------
 285         resp := &e2ap.E2APSubscriptionResponse{}
 286
 287         resp.RequestId.Id = req.RequestId.Id
 288         resp.RequestId.InstanceId = req.RequestId.InstanceId
 289         resp.FunctionId = req.FunctionId
 290
 291         resp.ActionAdmittedList.Items = make([]e2ap.ActionAdmittedItem, len(req.ActionSetups))
 292         for index := int(0); index < len(req.ActionSetups); index++ {
 293                 resp.ActionAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId
 294         }
 295
 296         for index := uint64(0); index < 1; index++ {
 297                 item := e2ap.ActionNotAdmittedItem{}
 298                 item.ActionId = index
 299                 item.Cause.Content = 1
 300                 item.Cause.Value = 1
 301                 resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item)
 302         }
 303
 304         packerr, packedMsg := e2SubsResp.Pack(resp)
 305         if packerr != nil {
 306                 tc.TestError(t, "pack NOK %s", packerr.Error())
 307         }
 308         tc.Debug("%s", e2SubsResp.String())
 309
 310         params := &xapp.RMRParams{}
 311         params.Mtype = xapp.RIC_SUB_RESP
 312         //params.SubId = msg.SubId
 313         params.SubId = -1
 314         params.Payload = packedMsg.Buf
 315         params.PayloadLen = len(packedMsg.Buf)
 316         params.Meid = msg.Meid
 317         //params.Xid = msg.Xid
 318         params.Mbuf = nil
 319
 320         tc.Info("SEND SUB RESP: %s", params.String())
 321         snderr := tc.SendWithRetry(params, false, 5)
 322         if snderr != nil {
 323                 tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
 324         }
 325 }
 326
 327 //-----------------------------------------------------------------------------
 328 //
 329 //-----------------------------------------------------------------------------
 330 func (tc *E2Stub) SendInvalidE2Asn1Resp(t *testing.T, msg *xapp.RMRParams, msgType int) {
 331
 332         params := &xapp.RMRParams{}
 333         params.Mtype = msgType
 334         params.SubId = -1
 335         params.Payload = []byte{1, 2, 3, 4, 5}
 336         params.PayloadLen = 5
 337         params.Meid = msg.Meid
 338         params.Xid = ""
 339         params.Mbuf = nil
 340
 341         if params.Mtype == xapp.RIC_SUB_RESP {
 342                 tc.Info("SEND INVALID ASN.1 SUB RESP")
 343
 344         } else if params.Mtype == xapp.RIC_SUB_FAILURE {
 345                 tc.Info("SEND INVALID ASN.1 SUB FAILURE")
 346
 347         } else if params.Mtype == xapp.RIC_SUB_DEL_RESP {
 348                 tc.Info("SEND INVALID ASN.1 SUB DEL RESP")
 349
 350         } else if params.Mtype == xapp.RIC_SUB_DEL_FAILURE {
 351                 tc.Info("SEND INVALID ASN.1 SUB DEL FAILURE")
 352         }
 353         snderr := tc.SendWithRetry(params, false, 5)
 354         if snderr != nil {
 355                 tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
 356         }
 357 }
 358
 359 //-----------------------------------------------------------------------------
 360 //
 361 //-----------------------------------------------------------------------------
 362 func (tc *E2Stub) RecvSubsResp(t *testing.T, trans *RmrTransactionId) uint32 {
 363         tc.Info("RecvSubsResp")
 364         e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
 365         var e2SubsId uint32
 366
 367         //---------------------------------
 368         // xapp activity: Recv Subs Resp
 369         //---------------------------------
 370         msg := tc.WaitMsg(15)
 371         if msg != nil {
 372                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] {
 373                         tc.TestError(t, "Received RIC_SUB_RESP wrong mtype expected %s got %s, error", "RIC_SUB_RESP", xapp.RicMessageTypeToName[msg.Mtype])
 374                         return 0
 375                 } else if msg.Xid != trans.xid {
 376                         tc.TestError(t, "Received RIC_SUB_RESP wrong xid expected %s got %s, error", trans.xid, msg.Xid)
 377                         return 0
 378                 } else {
 379                         packedData := &e2ap.PackedData{}
 380                         packedData.Buf = msg.Payload
 381                         if msg.SubId > 0 {
 382                                 e2SubsId = uint32(msg.SubId)
 383                         } else {
 384                                 e2SubsId = 0
 385                         }
 386                         unpackerr, resp := e2SubsResp.UnPack(packedData)
 387                         if unpackerr != nil {
 388                                 tc.TestError(t, "RIC_SUB_RESP unpack failed err: %s", unpackerr.Error())
 389                         }
 390                         tc.Info("Recv Subs Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
 391                         return e2SubsId
 392                 }
 393         } else {
 394                 tc.TestError(t, "Not Received msg within %d secs", 15)
 395         }
 396         return 0
 397 }
 398
 399 //-----------------------------------------------------------------------------
 400 //
 401 //-----------------------------------------------------------------------------
 402
 403 func (tc *E2Stub) SendSubsFail(t *testing.T, fparams *E2StubSubsFailParams, msg *xapp.RMRParams) {
 404         tc.Info("SendSubsFail")
 405         e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
 406
 407         //---------------------------------
 408         // e2term activity: Send Subs Fail
 409         //---------------------------------
 410         packerr, packedMsg := e2SubsFail.Pack(fparams.Fail)
 411         if packerr != nil {
 412                 tc.TestError(t, "pack NOK %s", packerr.Error())
 413         }
 414         tc.Debug("%s", e2SubsFail.String())
 415
 416         params := &xapp.RMRParams{}
 417         params.Mtype = xapp.RIC_SUB_FAILURE
 418         params.SubId = msg.SubId
 419         params.Payload = packedMsg.Buf
 420         params.PayloadLen = len(packedMsg.Buf)
 421         params.Meid = msg.Meid
 422         params.Xid = msg.Xid
 423         params.Mbuf = nil
 424
 425         tc.Info("SEND SUB FAIL: %s", params.String())
 426         snderr := tc.SendWithRetry(params, false, 5)
 427         if snderr != nil {
 428                 tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
 429         }
 430 }
 431
 432 //-----------------------------------------------------------------------------
 433 //
 434 //-----------------------------------------------------------------------------
 435 func (tc *E2Stub) RecvSubsFail(t *testing.T, trans *RmrTransactionId) uint32 {
 436         tc.Info("RecvSubsFail")
 437         e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
 438         var e2SubsId uint32
 439
 440         //-------------------------------
 441         // xapp activity: Recv Subs Fail
 442         //-------------------------------
 443         msg := tc.WaitMsg(15)
 444         if msg != nil {
 445                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_FAILURE"] {
 446                         tc.TestError(t, "Received RIC_SUB_FAILURE wrong mtype expected %s got %s, error", "RIC_SUB_FAILURE", xapp.RicMessageTypeToName[msg.Mtype])
 447                         return 0
 448                 } else if msg.Xid != trans.xid {
 449                         tc.TestError(t, "Received RIC_SUB_FAILURE wrong xid expected %s got %s, error", trans.xid, msg.Xid)
 450                         return 0
 451                 } else {
 452                         packedData := &e2ap.PackedData{}
 453                         packedData.Buf = msg.Payload
 454                         if msg.SubId > 0 {
 455                                 e2SubsId = uint32(msg.SubId)
 456                         } else {
 457                                 e2SubsId = 0
 458                         }
 459                         unpackerr, resp := e2SubsFail.UnPack(packedData)
 460                         if unpackerr != nil {
 461                                 tc.TestError(t, "RIC_SUB_FAILURE unpack failed err: %s", unpackerr.Error())
 462                         }
 463                         tc.Info("Recv Subs Fail rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
 464                         return e2SubsId
 465                 }
 466         } else {
 467                 tc.TestError(t, "Not Received msg within %d secs", 15)
 468         }
 469         return 0
 470 }
 471
 472 //-----------------------------------------------------------------------------
 473 //
 474 //-----------------------------------------------------------------------------
 475 func (tc *E2Stub) SendSubsDelReq(t *testing.T, oldTrans *RmrTransactionId, e2SubsId uint32) *RmrTransactionId {
 476
 477         trans := oldTrans
 478         if oldTrans == nil {
 479                 trans = tc.NewRmrTransactionId("", "RAN_NAME_1")
 480         }
 481
 482         tc.Info("SendSubsDelReq %s", trans.String())
 483         e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
 484         //---------------------------------
 485         // xapp activity: Send Subs Del Req
 486         //---------------------------------
 487         req := &e2ap.E2APSubscriptionDeleteRequest{}
 488         req.RequestId.Id = 1
 489         req.RequestId.InstanceId = e2SubsId
 490         req.FunctionId = 1
 491
 492         err, packedMsg := e2SubsDelReq.Pack(req)
 493         if err != nil {
 494                 tc.TestError(t, "pack NOK %s %s", trans.String(), err.Error())
 495                 return nil
 496         }
 497         tc.Debug("%s %s", trans.String(), e2SubsDelReq.String())
 498
 499         params := &xapp.RMRParams{}
 500         params.Mtype = xapp.RIC_SUB_DEL_REQ
 501         params.SubId = int(e2SubsId)
 502         params.Payload = packedMsg.Buf
 503         params.PayloadLen = len(packedMsg.Buf)
 504         params.Meid = trans.meid
 505         params.Xid = trans.xid
 506         params.Mbuf = nil
 507
 508         tc.Info("SEND SUB DEL REQ: %s", params.String())
 509         snderr := tc.SendWithRetry(params, false, 5)
 510         if snderr != nil {
 511                 tc.TestError(t, "RMR SEND FAILED: %s %s", trans.String(), snderr.Error())
 512                 return nil
 513         }
 514         return trans
 515 }
 516
 517 //-----------------------------------------------------------------------------
 518 //
 519 //-----------------------------------------------------------------------------
 520 func (tc *E2Stub) RecvSubsDelReq(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *xapp.RMRParams) {
 521         tc.Info("RecvSubsDelReq")
 522         e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
 523
 524         //---------------------------------
 525         // e2term activity: Recv Subs Del Req
 526         //---------------------------------
 527         msg := tc.WaitMsg(15)
 528         if msg != nil {
 529                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] {
 530                         tc.TestError(t, "Received wrong mtype expected %s got %s, error", "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype])
 531                 } else {
 532                         tc.Info("Recv Subs Del Req")
 533
 534                         packedData := &e2ap.PackedData{}
 535                         packedData.Buf = msg.Payload
 536                         unpackerr, req := e2SubsDelReq.UnPack(packedData)
 537                         if unpackerr != nil {
 538                                 tc.TestError(t, "RIC_SUB_DEL_REQ unpack failed err: %s", unpackerr.Error())
 539                         }
 540                         return req, msg
 541                 }
 542         } else {
 543                 tc.TestError(t, "Not Received msg within %d secs", 15)
 544         }
 545         return nil, nil
 546 }
 547
 548 //-----------------------------------------------------------------------------
 549 //
 550 //-----------------------------------------------------------------------------
 551 func (tc *E2Stub) SendSubsDelResp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) {
 552         tc.Info("SendSubsDelResp")
 553         e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
 554
 555         //---------------------------------
 556         // e2term activity: Send Subs Del Resp
 557         //---------------------------------
 558         resp := &e2ap.E2APSubscriptionDeleteResponse{}
 559         resp.RequestId.Id = req.RequestId.Id
 560         resp.RequestId.InstanceId = req.RequestId.InstanceId
 561         resp.FunctionId = req.FunctionId
 562
 563         packerr, packedMsg := e2SubsDelResp.Pack(resp)
 564         if packerr != nil {
 565                 tc.TestError(t, "pack NOK %s", packerr.Error())
 566         }
 567         tc.Debug("%s", e2SubsDelResp.String())
 568
 569         params := &xapp.RMRParams{}
 570         params.Mtype = xapp.RIC_SUB_DEL_RESP
 571         params.SubId = msg.SubId
 572         params.Payload = packedMsg.Buf
 573         params.PayloadLen = len(packedMsg.Buf)
 574         params.Meid = msg.Meid
 575         params.Xid = msg.Xid
 576         params.Mbuf = nil
 577
 578         tc.Info("SEND SUB DEL RESP: %s", params.String())
 579         snderr := tc.SendWithRetry(params, false, 5)
 580         if snderr != nil {
 581                 tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
 582         }
 583 }
 584
 585 //-----------------------------------------------------------------------------
 586 //
 587 //-----------------------------------------------------------------------------
 588 func (tc *E2Stub) RecvSubsDelResp(t *testing.T, trans *RmrTransactionId) {
 589         tc.Info("RecvSubsDelResp")
 590         e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
 591
 592         //---------------------------------
 593         // xapp activity: Recv Subs Del Resp
 594         //---------------------------------
 595         msg := tc.WaitMsg(15)
 596         if msg != nil {
 597                 if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] {
 598                         tc.TestError(t, "Received RIC_SUB_DEL_RESP wrong mtype expected %s got %s, error", "RIC_SUB_DEL_RESP", xapp.RicMessageTypeToName[msg.Mtype])
 599                         return
 600                 } else if trans != nil && msg.Xid != trans.xid {
 601                         tc.TestError(t, "Received RIC_SUB_DEL_RESP wrong xid expected %s got %s, error", trans.xid, msg.Xid)
 602                         return
 603                 } else {
 604                         packedData := &e2ap.PackedData{}
 605                         packedData.Buf = msg.Payload
 606                         unpackerr, resp := e2SubsDelResp.UnPack(packedData)
 607                         if unpackerr != nil {
 608                                 tc.TestError(t, "RIC_SUB_DEL_RESP unpack failed err: %s", unpackerr.Error())
 609                         }
 610                         tc.Info("Recv Subs Del Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
 611                         return
 612                 }
 613         } else {
 614                 tc.TestError(t, "Not Received msg within %d secs", 15)
 615         }
 616 }
 617
 618 //-----------------------------------------------------------------------------
 619 //
 620 //-----------------------------------------------------------------------------
 621 func (tc *E2Stub) SendSubsDelFail(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) {
 622         tc.Info("SendSubsDelFail")
 623         e2SubsDelFail := e2asnpacker.NewPackerSubscriptionDeleteFailure()
 624
 625         //---------------------------------
 626         // e2term activity: Send Subs Del Fail
 627         //---------------------------------
 628         resp := &e2ap.E2APSubscriptionDeleteFailure{}
 629         resp.RequestId.Id = req.RequestId.Id
 630         resp.RequestId.InstanceId = req.RequestId.InstanceId
 631         resp.FunctionId = req.FunctionId
 632         resp.Cause.Content = 5 // CauseMisc
 633         resp.Cause.Value = 3   // unspecified
 634
 635         packerr, packedMsg := e2SubsDelFail.Pack(resp)
 636         if packerr != nil {
 637                 tc.TestError(t, "pack NOK %s", packerr.Error())
 638         }
 639         tc.Debug("%s", e2SubsDelFail.String())
 640
 641         params := &xapp.RMRParams{}
 642         params.Mtype = xapp.RIC_SUB_DEL_FAILURE
 643         params.SubId = msg.SubId
 644         params.Payload = packedMsg.Buf
 645         params.PayloadLen = len(packedMsg.Buf)
 646         params.Meid = msg.Meid
 647         params.Xid = msg.Xid
 648         params.Mbuf = nil
 649
 650         tc.Info("SEND SUB DEL FAIL: %s", params.String())
 651         snderr := tc.SendWithRetry(params, false, 5)
 652         if snderr != nil {
 653                 tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
 654         }
 655 }
 656
 657 // REST code below all
 658
 659 /*****************************************************************************/
 660 // REST interface specific functions are below
 661
 662 //-----------------------------------------------------------------------------
 663 // Callback handler for subscription response notifications
 664 //-----------------------------------------------------------------------------
 665 func (tc *E2Stub) SubscriptionRespHandler(resp *clientmodel.SubscriptionResponse) {
 666         if tc.subscriptionId == "SUBSCRIPTIONID NOT SET" {
 667                 tc.Info("REST notification received for %v while no SubscriptionID was not set for InstanceID=%v, RequestorID=%v (%v)",
 668                         *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].RequestorID, tc)
 669                 tc.CallBackNotification <- *resp.SubscriptionInstances[0].InstanceID
 670         } else if tc.subscriptionId == *resp.SubscriptionID {
 671                 tc.Info("REST notification received SubscriptionID=%s, InstanceID=%v, RequestorID=%v (%v)",
 672                         *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].RequestorID, tc)
 673                 tc.CallBackNotification <- *resp.SubscriptionInstances[0].InstanceID
 674         } else {
 675                 tc.Info("MISMATCHING REST notification received SubscriptionID=%s<>%s, InstanceID=%v, RequestorID=%v (%v)",
 676                         tc.subscriptionId, *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].RequestorID, tc)
 677         }
 678 }
 679
 680 //-----------------------------------------------------------------------------
 681 //
 682 //-----------------------------------------------------------------------------
 683 func (tc *E2Stub) ExpectRESTNotification(t *testing.T, restSubsId string) {
 684
 685         tc.Info("### Started to wait REST notification for %v on port %v f(RMR port %v), %v responses expected", restSubsId, *tc.clientEndpoint.HTTPPort, *tc.clientEndpoint.RMRPort, tc.requestCount)
 686         tc.restSubsIdList = []string{restSubsId}
 687         xapp.Subscription.SetResponseCB(tc.ListedRestNotifHandler)
 688         if tc.requestCount == 0 {
 689                 tc.TestError(t, "### NO REST notifications SET received for endpoint=%s, request zount ZERO! (%v)", tc.clientEndpoint, tc)
 690         }
 691         go func() {
 692                 select {
 693                 case e2Ids := <-tc.CallBackListedNotifications:
 694                         if tc.requestCount == 0 {
 695                                 tc.TestError(t, "### REST notification count unexpectedly ZERO for %s (%v)", restSubsId, tc)
 696                         } else if e2Ids.RestSubsId != restSubsId {
 697                                 tc.TestError(t, "### Unexpected REST notifications received |%s:%s| (%v)", e2Ids.RestSubsId, restSubsId, tc)
 698                         } else {
 699                                 tc.requestCount--
 700                                 if tc.requestCount == 0 {
 701                                         tc.Info("### All expected REST notifications received for %s (%v)", e2Ids.RestSubsId, tc)
 702                                 } else {
 703                                         tc.Info("### Expected REST notifications received for %s, (%v)", e2Ids.RestSubsId, tc)
 704                                 }
 705                                 tc.Info("### REST Notification received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId)
 706                                 tc.ListedRESTNotifications <- e2Ids
 707                         }
 708                 case <-time.After(15 * time.Second):
 709                         err := fmt.Errorf("### Timeout 15s expired while expecting REST notification for subsId: %v", restSubsId)
 710                         tc.TestError(t, "%s", err.Error())
 711                 }
 712         }()
 713 }
 714
 715 func (tc *E2Stub) WaitRESTNotification(t *testing.T, restSubsId string) uint32 {
 716         select {
 717         case e2SubsId := <-tc.ListedRESTNotifications:
 718                 if e2SubsId.RestSubsId == restSubsId {
 719                         tc.Info("### Expected REST notifications received %s, e2SubsId %v for endpoint=%s, (%v)", e2SubsId.RestSubsId, e2SubsId.E2SubsId, tc.clientEndpoint, tc)
 720                         return e2SubsId.E2SubsId
 721                 } else {
 722                         tc.TestError(t, "### Unexpected REST notifications received %s, expected %s for endpoint=%s, (%v)", e2SubsId.RestSubsId, restSubsId, tc.clientEndpoint, tc)
 723                         return 0
 724                 }
 725         case <-time.After(15 * time.Second):
 726                 err := fmt.Errorf("### Timeout 15s expired while waiting REST notification for subsId: %v", restSubsId)
 727                 tc.TestError(t, "%s", err.Error())
 728                 panic("WaitRESTNotification - timeout error")
 729         }
 730         return 0
 731 }
 732
 733 func (tc *E2Stub) WaitRESTNotificationForAnySubscriptionId(t *testing.T) {
 734         go func() {
 735                 tc.Info("### REST notifications received for endpoint=%s, (%v)", tc.clientEndpoint, tc)
 736                 select {
 737                 case e2SubsId := <-tc.CallBackNotification:
 738                         tc.Info("### REST notifications received e2SubsId %v for endpoint=%s, (%v)", e2SubsId, tc.clientEndpoint, tc)
 739                         tc.RESTNotification <- (uint32)(e2SubsId)
 740                 case <-time.After(15 * time.Second):
 741                         err := fmt.Errorf("### Timeout 15s expired while waiting REST notification")
 742                         tc.TestError(t, "%s", err.Error())
 743                         tc.RESTNotification <- 0
 744                 }
 745         }()
 746 }
 747
 748 func (tc *E2Stub) ListedRestNotifHandler(resp *clientmodel.SubscriptionResponse) {
 749
 750         if len(tc.restSubsIdList) == 0 {
 751                 tc.Error("Unexpected listed REST notifications received for endpoint=%s, expected restSubsId list size was ZERO!", tc.clientEndpoint)
 752         } else {
 753                 for i, subsId := range tc.restSubsIdList {
 754                         if *resp.SubscriptionID == subsId {
 755                                 //tc.Info("Listed REST notifications received SubscriptionID=%s, InstanceID=%v, RequestorID=%v",
 756                                 //      *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].RequestorID)
 757
 758                                 tc.restSubsIdList = append(tc.restSubsIdList[:i], tc.restSubsIdList[i+1:]...)
 759                                 //tc.Info("Removed %s from Listed REST notifications, %v entries left", *resp.SubscriptionID, len(tc.restSubsIdList))
 760
 761                                 tc.CallBackListedNotifications <- E2RestIds{*resp.SubscriptionID, uint32(*resp.SubscriptionInstances[0].InstanceID)}
 762
 763                                 if len(tc.restSubsIdList) == 0 {
 764                                         //tc.Info("All listed REST notifications received for endpoint=%s", tc.clientEndpoint)
 765                                 }
 766
 767                                 return
 768                         }
 769                 }
 770                 tc.Error("UNKONWN REST notification received SubscriptionID=%s<>%s, InstanceID=%v, RequestorID=%v (%v)",
 771                         tc.subscriptionId, *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].RequestorID, tc)
 772         }
 773 }
 774
 775 //-----------------------------------------------------------------------------
 776 //
 777 //-----------------------------------------------------------------------------
 778 func (tc *E2Stub) WaitListedRestNotifications(t *testing.T, restSubsIds []string) {
 779         tc.Info("Started to wait REST notifications %v on port %v f(RMR port %v)", restSubsIds, *tc.clientEndpoint.HTTPPort, *tc.clientEndpoint.RMRPort)
 780
 781         tc.restSubsIdList = restSubsIds
 782         xapp.Subscription.SetResponseCB(tc.ListedRestNotifHandler)
 783
 784         for i := 0; i < len(restSubsIds); i++ {
 785                 go func() {
 786                         select {
 787                         case e2Ids := <-tc.CallBackListedNotifications:
 788                                 tc.Info("Listed Notification waiter received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId)
 789                                 tc.ListedRESTNotifications <- e2Ids
 790                         case <-time.After(15 * time.Second):
 791                                 err := fmt.Errorf("Timeout 15s expired while waiting Listed REST notification")
 792                                 tc.TestError(t, "%s", err.Error())
 793                                 tc.RESTNotification <- 0
 794                         }
 795                 }()
 796         }
 797 }
 798
 799 //-----------------------------------------------------------------------------
 800 //
 801 //-----------------------------------------------------------------------------
 802 func (tc *E2Stub) SendRESTSubsReq(t *testing.T, params *RESTSubsReqParams) string { // This need to be edited according to new specification
 803         tc.Info("======== Posting REST Report subscriptions to Submgr ======")
 804
 805         if params == nil {
 806                 tc.Info("SendRESTReportSubsReq: params == nil")
 807                 return ""
 808         }
 809
 810         tc.subscriptionId = "SUBSCIPTIONID NOT SET"
 811
 812         resp, err := xapp.Subscription.Subscribe(&params.SubsReqParams)
 813         if err != nil {
 814                 // Swagger generated code makes checks for the values that are inserted the subscription function
 815                 // If error cause is unknown and POST is not done, the problem is in the inserted values
 816                 tc.Error("======== REST report subscriptions failed %s ========", err.Error())
 817                 return ""
 818         }
 819         tc.subscriptionId = *resp.SubscriptionID
 820         tc.Info("======== REST report subscriptions posted successfully. SubscriptionID = %s, RequestCount = %v ========", *resp.SubscriptionID, tc.requestCount)
 821         return *resp.SubscriptionID
 822 }
 823
 824 //-----------------------------------------------------------------------------
 825 //
 826 //-----------------------------------------------------------------------------
 827 func (tc *E2Stub) GetRESTSubsReqReportParams(subReqCount int, parameterSet int, actionDefinitionPresent bool, actionParamCount int) *RESTSubsReqParams {
 828
 829         reportParams := RESTSubsReqParams{}
 830         if parameterSet == 1 {
 831                 reportParams.GetRESTSubsReqReportParams1(subReqCount, actionDefinitionPresent, actionParamCount, &tc.clientEndpoint, &tc.meid)
 832         } else if parameterSet == 2 {
 833
 834         } else {
 835                 tc.Error("Invalid parameterSet=%v", parameterSet)
 836         }
 837         tc.requestCount = subReqCount
 838         return &reportParams
 839 }
 840
 841 //-----------------------------------------------------------------------------
 842 //
 843 //-----------------------------------------------------------------------------
 844 func (tc *E2Stub) GetRESTSubsReqReportParams1(subReqCount int, actionDefinitionPresent bool, actionParamCount int) *RESTSubsReqParams {
 845
 846         reportParams := RESTSubsReqParams{}
 847         reportParams.GetRESTSubsReqReportParams1(subReqCount, actionDefinitionPresent, actionParamCount, &tc.clientEndpoint, &tc.meid)
 848         tc.requestCount = subReqCount
 849         return &reportParams
 850 }
 851
 852 //-----------------------------------------------------------------------------
 853 //
 854 //-----------------------------------------------------------------------------
 855 type RESTSubsReqParams struct {
 856         SubsReqParams clientmodel.SubscriptionParams
 857 }
 858
 859 func (p *RESTSubsReqParams) GetRESTSubsReqReportParams1(subReqCount int, actionDefinitionPresent bool, actionParamCount int, clientEndpoint *clientmodel.SubscriptionParamsClientEndpoint, meid *string) {
 860
 861         // E2SM-gNB-X2
 862         p.SubsReqParams.ClientEndpoint = clientEndpoint
 863         p.SubsReqParams.Meid = meid
 864         var rANFunctionID int64 = 33
 865         p.SubsReqParams.RANFunctionID = &rANFunctionID
 866
 867         //      reqId := int64(1)
 868         //seqId := int64(1)
 869         actionId := int64(1)
 870         actionType := "report"
 871         subsequestActioType := "continue"
 872         timeToWait := "w10ms"
 873
 874         for requestCount := 0; requestCount < subReqCount; requestCount++ {
 875                 reqId := int64(requestCount) + 1
 876                 seqId := int64(requestCount) + 1
 877                 subscriptionDetail := &clientmodel.SubscriptionDetail{
 878                         RequestorID: &reqId,
 879                         InstanceID:  &seqId,
 880                         EventTriggers: &clientmodel.EventTriggerDefinition{
 881                                 OctetString: "1234" + strconv.Itoa(requestCount),
 882                         },
 883                         ActionToBeSetupList: clientmodel.ActionsToBeSetup{
 884                                 &clientmodel.ActionToBeSetup{
 885                                         ActionID:   &actionId,
 886                                         ActionType: &actionType,
 887                                         ActionDefinition: &clientmodel.ActionDefinition{
 888                                                 OctetString: "5678" + strconv.Itoa(requestCount),
 889                                         },
 890                                         SubsequentAction: &clientmodel.SubsequentAction{
 891                                                 SubsequentActionType: &subsequestActioType,
 892                                                 TimeToWait:           &timeToWait,
 893                                         },
 894                                 },
 895                         },
 896                 }
 897                 p.SubsReqParams.SubscriptionDetails = append(p.SubsReqParams.SubscriptionDetails, subscriptionDetail)
 898         }
 899
 900 }
 901
 902 func (p *RESTSubsReqParams) SetMeid(MEID string) {
 903         p.SubsReqParams.Meid = &MEID
 904 }
 905
 906 func (p *RESTSubsReqParams) SetEndpoint(HTTP_port int64, RMR_port int64, host string) {
 907         var endpoint clientmodel.SubscriptionParamsClientEndpoint
 908         endpoint.HTTPPort = &HTTP_port
 909         endpoint.RMRPort = &RMR_port
 910         endpoint.Host = host
 911         p.SubsReqParams.ClientEndpoint = &endpoint
 912 }
 913
 914 func (p *RESTSubsReqParams) SetEndpointHost(host string) {
 915
 916         if p.SubsReqParams.ClientEndpoint.Host != "" {
 917                 if p.SubsReqParams.ClientEndpoint.Host != host {
 918                         // Renaming toto, print something tc.Info("Posting REST subscription request to Submgr")
 919                         err := fmt.Errorf("hostname change attempt: %s -> %s", p.SubsReqParams.ClientEndpoint.Host, host)
 920                         panic(err)
 921                 }
 922         }
 923         p.SubsReqParams.ClientEndpoint.Host = host
 924 }
 925
 926 func (p *RESTSubsReqParams) SetHTTPEndpoint(HTTP_port int64, host string) {
 927
 928         p.SubsReqParams.ClientEndpoint.HTTPPort = &HTTP_port
 929
 930         p.SetEndpointHost(host)
 931
 932         if p.SubsReqParams.ClientEndpoint.RMRPort == nil {
 933                 var RMR_port int64
 934                 p.SubsReqParams.ClientEndpoint.RMRPort = &RMR_port
 935         }
 936 }
 937
 938 func (p *RESTSubsReqParams) SetSubActionTypes(actionType string) {
 939
 940         for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
 941                 for _, action := range subDetail.ActionToBeSetupList {
 942                         if action != nil {
 943                                 action.ActionType = &actionType
 944                         }
 945                 }
 946         }
 947 }
 948
 949 func (p *RESTSubsReqParams) SetSubActionIDs(actionId int64) {
 950
 951         for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
 952                 for _, action := range subDetail.ActionToBeSetupList {
 953                         if action != nil {
 954                                 action.ActionID = &actionId
 955                         }
 956                 }
 957         }
 958 }
 959
 960 func (p *RESTSubsReqParams) SetSubActionDefinition(actionDefinition string) {
 961
 962         for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
 963                 for _, action := range subDetail.ActionToBeSetupList {
 964                         if action != nil {
 965                                 action.ActionDefinition.OctetString = actionDefinition
 966                         }
 967                 }
 968         }
 969 }
 970
 971 func (p *RESTSubsReqParams) SetSubEventTriggerDefinition(eventTriggerDefinition string) {
 972
 973         for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
 974                 if subDetail != nil {
 975                         subDetail.EventTriggers.OctetString = eventTriggerDefinition
 976                 }
 977         }
 978 }
 979
 980 func (p *RESTSubsReqParams) AppendActionToActionToBeSetupList(actionId int64, actionType string, actionDefinition string, subsequentActionType string, timeToWait string) {
 981
 982         actionToBeSetup := &clientmodel.ActionToBeSetup{
 983                 ActionID:   &actionId,
 984                 ActionType: &actionType,
 985                 ActionDefinition: &clientmodel.ActionDefinition{
 986                         OctetString: actionDefinition,
 987                 },
 988                 SubsequentAction: &clientmodel.SubsequentAction{
 989                         SubsequentActionType: &subsequentActionType,
 990                         TimeToWait:           &timeToWait,
 991                 },
 992         }
 993
 994         for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
 995                 if subDetail != nil {
 996                         subDetail.ActionToBeSetupList = append(subDetail.ActionToBeSetupList, actionToBeSetup)
 997                 }
 998         }
 999 }
1000
1001 func (p *RESTSubsReqParams) SetRMREndpoint(RMR_port int64, host string) {
1002
1003         p.SubsReqParams.ClientEndpoint.RMRPort = &RMR_port
1004
1005         p.SetEndpointHost(host)
1006
1007         if p.SubsReqParams.ClientEndpoint.HTTPPort == nil {
1008                 var HTTP_port int64
1009                 p.SubsReqParams.ClientEndpoint.HTTPPort = &HTTP_port
1010         }
1011 }
1012
1013 func (p *RESTSubsReqParams) SetTimeToWait(timeToWait string) {
1014
1015         for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
1016                 for _, action := range subDetail.ActionToBeSetupList {
1017                         if action != nil && action.SubsequentAction != nil {
1018                                 action.SubsequentAction.TimeToWait = &timeToWait
1019                         }
1020                 }
1021         }
1022 }
1023
1024 //-----------------------------------------------------------------------------
1025 //
1026 //-----------------------------------------------------------------------------
1027 func (tc *E2Stub) SendRESTSubsDelReq(t *testing.T, subscriptionID *string) {
1028
1029         if *subscriptionID == "" {
1030                 tc.Error("REST error in deleting subscriptions. Empty SubscriptionID = %s", *subscriptionID)
1031         }
1032         tc.Info("REST deleting E2 subscriptions. SubscriptionID = %s", *subscriptionID)
1033
1034         err := xapp.Subscription.Unsubscribe(*subscriptionID)
1035         if err != nil {
1036                 tc.Error("REST Delete subscription failed %s", err.Error())
1037         }
1038         tc.Info("REST delete subscription pushed to submgr successfully. SubscriptionID = %s", *subscriptionID)
1039 }
1040
1041 //-----------------------------------------------------------------------------
1042 //
1043 //-----------------------------------------------------------------------------
1044 func (tc *E2Stub) GetRESTSubsReqPolicyParams(subReqCount int, actionDefinitionPresent bool, policyParamCount int) *RESTSubsReqParams {
1045
1046         policyParams := RESTSubsReqParams{}
1047         policyParams.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount, &tc.clientEndpoint, &tc.meid)
1048         tc.requestCount = subReqCount
1049         return &policyParams
1050 }
1051
1052 //-----------------------------------------------------------------------------
1053 //
1054 //-----------------------------------------------------------------------------
1055 func (p *RESTSubsReqParams) GetRESTSubsReqPolicyParams(subReqCount int, actionDefinitionPresent bool, policyParamCount int, clientEndpoint *clientmodel.SubscriptionParamsClientEndpoint, meid *string) {
1056
1057         p.SubsReqParams.ClientEndpoint = clientEndpoint
1058         p.SubsReqParams.Meid = meid
1059         var rANFunctionID int64 = 33
1060         p.SubsReqParams.RANFunctionID = &rANFunctionID
1061
1062         //      reqId := int64(1)
1063         //seqId := int64(1)
1064         actionId := int64(1)
1065         actionType := "policy"
1066         subsequestActioType := "continue"
1067         timeToWait := "w10ms"
1068
1069         for requestCount := 0; requestCount < subReqCount; requestCount++ {
1070                 reqId := int64(requestCount) + 1
1071                 seqId := int64(0)
1072                 subscriptionDetail := &clientmodel.SubscriptionDetail{
1073                         RequestorID: &reqId,
1074                         InstanceID:  &seqId,
1075                         EventTriggers: &clientmodel.EventTriggerDefinition{
1076                                 OctetString: "1234" + strconv.Itoa(requestCount),
1077                         },
1078                         ActionToBeSetupList: clientmodel.ActionsToBeSetup{
1079                                 &clientmodel.ActionToBeSetup{
1080                                         ActionID:   &actionId,
1081                                         ActionType: &actionType,
1082                                         ActionDefinition: &clientmodel.ActionDefinition{
1083                                                 OctetString: "5678" + strconv.Itoa(requestCount),
1084                                         },
1085                                         SubsequentAction: &clientmodel.SubsequentAction{
1086                                                 SubsequentActionType: &subsequestActioType,
1087                                                 TimeToWait:           &timeToWait,
1088                                         },
1089                                 },
1090                         },
1091                 }
1092                 p.SubsReqParams.SubscriptionDetails = append(p.SubsReqParams.SubscriptionDetails, subscriptionDetail)
1093         }
1094
1095 }