e2ap/pkg/e2ap/e2ap_packerif.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 e2ap
  21
  22 import (
  23         "fmt"
  24         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/packer"
  25 )
  26
  27 //-----------------------------------------------------------------------------
  28 //
  29 //-----------------------------------------------------------------------------
  30 type E2APMsgPackerIf interface {
  31         Pack(*packer.PackedData) (error, *packer.PackedData)
  32         UnPack(msg *packer.PackedData) error
  33         String() string
  34 }
  35
  36 //-----------------------------------------------------------------------------
  37 //
  38 //-----------------------------------------------------------------------------
  39 type E2APMsgPackerSubscriptionRequestIf interface {
  40         E2APMsgPackerIf
  41         Set(*E2APSubscriptionRequest) error
  42         Get() (error, *E2APSubscriptionRequest)
  43 }
  44
  45 //-----------------------------------------------------------------------------
  46 //
  47 //-----------------------------------------------------------------------------
  48 type E2APMsgPackerSubscriptionResponseIf interface {
  49         E2APMsgPackerIf
  50         Set(*E2APSubscriptionResponse) error
  51         Get() (error, *E2APSubscriptionResponse)
  52 }
  53
  54 //-----------------------------------------------------------------------------
  55 //
  56 //-----------------------------------------------------------------------------
  57 type E2APMsgPackerSubscriptionFailureIf interface {
  58         E2APMsgPackerIf
  59         Set(*E2APSubscriptionFailure) error
  60         Get() (error, *E2APSubscriptionFailure)
  61 }
  62
  63 //-----------------------------------------------------------------------------
  64 //
  65 //-----------------------------------------------------------------------------
  66 type E2APMsgPackerSubscriptionDeleteRequestIf interface {
  67         E2APMsgPackerIf
  68         Set(*E2APSubscriptionDeleteRequest) error
  69         Get() (error, *E2APSubscriptionDeleteRequest)
  70 }
  71
  72 //-----------------------------------------------------------------------------
  73 //
  74 //-----------------------------------------------------------------------------
  75 type E2APMsgPackerSubscriptionDeleteResponseIf interface {
  76         E2APMsgPackerIf
  77         Set(*E2APSubscriptionDeleteResponse) error
  78         Get() (error, *E2APSubscriptionDeleteResponse)
  79 }
  80
  81 //-----------------------------------------------------------------------------
  82 //
  83 //-----------------------------------------------------------------------------
  84 type E2APMsgPackerSubscriptionDeleteFailureIf interface {
  85         E2APMsgPackerIf
  86         Set(*E2APSubscriptionDeleteFailure) error
  87         Get() (error, *E2APSubscriptionDeleteFailure)
  88 }
  89
  90 //-----------------------------------------------------------------------------
  91 //
  92 //-----------------------------------------------------------------------------
  93 type E2APPackerIf interface {
  94         NewPackerSubscriptionRequest() E2APMsgPackerSubscriptionRequestIf
  95         NewPackerSubscriptionResponse() E2APMsgPackerSubscriptionResponseIf
  96         NewPackerSubscriptionFailure() E2APMsgPackerSubscriptionFailureIf
  97         NewPackerSubscriptionDeleteRequest() E2APMsgPackerSubscriptionDeleteRequestIf
  98         NewPackerSubscriptionDeleteResponse() E2APMsgPackerSubscriptionDeleteResponseIf
  99         NewPackerSubscriptionDeleteFailure() E2APMsgPackerSubscriptionDeleteFailureIf
 100         MessageInfo(msg *packer.PackedData) *packer.MessageInfo
 101 }
 102
 103 //-----------------------------------------------------------------------------
 104 //
 105 //-----------------------------------------------------------------------------
 106 type E2APAutoPacker struct {
 107         packer E2APPackerIf
 108 }
 109
 110 func NewE2APAutoPacker(packer E2APPackerIf) *E2APAutoPacker {
 111         return &E2APAutoPacker{packer: packer}
 112 }
 113
 114 // TODO improve openasn handling to reuse PDU etc...
 115 // Now practically decodes two times each E2/X2 message, as first round solves message type
 116 func (autopacker *E2APAutoPacker) UnPack(msg *packer.PackedData) (error, interface{}) {
 117         var err error = nil
 118         msgInfo := autopacker.packer.MessageInfo(msg)
 119         if msgInfo != nil {
 120                 switch msgInfo.MsgType {
 121                 case E2AP_InitiatingMessage:
 122                         switch msgInfo.MsgId {
 123                         case E2AP_RICSubscriptionRequest:
 124                                 unpa := autopacker.packer.NewPackerSubscriptionRequest()
 125                                 err = unpa.UnPack(msg)
 126                                 if err == nil {
 127                                         return unpa.Get()
 128                                 }
 129                         case E2AP_RICSubscriptionDeleteRequest:
 130                                 unpa := autopacker.packer.NewPackerSubscriptionDeleteRequest()
 131                                 err = unpa.UnPack(msg)
 132                                 if err == nil {
 133                                         return unpa.Get()
 134                                 }
 135                         default:
 136                                 err = fmt.Errorf("MsgType: E2AP_InitiatingMessage => MsgId:%d unknown", msgInfo.MsgId)
 137                         }
 138                 case E2AP_SuccessfulOutcome:
 139                         switch msgInfo.MsgId {
 140                         case E2AP_RICSubscriptionResponse:
 141                                 unpa := autopacker.packer.NewPackerSubscriptionResponse()
 142                                 err = unpa.UnPack(msg)
 143                                 if err == nil {
 144                                         return unpa.Get()
 145                                 }
 146                         case E2AP_RICSubscriptionDeleteResponse:
 147                                 unpa := autopacker.packer.NewPackerSubscriptionDeleteResponse()
 148                                 err = unpa.UnPack(msg)
 149                                 if err == nil {
 150                                         return unpa.Get()
 151                                 }
 152                         default:
 153                                 err = fmt.Errorf("MsgType: E2AP_SuccessfulOutcome => MsgId:%d unknown", msgInfo.MsgId)
 154                         }
 155                 case E2AP_UnsuccessfulOutcome:
 156                         switch msgInfo.MsgId {
 157                         case E2AP_RICSubscriptionFailure:
 158                                 unpa := autopacker.packer.NewPackerSubscriptionFailure()
 159                                 err = unpa.UnPack(msg)
 160                                 if err == nil {
 161                                         return unpa.Get()
 162                                 }
 163                         case E2AP_RICSubscriptionDeleteFailure:
 164                                 unpa := autopacker.packer.NewPackerSubscriptionDeleteFailure()
 165                                 err = unpa.UnPack(msg)
 166                                 if err == nil {
 167                                         return unpa.Get()
 168                                 }
 169                         default:
 170                                 err = fmt.Errorf("MsgType: E2AP_UnsuccessfulOutcome => MsgId:%d unknown", msgInfo.MsgId)
 171                         }
 172                 default:
 173                         err = fmt.Errorf("MsgType: %d and MsgId:%d unknown", msgInfo.MsgType, msgInfo.MsgId)
 174                 }
 175         } else {
 176                 err = fmt.Errorf("MsgInfo not received")
 177         }
 178         return err, nil
 179 }
 180
 181 func (autopacker *E2APAutoPacker) Pack(data interface{}, trg *packer.PackedData) (error, *packer.PackedData) {
 182         var err error = nil
 183         switch themsg := data.(type) {
 184         case *E2APSubscriptionRequest:
 185                 pa := autopacker.packer.NewPackerSubscriptionRequest()
 186                 err = pa.Set(themsg)
 187                 if err == nil {
 188                         return pa.Pack(trg)
 189                 }
 190         case *E2APSubscriptionResponse:
 191                 pa := autopacker.packer.NewPackerSubscriptionResponse()
 192                 err = pa.Set(themsg)
 193                 if err == nil {
 194                         return pa.Pack(trg)
 195                 }
 196         case *E2APSubscriptionFailure:
 197                 pa := autopacker.packer.NewPackerSubscriptionFailure()
 198                 err = pa.Set(themsg)
 199                 if err == nil {
 200                         return pa.Pack(trg)
 201                 }
 202         case *E2APSubscriptionDeleteRequest:
 203                 pa := autopacker.packer.NewPackerSubscriptionDeleteRequest()
 204                 err = pa.Set(themsg)
 205                 if err == nil {
 206                         return pa.Pack(trg)
 207                 }
 208         case *E2APSubscriptionDeleteResponse:
 209                 pa := autopacker.packer.NewPackerSubscriptionDeleteResponse()
 210                 err = pa.Set(themsg)
 211                 if err == nil {
 212                         return pa.Pack(trg)
 213                 }
 214         case *E2APSubscriptionDeleteFailure:
 215                 pa := autopacker.packer.NewPackerSubscriptionDeleteFailure()
 216                 err = pa.Set(themsg)
 217                 if err == nil {
 218                         return pa.Pack(trg)
 219                 }
 220         default:
 221                 err = fmt.Errorf("unknown message")
 222         }
 223         return err, nil
 224 }