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 ==================================================================================
23 #cgo LDFLAGS: -le2ap_wrapper -le2ap
32 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
33 "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
34 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
35 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
38 var packerif e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
40 func GetPackerIf() e2ap.E2APPackerIf {
44 func SetPackerIf(iface e2ap.E2APPackerIf) {
51 //-----------------------------------------------------------------------------
53 //-----------------------------------------------------------------------------
54 func (e *E2ap) SetASN1DebugPrintStatus(logLevel int) {
55 e2ap_wrapper.SetASN1DebugPrintStatus(logLevel)
58 //-----------------------------------------------------------------------------
60 //-----------------------------------------------------------------------------
61 func (e *E2ap) FillSubscriptionReqMsgs(params interface{}, subreqList *e2ap.SubscriptionRequestList, restSubscription *RESTSubscription) error {
62 xapp.Logger.Debug("FillSubscriptionReqMsgs")
64 p := params.(*models.SubscriptionParams)
66 for _, subscriptionDetail := range p.SubscriptionDetails {
67 subReqMsg := e2ap.E2APSubscriptionRequest{}
69 if p.RANFunctionID != nil {
70 subReqMsg.FunctionId = (e2ap.FunctionId)(*p.RANFunctionID)
72 e2EventInstanceID := restSubscription.GetE2IdFromXappIdToE2Id(*subscriptionDetail.XappEventInstanceID)
73 subReqMsg.RequestId = e2ap.RequestId{uint32(*subscriptionDetail.XappEventInstanceID), uint32(e2EventInstanceID)}
75 if len(subscriptionDetail.EventTriggers) > 0 {
76 for _, val := range subscriptionDetail.EventTriggers {
77 subReqMsg.EventTriggerDefinition.Data.Data = append(subReqMsg.EventTriggerDefinition.Data.Data, byte(val))
79 subReqMsg.EventTriggerDefinition.Data.Length = uint64(len(subscriptionDetail.EventTriggers))
81 for _, actionToBeSetup := range subscriptionDetail.ActionToBeSetupList {
82 actionToBeSetupItem := e2ap.ActionToBeSetupItem{}
83 actionToBeSetupItem.ActionType = e2ap.E2AP_ActionTypeInvalid
84 actionToBeSetupItem.ActionId = uint64(*actionToBeSetup.ActionID)
86 actionToBeSetupItem.ActionType = e2ap.E2AP_ActionTypeStrMap[*actionToBeSetup.ActionType]
87 actionToBeSetupItem.RicActionDefinitionPresent = true
89 if len(actionToBeSetup.ActionDefinition) > 0 {
90 for _, val := range actionToBeSetup.ActionDefinition {
91 actionToBeSetupItem.ActionDefinitionChoice.Data.Data = append(actionToBeSetupItem.ActionDefinitionChoice.Data.Data, byte(val))
93 actionToBeSetupItem.ActionDefinitionChoice.Data.Length = uint64(len(actionToBeSetup.ActionDefinition))
96 if actionToBeSetup.SubsequentAction != nil {
97 actionToBeSetupItem.SubsequentAction.Present = true
98 actionToBeSetupItem.SubsequentAction.Type = e2ap.E2AP_SubSeqActionTypeStrMap[*actionToBeSetup.SubsequentAction.SubsequentActionType]
99 actionToBeSetupItem.SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitStrMap[*actionToBeSetup.SubsequentAction.TimeToWait]
101 subReqMsg.ActionSetups = append(subReqMsg.ActionSetups, actionToBeSetupItem)
103 subreqList.E2APSubscriptionRequests = append(subreqList.E2APSubscriptionRequests, subReqMsg)
108 //-----------------------------------------------------------------------------
110 //-----------------------------------------------------------------------------
111 func (e *E2ap) CheckActionNotAdmittedList(msgType int, actionNotAdmittedList e2ap.ActionNotAdmittedList, c *Control) ErrorInfo {
113 var prefixString string
114 var errorInfo ErrorInfo
115 var actionNotAdmittedString string
116 if len(actionNotAdmittedList.Items) > 0 {
117 if msgType == xapp.RIC_SUB_RESP {
118 prefixString = "RICSubscriptionResponse partially accepted:"
119 c.UpdateCounter(cPartialSubRespFromE2)
120 } else if msgType == xapp.RIC_SUB_FAILURE {
121 prefixString = "RICSubscriptionFailure:"
123 jsonActionNotAdmittedList, err := json.Marshal(actionNotAdmittedList.Items)
125 actionNotAdmittedString = "ActionNotAdmittedList > 0. Submgr json.Marshal error"
126 xapp.Logger.Error("CheckActionNotAdmittedList() json.Marshal error %s", err.Error())
128 actionNotAdmittedString = "ActionNotAdmittedList: " + string(jsonActionNotAdmittedList)
132 if msgType == xapp.RIC_SUB_FAILURE {
133 prefixString = "RICSubscriptionFailure"
134 err := fmt.Errorf("%s", prefixString)
135 errorInfo.SetInfo(err.Error(), models.SubscriptionInstanceErrorSourceE2Node, "")
137 err := fmt.Errorf("%s %s", prefixString, actionNotAdmittedString)
138 errorInfo.SetInfo(err.Error(), models.SubscriptionInstanceErrorSourceE2Node, "")
142 //-----------------------------------------------------------------------------
144 //-----------------------------------------------------------------------------
145 func (e *E2ap) UnpackSubscriptionRequest(payload []byte) (*e2ap.E2APSubscriptionRequest, error) {
146 e2SubReq := packerif.NewPackerSubscriptionRequest()
147 err, subReq := e2SubReq.UnPack(&e2ap.PackedData{payload})
149 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
154 func (c *E2ap) PackSubscriptionRequest(req *e2ap.E2APSubscriptionRequest) (int, *e2ap.PackedData, error) {
155 e2SubReq := packerif.NewPackerSubscriptionRequest()
156 err, packedData := e2SubReq.Pack(req)
160 return xapp.RIC_SUB_REQ, packedData, nil
163 //-----------------------------------------------------------------------------
165 //-----------------------------------------------------------------------------
166 func (e *E2ap) UnpackSubscriptionResponse(payload []byte) (*e2ap.E2APSubscriptionResponse, error) {
167 e2SubResp := packerif.NewPackerSubscriptionResponse()
168 err, subResp := e2SubResp.UnPack(&e2ap.PackedData{payload})
170 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
175 func (e *E2ap) PackSubscriptionResponse(req *e2ap.E2APSubscriptionResponse) (int, *e2ap.PackedData, error) {
176 e2SubResp := packerif.NewPackerSubscriptionResponse()
177 err, packedData := e2SubResp.Pack(req)
181 return xapp.RIC_SUB_RESP, packedData, nil
184 //-----------------------------------------------------------------------------
186 //-----------------------------------------------------------------------------
187 func (e *E2ap) UnpackSubscriptionFailure(payload []byte) (*e2ap.E2APSubscriptionFailure, error) {
188 e2SubFail := packerif.NewPackerSubscriptionFailure()
189 err, subFail := e2SubFail.UnPack(&e2ap.PackedData{payload})
191 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
196 func (e *E2ap) PackSubscriptionFailure(req *e2ap.E2APSubscriptionFailure) (int, *e2ap.PackedData, error) {
197 e2SubFail := packerif.NewPackerSubscriptionFailure()
198 err, packedData := e2SubFail.Pack(req)
202 return xapp.RIC_SUB_FAILURE, packedData, nil
205 //-----------------------------------------------------------------------------
207 //-----------------------------------------------------------------------------
208 func (e *E2ap) UnpackSubscriptionDeleteRequest(payload []byte) (*e2ap.E2APSubscriptionDeleteRequest, error) {
209 e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
210 err, subDelReq := e2SubDelReq.UnPack(&e2ap.PackedData{payload})
212 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
214 return subDelReq, nil
217 func (e *E2ap) PackSubscriptionDeleteRequest(req *e2ap.E2APSubscriptionDeleteRequest) (int, *e2ap.PackedData, error) {
218 e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
219 err, packedData := e2SubDelReq.Pack(req)
223 return xapp.RIC_SUB_DEL_REQ, packedData, nil
226 //-----------------------------------------------------------------------------
228 //-----------------------------------------------------------------------------
229 func (e *E2ap) UnpackSubscriptionDeleteResponse(payload []byte) (*e2ap.E2APSubscriptionDeleteResponse, error) {
230 e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
231 err, subDelResp := e2SubDelResp.UnPack(&e2ap.PackedData{payload})
233 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
235 return subDelResp, nil
238 func (e *E2ap) PackSubscriptionDeleteResponse(req *e2ap.E2APSubscriptionDeleteResponse) (int, *e2ap.PackedData, error) {
239 e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
240 err, packedData := e2SubDelResp.Pack(req)
244 return xapp.RIC_SUB_DEL_RESP, packedData, nil
247 //-----------------------------------------------------------------------------
249 //-----------------------------------------------------------------------------
250 func (e *E2ap) UnpackSubscriptionDeleteFailure(payload []byte) (*e2ap.E2APSubscriptionDeleteFailure, error) {
251 e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
252 err, subDelFail := e2SubDelFail.UnPack(&e2ap.PackedData{payload})
254 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
256 return subDelFail, nil
260 func (e *E2ap) PackSubscriptionDeleteFailure(req *e2ap.E2APSubscriptionDeleteFailure) (int, *e2ap.PackedData, error) {
261 e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
262 err, packedData := e2SubDelFail.Pack(req)
266 return xapp.RIC_SUB_DEL_FAILURE, packedData, nil
270 //-----------------------------------------------------------------------------
271 // Changes to support "RIC_SUB_DEL_REQUIRED"
272 //-----------------------------------------------------------------------------
273 func (c *E2ap) UnpackSubscriptionDeleteRequired(payload []byte) (*e2ap.SubscriptionDeleteRequiredList, error) {
274 e2SubDelRequ := packerif.NewPackerSubscriptionDeleteRequired()
275 err, subsToBeRemove := e2SubDelRequ.UnPack(&e2ap.PackedData{payload})
277 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
279 return subsToBeRemove, nil
282 func (c *E2ap) PackSubscriptionDeleteRequired(req *e2ap.SubscriptionDeleteRequiredList) (int, *e2ap.PackedData, error) {
283 e2SubDelRequ := packerif.NewPackerSubscriptionDeleteRequired()
284 err, packedData := e2SubDelRequ.Pack(req)
288 return xapp.RIC_SUB_DEL_REQUIRED, packedData, nil