101 lines
3.7 KiB
C++
101 lines
3.7 KiB
C++
#pragma once
|
|
|
|
#include <deque>
|
|
#include <EventLoop.h>
|
|
#include "client/voice/PrecomputedPuzzles.h"
|
|
#include "server/VoiceIOManager.h"
|
|
#include "TSServer.h"
|
|
|
|
namespace ts {
|
|
namespace server {
|
|
class InstanceHandler;
|
|
|
|
struct ServerReport {
|
|
size_t avariable;
|
|
size_t online;
|
|
|
|
size_t slots;
|
|
size_t onlineClients;
|
|
size_t onlineChannels;
|
|
};
|
|
class ServerManager {
|
|
public:
|
|
enum State {
|
|
STOPPED,
|
|
STARTING,
|
|
STARTED,
|
|
STOPPING
|
|
};
|
|
|
|
explicit ServerManager(InstanceHandler*);
|
|
~ServerManager();
|
|
|
|
bool initialize(bool execute_autostart = true);
|
|
|
|
std::shared_ptr<TSServer> createServer(std::string, uint16_t);
|
|
bool deleteServer(std::shared_ptr<TSServer>);
|
|
|
|
std::shared_ptr<TSServer> findServerById(ServerId);
|
|
std::shared_ptr<TSServer> findServerByPort(uint16_t);
|
|
uint16_t next_available_port();
|
|
ServerId next_available_server_id(bool& /* success */);
|
|
|
|
std::deque<std::shared_ptr<TSServer>> serverInstances(){
|
|
threads::MutexLock l(this->instanceLock);
|
|
return instances;
|
|
}
|
|
|
|
ServerReport report();
|
|
OnlineClientReport clientReport();
|
|
size_t runningServers();
|
|
size_t usedSlots();
|
|
|
|
void executeAutostart();
|
|
void shutdownAll(const std::string&);
|
|
|
|
//Dotn use shared_ptr references to keep sure that they be hold in memory
|
|
bool createServerSnapshot(Command &cmd, std::shared_ptr<TSServer> server, int version, std::string &error);
|
|
std::shared_ptr<TSServer> createServerFromSnapshot(std::shared_ptr<TSServer> old, std::string, uint16_t, const ts::Command &, std::string &);
|
|
|
|
size_t maxSlotLimit(){ return 254; }
|
|
|
|
protocol::PuzzleManager* rsaPuzzles() { return this->puzzles; }
|
|
|
|
event::EventExecutor* get_join_loop() { return this->join_loop; }
|
|
event::EventExecutor* get_executor_loop() { return this->execute_loop; }
|
|
|
|
inline void adjust_executor_threads() {
|
|
std::unique_lock instance_lock(this->instanceLock);
|
|
auto instance_count = this->instances.size();
|
|
instance_lock.unlock();
|
|
|
|
auto threads = std::min(config::threads::voice::execute_per_server * instance_count, config::threads::voice::execute_limit);
|
|
this->execute_loop->threads(threads);
|
|
}
|
|
io::VoiceIOManager* ioManager(){ return this->_ioManager; }
|
|
|
|
threads::Mutex server_create_lock;
|
|
|
|
State getState() { return this->state; }
|
|
private:
|
|
State state = State::STOPPED;
|
|
InstanceHandler* handle;
|
|
threads::Mutex instanceLock;
|
|
std::deque<std::shared_ptr<TSServer>> instances;
|
|
protocol::PuzzleManager* puzzles = nullptr;
|
|
|
|
event::EventExecutor* execute_loop = nullptr;
|
|
event::EventExecutor* join_loop = nullptr;
|
|
threads::Scheduler* handshakeTickers = nullptr;
|
|
io::VoiceIOManager* _ioManager = nullptr;
|
|
|
|
struct {
|
|
threads::Thread* thread = nullptr;
|
|
std::condition_variable condition;
|
|
std::mutex lock;
|
|
} acknowledge;
|
|
|
|
void tickHandshakeClients();
|
|
};
|
|
}
|
|
} |