Add option to override Live Control Gateway (#225)

* Add option to override Live Control Gateway * Add LCG clear command, and rename * Implement LCG domain verification logic
OpenShock · Apr 17, 2024 · a7cc803 · a7cc803
1 parent 2cc8672
commit a7cc803
Show file tree

Hide file tree

Showing 11 changed files with 303 additions and 33 deletions.
diff --git a/frontend/src/lib/_fbs/open-shock/serialization/configuration/backend-config.ts b/frontend/src/lib/_fbs/open-shock/serialization/configuration/backend-config.ts
@@ -42,8 +42,18 @@ authToken(optionalEncoding?:any):string|Uint8Array|null {
   return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 
+/**
+ * Override the Live-Control-Gateway (LCG) URL
+ */
+lcgOverride():string|null
+lcgOverride(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+lcgOverride(optionalEncoding?:any):string|Uint8Array|null {
+  const offset = this.bb!.__offset(this.bb_pos, 8);
+  return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+}
+
 static startBackendConfig(builder:flatbuffers.Builder) {
-  builder.startObject(2);
+  builder.startObject(3);
 }
 
 static addDomain(builder:flatbuffers.Builder, domainOffset:flatbuffers.Offset) {
@@ -54,15 +64,20 @@ static addAuthToken(builder:flatbuffers.Builder, authTokenOffset:flatbuffers.Off
   builder.addFieldOffset(1, authTokenOffset, 0);
 }
 
+static addLcgOverride(builder:flatbuffers.Builder, lcgOverrideOffset:flatbuffers.Offset) {
+  builder.addFieldOffset(2, lcgOverrideOffset, 0);
+}
+
 static endBackendConfig(builder:flatbuffers.Builder):flatbuffers.Offset {
   const offset = builder.endObject();
   return offset;
 }
 
-static createBackendConfig(builder:flatbuffers.Builder, domainOffset:flatbuffers.Offset, authTokenOffset:flatbuffers.Offset):flatbuffers.Offset {
+static createBackendConfig(builder:flatbuffers.Builder, domainOffset:flatbuffers.Offset, authTokenOffset:flatbuffers.Offset, lcgOverrideOffset:flatbuffers.Offset):flatbuffers.Offset {
   BackendConfig.startBackendConfig(builder);
   BackendConfig.addDomain(builder, domainOffset);
   BackendConfig.addAuthToken(builder, authTokenOffset);
+  BackendConfig.addLcgOverride(builder, lcgOverrideOffset);
   return BackendConfig.endBackendConfig(builder);
 }
 }
diff --git a/include/config/BackendConfig.h b/include/config/BackendConfig.h
@@ -7,10 +7,11 @@
 namespace OpenShock::Config {
   struct BackendConfig : public ConfigBase<Serialization::Configuration::BackendConfig> {
     BackendConfig();
-    BackendConfig(const std::string& domain, const std::string& authToken);
+    BackendConfig(const std::string& domain, const std::string& authToken, const std::string& lcgOverride);
 
     std::string domain;
     std::string authToken;
+    std::string lcgOverride;
 
     void ToDefault() override;
 

diff --git a/include/config/Config.h b/include/config/Config.h
@@ -75,4 +75,8 @@ namespace OpenShock::Config {
   bool GetBackendAuthToken(std::string& out);
   bool SetBackendAuthToken(const std::string& token);
   bool ClearBackendAuthToken();
+  bool HasBackendLCGOverride();
+  bool GetBackendLCGOverride(std::string& out);
+  bool SetBackendLCGOverride(const std::string& lcgOverride);
+  bool ClearBackendLCGOverride();
 }  // namespace OpenShock::Config
diff --git a/include/serialization/JsonAPI.h b/include/serialization/JsonAPI.h
@@ -9,6 +9,13 @@
 #include <vector>
 
 namespace OpenShock::Serialization::JsonAPI {
+  struct LcgInstanceDetailsResponse {
+    std::string name;
+    std::string version;
+    std::string currentTime;
+    std::string countryCode;
+    std::string fqdn;
+  };
   struct BackendVersionResponse {
     std::string version;
     std::string commit;
@@ -32,6 +39,7 @@ namespace OpenShock::Serialization::JsonAPI {
     std::string country;
   };
 
+  bool ParseLcgInstanceDetailsJsonResponse(int code, const cJSON* root, LcgInstanceDetailsResponse& out);
   bool ParseBackendVersionJsonResponse(int code, const cJSON* root, BackendVersionResponse& out);
   bool ParseAccountLinkJsonResponse(int code, const cJSON* root, AccountLinkResponse& out);
   bool ParseDeviceInfoJsonResponse(int code, const cJSON* root, DeviceInfoResponse& out);

diff --git a/include/serialization/_fbs/ConfigFile_generated.h b/include/serialization/_fbs/ConfigFile_generated.h
@@ -419,7 +419,8 @@ struct BackendConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   }
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_DOMAIN = 4,
-    VT_AUTH_TOKEN = 6
+    VT_AUTH_TOKEN = 6,
+    VT_LCG_OVERRIDE = 8
   };
   /// Domain name of the backend server, e.g. "api.shocklink.net"
   const ::flatbuffers::String *domain() const {
@@ -429,12 +430,18 @@ struct BackendConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *auth_token() const {
     return GetPointer<const ::flatbuffers::String *>(VT_AUTH_TOKEN);
   }
+  /// Override the Live-Control-Gateway (LCG) URL
+  const ::flatbuffers::String *lcg_override() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_LCG_OVERRIDE);
+  }
   bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_DOMAIN) &&
            verifier.VerifyString(domain()) &&
            VerifyOffset(verifier, VT_AUTH_TOKEN) &&
            verifier.VerifyString(auth_token()) &&
+           VerifyOffset(verifier, VT_LCG_OVERRIDE) &&
+           verifier.VerifyString(lcg_override()) &&
            verifier.EndTable();
   }
 };
@@ -449,6 +456,9 @@ struct BackendConfigBuilder {
   void add_auth_token(::flatbuffers::Offset<::flatbuffers::String> auth_token) {
     fbb_.AddOffset(BackendConfig::VT_AUTH_TOKEN, auth_token);
   }
+  void add_lcg_override(::flatbuffers::Offset<::flatbuffers::String> lcg_override) {
+    fbb_.AddOffset(BackendConfig::VT_LCG_OVERRIDE, lcg_override);
+  }
   explicit BackendConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -463,8 +473,10 @@ struct BackendConfigBuilder {
 inline ::flatbuffers::Offset<BackendConfig> CreateBackendConfig(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     ::flatbuffers::Offset<::flatbuffers::String> domain = 0,
-    ::flatbuffers::Offset<::flatbuffers::String> auth_token = 0) {
+    ::flatbuffers::Offset<::flatbuffers::String> auth_token = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> lcg_override = 0) {
   BackendConfigBuilder builder_(_fbb);
+  builder_.add_lcg_override(lcg_override);
   builder_.add_auth_token(auth_token);
   builder_.add_domain(domain);
   return builder_.Finish();
@@ -478,13 +490,16 @@ struct BackendConfig::Traits {
 inline ::flatbuffers::Offset<BackendConfig> CreateBackendConfigDirect(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     const char *domain = nullptr,
-    const char *auth_token = nullptr) {
+    const char *auth_token = nullptr,
+    const char *lcg_override = nullptr) {
   auto domain__ = domain ? _fbb.CreateString(domain) : 0;
   auto auth_token__ = auth_token ? _fbb.CreateString(auth_token) : 0;
+  auto lcg_override__ = lcg_override ? _fbb.CreateString(lcg_override) : 0;
   return OpenShock::Serialization::Configuration::CreateBackendConfig(
       _fbb,
       domain__,
-      auth_token__);
+      auth_token__,
+      lcg_override__);
 }
 
 struct SerialInputConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {

diff --git a/schemas/ConfigFile.fbs b/schemas/ConfigFile.fbs
@@ -42,6 +42,9 @@ table BackendConfig {
 
   /// Authentication token for the backend server
   auth_token:string;
+
+  /// Override the Live-Control-Gateway (LCG) URL
+  lcg_override:string;
 }
 
 table SerialInputConfig {

diff --git a/src/GatewayConnectionManager.cpp b/src/GatewayConnectionManager.cpp
@@ -207,6 +207,15 @@ bool StartConnectingToLCG() {
 
   _lastConnectionAttempt = msNow;
 
+  if (Config::HasBackendLCGOverride()) {
+    std::string lcgOverride;
+    Config::GetBackendLCGOverride(lcgOverride);
+
+    ESP_LOGD(TAG, "Connecting to overridden LCG endpoint %.*s", lcgOverride.size(), lcgOverride.data());
+    s_wsClient->connect(lcgOverride.c_str());
+    return true;
+  }
+
   if (!Config::HasBackendAuthToken()) {
     ESP_LOGD(TAG, "No auth token, can't connect to LCG");
     return false;

diff --git a/src/config/BackendConfig.cpp b/src/config/BackendConfig.cpp
@@ -7,7 +7,9 @@ const char* const TAG = "Config::BackendConfig";
 
 using namespace OpenShock::Config;
 
-BackendConfig::BackendConfig() : domain(OPENSHOCK_API_DOMAIN), authToken() { }
+BackendConfig::BackendConfig() : domain(OPENSHOCK_API_DOMAIN), authToken(), lcgOverride() { }
+
+BackendConfig::BackendConfig(const std::string& domain, const std::string& authToken, const std::string& lcgOverride) : domain(domain), authToken(authToken), lcgOverride(lcgOverride) { }
 
 void BackendConfig::ToDefault() {
   domain = OPENSHOCK_API_DOMAIN;
@@ -22,6 +24,7 @@ bool BackendConfig::FromFlatbuffers(const Serialization::Configuration::BackendC
 
   Internal::Utils::FromFbsStr(domain, config->domain(), OPENSHOCK_API_DOMAIN);
   Internal::Utils::FromFbsStr(authToken, config->auth_token(), "");
+  Internal::Utils::FromFbsStr(lcgOverride, config->lcg_override(), "");
 
   return true;
 }
@@ -36,7 +39,9 @@ flatbuffers::Offset<OpenShock::Serialization::Configuration::BackendConfig> Back
     authTokenOffset = 0;
   }
 
-  return Serialization::Configuration::CreateBackendConfig(builder, domainOffset, authTokenOffset);
+  auto lcgOverrideOffset = builder.CreateString(lcgOverride);
+
+  return Serialization::Configuration::CreateBackendConfig(builder, domainOffset, authTokenOffset, lcgOverrideOffset);
 }
 
 bool BackendConfig::FromJSON(const cJSON* json) {
@@ -52,6 +57,7 @@ bool BackendConfig::FromJSON(const cJSON* json) {
 
   Internal::Utils::FromJsonStr(domain, json, "domain", OPENSHOCK_API_DOMAIN);
   Internal::Utils::FromJsonStr(authToken, json, "authToken", "");
+  Internal::Utils::FromJsonStr(lcgOverride, json, "lcgOverride", "");
 
   return true;
 }
@@ -60,9 +66,12 @@ cJSON* BackendConfig::ToJSON(bool withSensitiveData) const {
   cJSON* root = cJSON_CreateObject();
 
   cJSON_AddStringToObject(root, "domain", domain.c_str());
+
   if (withSensitiveData) {
     cJSON_AddStringToObject(root, "authToken", authToken.c_str());
   }
 
+  cJSON_AddStringToObject(root, "lcgOverride", lcgOverride.c_str());
+
   return root;
 }
diff --git a/src/config/Config.cpp b/src/config/Config.cpp
@@ -695,3 +695,47 @@ bool Config::ClearBackendAuthToken() {
   _configData.backend.authToken.clear();
   return _trySaveConfig();
 }
+
+bool Config::HasBackendLCGOverride() {
+  ScopedReadLock lock(&_configMutex);
+  if (!lock.isLocked()) {
+    ESP_LOGE(TAG, "Failed to acquire read lock");
+    return false;
+  }
+
+  return !_configData.backend.lcgOverride.empty();
+}
+
+bool Config::GetBackendLCGOverride(std::string& out) {
+  ScopedReadLock lock(&_configMutex);
+  if (!lock.isLocked()) {
+    ESP_LOGE(TAG, "Failed to acquire read lock");
+    return false;
+  }
+
+  out = _configData.backend.lcgOverride;
+
+  return true;
+}
+
+bool Config::SetBackendLCGOverride(const std::string& lcgOverride) {
+  ScopedWriteLock lock(&_configMutex);
+  if (!lock.isLocked()) {
+    ESP_LOGE(TAG, "Failed to acquire write lock");
+    return false;
+  }
+
+  _configData.backend.lcgOverride = lcgOverride;
+  return _trySaveConfig();
+}
+
+bool Config::ClearBackendLCGOverride() {
+  ScopedWriteLock lock(&_configMutex);
+  if (!lock.isLocked()) {
+    ESP_LOGE(TAG, "Failed to acquire write lock");
+    return false;
+  }
+
+  _configData.backend.lcgOverride.clear();
+  return _trySaveConfig();
+}