X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fcontrol%2Ftracker.go;h=0e6941d7d37ce31e7d99d9152c75d2d56d7051eb;hb=refs%2Fchanges%2F77%2F2177%2F2;hp=65f816ee6cd037a193d67c7ae0211fc742d95b13;hpb=379ff082446038f3dee0f22d4f79c0965e9da25a;p=ric-plt%2Fsubmgr.git diff --git a/pkg/control/tracker.go b/pkg/control/tracker.go index 65f816e..0e6941d 100644 --- a/pkg/control/tracker.go +++ b/pkg/control/tracker.go @@ -22,100 +22,132 @@ package control import ( "fmt" "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp" + "strconv" "sync" ) -type TransactionKey struct { - SubID uint16 // subscription id / sequence number - TransType Action // action ongoing (CREATE/DELETE etc) +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +type TransactionXappKey struct { + RmrEndpoint + Xid string // xapp xid in req } -type TransactionXappKey struct { - Addr string // xapp addr - Port uint16 // xapp port - Xid string // xapp xid in req +func (key *TransactionXappKey) String() string { + return key.RmrEndpoint.String() + "/" + key.Xid } +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- type Transaction struct { - tracker *Tracker // tracker instance - Key TransactionKey // action key - Xappkey TransactionXappKey // transaction key - OrigParams *xapp.RMRParams // request orginal params + tracker *Tracker // tracker instance + Subs *Subscription + RmrEndpoint RmrEndpoint + Xid string // xapp xid in req + OrigParams *xapp.RMRParams // request orginal params + RespReceived bool + ForwardRespToXapp bool + mutex sync.Mutex } -func (t *Transaction) SubRouteInfo() SubRouteInfo { - return SubRouteInfo{t.Key.TransType, t.Xappkey.Addr, t.Xappkey.Port, t.Key.SubID} +func (t *Transaction) String() string { + t.mutex.Lock() + defer t.mutex.Unlock() + var subId string = "?" + if t.Subs != nil { + subId = strconv.FormatUint(uint64(t.Subs.Seq), 10) + } + return subId + "/" + t.RmrEndpoint.String() + "/" + t.Xid } -/* -Implements a record of ongoing transactions and helper functions to CRUD the records. -*/ +func (t *Transaction) CheckResponseReceived() bool { + t.mutex.Lock() + defer t.mutex.Unlock() + if t.RespReceived == false { + t.RespReceived = true + return false + } + return true +} + +func (t *Transaction) RetryTransaction() { + t.mutex.Lock() + defer t.mutex.Unlock() + t.RespReceived = false +} + +func (t *Transaction) Release() { + t.mutex.Lock() + defer t.mutex.Unlock() + if t.Subs != nil { + t.Subs.UnSetTransaction(t) + } + if t.tracker != nil { + xappkey := TransactionXappKey{t.RmrEndpoint, t.Xid} + t.tracker.UnTrackTransaction(xappkey) + } + t.Subs = nil + t.tracker = nil +} + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- type Tracker struct { - transactionTable map[TransactionKey]*Transaction transactionXappTable map[TransactionXappKey]*Transaction mutex sync.Mutex } func (t *Tracker) Init() { - t.transactionTable = make(map[TransactionKey]*Transaction) t.transactionXappTable = make(map[TransactionXappKey]*Transaction) } -/* -Checks if a tranascation with similar type has been ongoing. If not then creates one. -Returns error if there is similar transatcion ongoing. -*/ -func (t *Tracker) TrackTransaction(subID uint16, act Action, addr string, port uint16, params *xapp.RMRParams) (*Transaction, error) { - key := TransactionKey{subID, act} - xappkey := TransactionXappKey{addr, port, params.Xid} - trans := &Transaction{t, key, xappkey, params} +func (t *Tracker) TrackTransaction(subs *Subscription, endpoint RmrEndpoint, params *xapp.RMRParams, respReceived bool, forwardRespToXapp bool) (*Transaction, error) { + + trans := &Transaction{ + tracker: nil, + Subs: nil, + RmrEndpoint: endpoint, + Xid: params.Xid, + OrigParams: params, + RespReceived: respReceived, + ForwardRespToXapp: forwardRespToXapp, + } + t.mutex.Lock() defer t.mutex.Unlock() - if _, ok := t.transactionTable[key]; ok { - // TODO: Implement merge related check here. If the key is same but the value is different. - err := fmt.Errorf("transaction tracker: Similar transaction with sub id %d and type %s is ongoing", key.SubID, key.TransType) + + xappkey := TransactionXappKey{endpoint, params.Xid} + if _, ok := t.transactionXappTable[xappkey]; ok { + err := fmt.Errorf("Tracker: Similar transaction with xappkey %s is ongoing, transaction %s not created ", xappkey, trans) return nil, err } - if _, ok := t.transactionXappTable[xappkey]; ok { - // TODO: Implement merge related check here. If the key is same but the value is different. - err := fmt.Errorf("transaction tracker: Similar transaction with xapp key %v is ongoing", xappkey) + + if subs.SetTransaction(trans) == false { + othTrans := subs.GetTransaction() + err := fmt.Errorf("Tracker: Subscription %s got already transaction ongoing: %s, transaction %s not created", subs, othTrans, trans) + return nil, err + } + trans.Subs = subs + if (trans.Subs.RmrEndpoint.Addr != trans.RmrEndpoint.Addr) || (trans.Subs.RmrEndpoint.Port != trans.RmrEndpoint.Port) { + err := fmt.Errorf("Tracker: Subscription endpoint %s mismatch with trans: %s", subs, trans) + trans.Subs.UnSetTransaction(nil) return nil, err } - t.transactionTable[key] = trans + + trans.tracker = t t.transactionXappTable[xappkey] = trans return trans, nil } -/* -Retreives the transaction table entry for the given request. -Returns error in case the transaction cannot be found. -*/ -func (t *Tracker) RetriveTransaction(subID uint16, act Action) (*Transaction, error) { - key := TransactionKey{subID, act} - t.mutex.Lock() - defer t.mutex.Unlock() - if trans, ok := t.transactionTable[key]; ok { - return trans, nil - } - err := fmt.Errorf("transaction record for Subscription ID %d and action %s does not exist", subID, act) - return nil, err -} - -/* -Deletes the transaction table entry for the given request and returns the deleted xapp's address and port for reference. -Returns error in case the transaction cannot be found. -*/ -func (t *Tracker) completeTransaction(subID uint16, act Action) (*Transaction, error) { - key := TransactionKey{subID, act} +func (t *Tracker) UnTrackTransaction(xappKey TransactionXappKey) (*Transaction, error) { t.mutex.Lock() defer t.mutex.Unlock() - if trans, ok1 := t.transactionTable[key]; ok1 { - if _, ok2 := t.transactionXappTable[trans.Xappkey]; ok2 { - delete(t.transactionXappTable, trans.Xappkey) - } - delete(t.transactionTable, key) + if trans, ok2 := t.transactionXappTable[xappKey]; ok2 { + delete(t.transactionXappTable, xappKey) return trans, nil } - err := fmt.Errorf("transaction record for Subscription ID %d and action %s does not exist", subID, act) - return nil, err + return nil, fmt.Errorf("Tracker: No record for xappkey %s", xappKey) }