diff --git a/CMakeLists.txt b/CMakeLists.txt index d80ae06..147adfc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -18,7 +18,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON) ############################################################################################ ### dependencies and options -ecbuild_find_package( NAME eckit VERSION 1.18 REQUIRED ) +ecbuild_find_package( NAME eckit VERSION 1.28.0 REQUIRED ) ecbuild_find_package( NAME atlas ) ecbuild_add_option( FEATURE BUILD_TOOLS diff --git a/cmake/fortran_plugin.cc.in b/cmake/fortran_plugin.cc.in index 1bd9f66..63a06e1 100644 --- a/cmake/fortran_plugin.cc.in +++ b/cmake/fortran_plugin.cc.in @@ -17,7 +17,6 @@ namespace interface_plugin { REGISTER_LIBRARY(InterfacePlugin__@PLUGIN_NAME@) InterfacePlugin__@PLUGIN_NAME@::InterfacePlugin__@PLUGIN_NAME@() : Plugin(InterfacePlugin__@PLUGIN_NAME@::name()) {} -InterfacePlugin__@PLUGIN_NAME@::~InterfacePlugin__@PLUGIN_NAME@() {} const InterfacePlugin__@PLUGIN_NAME@& InterfacePlugin__@PLUGIN_NAME@::instance() { static InterfacePlugin__@PLUGIN_NAME@ instance; @@ -28,7 +27,6 @@ const InterfacePlugin__@PLUGIN_NAME@& InterfacePlugin__@PLUGIN_NAME@::instance() // InterfacePluginCore__@PLUGINCORE_NAME@ static plume::PluginCoreBuilder plugincore_Interface_Builder__@PLUGINCORE_NAME@; InterfacePluginCore__@PLUGINCORE_NAME@::InterfacePluginCore__@PLUGINCORE_NAME@(const eckit::Configuration& conf) : PluginCore(conf), config_{conf} {} -InterfacePluginCore__@PLUGINCORE_NAME@::~InterfacePluginCore__@PLUGINCORE_NAME@() {} //-------------------------------------------------------------- diff --git a/cmake/fortran_plugin.h.in b/cmake/fortran_plugin.h.in index 93f5871..a26bcf6 100644 --- a/cmake/fortran_plugin.h.in +++ b/cmake/fortran_plugin.h.in @@ -30,7 +30,6 @@ namespace interface_plugin { class InterfacePluginCore__@PLUGINCORE_NAME@ : public plume::PluginCore { public: InterfacePluginCore__@PLUGINCORE_NAME@(const eckit::Configuration& conf); - ~InterfacePluginCore__@PLUGINCORE_NAME@(); virtual void setup() override { plugincore_setup__@PLUGIN_NAME@__@PLUGINCORE_NAME@(&config_, &modelData()); @@ -59,7 +58,6 @@ class InterfacePlugin__@PLUGIN_NAME@ : public plume::Plugin { public: InterfacePlugin__@PLUGIN_NAME@(); - ~InterfacePlugin__@PLUGIN_NAME@(); // Name set in the Fortran interface static const char* name() { diff --git a/examples/example1.F90 b/examples/example1.F90 index 465436d..d6127fc 100644 --- a/examples/example1.F90 +++ b/examples/example1.F90 @@ -8,7 +8,7 @@ ! does it submit to any jurisdiction. program my_program -use iso_c_binding, only : c_null_char +use iso_c_binding, only : c_null_char, c_double use plume_module use atlas_module, only : atlas_Field, atlas_integer @@ -28,6 +28,10 @@ program my_program integer :: param_k = 100 type(atlas_Field) :: field +integer :: config_param_1 = 9 +real(c_double) :: config_param_2 = 99.99 +type(atlas_Field) :: config_param_3 + integer :: iter write(*,*) "*** Running Example 1 (Fortran interface) ***\n" @@ -44,18 +48,30 @@ program my_program call plume_check(offers%offer_int("K", "always", "this is param K")) call plume_check(offers%offer_atlas_field("field_dummy_1", "always", "this is param K")) +call plume_check(offers%offer_int("config-param-1", "always", "this is param config-param-1")) +call plume_check(offers%offer_double("config-param-2", "always", "this is param config-param-2")) +call plume_check(offers%offer_atlas_field("config-param-3", "always", "this is param config-param-3")) + ! negotiate call plume_check(manager%initialise()) call plume_check(manager%configure(trim(plume_config_path)//c_null_char)) call plume_check(manager%negotiate(offers)) ! fill in data +field = atlas_Field("field_dummy_1", atlas_integer(), (/0,10/)) +config_param_3 = atlas_Field("config-param-3", atlas_integer(), (/0,10/)) + call plume_check(data%initialise()) call plume_check(data%provide_int("I", param_i) ) call plume_check(data%provide_int("J", param_j) ) call plume_check(data%provide_int("K", param_k) ) -field = atlas_Field("field_dummy_1", atlas_integer(), (/0,10/)) -call plume_check( data%provide_atlas_field_shared("field_dummy_1", field) ) +call plume_check(data%provide_atlas_field_shared("field_dummy_1", field) ) + +call plume_check(data%provide_int("config-param-1", config_param_1) ) +call plume_check(data%provide_double("config-param-2", config_param_2) ) +call plume_check(data%provide_atlas_field_shared("config-param-3", config_param_3) ) + + ! pass data to the plugins call plume_check(manager%feed_plugins(data)) diff --git a/examples/example1.cc b/examples/example1.cc index b287f4a..73a6017 100644 --- a/examples/example1.cc +++ b/examples/example1.cc @@ -48,6 +48,10 @@ int main(int argc, char** argv) { offers.offerInt("J", "always", "this is param J"); offers.offerInt("K", "always", "this is param K"); offers.offerAtlasField("field_dummy_1", "always", "this is dummy_field"); + + offers.offerInt("config-param-1", "always", "this is param config-param-1"); + offers.offerDouble("config-param-2", "always", "this is param config-param-2"); + offers.offerAtlasField("config-param-3", "always", "this is param config-param-3"); plume::Manager::negotiate(offers); // data @@ -56,12 +60,20 @@ int main(int argc, char** argv) { int param_k = 100; atlas::Field field = createAtlasField(); + int config_param_1 = 9; + double config_param_2 = 99.99; + atlas::Field config_param_3 = createAtlasField(); + plume::data::ModelData data; data.provideInt("I", ¶m_i); data.provideInt("J", ¶m_j); data.provideInt("K", ¶m_k); data.provideAtlasFieldShared("field_dummy_1", field.get()); + data.provideInt("config-param-1", &config_param_1); + data.provideDouble("config-param-2", &config_param_2); + data.provideAtlasFieldShared("config-param-3", config_param_3.get()); + // Feed plugins with the data plume::Manager::feedPlugins(data); diff --git a/examples/example2.F90 b/examples/example2.F90 index 0030f8e..a5a479b 100644 --- a/examples/example2.F90 +++ b/examples/example2.F90 @@ -8,7 +8,7 @@ ! does it submit to any jurisdiction. program my_program -use iso_c_binding, only : c_bool, c_null_char +use iso_c_binding, only : c_bool, c_null_char, c_double use plume_module use atlas_module, only : atlas_Field, atlas_integer @@ -27,6 +27,11 @@ program my_program character(*), parameter :: field_name = "field_dummy_1"//c_null_char type(atlas_Field) :: field +integer :: config_param_1 = 9 +real(c_double) :: config_param_2 = 99.99 +type(atlas_Field) :: config_param_3 + + logical(c_bool) :: is_param_requested integer :: iter @@ -45,6 +50,11 @@ program my_program call plume_check(offers%offer_int("K", "always", "this is param K")) call plume_check(offers%offer_atlas_field(field_name, "on-request", "this is an atlas field")) +call plume_check(offers%offer_int("config-param-1", "always", "this is param config-param-1")) +call plume_check(offers%offer_double("config-param-2", "always", "this is param config-param-2")) +call plume_check(offers%offer_atlas_field("config-param-3", "always", "this is param config-param-3")) + + ! negotiate call plume_check(manager%initialise()) call plume_check(manager%configure(trim(plume_config_path)//c_null_char)) @@ -70,6 +80,12 @@ program my_program call plume_check( data%provide_atlas_field_shared(field_name, field) ) endif +config_param_3 = atlas_Field("config-param-3", atlas_integer(), (/0,10/)) +call plume_check(data%provide_int("config-param-1", config_param_1) ) +call plume_check(data%provide_double("config-param-2", config_param_2) ) +call plume_check(data%provide_atlas_field_shared("config-param-3", config_param_3) ) + + call plume_check(data%print()) ! pass data to the plugins diff --git a/examples/example2.cc b/examples/example2.cc index 750dfd1..3a4c370 100644 --- a/examples/example2.cc +++ b/examples/example2.cc @@ -47,13 +47,25 @@ int main(int argc, char** argv) { offers.offerInt("I", "always", "this is param I"); offers.offerInt("J", "always", "this is param J"); offers.offerInt("K", "always", "this is param K"); + offers.offerAtlasField("field_dummy_1", "on-request", "this is dummy_field"); + + offers.offerInt("config-param-1", "on-request", "this is param config-param-1"); + offers.offerDouble("config-param-2", "on-request", "this is param config-param-2"); + offers.offerAtlasField("config-param-3", "on-request", "this is param config-param-3"); + plume::Manager::negotiate(offers); // data int param_i = 0; int param_j = 10; int param_k = 100; + atlas::Field field_dummy; + + int config_param_1 = 9; + double config_param_2 = 99.99; + atlas::Field config_param_3; + plume::data::ModelData data; // Insert some int parameters (regardless of whether @@ -69,12 +81,29 @@ int main(int argc, char** argv) { // => This information can be used to insert "on-request" params // (i.e parameters that are inserted only if requested by plugins) // - // For example, if "field_dummy_1" has been requested, then insert it: - std::string name = "field_dummy_1"; - atlas::Field field; + // For example, if "field_dummy_1" has been requested, then insert it: + std::string name; + + name = "field_dummy_1"; + if ( plume::Manager::isParamRequested(name) ) { + field_dummy = createAtlasField(name); + data.provideAtlasFieldShared(name, field_dummy.get()); + } + + name = "config-param-1"; + if ( plume::Manager::isParamRequested(name) ) { + data.provideInt(name, &config_param_1); + } + + name = "config-param-2"; + if ( plume::Manager::isParamRequested(name) ) { + data.provideDouble(name, &config_param_2); + } + + name = "config-param-3"; if ( plume::Manager::isParamRequested(name) ) { - field = createAtlasField(name); - data.provideAtlasFieldShared(name, field.get()); + config_param_3 = createAtlasField(name); + data.provideAtlasFieldShared(name, config_param_3.get()); } // Once data is ready.. feed the plugins! diff --git a/examples/example3.F90 b/examples/example3.F90 index 2545b74..8c45997 100644 --- a/examples/example3.F90 +++ b/examples/example3.F90 @@ -8,78 +8,94 @@ ! does it submit to any jurisdiction. program my_program - use iso_c_binding, only : c_null_char - use plume_module - use atlas_module, only : atlas_Field, atlas_integer - - - implicit none - - character(1024) :: plume_config_path - - ! plume structures - type(plume_protocol) :: offers - type(plume_manager) :: manager - type(plume_data) :: data - - ! data - type(atlas_Field) :: field - - integer :: iter - - write(*,*) "*** Running Example 3 (Fortran interface) ***\n" - - CALL get_command_argument(1, plume_config_path) - - ! init - call plume_check(plume_initialise()) - - ! make offers - call plume_check(offers%initialise()) - call plume_check(offers%offer_int("I", "always", "this is param I")) - call plume_check(offers%offer_int("J", "always", "this is param J")) - call plume_check(offers%offer_int("K", "always", "this is param K")) - call plume_check(offers%offer_atlas_field("field_dummy_1", "always", "this is param K")) - - ! negotiate - call plume_check(manager%initialise()) - call plume_check(manager%configure(trim(plume_config_path)//c_null_char)) - call plume_check(manager%negotiate(offers)) - - ! fill in data - call plume_check(data%initialise()) - - ! make space for new parameters in the data - call plume_check(data%create_int("I", 0) ) - call plume_check(data%create_int("J", 10) ) - call plume_check(data%create_int("K", 100) ) - - field = atlas_Field("field_dummy_1", atlas_integer(), (/0,10/)) - call plume_check( data%provide_atlas_field_shared("field_dummy_1", field) ) - - ! pass data to the plugins - call plume_check(manager%feed_plugins(data)) - - ! Run the model for 10 iterations - do iter=1,10 - - ! update the internal parameters - call plume_check(data%update_int("I", 0+iter) ) - call plume_check(data%update_int("J", 10+iter) ) - call plume_check(data%update_int("K", 100+iter) ) - - ! run the model.. - call plume_check(manager%run()) - enddo - - ! finalise - call plume_check(data%finalise()) - call plume_check(manager%finalise()) - call plume_check(offers%finalise()) - call plume_check(plume_finalise()) - - write(*,*) "*** Example 3 complete. ***" - write(*,*) - - end program - \ No newline at end of file +use iso_c_binding, only : c_null_char, c_double +use plume_module +use atlas_module, only : atlas_Field, atlas_integer + + +implicit none + +character(1024) :: plume_config_path + +! plume structures +type(plume_protocol) :: offers +type(plume_manager) :: manager +type(plume_data) :: data + +! data +type(atlas_Field) :: field + +integer :: config_param_1 = 9 +real(c_double) :: config_param_2 = 99.99 +type(atlas_Field) :: config_param_3 + + +integer :: iter + +write(*,*) "*** Running Example 3 (Fortran interface) ***\n" + +CALL get_command_argument(1, plume_config_path) + +! init +call plume_check(plume_initialise()) + +! make offers +call plume_check(offers%initialise()) +call plume_check(offers%offer_int("I", "always", "this is param I")) +call plume_check(offers%offer_int("J", "always", "this is param J")) +call plume_check(offers%offer_int("K", "always", "this is param K")) +call plume_check(offers%offer_atlas_field("field_dummy_1", "always", "this is param K")) + +call plume_check(offers%offer_int("config-param-1", "always", "this is param config-param-1")) +call plume_check(offers%offer_double("config-param-2", "always", "this is param config-param-2")) +call plume_check(offers%offer_atlas_field("config-param-3", "always", "this is param config-param-3")) + + +! negotiate +call plume_check(manager%initialise()) +call plume_check(manager%configure(trim(plume_config_path)//c_null_char)) +call plume_check(manager%negotiate(offers)) + +! fill in data +call plume_check(data%initialise()) + +! make space for new parameters in the data +call plume_check(data%create_int("I", 0) ) +call plume_check(data%create_int("J", 10) ) +call plume_check(data%create_int("K", 100) ) + +field = atlas_Field("field_dummy_1", atlas_integer(), (/0,10/)) +call plume_check( data%provide_atlas_field_shared("field_dummy_1", field) ) + +! Some more parameters that will be requested through the configuration +config_param_3 = atlas_Field("config-param-3", atlas_integer(), (/0,10/)) +call plume_check(data%provide_int("config-param-1", config_param_1) ) +call plume_check(data%provide_double("config-param-2", config_param_2) ) +call plume_check(data%provide_atlas_field_shared("config-param-3", config_param_3) ) + + +! pass data to the plugins +call plume_check(manager%feed_plugins(data)) + +! Run the model for 10 iterations +do iter=1,10 + + ! update the internal parameters + call plume_check(data%update_int("I", 0+iter) ) + call plume_check(data%update_int("J", 10+iter) ) + call plume_check(data%update_int("K", 100+iter) ) + + ! run the model.. + call plume_check(manager%run()) +enddo + +! finalise +call plume_check(data%finalise()) +call plume_check(manager%finalise()) +call plume_check(offers%finalise()) +call plume_check(plume_finalise()) + +write(*,*) "*** Example 3 complete. ***" +write(*,*) + +end program my_program \ No newline at end of file diff --git a/examples/example3.cc b/examples/example3.cc index 7b20972..268fe52 100644 --- a/examples/example3.cc +++ b/examples/example3.cc @@ -48,6 +48,12 @@ int main(int argc, char** argv) { offers.offerInt("J", "always", "this is param J"); offers.offerInt("K", "always", "this is param K"); offers.offerAtlasField("field_dummy_1", "always", "this is dummy_field"); + + offers.offerInt("config-param-1", "on-request", "this is param config-param-1"); + offers.offerDouble("config-param-2", "on-request", "this is param config-param-2"); + offers.offerAtlasField("config-param-3", "on-request", "this is param config-param-3"); + + // Negotiate with plugins plume::Manager::negotiate(offers); // data @@ -60,6 +66,16 @@ int main(int argc, char** argv) { data.createInt("K", 100); data.provideAtlasFieldShared("field_dummy_1", field.get()); + + // parameters requested by the plugins through configuration + int config_param_1 = 9; + double config_param_2 = 99.99; + atlas::Field config_param_3 = createAtlasField(); + + data.provideInt("config-param-1", &config_param_1); + data.provideDouble("config-param-2", &config_param_2); + data.provideAtlasFieldShared("config-param-3", config_param_3.get()); + // Feed plugins with the data plume::Manager::feedPlugins(data); diff --git a/examples/plugin_bar.cc b/examples/plugin_bar.cc index 32f0229..64d5f54 100644 --- a/examples/plugin_bar.cc +++ b/examples/plugin_bar.cc @@ -18,8 +18,6 @@ REGISTER_LIBRARY(PluginBar) PluginBar::PluginBar() : Plugin("PluginBar"){}; -PluginBar::~PluginBar(){}; - const PluginBar& PluginBar::instance() { static PluginBar instance; return instance; @@ -32,9 +30,21 @@ static plume::PluginCoreBuilder runnable_plugincore_BarBuilder_; PluginCoreBar::PluginCoreBar(const eckit::Configuration& conf) : PluginCore(conf) {} -PluginCoreBar::~PluginCoreBar() {} - void PluginCoreBar::run() { + + eckit::Log::info() << "Plugin Bar running..." << std::endl; + + eckit::Log::info() << " ---> data contains parameters: " << std::endl; + modelData().print(); + + + // list all available parameters of type "atlas_field" + eckit::Log::info() << " ---> data contains parameters of type 'atlas_field': " << std::endl; + for (const auto& key : modelData().listAvailableParameters("ATLAS_FIELD")) { + eckit::Log::info() << "Param: " << key << std::endl; + } + + eckit::Log::info() << "Plugin Bar consuming parameters: (" << "K=" << modelData().getInt("K") << ", " << "field=" << modelData().getAtlasFieldShared("field_dummy_1") << ") " diff --git a/examples/plugin_bar.h b/examples/plugin_bar.h index 11a664b..9101da7 100644 --- a/examples/plugin_bar.h +++ b/examples/plugin_bar.h @@ -22,7 +22,6 @@ namespace plugin_bar { class PluginCoreBar : public plume::PluginCore { public: PluginCoreBar(const eckit::Configuration& conf); - ~PluginCoreBar(); void run() override; constexpr static const char* type() { return "plugincore-bar"; } }; @@ -37,8 +36,6 @@ class PluginBar : public plume::Plugin { public: PluginBar(); - ~PluginBar(); - plume::Protocol negotiate() override { plume::Protocol protocol; protocol.requireInt("K"); diff --git a/examples/plugin_foo.cc b/examples/plugin_foo.cc index 0e8057d..a58181c 100644 --- a/examples/plugin_foo.cc +++ b/examples/plugin_foo.cc @@ -18,8 +18,6 @@ REGISTER_LIBRARY(PluginFoo) PluginFoo::PluginFoo() : Plugin("PluginFoo"){}; -PluginFoo::~PluginFoo(){}; - const PluginFoo& PluginFoo::instance() { static PluginFoo instance; return instance; @@ -32,9 +30,12 @@ static plume::PluginCoreBuilder runnable_plugincore_FooBuilder_; PluginCoreFoo::PluginCoreFoo(const eckit::Configuration& conf) : PluginCore(conf) {} -PluginCoreFoo::~PluginCoreFoo() {} - void PluginCoreFoo::run() { + + eckit::Log::info() << "Plugin Foo running..." << std::endl; + eckit::Log::info() << " ---> data contains parameters: " << std::endl; + modelData().print(); + eckit::Log::info() << "Plugin Foo consuming parameters: (" << "I=" << modelData().getInt("I") << ", " << "J=" << modelData().getInt("J") << ") " diff --git a/examples/plugin_foo.h b/examples/plugin_foo.h index e80553f..f0e150b 100644 --- a/examples/plugin_foo.h +++ b/examples/plugin_foo.h @@ -22,7 +22,6 @@ namespace plugin_foo { class PluginCoreFoo : public plume::PluginCore { public: PluginCoreFoo(const eckit::Configuration& conf); - ~PluginCoreFoo(); void run() override; constexpr static const char* type() { return "plugincore-foo"; } }; @@ -37,8 +36,6 @@ class PluginFoo : public plume::Plugin { public: PluginFoo(); - ~PluginFoo(); - plume::Protocol negotiate() override { plume::Protocol protocol; protocol.requireInt("I"); diff --git a/examples/plume_config.yml b/examples/plume_config.yml index 661e263..219b006 100644 --- a/examples/plume_config.yml +++ b/examples/plume_config.yml @@ -1,5 +1,4 @@ { - "required-atlas-version": "0.10.0", "verbose": true, "plugins": [ { @@ -8,8 +7,21 @@ }, { "name": "PluginBar", - "lib": "plugin_bar", - "plugincore-config": { + "lib": "plugin_bar", + "parameters": [ + [ + {"name": "config-param-1", "type": "int"}, + {"name": "config-param-2", "type": "double"}, + {"name": "config-param-3", "type": "atlas_field"}, + {"name": "config-param-4", "type": "atlas_field"}, + {"name": "config-param-5", "type": "atlas_field"} + ], + [ + {"name": "config-param-1", "type": "int"}, + {"name": "config-param-3", "type": "int"} + ] + ], + "core-config": { "exceptions-dump-trace": true, "key-2": "val-2", "key-3": "val-3" diff --git a/src/plume/CMakeLists.txt b/src/plume/CMakeLists.txt index 8140009..cadb777 100644 --- a/src/plume/CMakeLists.txt +++ b/src/plume/CMakeLists.txt @@ -23,6 +23,7 @@ install(FILES # #################### Plume plugin ###################### set(PLUGIN_FILES_H Plugin.h + Plugin_decision.h PluginHandler.h Protocol.h PluginCore.h @@ -71,10 +72,14 @@ ecbuild_add_library( set(PLUME_PLUGIN_MANAGER_SOURCES Manager.h Manager.cc + ManagerConfig.h + Negotiator.h + Negotiator.cc Protocol.h Protocol.cc Configurable.h Configurable.cc + PluginConfig.h data/ModelData.h data/ModelData.cc data/ParameterCatalogue.h diff --git a/src/plume/Configurable.cc b/src/plume/Configurable.cc index afa75f8..cd60fc1 100644 --- a/src/plume/Configurable.cc +++ b/src/plume/Configurable.cc @@ -23,10 +23,6 @@ Configurable::Configurable(const eckit::Configuration& config) : config_{config} } -Configurable::~Configurable() { -} - - const eckit::LocalConfiguration& Configurable::config() const { return config_; } @@ -40,47 +36,64 @@ std::ostream& operator<<(std::ostream& oss, const Configurable& obj) { -CheckedConfigurable::CheckedConfigurable(const eckit::Configuration& config, const std::vector essentialKeys, const eckit::Configuration& options) : Configurable{config} { - if (!isValid(config, essentialKeys, options)) { +CheckedConfigurable::CheckedConfigurable(const eckit::Configuration& config, + const std::unordered_set& essentialKeys, + const std::unordered_set& optionalKeys) : Configurable{config} { + + eckit::Log::debug() << "checking configuration: " << config << std::endl; + if (!isValid(config, essentialKeys, optionalKeys)) { throw eckit::BadValue("Data type configuration not valid!"); } } -CheckedConfigurable::~CheckedConfigurable() { +bool CheckedConfigurable::isValid(const eckit::Configuration& config, + const std::unordered_set& essentialKeys, + const std::unordered_set& optionalKeys) { + + // 1) check that the configuration contains all the essential keys + if (!CheckedConfigurable::hasEssentialKeys(config, essentialKeys)) { + return false; + } + + // 2) check that the configuration contains only valid keys (essential and/or optional) + if (!CheckedConfigurable::hasAllValidKeys(config, essentialKeys, optionalKeys)) { + return false; + } + + // checkd passed + return true; } -bool CheckedConfigurable::isValid(const eckit::Configuration& config, const std::vector essentialKeys, const eckit::Configuration& options) { - // 1) check that the configuration contains all the essential keys +// helper function to check for optional keys +bool CheckedConfigurable::hasEssentialKeys(const eckit::Configuration& config, + const std::unordered_set& essentialKeys) { for (const auto& key: essentialKeys) { if (!config.has(key)) { + eckit::Log::error() << "Missing essential key: " << key << std::endl; return false; } } + return true; +} - // 2) check that all the keys in configuration are valid - for (const auto& key: config.keys()) { - // Check if key is listed in the options - if (!options.has(key)) { +// helper function to check for optional keys +bool CheckedConfigurable::hasAllValidKeys(const eckit::Configuration& config, + const std::unordered_set& essentialKeys, + const std::unordered_set& optionalKeys) { + + for (const auto& key: config.keys()) { + if (essentialKeys.find(key) == essentialKeys.end() && optionalKeys.find(key) == optionalKeys.end()) { + eckit::Log::error() << "Invalid key: " << key << std::endl; return false; } - - // Check if the value is within acceptable options - std::string value = config.getString(key); - std::vector keyOptions = options.getStringVector(key); - - // an empty list of options, means all values allowed! - if (keyOptions.size() > 0) { - if (find(keyOptions.begin(), keyOptions.end(), value) == keyOptions.end()) { - return false; - } - } } return true; } + } // namespace plume diff --git a/src/plume/Configurable.h b/src/plume/Configurable.h index f3f3ab3..18c3fc5 100644 --- a/src/plume/Configurable.h +++ b/src/plume/Configurable.h @@ -8,9 +8,12 @@ * granted to it by virtue of its status as an intergovernmental organisation nor * does it submit to any jurisdiction. */ +#pragma once + #include #include -#include +#include + #include "eckit/config/LocalConfiguration.h" @@ -27,7 +30,7 @@ class Configurable { Configurable(const eckit::Configuration& config); - virtual ~Configurable(); + virtual ~Configurable() = default; const eckit::LocalConfiguration& config() const; @@ -49,10 +52,29 @@ class CheckedConfigurable : public Configurable { public: - CheckedConfigurable(const eckit::Configuration& config, const std::vector essentialKeys, const eckit::Configuration& options); - virtual ~CheckedConfigurable() ; + CheckedConfigurable(const eckit::Configuration& config, + const std::unordered_set& essentialKeys, + const std::unordered_set& optionalKeys = std::unordered_set{}); + + static bool isValid(const eckit::Configuration& config, + const std::unordered_set& essentialKeys, + const std::unordered_set& optionalKeys = std::unordered_set{}); + + bool has(const std::string& key) const { + return config().has(key); + } + +private: + + // function that checks for essential keys + static bool hasEssentialKeys(const eckit::Configuration& config, + const std::unordered_set& essentialKeys); + + // function that checks for optional keys + static bool hasAllValidKeys(const eckit::Configuration& config, + const std::unordered_set& essentialKeys, + const std::unordered_set& optionalKeys); - static bool isValid(const eckit::Configuration& config, const std::vector essentialKeys, const eckit::Configuration& options); }; } // namespace plume \ No newline at end of file diff --git a/src/plume/Manager.cc b/src/plume/Manager.cc index 9721e50..c2a993d 100644 --- a/src/plume/Manager.cc +++ b/src/plume/Manager.cc @@ -13,6 +13,7 @@ #include #include #include +#include #include "eckit/config/LocalConfiguration.h" #include "eckit/exception/Exceptions.h" @@ -23,12 +24,14 @@ #include "plume/plume.h" #include "plume/utils.h" #include "plume/PluginCore.h" +#include "plume/PluginConfig.h" #include "plume/PluginHandler.h" #include "plume/data/ParameterCatalogue.h" #include "plume/data/DataChecker.h" #include "plume/Protocol.h" #include "plume/Manager.h" +#include "plume/Negotiator.h" @@ -46,45 +49,38 @@ class PluginRegistry { return reg; } - ~PluginRegistry() { - // Destroy the active plugincores (i.e. plugincores built when the corresponding plugins were set as active) - for (plume::PluginHandler pluginHandle : PluginRegistry::instance().getActivePlugins()) { - - plume::PluginCore* plugincorePtr = pluginHandle.plugincore(); + ~PluginRegistry() {} - // Plugin is now disassociated - pluginHandle.deactivate(); - - // delete the plugincore - delete plugincorePtr; - - } - } - - void setActive(Plugin& plugin, const eckit::Configuration& config) { + void setActive(Plugin& plugin, const PluginConfig& pconfig, const std::vector& offeredParams) { std::string name = plugin.plugincoreName(); - eckit::LocalConfiguration plugincoreConfig = config.getSubConfiguration("core-config"); - plume::PluginCore* plugincorePtr = plume::PluginCoreFactory::instance().build(name, plugincoreConfig); - PluginHandler pluginHandle(&plugin); + // create a plugin handler + PluginHandler pluginHandle(plugin, pconfig, offeredParams); - pluginHandle.activate(plugincorePtr); + // instantiate the plugincore (the plugin handler takes ownership of it) + pluginHandle.activate( std::unique_ptr( plume::PluginCoreFactory::instance().build(name, pconfig.coreConfig()) ) ); // plugin added to the active plugin list - PluginRegistry::instance().pluginHandlers_.push_back(pluginHandle); + PluginRegistry::instance().pluginHandlers_.push_back(std::move(pluginHandle)); } // get the active Plugins - std::vector getActivePlugins() { return pluginHandlers_; } + std::vector& getActivePlugins() { return pluginHandlers_; } // Parameters requested by all active plugins collectively std::vector getActiveParams() { std::vector requiredParams; for (const auto& pluginHandle : pluginHandlers_) { - auto req_fields = pluginHandle.plugin()->negotiate().requiredParamNames(); - requiredParams.insert(requiredParams.end(), req_fields.begin(), req_fields.end()); + auto req_fields = pluginHandle.getRequiredParamNames(); + + // TODO: consider std::set + for (const auto& field : req_fields) { + if (std::find(requiredParams.begin(), requiredParams.end(), field) == requiredParams.end()) { + requiredParams.push_back(field); + } + } } return requiredParams; } @@ -113,19 +109,35 @@ class PluginRegistry { // ------------------------------------------------------------------- -eckit::LocalConfiguration Manager::config_{}; +ManagerConfig Manager::managerConfig_{}; + bool Manager::isConfigured_{false}; void Manager::configure(const eckit::Configuration& config) { if (!Manager::isConfigured_){ - eckit::LocalConfiguration tmp{config}; - config_ = tmp; + managerConfig_ = ManagerConfig(config); Manager::isConfigured_ = true; } } +// load a plugin from a shared library +Plugin& Manager::loadPlugin(const std::string& lib, const std::string& name) { + + void* libHandle = eckit::system::LibraryManager::loadLibrary(lib); + if (!libHandle) { + throw eckit::BadValue("Loading library " + lib + " failed!", Here()); + } + + eckit::Log::info() << "Loading Library: " << lib << " containing Plugin: " << name << std::endl; + + // here we are loading a Plume plugin + Plugin& plugin = dynamic_cast(eckit::system::LibraryManager::loadPlugin(name)); + + return plugin; +} + // Negotiate with all candidate plugins void Manager::negotiate(const Protocol& offers) { @@ -133,39 +145,42 @@ void Manager::negotiate(const Protocol& offers) { // before negotiation, make sure the manager has been configured ASSERT_MSG(isConfigured_, "Plume manager needs to be configured first!"); - eckit::Log::info() << "Plume config: " << config_ - << ", offers: " << offers.offeredParamNames() << std::endl; - - std::vector plugins = config_.getSubConfigurations("plugins"); + eckit::Log::info() << "Plume config: " << managerConfig_ << ", offers: " << offers.offeredParamNames() << std::endl; + // Negotiate with each plugin + Negotiator negotiator; + // Load all selected plugins as per configuration - for (const auto& conf : plugins) { + for (const auto& pconfig : managerConfig_.plugins()) { + + auto name = pconfig.name(); + auto lib = pconfig.lib(); - std::string name = conf.getString("name"); - std::string lib = conf.getString("lib"); + eckit::Log::info() << std::endl << " <== Evaluating Plugin: " << name << " from Library: " << lib << std::endl; - void* libHandle = eckit::system::LibraryManager::loadLibrary(lib); - if (!libHandle) { - throw eckit::BadValue("Loading library " + lib + " failed!", Here()); - } - - eckit::Log::info() << "Loading Library: " << lib << " containing Plugin: " << name << std::endl; - - // here we are loading a Plume plugin - Plugin& plugin = dynamic_cast(eckit::system::LibraryManager::loadPlugin(name)); + // Load the plugin + Plugin& plugin = loadPlugin(lib, name); - // Negotiate with each plugin + // check what each plugin requires Protocol requires = plugin.negotiate(); - if (decideOnPlugin(offers, requires)) { - eckit::Log::info() << " ==> Plugin manager has accepted plugin: " << plugin.name() << std::endl; - - // Evaluation of plugin successful => Plugin now set as active - PluginRegistry::instance().setActive(plugin, conf); + // Check plugin parameters requested through configuration (if any) + auto config_params = pconfig.parameters(); + if (config_params.size() > 0) { + eckit::Log::info() << "Parameters from Config: " << config_params << std::endl; + } else { + eckit::Log::info() << "No additional parameters found in Config." << std::endl; } - else { - eckit::Log::info() << " ==> Plugin manager has rejected plugin: " << plugin.name() << std::endl; + + // negotiator handles the negotiation + PluginDecision decision = negotiator.negotiate(offers, requires, config_params); + eckit::Log::info() << decision << std::endl; + + // If the plugin is accepted, set it as active + if (decision.accepted()) { + PluginRegistry::instance().setActive(plugin, pconfig, decision.offeredParams()); } + } PluginRegistry::instance().setDataCatalogue(offers.offers()); @@ -182,17 +197,14 @@ void Manager::feedPlugins(const data::ModelData& data) { for (auto& pluginHandler : PluginRegistry::instance().getActivePlugins()) { // get the share of run data needed to run the plugincore - auto requiredParams = pluginHandler.plugin()->negotiate().requiredParamNames(); + auto requiredParams = pluginHandler.getRequiredParamNames(); data::ModelData requiredData = data.filter(requiredParams); - // get the associated plugincore - plume::PluginCore* plugincore = pluginHandler.plugincore(); - - // grab data - plugincore->grabData(requiredData); + // grab data + pluginHandler.grabData(requiredData); // setup - plugincore->setup(); + pluginHandler.setup(); } } @@ -200,7 +212,7 @@ void Manager::feedPlugins(const data::ModelData& data) { // Run all active plugincores void Manager::run() { for (auto& pluginHandler : PluginRegistry::instance().getActivePlugins()) { - pluginHandler.plugincore()->run(); + pluginHandler.run(); } }; @@ -209,50 +221,8 @@ void Manager::run() { void Manager::teardown() { for (auto& pluginHandler : PluginRegistry::instance().getActivePlugins()) { // teardown the plugincore first - pluginHandler.plugincore()->teardown(); - } -}; - - -bool Manager::decideOnPlugin(const Protocol& offers, const Protocol& requires) { - - /// TODO: this negotiation should be done in a separate class - - eckit::Log::info() << "Requesting Plume Version: " << LibVersion(requires.requiredPlumeVersion()).asString() - << " VS Actual Plume version "<< plume_VERSION << std::endl; - - eckit::Log::info() << "Requesting Atlas Version: " << LibVersion(requires.requiredAtlasVersion()).asString() - << " VS Actual Atlas version "<< offers.offeredAtlasVersion() << std::endl; - - // Check Plume version - if (LibVersion(requires.requiredPlumeVersion()) > LibVersion( plume_VERSION )) { - return false; - } - - // Check Atlas version - if (LibVersion(requires.requiredAtlasVersion()) > LibVersion( offers.offeredAtlasVersion() )) { - return false; - } - - // Check requested parameters - eckit::Log::info() << "Requesting Parameters: ["; - for (int i = 0; i < requires.requiredParamNames().size(); i++) { - if (i) - eckit::Log::info() << ", "; - eckit::Log::info() << requires.requiredParamNames()[i]; - } - eckit::Log::info() << "]" << std::endl; - - for (const auto& f : requires.requiredParamNames()) { - - eckit::Log::info() << " - Considering Parameter: " << f << std::endl; - - if (!offers.isParamOffered(f)) { - eckit::Log::warning() << "Parameter " << f << " not found!" << std::endl; - return false; - } + pluginHandler.teardown(); } - return true; }; @@ -281,7 +251,6 @@ bool Manager::isConfigured() { } - void Manager::checkData(const data::ModelData& data) { eckit::Log::info() << "--- Plume manager is checking data ..." << std::endl; diff --git a/src/plume/Manager.h b/src/plume/Manager.h index 32ce679..de47af3 100644 --- a/src/plume/Manager.h +++ b/src/plume/Manager.h @@ -20,8 +20,10 @@ #include "eckit/system/LibraryManager.h" #include "plume/Plugin.h" +#include "plume/Plugin_decision.h" #include "plume/data/ParameterCatalogue.h" #include "plume/data/ModelData.h" +#include "plume/ManagerConfig.h" namespace plume { @@ -101,17 +103,17 @@ class Manager : public eckit::system::LibraryManager { static bool isParamRequested(const std::string& name); static bool isConfigured(); + private: /** - * @brief Make a decision on each plugins, to establish which ones will run + * @brief Load a plugin from a shared library * - * @param dataConfig - * @param protocol - * @return true - * @return false + * @param lib + * @param name + * @return Plugin& */ - static bool decideOnPlugin(const Protocol& offers, const Protocol& requires); + static Plugin& loadPlugin(const std::string& lib, const std::string& name); /** * @brief Check data before feeding plugins @@ -120,7 +122,8 @@ class Manager : public eckit::system::LibraryManager { */ static void checkData(const data::ModelData& data); - static eckit::LocalConfiguration config_; + static ManagerConfig managerConfig_; + static bool isConfigured_; }; diff --git a/src/plume/ManagerConfig.h b/src/plume/ManagerConfig.h new file mode 100644 index 0000000..bd65573 --- /dev/null +++ b/src/plume/ManagerConfig.h @@ -0,0 +1,74 @@ +/* + * (C) Copyright 2023- ECMWF. + * + * This software is licensed under the terms of the Apache Licence Version 2.0 + * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. + * + * In applying this licence, ECMWF does not waive the privileges and immunities + * granted to it by virtue of its status as an intergovernmental organisation nor + * does it submit to any jurisdiction. + */ + +#pragma once + +#include "Configurable.h" +#include "eckit/config/LocalConfiguration.h" +#include "eckit/config/YAMLConfiguration.h" + +#include "plume/PluginConfig.h" + +namespace plume { + +class ManagerConfig final : public CheckedConfigurable { + +public: + +ManagerConfig() : + CheckedConfigurable{eckit::YAMLConfiguration(std::string("{\"plugins\":[]}")), {"plugins"}, {"verbose"}} {} + +ManagerConfig(const eckit::Configuration& config) : + CheckedConfigurable{config, {"plugins"}, {"verbose"}} { + + // run specific checks + + // 1) in this case, we can check that each contained plugin has a valid configuration + if (this->config().has("plugins")) { + + // plugins must be a list + if (!this->config().isSubConfigurationList("plugins")) { + throw eckit::BadValue("ManagerConfig: plugins must be a list of configurations", Here()); + } + + // check each plugin configuration + for (const auto& pconfig : this->config().getSubConfigurations("plugins")) { + PluginConfig pc(pconfig); + } + + } +} + + +/** + * @brief get the plugins (configuration) + * + * @return std::vector + */ +std::vector plugins() const { + + std::vector pluginConfigs; + + // plugins key must be present at this point + ASSERT(config().has("plugins")); + + auto pconfigs = config().getSubConfigurations("plugins"); + + for (const auto& pconfig : pconfigs) { + pluginConfigs.push_back(PluginConfig(pconfig)); + } + + return pluginConfigs; +} + +}; + +} // namespace plume \ No newline at end of file diff --git a/src/plume/Negotiator.cc b/src/plume/Negotiator.cc new file mode 100644 index 0000000..8284144 --- /dev/null +++ b/src/plume/Negotiator.cc @@ -0,0 +1,100 @@ +/* + * (C) Copyright 2023- ECMWF. + * + * This software is licensed under the terms of the Apache Licence Version 2.0 + * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. + * + * In applying this licence, ECMWF does not waive the privileges and immunities + * granted to it by virtue of its status as an intergovernmental organisation nor + * does it submit to any jurisdiction. + */ + +#include + +#include "plume/Negotiator.h" +#include "plume/utils.h" +#include "plume/plume.h" + + namespace plume { + + +PluginDecision Negotiator::negotiate(const Protocol& offers, const Protocol& requires, const std::vector& config_params) { + + eckit::Log::info() << "Requesting Plume Version: " << LibVersion(requires.requiredPlumeVersion()).asString() + << " VS Actual Plume version "<< plume_VERSION << std::endl; + + eckit::Log::info() << "Requesting Atlas Version: " << LibVersion(requires.requiredAtlasVersion()).asString() + << " VS Actual Atlas version "<< offers.offeredAtlasVersion() << std::endl; + + // Check Plume version + if (LibVersion(requires.requiredPlumeVersion()) > LibVersion( plume_VERSION )) { + return PluginDecision{false}; + } + + // Check Atlas version + if (LibVersion(requires.requiredAtlasVersion()) > LibVersion( offers.offeredAtlasVersion() )) { + return PluginDecision{false}; + } + + std::set allRequestedParams; + std::vector requested_params = requires.requiredParamNames(); + + // 1) Check requested parameters (from the plugin) + // if ANY one of these parameters is not offered, the plugin is rejected + eckit::Log::info() << "Requesting Parameters: ["; + for (int i = 0; i < requested_params.size()-1; i++) { + eckit::Log::info() << requested_params[i] << ", "; + } + eckit::Log::info() << requested_params[requested_params.size()-1] << "]" << std::endl; + + for (const auto& param_name : requested_params) { + eckit::Log::info() << " - Considering Parameter: " << param_name << std::endl; + if (!offers.isParamOffered(param_name)) { + eckit::Log::warning() << "Parameter " << param_name << " not found!" << std::endl; + return PluginDecision{false}; + } + } + + if (!requested_params.empty()) { + allRequestedParams.insert(requested_params.begin(), requested_params.end()); + } + + // 2) Check requested parameters (from the configuration) + // Here we check "groups" of requested parameters. A plugin can run if ANY of the "groups" are satisfied + if (!config_params.empty()) { + + for (const auto& param_group : config_params) { + + eckit::Log::info() << "Considering Parameter Group..." << std::endl; + + const std::vector& params = param_group.getSubConfigurations(); + + // loop over parameters in the group and check if they are all offered + bool group_satisfied = std::all_of(params.begin(), params.end(), [&offers](const auto& param){ + std::string param_name = param.getString("name"); + eckit::Log::info() << " - Considering Parameter: " << param_name << std::endl; + if (!offers.isParamOffered(param_name)) { + eckit::Log::warning() << " ---> Configuration Parameter " << param_name << " not found! => Group rejected!" << std::endl; + return false; + } + return true; + }); + + // group is satisfied + if (group_satisfied) { + eckit::Log::info() << " ---> Parameter Group Accepted!" << std::endl; + + // add all parameters in the group to the set "allRequestedParams" + for (const auto& param : params) { + allRequestedParams.insert(param.getString("name")); + } + } + } + } + + return PluginDecision{true, std::vector(allRequestedParams.begin(), allRequestedParams.end())}; +}; + + + + } // namespace plume diff --git a/src/plume/Negotiator.h b/src/plume/Negotiator.h new file mode 100644 index 0000000..4bd7d60 --- /dev/null +++ b/src/plume/Negotiator.h @@ -0,0 +1,40 @@ +/* + * (C) Copyright 2023- ECMWF. + * + * This software is licensed under the terms of the Apache Licence Version 2.0 + * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. + * + * In applying this licence, ECMWF does not waive the privileges and immunities + * granted to it by virtue of its status as an intergovernmental organisation nor + * does it submit to any jurisdiction. + */ + +#pragma once + +#include "Protocol.h" +#include "Plugin_decision.h" +#include "eckit/config/LocalConfiguration.h" + + +namespace plume { + +class Negotiator { +public: + + virtual ~Negotiator() = default; + + /** + * @brief Negotiate with a plugin + * + * @param requires + * @param config_params + * @return PluginDecision + */ + PluginDecision negotiate(const Protocol& offers, + const Protocol& requires, + const std::vector& config_params = std::vector{}); + +}; + + +} // namespace plume \ No newline at end of file diff --git a/src/plume/Plugin.cc b/src/plume/Plugin.cc index f57b35e..0a0da87 100644 --- a/src/plume/Plugin.cc +++ b/src/plume/Plugin.cc @@ -17,8 +17,6 @@ Plugin::Plugin(const std::string& name, const std::string& libname) : eckit::sys eckit::Log::debug() << "Instantiating " << this->name() << std::endl; } -Plugin::~Plugin() { - eckit::Log::debug() << "Destroying " << name() << std::endl; -} +Plugin::~Plugin() {} } // namespace plume \ No newline at end of file diff --git a/src/plume/PluginConfig.h b/src/plume/PluginConfig.h new file mode 100644 index 0000000..f5aad11 --- /dev/null +++ b/src/plume/PluginConfig.h @@ -0,0 +1,78 @@ +/* + * (C) Copyright 2023- ECMWF. + * + * This software is licensed under the terms of the Apache Licence Version 2.0 + * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. + * + * In applying this licence, ECMWF does not waive the privileges and immunities + * granted to it by virtue of its status as an intergovernmental organisation nor + * does it submit to any jurisdiction. + */ + +#pragma once + +#include "Configurable.h" +#include "eckit/config/LocalConfiguration.h" + + +namespace plume { + +class PluginConfig : public CheckedConfigurable { + +public: + +PluginConfig(const eckit::Configuration& config) : + CheckedConfigurable{config, {"name", "lib"}, {"parameters", "core-config"}} { + + // 1) check that parameters is a list of configurations + if (this->config().has("parameters")) { + if (!this->config().isList("parameters")) { + throw eckit::BadValue("PluginConfig: parameters must be a list of configurations", Here()); + } + } + + } + +/** + * @brief get the name of the plugin + * + * @return std::string + */ +std::string name() const { + return config().getString("name"); +} + +/** + * @brief get the library name of the plugin + * + * @return std::string + */ +std::string lib() const { + return config().getString("lib"); +} + +/** + * @brief get the optional required parameters + * + * @return std::vector + */ +std::vector parameters() const { + std::vector config_params; + if (config().has("parameters")) { + config_params = config().getSubConfigurations("parameters"); + } + return config_params; +} + +/** + * @brief get the plugincore configuration + * + * @return eckit::LocalConfiguration + */ +eckit::LocalConfiguration coreConfig() const { + return config().getSubConfiguration("core-config"); +} + +}; + + } // namespace plume \ No newline at end of file diff --git a/src/plume/PluginHandler.cc b/src/plume/PluginHandler.cc index cdc7b95..dc5aa4e 100644 --- a/src/plume/PluginHandler.cc +++ b/src/plume/PluginHandler.cc @@ -12,40 +12,68 @@ namespace plume { -PluginHandler::PluginHandler(Plugin* plugin) : pluginPtr_{plugin} { + PluginHandler::PluginHandler(Plugin& plugin, const PluginConfig& config, const std::vector& offeredParams) : + pluginRef_{plugin}, config_{config}, offeredParams_{offeredParams} { } + PluginHandler::~PluginHandler() { } -void PluginHandler::activate(plume::PluginCore* plugincorePtr) { + +void PluginHandler::activate(std::unique_ptr plugincorePtr) { // plugincore ptr must not be null ASSERT(plugincorePtr); - // the plugin is not active and associated to a plugincore - plugincorePtr_ = plugincorePtr; + // the plugin is now active and associated to a plugincore + plugincorePtr_ = std::move(plugincorePtr); } + void PluginHandler::deactivate() { // disassociate from the plugincore - plugincorePtr_ = nullptr; + plugincorePtr_.reset(); } + bool PluginHandler::isActive() const { return (plugincorePtr_ != nullptr); } -PluginCore* PluginHandler::plugincore() const { - return plugincorePtr_; -} Plugin* PluginHandler::plugin() const { - return pluginPtr_; + return &pluginRef_.get(); +} + + +const std::vector& PluginHandler::getRequiredParamNames() const { + return offeredParams_; +} + + +void PluginHandler::grabData(const data::ModelData& data) { + plugincorePtr_->grabData(data); } + +void PluginHandler::setup() { + plugincorePtr_->setup(); +} + + +void PluginHandler::run() { + plugincorePtr_->run(); +} + + +void PluginHandler::teardown() { + plugincorePtr_->teardown(); +} + + } // namespace plume diff --git a/src/plume/PluginHandler.h b/src/plume/PluginHandler.h index 734fd9e..00bf279 100644 --- a/src/plume/PluginHandler.h +++ b/src/plume/PluginHandler.h @@ -10,8 +10,11 @@ */ #pragma once +#include + #include "plume/Plugin.h" #include "plume/PluginCore.h" +#include "plume/PluginConfig.h" namespace plume { @@ -24,10 +27,18 @@ class PluginHandler { public: - PluginHandler(Plugin* plugin); + PluginHandler(Plugin& plugin, const PluginConfig& config, const std::vector& offeredParams); ~PluginHandler(); + // Delete the copy constructor and assignment operator + PluginHandler(const PluginHandler&) = delete; + PluginHandler& operator=(const PluginHandler&) = delete; + + // Default move constructor and assignment operator + PluginHandler(PluginHandler&& other) = default; + PluginHandler& operator=(PluginHandler&& other) = default; + /** * @brief is Active * @@ -41,7 +52,7 @@ class PluginHandler { * * @param plugincorePtr */ - void activate(PluginCore* plugincorePtr); + void activate(std::unique_ptr plugincorePtr); /** * @brief deactivate the plugin @@ -50,27 +61,57 @@ class PluginHandler { void deactivate(); /** - * @brief Get the plugincore pointer + * @brief get the plugin pointer * - * @return plume::PluginCore* + * @return plume::Plugin* */ - plume::PluginCore* plugincore() const ; + Plugin* plugin() const ; + /** + * @brief Get the Active Param Names + * + * @return std::vector + */ + const std::vector& getRequiredParamNames() const; /** - * @brief get the plugin pointer + * @brief Forward data to the plugincore + * + * @param data + */ + void grabData(const data::ModelData& data); + + /** + * @brief setup the plugincore + * + */ + void setup(); + + /** + * @brief run the plugincore * - * @return plume::Plugin* */ - plume::Plugin* plugin() const ; + void run(); + + /** + * @brief teardown the plugincore + * + */ + void teardown(); private: - // internal Plugin ptr - Plugin* pluginPtr_; + // internal Plugin ref + std::reference_wrapper pluginRef_; + + // store the plugin configuration + PluginConfig config_; // internal PluginCore ptr - PluginCore* plugincorePtr_; + std::unique_ptr plugincorePtr_; + + // offered parameters + std::vector offeredParams_; }; } // namespace plume \ No newline at end of file diff --git a/src/plume/Plugin_decision.h b/src/plume/Plugin_decision.h new file mode 100644 index 0000000..7815446 --- /dev/null +++ b/src/plume/Plugin_decision.h @@ -0,0 +1,39 @@ +#pragma once + +#include +#include + +#include "eckit/config/LocalConfiguration.h" + +/** + * @brief Class that stores the decision on whether to accept or reject a plugin + * and it also keeps track of the parameters actually offered to the plugin + * + */ +class PluginDecision { + + public: + + PluginDecision(bool accepted, const std::vector& offeredParams = std::vector()) : + accepted_{accepted}, offeredParams_{offeredParams} {} + + bool accepted() const { return accepted_; } + + const std::vector& offeredParams() const { return offeredParams_; } + + // print decision + friend std::ostream& operator<<(std::ostream& os, const PluginDecision& decision) { + os << "PluginDecision: " << (decision.accepted_ ? "ACCEPTED" : "REJECTED") << std::endl; + os << "Agreed Parameters: ["; + for (int i = 0; i < decision.offeredParams_.size()-1; i++) { + os << decision.offeredParams_[i] << ", "; + } + os << decision.offeredParams_[decision.offeredParams_.size()-1] << "]" << std::endl; + return os; + } + + private: + bool accepted_; + std::vector offeredParams_; +}; + \ No newline at end of file diff --git a/src/plume/Protocol.cc b/src/plume/Protocol.cc index 0637439..7d59c26 100644 --- a/src/plume/Protocol.cc +++ b/src/plume/Protocol.cc @@ -29,8 +29,8 @@ Protocol::Protocol(const eckit::Configuration& config) { setParamsFromConfig(config); requestedPlumeVersion_ = config.getString("requestedPlumeVersion", "0.0.0"); requestedAtlasVersion_ = config.getString("requestedAtlasVersion", "0.0.0"); - offeredPlumeVersion_ = config.getString("offeredPlumeVersion", "0.0.0"); - offeredAtlasVersion_ = config.getString("offeredAtlasVersion", "0.0.0"); + offeredPlumeVersion_ = config.getString("offeredPlumeVersion", plume_VERSION); + offeredAtlasVersion_ = config.getString("offeredAtlasVersion", atlas::library::version()); } @@ -156,6 +156,11 @@ void Protocol::setParamsFromConfig(const eckit::Configuration& config) { offeredParams_.insertParam(p); } } + + // if it's neither requesting nor offering, then throw an error + if (!config.has("required") && !config.has("offered")) { + throw eckit::BadParameter("Protocol configuration must have either 'required' or 'offered' keys", Here()); + } } diff --git a/src/plume/data/ModelData.cc b/src/plume/data/ModelData.cc index 9c40e93..f8a79ae 100644 --- a/src/plume/data/ModelData.cc +++ b/src/plume/data/ModelData.cc @@ -209,6 +209,20 @@ void ModelData::print() const { } +std::vector ModelData::listAvailableParameters(std::string type_string) const { + ParameterType type = ParameterTypeConverter::fromString(type_string); + std::vector keys; + for (const auto& key : valueMap_) { + if (key.second->type() == type) { + keys.push_back(key.first); + } + } + return keys; +} + + + + // -------- private // All values available diff --git a/src/plume/data/ModelData.h b/src/plume/data/ModelData.h index 0494ee7..4efc12c 100644 --- a/src/plume/data/ModelData.h +++ b/src/plume/data/ModelData.h @@ -81,6 +81,9 @@ class ModelData { // check if a parameter is in the data bool hasParameter(const std::string& name, const ParameterType& type) const ; + // list available parameters of a certain type + std::vector listAvailableParameters(std::string type_string) const ; + void print() const; private: diff --git a/src/plume/data/Parameter.cc b/src/plume/data/Parameter.cc index 83f26b5..7073ddf 100644 --- a/src/plume/data/Parameter.cc +++ b/src/plume/data/Parameter.cc @@ -34,7 +34,7 @@ eckit::LocalConfiguration parameterOptions() { } -Parameter::Parameter(const eckit::Configuration& config) : CheckedConfigurable(config, std::vector{"name", "type"}, parameterOptions() ) { +Parameter::Parameter(const eckit::Configuration& config) : CheckedConfigurable(config, {"name", "type"}, {"available", "comment"} ) { // setup from config name_ = config.getString("name"); diff --git a/tests/core/CMakeLists.txt b/tests/core/CMakeLists.txt index 143af1f..015864d 100644 --- a/tests/core/CMakeLists.txt +++ b/tests/core/CMakeLists.txt @@ -73,3 +73,23 @@ ecbuild_add_test( TARGET plume_test_parameter LIBS plume_plugin_manager ) + +ecbuild_add_test( TARGET plume_test_negotiator + SOURCES test_negotiator.cc + LIBS + plume_plugin_manager +) + +ecbuild_add_test( TARGET plume_test_configs + SOURCES test_configs.cc + LIBS + plume_plugin_manager +) + + +ecbuild_add_test( TARGET plume_test_plugin_params + SOURCES test_plugin_params.cc + LIBS + plume_plugin_manager + eckit +) diff --git a/tests/core/simple_plugin.cc b/tests/core/simple_plugin.cc index a3dadc6..b82ab75 100644 --- a/tests/core/simple_plugin.cc +++ b/tests/core/simple_plugin.cc @@ -18,8 +18,6 @@ REGISTER_LIBRARY(SimplePlugin) SimplePlugin::SimplePlugin() : Plugin("SimplePlugin"){}; -SimplePlugin::~SimplePlugin(){}; - const SimplePlugin& SimplePlugin::instance() { static SimplePlugin instance; return instance; @@ -32,8 +30,6 @@ static plume::PluginCoreBuilder runnable_plugincore_FooBuilder SimplePluginCore::SimplePluginCore(const eckit::Configuration& conf) : PluginCore(conf) {} -SimplePluginCore::~SimplePluginCore() {} - void SimplePluginCore::run() { eckit::Log::info() << "Consuming parameters: (" << "I=" << modelData().getInt("I") << ", " diff --git a/tests/core/simple_plugin.h b/tests/core/simple_plugin.h index 931eb4d..7b22de2 100644 --- a/tests/core/simple_plugin.h +++ b/tests/core/simple_plugin.h @@ -19,7 +19,6 @@ namespace plume_example_plugin { class SimplePluginCore : public plume::PluginCore { public: SimplePluginCore(const eckit::Configuration& conf); - ~SimplePluginCore(); void run() override; constexpr static const char* type() { return "simple-plugincore"; } }; @@ -31,8 +30,6 @@ class SimplePlugin : public plume::Plugin { public: SimplePlugin(); - ~SimplePlugin(); - plume::Protocol negotiate() override { plume::Protocol protocol; protocol.requireInt("I"); diff --git a/tests/core/test_configs.cc b/tests/core/test_configs.cc new file mode 100644 index 0000000..49f2488 --- /dev/null +++ b/tests/core/test_configs.cc @@ -0,0 +1,130 @@ +/* + * (C) Copyright 2023- ECMWF. + * + * This software is licensed under the terms of the Apache Licence Version 2.0 + * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. + * + * In applying this licence, ECMWF does not waive the privileges and immunities + * granted to it by virtue of its status as an intergovernmental organisation nor + * does it submit to any jurisdiction. + */ +#include "eckit/testing/Test.h" +#include "eckit/config/YAMLConfiguration.h" + +#include "plume/ManagerConfig.h" +#include "plume/PluginConfig.h" + + +using namespace eckit::testing; + +namespace eckit { +namespace test { + +CASE("test_manager_configuration") { + + std::string mgr_configstr_valid = R"YAML({ + "plugins": [ + {"name": "simple_plugin", "lib": "libsimple_plugin", "parameters": [{"name": "param1", "type": "INT", "available": "always", "comment": "none"}]}, + {"name": "simple_plugin2", "lib": "libsimple_plugin2", "parameters": [{"name": "param2", "type": "INT", "available": "always", "comment": "none"}]} + ], + "verbose": true + })YAML"; + + eckit::YAMLConfiguration config(mgr_configstr_valid); + plume::ManagerConfig managerConfig(config); + + EXPECT_EQUAL(managerConfig.plugins().size(), 2); + + // test class PluginConfig + plume::PluginConfig pluginConfig(managerConfig.plugins()[0]); + + EXPECT_EQUAL(pluginConfig.name(), "simple_plugin"); + EXPECT_EQUAL(pluginConfig.lib(), "libsimple_plugin"); + EXPECT_EQUAL(pluginConfig.parameters().size(), 1); + +} + +CASE("test_manager_configuration_invalid") { + + std::string missing_plugins = R"YAML({ + "verbose": true + })YAML"; + + eckit::YAMLConfiguration config(missing_plugins); + + EXPECT_THROWS(plume::ManagerConfig managerConfig(config)); + +} + + +CASE("test_plugin_configuration") { + + std::string valid_config = R"YAML({ + "name": "simple_plugin", + "lib": "libsimple_plugin", + "parameters": [ + {"name": "param1", "type": "INT", "available": "always", "comment": "none"}, + {"name": "param2", "type": "INT", "available": "always", "comment": "none"} + ] + })YAML"; + + eckit::YAMLConfiguration config(valid_config); + plume::PluginConfig pluginConfig(config); + + EXPECT_EQUAL(pluginConfig.name(), "simple_plugin"); + EXPECT_EQUAL(pluginConfig.lib(), "libsimple_plugin"); + EXPECT_EQUAL(pluginConfig.parameters().size(), 2); + + + // check parameters one by one + std::vector params = pluginConfig.parameters(); + EXPECT_EQUAL(params[0].getString("name"), "param1"); + EXPECT_EQUAL(params[0].getString("type"), "INT"); + EXPECT_EQUAL(params[0].getString("available"), "always"); + EXPECT_EQUAL(params[0].getString("comment"), "none"); + + EXPECT_EQUAL(params[1].getString("name"), "param2"); + EXPECT_EQUAL(params[1].getString("type"), "INT"); + EXPECT_EQUAL(params[1].getString("available"), "always"); + EXPECT_EQUAL(params[1].getString("comment"), "none"); + + +} + + +CASE("test_plugin_configuration_invalid") { + + std::string missing_name = R"YAML({ + "lib": "libsimple_plugin", + "parameters": [ + {"name": "param1", "type": "INT", "available": "always", "comment": "none"}, + {"name": "param2", "type": "INT", "available": "always", "comment": "none"} + ] + })YAML"; + + eckit::YAMLConfiguration config(missing_name); + EXPECT_THROWS(plume::PluginConfig pluginConfig(config)); + + + // missing lib + std::string missing_lib = R"YAML({ + "name": "simple_plugin", + "parameters": [ + {"name": "param1", "type": "INT", "available": "always", "comment": "none"}, + {"name": "param2", "type": "INT", "available": "always", "comment": "none"} + ] + })YAML"; + + eckit::YAMLConfiguration config2(missing_lib); + EXPECT_THROWS(plume::PluginConfig pluginConfig2(config2)); + +} + +//---------------------------------------------------------------------------------------------------------------------- + +} // namespace test +} // namespace eckit + +int main(int argc, char** argv) { + return run_tests(argc, argv); +} \ No newline at end of file diff --git a/tests/core/test_manager.cc b/tests/core/test_manager.cc index 0c37886..6e1495d 100644 --- a/tests/core/test_manager.cc +++ b/tests/core/test_manager.cc @@ -20,10 +20,36 @@ using namespace eckit::testing; namespace eckit { namespace test { -CASE("test manager 1") { + + +CASE("test_invalid_manager_configuration") { + + // missing plugins + std::string mgr_conf_str_plugins_missing = R"YAML({})YAML"; + eckit::YAMLConfiguration mgr_cfg_plugins_missing(mgr_conf_str_plugins_missing); + + // protocol from config + std::string data_conf_str = R"YAML({ + "offered": [ + {"name":"I", "type":"INT", "available": "always", "comment":"none-1"}, + {"name":"J", "type":"INT", "available": "always", "comment":"none-2"}, + {"name":"K", "type":"INT", "available": "always", "comment":"none-3"}] + })YAML"; + + eckit::YAMLConfiguration data_cfg(data_conf_str); + + // configure + EXPECT_THROWS(plume::Manager::configure(mgr_cfg_plugins_missing)); + EXPECT_EQUAL(plume::Manager::isConfigured(), false); + +} + + + +CASE("test_valid_manager_configiuration") { // simple plugin loaded - std::string mgr_conf_str = R"YAML({"plugins": [{"lib": "simple_plugin", "name": "SimplePlugin"}]})YAML"; + std::string mgr_conf_str = R"YAML({"plugins": [{"lib": "simple_plugin", "name": "SimplePlugin", "core-config": {}}]})YAML"; eckit::YAMLConfiguration mgr_cfg(mgr_conf_str); // protocol from config @@ -37,6 +63,7 @@ CASE("test manager 1") { // configure plume::Manager::configure(mgr_cfg); + EXPECT_EQUAL(plume::Manager::isConfigured(), true); // negotiate plume::Manager::negotiate(data_cfg); diff --git a/tests/core/test_negotiator.cc b/tests/core/test_negotiator.cc new file mode 100644 index 0000000..934d174 --- /dev/null +++ b/tests/core/test_negotiator.cc @@ -0,0 +1,80 @@ +/* + * (C) Copyright 2023- ECMWF. + * + * This software is licensed under the terms of the Apache Licence Version 2.0 + * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. + * + * In applying this licence, ECMWF does not waive the privileges and immunities + * granted to it by virtue of its status as an intergovernmental organisation nor + * does it submit to any jurisdiction. + */ +#include "eckit/testing/Test.h" +#include "eckit/config/YAMLConfiguration.h" + + +#include "plume/Negotiator.h" +#include "plume/data/ParameterCatalogue.h" + + +using namespace eckit::testing; +using namespace plume; + +namespace eckit { +namespace test { + +CASE("test_negotiator ") { + + Negotiator negotiator; + + std::string offers_str = R"YAML({ + "offered": [ + {"name":"I", "type":"INT", "available": "always", "comment":"none-1"}, + {"name":"J", "type":"INT", "available": "always", "comment":"none-2"}, + {"name":"K", "type":"INT", "available": "always", "comment":"none-3"}] + })YAML"; + + std::string requires_str = R"YAML({ + "required": [ + {"name":"I", "type":"INT", "available": "always", "comment":"none-1"}, + {"name":"J", "type":"INT", "available": "always", "comment":"none-2"}, + {"name":"K", "type":"INT", "available": "always", "comment":"none-3"}] + })YAML"; + + std::string requires_not_fullfilled_str = R"YAML({ + "required": [ + {"name":"I", "type":"INT", "available": "always", "comment":"none-1"}, + {"name":"J", "type":"INT", "available": "always", "comment":"none-2"}, + {"name":"K", "type":"INT", "available": "always", "comment":"none-3"}, + {"name":"K_new", "type":"INT", "available": "always", "comment":"none-3"}, + {"name":"K_new2", "type":"INT", "available": "always", "comment":"none-3"}] + })YAML"; + + std::string requires_invalid_str = R"YAML({ + "required_invalid_key": [ + {"name":"I", "type":"INT", "available": "always", "comment":"none-1"}, + {"name":"J", "type":"INT", "available": "always", "comment":"none-2"}, + {"name":"K", "type":"INT", "available": "always", "comment":"none-3"}] + })YAML"; + + // negotiate + PluginDecision decision = negotiator.negotiate(eckit::YAMLConfiguration(offers_str), eckit::YAMLConfiguration(requires_str)); + EXPECT_EQUAL(decision.accepted(), true); + + // requests not fullfilled + PluginDecision decision_not_fullfilled = negotiator.negotiate(eckit::YAMLConfiguration(offers_str), eckit::YAMLConfiguration(requires_not_fullfilled_str)); + EXPECT_EQUAL(decision_not_fullfilled.accepted(), false); + + // invalid key + EXPECT_THROWS(negotiator.negotiate(eckit::YAMLConfiguration(offers_str), eckit::YAMLConfiguration(requires_invalid_str))); + +} + + +//---------------------------------------------------------------------------------------------------------------------- + +} // namespace test +} // namespace eckit + +int main(int argc, char** argv) { + return run_tests(argc, argv); +} \ No newline at end of file diff --git a/tests/core/test_parameter.cc b/tests/core/test_parameter.cc index 9c9acc3..a5f7d13 100644 --- a/tests/core/test_parameter.cc +++ b/tests/core/test_parameter.cc @@ -21,13 +21,13 @@ namespace test { CASE("test parameter") { // valid - const char* valid_config = R"YAML({"name": "lat", "type": "ATLAS_FIELD", "available": "on-request", "comment": "none"})YAML"; + std::string valid_config = R"YAML({"name": "lat", "type": "ATLAS_FIELD", "available": "on-request", "comment": "none"})YAML"; // invalid - const char* missing_name = R"YAML({"type": "ATLAS_FIELD", "available": "on-request", "comment": "none"})YAML"; - const char* missing_type = R"YAML({"name": "lat", "available": "on-request", "comment": "none"})YAML"; - const char* missing_avail = R"YAML({"name": "lat", "type": "ATLAS_FIELD", "comment": "none"})YAML"; - const char* missing_comment = R"YAML({"name": "lat", "type": "ATLAS_FIELD", "available": "on-request"})YAML"; + std::string missing_name = R"YAML({"type": "ATLAS_FIELD", "available": "on-request", "comment": "none"})YAML"; + std::string missing_type = R"YAML({"name": "lat", "available": "on-request", "comment": "none"})YAML"; + std::string missing_avail = R"YAML({"name": "lat", "type": "ATLAS_FIELD", "comment": "none"})YAML"; + std::string missing_comment = R"YAML({"name": "lat", "type": "ATLAS_FIELD", "available": "on-request"})YAML"; eckit::YAMLConfiguration config(valid_config); diff --git a/tests/core/test_plugin_params.cc b/tests/core/test_plugin_params.cc new file mode 100644 index 0000000..7a5a6b9 --- /dev/null +++ b/tests/core/test_plugin_params.cc @@ -0,0 +1,114 @@ +/* + * (C) Copyright 2023- ECMWF. + * + * This software is licensed under the terms of the Apache Licence Version 2.0 + * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. + * + * In applying this licence, ECMWF does not waive the privileges and immunities + * granted to it by virtue of its status as an intergovernmental organisation nor + * does it submit to any jurisdiction. + */ +#include "eckit/testing/Test.h" +#include "eckit/config/YAMLConfiguration.h" + +#include "plume/Manager.h" +#include "plume/data/ParameterCatalogue.h" + + +using namespace eckit::testing; + +namespace eckit { +namespace test { + + + +CASE("test_invalid_plugin_configuration_parameters") { + + // invalid yaml + std::string mgr_conf_str = R"YAML({"plugins": [{"lib": "simple_plugin", "name": "SimplePlugin", "parameters": 999 "core-config": {}}]})YAML"; + EXPECT_THROWS(eckit::YAMLConfiguration mgr_cfg_invalid_json(mgr_conf_str)); + + // wrong "parameters" type + std::string mgr_conf_str2 = R"YAML({"plugins": [{"lib": "simple_plugin", "name": "SimplePlugin", "parameters": 999, "core-config": {}}]})YAML"; + eckit::YAMLConfiguration mgr_cfg_invalid_param_type(mgr_conf_str2); + + // protocol from config + std::string data_conf_str = R"YAML({ + "offered": [ + {"name":"I", "type":"INT", "available": "always", "comment":"none-1"}, + {"name":"J", "type":"INT", "available": "always", "comment":"none-2"}, + {"name":"K", "type":"INT", "available": "always", "comment":"none-3"}] + })YAML"; + + eckit::YAMLConfiguration data_cfg(data_conf_str); + + // configure + EXPECT_EQUAL(plume::Manager::isConfigured(), false); + EXPECT_THROWS(plume::Manager::configure(mgr_cfg_invalid_param_type)); + EXPECT_EQUAL(plume::Manager::isConfigured(), false); + +} + + +CASE("test_valid_plugin_configuration_parameters") { + + // invalid yaml + std::string mgr_conf_str = R"YAML({"plugins": [ + { + "lib": "simple_plugin", + "name": "SimplePlugin", + "parameters": [ + [{"name":"I", "type":"INT"}, {"name":"J", "type":"INT"}], + [{"name":"JJJ", "type":"INT"}, {"name":"J", "type":"INT"}, {"name":"KKMM", "type":"INT"}], + [{"name":"XYZ", "type":"INT"}, {"name":"K", "type":"INT"}] + ], + "core-config": {} + } + ] + })YAML"; + + eckit::YAMLConfiguration mgr_cfg_valid_json(mgr_conf_str); + + // protocol from config + std::string data_conf_str = R"YAML({ + "offered": [ + {"name":"I", "type":"INT", "available": "always", "comment":"none-1"}, + {"name":"J", "type":"INT", "available": "always", "comment":"none-1"}, + {"name":"JJJ", "type":"INT", "available": "always", "comment":"none-2"}, + {"name":"XYZ", "type":"INT", "available": "always", "comment":"none-2"}, + {"name":"K", "type":"INT", "available": "always", "comment":"none-3"}] + })YAML"; + + eckit::YAMLConfiguration data_cfg(data_conf_str); + + // configure + EXPECT_EQUAL(plume::Manager::isConfigured(), false); + + // valid configuration + plume::Manager::configure(mgr_cfg_valid_json); + + // should be validly initialised + EXPECT_EQUAL(plume::Manager::isConfigured(), true); + + + // negotiate + plume::Manager::negotiate(data_cfg); + + // still configured + EXPECT_EQUAL(plume::Manager::isConfigured(), true); + + // expected to be active parame: I, J, XYZ, K + EXPECT_EQUAL(plume::Manager::getActiveParams().size(), 4); + +} + + + +//---------------------------------------------------------------------------------------------------------------------- + +} // namespace test +} // namespace eckit + +int main(int argc, char** argv) { + return run_tests(argc, argv); +} \ No newline at end of file diff --git a/tests/core/test_protocol.cc b/tests/core/test_protocol.cc index b5fd4bb..bea4265 100644 --- a/tests/core/test_protocol.cc +++ b/tests/core/test_protocol.cc @@ -20,7 +20,7 @@ namespace test { CASE("test protocol - required params") { - const char* text = R"YAML( + std::string text = R"YAML( --- required: - name: param-1 @@ -67,7 +67,7 @@ CASE("test protocol - required params") { CASE("test protocol - offered params") { - const char* text = R"YAML( + std::string text = R"YAML( --- offered: - name: param-1