Fix #782: Change hard-coded limitations in API's to configurable

libraries/app/api.cpp

@@ -101,7 +101,7 @@ namespace graphene { namespace app {
        }
        else if( api_name == "asset_api" )
        {
-          _asset_api = std::make_shared< asset_api >( std::ref( *_app.chain_database() ) );
+          _asset_api = std::make_shared< asset_api >( std::ref( _app ) );
        }
        else if( api_name == "orders_api" )
        {
@@ -316,7 +316,8 @@ namespace graphene { namespace app {
     {
        FC_ASSERT( _app.chain_database() );
        const auto& db = *_app.chain_database();
-       FC_ASSERT( limit <= 100 );
+       uint64_t api_limit_get_account_history=_app.get_options().api_limit_get_account_history;
+       FC_ASSERT( limit <= api_limit_get_account_history );
        vector<operation_history_object> result;
        account_id_type account;
        try {
@@ -352,7 +353,8 @@ namespace graphene { namespace app {
     {
        FC_ASSERT( _app.chain_database() );
        const auto& db = *_app.chain_database();
-       FC_ASSERT( limit <= 100 );
+       uint64_t api_limit_get_account_history_operations=_app.get_options().api_limit_get_account_history_operations;
+       FC_ASSERT(limit <= api_limit_get_account_history_operations);
        vector<operation_history_object> result;
        account_id_type account;
        try {
@@ -391,7 +393,8 @@ namespace graphene { namespace app {
     {
        FC_ASSERT( _app.chain_database() );
        const auto& db = *_app.chain_database();
-       FC_ASSERT(limit <= 100);
+       uint64_t api_limit_get_relative_account_history=_app.get_options().api_limit_get_relative_account_history;
+       FC_ASSERT(limit <= api_limit_get_relative_account_history);
        vector<operation_history_object> result;
        account_id_type account;
        try {
@@ -430,7 +433,8 @@ namespace graphene { namespace app {
 
     history_operation_detail history_api::get_account_history_by_operations(const std::string account_id_or_name, vector<uint16_t> operation_types, uint32_t start, unsigned limit)
     {
-       FC_ASSERT(limit <= 100);
+       uint64_t api_limit_get_account_history_by_operations=_app.get_options().api_limit_get_account_history_by_operations;
+       FC_ASSERT(limit <= api_limit_get_account_history_by_operations);
        history_operation_detail result;
        vector<operation_history_object> objs = get_relative_account_history(account_id_or_name, start, limit, limit + start - 1);
        std::for_each(objs.begin(), objs.end(), [&](const operation_history_object &o) {
@@ -526,13 +530,14 @@ namespace graphene { namespace app {
     }
 
     // asset_api
-    asset_api::asset_api(graphene::chain::database& db) : _db(db) { }
-    asset_api::~asset_api() { }
-
     vector<account_asset_balance> asset_api::get_asset_holders( asset_id_type asset_id, uint32_t start, uint32_t limit ) const {
-      FC_ASSERT(limit <= 100);
 
-      const auto& bal_idx = _db.get_index_type< account_balance_index >().indices().get< by_asset_balance >();
+      FC_ASSERT( _app.chain_database() );
+      const auto& db = *_app.chain_database();
+      uint64_t api_limit_get_asset_holders=_app.get_options().api_limit_get_asset_holders;
+
+      FC_ASSERT(limit <= api_limit_get_asset_holders);
+      const auto& bal_idx = db.get_index_type< account_balance_index >().indices().get< by_asset_balance >();
       auto range = bal_idx.equal_range( boost::make_tuple( asset_id ) );
 
       vector<account_asset_balance> result;
@@ -549,7 +554,7 @@ namespace graphene { namespace app {
         if( index++ < start )
             continue;
 
-        const auto account = _db.find(bal.owner);
+        const auto account = db.find(bal.owner);
 
         account_asset_balance aab;
         aab.name       = account->name;
@@ -563,8 +568,9 @@ namespace graphene { namespace app {
     }
     // get number of asset holders.
     int asset_api::get_asset_holders_count( asset_id_type asset_id ) const {
-
-      const auto& bal_idx = _db.get_index_type< account_balance_index >().indices().get< by_asset_balance >();
+      FC_ASSERT( _app.chain_database() );
+      const auto& db = *_app.chain_database();
+      const auto& bal_idx = db.get_index_type< account_balance_index >().indices().get< by_asset_balance >();
       auto range = bal_idx.equal_range( boost::make_tuple( asset_id ) );
 
       int count = boost::distance(range) - 1;
@@ -573,18 +579,19 @@ namespace graphene { namespace app {
     }
     // function to get vector of system assets with holders count.
     vector<asset_holders> asset_api::get_all_asset_holders() const {
-
+      FC_ASSERT( _app.chain_database() );
+      const auto& db = *_app.chain_database();
       vector<asset_holders> result;
 
       vector<asset_id_type> total_assets;
-      for( const asset_object& asset_obj : _db.get_index_type<asset_index>().indices() )
+      for( const asset_object& asset_obj : db.get_index_type<asset_index>().indices() )
       {
-        const auto& dasset_obj = asset_obj.dynamic_asset_data_id(_db);
+        const auto& dasset_obj = asset_obj.dynamic_asset_data_id(db);
 
         asset_id_type asset_id;
         asset_id = dasset_obj.id;
 
-        const auto& bal_idx = _db.get_index_type< account_balance_index >().indices().get< by_asset_balance >();
+        const auto& bal_idx = db.get_index_type< account_balance_index >().indices().get< by_asset_balance >();
         auto range = bal_idx.equal_range( boost::make_tuple( asset_id ) );
 
         int count = boost::distance(range) - 1;
@@ -613,7 +620,8 @@ namespace graphene { namespace app {
                                                                optional<price> start,
                                                                uint32_t limit )const
    {
-      FC_ASSERT( limit <= 101 );
+      uint64_t api_limit_get_grouped_limit_orders=_app.get_options().api_limit_get_grouped_limit_orders;
+      FC_ASSERT( limit <= api_limit_get_grouped_limit_orders );
       auto plugin = _app.get_plugin<grouped_orders_plugin>( "grouped_orders" );
       FC_ASSERT( plugin );
       const auto& limit_groups = plugin->limit_order_groups();

libraries/app/application.cpp

@@ -318,6 +318,29 @@ void application_impl::set_dbg_init_key( graphene::chain::genesis_state_type& ge
       genesis.initial_witness_candidates[i].block_signing_key = init_pubkey;
 }
 
+
+void application_impl::set_dgb_api_limit_api() {
+   if (_options->count("api-limit-get-account-history-operations")) {
+      _app_options.api_limit_get_account_history_operations = _options->at("api-limit-get-account-history-operations").as<uint64_t>();
+   }
+   if(_options->count("api-limit-get-account-history")){
+      _app_options.api_limit_get_account_history = _options->at("api-limit-get-account-history").as<uint64_t>();
+   }
+   if(_options->count("api-limit-get-grouped-limit-orders")){
+      _app_options.api_limit_get_grouped_limit_orders = _options->at("api-limit-get-grouped-limit-orders").as<uint64_t>();
+   }
+   if(_options->count("api-limit-get-relative-account-history")){
+       _app_options.api_limit_get_relative_account_history = _options->at("api-limit-get-relative-account-history").as<uint64_t>();
+   }
+   if(_options->count("api-limit-get-account-history-by-operations")){
+       _app_options.api_limit_get_account_history_by_operations = _options->at("api-limit-get-account-history-by-operations").as<uint64_t>();
+   }
+   if(_options->count("api-limit-get-asset-holders")){
+       _app_options.api_limit_get_asset_holders = _options->at("api-limit-get-asset-holders").as<uint64_t>();
+   }
+
+}
+
 void application_impl::startup()
 { try {
    fc::create_directories(_data_dir / "blockchain");
@@ -439,6 +462,8 @@ void application_impl::startup()
    if ( _options->count("enable-subscribe-to-all") )
       _app_options.enable_subscribe_to_all = _options->at( "enable-subscribe-to-all" ).as<bool>();
 
+   set_dgb_api_limit_api();
+
    if( _active_plugins.find( "market_history" ) != _active_plugins.end() )
       _app_options.has_market_history_plugin = true;
 
@@ -982,6 +1007,18 @@ void application::set_program_options(boost::program_options::options_descriptio
          ("enable-standby-votes-tracking", bpo::value<bool>()->implicit_value(true),
           "Whether to enable tracking of votes of standby witnesses and committee members. "
           "Set it to true to provide accurate data to API clients, set to false for slightly better performance.")
+         ("api-limit-get-account-history-operations",boost::program_options::value<uint64_t>()->default_value(100),
+          "For history_api::get_account_history_operations to set its default limit value as 100")
+         ("api-limit-get-account-history",boost::program_options::value<uint64_t>()->default_value(100),
+          "For history_api::get_account_history to set its default limit value as 100")
+         ("api-limit-get-grouped-limit-orders",boost::program_options::value<uint64_t>()->default_value(101),
+          "For orders_api::get_grouped_limit_orders to set its default limit value as 101")
+         ("api-limit-get-relative-account-history",boost::program_options::value<uint64_t>()->default_value(100),
+          "For history_api::get_relative_account_history to set its default limit value as 100")
+         ("api-limit-get-account-history-by-operations",boost::program_options::value<uint64_t>()->default_value(100),
+          "For history_api::get_account_history_by_operations to set its default limit value as 100")
+         ("api-limit-get-asset-holders",boost::program_options::value<uint64_t>()->default_value(100),
+          "For asset_api::get_asset_holders to set its default limit value as 100")
          ;
    command_line_options.add(configuration_file_options);
    command_line_options.add_options()
@@ -1076,6 +1113,18 @@ void application::startup()
       throw;
    }
 }
+void application::set_dgb_api_limit_api()
+{
+   try {
+      my->set_dgb_api_limit_api();
+   } catch ( const fc::exception& e ) {
+      elog( "${e}", ("e",e.to_detail_string()) );
+      throw;
+   } catch ( ... ) {
+      elog( "unexpected exception" );
+      throw;
+   }
+}
 
 std::shared_ptr<abstract_plugin> application::get_plugin(const string& name) const
 {

libraries/app/application_impl.hxx

@@ -41,6 +41,7 @@ class application_impl : public net::node_delegate
       }
 
       void set_dbg_init_key( graphene::chain::genesis_state_type& genesis, const std::string& init_key );
+      void set_dgb_api_limit_api();
 
       void startup();
 

libraries/app/include/graphene/app/api.hpp

@@ -438,8 +438,8 @@ namespace graphene { namespace app {
    class asset_api
    {
       public:
-         asset_api(graphene::chain::database& db);
-         ~asset_api();
+         asset_api(application& app)
+                 :_app(app), database_api( std::ref(*app.chain_database()), &(app.get_options())) {}
 
          /**
           * @brief Get asset holders for a specific asset
@@ -464,7 +464,8 @@ namespace graphene { namespace app {
          vector<asset_holders> get_all_asset_holders() const;
 
       private:
-         graphene::chain::database& _db;
+           application& _app;
+           graphene::app::database_api database_api;
    };
 
    /**

libraries/app/include/graphene/app/application.hpp

@@ -40,6 +40,12 @@ namespace graphene { namespace app {
       public:
          bool enable_subscribe_to_all = false;
          bool has_market_history_plugin = false;
+         uint64_t api_limit_get_account_history_operations=100;
+         uint64_t api_limit_get_account_history=100;
+         uint64_t api_limit_get_grouped_limit_orders=101;
+         uint64_t api_limit_get_relative_account_history=100;
+         uint64_t api_limit_get_account_history_by_operations=100;
+         uint64_t api_limit_get_asset_holders=100;
    };
 
    class application
@@ -87,7 +93,7 @@ namespace graphene { namespace app {
 
          net::node_ptr                    p2p_node();
          std::shared_ptr<chain::database> chain_database()const;
-
+         void set_dgb_api_limit_api();
          void set_block_production(bool producing_blocks);
          fc::optional< api_access_info > get_api_access_info( const string& username )const;
          void set_api_access_info(const string& username, api_access_info&& permissions);

tests/common/database_fixture.cpp

@@ -120,6 +120,40 @@ database_fixture::database_fixture()
    {
       options.insert(std::make_pair("max-ops-per-account", boost::program_options::variable_value((uint64_t)75, false)));
    }
+   if (current_test_name == "api_limit_get_account_history_operations")
+   {
+       options.insert(std::make_pair("max-ops-per-account", boost::program_options::variable_value((uint64_t)125, false)));
+       options.insert(std::make_pair("api-limit-get-account-history-operations", boost::program_options::variable_value((uint64_t)300, false)));
+       options.insert(std::make_pair("plugins", boost::program_options::variable_value(string("account_history"), false)));
+   }
+   if(current_test_name =="api_limit_get_account_history")
+   {
+       options.insert(std::make_pair("max-ops-per-account", boost::program_options::variable_value((uint64_t)125, false)));
+       options.insert(std::make_pair("api-limit-get-account-history", boost::program_options::variable_value((uint64_t)250, false)));
+       options.insert(std::make_pair("plugins", boost::program_options::variable_value(string("account_history"), false)));
+   }
+   if(current_test_name =="api_limit_get_grouped_limit_orders")
+   {
+       options.insert(std::make_pair("api-limit-get-grouped-limit-orders", boost::program_options::variable_value((uint64_t)250, false)));
+       options.insert(std::make_pair("plugins", boost::program_options::variable_value(string("grouped_orders"), false)));
+   }
+   if(current_test_name =="api_limit_get_relative_account_history")
+   {
+       options.insert(std::make_pair("max-ops-per-account", boost::program_options::variable_value((uint64_t)125, false)));
+       options.insert(std::make_pair("api-limit-get-relative-account-history", boost::program_options::variable_value((uint64_t)250, false)));
+       options.insert(std::make_pair("plugins", boost::program_options::variable_value(string("account_history"), false)));
+   }
+   if(current_test_name =="api_limit_get_account_history_by_operations")
+   {
+       options.insert(std::make_pair("api-limit-get-account-history-by-operations", boost::program_options::variable_value((uint64_t)250, false)));
+       options.insert(std::make_pair("plugins", boost::program_options::variable_value(string("account_history"), false)));
+   }
+   if(current_test_name =="api_limit_get_asset_holders")
+   {
+       options.insert(std::make_pair("api-limit-get-asset-holders", boost::program_options::variable_value((uint64_t)250, false)));
+       options.insert(std::make_pair("plugins", boost::program_options::variable_value(string("account_history"), false)));
+   }
+
    // add account tracking for ahplugin for special test case with track-account enabled
    if( !options.count("track-account") && current_test_name == "track_account") {
       std::vector<std::string> track_account;
@@ -161,6 +195,13 @@ database_fixture::database_fixture()
       ahplugin->plugin_set_app(&app);
       ahplugin->plugin_initialize(options);
       ahplugin->plugin_startup();
+      if (current_test_name == "api_limit_get_account_history_operations" || current_test_name == "api_limit_get_account_history"
+      || current_test_name == "api_limit_get_grouped_limit_orders" || current_test_name == "api_limit_get_relative_account_history"
+      || current_test_name == "api_limit_get_account_history_by_operations" || current_test_name =="api_limit_get_asset_holders")
+      {
+          app.initialize(graphene::utilities::temp_directory_path(), options);
+          app.set_dgb_api_limit_api();
+      }
    }
 
    if(current_test_name == "elasticsearch_objects" || current_test_name == "elasticsearch_suite") {

tests/tests/asset_api_tests.cpp

@@ -37,7 +37,7 @@ BOOST_FIXTURE_TEST_SUITE(asset_api_tests, database_fixture)
 
 BOOST_AUTO_TEST_CASE( asset_holders )
 {
-   graphene::app::asset_api asset_api(db);
+   graphene::app::asset_api asset_api(app);
 
    // create an asset and some accounts
    create_bitasset("USD", account_id_type());
@@ -60,5 +60,25 @@ BOOST_AUTO_TEST_CASE( asset_holders )
    BOOST_CHECK(holders[2].name == "alice");
    BOOST_CHECK(holders[3].name == "dan");
 }
+BOOST_AUTO_TEST_CASE( api_limit_get_asset_holders )
+{
+   graphene::app::asset_api asset_api(app);
+
+   // create an asset and some accounts
+   create_bitasset("USD", account_id_type());
+   auto dan = create_account("dan");
+   auto bob = create_account("bob");
+   auto alice = create_account("alice");
+
+   // send them some bts
+   transfer(account_id_type()(db), dan, asset(100));
+   transfer(account_id_type()(db), alice, asset(200));
+   transfer(account_id_type()(db), bob, asset(300));
+
+   // make call
+   GRAPHENE_CHECK_THROW(asset_api.get_asset_holders(asset_id_type(), 0, 260), fc::exception)
+   vector<account_asset_balance> holders = asset_api.get_asset_holders(asset_id_type(), 0, 210);;
+   BOOST_REQUIRE_EQUAL( holders.size(), 4 );
+}
 
 BOOST_AUTO_TEST_SUITE_END()