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=1682ae7554fb3bb888e1476027c99ebdabcfd6be;hpb=ff8dccd02d76eebfccc0b509ce0b42a2c1760e12;p=ric-plt%2Fsubmgr.git diff --git a/pkg/control/tracker.go b/pkg/control/tracker.go index 1682ae7..0e6941d 100644 --- a/pkg/control/tracker.go +++ b/pkg/control/tracker.go @@ -21,83 +21,133 @@ package control import ( "fmt" + "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp" + "strconv" "sync" ) -/* -Implements a record of ongoing transactions and helper functions to CRUD the records. -*/ -type Tracker struct { - transactionTable map[TransactionKey]Transaction - mutex sync.Mutex +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +type TransactionXappKey struct { + RmrEndpoint + Xid string // xapp xid in req } -func (t *Tracker) Init() { - t.transactionTable = make(map[TransactionKey]Transaction) +func (key *TransactionXappKey) String() string { + return key.RmrEndpoint.String() + "/" + key.Xid } -/* -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(key TransactionKey, xact Transaction) error { +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +type Transaction struct { + 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) String() string { 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) - return err + var subId string = "?" + if t.Subs != nil { + subId = strconv.FormatUint(uint64(t.Subs.Seq), 10) } - t.transactionTable[key] = xact - return nil + return subId + "/" + t.RmrEndpoint.String() + "/" + t.Xid } -/* -Retreives the transaction table entry for the given request. -Returns error in case the transaction cannot be found. -*/ -func (t *Tracker) UpdateTransaction(SubID uint16, transType Action, xact Transaction) error { - key := TransactionKey{SubID, transType} +func (t *Transaction) CheckResponseReceived() bool { 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 %v is ongoing", key.SubID, key.transType) - return err + if t.RespReceived == false { + t.RespReceived = true + return false } - t.transactionTable[key] = xact - return nil + return true } -/* -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} +func (t *Transaction) RetryTransaction() { t.mutex.Lock() defer t.mutex.Unlock() - var xact Transaction - if xact, ok := t.transactionTable[key]; ok { - return xact, nil + 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) } - err := fmt.Errorf("transaction record for Subscription ID %d and action %s does not exist", subID, act) - return xact, err + t.Subs = nil + t.tracker = nil } -/* -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} - var emptyTransaction Transaction +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +type Tracker struct { + transactionXappTable map[TransactionXappKey]*Transaction + mutex sync.Mutex +} + +func (t *Tracker) Init() { + t.transactionXappTable = make(map[TransactionXappKey]*Transaction) +} + +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() + + 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 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 + } + + trans.tracker = t + t.transactionXappTable[xappkey] = trans + return trans, nil +} + +func (t *Tracker) UnTrackTransaction(xappKey TransactionXappKey) (*Transaction, error) { t.mutex.Lock() defer t.mutex.Unlock() - if xact, ok := t.transactionTable[key]; ok { - delete(t.transactionTable, key) - return xact, nil + 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 emptyTransaction, err + return nil, fmt.Errorf("Tracker: No record for xappkey %s", xappKey) }