pkg/control/transaction.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 import (
  23         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
  24         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  25         "strconv"
  26         "sync"
  27         "time"
  28 )
  29
  30 //-----------------------------------------------------------------------------
  31 //
  32 //-----------------------------------------------------------------------------
  33 type TransactionIf interface {
  34         String() string
  35         Release()
  36         SendEvent(interface{}, time.Duration) (bool, bool)
  37         WaitEvent(time.Duration) (interface{}, bool)
  38 }
  39
  40 //-----------------------------------------------------------------------------
  41 //
  42 //-----------------------------------------------------------------------------
  43
  44 type Transaction struct {
  45         mutex     sync.Mutex       //
  46         Seq       uint64           //transaction sequence
  47         tracker   *Tracker         //tracker instance
  48         Meid      *xapp.RMRMeid    //meid transaction related
  49         Mtype     int              //Encoded message type to be send
  50         Payload   *e2ap.PackedData //Encoded message to be send
  51         EventChan chan interface{}
  52 }
  53
  54 func (t *Transaction) String() string {
  55         return "trans(" + strconv.FormatUint(uint64(t.Seq), 10) + "/" + t.Meid.RanName + ")"
  56 }
  57
  58 func (t *Transaction) SendEvent(event interface{}, waittime time.Duration) (bool, bool) {
  59         if waittime > 0 {
  60                 select {
  61                 case t.EventChan <- event:
  62                         return true, false
  63                 case <-time.After(waittime):
  64                         return false, true
  65                 }
  66                 return false, false
  67         }
  68         t.EventChan <- event
  69         return true, false
  70 }
  71
  72 func (t *Transaction) WaitEvent(waittime time.Duration) (interface{}, bool) {
  73         if waittime > 0 {
  74                 select {
  75                 case event := <-t.EventChan:
  76                         return event, false
  77                 case <-time.After(waittime):
  78                         return nil, true
  79                 }
  80         }
  81         event := <-t.EventChan
  82         return event, false
  83 }
  84
  85 func (t *Transaction) GetMtype() int {
  86         t.mutex.Lock()
  87         defer t.mutex.Unlock()
  88         return t.Mtype
  89 }
  90
  91 func (t *Transaction) GetMeid() *xapp.RMRMeid {
  92         t.mutex.Lock()
  93         defer t.mutex.Unlock()
  94         if t.Meid != nil {
  95                 return t.Meid
  96         }
  97         return nil
  98 }
  99
 100 func (t *Transaction) GetPayload() *e2ap.PackedData {
 101         t.mutex.Lock()
 102         defer t.mutex.Unlock()
 103         return t.Payload
 104 }
 105
 106 //-----------------------------------------------------------------------------
 107 //
 108 //-----------------------------------------------------------------------------
 109 type TransactionSubs struct {
 110         Transaction //
 111 }
 112
 113 func (t *TransactionSubs) String() string {
 114         return "transsubs(" + t.Transaction.String() + ")"
 115 }
 116
 117 func (t *TransactionSubs) Release() {
 118         t.mutex.Lock()
 119         xapp.Logger.Debug("RELEASE %s", t.String())
 120         t.tracker = nil
 121         t.mutex.Unlock()
 122 }
 123
 124 //-----------------------------------------------------------------------------
 125 //
 126 //-----------------------------------------------------------------------------
 127 type TransactionXappKey struct {
 128         RmrEndpoint
 129         Xid string // xapp xid in req
 130 }
 131
 132 func (key *TransactionXappKey) String() string {
 133         return "transkey(" + key.RmrEndpoint.String() + "/" + key.Xid + ")"
 134 }
 135
 136 //-----------------------------------------------------------------------------
 137 //
 138 //-----------------------------------------------------------------------------
 139 type TransactionXapp struct {
 140         Transaction
 141         XappKey *TransactionXappKey
 142         SubId   uint32
 143 }
 144
 145 func (t *TransactionXapp) String() string {
 146         var transkey string = "transkey(N/A)"
 147         if t.XappKey != nil {
 148                 transkey = t.XappKey.String()
 149         }
 150         return "transxapp(" + t.Transaction.String() + "/" + transkey + "/" + strconv.FormatUint(uint64(t.SubId), 10) + ")"
 151 }
 152
 153 func (t *TransactionXapp) GetEndpoint() *RmrEndpoint {
 154         t.mutex.Lock()
 155         defer t.mutex.Unlock()
 156         if t.XappKey != nil {
 157                 return &t.XappKey.RmrEndpoint
 158         }
 159         return nil
 160 }
 161
 162 func (t *TransactionXapp) GetXid() string {
 163         t.mutex.Lock()
 164         defer t.mutex.Unlock()
 165         if t.XappKey != nil {
 166                 return t.XappKey.Xid
 167         }
 168         return ""
 169 }
 170
 171 func (t *TransactionXapp) GetSrc() string {
 172         t.mutex.Lock()
 173         defer t.mutex.Unlock()
 174         if t.XappKey != nil {
 175                 return t.XappKey.RmrEndpoint.String()
 176         }
 177         return ""
 178 }
 179
 180 func (t *TransactionXapp) GetSubId() uint32 {
 181         t.mutex.Lock()
 182         defer t.mutex.Unlock()
 183         return t.SubId
 184 }
 185
 186 func (t *TransactionXapp) Release() {
 187         t.mutex.Lock()
 188         xapp.Logger.Debug("RELEASE %s", t.String())
 189         tracker := t.tracker
 190         xappkey := t.XappKey
 191         t.tracker = nil
 192         t.mutex.Unlock()
 193
 194         if tracker != nil && xappkey != nil {
 195                 tracker.UnTrackTransaction(*xappkey)
 196         }
 197 }