Inheritance diagram for CachedSessionStore:

Collaboration diagram for CachedSessionStore:

Public Member Functions
	CachedSessionStore (int idle_session_duration, int max_session_duration, int capacity, DisconnectCallback disconnect_callback)

SessionInfoPtr	add (const Catalog_Namespace::UserMetadata &user_meta, std::shared_ptr< Catalog > cat, ExecutorDeviceType device) override

SessionInfoPtr	get (const std::string &session_id) override

heavyai::shared_mutex &	getLock () override

void	eraseIf (std::function< bool(const SessionInfoPtr &)> predicate) override

	~CachedSessionStore () override

Public Member Functions inherited from Catalog_Namespace::SessionsStore
void	erase (const std::string &session_id)

void	eraseByUser (const std::string &user_name)

void	eraseByDB (const std::string &db_name)

std::vector< SessionInfoPtr >	getAllSessions ()

std::vector< SessionInfoPtr >	getUserSessions (const std::string &user_name)

SessionInfoPtr	getByPublicID (const std::string &public_id)

virtual	~SessionsStore ()=default

SessionInfo	getSessionCopy (const std::string &session_id)

void	disconnect (const std::string session_id)

Protected Member Functions
void	eraseUnlocked (const std::string &session_id) override

bool	isSessionInUse (const SessionInfoPtr &session_ptr) override

SessionInfoPtr	getUnlocked (const std::string &session_id) override

DisconnectCallback	getDisconnectCallback () override

std::vector< SessionInfoPtr >	getIf (std::function< bool(const SessionInfoPtr &)> predicate) override

Protected Member Functions inherited from Catalog_Namespace::SessionsStore
bool	isSessionExpired (const SessionInfoPtr &session_ptr, int idle_session_duration, int max_session_duration)

Private Attributes
std::unordered_map < std::string, SessionInfoPtr >	sessions_

heavyai::shared_mutex	mtx_

const int	idle_session_duration_

const int	max_session_duration_

const int	capacity_

DisconnectCallback	disconnect_callback_

Additional Inherited Members
Static Public Member Functions inherited from Catalog_Namespace::SessionsStore
static std::unique_ptr < SessionsStore >	create (const std::string &base_path, size_t n_workers, int idle_session_duration, int max_session_duration, int capacity, DisconnectCallback disconnect_callback)

Detailed Description

Definition at line 114 of file SessionsStore.cpp.

Constructor & Destructor Documentation

CachedSessionStore::CachedSessionStore	(	int	idle_session_duration,
		int	max_session_duration,
		int	capacity,
		DisconnectCallback	disconnect_callback
	)

inline

Definition at line 116 of file SessionsStore.cpp.

       : idle_session_duration_(idle_session_duration)
       , max_session_duration_(max_session_duration)
       , capacity_(capacity > 0 ? capacity : INT_MAX)
       , disconnect_callback_(disconnect_callback) {}

CachedSessionStore::~CachedSessionStore ( )

inlineoverride

Definition at line 196 of file SessionsStore.cpp.

                                  {
     std::lock_guard lg(mtx_);
     sessions_.clear();
   }

Member Function Documentation

SessionInfoPtr CachedSessionStore::add	(	const Catalog_Namespace::UserMetadata &	user_meta,
		std::shared_ptr< Catalog >	cat,
		ExecutorDeviceType	device
	)

inlineoverridevirtual

Implements Catalog_Namespace::SessionsStore.

Definition at line 125 of file SessionsStore.cpp.

References cat(), generate_random_string(), Catalog_Namespace::SESSION_ID_LENGTH, and UNREACHABLE.

                                                          {
     heavyai::lock_guard<heavyai::shared_mutex> lock(mtx_);
     if (int(sessions_.size()) >= capacity_) {
       std::vector<SessionInfoPtr> expired_sessions;
       for (auto it = sessions_.begin(); it != sessions_.end(); it++) {
         if (isSessionExpired(it->second, idle_session_duration_, max_session_duration_)) {
           expired_sessions.push_back(it->second);
         }
       }
       for (auto& session_ptr : expired_sessions) {
         try {
           disconnect_callback_(session_ptr);
           eraseUnlocked(session_ptr->get_session_id());
         } catch (const std::exception& e) {
           eraseUnlocked(session_ptr->get_session_id());
           throw e;
         }
       }
     }
     if (int(sessions_.size()) < capacity_) {
       do {
         auto session_id = generate_random_string(Catalog_Namespace::SESSION_ID_LENGTH);
         if (sessions_.count(session_id) != 0) {
           continue;
         }
         auto session_ptr = std::make_shared<Catalog_Namespace::SessionInfo>(
             cat, user_meta, device, session_id);
         sessions_[session_id] = session_ptr;
         return session_ptr;
       } while (true);
       UNREACHABLE();
     }
     throw std::runtime_error("Too many active sessions");
   }

Here is the call graph for this function:

void CachedSessionStore::eraseIf ( std::function< bool(const SessionInfoPtr &)> predicate )

inlineoverridevirtual

Implements Catalog_Namespace::SessionsStore.

Definition at line 185 of file SessionsStore.cpp.

                                                                             {
     heavyai::lock_guard<heavyai::shared_mutex> lock(mtx_);
     for (auto it = sessions_.begin(); it != sessions_.end();) {
       if (predicate(it->second)) {
         it = sessions_.erase(it);
       } else {
         it++;
       }
     }
   }

void CachedSessionStore::eraseUnlocked ( const std::string & session_id )

inlineoverrideprotectedvirtual

Implements Catalog_Namespace::SessionsStore.

Definition at line 202 of file SessionsStore.cpp.

                                                            {
     sessions_.erase(session_id);
   }

SessionInfoPtr CachedSessionStore::get ( const std::string & session_id )

inlineoverridevirtual

Implements Catalog_Namespace::SessionsStore.

Definition at line 162 of file SessionsStore.cpp.

References Catalog_Namespace::SessionsStore::isSessionExpired().

                                                            {
     heavyai::lock_guard<heavyai::shared_mutex> lock(mtx_);
     auto session_ptr = getUnlocked(session_id);
     if (session_ptr) {
       if (SessionsStore::isSessionExpired(
               session_ptr, idle_session_duration_, max_session_duration_)) {
         try {
           disconnect_callback_(session_ptr);
           eraseUnlocked(session_ptr->get_session_id());
         } catch (const std::exception& e) {
           eraseUnlocked(session_ptr->get_session_id());
           throw e;
         }
         return nullptr;
       }
       session_ptr->update_last_used_time();
       return session_ptr;
     }
     return nullptr;
   }

Here is the call graph for this function:

DisconnectCallback CachedSessionStore::getDisconnectCallback ( )

inlineoverrideprotectedvirtual

Implements Catalog_Namespace::SessionsStore.

Definition at line 217 of file SessionsStore.cpp.

217 { return disconnect_callback_; }

CachedSessionStore::disconnect_callback_

DisconnectCallback disconnect_callback_

Definition: SessionsStore.cpp:238

std::vector<SessionInfoPtr> CachedSessionStore::getIf ( std::function< bool(const SessionInfoPtr &)> predicate )

inlineoverrideprotectedvirtual

Implements Catalog_Namespace::SessionsStore.

Definition at line 219 of file SessionsStore.cpp.

                                                                    {
     std::vector<SessionInfoPtr> out;
     heavyai::shared_lock<heavyai::shared_mutex> sessions_lock(getLock());
     for (auto& [_, session] : sessions_) {
       heavyai::shared_lock<heavyai::shared_mutex> session_lock(session->getLock());
       if (predicate(session)) {
         out.push_back(session);
       }
     }
     return out;
   }

heavyai::shared_mutex& CachedSessionStore::getLock ( )

inlineoverridevirtual

Implements Catalog_Namespace::SessionsStore.

Definition at line 183 of file SessionsStore.cpp.

183 { return mtx_; }

CachedSessionStore::mtx_

heavyai::shared_mutex mtx_

Definition: SessionsStore.cpp:234

SessionInfoPtr CachedSessionStore::getUnlocked ( const std::string & session_id )

inlineoverrideprotectedvirtual

Implements Catalog_Namespace::SessionsStore.

Definition at line 210 of file SessionsStore.cpp.

                                                                    {
     if (auto session_it = sessions_.find(session_id); session_it != sessions_.end()) {
       return session_it->second;
     }
     return nullptr;
   }

bool CachedSessionStore::isSessionInUse ( const SessionInfoPtr & session_ptr )

inlineoverrideprotectedvirtual

Implements Catalog_Namespace::SessionsStore.

Definition at line 206 of file SessionsStore.cpp.

                                                                   {
     return session_ptr.use_count() > 2;
   }

Member Data Documentation

const int CachedSessionStore::capacity_

private

Definition at line 237 of file SessionsStore.cpp.

DisconnectCallback CachedSessionStore::disconnect_callback_

private

Definition at line 238 of file SessionsStore.cpp.

const int CachedSessionStore::idle_session_duration_

private

Definition at line 235 of file SessionsStore.cpp.

const int CachedSessionStore::max_session_duration_

private

Definition at line 236 of file SessionsStore.cpp.

heavyai::shared_mutex CachedSessionStore::mtx_

mutableprivate

Definition at line 234 of file SessionsStore.cpp.

std::unordered_map<std::string, SessionInfoPtr> CachedSessionStore::sessions_

private

Definition at line 233 of file SessionsStore.cpp.

The documentation for this class was generated from the following file:

/home/jenkins-slave/workspace/core-os-doxygen/Catalog/SessionsStore.cpp

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation