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