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         gchar** members = json_reader_list_members(reader);
  61
  62         for(int i=0; i< json_reader_count_members(reader); i++)
  63         {
  64                 cout<<"member: "<<members[i]<<endl;
  65         }
  66
  67         json_reader_read_member(reader,"sources");
  68
  69         const GError * srcReadError = json_reader_get_error(reader);
  70
  71         if(srcReadError != nullptr)
  72         {
  73                 DebugOut()<<"Error getting sources member: "<<srcReadError->message<<endl;
  74                 throw std::runtime_error("Error getting sources member");
  75         }
  76
  77         g_assert(json_reader_is_array(reader));
  78
  79
  80         for(int i=0; i < json_reader_count_elements(reader); i++)
  81         {
  82                 json_reader_read_element(reader,i);
  83
  84                 gchar** srcMembers = json_reader_list_members(reader);
  85
  86                 std::map<std::string, std::string> configurationMap;
  87
  88                 for(int i=0; i< json_reader_count_members(reader); i++)
  89                 {
  90                         json_reader_read_member(reader,srcMembers[i]);
  91                         configurationMap[srcMembers[i]] = json_reader_get_string_value(reader);
  92                         DebugOut()<<"plugin config key: "<<srcMembers[i]<<" value: "<<configurationMap[srcMembers[i]]<<endl;
  93                         json_reader_end_member(reader);
  94                 }
  95
  96                 json_reader_read_member(reader, "path");
  97                 string path = json_reader_get_string_value(reader);
  98                 json_reader_end_member(reader);
  99
 100                 AbstractSource* plugin = loadPlugin<AbstractSource*>(path,configurationMap);
 101
 102                 if(plugin != nullptr)
 103                 {
 104                         mSources.push_back(plugin);
 105                 }
 106
 107                 json_reader_end_element(reader);
 108         }
 109
 110         json_reader_end_member(reader);
 111
 112         ///read the sinks:
 113
 114         json_reader_read_member(reader,"sinks");
 115
 116         for(int i=0; i < json_reader_count_elements(reader); i++)
 117         {
 118                 json_reader_read_element(reader,i);
 119
 120                 gchar** srcMembers = json_reader_list_members(reader);
 121
 122                 std::map<std::string, std::string> configurationMap;
 123
 124                 for(int i=0; i< json_reader_count_members(reader); i++)
 125                 {
 126                         json_reader_read_member(reader,srcMembers[i]);
 127                         configurationMap[srcMembers[i]] = json_reader_get_string_value(reader);
 128                         json_reader_end_member(reader);
 129                 }
 130
 131                 json_reader_read_member(reader, "path");
 132                 string path = json_reader_get_string_value(reader);
 133                 json_reader_end_member(reader);
 134
 135                 AbstractSinkManager* plugin = loadPlugin<AbstractSinkManager*>(path, configurationMap);
 136
 137                 if(plugin == nullptr)
 138                 {
 139                         throw std::runtime_error("plugin is not a SinkManager");
 140                 }
 141
 142                 json_reader_end_element(reader);
 143         }
 144
 145         json_reader_end_member(reader);
 146
 147         ///TODO: this will probably explode:
 148
 149         if(error) g_error_free(error);
 150
 151         g_object_unref(reader);
 152         g_object_unref(parser);
 153
 154 }
 155
 156 SinkList PluginLoader::sinks()
 157 {
 158         return mSinks;
 159 }
 160
 161 SourceList PluginLoader::sources()
 162 {
 163         return mSources;
 164 }
 165
 166
 167
 168 std::string PluginLoader::errorString()
 169 {
 170         return mErrorString;
 171 }
 172