diff --git a/src/lib/orderman/orderman_utils/orderman_utils.cpp b/src/lib/orderman/orderman_utils/orderman_utils.cpp index 2baa124cb..866fa877e 100644 --- a/src/lib/orderman/orderman_utils/orderman_utils.cpp +++ b/src/lib/orderman/orderman_utils/orderman_utils.cpp @@ -159,7 +159,7 @@ api::orderman::DynamicOrderParamDescriptor param_array(const std::string& name, api::orderman::DynamicOrderParamDescriptor doap; doap.set_param_name(name); doap.mutable_param_type()->mutable_array()->mutable_element_type()->CopyFrom(entry); - return {}; + return doap; } api::orderman::DynamicOrderParamDescriptor param_struct(const std::string& name, const std::vector& entries) { api::orderman::DynamicOrderParamDescriptor doap; @@ -168,7 +168,7 @@ api::orderman::DynamicOrderParamDescriptor param_struct(const std::string& name, for (const auto& field : entries) { *dstruct.add_field() = field; } - return {}; + return doap; } } // namespace orderman diff --git a/src/lib/plugin/SparkServices.cpp b/src/lib/plugin/SparkServices.cpp index b3c74fae3..6d75d7959 100644 --- a/src/lib/plugin/SparkServices.cpp +++ b/src/lib/plugin/SparkServices.cpp @@ -1,5 +1,6 @@ #include "SparkServices.h" #include "lib/orderman/order_factory/DynamicOrderRegistry.h" +#include "lib/logging/logging.h" namespace bts { @@ -21,10 +22,67 @@ void SparkServices::register_dynamic_order( me->dyn_order_registry.register_dynamic_order(desc, builder); } -void SparkServices::register_dynamic_algo_order( +bool validate_param(const api::orderman::DynamicOrderParamDescriptor& param); +bool validate_type(const std::string name, const api::orderman::DynamicOrderTypeDescriptor& type) { + switch(type.descriptor_case()) { + case api::orderman::DynamicOrderTypeDescriptor::DescriptorCase::kPrimitive: break; + case api::orderman::DynamicOrderTypeDescriptor::DescriptorCase::kArray: + if (!type.array().has_element_type()) { + LOG(OrderMan, Error, "Array parameter {} missing element type", name); + return false; + } + if (!validate_type(name + "::array", type.array().element_type())) return false; + break; + case api::orderman::DynamicOrderTypeDescriptor::DescriptorCase::kStructure: + for(const auto& field : type.structure().field()) { + if (!validate_param(field)) return false; + } + break; + case api::orderman::DynamicOrderTypeDescriptor::DescriptorCase::kEnumerated: + if (type.enumerated().element_size() == 0) { + LOG(OrderMan, Error, "Enumerated parameter {} missing options list", name); + return false; + } + case api::orderman::DynamicOrderTypeDescriptor::DescriptorCase::DESCRIPTOR_NOT_SET: + break; + } + return true; +} +bool validate_param(const api::orderman::DynamicOrderParamDescriptor& param) { + if (param.param_name().empty()) { + LOG(OrderMan, Error, "Parameter missing param_name"); + return false; + } + if (!param.has_param_type()) { + LOG(OrderMan, Error, "Parameter {} missing type", param.param_name()); + return false; + } + return validate_type(param.param_name(), param.param_type()); + return true; +} + +bool validate_descriptor(const api::orderman::DynamicOrderDescriptor& desc) { + if (desc.dynamic_order_type().empty()) { + LOG(OrderMan, Error, "Algo missing 'dynamic_order_type'"); + return false; + } + for (const auto& param : desc.param_desc()) { + if (!validate_param(param)) { + return false; + } + } + return true; +} + +AlgoRegistrationResult SparkServices::register_dynamic_algo_order( api::orderman::DynamicOrderDescriptor const &desc, std::function()> const &builder) { - me->dyn_order_registry.register_dynamic_algo_order(desc, builder); + + if (validate_descriptor(desc)) { + me->dyn_order_registry.register_dynamic_algo_order(desc, builder); + return AlgoRegistrationResult::SUCCESS; + } + return AlgoRegistrationResult::ERROR; } extern "C" void initialize_spark_plugin(SparkServices &) {} diff --git a/src/lib/plugin/SparkServices.h b/src/lib/plugin/SparkServices.h index 70de0c9cf..d4ef29221 100644 --- a/src/lib/plugin/SparkServices.h +++ b/src/lib/plugin/SparkServices.h @@ -13,6 +13,11 @@ class IAlgoOrder; class DynamicOrderRegistry; } // namespace orderman +enum class AlgoRegistrationResult { + SUCCESS, + ERROR +}; + class SparkServices { public: SparkServices(orderman::DynamicOrderRegistry &); @@ -22,7 +27,7 @@ class SparkServices { api::orderman::DynamicOrderDescriptor const &desc, std::function()> const &builder); - void register_dynamic_algo_order( + AlgoRegistrationResult register_dynamic_algo_order( api::orderman::DynamicOrderDescriptor const &desc, std::function()> const &builder); private: diff --git a/src/sdk/examples/order_plugin_example.cpp b/src/sdk/examples/order_plugin_example.cpp index 69a715c5c..4f62067e1 100644 --- a/src/sdk/examples/order_plugin_example.cpp +++ b/src/sdk/examples/order_plugin_example.cpp @@ -324,8 +324,14 @@ extern "C" void init_spark_plugin(bts::SparkServices &serv) { // Associate the descriptor with a builder function and register // that with the Spark server. - serv.register_dynamic_algo_order( + auto result = + serv.register_dynamic_algo_order( join_desc, []() { return std::make_unique(); }); + + if (result != bts::AlgoRegistrationResult::SUCCESS) { + // The join_desc has errors + // Check the error log for more details + } } } // namespace order_example