ambd/pluginloader.cpp

   1 /*
   2 Copyright (C) 2012 Intel Corporation
   3
   4 This library is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU Lesser General Public
   6 License as published by the Free Software Foundation; either
   7 version 2.1 of the License, or (at your option) any later version.
   8
   9 This library is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 Lesser General Public License for more details.
  13
  14 You should have received a copy of the GNU Lesser General Public
  15 License along with this library; if not, write to the Free Software
  16 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18
  19
  20 #include "pluginloader.h"
  21 #include <iostream>
  22 #include <stdexcept>
  23 #include <json-glib/json-glib.h>
  24
  25 using namespace std;
  26
  27 /********************************************
  28  * Example JSON config:
  29  * {
  30  *      sources: [ path1, path2, path3 ]
  31  *      sinks: [ path1, path2, path3 ]
  32  * }
  33  *
  34 **********************************************/
  35
  36 PluginLoader::PluginLoader(string configFile, AbstractRoutingEngine* re): f_create(NULL), routingEngine(re)
  37 {
  38         DebugOut()<<"Loading config file: "<<configFile<<endl;
  39
  40         JsonParser* parser = json_parser_new();
  41         GError* error = nullptr;
  42         if(!json_parser_load_from_file(parser, configFile.c_str(), &error))
  43         {
  44                 DebugOut()<<"Failed to load config: "<<error->message;
  45                 throw std::runtime_error("Failed to load config");
  46         }
  47
  48         JsonNode* node = json_parser_get_root(parser);
  49
  50         if(node == nullptr)
  51                 throw std::runtime_error("Unable to get JSON root object");
  52
  53         JsonReader* reader = json_reader_new(node);
  54
  55         if(reader == nullptr)
  56                 throw std::runtime_error("Unable to create JSON reader");
  57
  58         DebugOut()<<"Config members: "<<json_reader_count_members(reader)<<endl;
  59
  60         json_reader_read_member(reader,"sources");
  61
  62         const GError * srcReadError = json_reader_get_error(reader);
  63
  64         if(srcReadError != nullptr)
  65         {
  66                 DebugOut()<<"Error getting sources member: "<<srcReadError->message<<endl;
  67                 throw std::runtime_error("Error getting sources member");
  68         }
  69
  70         g_assert(json_reader_is_array(reader));
  71
  72
  73         for(int i=0; i < json_reader_count_elements(reader); i++)
  74         {
  75                 json_reader_read_element(reader,i);
  76
  77                 gchar** srcMembers = json_reader_list_members(reader);
  78
  79                 std::map<std::string, std::string> configurationMap;
  80
  81                 for(int i=0; i< json_reader_count_members(reader); i++)
  82                 {
  83                         json_reader_read_member(reader,srcMembers[i]);
  84                         configurationMap[srcMembers[i]] = json_reader_get_string_value(reader);
  85                         DebugOut()<<"plugin config key: "<<srcMembers[i]<<" value: "<<configurationMap[srcMembers[i]]<<endl;
  86                         json_reader_end_member(reader);
  87                 }
  88
  89                 json_reader_read_member(reader, "path");
  90                 string path = json_reader_get_string_value(reader);
  91                 json_reader_end_member(reader);
  92
  93                 AbstractSource* plugin = loadPlugin<AbstractSource*>(path,configurationMap);
  94
  95                 if(plugin != nullptr)
  96                 {
  97                         mSources.push_back(plugin);
  98                 }
  99
 100                 json_reader_end_element(reader);
 101         }
 102
 103         json_reader_end_member(reader);
 104
 105         ///read the sinks:
 106
 107         json_reader_read_member(reader,"sinks");
 108
 109         for(int i=0; i < json_reader_count_elements(reader); i++)
 110         {
 111                 json_reader_read_element(reader,i);
 112
 113                 gchar** srcMembers = json_reader_list_members(reader);
 114
 115                 std::map<std::string, std::string> configurationMap;
 116
 117                 for(int i=0; i< json_reader_count_members(reader); i++)
 118                 {
 119                         json_reader_read_member(reader,srcMembers[i]);
 120                         configurationMap[srcMembers[i]] = json_reader_get_string_value(reader);
 121                         json_reader_end_member(reader);
 122                 }
 123
 124                 json_reader_read_member(reader, "path");
 125                 string path = json_reader_get_string_value(reader);
 126                 json_reader_end_member(reader);
 127
 128                 AbstractSinkManager* plugin = loadPlugin<AbstractSinkManager*>(path, configurationMap);
 129
 130                 if(plugin == nullptr)
 131                 {
 132                         throw std::runtime_error("plugin is not a SinkManager");
 133                 }
 134
 135                 json_reader_end_element(reader);
 136         }
 137
 138         json_reader_end_member(reader);
 139
 140         ///TODO: this will probably explode:
 141
 142         if(error) g_error_free(error);
 143
 144         g_object_unref(reader);
 145         g_object_unref(parser);
 146
 147 }
 148
 149 PluginLoader::~PluginLoader()
 150 {
 151         for(auto itr = mSinks.begin(); itr != mSinks.end(); itr++)
 152         {
 153                 delete *itr;
 154         }
 155
 156         for(auto itr = mSources.begin(); itr != mSources.end(); itr++)
 157         {
 158                 delete *itr;
 159         }
 160 }
 161
 162 SinkList PluginLoader::sinks()
 163 {
 164         return mSinks;
 165 }
 166
 167 SourceList PluginLoader::sources()
 168 {
 169         return mSources;
 170 }
 171
 172
 173
 174 std::string PluginLoader::errorString()
 175 {
 176         return mErrorString;
 177 }
 178