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
 132         if msgType == xapp.RIC_SUB_FAILURE {
 133                 prefixString = "RICSubscriptionFailure"
 134                 err := fmt.Errorf("%s", prefixString)
 135                 errorInfo.SetInfo(err.Error(), models.SubscriptionInstanceErrorSourceE2Node, "")
 136         }
 137         err := fmt.Errorf("%s %s", prefixString, actionNotAdmittedString)
 138         errorInfo.SetInfo(err.Error(), models.SubscriptionInstanceErrorSourceE2Node, "")
 139         return errorInfo
 140 }
 141
 142 //-----------------------------------------------------------------------------
 143 //
 144 //-----------------------------------------------------------------------------
 145 func (e *E2ap) UnpackSubscriptionRequest(payload []byte) (*e2ap.E2APSubscriptionRequest, error) {
 146         e2SubReq := packerif.NewPackerSubscriptionRequest()
 147         err, subReq := e2SubReq.UnPack(&e2ap.PackedData{payload})
 148         if err != nil {
 149                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 150         }
 151         return subReq, nil
 152 }
 153
 154 func (c *E2ap) PackSubscriptionRequest(req *e2ap.E2APSubscriptionRequest) (int, *e2ap.PackedData, error) {
 155         e2SubReq := packerif.NewPackerSubscriptionRequest()
 156         err, packedData := e2SubReq.Pack(req)
 157         if err != nil {
 158                 return 0, nil, err
 159         }
 160         return xapp.RIC_SUB_REQ, packedData, nil
 161 }
 162
 163 //-----------------------------------------------------------------------------
 164 //
 165 //-----------------------------------------------------------------------------
 166 func (e *E2ap) UnpackSubscriptionResponse(payload []byte) (*e2ap.E2APSubscriptionResponse, error) {
 167         e2SubResp := packerif.NewPackerSubscriptionResponse()
 168         err, subResp := e2SubResp.UnPack(&e2ap.PackedData{payload})
 169         if err != nil {
 170                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 171         }
 172         return subResp, nil
 173 }
 174
 175 func (e *E2ap) PackSubscriptionResponse(req *e2ap.E2APSubscriptionResponse) (int, *e2ap.PackedData, error) {
 176         e2SubResp := packerif.NewPackerSubscriptionResponse()
 177         err, packedData := e2SubResp.Pack(req)
 178         if err != nil {
 179                 return 0, nil, err
 180         }
 181         return xapp.RIC_SUB_RESP, packedData, nil
 182 }
 183
 184 //-----------------------------------------------------------------------------
 185 //
 186 //-----------------------------------------------------------------------------
 187 func (e *E2ap) UnpackSubscriptionFailure(payload []byte) (*e2ap.E2APSubscriptionFailure, error) {
 188         e2SubFail := packerif.NewPackerSubscriptionFailure()
 189         err, subFail := e2SubFail.UnPack(&e2ap.PackedData{payload})
 190         if err != nil {
 191                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 192         }
 193         return subFail, nil
 194 }
 195
 196 func (e *E2ap) PackSubscriptionFailure(req *e2ap.E2APSubscriptionFailure) (int, *e2ap.PackedData, error) {
 197         e2SubFail := packerif.NewPackerSubscriptionFailure()
 198         err, packedData := e2SubFail.Pack(req)
 199         if err != nil {
 200                 return 0, nil, err
 201         }
 202         return xapp.RIC_SUB_FAILURE, packedData, nil
 203 }
 204
 205 //-----------------------------------------------------------------------------
 206 //
 207 //-----------------------------------------------------------------------------
 208 func (e *E2ap) UnpackSubscriptionDeleteRequest(payload []byte) (*e2ap.E2APSubscriptionDeleteRequest, error) {
 209         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 210         err, subDelReq := e2SubDelReq.UnPack(&e2ap.PackedData{payload})
 211         if err != nil {
 212                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 213         }
 214         return subDelReq, nil
 215 }
 216
 217 func (e *E2ap) PackSubscriptionDeleteRequest(req *e2ap.E2APSubscriptionDeleteRequest) (int, *e2ap.PackedData, error) {
 218         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 219         err, packedData := e2SubDelReq.Pack(req)
 220         if err != nil {
 221                 return 0, nil, err
 222         }
 223         return xapp.RIC_SUB_DEL_REQ, packedData, nil
 224 }
 225
 226 //-----------------------------------------------------------------------------
 227 //
 228 //-----------------------------------------------------------------------------
 229 func (e *E2ap) UnpackSubscriptionDeleteResponse(payload []byte) (*e2ap.E2APSubscriptionDeleteResponse, error) {
 230         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 231         err, subDelResp := e2SubDelResp.UnPack(&e2ap.PackedData{payload})
 232         if err != nil {
 233                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 234         }
 235         return subDelResp, nil
 236 }
 237
 238 func (e *E2ap) PackSubscriptionDeleteResponse(req *e2ap.E2APSubscriptionDeleteResponse) (int, *e2ap.PackedData, error) {
 239         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 240         err, packedData := e2SubDelResp.Pack(req)
 241         if err != nil {
 242                 return 0, nil, err
 243         }
 244         return xapp.RIC_SUB_DEL_RESP, packedData, nil
 245 }
 246
 247 //-----------------------------------------------------------------------------
 248 //
 249 //-----------------------------------------------------------------------------
 250 func (e *E2ap) UnpackSubscriptionDeleteFailure(payload []byte) (*e2ap.E2APSubscriptionDeleteFailure, error) {
 251         e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
 252         err, subDelFail := e2SubDelFail.UnPack(&e2ap.PackedData{payload})
 253         if err != nil {
 254                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 255         }
 256         return subDelFail, nil
 257 }
 258
 259 /*
 260 func (e *E2ap) PackSubscriptionDeleteFailure(req *e2ap.E2APSubscriptionDeleteFailure) (int, *e2ap.PackedData, error) {
 261         e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
 262         err, packedData := e2SubDelFail.Pack(req)
 263         if err != nil {
 264                 return 0, nil, err
 265         }
 266         return xapp.RIC_SUB_DEL_FAILURE, packedData, nil
 267 }
 268 */