2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
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
10 http://www.apache.org/licenses/LICENSE-2.0
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 ==================================================================================
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"
35 //-----------------------------------------------------------------------------
37 //-----------------------------------------------------------------------------
38 var e2asnpacker e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
40 //-----------------------------------------------------------------------------
42 //-----------------------------------------------------------------------------
43 type RmrTransactionId struct {
48 type E2RestIds struct {
53 func (trans *RmrTransactionId) String() string {
55 if trans.meid != nil {
56 meidstr = trans.meid.String()
58 return "trans(" + trans.xid + "/" + meidstr + ")"
62 teststub.RmrStubControl
66 CallBackNotification chan int64
67 RESTNotification chan uint32
68 CallBackListedNotifications chan E2RestIds
69 ListedRESTNotifications chan E2RestIds
70 clientEndpoint clientmodel.SubscriptionParamsClientEndpoint
72 restSubsIdList []string
75 //-----------------------------------------------------------------------------
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 {
80 tc.RmrStubControl.Init(desc, srcId, rtgSvc, stat, mtypeseed)
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
89 endPoint.HTTPPort = &HTTPPort
90 endPoint.RMRPort = &RMRPort
91 tc.clientEndpoint = endPoint
96 //-----------------------------------------------------------------------------
98 //-----------------------------------------------------------------------------
99 func CreateNewE2termStub(desc string, srcId teststub.RmrSrcId, rtgSvc teststub.RmrRtgSvc, stat string, mtypeseed int) *E2Stub {
101 tc.RmrStubControl.Init(desc, srcId, rtgSvc, stat, mtypeseed)
103 tc.SetCheckXid(false)
107 //-----------------------------------------------------------------------------
109 //-----------------------------------------------------------------------------
110 func (tc *E2Stub) NewRmrTransactionId(xid string, ranname string) *RmrTransactionId {
111 trans := &RmrTransactionId{}
113 trans.xid = tc.GetDesc() + "_XID_" + strconv.FormatUint(uint64(tc.xid_seq), 10)
118 trans.meid = &xapp.RMRMeid{RanName: ranname}
119 tc.Info("New test %s", trans.String())
123 //-----------------------------------------------------------------------------
125 //-----------------------------------------------------------------------------
126 type E2StubSubsReqParams struct {
127 Req *e2ap.E2APSubscriptionRequest
130 func (p *E2StubSubsReqParams) Init() {
131 p.Req = &e2ap.E2APSubscriptionRequest{}
133 p.Req.RequestId.Id = 1
134 p.Req.RequestId.InstanceId = 0
137 // gnb -> enb outgoing
138 // enb -> gnb incoming
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
144 p.Req.ActionSetups = make([]e2ap.ActionToBeSetupItem, 1)
146 p.Req.ActionSetups[0].ActionId = 0
147 p.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeReport
148 p.Req.ActionSetups[0].RicActionDefinitionPresent = true
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
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
159 //-----------------------------------------------------------------------------
161 //-----------------------------------------------------------------------------
163 type E2StubSubsFailParams struct {
164 Req *e2ap.E2APSubscriptionRequest
165 Fail *e2ap.E2APSubscriptionFailure
168 func (p *E2StubSubsFailParams) Set(req *e2ap.E2APSubscriptionRequest) {
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)
182 func (p *E2StubSubsFailParams) SetCauseVal(ind int, content uint8, causeval uint8) {
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
191 p.Fail.ActionNotAdmittedList.Items[ind].Cause.Content = content
192 p.Fail.ActionNotAdmittedList.Items[ind].Cause.Value = causeval
195 //-----------------------------------------------------------------------------
197 //-----------------------------------------------------------------------------
199 func (tc *E2Stub) SendSubsReq(t *testing.T, rparams *E2StubSubsReqParams, oldTrans *RmrTransactionId) *RmrTransactionId {
203 trans = tc.NewRmrTransactionId("", "RAN_NAME_1")
206 tc.Info("SendSubsReq %s", trans.String())
207 e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
209 //---------------------------------
210 // xapp activity: Send Subs Req
211 //---------------------------------
215 myparams = &E2StubSubsReqParams{}
219 err, packedMsg := e2SubsReq.Pack(myparams.Req)
221 tc.TestError(t, "pack NOK %s %s", trans.String(), err.Error())
224 tc.Debug("%s %s", trans.String(), e2SubsReq.String())
226 params := &xapp.RMRParams{}
227 params.Mtype = xapp.RIC_SUB_REQ
229 params.Payload = packedMsg.Buf
230 params.PayloadLen = len(packedMsg.Buf)
231 params.Meid = trans.meid
232 params.Xid = trans.xid
235 tc.Info("SEND SUB REQ: %s", params.String())
236 snderr := tc.SendWithRetry(params, false, 5)
238 tc.TestError(t, "RMR SEND FAILED: %s %s", trans.String(), snderr.Error())
244 //-----------------------------------------------------------------------------
246 //-----------------------------------------------------------------------------
247 func (tc *E2Stub) RecvSubsReq(t *testing.T) (*e2ap.E2APSubscriptionRequest, *xapp.RMRParams) {
248 tc.Info("RecvSubsReq")
249 e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
251 //---------------------------------
252 // e2term activity: Recv Subs Req
253 //---------------------------------
254 msg := tc.WaitMsg(15)
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])
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())
269 tc.TestError(t, "Not Received msg within %d secs", 15)
275 //-----------------------------------------------------------------------------
277 //-----------------------------------------------------------------------------
278 func (tc *E2Stub) SendSubsResp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *xapp.RMRParams) {
279 tc.Info("SendSubsResp")
280 e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
282 //---------------------------------
283 // e2term activity: Send Subs Resp
284 //---------------------------------
285 resp := &e2ap.E2APSubscriptionResponse{}
287 resp.RequestId.Id = req.RequestId.Id
288 resp.RequestId.InstanceId = req.RequestId.InstanceId
289 resp.FunctionId = req.FunctionId
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
296 for index := uint64(0); index < 1; index++ {
297 item := e2ap.ActionNotAdmittedItem{}
298 item.ActionId = index
299 item.Cause.Content = 1
301 resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item)
304 packerr, packedMsg := e2SubsResp.Pack(resp)
306 tc.TestError(t, "pack NOK %s", packerr.Error())
308 tc.Debug("%s", e2SubsResp.String())
310 params := &xapp.RMRParams{}
311 params.Mtype = xapp.RIC_SUB_RESP
312 //params.SubId = msg.SubId
314 params.Payload = packedMsg.Buf
315 params.PayloadLen = len(packedMsg.Buf)
316 params.Meid = msg.Meid
317 //params.Xid = msg.Xid
320 tc.Info("SEND SUB RESP: %s", params.String())
321 snderr := tc.SendWithRetry(params, false, 5)
323 tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
327 //-----------------------------------------------------------------------------
329 //-----------------------------------------------------------------------------
330 func (tc *E2Stub) SendInvalidE2Asn1Resp(t *testing.T, msg *xapp.RMRParams, msgType int) {
332 params := &xapp.RMRParams{}
333 params.Mtype = msgType
335 params.Payload = []byte{1, 2, 3, 4, 5}
336 params.PayloadLen = 5
337 params.Meid = msg.Meid
341 if params.Mtype == xapp.RIC_SUB_RESP {
342 tc.Info("SEND INVALID ASN.1 SUB RESP")
344 } else if params.Mtype == xapp.RIC_SUB_FAILURE {
345 tc.Info("SEND INVALID ASN.1 SUB FAILURE")
347 } else if params.Mtype == xapp.RIC_SUB_DEL_RESP {
348 tc.Info("SEND INVALID ASN.1 SUB DEL RESP")
350 } else if params.Mtype == xapp.RIC_SUB_DEL_FAILURE {
351 tc.Info("SEND INVALID ASN.1 SUB DEL FAILURE")
353 snderr := tc.SendWithRetry(params, false, 5)
355 tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
359 //-----------------------------------------------------------------------------
361 //-----------------------------------------------------------------------------
362 func (tc *E2Stub) RecvSubsResp(t *testing.T, trans *RmrTransactionId) uint32 {
363 tc.Info("RecvSubsResp")
364 e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
367 //---------------------------------
368 // xapp activity: Recv Subs Resp
369 //---------------------------------
370 msg := tc.WaitMsg(15)
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])
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)
379 packedData := &e2ap.PackedData{}
380 packedData.Buf = msg.Payload
382 e2SubsId = uint32(msg.SubId)
386 unpackerr, resp := e2SubsResp.UnPack(packedData)
387 if unpackerr != nil {
388 tc.TestError(t, "RIC_SUB_RESP unpack failed err: %s", unpackerr.Error())
390 tc.Info("Recv Subs Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
394 tc.TestError(t, "Not Received msg within %d secs", 15)
399 //-----------------------------------------------------------------------------
401 //-----------------------------------------------------------------------------
403 func (tc *E2Stub) SendSubsFail(t *testing.T, fparams *E2StubSubsFailParams, msg *xapp.RMRParams) {
404 tc.Info("SendSubsFail")
405 e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
407 //---------------------------------
408 // e2term activity: Send Subs Fail
409 //---------------------------------
410 packerr, packedMsg := e2SubsFail.Pack(fparams.Fail)
412 tc.TestError(t, "pack NOK %s", packerr.Error())
414 tc.Debug("%s", e2SubsFail.String())
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
425 tc.Info("SEND SUB FAIL: %s", params.String())
426 snderr := tc.SendWithRetry(params, false, 5)
428 tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
432 //-----------------------------------------------------------------------------
434 //-----------------------------------------------------------------------------
435 func (tc *E2Stub) RecvSubsFail(t *testing.T, trans *RmrTransactionId) uint32 {
436 tc.Info("RecvSubsFail")
437 e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
440 //-------------------------------
441 // xapp activity: Recv Subs Fail
442 //-------------------------------
443 msg := tc.WaitMsg(15)
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])
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)
452 packedData := &e2ap.PackedData{}
453 packedData.Buf = msg.Payload
455 e2SubsId = uint32(msg.SubId)
459 unpackerr, resp := e2SubsFail.UnPack(packedData)
460 if unpackerr != nil {
461 tc.TestError(t, "RIC_SUB_FAILURE unpack failed err: %s", unpackerr.Error())
463 tc.Info("Recv Subs Fail rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
467 tc.TestError(t, "Not Received msg within %d secs", 15)
472 //-----------------------------------------------------------------------------
474 //-----------------------------------------------------------------------------
475 func (tc *E2Stub) SendSubsDelReq(t *testing.T, oldTrans *RmrTransactionId, e2SubsId uint32) *RmrTransactionId {
479 trans = tc.NewRmrTransactionId("", "RAN_NAME_1")
482 tc.Info("SendSubsDelReq %s", trans.String())
483 e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
484 //---------------------------------
485 // xapp activity: Send Subs Del Req
486 //---------------------------------
487 req := &e2ap.E2APSubscriptionDeleteRequest{}
489 req.RequestId.InstanceId = e2SubsId
492 err, packedMsg := e2SubsDelReq.Pack(req)
494 tc.TestError(t, "pack NOK %s %s", trans.String(), err.Error())
497 tc.Debug("%s %s", trans.String(), e2SubsDelReq.String())
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
508 tc.Info("SEND SUB DEL REQ: %s", params.String())
509 snderr := tc.SendWithRetry(params, false, 5)
511 tc.TestError(t, "RMR SEND FAILED: %s %s", trans.String(), snderr.Error())
517 //-----------------------------------------------------------------------------
519 //-----------------------------------------------------------------------------
520 func (tc *E2Stub) RecvSubsDelReq(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *xapp.RMRParams) {
521 tc.Info("RecvSubsDelReq")
522 e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
524 //---------------------------------
525 // e2term activity: Recv Subs Del Req
526 //---------------------------------
527 msg := tc.WaitMsg(15)
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])
532 tc.Info("Recv Subs Del Req")
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())
543 tc.TestError(t, "Not Received msg within %d secs", 15)
548 //-----------------------------------------------------------------------------
550 //-----------------------------------------------------------------------------
551 func (tc *E2Stub) SendSubsDelResp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) {
552 tc.Info("SendSubsDelResp")
553 e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
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
563 packerr, packedMsg := e2SubsDelResp.Pack(resp)
565 tc.TestError(t, "pack NOK %s", packerr.Error())
567 tc.Debug("%s", e2SubsDelResp.String())
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
578 tc.Info("SEND SUB DEL RESP: %s", params.String())
579 snderr := tc.SendWithRetry(params, false, 5)
581 tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
585 //-----------------------------------------------------------------------------
587 //-----------------------------------------------------------------------------
588 func (tc *E2Stub) RecvSubsDelResp(t *testing.T, trans *RmrTransactionId) {
589 tc.Info("RecvSubsDelResp")
590 e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
592 //---------------------------------
593 // xapp activity: Recv Subs Del Resp
594 //---------------------------------
595 msg := tc.WaitMsg(15)
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])
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)
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())
610 tc.Info("Recv Subs Del Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
614 tc.TestError(t, "Not Received msg within %d secs", 15)
618 //-----------------------------------------------------------------------------
620 //-----------------------------------------------------------------------------
621 func (tc *E2Stub) SendSubsDelFail(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) {
622 tc.Info("SendSubsDelFail")
623 e2SubsDelFail := e2asnpacker.NewPackerSubscriptionDeleteFailure()
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
635 packerr, packedMsg := e2SubsDelFail.Pack(resp)
637 tc.TestError(t, "pack NOK %s", packerr.Error())
639 tc.Debug("%s", e2SubsDelFail.String())
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
650 tc.Info("SEND SUB DEL FAIL: %s", params.String())
651 snderr := tc.SendWithRetry(params, false, 5)
653 tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
657 // REST code below all
659 /*****************************************************************************/
660 // REST interface specific functions are below
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
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)
680 //-----------------------------------------------------------------------------
682 //-----------------------------------------------------------------------------
683 func (tc *E2Stub) ExpectRESTNotification(t *testing.T, restSubsId string) {
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)
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)
700 if tc.requestCount == 0 {
701 tc.Info("### All expected REST notifications received for %s (%v)", e2Ids.RestSubsId, tc)
703 tc.Info("### Expected REST notifications received for %s, (%v)", e2Ids.RestSubsId, tc)
705 tc.Info("### REST Notification received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId)
706 tc.ListedRESTNotifications <- e2Ids
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())
715 func (tc *E2Stub) WaitRESTNotification(t *testing.T, restSubsId string) uint32 {
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
722 tc.TestError(t, "### Unexpected REST notifications received %s, expected %s for endpoint=%s, (%v)", e2SubsId.RestSubsId, restSubsId, tc.clientEndpoint, tc)
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")
733 func (tc *E2Stub) WaitRESTNotificationForAnySubscriptionId(t *testing.T) {
735 tc.Info("### REST notifications received for endpoint=%s, (%v)", tc.clientEndpoint, tc)
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
748 func (tc *E2Stub) ListedRestNotifHandler(resp *clientmodel.SubscriptionResponse) {
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)
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)
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))
761 tc.CallBackListedNotifications <- E2RestIds{*resp.SubscriptionID, uint32(*resp.SubscriptionInstances[0].InstanceID)}
763 if len(tc.restSubsIdList) == 0 {
764 //tc.Info("All listed REST notifications received for endpoint=%s", tc.clientEndpoint)
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)
775 //-----------------------------------------------------------------------------
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)
781 tc.restSubsIdList = restSubsIds
782 xapp.Subscription.SetResponseCB(tc.ListedRestNotifHandler)
784 for i := 0; i < len(restSubsIds); i++ {
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
799 //-----------------------------------------------------------------------------
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 ======")
806 tc.Info("SendRESTReportSubsReq: params == nil")
810 tc.subscriptionId = "SUBSCIPTIONID NOT SET"
812 resp, err := xapp.Subscription.Subscribe(¶ms.SubsReqParams)
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())
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
824 //-----------------------------------------------------------------------------
826 //-----------------------------------------------------------------------------
827 func (tc *E2Stub) GetRESTSubsReqReportParams(subReqCount int, parameterSet int, actionDefinitionPresent bool, actionParamCount int) *RESTSubsReqParams {
829 reportParams := RESTSubsReqParams{}
830 if parameterSet == 1 {
831 reportParams.GetRESTSubsReqReportParams1(subReqCount, actionDefinitionPresent, actionParamCount, &tc.clientEndpoint, &tc.meid)
832 } else if parameterSet == 2 {
835 tc.Error("Invalid parameterSet=%v", parameterSet)
837 tc.requestCount = subReqCount
841 //-----------------------------------------------------------------------------
843 //-----------------------------------------------------------------------------
844 func (tc *E2Stub) GetRESTSubsReqReportParams1(subReqCount int, actionDefinitionPresent bool, actionParamCount int) *RESTSubsReqParams {
846 reportParams := RESTSubsReqParams{}
847 reportParams.GetRESTSubsReqReportParams1(subReqCount, actionDefinitionPresent, actionParamCount, &tc.clientEndpoint, &tc.meid)
848 tc.requestCount = subReqCount
852 //-----------------------------------------------------------------------------
854 //-----------------------------------------------------------------------------
855 type RESTSubsReqParams struct {
856 SubsReqParams clientmodel.SubscriptionParams
859 func (p *RESTSubsReqParams) GetRESTSubsReqReportParams1(subReqCount int, actionDefinitionPresent bool, actionParamCount int, clientEndpoint *clientmodel.SubscriptionParamsClientEndpoint, meid *string) {
862 p.SubsReqParams.ClientEndpoint = clientEndpoint
863 p.SubsReqParams.Meid = meid
864 var rANFunctionID int64 = 33
865 p.SubsReqParams.RANFunctionID = &rANFunctionID
870 actionType := "report"
871 subsequestActioType := "continue"
872 timeToWait := "w10ms"
874 for requestCount := 0; requestCount < subReqCount; requestCount++ {
875 reqId := int64(requestCount) + 1
876 seqId := int64(requestCount) + 1
877 subscriptionDetail := &clientmodel.SubscriptionDetail{
880 EventTriggers: &clientmodel.EventTriggerDefinition{
881 OctetString: "1234" + strconv.Itoa(requestCount),
883 ActionToBeSetupList: clientmodel.ActionsToBeSetup{
884 &clientmodel.ActionToBeSetup{
886 ActionType: &actionType,
887 ActionDefinition: &clientmodel.ActionDefinition{
888 OctetString: "5678" + strconv.Itoa(requestCount),
890 SubsequentAction: &clientmodel.SubsequentAction{
891 SubsequentActionType: &subsequestActioType,
892 TimeToWait: &timeToWait,
897 p.SubsReqParams.SubscriptionDetails = append(p.SubsReqParams.SubscriptionDetails, subscriptionDetail)
902 func (p *RESTSubsReqParams) SetMeid(MEID string) {
903 p.SubsReqParams.Meid = &MEID
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
911 p.SubsReqParams.ClientEndpoint = &endpoint
914 func (p *RESTSubsReqParams) SetEndpointHost(host string) {
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)
923 p.SubsReqParams.ClientEndpoint.Host = host
926 func (p *RESTSubsReqParams) SetHTTPEndpoint(HTTP_port int64, host string) {
928 p.SubsReqParams.ClientEndpoint.HTTPPort = &HTTP_port
930 p.SetEndpointHost(host)
932 if p.SubsReqParams.ClientEndpoint.RMRPort == nil {
934 p.SubsReqParams.ClientEndpoint.RMRPort = &RMR_port
938 func (p *RESTSubsReqParams) SetSubActionTypes(actionType string) {
940 for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
941 for _, action := range subDetail.ActionToBeSetupList {
943 action.ActionType = &actionType
949 func (p *RESTSubsReqParams) SetSubActionIDs(actionId int64) {
951 for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
952 for _, action := range subDetail.ActionToBeSetupList {
954 action.ActionID = &actionId
960 func (p *RESTSubsReqParams) SetSubActionDefinition(actionDefinition string) {
962 for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
963 for _, action := range subDetail.ActionToBeSetupList {
965 action.ActionDefinition.OctetString = actionDefinition
971 func (p *RESTSubsReqParams) SetSubEventTriggerDefinition(eventTriggerDefinition string) {
973 for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
974 if subDetail != nil {
975 subDetail.EventTriggers.OctetString = eventTriggerDefinition
980 func (p *RESTSubsReqParams) AppendActionToActionToBeSetupList(actionId int64, actionType string, actionDefinition string, subsequentActionType string, timeToWait string) {
982 actionToBeSetup := &clientmodel.ActionToBeSetup{
984 ActionType: &actionType,
985 ActionDefinition: &clientmodel.ActionDefinition{
986 OctetString: actionDefinition,
988 SubsequentAction: &clientmodel.SubsequentAction{
989 SubsequentActionType: &subsequentActionType,
990 TimeToWait: &timeToWait,
994 for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
995 if subDetail != nil {
996 subDetail.ActionToBeSetupList = append(subDetail.ActionToBeSetupList, actionToBeSetup)
1001 func (p *RESTSubsReqParams) SetRMREndpoint(RMR_port int64, host string) {
1003 p.SubsReqParams.ClientEndpoint.RMRPort = &RMR_port
1005 p.SetEndpointHost(host)
1007 if p.SubsReqParams.ClientEndpoint.HTTPPort == nil {
1009 p.SubsReqParams.ClientEndpoint.HTTPPort = &HTTP_port
1013 func (p *RESTSubsReqParams) SetTimeToWait(timeToWait string) {
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
1024 //-----------------------------------------------------------------------------
1026 //-----------------------------------------------------------------------------
1027 func (tc *E2Stub) SendRESTSubsDelReq(t *testing.T, subscriptionID *string) {
1029 if *subscriptionID == "" {
1030 tc.Error("REST error in deleting subscriptions. Empty SubscriptionID = %s", *subscriptionID)
1032 tc.Info("REST deleting E2 subscriptions. SubscriptionID = %s", *subscriptionID)
1034 err := xapp.Subscription.Unsubscribe(*subscriptionID)
1036 tc.Error("REST Delete subscription failed %s", err.Error())
1038 tc.Info("REST delete subscription pushed to submgr successfully. SubscriptionID = %s", *subscriptionID)
1041 //-----------------------------------------------------------------------------
1043 //-----------------------------------------------------------------------------
1044 func (tc *E2Stub) GetRESTSubsReqPolicyParams(subReqCount int, actionDefinitionPresent bool, policyParamCount int) *RESTSubsReqParams {
1046 policyParams := RESTSubsReqParams{}
1047 policyParams.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount, &tc.clientEndpoint, &tc.meid)
1048 tc.requestCount = subReqCount
1049 return &policyParams
1052 //-----------------------------------------------------------------------------
1054 //-----------------------------------------------------------------------------
1055 func (p *RESTSubsReqParams) GetRESTSubsReqPolicyParams(subReqCount int, actionDefinitionPresent bool, policyParamCount int, clientEndpoint *clientmodel.SubscriptionParamsClientEndpoint, meid *string) {
1057 p.SubsReqParams.ClientEndpoint = clientEndpoint
1058 p.SubsReqParams.Meid = meid
1059 var rANFunctionID int64 = 33
1060 p.SubsReqParams.RANFunctionID = &rANFunctionID
1062 // reqId := int64(1)
1064 actionId := int64(1)
1065 actionType := "policy"
1066 subsequestActioType := "continue"
1067 timeToWait := "w10ms"
1069 for requestCount := 0; requestCount < subReqCount; requestCount++ {
1070 reqId := int64(requestCount) + 1
1072 subscriptionDetail := &clientmodel.SubscriptionDetail{
1073 RequestorID: &reqId,
1075 EventTriggers: &clientmodel.EventTriggerDefinition{
1076 OctetString: "1234" + strconv.Itoa(requestCount),
1078 ActionToBeSetupList: clientmodel.ActionsToBeSetup{
1079 &clientmodel.ActionToBeSetup{
1080 ActionID: &actionId,
1081 ActionType: &actionType,
1082 ActionDefinition: &clientmodel.ActionDefinition{
1083 OctetString: "5678" + strconv.Itoa(requestCount),
1085 SubsequentAction: &clientmodel.SubsequentAction{
1086 SubsequentActionType: &subsequestActioType,
1087 TimeToWait: &timeToWait,
1092 p.SubsReqParams.SubscriptionDetails = append(p.SubsReqParams.SubscriptionDetails, subscriptionDetail)