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         "fmt"
  30
  31         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
  32         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
  33         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
  34         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  35 )
  36
  37 var packerif e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
  38
  39 func GetPackerIf() e2ap.E2APPackerIf {
  40         return packerif
  41 }
  42
  43 func SetPackerIf(iface e2ap.E2APPackerIf) {
  44         packerif = iface
  45 }
  46
  47 type E2ap struct {
  48 }
  49
  50 //-----------------------------------------------------------------------------
  51 //
  52 //-----------------------------------------------------------------------------
  53 func (c *E2ap) SetASN1DebugPrintStatus(logLevel int) {
  54         e2ap_wrapper.SetASN1DebugPrintStatus(logLevel)
  55 }
  56
  57 //-----------------------------------------------------------------------------
  58 //
  59 //-----------------------------------------------------------------------------
  60 func (c *E2ap) FillSubscriptionReqMsgs(params interface{}, subreqList *e2ap.SubscriptionRequestList, restSubscription *RESTSubscription) error {
  61         xapp.Logger.Debug("FillSubscriptionReqMsgs")
  62
  63         p := params.(*models.SubscriptionParams)
  64
  65         for _, subscriptionDetail := range p.SubscriptionDetails {
  66                 subReqMsg := e2ap.E2APSubscriptionRequest{}
  67
  68                 if p.RANFunctionID != nil {
  69                         subReqMsg.FunctionId = (e2ap.FunctionId)(*p.RANFunctionID)
  70                 }
  71                 e2EventInstanceID := restSubscription.GetE2IdFromXappIdToE2Id(*subscriptionDetail.XappEventInstanceID)
  72                 subReqMsg.RequestId = e2ap.RequestId{uint32(*subscriptionDetail.XappEventInstanceID), uint32(e2EventInstanceID)}
  73
  74                 if len(subscriptionDetail.EventTriggers) > 0 {
  75                         for _, val := range subscriptionDetail.EventTriggers {
  76                                 subReqMsg.EventTriggerDefinition.Data.Data = append(subReqMsg.EventTriggerDefinition.Data.Data, byte(val))
  77                         }
  78                         subReqMsg.EventTriggerDefinition.Data.Length = uint64(len(subscriptionDetail.EventTriggers))
  79                 }
  80                 for _, actionToBeSetup := range subscriptionDetail.ActionToBeSetupList {
  81                         actionToBeSetupItem := e2ap.ActionToBeSetupItem{}
  82                         actionToBeSetupItem.ActionType = e2ap.E2AP_ActionTypeInvalid
  83                         actionToBeSetupItem.ActionId = uint64(*actionToBeSetup.ActionID)
  84
  85                         actionToBeSetupItem.ActionType = e2ap.E2AP_ActionTypeStrMap[*actionToBeSetup.ActionType]
  86                         actionToBeSetupItem.RicActionDefinitionPresent = true
  87
  88                         if len(actionToBeSetup.ActionDefinition) > 0 {
  89                                 for _, val := range actionToBeSetup.ActionDefinition {
  90                                         actionToBeSetupItem.ActionDefinitionChoice.Data.Data = append(actionToBeSetupItem.ActionDefinitionChoice.Data.Data, byte(val))
  91                                 }
  92                                 actionToBeSetupItem.ActionDefinitionChoice.Data.Length = uint64(len(actionToBeSetup.ActionDefinition))
  93
  94                         }
  95                         if actionToBeSetup.SubsequentAction != nil {
  96                                 actionToBeSetupItem.SubsequentAction.Present = true
  97                                 actionToBeSetupItem.SubsequentAction.Type = e2ap.E2AP_SubSeqActionTypeStrMap[*actionToBeSetup.SubsequentAction.SubsequentActionType]
  98                                 actionToBeSetupItem.SubsequentAction.TimetoWait = e2ap.E2AP_TimeToWaitStrMap[*actionToBeSetup.SubsequentAction.TimeToWait]
  99                         }
 100                         subReqMsg.ActionSetups = append(subReqMsg.ActionSetups, actionToBeSetupItem)
 101                 }
 102                 subreqList.E2APSubscriptionRequests = append(subreqList.E2APSubscriptionRequests, subReqMsg)
 103         }
 104         return nil
 105 }
 106
 107 //-----------------------------------------------------------------------------
 108 //
 109 //-----------------------------------------------------------------------------
 110 func (c *E2ap) UnpackSubscriptionRequest(payload []byte) (*e2ap.E2APSubscriptionRequest, error) {
 111         e2SubReq := packerif.NewPackerSubscriptionRequest()
 112         err, subReq := e2SubReq.UnPack(&e2ap.PackedData{payload})
 113         if err != nil {
 114                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 115         }
 116         return subReq, nil
 117 }
 118
 119 func (c *E2ap) PackSubscriptionRequest(req *e2ap.E2APSubscriptionRequest) (int, *e2ap.PackedData, error) {
 120         e2SubReq := packerif.NewPackerSubscriptionRequest()
 121         err, packedData := e2SubReq.Pack(req)
 122         if err != nil {
 123                 return 0, nil, err
 124         }
 125         return xapp.RIC_SUB_REQ, packedData, nil
 126 }
 127
 128 //-----------------------------------------------------------------------------
 129 //
 130 //-----------------------------------------------------------------------------
 131 func (c *E2ap) UnpackSubscriptionResponse(payload []byte) (*e2ap.E2APSubscriptionResponse, error) {
 132         e2SubResp := packerif.NewPackerSubscriptionResponse()
 133         err, subResp := e2SubResp.UnPack(&e2ap.PackedData{payload})
 134         if err != nil {
 135                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 136         }
 137         return subResp, nil
 138 }
 139
 140 func (c *E2ap) PackSubscriptionResponse(req *e2ap.E2APSubscriptionResponse) (int, *e2ap.PackedData, error) {
 141         e2SubResp := packerif.NewPackerSubscriptionResponse()
 142         err, packedData := e2SubResp.Pack(req)
 143         if err != nil {
 144                 return 0, nil, err
 145         }
 146         return xapp.RIC_SUB_RESP, packedData, nil
 147 }
 148
 149 //-----------------------------------------------------------------------------
 150 //
 151 //-----------------------------------------------------------------------------
 152 func (c *E2ap) UnpackSubscriptionFailure(payload []byte) (*e2ap.E2APSubscriptionFailure, error) {
 153         e2SubFail := packerif.NewPackerSubscriptionFailure()
 154         err, subFail := e2SubFail.UnPack(&e2ap.PackedData{payload})
 155         if err != nil {
 156                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 157         }
 158         return subFail, nil
 159 }
 160
 161 func (c *E2ap) PackSubscriptionFailure(req *e2ap.E2APSubscriptionFailure) (int, *e2ap.PackedData, error) {
 162         e2SubFail := packerif.NewPackerSubscriptionFailure()
 163         err, packedData := e2SubFail.Pack(req)
 164         if err != nil {
 165                 return 0, nil, err
 166         }
 167         return xapp.RIC_SUB_FAILURE, packedData, nil
 168 }
 169
 170 //-----------------------------------------------------------------------------
 171 //
 172 //-----------------------------------------------------------------------------
 173 func (c *E2ap) UnpackSubscriptionDeleteRequest(payload []byte) (*e2ap.E2APSubscriptionDeleteRequest, error) {
 174         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 175         err, subDelReq := e2SubDelReq.UnPack(&e2ap.PackedData{payload})
 176         if err != nil {
 177                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 178         }
 179         return subDelReq, nil
 180 }
 181
 182 func (c *E2ap) PackSubscriptionDeleteRequest(req *e2ap.E2APSubscriptionDeleteRequest) (int, *e2ap.PackedData, error) {
 183         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 184         err, packedData := e2SubDelReq.Pack(req)
 185         if err != nil {
 186                 return 0, nil, err
 187         }
 188         return xapp.RIC_SUB_DEL_REQ, packedData, nil
 189 }
 190
 191 //-----------------------------------------------------------------------------
 192 //
 193 //-----------------------------------------------------------------------------
 194 func (c *E2ap) UnpackSubscriptionDeleteResponse(payload []byte) (*e2ap.E2APSubscriptionDeleteResponse, error) {
 195         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 196         err, subDelResp := e2SubDelResp.UnPack(&e2ap.PackedData{payload})
 197         if err != nil {
 198                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 199         }
 200         return subDelResp, nil
 201 }
 202
 203 func (c *E2ap) PackSubscriptionDeleteResponse(req *e2ap.E2APSubscriptionDeleteResponse) (int, *e2ap.PackedData, error) {
 204         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 205         err, packedData := e2SubDelResp.Pack(req)
 206         if err != nil {
 207                 return 0, nil, err
 208         }
 209         return xapp.RIC_SUB_DEL_RESP, packedData, nil
 210 }
 211
 212 //-----------------------------------------------------------------------------
 213 //
 214 //-----------------------------------------------------------------------------
 215 func (c *E2ap) UnpackSubscriptionDeleteFailure(payload []byte) (*e2ap.E2APSubscriptionDeleteFailure, error) {
 216         e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
 217         err, subDelFail := e2SubDelFail.UnPack(&e2ap.PackedData{payload})
 218         if err != nil {
 219                 return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
 220         }
 221         return subDelFail, nil
 222 }
 223
 224 /*
 225 func (c *E2ap) PackSubscriptionDeleteFailure(req *e2ap.E2APSubscriptionDeleteFailure) (int, *e2ap.PackedData, error) {
 226         e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
 227         err, packedData := e2SubDelFail.Pack(req)
 228         if err != nil {
 229                 return 0, nil, err
 230         }
 231         return xapp.RIC_SUB_DEL_FAILURE, packedData, nil
 232 }
 233 */