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