smw/deskflow
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: ServerApp::EServerState => Enum class ServerApp::ServerState

Browse source
This commit is contained in:
sithlord48 2025-07-30 19:15:06 -04:00 committed by Nick Bolton
parent 8977d70dd9
commit ffa5b88cdf
2 changed files with 42 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

63
src/lib/deskflow/ServerApp.cpp
View file

@ -263,15 +263,16 @@ void ServerApp::closeClientListener(ClientListener *listen)
void ServerApp::stopServer() void ServerApp::stopServer()
{ {
if (m_serverState == kStarted) { using enum ServerState;
if (m_serverState == Started) {
closeServer(m_server); closeServer(m_server);
closeClientListener(m_listener); closeClientListener(m_listener);
m_server = nullptr; m_server = nullptr;
m_listener = nullptr; m_listener = nullptr;
m_serverState = kInitialized; m_serverState = Initialized;
} else if (m_serverState == kStarting) { } else if (m_serverState == Starting) {
stopRetryTimer(); stopRetryTimer();
m_serverState = kInitialized; m_serverState = Initialized;
} }
assert(m_server == nullptr); assert(m_server == nullptr);
assert(m_listener == nullptr); assert(m_listener == nullptr);
@ -295,20 +296,21 @@ void ServerApp::closeServerScreen(deskflow::Screen *screen)
void ServerApp::cleanupServer() void ServerApp::cleanupServer()
{ {
using enum ServerState;
stopServer(); stopServer();
if (m_serverState == kInitialized) { if (m_serverState == Initialized) {
closePrimaryClient(m_primaryClient); closePrimaryClient(m_primaryClient);
closeServerScreen(m_serverScreen); closeServerScreen(m_serverScreen);
m_primaryClient = nullptr; m_primaryClient = nullptr;
m_serverScreen = nullptr; m_serverScreen = nullptr;
m_serverState = kUninitialized; m_serverState = Uninitialized;
} else if (m_serverState == kInitializing || m_serverState == kInitializingToStart) { } else if (m_serverState == Initializing || m_serverState == InitializingToStart) {
stopRetryTimer(); stopRetryTimer();
m_serverState = kUninitialized; m_serverState = Uninitialized;
} }
assert(m_primaryClient == nullptr); assert(m_primaryClient == nullptr);
assert(m_serverScreen == nullptr); assert(m_serverScreen == nullptr);
assert(m_serverState == kUninitialized); assert(m_serverState == Uninitialized);
} }
void ServerApp::retryHandler() void ServerApp::retryHandler()
@ -319,26 +321,27 @@ void ServerApp::retryHandler()
// try initializing/starting the server again // try initializing/starting the server again
switch (m_serverState) { switch (m_serverState) {
case kUninitialized: using enum ServerState;
case kInitialized: case Uninitialized:
case kStarted: case Initialized:
case Started:
assert(0 && "bad internal server state"); assert(0 && "bad internal server state");
break; break;
case kInitializing: case Initializing:
LOG((CLOG_DEBUG1 "retry server initialization")); LOG((CLOG_DEBUG1 "retry server initialization"));
m_serverState = kUninitialized; m_serverState = Uninitialized;
if (!initServer()) { if (!initServer()) {
m_events->addEvent(Event(EventTypes::Quit)); m_events->addEvent(Event(EventTypes::Quit));
} }
break; break;
case kInitializingToStart: case InitializingToStart:
LOG((CLOG_DEBUG1 "retry server initialization")); LOG((CLOG_DEBUG1 "retry server initialization"));
m_serverState = kUninitialized; m_serverState = Uninitialized;
if (!initServer()) { if (!initServer()) {
m_events->addEvent(Event(EventTypes::Quit)); m_events->addEvent(Event(EventTypes::Quit));
} else if (m_serverState == kInitialized) { } else if (m_serverState == Initialized) {
LOG((CLOG_DEBUG1 "starting server")); LOG((CLOG_DEBUG1 "starting server"));
if (!startServer()) { if (!startServer()) {
m_events->addEvent(Event(EventTypes::Quit)); m_events->addEvent(Event(EventTypes::Quit));
@ -346,9 +349,9 @@ void ServerApp::retryHandler()
} }
break; break;
case kStarting: case Starting:
LOG((CLOG_DEBUG1 "retry starting server")); LOG((CLOG_DEBUG1 "retry starting server"));
m_serverState = kInitialized; m_serverState = Initialized;
if (!startServer()) { if (!startServer()) {
m_events->addEvent(Event(EventTypes::Quit)); m_events->addEvent(Event(EventTypes::Quit));
} }
@ -358,8 +361,9 @@ void ServerApp::retryHandler()
bool ServerApp::initServer() bool ServerApp::initServer()
{ {
using enum ServerState;
// skip if already initialized or initializing // skip if already initialized or initializing
if (m_serverState != kUninitialized) { if (m_serverState != Uninitialized) {
return true; return true;
} }
@ -372,7 +376,7 @@ bool ServerApp::initServer()
primaryClient = openPrimaryClient(name, serverScreen); primaryClient = openPrimaryClient(name, serverScreen);
m_serverScreen = serverScreen; m_serverScreen = serverScreen;
m_primaryClient = primaryClient; m_primaryClient = primaryClient;
m_serverState = kInitialized; m_serverState = Initialized;
updateStatus(); updateStatus();
return true; return true;
} catch (XScreenUnavailable &e) { } catch (XScreenUnavailable &e) {
@ -399,7 +403,7 @@ bool ServerApp::initServer()
LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime)); LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime));
m_timer = m_events->newOneShotTimer(retryTime, nullptr); m_timer = m_events->newOneShotTimer(retryTime, nullptr);
m_events->addHandler(EventTypes::Timer, m_timer, [this](const auto &) { retryHandler(); }); m_events->addHandler(EventTypes::Timer, m_timer, [this](const auto &) { retryHandler(); });
m_serverState = kInitializing; m_serverState = Initializing;
return true; return true;
} else { } else {
// don't try again // don't try again
@ -420,23 +424,24 @@ deskflow::Screen *ServerApp::openServerScreen()
bool ServerApp::startServer() bool ServerApp::startServer()
{ {
using enum ServerState;
// skip if already started or starting // skip if already started or starting
if (m_serverState == kStarting || m_serverState == kStarted) { if (m_serverState == Starting || m_serverState == Started) {
return true; return true;
} }
// initialize if necessary // initialize if necessary
if (m_serverState != kInitialized) { if (m_serverState != Initialized) {
if (!initServer()) { if (!initServer()) {
// hard initialization failure // hard initialization failure
return false; return false;
} }
if (m_serverState == kInitializing) { if (m_serverState == Initializing) {
// not ready to start // not ready to start
m_serverState = kInitializingToStart; m_serverState = InitializingToStart;
return true; return true;
} }
assert(m_serverState == kInitialized); assert(m_serverState == Initialized);
} }
ClientListener *listener = nullptr; ClientListener *listener = nullptr;
@ -448,7 +453,7 @@ bool ServerApp::startServer()
m_listener = listener; m_listener = listener;
updateStatus(); updateStatus();
LOG((CLOG_NOTE "started server, waiting for clients")); LOG((CLOG_NOTE "started server, waiting for clients"));
m_serverState = kStarted; m_serverState = Started;
return true; return true;
} catch (XSocketAddressInUse &e) { } catch (XSocketAddressInUse &e) {
if (args().m_restartable) { if (args().m_restartable) {
@ -471,7 +476,7 @@ bool ServerApp::startServer()
LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime)); LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime));
m_timer = m_events->newOneShotTimer(retryTime, nullptr); m_timer = m_events->newOneShotTimer(retryTime, nullptr);
m_events->addHandler(EventTypes::Timer, m_timer, [this](const auto &) { retryHandler(); }); m_events->addHandler(EventTypes::Timer, m_timer, [this](const auto &) { retryHandler(); });
m_serverState = kStarting; m_serverState = Starting;
return true; return true;
} else { } else {
// don't try again // don't try again

16
src/lib/deskflow/ServerApp.h
View file

@ -19,14 +19,14 @@
#include <memory> #include <memory>
enum EServerState enum class ServerState
{ {
kUninitialized, Uninitialized,
kInitializing, Initializing,
kInitializingToStart, InitializingToStart,
kInitialized, Initialized,
kStarting, Starting,
kStarted Started
}; };
class Server; class Server;
@ -131,7 +131,7 @@ private:
bool m_suspended = false; bool m_suspended = false;
Server *m_server = nullptr; Server *m_server = nullptr;
EServerState m_serverState = EServerState::kUninitialized; ServerState m_serverState = ServerState::Uninitialized;
deskflow::Screen *m_serverScreen = nullptr; deskflow::Screen *m_serverScreen = nullptr;
PrimaryClient *m_primaryClient = nullptr; PrimaryClient *m_primaryClient = nullptr;
ClientListener *m_listener = nullptr; ClientListener *m_listener = nullptr;