| /* |
| ================================================================================== |
| 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 control |
| |
| import ( |
| "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/e2ap/pkg/packer" |
| "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp" |
| "testing" |
| "time" |
| ) |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| |
| var e2asnpacker e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer() |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func createSubsReq() *e2ap.E2APSubscriptionRequest { |
| req := &e2ap.E2APSubscriptionRequest{} |
| |
| req.RequestId.Id = 1 |
| req.RequestId.Seq = 0 |
| req.FunctionId = 1 |
| |
| req.EventTriggerDefinition.InterfaceId.GlobalEnbId.Present = true |
| req.EventTriggerDefinition.InterfaceId.GlobalEnbId.PlmnIdentity.StringPut("310150") |
| req.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Id = 123 |
| req.EventTriggerDefinition.InterfaceId.GlobalEnbId.NodeId.Bits = e2ap.E2AP_ENBIDHomeBits28 |
| |
| // gnb -> enb outgoing |
| // enb -> gnb incoming |
| // X2 36423-f40.doc |
| req.EventTriggerDefinition.InterfaceDirection = e2ap.E2AP_InterfaceDirectionIncoming |
| req.EventTriggerDefinition.ProcedureCode = 5 //28 35 |
| req.EventTriggerDefinition.TypeOfMessage = e2ap.E2AP_InitiatingMessage |
| |
| req.ActionSetups = make([]e2ap.ActionToBeSetupItem, 1) |
| req.ActionSetups[0].ActionId = 0 |
| req.ActionSetups[0].ActionType = e2ap.E2AP_ActionTypeReport |
| req.ActionSetups[0].ActionDefinition.Present = false |
| //req.ActionSetups[index].ActionDefinition.StyleId = 255 |
| //req.ActionSetups[index].ActionDefinition.ParamId = 222 |
| req.ActionSetups[0].SubsequentAction.Present = true |
| req.ActionSetups[0].SubsequentAction.Type = e2ap.E2AP_SubSeqActionTypeContinue |
| req.ActionSetups[0].SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitZero |
| |
| return req |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func createSubsResp(req *e2ap.E2APSubscriptionRequest) *e2ap.E2APSubscriptionResponse { |
| |
| resp := &e2ap.E2APSubscriptionResponse{} |
| |
| resp.RequestId.Id = req.RequestId.Id |
| resp.RequestId.Seq = req.RequestId.Seq |
| 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.CauseVal = 1 |
| resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item) |
| } |
| |
| return resp |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func createSubsDelReq(e2SubsId uint32) *e2ap.E2APSubscriptionDeleteRequest { |
| req := &e2ap.E2APSubscriptionDeleteRequest{} |
| req.RequestId.Id = 1 |
| req.RequestId.Seq = e2SubsId |
| req.FunctionId = 1 |
| return req |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func createSubsDelResp(req *e2ap.E2APSubscriptionDeleteRequest) *e2ap.E2APSubscriptionDeleteResponse { |
| resp := &e2ap.E2APSubscriptionDeleteResponse{} |
| resp.RequestId.Id = req.RequestId.Id |
| resp.RequestId.Seq = req.RequestId.Seq |
| resp.FunctionId = req.FunctionId |
| return resp |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func handle_xapp_subs_req(t *testing.T) { |
| xapp.Logger.Info("handle_xapp_subs_req start") |
| e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest() |
| |
| //--------------------------------- |
| // xapp activity: Send Subs Req |
| //--------------------------------- |
| //select { |
| //case <-time.After(1 * time.Second): |
| xapp.Logger.Info("(xappConn) Send Subs Req") |
| req := createSubsReq() |
| e2SubsReq.Set(req) |
| xapp.Logger.Debug("%s", e2SubsReq.String()) |
| err, packedMsg := e2SubsReq.Pack(nil) |
| if err != nil { |
| testError(t, "(xappConn) pack NOK %s", err.Error()) |
| } |
| |
| params := &xapp.RMRParams{} |
| params.Mtype = xapp.RIC_SUB_REQ |
| params.SubId = -1 |
| params.Payload = packedMsg.Buf |
| params.Meid = &xapp.RMRMeid{RanName: "RAN_NAME_1"} |
| params.Xid = "XID_1" |
| params.Mbuf = nil |
| |
| snderr := xappConn.RmrSend(params) |
| if snderr != nil { |
| testError(t, "(xappConn) RMR SEND FAILED: %s", snderr.Error()) |
| } |
| //} |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func handle_e2term_subs_req(t *testing.T) (*e2ap.E2APSubscriptionRequest, *xapp.RMRParams) { |
| xapp.Logger.Info("handle_e2term_subs_req start") |
| e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest() |
| |
| //--------------------------------- |
| // e2term activity: Recv Subs Req |
| //--------------------------------- |
| select { |
| case msg := <-e2termConn.rmrConChan: |
| if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] { |
| testError(t, "(e2termConn) Received non RIC_SUB_REQ message") |
| } else { |
| xapp.Logger.Info("(e2termConn) Recv Subs Req") |
| packedData := &packer.PackedData{} |
| packedData.Buf = msg.Payload |
| unpackerr := e2SubsReq.UnPack(packedData) |
| if unpackerr != nil { |
| testError(t, "(e2termConn) RIC_SUB_REQ unpack failed err: %s", unpackerr.Error()) |
| } |
| geterr, req := e2SubsReq.Get() |
| if geterr != nil { |
| testError(t, "(e2termConn) RIC_SUB_REQ get failed err: %s", geterr.Error()) |
| } |
| return req, msg |
| } |
| case <-time.After(15 * time.Second): |
| testError(t, "(e2termConn) Not Received RIC_SUB_REQ within 15 secs") |
| } |
| return nil, nil |
| } |
| |
| func handle_e2term_subs_resp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *xapp.RMRParams) { |
| xapp.Logger.Info("handle_e2term_subs_resp start") |
| e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse() |
| |
| //--------------------------------- |
| // e2term activity: Send Subs Resp |
| //--------------------------------- |
| xapp.Logger.Info("(e2termConn) Send Subs Resp") |
| resp := createSubsResp(req) |
| e2SubsResp.Set(resp) |
| xapp.Logger.Debug("%s", e2SubsResp.String()) |
| packerr, packedMsg := e2SubsResp.Pack(nil) |
| if packerr != nil { |
| testError(t, "(e2termConn) pack NOK %s", packerr.Error()) |
| } |
| |
| params := &xapp.RMRParams{} |
| params.Mtype = xapp.RIC_SUB_RESP |
| params.SubId = msg.SubId |
| params.Payload = packedMsg.Buf |
| params.Meid = msg.Meid |
| params.Xid = msg.Xid |
| params.Mbuf = nil |
| |
| snderr := e2termConn.RmrSend(params) |
| if snderr != nil { |
| testError(t, "(e2termConn) RMR SEND FAILED: %s", snderr.Error()) |
| } |
| } |
| |
| func handle_e2term_subs_reqandresp(t *testing.T) { |
| req, msg := handle_e2term_subs_req(t) |
| handle_e2term_subs_resp(t, req, msg) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func handle_xapp_subs_resp(t *testing.T) int { |
| xapp.Logger.Info("handle_xapp_subs_resp start") |
| e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse() |
| var e2SubsId int |
| |
| //--------------------------------- |
| // xapp activity: Recv Subs Resp |
| //--------------------------------- |
| select { |
| case msg := <-xappConn.rmrConChan: |
| if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] { |
| testError(t, "(xappConn) Received non RIC_SUB_RESP message") |
| } else { |
| xapp.Logger.Info("(xappConn) Recv Subs Resp") |
| |
| packedData := &packer.PackedData{} |
| packedData.Buf = msg.Payload |
| e2SubsId = msg.SubId |
| unpackerr := e2SubsResp.UnPack(packedData) |
| |
| if unpackerr != nil { |
| testError(t, "(xappConn) RIC_SUB_RESP unpack failed err: %s", unpackerr.Error()) |
| } |
| geterr, _ := e2SubsResp.Get() |
| if geterr != nil { |
| testError(t, "(xappConn) RIC_SUB_RESP get failed err: %s", geterr.Error()) |
| } |
| |
| } |
| case <-time.After(15 * time.Second): |
| testError(t, "(xappConn) Not Received RIC_SUB_RESP within 15 secs") |
| } |
| return e2SubsId |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func handle_xapp_subs_del_req(t *testing.T, e2SubsId int) { |
| xapp.Logger.Info("handle_xapp_subs_del_req start") |
| e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest() |
| |
| //--------------------------------- |
| // xapp activity: Send Subs Del Req |
| //--------------------------------- |
| //select { |
| //case <-time.After(1 * time.Second): |
| xapp.Logger.Info("(xappConn) Send Subs Del Req") |
| req := createSubsDelReq(uint32(e2SubsId)) |
| e2SubsDelReq.Set(req) |
| xapp.Logger.Debug("%s", e2SubsDelReq.String()) |
| err, packedMsg := e2SubsDelReq.Pack(nil) |
| if err != nil { |
| testError(t, "(xappConn) pack NOK %s", err.Error()) |
| } |
| |
| params := &xapp.RMRParams{} |
| params.Mtype = xapp.RIC_SUB_DEL_REQ |
| params.SubId = e2SubsId |
| params.Payload = packedMsg.Buf |
| params.Meid = &xapp.RMRMeid{RanName: "RAN_NAME_1"} |
| params.Xid = "XID_1" |
| params.Mbuf = nil |
| |
| snderr := xappConn.RmrSend(params) |
| if snderr != nil { |
| testError(t, "(xappConn) RMR SEND FAILED: %s", snderr.Error()) |
| } |
| //} |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *xapp.RMRParams) { |
| xapp.Logger.Info("handle_e2term_subs_del_req start") |
| e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest() |
| |
| //--------------------------------- |
| // e2term activity: Recv Subs Del Req |
| //--------------------------------- |
| select { |
| case msg := <-e2termConn.rmrConChan: |
| if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] { |
| testError(t, "(e2termConn) Received non RIC_SUB_DEL_REQ message") |
| } else { |
| xapp.Logger.Info("(e2termConn) Recv Subs Del Req") |
| |
| packedData := &packer.PackedData{} |
| packedData.Buf = msg.Payload |
| unpackerr := e2SubsDelReq.UnPack(packedData) |
| if unpackerr != nil { |
| testError(t, "(e2termConn) RIC_SUB_DEL_REQ unpack failed err: %s", unpackerr.Error()) |
| } |
| geterr, req := e2SubsDelReq.Get() |
| if geterr != nil { |
| testError(t, "(e2termConn) RIC_SUB_DEL_REQ get failed err: %s", geterr.Error()) |
| } |
| return req, msg |
| } |
| case <-time.After(15 * time.Second): |
| testError(t, "(e2termConn) Not Received RIC_SUB_DEL_REQ within 15 secs") |
| } |
| return nil, nil |
| } |
| |
| func handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) { |
| xapp.Logger.Info("handle_e2term_subs_del_resp start") |
| e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse() |
| |
| //--------------------------------- |
| // e2term activity: Send Subs Del Resp |
| //--------------------------------- |
| xapp.Logger.Info("(e2termConn) Send Subs Del Resp") |
| resp := createSubsDelResp(req) |
| e2SubsDelResp.Set(resp) |
| xapp.Logger.Debug("%s", e2SubsDelResp.String()) |
| packerr, packedMsg := e2SubsDelResp.Pack(nil) |
| if packerr != nil { |
| testError(t, "(e2termConn) pack NOK %s", packerr.Error()) |
| } |
| |
| params := &xapp.RMRParams{} |
| params.Mtype = xapp.RIC_SUB_DEL_RESP |
| params.SubId = msg.SubId |
| params.Payload = packedMsg.Buf |
| params.Meid = msg.Meid |
| params.Xid = msg.Xid |
| params.Mbuf = nil |
| |
| snderr := e2termConn.RmrSend(params) |
| if snderr != nil { |
| testError(t, "(e2termConn) RMR SEND FAILED: %s", snderr.Error()) |
| } |
| |
| } |
| |
| func handle_e2term_subs_del_reqandresp(t *testing.T) { |
| req, msg := handle_e2term_subs_del_req(t) |
| handle_e2term_subs_del_resp(t, req, msg) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func handle_xapp_subs_del_resp(t *testing.T) { |
| xapp.Logger.Info("handle_xapp_subs_del_resp start") |
| e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse() |
| |
| //--------------------------------- |
| // xapp activity: Recv Subs Del Resp |
| //--------------------------------- |
| select { |
| case msg := <-xappConn.rmrConChan: |
| if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] { |
| testError(t, "(xappConn) Received non RIC_SUB_DEL_RESP message") |
| } else { |
| xapp.Logger.Info("(xappConn) Recv Subs Del Resp") |
| |
| packedData := &packer.PackedData{} |
| packedData.Buf = msg.Payload |
| unpackerr := e2SubsDelResp.UnPack(packedData) |
| if unpackerr != nil { |
| testError(t, "(xappConn) RIC_SUB_DEL_RESP unpack failed err: %s", unpackerr.Error()) |
| } |
| geterr, _ := e2SubsDelResp.Get() |
| if geterr != nil { |
| testError(t, "(xappConn) RIC_SUB_DEL_RESP get failed err: %s", geterr.Error()) |
| } |
| |
| } |
| case <-time.After(15 * time.Second): |
| testError(t, "(xappConn) Not Received RIC_SUB_DEL_RESP within 15 secs") |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| // |
| //----------------------------------------------------------------------------- |
| func handle_wait_subs_clean(t *testing.T, e2SubsId int) bool { |
| xapp.Logger.Info("handle_wait_subs_clean start") |
| if mainCtrl.wait_subs_clean(e2SubsId, 10) == false { |
| testError(t, "(general) no clean within 10 secs") |
| return false |
| } |
| return true |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqAndSubDelOk |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | SubResp | | |
| // |<-------------| | |
| // | | | |
| // | | | |
| // | SubDelReq | | |
| // |------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | SubDelResp | | |
| // |<-------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqAndSubDelOk(t *testing.T) { |
| xapp.Logger.Info("TestSubReqAndSubDelOk start") |
| |
| handle_xapp_subs_req(t) |
| handle_e2term_subs_reqandresp(t) |
| e2SubsId := handle_xapp_subs_resp(t) |
| |
| handle_xapp_subs_del_req(t, e2SubsId) |
| handle_e2term_subs_del_reqandresp(t) |
| handle_xapp_subs_del_resp(t) |
| |
| //Wait that subs is cleaned |
| handle_wait_subs_clean(t, e2SubsId) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubReqRetransmission |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | SubReq | | |
| // |------------->| | |
| // | | | |
| // | | SubReq | |
| // | |------------->| |
| // | | | |
| // | SubReq | | |
| // | (retrans) | | |
| // |------------->| | |
| // | | | |
| // | | SubResp | |
| // | |<-------------| |
| // | | | |
| // | SubResp | | |
| // |<-------------| | |
| // | | | |
| // | [SUBS DELETE] | |
| // | | | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubReqRetransmission(t *testing.T) { |
| xapp.Logger.Info("TestSubReqRetransmission start") |
| |
| //Subs Create |
| handle_xapp_subs_req(t) |
| req, msg := handle_e2term_subs_req(t) |
| handle_xapp_subs_req(t) |
| |
| handle_e2term_subs_resp(t, req, msg) |
| |
| e2SubsId := handle_xapp_subs_resp(t) |
| |
| //Subs Delete |
| handle_xapp_subs_del_req(t, e2SubsId) |
| handle_e2term_subs_del_reqandresp(t) |
| handle_xapp_subs_del_resp(t) |
| |
| //Wait that subs is cleaned |
| handle_wait_subs_clean(t, e2SubsId) |
| } |
| |
| //----------------------------------------------------------------------------- |
| // TestSubDelReqRetransmission |
| // |
| // stub stub |
| // +-------+ +---------+ +---------+ |
| // | xapp | | submgr | | e2term | |
| // +-------+ +---------+ +---------+ |
| // | | | |
| // | [SUBS CREATE] | |
| // | | | |
| // | | | |
| // | SubDelReq | | |
| // |------------->| | |
| // | | | |
| // | | SubDelReq | |
| // | |------------->| |
| // | | | |
| // | SubDelReq | | |
| // |------------->| | |
| // | | | |
| // | | SubDelResp | |
| // | |<-------------| |
| // | | | |
| // | SubDelResp | | |
| // |<-------------| | |
| // |
| //----------------------------------------------------------------------------- |
| func TestSubDelReqRetransmission(t *testing.T) { |
| xapp.Logger.Info("TestSubDelReqRetransmission start") |
| |
| //Subs Create |
| handle_xapp_subs_req(t) |
| handle_e2term_subs_reqandresp(t) |
| e2SubsId := handle_xapp_subs_resp(t) |
| |
| //Subs Delete |
| handle_xapp_subs_del_req(t, e2SubsId) |
| req, msg := handle_e2term_subs_del_req(t) |
| |
| <-time.After(2 * time.Second) |
| |
| handle_xapp_subs_del_req(t, e2SubsId) |
| |
| handle_e2term_subs_del_resp(t, req, msg) |
| |
| //Wait that subs is cleaned |
| handle_wait_subs_clean(t, e2SubsId) |
| } |