pkg/control/e2ap.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 ==================================================================================
  18 */
  19
  20 package control
  21
  22 /*
  23 #cgo LDFLAGS: -le2ap_wrapper -le2ap
  24 */
  25 import "C"
  26
  27 import (
  28         "encoding/hex"
  29         "encoding/json"
  30         "fmt"
  31
  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"
  36 )
  37
  38 var packerif e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
  39
  40 func GetPackerIf() e2ap.E2APPackerIf {
  41         return packerif
  42 }
  43
  44 func SetPackerIf(iface e2ap.E2APPackerIf) {
  45         packerif = iface
  46 }
  47
  48 type E2ap struct {
  49 }
  50
  51 //-----------------------------------------------------------------------------
  52 //
  53 //-----------------------------------------------------------------------------
  54 func (e *E2ap) SetASN1DebugPrintStatus(logLevel int) {
  55         e2ap_wrapper.SetASN1DebugPrintStatus(logLevel)
  56 }
  57
  58 //-----------------------------------------------------------------------------
  59 //
  60 //-----------------------------------------------------------------------------
  61 func (e *E2ap) FillSubscriptionReqMsgs(params interface{}, subreqList *e2ap.SubscriptionRequestList, restSubscription *RESTSubscription) error {
  62         xapp.Logger.Debug("FillSubscriptionReqMsgs")
  63
  64         p := params.(*models.SubscriptionParams)
  65
  66         for _, subscriptionDetail := range p.SubscriptionDetails {
  67                 subReqMsg := e2ap.E2APSubscriptionRequest{}
  68
  69                 if p.RANFunctionID != nil {
  70                         subReqMsg.FunctionId = (e2ap.FunctionId)(*p.RANFunctionID)
  71                 }
  72                 e2EventInstanceID := restSubscription.GetE2IdFromXappIdToE2Id(*subscriptionDetail.XappEventInstanceID)
  73                 subReqMsg.RequestId = e2ap.RequestId{uint32(*subscriptionDetail.XappEventInstanceID), uint32(e2EventInstanceID)}
  74
  75                 if len(subscriptionDetail.EventTriggers) > 0 {
  76                         for _, val := range subscriptionDetail.EventTriggers {
  77                                 subReqMsg.EventTriggerDefinition.Data.Data = append(subReqMsg.EventTriggerDefinition.Data.Data, byte(val))
  78                         }
  79                         subReqMsg.EventTriggerDefinition.Data.Length = uint64(len(subscriptionDetail.EventTriggers))
  80                 }
  81                 for _, actionToBeSetup := range subscriptionDetail.ActionToBeSetupList {
  82                         actionToBeSetupItem := e2ap.ActionToBeSetupItem{}
  83                         actionToBeSetupItem.ActionType = e2ap.E2AP_ActionTypeInvalid
  84                         actionToBeSetupItem.ActionId = uint64(*actionToBeSetup.ActionID)
  85
  86                         actionToBeSetupItem.ActionType = e2ap.E2AP_ActionTypeStrMap[*actionToBeSetup.ActionType]
  87                         actionToBeSetupItem.RicActionDefinitionPresent = true
  88
  89                         if len(actionToBeSetup.ActionDefinition) > 0 {
  90                                 for _, val := range actionToBeSetup.ActionDefinition {
  91                                         actionToBeSetupItem.ActionDefinitionChoice.Data.Data = append(actionToBeSetupItem.ActionDefinitionChoice.Data.Data, byte(val))
  92                                 }
  93                                 actionToBeSetupItem.ActionDefinitionChoice.Data.Length = uint64(len(actionToBeSetup.ActionDefinition))
  94
  95                         }
  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]
 100                         }
 101                         subReqMsg.ActionSetups = append(subReqMsg.ActionSetups, actionToBeSetupItem)
 102                 }
 103                 subreqList.E2APSubscriptionRequests = append(subreqList.E2APSubscriptionRequests, subReqMsg)
 104         }
 105         return nil
 106 }
 107
 108 //-----------------------------------------------------------------------------
 109 //
 110 //-----------------------------------------------------------------------------
 111 func (e *E2ap) CheckActionNotAdmittedList(msgType int, actionNotAdmittedList e2ap.ActionNotAdmittedList, c *Control) ErrorInfo {
 112
 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:"
 122                 }
 123                 jsonActionNotAdmittedList, err := json.Marshal(actionNotAdmittedList.Items)
 124                 if err != nil {
 125                         actionNotAdmittedString = "ActionNotAdmittedList > 0. Submgr json.Marshal error"
 126                         xapp.Logger.Error("CheckActionNotAdmittedList() json.Marshal error %s", err.Error())
 127                 } else {
 128                         actionNotAdmittedString = "ActionNotAdmittedList: " + string(jsonActionNotAdmittedList)
 129                 }
 130         }
 131         err := fmt.Errorf("%s %s", prefixString, actionNotAdmittedString)
 132         errorInfo.SetInfo(err.Error(), models.SubscriptionInstanceErrorSourceE2Node, "")
 133         return errorInfo
 134 }
 135
 136 //-----------------------------------------------------------------------------
 137 //
 138 //-----------------------------------------------------------------------------
 139 func (e *E2ap) UnpackSubscriptionRequest(payload []byte) (*e2ap.E2APSubscriptionRequest, error) {
 140         e2SubReq := packerif.NewPackerSubscriptionRequest()
 141         err, subReq := e2SubReq.UnPack(&e2ap.PackedData{payload})
 142         if err != nil {
 143                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 144         }
 145         return subReq, nil
 146 }
 147
 148 func (c *E2ap) PackSubscriptionRequest(req *e2ap.E2APSubscriptionRequest) (int, *e2ap.PackedData, error) {
 149         e2SubReq := packerif.NewPackerSubscriptionRequest()
 150         err, packedData := e2SubReq.Pack(req)
 151         if err != nil {
 152                 return 0, nil, err
 153         }
 154         return xapp.RIC_SUB_REQ, packedData, nil
 155 }
 156
 157 //-----------------------------------------------------------------------------
 158 //
 159 //-----------------------------------------------------------------------------
 160 func (e *E2ap) UnpackSubscriptionResponse(payload []byte) (*e2ap.E2APSubscriptionResponse, error) {
 161         e2SubResp := packerif.NewPackerSubscriptionResponse()
 162         err, subResp := e2SubResp.UnPack(&e2ap.PackedData{payload})
 163         if err != nil {
 164                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 165         }
 166         return subResp, nil
 167 }
 168
 169 func (e *E2ap) PackSubscriptionResponse(req *e2ap.E2APSubscriptionResponse) (int, *e2ap.PackedData, error) {
 170         e2SubResp := packerif.NewPackerSubscriptionResponse()
 171         err, packedData := e2SubResp.Pack(req)
 172         if err != nil {
 173                 return 0, nil, err
 174         }
 175         return xapp.RIC_SUB_RESP, packedData, nil
 176 }
 177
 178 //-----------------------------------------------------------------------------
 179 //
 180 //-----------------------------------------------------------------------------
 181 func (e *E2ap) UnpackSubscriptionFailure(payload []byte) (*e2ap.E2APSubscriptionFailure, error) {
 182         e2SubFail := packerif.NewPackerSubscriptionFailure()
 183         err, subFail := e2SubFail.UnPack(&e2ap.PackedData{payload})
 184         if err != nil {
 185                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 186         }
 187         return subFail, nil
 188 }
 189
 190 func (e *E2ap) PackSubscriptionFailure(req *e2ap.E2APSubscriptionFailure) (int, *e2ap.PackedData, error) {
 191         e2SubFail := packerif.NewPackerSubscriptionFailure()
 192         err, packedData := e2SubFail.Pack(req)
 193         if err != nil {
 194                 return 0, nil, err
 195         }
 196         return xapp.RIC_SUB_FAILURE, packedData, nil
 197 }
 198
 199 //-----------------------------------------------------------------------------
 200 //
 201 //-----------------------------------------------------------------------------
 202 func (e *E2ap) UnpackSubscriptionDeleteRequest(payload []byte) (*e2ap.E2APSubscriptionDeleteRequest, error) {
 203         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 204         err, subDelReq := e2SubDelReq.UnPack(&e2ap.PackedData{payload})
 205         if err != nil {
 206                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 207         }
 208         return subDelReq, nil
 209 }
 210
 211 func (e *E2ap) PackSubscriptionDeleteRequest(req *e2ap.E2APSubscriptionDeleteRequest) (int, *e2ap.PackedData, error) {
 212         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 213         err, packedData := e2SubDelReq.Pack(req)
 214         if err != nil {
 215                 return 0, nil, err
 216         }
 217         return xapp.RIC_SUB_DEL_REQ, packedData, nil
 218 }
 219
 220 //-----------------------------------------------------------------------------
 221 //
 222 //-----------------------------------------------------------------------------
 223 func (e *E2ap) UnpackSubscriptionDeleteResponse(payload []byte) (*e2ap.E2APSubscriptionDeleteResponse, error) {
 224         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 225         err, subDelResp := e2SubDelResp.UnPack(&e2ap.PackedData{payload})
 226         if err != nil {
 227                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 228         }
 229         return subDelResp, nil
 230 }
 231
 232 func (e *E2ap) PackSubscriptionDeleteResponse(req *e2ap.E2APSubscriptionDeleteResponse) (int, *e2ap.PackedData, error) {
 233         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 234         err, packedData := e2SubDelResp.Pack(req)
 235         if err != nil {
 236                 return 0, nil, err
 237         }
 238         return xapp.RIC_SUB_DEL_RESP, packedData, nil
 239 }
 240
 241 //-----------------------------------------------------------------------------
 242 //
 243 //-----------------------------------------------------------------------------
 244 func (e *E2ap) UnpackSubscriptionDeleteFailure(payload []byte) (*e2ap.E2APSubscriptionDeleteFailure, error) {
 245         e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
 246         err, subDelFail := e2SubDelFail.UnPack(&e2ap.PackedData{payload})
 247         if err != nil {
 248                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 249         }
 250         return subDelFail, nil
 251 }
 252
 253 /*
 254 func (e *E2ap) PackSubscriptionDeleteFailure(req *e2ap.E2APSubscriptionDeleteFailure) (int, *e2ap.PackedData, error) {
 255         e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
 256         err, packedData := e2SubDelFail.Pack(req)
 257         if err != nil {
 258                 return 0, nil, err
 259         }
 260         return xapp.RIC_SUB_DEL_FAILURE, packedData, nil
 261 }
 262 */