mqtt::bridge::lib::BridgeStore Class Reference

#include <BridgeStore.h>

Collaboration diagram for mqtt::bridge::lib::BridgeStore:

Public Member Functions
bool	loadAndValidate (const std::string &fileName)
const Broker &	getBroker (const std::string &instanceName)
const std::map< std::string, Broker > &	getBrokers ()

Static Public Member Functions
static BridgeStore &	instance ()

Private Member Functions
	BridgeStore ()=default

Private Attributes
std::list< Bridge >	bridgeList
std::map< std::string, Broker >	brokers

Detailed Description

Definition at line 58 of file BridgeStore.h.

Constructor & Destructor Documentation

BridgeStore()

mqtt::bridge::lib::BridgeStore::BridgeStore ( )

privatedefault

Member Function Documentation

getBroker()

const Broker & mqtt::bridge::lib::BridgeStore::getBroker

(

const std::string &

instanceName

)

Definition at line 177 of file BridgeStore.cpp.

                                                                      {
        return brokers.find(instanceName)->second;
    }

getBrokers()

const std::map< std::string, Broker > & mqtt::bridge::lib::BridgeStore::getBrokers

(

)

Definition at line 181 of file BridgeStore.cpp.

                                                             {
        return brokers;
    }

References brokers.

instance()

BridgeStore & mqtt::bridge::lib::BridgeStore::instance ( )

static

Definition at line 64 of file BridgeStore.cpp.

                                       {
        static BridgeStore bridgeConfigLoader;
 
        return bridgeConfigLoader;
    }

Referenced by mqtt::mqttbridge::websocket::SubProtocolFactory::create(), and main().

Here is the caller graph for this function:

loadAndValidate()

bool mqtt::bridge::lib::BridgeStore::loadAndValidate

(

const std::string &

fileName

)

Definition at line 70 of file BridgeStore.cpp.

                                                               {
        bool success = !brokers.empty();
 
#include "bridge-schema.json.h" // IWYU pragma: keep
 
        if (!success) {
            try {
                const nlohmann::json bridgeJsonSchema = nlohmann::json::parse(bridgeJsonSchemaString);
 
                if (!fileName.empty()) {
                    std::ifstream bridgeConfigJsonFile(fileName);
 
                    if (bridgeConfigJsonFile.is_open()) {
                        VLOG(1) << "Bridge config JSON: " << fileName;
 
                        try {
                            nlohmann::json bridgesConfigJson;
 
                            bridgeConfigJsonFile >> bridgesConfigJson;
 
                            try {
                                const nlohmann::json_schema::json_validator validator(bridgeJsonSchema);
 
                                try {
                                    const nlohmann::json defaultPatch = validator.validate(bridgesConfigJson);
 
                                    try {
                                        bridgesConfigJson = bridgesConfigJson.patch(defaultPatch);
 
                                        for (const nlohmann::json& bridgeConfigJson : bridgesConfigJson["bridges"]) {
                                            Bridge& bridge = bridgeList.emplace_back(
                                                bridgeConfigJson["name"], bridgeConfigJson["prefix"], bridgeConfigJson["disabled"]);
 
                                            for (const nlohmann::json& brokerConfigJson : bridgeConfigJson["brokers"]) {
                                                std::list<iot::mqtt::Topic> topics;
                                                for (const nlohmann::json& topicJson : brokerConfigJson["topics"]) {
                                                    if (!topicJson["topic"].get<std::string>().empty()) {
                                                        topics.emplace_back(topicJson["topic"], // cppcheck-suppress useStlAlgorithm
                                                                            topicJson["qos"]);
                                                    }
                                                }
 
                                                const nlohmann::json& mqtt = brokerConfigJson["mqtt"];
                                                const nlohmann::json& network = brokerConfigJson["network"];
 
                                                const std::string fullInstanceName =
                                                    bridge.getName() + "+" + network["instance_name"].get<std::string>();
 
                                                brokers.emplace(fullInstanceName,
                                                                Broker(bridge,
                                                                       brokerConfigJson["session_store"],
                                                                       fullInstanceName,
                                                                       network["protocol"],
                                                                       network["encryption"],
                                                                       network["transport"],
                                                                       network[network["protocol"]],
                                                                       mqtt["client_id"],
                                                                       mqtt["keep_alive"],
                                                                       mqtt["clean_session"],
                                                                       mqtt["will_topic"],
                                                                       mqtt["will_message"],
                                                                       mqtt["will_qos"],
                                                                       mqtt["will_retain"],
                                                                       mqtt["username"],
                                                                       mqtt["password"],
                                                                       mqtt["loop_prevention"],
                                                                       brokerConfigJson["prefix"],
                                                                       brokerConfigJson["disabled"],
                                                                       topics));
                                            }
                                        }
 
                                        success = true;
                                    } catch (const std::exception& e) {
                                        VLOG(1) << "  Patching JSON with default patch failed:\n" << defaultPatch.dump(4);
                                        VLOG(1) << "    " << e.what();
                                    }
                                } catch (const std::exception& e) {
                                    VLOG(1) << "  Validating JSON failed:\n" << bridgesConfigJson.dump(4);
                                    VLOG(1) << "    " << e.what();
                                }
                            } catch (const std::exception& e) {
                                VLOG(1) << "  Setting root json mapping schema failed:\n" << bridgeJsonSchema.dump(4);
                                VLOG(1) << "    " << e.what();
                            }
                        } catch (const std::exception& e) {
                            VLOG(1) << "  JSON map file parsing failed:" << e.what() << " at " << bridgeConfigJsonFile.tellg();
                        }
 
                        bridgeConfigJsonFile.close();
                    } else {
                        VLOG(1) << "BridgeJsonConfig: " << fileName << " not found";
                    }
                } else {
                    // Do not log missing path. In regular use this missing option is captured by the command line interface
                }
            } catch (const std::exception& e) {
                VLOG(1) << "Parsing schema failed: " << e.what();
                VLOG(1) << bridgeJsonSchemaString;
            }
        } else {
            VLOG(1) << "MappingFile already loaded and validated";
        }
 
        return success;
    }

References brokers, nlohmann::json_schema::json_validator::json_validator(), and nlohmann::json_schema::json_validator::validate().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bridgeList

std::list<Bridge> mqtt::bridge::lib::BridgeStore::bridgeList

private

Definition at line 71 of file BridgeStore.h.

brokers

std::map<std::string, Broker> mqtt::bridge::lib::BridgeStore::brokers

private

Definition at line 72 of file BridgeStore.h.

Referenced by getBrokers(), and loadAndValidate().

---

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

• mqttbridge/lib/BridgeStore.h
• mqttbridge/lib/BridgeStore.cpp