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 func (e *E2ap) SetE2IEOrderCheck(ieOrderCheck uint8) {
  59         e2ap_wrapper.SetE2IEOrderCheck(ieOrderCheck)
  60 }
  61
  62 //-----------------------------------------------------------------------------
  63 //
  64 //-----------------------------------------------------------------------------
  65 func (e *E2ap) FillSubscriptionReqMsgs(params interface{}, subreqList *e2ap.SubscriptionRequestList, restSubscription *RESTSubscription) error {
  66         xapp.Logger.Debug("FillSubscriptionReqMsgs")
  67
  68         p := params.(*models.SubscriptionParams)
  69
  70         for _, subscriptionDetail := range p.SubscriptionDetails {
  71                 subReqMsg := e2ap.E2APSubscriptionRequest{}
  72
  73                 if p.RANFunctionID != nil {
  74                         subReqMsg.FunctionId = (e2ap.FunctionId)(*p.RANFunctionID)
  75                 }
  76                 e2EventInstanceID := restSubscription.GetE2IdFromXappIdToE2Id(*subscriptionDetail.XappEventInstanceID)
  77                 subReqMsg.RequestId = e2ap.RequestId{uint32(*subscriptionDetail.XappEventInstanceID), uint32(e2EventInstanceID)}
  78
  79                 if len(subscriptionDetail.EventTriggers) > 0 {
  80                         for _, val := range subscriptionDetail.EventTriggers {
  81                                 subReqMsg.EventTriggerDefinition.Data.Data = append(subReqMsg.EventTriggerDefinition.Data.Data, byte(val))
  82                         }
  83                         subReqMsg.EventTriggerDefinition.Data.Length = uint64(len(subscriptionDetail.EventTriggers))
  84                 }
  85                 for _, actionToBeSetup := range subscriptionDetail.ActionToBeSetupList {
  86                         actionToBeSetupItem := e2ap.ActionToBeSetupItem{}
  87                         actionToBeSetupItem.ActionType = e2ap.E2AP_ActionTypeInvalid
  88                         actionToBeSetupItem.ActionId = uint64(*actionToBeSetup.ActionID)
  89
  90                         actionToBeSetupItem.ActionType = e2ap.E2AP_ActionTypeStrMap[*actionToBeSetup.ActionType]
  91                         actionToBeSetupItem.RicActionDefinitionPresent = true
  92
  93                         if len(actionToBeSetup.ActionDefinition) > 0 {
  94                                 for _, val := range actionToBeSetup.ActionDefinition {
  95                                         actionToBeSetupItem.ActionDefinitionChoice.Data.Data = append(actionToBeSetupItem.ActionDefinitionChoice.Data.Data, byte(val))
  96                                 }
  97                                 actionToBeSetupItem.ActionDefinitionChoice.Data.Length = uint64(len(actionToBeSetup.ActionDefinition))
  98
  99                         }
 100                         if actionToBeSetup.SubsequentAction != nil {
 101                                 actionToBeSetupItem.SubsequentAction.Present = true
 102                                 actionToBeSetupItem.SubsequentAction.Type = e2ap.E2AP_SubSeqActionTypeStrMap[*actionToBeSetup.SubsequentAction.SubsequentActionType]
 103                                 actionToBeSetupItem.SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitStrMap[*actionToBeSetup.SubsequentAction.TimeToWait]
 104                         }
 105                         subReqMsg.ActionSetups = append(subReqMsg.ActionSetups, actionToBeSetupItem)
 106                 }
 107                 subreqList.E2APSubscriptionRequests = append(subreqList.E2APSubscriptionRequests, subReqMsg)
 108         }
 109         return nil
 110 }
 111
 112 //-----------------------------------------------------------------------------
 113 //
 114 //-----------------------------------------------------------------------------
 115 func (e *E2ap) CheckActionNotAdmittedList(msgType int, actionNotAdmittedList e2ap.ActionNotAdmittedList, c *Control) ErrorInfo {
 116
 117         var prefixString string
 118         var errorInfo ErrorInfo
 119         var actionNotAdmittedString string
 120         if len(actionNotAdmittedList.Items) > 0 {
 121                 if msgType == xapp.RIC_SUB_RESP {
 122                         prefixString = "RICSubscriptionResponse partially accepted:"
 123                         c.UpdateCounter(cPartialSubRespFromE2)
 124                 } else if msgType == xapp.RIC_SUB_FAILURE {
 125                         prefixString = "RICSubscriptionFailure:"
 126                 }
 127                 jsonActionNotAdmittedList, err := json.Marshal(actionNotAdmittedList.Items)
 128                 if err != nil {
 129                         actionNotAdmittedString = "ActionNotAdmittedList > 0. Submgr json.Marshal error"
 130                         xapp.Logger.Error("CheckActionNotAdmittedList() json.Marshal error %s", err.Error())
 131                 } else {
 132                         actionNotAdmittedString = "ActionNotAdmittedList: " + string(jsonActionNotAdmittedList)
 133                 }
 134         }
 135
 136         if msgType == xapp.RIC_SUB_FAILURE {
 137                 prefixString = "RICSubscriptionFailure"
 138                 err := fmt.Errorf("%s", prefixString)
 139                 errorInfo.SetInfo(err.Error(), models.SubscriptionInstanceErrorSourceE2Node, "")
 140         }
 141         err := fmt.Errorf("%s %s", prefixString, actionNotAdmittedString)
 142         errorInfo.SetInfo(err.Error(), models.SubscriptionInstanceErrorSourceE2Node, "")
 143         return errorInfo
 144 }
 145
 146 //-----------------------------------------------------------------------------
 147 //
 148 //-----------------------------------------------------------------------------
 149 func (e *E2ap) UnpackSubscriptionRequest(payload []byte) (*e2ap.E2APSubscriptionRequest, error) {
 150         e2SubReq := packerif.NewPackerSubscriptionRequest()
 151         err, subReq := e2SubReq.UnPack(&e2ap.PackedData{payload})
 152         if err != nil {
 153                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 154         }
 155         return subReq, nil
 156 }
 157
 158 func (c *E2ap) PackSubscriptionRequest(req *e2ap.E2APSubscriptionRequest) (int, *e2ap.PackedData, error) {
 159         e2SubReq := packerif.NewPackerSubscriptionRequest()
 160         err, packedData := e2SubReq.Pack(req)
 161         if err != nil {
 162                 return 0, nil, err
 163         }
 164         return xapp.RIC_SUB_REQ, packedData, nil
 165 }
 166
 167 //-----------------------------------------------------------------------------
 168 //
 169 //-----------------------------------------------------------------------------
 170 func (e *E2ap) UnpackSubscriptionResponse(payload []byte) (*e2ap.E2APSubscriptionResponse, error) {
 171         e2SubResp := packerif.NewPackerSubscriptionResponse()
 172         err, subResp := e2SubResp.UnPack(&e2ap.PackedData{payload})
 173         if err != nil {
 174                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 175         }
 176         return subResp, nil
 177 }
 178
 179 func (e *E2ap) PackSubscriptionResponse(req *e2ap.E2APSubscriptionResponse) (int, *e2ap.PackedData, error) {
 180         e2SubResp := packerif.NewPackerSubscriptionResponse()
 181         err, packedData := e2SubResp.Pack(req)
 182         if err != nil {
 183                 return 0, nil, err
 184         }
 185         return xapp.RIC_SUB_RESP, packedData, nil
 186 }
 187
 188 //-----------------------------------------------------------------------------
 189 //
 190 //-----------------------------------------------------------------------------
 191 func (e *E2ap) UnpackSubscriptionFailure(payload []byte) (*e2ap.E2APSubscriptionFailure, error) {
 192         e2SubFail := packerif.NewPackerSubscriptionFailure()
 193         err, subFail := e2SubFail.UnPack(&e2ap.PackedData{payload})
 194         if err != nil {
 195                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 196         }
 197         return subFail, nil
 198 }
 199
 200 func (e *E2ap) PackSubscriptionFailure(req *e2ap.E2APSubscriptionFailure) (int, *e2ap.PackedData, error) {
 201         e2SubFail := packerif.NewPackerSubscriptionFailure()
 202         err, packedData := e2SubFail.Pack(req)
 203         if err != nil {
 204                 return 0, nil, err
 205         }
 206         return xapp.RIC_SUB_FAILURE, packedData, nil
 207 }
 208
 209 //-----------------------------------------------------------------------------
 210 //
 211 //-----------------------------------------------------------------------------
 212 func (e *E2ap) UnpackSubscriptionDeleteRequest(payload []byte) (*e2ap.E2APSubscriptionDeleteRequest, error) {
 213         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 214         err, subDelReq := e2SubDelReq.UnPack(&e2ap.PackedData{payload})
 215         if err != nil {
 216                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 217         }
 218         return subDelReq, nil
 219 }
 220
 221 func (e *E2ap) PackSubscriptionDeleteRequest(req *e2ap.E2APSubscriptionDeleteRequest) (int, *e2ap.PackedData, error) {
 222         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 223         err, packedData := e2SubDelReq.Pack(req)
 224         if err != nil {
 225                 return 0, nil, err
 226         }
 227         return xapp.RIC_SUB_DEL_REQ, packedData, nil
 228 }
 229
 230 //-----------------------------------------------------------------------------
 231 //
 232 //-----------------------------------------------------------------------------
 233 func (e *E2ap) UnpackSubscriptionDeleteResponse(payload []byte) (*e2ap.E2APSubscriptionDeleteResponse, error) {
 234         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 235         err, subDelResp := e2SubDelResp.UnPack(&e2ap.PackedData{payload})
 236         if err != nil {
 237                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 238         }
 239         return subDelResp, nil
 240 }
 241
 242 func (e *E2ap) PackSubscriptionDeleteResponse(req *e2ap.E2APSubscriptionDeleteResponse) (int, *e2ap.PackedData, error) {
 243         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 244         err, packedData := e2SubDelResp.Pack(req)
 245         if err != nil {
 246                 return 0, nil, err
 247         }
 248         return xapp.RIC_SUB_DEL_RESP, packedData, nil
 249 }
 250
 251 //-----------------------------------------------------------------------------
 252 //
 253 //-----------------------------------------------------------------------------
 254 func (e *E2ap) UnpackSubscriptionDeleteFailure(payload []byte) (*e2ap.E2APSubscriptionDeleteFailure, error) {
 255         e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
 256         err, subDelFail := e2SubDelFail.UnPack(&e2ap.PackedData{payload})
 257         if err != nil {
 258                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 259         }
 260         return subDelFail, nil
 261 }
 262
 263 /*
 264 func (e *E2ap) PackSubscriptionDeleteFailure(req *e2ap.E2APSubscriptionDeleteFailure) (int, *e2ap.PackedData, error) {
 265         e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
 266         err, packedData := e2SubDelFail.Pack(req)
 267         if err != nil {
 268                 return 0, nil, err
 269         }
 270         return xapp.RIC_SUB_DEL_FAILURE, packedData, nil
 271 }
 272 */
 273
 274 //-----------------------------------------------------------------------------
 275 // Changes to support "RIC_SUB_DEL_REQUIRED"
 276 //-----------------------------------------------------------------------------
 277 func (c *E2ap) UnpackSubscriptionDeleteRequired(payload []byte) (*e2ap.SubscriptionDeleteRequiredList, error) {
 278         e2SubDelRequ := packerif.NewPackerSubscriptionDeleteRequired()
 279         err, subsToBeRemove := e2SubDelRequ.UnPack(&e2ap.PackedData{payload})
 280         if err != nil {
 281                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 282         }
 283         return subsToBeRemove, nil
 284 }
 285
 286 func (c *E2ap) PackSubscriptionDeleteRequired(req *e2ap.SubscriptionDeleteRequiredList) (int, *e2ap.PackedData, error) {
 287         e2SubDelRequ := packerif.NewPackerSubscriptionDeleteRequired()
 288         err, packedData := e2SubDelRequ.Pack(req)
 289         if err != nil {
 290                 return 0, nil, err
 291         }
 292         return xapp.RIC_SUB_DEL_REQUIRED, packedData, nil
 293 }