mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-05-24 22:45:55 -04:00
Code Issues Packages Projects Releases Wiki Activity

Rework server initialization

Browse Source 
* Only create server instance if server is actually needed
    * Pass initial server host and port through ResourceManager
    * Allow setting default server host and port in Server settings
This commit is contained in:
Adam Honse
2026-04-05 21:25:12 -05:00
parent 9ac84ed408
commit 9b84f28cba
12 changed files with 297 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
NetworkProtocol.h
View File

@@ -28,7 +28,7 @@
/*-----------------------------------------------------*\
| Default Interface to bind to. |
\*-----------------------------------------------------*/
#define OPENRGB_SDK_HOST "0.0.0.0"
#define OPENRGB_SDK_HOST "127.0.0.1"
/*-----------------------------------------------------*\
| Default OpenRGB SDK port is 6742 |

31
ProfileManager.cpp
View File

@@ -911,7 +911,12 @@ void ProfileManager::SetActiveProfile(std::string profile_name)
{
active_profile = profile_name;
ResourceManager::get()->GetServer()->SendRequest_ProfileManager_ActiveProfileChanged(active_profile);
NetworkServer* server = ResourceManager::get()->GetServer();
if(server)
{
server->SendRequest_ProfileManager_ActiveProfileChanged(active_profile);
}
SignalProfileManagerUpdate(PROFILEMANAGER_UPDATE_REASON_ACTIVE_PROFILE_CHANGED);
}
@@ -969,7 +974,12 @@ void ProfileManager::SetProfileListFromDescription(unsigned int /*data_size*/, c
void ProfileManager::SignalProfileManagerUpdate(unsigned int update_reason)
{
ResourceManager::get()->GetServer()->SignalProfileManagerUpdate(update_reason);
NetworkServer* server = ResourceManager::get()->GetServer();
if(server)
{
server->SignalProfileManagerUpdate(update_reason);
}
ProfileManagerCallbackMutex.lock();
@@ -1355,7 +1365,12 @@ bool ProfileManager::LoadProfileWithOptions
plugin_manager->OnProfileAboutToLoad();
}
ResourceManager::get()->GetServer()->ProfileManager_ProfileAboutToLoad();
NetworkServer* server = ResourceManager::get()->GetServer();
if(server)
{
server->ProfileManager_ProfileAboutToLoad();
}
/*-------------------------------------------------*\
| Get the list of controllers from the resource |
@@ -1384,14 +1399,20 @@ bool ProfileManager::LoadProfileWithOptions
/*-------------------------------------------------*\
| Notify local client |
\*-------------------------------------------------*/
ResourceManager::get()->GetServer()->SendRequest_ProfileManager_ProfileLoaded(profile_json.dump());
if(server)
{
server->SendRequest_ProfileManager_ProfileLoaded(profile_json.dump());
}
/*-------------------------------------------------*\
| Update active profile |
\*-------------------------------------------------*/
SetActiveProfile(profile_name);
ResourceManager::get()->GetServer()->SendRequest_ProfileManager_ActiveProfileChanged(active_profile);
if(server)
{
server->SendRequest_ProfileManager_ActiveProfileChanged(active_profile);
}
return(true);
}

191
ResourceManager.cpp
View File

@@ -132,9 +132,12 @@ ResourceManager::ResourceManager()
\*-----------------------------------------------------*/
auto_connection_client = NULL;
auto_connection_active = false;
default_server_host = "";
default_server_port = 0;
detection_enabled = true;
init_finished = false;
plugin_manager = NULL;
server = NULL;
SetupConfigurationDirectory();
@@ -150,44 +153,10 @@ ResourceManager::ResourceManager()
\*-----------------------------------------------------*/
LogManager::get()->configure(settings_manager->GetSettings("LogManager"), GetConfigurationDirectory());
/*-----------------------------------------------------*\
| Initialize Server Instance |
| If configured, pass through full controller list |
| including clients. Otherwise, pass only local |
| hardware controllers |
\*-----------------------------------------------------*/
json server_settings = settings_manager->GetSettings("Server");
bool legacy_workaround = false;
server = new NetworkServer();
/*-----------------------------------------------------*\
| Set server name |
\*-----------------------------------------------------*/
std::string titleString = "OpenRGB ";
titleString.append(VERSION_STRING);
server->SetName(titleString);
server->SetSettingsManager(settings_manager);
/*-----------------------------------------------------*\
| Enable legacy SDK workaround in server if configured |
\*-----------------------------------------------------*/
if(server_settings.contains("legacy_workaround"))
{
legacy_workaround = server_settings["legacy_workaround"];
}
if(legacy_workaround)
{
server->SetLegacyWorkaroundEnable(true);
}
/*-----------------------------------------------------*\
| Load sizes list from file |
\*-----------------------------------------------------*/
profile_manager = new ProfileManager(GetConfigurationDirectory());
server->SetProfileManager(profile_manager);
}
ResourceManager::~ResourceManager()
@@ -224,6 +193,16 @@ filesystem::path ResourceManager::GetConfigurationDirectory()
return(config_dir);
}
std::string ResourceManager::GetDefaultServerHost()
{
return(default_server_host);
}
unsigned short ResourceManager::GetDefaultServerPort()
{
return(default_server_port);
}
std::vector<i2c_smbus_interface*> & ResourceManager::GetI2CBuses()
{
return DetectionManager::get()->GetI2CBuses();
@@ -266,10 +245,24 @@ void ResourceManager::SetConfigurationDirectory(const filesystem::path &director
profile_manager->SetConfigurationDirectory(directory);
}
void ResourceManager::SetDefaultServerHost(std::string new_server_host)
{
default_server_host = new_server_host;
}
void ResourceManager::SetDefaultServerPort(unsigned short new_server_port)
{
default_server_port = new_server_port;
}
void ResourceManager::SetPluginManager(PluginManagerInterface* plugin_manager_ptr)
{
plugin_manager = plugin_manager_ptr;
server->SetPluginManager(plugin_manager);
if(server)
{
server->SetPluginManager(plugin_manager);
}
}
/*---------------------------------------------------------*\
@@ -494,21 +487,24 @@ void ResourceManager::UpdateDeviceList()
/*-----------------------------------------------------*\
| Update server list |
\*-----------------------------------------------------*/
json server_settings = settings_manager->GetSettings("Server");
bool all_controllers = false;
if(server)
{
json server_settings = settings_manager->GetSettings("Server");
bool all_controllers = false;
if(server_settings.contains("all_controllers"))
{
all_controllers = server_settings["all_controllers"];
}
if(server_settings.contains("all_controllers"))
{
all_controllers = server_settings["all_controllers"];
}
if(all_controllers)
{
server->SetControllers(rgb_controllers);
}
else
{
server->SetControllers(rgb_controllers_hw);
if(all_controllers)
{
server->SetControllers(rgb_controllers);
}
else
{
server->SetControllers(rgb_controllers_hw);
}
}
/*-----------------------------------------------------*\
@@ -532,7 +528,10 @@ void ResourceManager::WaitForDetection()
\*---------------------------------------------------------*/
void ResourceManager::SignalResourceManagerUpdate(unsigned int update_reason)
{
server->SignalResourceManagerUpdate(update_reason);
if(server)
{
server->SignalResourceManagerUpdate(update_reason);
}
ResourceManagerCallbackMutex.lock();
@@ -724,13 +723,45 @@ void ResourceManager::Initialize(bool tryConnect, bool detectDevices, bool start
}
}
/*-----------------------------------------------------*\
| If the server host and port have been set on the CLI, |
| use those values. Otherwise, get default server host |
| and port from settings if configured. |
\*-----------------------------------------------------*/
json server_settings = settings_manager->GetSettings("Server");
if(default_server_host == "")
{
if(server_settings.contains("default_host"))
{
default_server_host = server_settings["default_host"];
}
else
{
default_server_host = OPENRGB_SDK_HOST;
}
}
if(default_server_port == 0)
{
if(server_settings.contains("default_port"))
{
default_server_port = server_settings["default_port"];
}
else
{
default_server_port = OPENRGB_SDK_PORT;
}
}
/*-----------------------------------------------------*\
| Start server if requested |
\*-----------------------------------------------------*/
if(start_server)
{
GetServer()->StartServer();
if(!GetServer()->GetOnline())
InitializeServer();
server->StartServer();
if(!server->GetOnline())
{
LOG_DEBUG("[%s] Server failed to start", RESOURCEMANAGER);
}
@@ -760,6 +791,64 @@ void ResourceManager::Initialize(bool tryConnect, bool detectDevices, bool start
init_finished = true;
}
void ResourceManager::InitializeServer()
{
/*-----------------------------------------------------*\
| Initialize Server Instance |
| If configured, pass through full controller list |
| including clients. Otherwise, pass only local |
| hardware controllers |
\*-----------------------------------------------------*/
json server_settings = settings_manager->GetSettings("Server");
bool legacy_workaround = false;
server = new NetworkServer();
/*-----------------------------------------------------*\
| Set server name |
\*-----------------------------------------------------*/
std::string titleString = "OpenRGB ";
titleString.append(VERSION_STRING);
server->SetName(titleString);
server->SetSettingsManager(settings_manager);
/*-----------------------------------------------------*\
| Enable legacy SDK workaround in server if configured |
\*-----------------------------------------------------*/
if(server_settings.contains("legacy_workaround"))
{
legacy_workaround = server_settings["legacy_workaround"];
}
if(legacy_workaround)
{
server->SetLegacyWorkaroundEnable(true);
}
server->SetProfileManager(profile_manager);
if(plugin_manager)
{
server->SetPluginManager(plugin_manager);
}
/*-----------------------------------------------------*\
| If the server host and port have been set on the CLI, |
| use those values. Otherwise, get default server host |
| and port from settings if configured. |
\*-----------------------------------------------------*/
if(default_server_host != "")
{
server->SetHost(default_server_host);
}
if(default_server_port != 0)
{
server->SetPort(default_server_port);
}
}
void ResourceManager::WaitForInitialization()
{
/*-----------------------------------------------------*\

7
ResourceManager.h
View File

@@ -52,6 +52,8 @@ public:
\*-----------------------------------------------------*/
std::vector<NetworkClient*>& GetClients();
filesystem::path GetConfigurationDirectory();
std::string GetDefaultServerHost();
unsigned short GetDefaultServerPort();
LogManager* GetLogManager();
std::vector<i2c_smbus_interface*>& GetI2CBuses();
PluginManagerInterface* GetPluginManager();
@@ -61,6 +63,8 @@ public:
SettingsManager* GetSettingsManager();
void SetConfigurationDirectory(const filesystem::path &directory);
void SetDefaultServerHost(std::string server_host);
void SetDefaultServerPort(unsigned short server_port);
void SetPluginManager(PluginManagerInterface* plugin_manager_ptr);
/*-----------------------------------------------------*\
@@ -99,6 +103,7 @@ public:
void SignalResourceManagerUpdate(unsigned int update_reason);
void Initialize(bool tryConnect, bool detectDevices, bool startServer, bool applyPostOptions);
void InitializeServer();
void WaitForInitialization();
@@ -170,6 +175,8 @@ private:
| Network Server |
\*-----------------------------------------------------*/
NetworkServer* server;
std::string default_server_host;
unsigned short default_server_port;
/*-----------------------------------------------------*\
| Network Clients |

1
SettingsManager.cpp
View File

@@ -27,7 +27,6 @@ static const std::string ui_settings_keys[7] =
"Plugins",
"Client",
"LogManager",
"Server"
};
SettingsManager::SettingsManager()

17
cli.cpp
View File

@@ -1269,8 +1269,6 @@ unsigned int cli_pre_detection(int argc, char* argv[])
int arg_index = 1;
unsigned int cfg_args = 0;
unsigned int ret_flags = 0;
std::string server_host = OPENRGB_SDK_HOST;
unsigned short server_port = OPENRGB_SDK_PORT;
bool server_start = false;
bool print_help = false;
@@ -1408,14 +1406,14 @@ unsigned int cli_pre_detection(int argc, char* argv[])
\*---------------------------------------------------------*/
else if(option == "--server-port")
{
if (argument != "")
if(argument != "")
{
try
{
int port = std::stoi(argument);
if (port >= 1024 && port <= 65535)
if(port >= 1024 && port <= 65535)
{
server_port = port;
ResourceManager::get()->SetDefaultServerPort(port);
server_start = true;
}
else
@@ -1446,11 +1444,9 @@ unsigned int cli_pre_detection(int argc, char* argv[])
\*---------------------------------------------------------*/
else if(option == "--server-host")
{
if (argument != "")
if(argument != "")
{
std::string host = argument;
server_host = host;
ResourceManager::get()->SetDefaultServerHost(argument);
server_start = true;
}
else
@@ -1694,9 +1690,6 @@ unsigned int cli_pre_detection(int argc, char* argv[])
if(server_start)
{
NetworkServer * server = ResourceManager::get()->GetServer();
server->SetHost(server_host);
server->SetPort(server_port);
ret_flags |= RET_FLAG_START_SERVER;
}

9
qt/OpenRGBDialog/OpenRGBDialog.cpp
View File

@@ -871,9 +871,12 @@ void OpenRGBDialog::AddServerTab()
/*-----------------------------------------------------*\
| Add server information tab if there is a server |
\*-----------------------------------------------------*/
OpenRGBServerInfoPage *ServerInfoPage = new OpenRGBServerInfoPage(ResourceManager::get()->GetServer());
ServerInfoPage->setObjectName(QString("SDK Server"));
ui->MainTabBar->insertTab(2, ServerInfoPage, tr("SDK Server"));
if(!ResourceManager::get()->IsLocalClient())
{
OpenRGBServerInfoPage *ServerInfoPage = new OpenRGBServerInfoPage();
ServerInfoPage->setObjectName(QString("SDK Server"));
ui->MainTabBar->insertTab(2, ServerInfoPage, tr("SDK Server"));
}
}
void OpenRGBDialog::ClearDevicesList()

65
qt/OpenRGBServerInfoPage/OpenRGBServerInfoPage.cpp
View File

@@ -17,18 +17,21 @@ static void UpdateInfoCallback(void * this_ptr)
QMetaObject::invokeMethod(this_obj, "UpdateInfo", Qt::QueuedConnection);
}
OpenRGBServerInfoPage::OpenRGBServerInfoPage(NetworkServer * server, QWidget *parent) :
OpenRGBServerInfoPage::OpenRGBServerInfoPage(QWidget *parent) :
QFrame(parent),
ui(new Ui::OpenRGBServerInfoPage)
{
network_server = server;
ui->setupUi(this);
UpdateInfo();
network_server = ResourceManager::get()->GetServer();
network_server->RegisterClientInfoChangeCallback(UpdateInfoCallback, this);
network_server->RegisterServerListeningChangeCallback(UpdateInfoCallback, this);
if(network_server)
{
network_server->RegisterClientInfoChangeCallback(UpdateInfoCallback, this);
network_server->RegisterServerListeningChangeCallback(UpdateInfoCallback, this);
}
UpdateInfo();
}
OpenRGBServerInfoPage::~OpenRGBServerInfoPage()
@@ -46,10 +49,18 @@ void OpenRGBServerInfoPage::changeEvent(QEvent *event)
void OpenRGBServerInfoPage::UpdateInfo()
{
ui->ServerHostValue->setText(network_server->GetHost().c_str());
ui->ServerPortValue->setText(std::to_string(network_server->GetPort()).c_str());
if(network_server)
{
ui->ServerHostValue->setText(network_server->GetHost().c_str());
ui->ServerPortValue->setText(std::to_string(network_server->GetPort()).c_str());
}
else
{
ui->ServerHostValue->setText(ResourceManager::get()->GetDefaultServerHost().c_str());
ui->ServerPortValue->setText(std::to_string(ResourceManager::get()->GetDefaultServerPort()).c_str());
}
if(network_server->GetListening() && !network_server->GetOnline())
if(network_server && network_server->GetListening() && !network_server->GetOnline())
{
ui->ServerStatusValue->setText(tr("Stopping..."));
ui->ServerStartButton->setEnabled(false);
@@ -57,7 +68,7 @@ void OpenRGBServerInfoPage::UpdateInfo()
ui->ServerHostValue->setEnabled(false);
ui->ServerPortValue->setEnabled(false);
}
else if(network_server->GetListening())
else if(network_server && network_server->GetListening())
{
ui->ServerStatusValue->setText(tr("Online"));
ui->ServerStartButton->setEnabled(false);
@@ -75,20 +86,33 @@ void OpenRGBServerInfoPage::UpdateInfo()
}
ui->ServerClientTree->clear();
for(unsigned int client_idx = 0; client_idx < network_server->GetNumClients(); client_idx++)
if(network_server)
{
QTreeWidgetItem * new_item = new QTreeWidgetItem();
for(unsigned int client_idx = 0; client_idx < network_server->GetNumClients(); client_idx++)
{
QTreeWidgetItem * new_item = new QTreeWidgetItem();
new_item->setText(0, network_server->GetClientIP(client_idx));
new_item->setText(1, QString::number(network_server->GetClientProtocolVersion(client_idx)));
new_item->setText(2, network_server->GetClientString(client_idx));
new_item->setText(0, network_server->GetClientIP(client_idx));
new_item->setText(1, QString::number(network_server->GetClientProtocolVersion(client_idx)));
new_item->setText(2, network_server->GetClientString(client_idx));
ui->ServerClientTree->addTopLevelItem(new_item);
ui->ServerClientTree->addTopLevelItem(new_item);
}
}
}
void OpenRGBServerInfoPage::on_ServerStartButton_clicked()
{
if(!network_server)
{
ResourceManager::get()->InitializeServer();
network_server = ResourceManager::get()->GetServer();
network_server->RegisterClientInfoChangeCallback(UpdateInfoCallback, this);
network_server->RegisterServerListeningChangeCallback(UpdateInfoCallback, this);
}
if(network_server->GetOnline() == false)
{
network_server->SetHost(ui->ServerHostValue->text().toStdString());
@@ -101,10 +125,13 @@ void OpenRGBServerInfoPage::on_ServerStartButton_clicked()
void OpenRGBServerInfoPage::on_ServerStopButton_clicked()
{
if(network_server->GetOnline() == true)
if(network_server)
{
network_server->StopServer();
if(network_server->GetOnline() == true)
{
network_server->StopServer();
UpdateInfo();
UpdateInfo();
}
}
}

2
qt/OpenRGBServerInfoPage/OpenRGBServerInfoPage.h
View File

@@ -23,7 +23,7 @@ class OpenRGBServerInfoPage : public QFrame
Q_OBJECT
public:
explicit OpenRGBServerInfoPage(NetworkServer * server, QWidget *parent = nullptr);
explicit OpenRGBServerInfoPage(QWidget *parent = nullptr);
~OpenRGBServerInfoPage();
public slots:

28
qt/OpenRGBSettingsPage/OpenRGBSettingsPage.cpp
View File

@@ -317,6 +317,18 @@ OpenRGBSettingsPage::OpenRGBSettingsPage(QWidget *parent) :
ui->CheckboxLegacyWorkaround->setChecked(legacy_workaround);
}
if(server_settings.contains("default_host"))
{
std::string host = server_settings["default_host"];
ui->LineEditServerDefaultHost->setText(QString::fromStdString(host));
}
if(server_settings.contains("default_port"))
{
unsigned short port = server_settings["default_port"];
ui->SpinBoxServerDefaultPort->setValue(port);
}
UpdateProfiles();
/*---------------------------------------------------------*\
@@ -1179,3 +1191,19 @@ void OpenRGBSettingsPage::on_CheckboxShowLEDView_clicked()
ResourceManager::get()->GetSettingsManager()->SetSettings("UserInterface", ui_settings);
SaveSettings();
}
void OpenRGBSettingsPage::on_LineEditServerDefaultHost_textChanged(const QString server_default_host)
{
json server_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("Server");
server_settings["default_host"] = server_default_host.toStdString();
ResourceManager::get()->GetSettingsManager()->SetSettings("Server", server_settings);
SaveSettings();
}
void OpenRGBSettingsPage::on_SpinBoxServerDefaultPort_valueChanged(int server_default_port)
{
json server_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("Server");
server_settings["default_port"] = (unsigned short)server_default_port;
ResourceManager::get()->GetSettingsManager()->SetSettings("Server", server_settings);
SaveSettings();
}

2
qt/OpenRGBSettingsPage/OpenRGBSettingsPage.h
View File

@@ -96,4 +96,6 @@ private slots:
void on_CheckboxShowLEDView_clicked();
void on_CheckboxAllDevices_clicked(bool checked);
void on_CheckboxLegacyWorkaround_clicked(bool checked);
void on_LineEditServerDefaultHost_textChanged(const QString server_default_host);
void on_SpinBoxServerDefaultPort_valueChanged(int server_default_port);
};

39
qt/OpenRGBSettingsPage/OpenRGBSettingsPage.ui
View File

@@ -220,17 +220,48 @@
<string>Server</string>
</property>
<layout class="QGridLayout" name="gridLayout_8">
<item row="0" column="0">
<item row="2" column="1">
<widget class="QLineEdit" name="LineEditServerDefaultHost">
<property name="text">
<string>127.0.0.1</string>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="LabelServerDefaultHost">
<property name="text">
<string>Server Default Host</string>
</property>
</widget>
</item>
<item row="1" column="0" colspan="2">
<widget class="QCheckBox" name="CheckboxLegacyWorkaround">
<property name="text">
<string>Legacy Workaround</string>
</property>
</widget>
</item>
<item row="0" column="0" colspan="2">
<widget class="QCheckBox" name="CheckboxAllDevices">
<property name="text">
<string>Serve All Devices (Including those from client connections)</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QCheckBox" name="CheckboxLegacyWorkaround">
<item row="3" column="0">
<widget class="QLabel" name="LabelServerDefaultPort">
<property name="text">
<string>Legacy Workaround</string>
<string>Server Default Port</string>
</property>
</widget>
</item>
<item row="3" column="1">
<widget class="QSpinBox" name="SpinBoxServerDefaultPort">
<property name="maximum">
<number>65535</number>
</property>
<property name="value">
<number>6742</number>
</property>
</widget>
</item>