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 "glibmainloop.h"
  22 #include <json.h>
  23 #include <iostream>
  24 #include <stdexcept>
  25 #include <boost/concept_check.hpp>
  26 //#include <json-glib/json-glib.h>
  27
  28
  29 using namespace std;
  30
  31 /********************************************
  32  * Example JSON config:
  33  * {
  34  *      sources: [ path1, path2, path3 ]
  35  *      sinks: [ path1, path2, path3 ]
  36  * }
  37  *
  38 **********************************************/
  39
  40 std::string get_file_contents(const char *filename)
  41 {
  42   //FILE *in = fopen(filename,"r");
  43
  44   std::ifstream in(filename, std::ios::in);
  45   std::string output;
  46   std::string line;
  47   while(in.good())
  48   {
  49     getline(in,line);
  50     output.append(line);
  51   }
  52   return output;
  53 }
  54 PluginLoader::PluginLoader(string configFile, AbstractRoutingEngine* re, int argc, char** argv): f_create(NULL), routingEngine(re), mMainLoop(nullptr)
  55 {
  56
  57         DebugOut()<<"Loading config file: "<<configFile<<endl;
  58         json_object *rootobject;
  59         json_tokener *tokener = json_tokener_new();
  60         std::string configBuffer = get_file_contents(configFile.c_str());
  61         if(configBuffer == "")
  62         {
  63                 throw std::runtime_error("No config or config empty");
  64         }
  65         enum json_tokener_error err;
  66         do
  67         {
  68                 rootobject = json_tokener_parse_ex(tokener, configBuffer.c_str(),configBuffer.length());
  69         } while ((err = json_tokener_get_error(tokener)) == json_tokener_continue);
  70         if (err != json_tokener_success)
  71         {
  72                 fprintf(stderr, "Error: %s\n", json_tokener_error_desc(err));
  73                 // Handle errors, as appropriate for your application.
  74         }
  75         if (tokener->char_offset < configFile.length()) // XXX shouldn't access internal fields
  76         {
  77                 // Handle extra characters after parsed object as desired.
  78                 // e.g. issue an error, parse another object from that point, etc...
  79         }
  80
  81         //DebugOut()<<"Config members: "<<json_reader_count_members(reader)<<endl;
  82         json_object *mainloopobject = json_object_object_get(rootobject,"mainloop");
  83         if (mainloopobject)
  84         {
  85                 /// there is a mainloop entry.  Load the plugin:
  86
  87                 string mainloopstr = string(json_object_get_string(mainloopobject));
  88
  89                 mMainLoop = loadMainLoop(mainloopstr,argc, argv);
  90
  91                 if(!mMainLoop)
  92                 {
  93                         DebugOut(0)<<"Failed to load main loop plugin."<<endl;
  94                 }
  95         }
  96         else if(!mMainLoop)
  97         {
  98                 /// there is no mainloop entry, use default glib
  99                 DebugOut()<<"No mainloop specified in config.  Using glib by default."<<endl;
 100                 mMainLoop = new GlibMainLoop(argc,argv);
 101         }
 102
 103         json_object *sourcesobject = json_object_object_get(rootobject,"sources");
 104
 105         if(!sourcesobject)
 106         {
 107                 DebugOut()<<"Error getting sources member: "<<endl;
 108                 throw std::runtime_error("Error getting sources member");
 109         }
 110
 111         //g_assert(json_reader_is_array(reader));
 112         g_assert(json_object_get_type(sourcesobject)==json_type_array);
 113
 114
 115         array_list *sourceslist = json_object_get_array(sourcesobject);
 116         if (!sourceslist)
 117         {
 118           DebugOut() << "Error getting source list" << endl;
 119           throw std::runtime_error("Error getting sources list");
 120         }
 121
 122         for(int i=0; i < array_list_length(sourceslist); i++)
 123         {
 124                 json_object *obj = (json_object*)array_list_get_idx(sourceslist,i); //This is an object
 125
 126                 std::map<std::string, std::string> configurationMap;
 127                 json_object_object_foreach(obj, key, val)
 128                 {
 129                         string valstr = json_object_get_string(val);
 130                         DebugOut() << "plugin config key: " << key << "value:" << valstr << endl;
 131                         configurationMap[key] = valstr;
 132                 }
 133
 134                 string path = configurationMap["path"];
 135
 136                 AbstractSource* plugin = loadPlugin<AbstractSource*>(path,configurationMap);
 137
 138                 if(plugin != nullptr)
 139                 {
 140                         mSources.push_back(plugin);
 141                 }
 142         }
 143         DebugOut() << "Trying to free list" << endl;
 144         //array_list_free(sourceslist);
 145         DebugOut() << "Trying to free obj" << endl;
 146         json_object_put(sourcesobject);
 147         DebugOut() << "Done first" << endl;
 148         ///read the sinks:
 149
 150         json_object *sinksobject = json_object_object_get(rootobject,"sinks");
 151
 152         if (!sinksobject)
 153         {
 154           DebugOut() << "Error getting sink object" << endl;
 155           throw std::runtime_error("Error getting sink object");
 156         }
 157
 158
 159
 160         array_list *sinkslist = json_object_get_array(sinksobject);
 161
 162
 163         if (!sinkslist)
 164         {
 165           DebugOut() << "Error getting sink list" << endl;
 166           throw std::runtime_error("Error getting sink list");
 167         }
 168
 169
 170         for(int i=0; i < array_list_length(sinkslist); i++)
 171         {
 172                 json_object *obj = (json_object*)array_list_get_idx(sinkslist,i);
 173
 174                 std::map<std::string, std::string> configurationMap;
 175
 176                 json_object_object_foreach(obj, key, val)
 177                 {
 178                         string valstr = json_object_get_string(val);
 179                         DebugOut() << "plugin config key: " << key << "value:" << valstr << endl;
 180                         configurationMap[key] = valstr;
 181                 }
 182
 183
 184                 string path = configurationMap["path"];
 185
 186                 AbstractSinkManager* plugin = loadPlugin<AbstractSinkManager*>(path, configurationMap);
 187
 188                 if(plugin == nullptr)
 189                 {
 190                         throw std::runtime_error("plugin is not a SinkManager");
 191                 }
 192         }
 193
 194         DebugOut() << "Trying to free obj" << endl;
 195         json_object_put(sinksobject);
 196         DebugOut() << "Done" << endl;
 197 }
 198
 199 PluginLoader::~PluginLoader()
 200 {
 201 }
 202
 203 IMainLoop *PluginLoader::mainloop()
 204 {
 205         return mMainLoop;
 206 }
 207
 208 SourceList PluginLoader::sources()
 209 {
 210         return mSources;
 211 }
 212
 213
 214
 215 std::string PluginLoader::errorString()
 216 {
 217         return mErrorString;
 218 }
 219