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