| /* |
| ================================================================================== |
| Copyright (c) 2019 AT&T Intellectual Property. |
| Copyright (c) 2019 Nokia |
| |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| ================================================================================== |
| */ |
| |
| package teststube2ap |
| |
| import ( |
| "fmt" |
| "runtime/debug" |
| "strconv" |
| "testing" |
| "time" |
| |
| "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap" |
| "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper" |
| "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststub" |
| clientmodel "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/clientmodel" |
| //"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models" |
| "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp" |
| ) |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| var e2asnpacker e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer() |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| type RmrTransactionId struct { |
| xid string |
| meid *xapp.RMRMeid |
| } |
| |
| type E2RestIds struct { |
| RestSubsId string |
| E2SubsId uint32 |
| ErrorCause string |
| ErrorSource string |
| TimeoutType string |
| } |
| |
| func (trans *RmrTransactionId) String() string { |
| meidstr := "N/A" |
| if trans.meid != nil { |
| meidstr = trans.meid.String() |
| } |
| return "trans(" + trans.xid + "/" + meidstr + ")" |
| } |
| |
| type E2Stub struct { |
| teststub.RmrStubControl |
| xid_seq uint64 |
| subscriptionId string |
| requestCount int |
| CallBackNotification chan int64 |
| RESTNotification chan uint32 |
| CallBackListedNotifications chan E2RestIds |
| ListedRESTNotifications chan E2RestIds |
| clientEndpoint clientmodel.SubscriptionParamsClientEndpoint |
| meid string |
| restSubsIdList []string |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func CreateNewE2Stub(desc string, srcId teststub.RmrSrcId, rtgSvc teststub.RmrRtgSvc, stat string, mtypeseed int, ranName string, host string, RMRPort int64, HTTPPort int64) *E2Stub { |
| tc := &E2Stub{} |
| tc.RmrStubControl.Init(desc, srcId, rtgSvc, stat, mtypeseed) |
| tc.xid_seq = 1 |
| tc.SetCheckXid(true) |
| tc.CallBackNotification = make(chan int64) |
| tc.RESTNotification = make(chan uint32) |
| tc.CallBackListedNotifications = make(chan E2RestIds) |
| tc.ListedRESTNotifications = make(chan E2RestIds, 2) |
| var endPoint clientmodel.SubscriptionParamsClientEndpoint |
| endPoint.Host = host |
| endPoint.HTTPPort = &HTTPPort |
| endPoint.RMRPort = &RMRPort |
| tc.clientEndpoint = endPoint |
| tc.meid = ranName |
| return tc |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func CreateNewE2termStub(desc string, srcId teststub.RmrSrcId, rtgSvc teststub.RmrRtgSvc, stat string, mtypeseed int) *E2Stub { |
| tc := &E2Stub{} |
| tc.RmrStubControl.Init(desc, srcId, rtgSvc, stat, mtypeseed) |
| tc.xid_seq = 1 |
| tc.SetCheckXid(false) |
| return tc |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) NewRmrTransactionId(xid string, ranname string) *RmrTransactionId { |
| trans := &RmrTransactionId{} |
| if len(xid) == 0 { |
| trans.xid = tc.GetDesc() + "_XID_" + strconv.FormatUint(uint64(tc.xid_seq), 10) |
| tc.xid_seq++ |
| } else { |
| trans.xid = xid |
| } |
| trans.meid = &xapp.RMRMeid{RanName: ranname} |
| tc.Debug("New test %s", trans.String()) |
| return trans |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| type E2StubSubsReqParams struct { |
| Req *e2ap.E2APSubscriptionRequest |
| } |
| |
| func (p *E2StubSubsReqParams) Init() { |
| p.Req = &e2ap.E2APSubscriptionRequest{} |
| |
| p.Req.RequestId.Id = 1 |
| p.Req.RequestId.InstanceId = 0 |
| p.Req.FunctionId = 1 |
| |
| // gnb -> enb outgoing |
| // enb -> gnb incoming |
| // X2 36423-f40.doc |
| p.Req.EventTriggerDefinition.Data.Length = 1 |
| p.Req.EventTriggerDefinition.Data.Data = make([]uint8, p.Req.EventTriggerDefinition.Data.Length) |
| p.Req.EventTriggerDefinition.Data.Data[0] = 1 |
| |
| p.Req.ActionSetups = make([]e2ap.ActionToBeSetupItem, 1) |
| |
| p.Req.ActionSetups[0].ActionId = 0 |
| p.Req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeReport |
| p.Req.ActionSetups[0].RicActionDefinitionPresent = true |
| |
| p.Req.ActionSetups[0].ActionDefinitionChoice.Data.Length = 1 |
| p.Req.ActionSetups[0].ActionDefinitionChoice.Data.Data = make([]uint8, p.Req.ActionSetups[0].ActionDefinitionChoice.Data.Length) |
| p.Req.ActionSetups[0].ActionDefinitionChoice.Data.Data[0] = 1 |
| |
| p.Req.ActionSetups[0].SubsequentAction.Present = true |
| p.Req.ActionSetups[0].SubsequentAction.Type = e2ap.E2AP_SubSeqActionTypeContinue |
| p.Req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitZero |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| |
| type E2StubSubsFailParams struct { |
| Req *e2ap.E2APSubscriptionRequest |
| Fail *e2ap.E2APSubscriptionFailure |
| } |
| |
| func (p *E2StubSubsFailParams) Set(req *e2ap.E2APSubscriptionRequest) { |
| p.Req = req |
| |
| p.Fail = &e2ap.E2APSubscriptionFailure{} |
| p.Fail.RequestId.Id = p.Req.RequestId.Id |
| p.Fail.RequestId.InstanceId = p.Req.RequestId.InstanceId |
| p.Fail.FunctionId = p.Req.FunctionId |
| p.Fail.ActionNotAdmittedList.Items = make([]e2ap.ActionNotAdmittedItem, len(p.Req.ActionSetups)) |
| for index := int(0); index < len(p.Fail.ActionNotAdmittedList.Items); index++ { |
| p.Fail.ActionNotAdmittedList.Items[index].ActionId = p.Req.ActionSetups[index].ActionId |
| p.SetCauseVal(index, 5, 1) |
| } |
| } |
| |
| func (p *E2StubSubsFailParams) SetCauseVal(ind int, content uint8, causeval uint8) { |
| |
| if ind < 0 { |
| for index := int(0); index < len(p.Fail.ActionNotAdmittedList.Items); index++ { |
| p.Fail.ActionNotAdmittedList.Items[index].Cause.Content = content |
| p.Fail.ActionNotAdmittedList.Items[index].Cause.Value = causeval |
| } |
| return |
| } |
| p.Fail.ActionNotAdmittedList.Items[ind].Cause.Content = content |
| p.Fail.ActionNotAdmittedList.Items[ind].Cause.Value = causeval |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| |
| func (tc *E2Stub) SendSubsReq(t *testing.T, rparams *E2StubSubsReqParams, oldTrans *RmrTransactionId) *RmrTransactionId { |
| |
| trans := oldTrans |
| if oldTrans == nil { |
| trans = tc.NewRmrTransactionId("", "RAN_NAME_1") |
| } |
| |
| tc.Debug("SendSubsReq %s", trans.String()) |
| e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest() |
| |
| //--------------------------------- |
| // xapp activity: Send Subs Req |
| //--------------------------------- |
| myparams := rparams |
| |
| if myparams == nil { |
| myparams = &E2StubSubsReqParams{} |
| myparams.Init() |
| } |
| |
| err, packedMsg := e2SubsReq.Pack(myparams.Req) |
| if err != nil { |
| tc.TestError(t, "pack NOK %s %s", trans.String(), err.Error()) |
| return nil |
| } |
| tc.Debug("%s %s", trans.String(), e2SubsReq.String()) |
| |
| params := &xapp.RMRParams{} |
| params.Mtype = xapp.RIC_SUB_REQ |
| params.SubId = -1 |
| params.Payload = packedMsg.Buf |
| params.PayloadLen = len(packedMsg.Buf) |
| params.Meid = trans.meid |
| params.Xid = trans.xid |
| params.Mbuf = nil |
| |
| tc.Debug("SEND SUB REQ: %s", params.String()) |
| snderr := tc.SendWithRetry(params, false, 5) |
| if snderr != nil { |
| tc.TestError(t, "RMR SEND FAILED: %s %s", trans.String(), snderr.Error()) |
| return nil |
| } |
| return trans |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) RecvSubsReq(t *testing.T) (*e2ap.E2APSubscriptionRequest, *xapp.RMRParams) { |
| tc.Debug("RecvSubsReq") |
| e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest() |
| |
| //--------------------------------- |
| // e2term activity: Recv Subs Req |
| //--------------------------------- |
| msg := tc.WaitMsg(15) |
| if msg != nil { |
| if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] { |
| tc.TestError(t, "Received wrong mtype expected %s got %s, error", "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype]) |
| } else { |
| tc.Debug("Recv Subs Req") |
| packedData := &e2ap.PackedData{} |
| packedData.Buf = msg.Payload |
| unpackerr, req := e2SubsReq.UnPack(packedData) |
| if unpackerr != nil { |
| tc.TestError(t, "RIC_SUB_REQ unpack failed err: %s", unpackerr.Error()) |
| } |
| return req, msg |
| } |
| } else { |
| tc.TestError(t, "Not Received msg within %d secs", 15) |
| } |
| |
| return nil, nil |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) SendSubsResp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *xapp.RMRParams) { |
| tc.Debug("SendSubsResp") |
| e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse() |
| |
| //--------------------------------- |
| // e2term activity: Send Subs Resp |
| //--------------------------------- |
| resp := &e2ap.E2APSubscriptionResponse{} |
| |
| resp.RequestId.Id = req.RequestId.Id |
| resp.RequestId.InstanceId = req.RequestId.InstanceId |
| resp.FunctionId = req.FunctionId |
| |
| resp.ActionAdmittedList.Items = make([]e2ap.ActionAdmittedItem, len(req.ActionSetups)) |
| for index := int(0); index < len(req.ActionSetups); index++ { |
| resp.ActionAdmittedList.Items[index].ActionId = req.ActionSetups[index].ActionId |
| } |
| |
| for index := uint64(0); index < 1; index++ { |
| item := e2ap.ActionNotAdmittedItem{} |
| item.ActionId = index |
| item.Cause.Content = 1 |
| item.Cause.Value = 1 |
| resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item) |
| } |
| |
| packerr, packedMsg := e2SubsResp.Pack(resp) |
| if packerr != nil { |
| tc.TestError(t, "pack NOK %s", packerr.Error()) |
| } |
| tc.Debug("%s", e2SubsResp.String()) |
| |
| params := &xapp.RMRParams{} |
| params.Mtype = xapp.RIC_SUB_RESP |
| //params.SubId = msg.SubId |
| params.SubId = -1 |
| params.Payload = packedMsg.Buf |
| params.PayloadLen = len(packedMsg.Buf) |
| params.Meid = msg.Meid |
| //params.Xid = msg.Xid |
| params.Mbuf = nil |
| |
| tc.Debug("SEND SUB RESP: %s", params.String()) |
| snderr := tc.SendWithRetry(params, false, 5) |
| if snderr != nil { |
| tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error()) |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) SendInvalidE2Asn1Resp(t *testing.T, msg *xapp.RMRParams, msgType int) { |
| |
| params := &xapp.RMRParams{} |
| params.Mtype = msgType |
| params.SubId = -1 |
| params.Payload = []byte{1, 2, 3, 4, 5} |
| params.PayloadLen = 5 |
| params.Meid = msg.Meid |
| params.Xid = "" |
| params.Mbuf = nil |
| |
| if params.Mtype == xapp.RIC_SUB_RESP { |
| tc.Debug("SEND INVALID ASN.1 SUB RESP") |
| |
| } else if params.Mtype == xapp.RIC_SUB_FAILURE { |
| tc.Debug("SEND INVALID ASN.1 SUB FAILURE") |
| |
| } else if params.Mtype == xapp.RIC_SUB_DEL_RESP { |
| tc.Debug("SEND INVALID ASN.1 SUB DEL RESP") |
| |
| } else if params.Mtype == xapp.RIC_SUB_DEL_FAILURE { |
| tc.Debug("SEND INVALID ASN.1 SUB DEL FAILURE") |
| } |
| snderr := tc.SendWithRetry(params, false, 5) |
| if snderr != nil { |
| tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error()) |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) RecvSubsResp(t *testing.T, trans *RmrTransactionId) uint32 { |
| tc.Debug("RecvSubsResp") |
| e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse() |
| var e2SubsId uint32 |
| |
| //--------------------------------- |
| // xapp activity: Recv Subs Resp |
| //--------------------------------- |
| msg := tc.WaitMsg(15) |
| if msg != nil { |
| if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] { |
| tc.TestError(t, "Received RIC_SUB_RESP wrong mtype expected %s got %s, error", "RIC_SUB_RESP", xapp.RicMessageTypeToName[msg.Mtype]) |
| return 0 |
| } else if msg.Xid != trans.xid { |
| tc.TestError(t, "Received RIC_SUB_RESP wrong xid expected %s got %s, error", trans.xid, msg.Xid) |
| return 0 |
| } else { |
| packedData := &e2ap.PackedData{} |
| packedData.Buf = msg.Payload |
| if msg.SubId > 0 { |
| e2SubsId = uint32(msg.SubId) |
| } else { |
| e2SubsId = 0 |
| } |
| unpackerr, resp := e2SubsResp.UnPack(packedData) |
| if unpackerr != nil { |
| tc.TestError(t, "RIC_SUB_RESP unpack failed err: %s", unpackerr.Error()) |
| } |
| tc.Debug("Recv Subs Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId) |
| return e2SubsId |
| } |
| } else { |
| tc.TestError(t, "Not Received msg within %d secs", 15) |
| } |
| return 0 |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| |
| func (tc *E2Stub) SendSubsFail(t *testing.T, fparams *E2StubSubsFailParams, msg *xapp.RMRParams) { |
| tc.Debug("SendSubsFail") |
| e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure() |
| |
| //--------------------------------- |
| // e2term activity: Send Subs Fail |
| //--------------------------------- |
| packerr, packedMsg := e2SubsFail.Pack(fparams.Fail) |
| if packerr != nil { |
| tc.TestError(t, "pack NOK %s", packerr.Error()) |
| } |
| tc.Debug("%s", e2SubsFail.String()) |
| |
| params := &xapp.RMRParams{} |
| params.Mtype = xapp.RIC_SUB_FAILURE |
| params.SubId = msg.SubId |
| params.Payload = packedMsg.Buf |
| params.PayloadLen = len(packedMsg.Buf) |
| params.Meid = msg.Meid |
| params.Xid = msg.Xid |
| params.Mbuf = nil |
| |
| tc.Debug("SEND SUB FAIL: %s", params.String()) |
| snderr := tc.SendWithRetry(params, false, 5) |
| if snderr != nil { |
| tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error()) |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) RecvSubsFail(t *testing.T, trans *RmrTransactionId) uint32 { |
| tc.Debug("RecvSubsFail") |
| e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure() |
| var e2SubsId uint32 |
| |
| //------------------------------- |
| // xapp activity: Recv Subs Fail |
| //------------------------------- |
| msg := tc.WaitMsg(15) |
| if msg != nil { |
| if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_FAILURE"] { |
| tc.TestError(t, "Received RIC_SUB_FAILURE wrong mtype expected %s got %s, error", "RIC_SUB_FAILURE", xapp.RicMessageTypeToName[msg.Mtype]) |
| return 0 |
| } else if msg.Xid != trans.xid { |
| tc.TestError(t, "Received RIC_SUB_FAILURE wrong xid expected %s got %s, error", trans.xid, msg.Xid) |
| return 0 |
| } else { |
| packedData := &e2ap.PackedData{} |
| packedData.Buf = msg.Payload |
| if msg.SubId > 0 { |
| e2SubsId = uint32(msg.SubId) |
| } else { |
| e2SubsId = 0 |
| } |
| unpackerr, resp := e2SubsFail.UnPack(packedData) |
| if unpackerr != nil { |
| tc.TestError(t, "RIC_SUB_FAILURE unpack failed err: %s", unpackerr.Error()) |
| } |
| tc.Debug("Recv Subs Fail rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId) |
| return e2SubsId |
| } |
| } else { |
| tc.TestError(t, "Not Received msg within %d secs", 15) |
| } |
| return 0 |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) SendSubsDelReq(t *testing.T, oldTrans *RmrTransactionId, e2SubsId uint32) *RmrTransactionId { |
| |
| trans := oldTrans |
| if oldTrans == nil { |
| trans = tc.NewRmrTransactionId("", "RAN_NAME_1") |
| } |
| |
| tc.Debug("SendSubsDelReq %s", trans.String()) |
| e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest() |
| //--------------------------------- |
| // xapp activity: Send Subs Del Req |
| //--------------------------------- |
| req := &e2ap.E2APSubscriptionDeleteRequest{} |
| req.RequestId.Id = 1 |
| req.RequestId.InstanceId = e2SubsId |
| req.FunctionId = 1 |
| |
| err, packedMsg := e2SubsDelReq.Pack(req) |
| if err != nil { |
| tc.TestError(t, "pack NOK %s %s", trans.String(), err.Error()) |
| return nil |
| } |
| tc.Debug("%s %s", trans.String(), e2SubsDelReq.String()) |
| |
| params := &xapp.RMRParams{} |
| params.Mtype = xapp.RIC_SUB_DEL_REQ |
| params.SubId = int(e2SubsId) |
| params.Payload = packedMsg.Buf |
| params.PayloadLen = len(packedMsg.Buf) |
| params.Meid = trans.meid |
| params.Xid = trans.xid |
| params.Mbuf = nil |
| |
| tc.Debug("SEND SUB DEL REQ: %s", params.String()) |
| snderr := tc.SendWithRetry(params, false, 5) |
| if snderr != nil { |
| tc.TestError(t, "RMR SEND FAILED: %s %s", trans.String(), snderr.Error()) |
| return nil |
| } |
| return trans |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) RecvSubsDelReq(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *xapp.RMRParams) { |
| tc.Debug("RecvSubsDelReq") |
| e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest() |
| |
| //--------------------------------- |
| // e2term activity: Recv Subs Del Req |
| //--------------------------------- |
| msg := tc.WaitMsg(15) |
| if msg != nil { |
| if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] { |
| tc.TestError(t, "Received wrong mtype expected %s got %s, error", "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype]) |
| } else { |
| tc.Debug("Recv Subs Del Req") |
| |
| packedData := &e2ap.PackedData{} |
| packedData.Buf = msg.Payload |
| unpackerr, req := e2SubsDelReq.UnPack(packedData) |
| if unpackerr != nil { |
| tc.TestError(t, "RIC_SUB_DEL_REQ unpack failed err: %s", unpackerr.Error()) |
| } |
| return req, msg |
| } |
| } else { |
| tc.TestError(t, "Not Received msg within %d secs", 15) |
| } |
| return nil, nil |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) SendSubsDelResp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) { |
| tc.Debug("SendSubsDelResp") |
| e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse() |
| |
| //--------------------------------- |
| // e2term activity: Send Subs Del Resp |
| //--------------------------------- |
| resp := &e2ap.E2APSubscriptionDeleteResponse{} |
| resp.RequestId.Id = req.RequestId.Id |
| resp.RequestId.InstanceId = req.RequestId.InstanceId |
| resp.FunctionId = req.FunctionId |
| |
| packerr, packedMsg := e2SubsDelResp.Pack(resp) |
| if packerr != nil { |
| tc.TestError(t, "pack NOK %s", packerr.Error()) |
| } |
| tc.Debug("%s", e2SubsDelResp.String()) |
| |
| params := &xapp.RMRParams{} |
| params.Mtype = xapp.RIC_SUB_DEL_RESP |
| params.SubId = msg.SubId |
| params.Payload = packedMsg.Buf |
| params.PayloadLen = len(packedMsg.Buf) |
| params.Meid = msg.Meid |
| params.Xid = msg.Xid |
| params.Mbuf = nil |
| |
| tc.Debug("SEND SUB DEL RESP: %s", params.String()) |
| snderr := tc.SendWithRetry(params, false, 5) |
| if snderr != nil { |
| tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error()) |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) RecvSubsDelResp(t *testing.T, trans *RmrTransactionId) { |
| tc.Debug("RecvSubsDelResp") |
| e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse() |
| |
| //--------------------------------- |
| // xapp activity: Recv Subs Del Resp |
| //--------------------------------- |
| msg := tc.WaitMsg(15) |
| if msg != nil { |
| if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] { |
| tc.TestError(t, "Received RIC_SUB_DEL_RESP wrong mtype expected %s got %s, error", "RIC_SUB_DEL_RESP", xapp.RicMessageTypeToName[msg.Mtype]) |
| return |
| } else if trans != nil && msg.Xid != trans.xid { |
| tc.TestError(t, "Received RIC_SUB_DEL_RESP wrong xid expected %s got %s, error", trans.xid, msg.Xid) |
| return |
| } else { |
| packedData := &e2ap.PackedData{} |
| packedData.Buf = msg.Payload |
| unpackerr, resp := e2SubsDelResp.UnPack(packedData) |
| if unpackerr != nil { |
| tc.TestError(t, "RIC_SUB_DEL_RESP unpack failed err: %s", unpackerr.Error()) |
| } |
| tc.Debug("Recv Subs Del Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId) |
| return |
| } |
| } else { |
| tc.TestError(t, "Not Received msg within %d secs", 15) |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) SendSubsDelFail(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) { |
| tc.Debug("SendSubsDelFail") |
| e2SubsDelFail := e2asnpacker.NewPackerSubscriptionDeleteFailure() |
| |
| //--------------------------------- |
| // e2term activity: Send Subs Del Fail |
| //--------------------------------- |
| resp := &e2ap.E2APSubscriptionDeleteFailure{} |
| resp.RequestId.Id = req.RequestId.Id |
| resp.RequestId.InstanceId = req.RequestId.InstanceId |
| resp.FunctionId = req.FunctionId |
| resp.Cause.Content = 5 // CauseMisc |
| resp.Cause.Value = 3 // unspecified |
| |
| packerr, packedMsg := e2SubsDelFail.Pack(resp) |
| if packerr != nil { |
| tc.TestError(t, "pack NOK %s", packerr.Error()) |
| } |
| tc.Debug("%s", e2SubsDelFail.String()) |
| |
| params := &xapp.RMRParams{} |
| params.Mtype = xapp.RIC_SUB_DEL_FAILURE |
| params.SubId = msg.SubId |
| params.Payload = packedMsg.Buf |
| params.PayloadLen = len(packedMsg.Buf) |
| params.Meid = msg.Meid |
| params.Xid = msg.Xid |
| params.Mbuf = nil |
| |
| tc.Debug("SEND SUB DEL FAIL: %s", params.String()) |
| snderr := tc.SendWithRetry(params, false, 5) |
| if snderr != nil { |
| tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error()) |
| } |
| } |
| |
| // REST code below all |
| |
| /*****************************************************************************/ |
| // REST interface specific functions are below |
| |
| //----------------------------------------------------------------------------- |
| // Callback handler for subscription response notifications |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) SubscriptionRespHandler(resp *clientmodel.SubscriptionResponse) { |
| |
| if tc.subscriptionId == "SUBSCRIPTIONID NOT SET" { |
| tc.Debug("REST notification received for %v while no SubscriptionID was not set for E2EventInstanceID=%v, XappEventInstanceID=%v (%v)", |
| *resp.SubscriptionID, *resp.SubscriptionInstances[0].E2EventInstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID, tc) |
| tc.CallBackNotification <- *resp.SubscriptionInstances[0].E2EventInstanceID |
| } else if tc.subscriptionId == *resp.SubscriptionID { |
| tc.Debug("REST notification received SubscriptionID=%s, E2EventInstanceID=%v, RequestorID=%v (%v)", |
| *resp.SubscriptionID, *resp.SubscriptionInstances[0].E2EventInstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID, tc) |
| tc.CallBackNotification <- *resp.SubscriptionInstances[0].E2EventInstanceID |
| } else { |
| tc.Debug("MISMATCHING REST notification received SubscriptionID=%s<>%s, E2EventInstanceID=%v, XappEventInstanceID=%v (%v)", |
| tc.subscriptionId, *resp.SubscriptionID, *resp.SubscriptionInstances[0].E2EventInstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID, tc) |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| |
| func (tc *E2Stub) ExpectRESTNotification(t *testing.T, restSubsId string) { |
| tc.expectNotification(t, restSubsId, "") |
| } |
| |
| func (tc *E2Stub) ExpectRESTNotificationOk(t *testing.T, restSubsId string) { |
| tc.expectNotification(t, restSubsId, "allOk") |
| } |
| |
| func (tc *E2Stub) ExpectRESTNotificationNok(t *testing.T, restSubsId string, expectError string) { |
| tc.expectNotification(t, restSubsId, expectError) |
| } |
| |
| func (tc *E2Stub) expectNotification(t *testing.T, restSubsId string, expectError string) { |
| |
| tc.Debug("### 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) |
| tc.restSubsIdList = []string{restSubsId} |
| xapp.Subscription.SetResponseCB(tc.ListedRestNotifHandler) |
| if tc.requestCount == 0 { |
| tc.TestError(t, "### NO REST notifications SET received for endpoint=%s, request zount ZERO! (%v)", tc.clientEndpoint, *tc) |
| } |
| go func() { |
| select { |
| case e2Ids := <-tc.CallBackListedNotifications: |
| if tc.requestCount == 0 { |
| tc.TestError(t, "### REST notification count unexpectedly ZERO for %s (%v)", restSubsId, *tc) |
| } else if e2Ids.RestSubsId != restSubsId { |
| tc.TestError(t, "### Unexpected REST notifications received, expected %s bunt got %s instead| (%v)", e2Ids.RestSubsId, restSubsId, *tc) |
| } else if e2Ids.ErrorCause == "" && expectError == "allFail" { |
| tc.TestError(t, "### Unexpected ok cause received from REST notifications |%s:%s| (%v)", e2Ids.RestSubsId, restSubsId, *tc) |
| } else if e2Ids.ErrorCause != "" && expectError == "allOk" { |
| tc.TestError(t, "### Unexpected ErrorCause: (%s), ErrorSource: (%s), TimeoutType: (%s) received from REST notifications |%s:%s| (%v)", e2Ids.ErrorCause, e2Ids.ErrorSource, e2Ids.TimeoutType, e2Ids.RestSubsId, restSubsId, *tc) |
| } else { |
| tc.requestCount-- |
| if tc.requestCount == 0 { |
| tc.Debug("### All expected REST notifications received for %s (%v)", e2Ids.RestSubsId, *tc) |
| } else { |
| tc.Debug("### Expected REST notifications received for %s, (%v)", e2Ids.RestSubsId, *tc) |
| } |
| if e2Ids.ErrorCause != "" && expectError == "allFail" { |
| tc.Debug("### REST Notification: RestSubsId: %s, ErrorCause: %s, ErrorSource: (%s), TimeoutType: (%s)", e2Ids.RestSubsId, e2Ids.ErrorCause, e2Ids.ErrorSource, e2Ids.TimeoutType) |
| } |
| tc.Debug("### REST Notification received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId) |
| tc.ListedRESTNotifications <- e2Ids |
| if len(tc.ListedRESTNotifications) > 1 { |
| panic("expectNotification - ListedRESTNotifications stacking up") |
| } |
| } |
| case <-time.After(15 * time.Second): |
| err := fmt.Errorf("### Timeout 15s expired while expecting REST notification for subsId: %v", restSubsId) |
| tc.TestError(t, "%s", err.Error()) |
| } |
| }() |
| } |
| |
| func (tc *E2Stub) WaitRESTNotification(t *testing.T, restSubsId string) uint32 { |
| |
| stack := string(debug.Stack()) |
| |
| select { |
| case e2SubsId := <-tc.ListedRESTNotifications: |
| if e2SubsId.RestSubsId == restSubsId { |
| tc.Debug("### Expected REST notifications received %s, e2SubsId %v for endpoint=%v, (%v)", e2SubsId.RestSubsId, e2SubsId.E2SubsId, tc.clientEndpoint, *tc) |
| return e2SubsId.E2SubsId |
| } else { |
| tc.TestError(t, "### Unexpected REST notification %s received, expected %v for endpoint=%v, (%v)", e2SubsId.RestSubsId, restSubsId, tc.clientEndpoint, *tc) |
| xapp.Logger.Debug("CALL STACK:\n %s", stack) |
| return 0 |
| } |
| case <-time.After(15 * time.Second): |
| err := fmt.Errorf("### Timeout 15s expired while waiting REST notification for subsId: %v", restSubsId) |
| tc.TestError(t, "%s", err.Error()) |
| xapp.Logger.Debug("CALL STACK:\n %s", stack) |
| panic("WaitRESTNotification - timeout error") |
| } |
| } |
| |
| // Note, this function should be followed by a handling of <-xappConn1.RESTNotification. |
| func (tc *E2Stub) ExpectAnyNotification(t *testing.T) { |
| go func() { |
| tc.Debug("### Started waiting ANY REST notifications received for endpoint=%s, (%v)", tc.clientEndpoint, tc) |
| select { |
| case e2SubsId := <-tc.CallBackNotification: |
| tc.Debug("### ANY REST notifications received e2SubsId %v for endpoint=%s, (%v) via CallBackNotification", e2SubsId, tc.clientEndpoint, tc) |
| tc.RESTNotification <- (uint32)(e2SubsId) |
| case <-time.After(15 * time.Second): |
| err := fmt.Errorf("### Timeout 15s expired while waiting ANY REST notification") |
| tc.TestError(t, "%s", err.Error()) |
| tc.RESTNotification <- 0 |
| } |
| }() |
| } |
| |
| func (tc *E2Stub) WaitAnyRESTNotification(t *testing.T) uint32 { |
| |
| select { |
| case e2SubsId := <-tc.RESTNotification: |
| tc.Debug("### Expected ANY REST notification received - e2SubsId %v for endpoint=%s, (%v)", e2SubsId, tc.clientEndpoint, tc) |
| return e2SubsId |
| |
| case <-time.After(15 * time.Second): |
| err := fmt.Errorf("### Timeout 15s expired while waiting ANY REST notification") |
| tc.TestError(t, "%s", err.Error()) |
| panic("WaitRESTNotification - timeout error") |
| } |
| } |
| |
| func (tc *E2Stub) ListedRestNotifHandler(resp *clientmodel.SubscriptionResponse) { |
| |
| if len(tc.restSubsIdList) == 0 { |
| tc.Error("Unexpected listed REST notifications received for endpoint=%v, expected restSubsId list size was ZERO!", tc.clientEndpoint) |
| } else { |
| for i, subsId := range tc.restSubsIdList { |
| if *resp.SubscriptionID == subsId { |
| //tc.Debug("Listed REST notifications received SubscriptionID=%s, InstanceID=%v, XappEventInstanceID=%v", |
| // *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID) |
| |
| tc.restSubsIdList = append(tc.restSubsIdList[:i], tc.restSubsIdList[i+1:]...) |
| //tc.Debug("Removed %s from Listed REST notifications, %v entries left", *resp.SubscriptionID, len(tc.restSubsIdList)) |
| |
| // if resp.SubscriptionInstances[0].ErrorCause != nil { |
| tc.CallBackListedNotifications <- *tc.GetE2RestIds(resp) |
| // } else { |
| // tc.CallBackListedNotifications <- E2RestIds{*resp.SubscriptionID, uint32(*resp.SubscriptionInstances[0].E2EventInstanceID), "", "", ""} |
| // } |
| |
| if len(tc.restSubsIdList) == 0 { |
| tc.Debug("All listed REST notifications received for endpoint=%v", tc.clientEndpoint) |
| } |
| |
| return |
| } |
| } |
| tc.Error("UNKONWN REST notification received SubscriptionID=%s<>%s, InstanceID=%v, XappEventInstanceID=%v (%v)", |
| tc.subscriptionId, *resp.SubscriptionID, *resp.SubscriptionInstances[0].E2EventInstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID, tc) |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) GetE2RestIds(resp *clientmodel.SubscriptionResponse) *E2RestIds { |
| |
| e2RestIds := &E2RestIds{} |
| if resp != nil { |
| if resp.SubscriptionID != nil { |
| e2RestIds.RestSubsId = *resp.SubscriptionID |
| } |
| if resp.SubscriptionInstances != nil { |
| if resp.SubscriptionInstances[0].E2EventInstanceID != nil { |
| e2RestIds.E2SubsId = uint32(*resp.SubscriptionInstances[0].E2EventInstanceID) |
| } |
| e2RestIds.ErrorCause = resp.SubscriptionInstances[0].ErrorCause |
| e2RestIds.ErrorSource = resp.SubscriptionInstances[0].ErrorSource |
| e2RestIds.TimeoutType = resp.SubscriptionInstances[0].TimeoutType |
| } |
| } |
| return e2RestIds |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) WaitListedRestNotifications(t *testing.T, restSubsIds []string) { |
| tc.Debug("Started to wait REST notifications %v on port %v f(RMR port %v)", restSubsIds, *tc.clientEndpoint.HTTPPort, *tc.clientEndpoint.RMRPort) |
| |
| tc.restSubsIdList = restSubsIds |
| xapp.Subscription.SetResponseCB(tc.ListedRestNotifHandler) |
| |
| for i := 0; i < len(restSubsIds); i++ { |
| go func() { |
| select { |
| case e2Ids := <-tc.CallBackListedNotifications: |
| tc.Debug("Listed Notification waiter received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId) |
| tc.ListedRESTNotifications <- e2Ids |
| case <-time.After(15 * time.Second): |
| err := fmt.Errorf("Timeout 15s expired while waiting Listed REST notification") |
| tc.TestError(t, "%s", err.Error()) |
| tc.RESTNotification <- 0 |
| } |
| }() |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) SendRESTSubsReq(t *testing.T, params *RESTSubsReqParams) string { |
| tc.Debug("======== Posting REST subscriptions to Submgr ======") |
| |
| if params == nil { |
| tc.Debug("SendRESTReportSubsReq: params == nil") |
| return "" |
| } |
| |
| tc.subscriptionId = "SUBSCRIPTIONID NOT SET" |
| |
| resp, err := xapp.Subscription.Subscribe(¶ms.SubsReqParams) |
| if err != nil { |
| // Swagger generated code makes checks for the values that are inserted the subscription function |
| // If error cause is unknown and POST is not done, the problem is in the inserted values |
| tc.Error("======== REST subscription request failed %s ========", err.Error()) |
| return "" |
| } |
| tc.subscriptionId = *resp.SubscriptionID |
| tc.Debug("======== REST subscriptions posted successfully. SubscriptionID = %s, RequestCount = %v ========", *resp.SubscriptionID, tc.requestCount) |
| return *resp.SubscriptionID |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) GetRESTSubsReqReportParams(subReqCount int) *RESTSubsReqParams { |
| |
| reportParams := RESTSubsReqParams{} |
| reportParams.GetRESTSubsReqReportParams(subReqCount, &tc.clientEndpoint, &tc.meid) |
| tc.requestCount = subReqCount |
| return &reportParams |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| type RESTSubsReqParams struct { |
| SubsReqParams clientmodel.SubscriptionParams |
| } |
| |
| func (p *RESTSubsReqParams) GetRESTSubsReqReportParams(subReqCount int, clientEndpoint *clientmodel.SubscriptionParamsClientEndpoint, meid *string) { |
| |
| // E2SM-gNB-X2 |
| p.SubsReqParams.ClientEndpoint = clientEndpoint |
| p.SubsReqParams.Meid = meid |
| var rANFunctionID int64 = 33 |
| p.SubsReqParams.RANFunctionID = &rANFunctionID |
| |
| actionId := int64(1) |
| actionType := "report" |
| subsequestActioType := "continue" |
| timeToWait := "w10ms" |
| |
| for requestCount := 0; requestCount < subReqCount; requestCount++ { |
| reqId := int64(requestCount) + 1 |
| subscriptionDetail := &clientmodel.SubscriptionDetail{ |
| XappEventInstanceID: &reqId, |
| EventTriggers: clientmodel.EventTriggerDefinition{ |
| int64(1234 + requestCount), |
| }, |
| ActionToBeSetupList: clientmodel.ActionsToBeSetup{ |
| &clientmodel.ActionToBeSetup{ |
| ActionID: &actionId, |
| ActionType: &actionType, |
| ActionDefinition: clientmodel.ActionDefinition{ |
| int64(5678 + requestCount), |
| }, |
| SubsequentAction: &clientmodel.SubsequentAction{ |
| SubsequentActionType: &subsequestActioType, |
| TimeToWait: &timeToWait, |
| }, |
| }, |
| }, |
| } |
| p.SubsReqParams.SubscriptionDetails = append(p.SubsReqParams.SubscriptionDetails, subscriptionDetail) |
| } |
| |
| } |
| |
| func (p *RESTSubsReqParams) SetMeid(MEID string) { |
| p.SubsReqParams.Meid = &MEID |
| } |
| |
| func (p *RESTSubsReqParams) SetEndpoint(HTTP_port int64, RMR_port int64, host string) { |
| var endpoint clientmodel.SubscriptionParamsClientEndpoint |
| endpoint.HTTPPort = &HTTP_port |
| endpoint.RMRPort = &RMR_port |
| endpoint.Host = host |
| p.SubsReqParams.ClientEndpoint = &endpoint |
| } |
| |
| func (p *RESTSubsReqParams) SetEndpointHost(host string) { |
| |
| if p.SubsReqParams.ClientEndpoint.Host != "" { |
| if p.SubsReqParams.ClientEndpoint.Host != host { |
| // Renaming toto, print something tc.Debug("Posting REST subscription request to Submgr") |
| err := fmt.Errorf("hostname change attempt: %s -> %s", p.SubsReqParams.ClientEndpoint.Host, host) |
| panic(err) |
| } |
| } |
| p.SubsReqParams.ClientEndpoint.Host = host |
| } |
| |
| func (p *RESTSubsReqParams) SetHTTPEndpoint(HTTP_port int64, host string) { |
| |
| p.SubsReqParams.ClientEndpoint.HTTPPort = &HTTP_port |
| |
| p.SetEndpointHost(host) |
| |
| if p.SubsReqParams.ClientEndpoint.RMRPort == nil { |
| var RMR_port int64 |
| p.SubsReqParams.ClientEndpoint.RMRPort = &RMR_port |
| } |
| } |
| |
| func (p *RESTSubsReqParams) SetE2SubscriptionDirectives(E2RetryCount int64, E2TimeoutTimerValue int64, RMRRoutingNeeded bool) { |
| |
| E2SubscriptionDirectives := &clientmodel.SubscriptionParamsE2SubscriptionDirectives{} |
| p.SubsReqParams.E2SubscriptionDirectives = E2SubscriptionDirectives |
| p.SubsReqParams.E2SubscriptionDirectives.E2RetryCount = &E2RetryCount |
| p.SubsReqParams.E2SubscriptionDirectives.E2TimeoutTimerValue = E2TimeoutTimerValue |
| p.SubsReqParams.E2SubscriptionDirectives.RMRRoutingNeeded = RMRRoutingNeeded |
| } |
| |
| func (p *RESTSubsReqParams) RemoveE2SubscriptionDirectives() { |
| |
| p.SubsReqParams.E2SubscriptionDirectives = nil |
| } |
| |
| func (p *RESTSubsReqParams) SetSubActionTypes(actionType string) { |
| |
| for _, subDetail := range p.SubsReqParams.SubscriptionDetails { |
| for _, action := range subDetail.ActionToBeSetupList { |
| if action != nil { |
| action.ActionType = &actionType |
| } |
| } |
| } |
| } |
| |
| func (p *RESTSubsReqParams) SetSubActionIDs(actionId int64) { |
| |
| for _, subDetail := range p.SubsReqParams.SubscriptionDetails { |
| for _, action := range subDetail.ActionToBeSetupList { |
| if action != nil { |
| action.ActionID = &actionId |
| } |
| } |
| } |
| } |
| |
| func (p *RESTSubsReqParams) SetSubActionDefinition(actionDefinition []int64) { |
| |
| for _, subDetail := range p.SubsReqParams.SubscriptionDetails { |
| for _, action := range subDetail.ActionToBeSetupList { |
| if action != nil { |
| action.ActionDefinition = actionDefinition |
| } |
| } |
| } |
| } |
| |
| func (p *RESTSubsReqParams) SetSubEventTriggerDefinition(eventTriggerDefinition []int64) { |
| |
| for _, subDetail := range p.SubsReqParams.SubscriptionDetails { |
| if subDetail != nil { |
| subDetail.EventTriggers = eventTriggerDefinition |
| } |
| } |
| } |
| |
| func (p *RESTSubsReqParams) AppendActionToActionToBeSetupList(actionId int64, actionType string, actionDefinition []int64, subsequentActionType string, timeToWait string) { |
| |
| actionToBeSetup := &clientmodel.ActionToBeSetup{ |
| ActionID: &actionId, |
| ActionType: &actionType, |
| ActionDefinition: clientmodel.ActionDefinition(actionDefinition), |
| SubsequentAction: &clientmodel.SubsequentAction{ |
| SubsequentActionType: &subsequentActionType, |
| TimeToWait: &timeToWait, |
| }, |
| } |
| |
| for _, subDetail := range p.SubsReqParams.SubscriptionDetails { |
| if subDetail != nil { |
| subDetail.ActionToBeSetupList = append(subDetail.ActionToBeSetupList, actionToBeSetup) |
| } |
| } |
| } |
| |
| func (p *RESTSubsReqParams) SetRMREndpoint(RMR_port int64, host string) { |
| |
| p.SubsReqParams.ClientEndpoint.RMRPort = &RMR_port |
| |
| p.SetEndpointHost(host) |
| |
| if p.SubsReqParams.ClientEndpoint.HTTPPort == nil { |
| var HTTP_port int64 |
| p.SubsReqParams.ClientEndpoint.HTTPPort = &HTTP_port |
| } |
| } |
| |
| func (p *RESTSubsReqParams) SetTimeToWait(timeToWait string) { |
| |
| for _, subDetail := range p.SubsReqParams.SubscriptionDetails { |
| for _, action := range subDetail.ActionToBeSetupList { |
| if action != nil && action.SubsequentAction != nil { |
| action.SubsequentAction.TimeToWait = &timeToWait |
| } |
| } |
| } |
| } |
| |
| func (p *RESTSubsReqParams) SetSubscriptionID(SubscriptionID *string) { |
| |
| if *SubscriptionID == "" { |
| return |
| } |
| p.SubsReqParams.SubscriptionID = *SubscriptionID |
| } |
| |
| func (p *RESTSubsReqParams) SetXappEventInstanceID(xappEventInstanceId int64) { |
| |
| for _, subDetail := range p.SubsReqParams.SubscriptionDetails { |
| if subDetail != nil { |
| subDetail.XappEventInstanceID = &xappEventInstanceId |
| } |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) SendRESTSubsDelReq(t *testing.T, subscriptionID *string) { |
| |
| tc.Debug("======== Posting REST DELETE subscription(s) to Submgr ======") |
| |
| if *subscriptionID == "" { |
| tc.Error("REST error in deleting subscriptions. Empty SubscriptionID = %s", *subscriptionID) |
| } |
| tc.Debug("REST deleting E2 subscriptions. SubscriptionID = %s", *subscriptionID) |
| |
| err := xapp.Subscription.Unsubscribe(*subscriptionID) |
| if err != nil { |
| tc.Error("REST Delete subscription failed %s", err.Error()) |
| } |
| tc.Debug("REST delete subscription pushed to submgr successfully. SubscriptionID = %s", *subscriptionID) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) GetRESTSubsReqPolicyParams(subReqCount int) *RESTSubsReqParams { |
| |
| policyParams := RESTSubsReqParams{} |
| policyParams.GetRESTSubsReqPolicyParams(subReqCount, &tc.clientEndpoint, &tc.meid) |
| tc.requestCount = subReqCount |
| return &policyParams |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (tc *E2Stub) DecrementRequestCount() { |
| if tc.requestCount > 0 { |
| tc.requestCount -= 1 |
| } else { |
| tc.Error("FAILED to decrement request count, count already ZERO") |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func (p *RESTSubsReqParams) GetRESTSubsReqPolicyParams(subReqCount int, clientEndpoint *clientmodel.SubscriptionParamsClientEndpoint, meid *string) { |
| |
| p.SubsReqParams.ClientEndpoint = clientEndpoint |
| p.SubsReqParams.Meid = meid |
| var rANFunctionID int64 = 33 |
| p.SubsReqParams.RANFunctionID = &rANFunctionID |
| actionId := int64(1) |
| actionType := "policy" |
| subsequestActioType := "continue" |
| timeToWait := "w10ms" |
| |
| for requestCount := 0; requestCount < subReqCount; requestCount++ { |
| reqId := int64(requestCount) + 1 |
| subscriptionDetail := &clientmodel.SubscriptionDetail{ |
| XappEventInstanceID: &reqId, |
| EventTriggers: clientmodel.EventTriggerDefinition{ |
| int64(1234 + requestCount), |
| }, |
| ActionToBeSetupList: clientmodel.ActionsToBeSetup{ |
| &clientmodel.ActionToBeSetup{ |
| ActionID: &actionId, |
| ActionType: &actionType, |
| ActionDefinition: clientmodel.ActionDefinition{ |
| int64(5678 + requestCount), |
| }, |
| SubsequentAction: &clientmodel.SubsequentAction{ |
| SubsequentActionType: &subsequestActioType, |
| TimeToWait: &timeToWait, |
| }, |
| }, |
| }, |
| } |
| p.SubsReqParams.SubscriptionDetails = append(p.SubsReqParams.SubscriptionDetails, subscriptionDetail) |
| } |
| } |
| |
| func (p *RESTSubsReqParams) SetSubscriptionDirectives(e2Timeout int64, e2RetryCount int64, routingNeeded bool) { |
| |
| e2SubscriptionDirectives := &clientmodel.SubscriptionParamsE2SubscriptionDirectives{} |
| e2SubscriptionDirectives.E2TimeoutTimerValue = e2Timeout |
| e2SubscriptionDirectives.E2RetryCount = &e2RetryCount |
| e2SubscriptionDirectives.RMRRoutingNeeded = routingNeeded |
| p.SubsReqParams.E2SubscriptionDirectives = e2SubscriptionDirectives |
| |
| } |