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