mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-12 18:46:24 +05:00
91 lines
2.6 KiB
Go
91 lines
2.6 KiB
Go
/*
|
|
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
|
|
Copyright (C) ITsysCOM GmbH
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
|
|
package sessionmanager
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/cgrates/cgrates/engine"
|
|
"github.com/cgrates/cgrates/guardian"
|
|
)
|
|
|
|
func NewSessions() *Sessions {
|
|
return &Sessions{
|
|
sessionsMux: new(sync.Mutex),
|
|
guard: guardian.Guardian,
|
|
}
|
|
}
|
|
|
|
type Sessions struct {
|
|
sessions []*Session
|
|
sessionsMux *sync.Mutex // Lock the list operations
|
|
guard *guardian.GuardianLock // Used to lock on uuid
|
|
}
|
|
|
|
func (self *Sessions) indexSession(s *Session) {
|
|
self.sessionsMux.Lock()
|
|
self.sessions = append(self.sessions, s)
|
|
self.sessionsMux.Unlock()
|
|
}
|
|
|
|
func (self *Sessions) getSessions() []*Session {
|
|
self.sessionsMux.Lock()
|
|
defer self.sessionsMux.Unlock()
|
|
return self.sessions
|
|
}
|
|
|
|
// Searches and return the session with the specifed uuid
|
|
func (self *Sessions) getSession(uuid string) *Session {
|
|
self.sessionsMux.Lock()
|
|
defer self.sessionsMux.Unlock()
|
|
for _, s := range self.sessions {
|
|
if s.eventStart.GetUUID() == uuid {
|
|
return s
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Remove session from session list, removes all related in case of multiple runs, true if item was found
|
|
func (self *Sessions) unindexSession(uuid string) bool {
|
|
self.sessionsMux.Lock()
|
|
defer self.sessionsMux.Unlock()
|
|
for i, ss := range self.sessions {
|
|
if ss.eventStart.GetUUID() == uuid {
|
|
self.sessions = append(self.sessions[:i], self.sessions[i+1:]...)
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (self *Sessions) removeSession(s *Session, evStop engine.Event) error {
|
|
_, err := self.guard.Guard(func() (interface{}, error) { // Lock it on UUID level
|
|
if !self.unindexSession(s.eventStart.GetUUID()) { // Unreference it early so we avoid concurrency
|
|
return nil, nil // Did not find the session so no need to close it anymore
|
|
}
|
|
if err := s.Close(evStop); err != nil { // Stop loop, refund advanced charges and save the costs deducted so far to database
|
|
return nil, err
|
|
}
|
|
return nil, nil
|
|
}, time.Duration(2)*time.Second, s.eventStart.GetUUID())
|
|
return err
|
|
}
|