Merge branch 'golos-v0.16.2'

Author: nemothenoone

CMakeLists.txt

@@ -70,6 +70,13 @@ if(LOW_MEMORY_NODE)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DIS_LOW_MEM")
 endif()
 
+option(CHAINBASE_CHECK_LOCKING "Check locks in chainbase (ON or OFF)" TRUE)
+message(STATUS "CHAINBASE_CHECK_LOCKING: ${CHAINBASE_CHECK_LOCKING}")
+if(CHAINBASE_CHECK_LOCKING)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DCHAINBASE_CHECK_LOCKING")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DCHAINBASE_CHECK_LOCKING")
+endif()
+
 option(CLEAR_VOTES "Build source to clear old votes from memory" ON)
 if(CLEAR_VOTES)
     message(STATUS "   CONFIGURING TO CLEAR OLD VOTES FROM MEMORY")

libraries/app/application.cpp

@@ -232,6 +232,10 @@ namespace steemit {
                         bool read_only = _options->count("read-only");
                         register_builtin_apis();
 
+                        if (_options->count("check-locks")) {
+                            _chain_db->set_require_locking(true);
+                        }
+
                         if (_options->count("shared-file-dir")) {
                             _shared_dir = fc::path(_options->at("shared-file-dir").as<string>());
                         } else {
@@ -543,16 +547,16 @@ namespace steemit {
                              num <= _chain_db->head_block_num() &&
                              result.size() < limit;
                              ++num) {
-                                 if (num > 0) {
-                                     result.push_back(_chain_db->get_block_id_for_num(num));
-                                 }
+                            if (num > 0) {
+                                result.push_back(_chain_db->get_block_id_for_num(num));
+                            }
                         }
 
                         if (!result.empty() &&
                             block_header::num_from_id(result.back()) <
                             _chain_db->head_block_num()) {
-                                remaining_item_count = _chain_db->head_block_num() -
-                                                       block_header::num_from_id(result.back());
+                            remaining_item_count = _chain_db->head_block_num() -
+                                                   block_header::num_from_id(result.back());
                         }
 
                         return result;
@@ -690,9 +694,9 @@ namespace steemit {
 
                                     if (last_non_fork_block ==
                                         block_id_type()) { // if the fork goes all the way back to genesis (does graphene's fork db allow this?)
-                                            non_fork_high_block_num = 0;
+                                        non_fork_high_block_num = 0;
                                     } else {
-                                            non_fork_high_block_num = block_header::num_from_id(last_non_fork_block);
+                                        non_fork_high_block_num = block_header::num_from_id(last_non_fork_block);
                                     }
 
                                     high_block_num = non_fork_high_block_num +
@@ -904,7 +908,8 @@ namespace steemit {
                     ("public-api", bpo::value<vector<string>>()->composing()->default_value(default_apis, str_default_apis), "Set an API to be publicly available, may be specified multiple times")
                     ("enable-plugin", bpo::value<vector<string>>()->composing()->default_value(default_plugins, str_default_plugins), "Plugin(s) to enable, may be specified multiple times")
                     ("max-block-age", bpo::value<int32_t>()->default_value(200), "Maximum age of head block when broadcasting tx via API")
-                    ("flush", bpo::value<uint32_t>()->default_value(100000), "Flush shared memory file to disk this many blocks");
+                    ("flush", bpo::value<uint32_t>()->default_value(100000), "Flush shared memory file to disk this many blocks")
+                    ("check-locks", bpo::value<bool>()->default_value(false), "Check correctness of chainbase locking");
             command_line_options.add(configuration_file_options);
             command_line_options.add_options()
                     ("replay-blockchain", "Rebuild object graph by replaying all blocks")

libraries/app/database_api.cpp

@@ -15,7 +15,6 @@
 #include <fc/api.hpp>
 #include <fc/optional.hpp>
 #include <fc/variant_object.hpp>
-
 #include <fc/network/ip.hpp>
 
 #include <boost/container/flat_set.hpp>
@@ -75,6 +74,7 @@ namespace steemit {
 /**
  *  Defines the arguments to a query as a struct so it can be easily extended
  */
+
         struct discussion_query {
             void validate() const {
                 FC_ASSERT(filter_tags.find(tag) == filter_tags.end());
@@ -84,6 +84,9 @@ namespace steemit {
             string tag;
             uint32_t limit = 0;
             set<string> filter_tags;
+            set<string> select_authors; ///< list of authors to include, posts not by this author are filtered
+            set<string> select_tags; ///< list of tags to include, posts without these tags are filtered
+            uint32_t truncate_body = 0; ///< the number of bytes of the post body to return, 0 for all
             optional<string> start_author;
             optional<string> start_permlink;
             optional<string> parent_author;
@@ -356,6 +359,9 @@ namespace steemit {
             vector<discussion> get_content_replies(string parent, string parent_permlink) const;
 
             ///@{ tags API
+            /** This API will return the top 1000 tags used by an author sorted by most frequently used */
+            vector<pair<string, uint32_t>> get_tags_used_by_author(const string &author) const;
+
             vector<discussion> get_discussions_by_trending(const discussion_query &query) const;
 
             vector<discussion> get_discussions_by_trending30(const discussion_query &query) const;
@@ -440,7 +446,7 @@ namespace steemit {
 
             void set_url(discussion &d) const;
 
-            discussion get_discussion(comment_id_type) const;
+            discussion get_discussion(comment_id_type, uint32_t truncate_body = 0) const;
 
             static bool filter_default(const comment_api_obj &c) {
                 return false;
@@ -455,14 +461,14 @@ namespace steemit {
             }
 
             template<typename Index, typename StartItr>
-            vector<discussion> get_discussions(const discussion_query &q,
+            vector<discussion> get_discussions(const discussion_query &query,
                     const string &tag,
                     comment_id_type parent,
-                    const Index &idx, StartItr itr,
+                    const Index &tidx, StartItr tidx_itr,
+                    uint32_t truncate_body = 0,
                     const std::function<bool(const comment_api_obj &)> &filter = &database_api::filter_default,
                     const std::function<bool(const comment_api_obj &)> &exit = &database_api::exit_default,
-                    const std::function<bool(const tags::tag_object &)> &tag_exit = &database_api::tag_exit_default
-            ) const;
+                    const std::function<bool(const tags::tag_object &)> &tag_exit = &database_api::tag_exit_default) const;
 
             comment_id_type get_parent(const discussion_query &q) const;
 
@@ -480,7 +486,7 @@ FC_REFLECT(steemit::app::scheduled_hardfork, (hf_version)(live_time));
 FC_REFLECT(steemit::app::liquidity_balance, (account)(weight));
 FC_REFLECT(steemit::app::withdraw_route, (from_account)(to_account)(percent)(auto_vest));
 
-FC_REFLECT(steemit::app::discussion_query, (tag)(filter_tags)(start_author)(start_permlink)(parent_author)(parent_permlink)(limit));
+FC_REFLECT(steemit::app::discussion_query, (tag)(filter_tags)(select_tags)(select_authors)(truncate_body)(start_author)(start_permlink)(parent_author)(parent_permlink)(limit));
 
 FC_REFLECT_ENUM(steemit::app::withdraw_route_type, (incoming)(outgoing)(all));
 
@@ -493,6 +499,7 @@ FC_API(steemit::app::database_api,
 
                 // tags
                 (get_trending_tags)
+                (get_tags_used_by_author)
                 (get_discussions_by_trending)
                 (get_discussions_by_trending30)
                 (get_discussions_by_created)

libraries/app/include/steemit/app/database_api.hpp

@@ -82,7 +82,9 @@ namespace steemit {
             vector<string> replies; ///< author/slug mapping
             share_type author_reputation = 0;
             asset promoted = asset(0, SBD_SYMBOL);
-            optional<string> first_reblogged_by;
+            uint32_t body_length = 0;
+            vector<account_name_type> reblogged_by;
+            optional<account_name_type> first_reblogged_by;
             optional<time_point_sec> first_reblogged_on;
         };
 
@@ -105,6 +107,8 @@ namespace steemit {
             map<uint64_t, applied_operation> vote_history;
             map<uint64_t, applied_operation> other_history;
             set<string> witness_votes;
+            vector<pair<string, uint32_t>> tags_usage;
+            vector<pair<account_name_type, uint32_t>> guest_bloggers;
 
             optional<map<uint32_t, extended_limit_order>> open_orders;
             optional<vector<string>> comments; /// permlinks for this user
@@ -193,7 +197,7 @@ namespace steemit {
 FC_REFLECT_DERIVED(steemit::app::extended_account,
         (steemit::app::account_api_obj),
         (vesting_balance)(reputation)
-                (transfer_history)(market_history)(post_history)(vote_history)(other_history)(witness_votes)(open_orders)(comments)(feed)(blog)(recent_replies)(blog_category)(recommended))
+                (transfer_history)(market_history)(post_history)(vote_history)(other_history)(witness_votes)(tags_usage)(guest_bloggers)(open_orders)(comments)(feed)(blog)(recent_replies)(blog_category)(recommended))
 
 
 FC_REFLECT(steemit::app::vote_state, (voter)(weight)(rshares)(percent)(reputation)(time));
@@ -202,7 +206,7 @@ FC_REFLECT(steemit::app::account_vote, (authorperm)(weight)(rshares)(percent)(ti
 FC_REFLECT(steemit::app::discussion_index, (category)(trending)(trending30)(updated)(created)(responses)(active)(votes)(maturing)(best)(hot)(promoted)(cashout))
 FC_REFLECT(steemit::app::category_index, (active)(recent)(best))
 FC_REFLECT(steemit::app::tag_index, (trending))
-FC_REFLECT_DERIVED(steemit::app::discussion, (steemit::app::comment_api_obj), (url)(root_title)(pending_payout_value)(total_pending_payout_value)(active_votes)(replies)(author_reputation)(promoted)(first_reblogged_by)(first_reblogged_on))
+FC_REFLECT_DERIVED(steemit::app::discussion, (steemit::app::comment_api_obj), (url)(root_title)(pending_payout_value)(total_pending_payout_value)(active_votes)(replies)(author_reputation)(promoted)(body_length)(reblogged_by)(first_reblogged_by)(first_reblogged_on))
 
 FC_REFLECT(steemit::app::state, (current_route)(props)(category_idx)(tag_idx)(categories)(tags)(content)(accounts)(pow_queue)(witnesses)(discussion_idx)(witness_schedule)(feed_price)(error)(market_data))
 

libraries/app/include/steemit/app/state.hpp

@@ -600,15 +600,14 @@ namespace steemit {
 
             bool result;
             detail::with_skip_flags(*this, skip, [&]() {
-                detail::without_pending_transactions(*this, std::move(_pending_tx),
-                        [&]() {
-                            try {
-                                with_write_lock([&]() {
-                                    result = _push_block(new_block);
-                                });
-                            }
-                            FC_CAPTURE_AND_RETHROW((new_block))
-                        });
+                with_write_lock([&]() {
+                    detail::without_pending_transactions(*this, std::move(_pending_tx), [&]() {
+                        try {
+                            result = _push_block(new_block);
+                        }
+                        FC_CAPTURE_AND_RETHROW((new_block))
+                    });
+                });
             });
 
             //fc::time_point end_time = fc::time_point::now();
@@ -2315,7 +2314,8 @@ namespace steemit {
                 auto pay = std::max(percent, STEEMIT_MIN_PRODUCER_REWARD);
 
                 /// pay witness in vesting shares
-                if (props.head_block_number >= STEEMIT_START_MINER_VOTING_BLOCK ||
+                if (props.head_block_number >=
+                    STEEMIT_START_MINER_VOTING_BLOCK ||
                     (witness_account.vesting_shares.amount.value == 0)) {
                     // const auto& witness_obj = get_witness( props.current_witness );
                     create_vesting(witness_account, pay);
@@ -2330,7 +2330,8 @@ namespace steemit {
                 auto pay = std::max(percent, STEEMIT_MIN_PRODUCER_REWARD_PRE_HF_16);
 
                 /// pay witness in vesting shares
-                if (props.head_block_number >= STEEMIT_START_MINER_VOTING_BLOCK ||
+                if (props.head_block_number >=
+                    STEEMIT_START_MINER_VOTING_BLOCK ||
                     (witness_account.vesting_shares.amount.value == 0)) {
                     // const auto& witness_obj = get_witness( props.current_witness );
                     create_vesting(witness_account, pay);
@@ -2371,8 +2372,9 @@ namespace steemit {
 
         void database::pay_liquidity_reward() {
 #ifdef STEEMIT_BUILD_TESTNET
-            if( !liquidity_rewards_enabled )
-      return;
+            if (!liquidity_rewards_enabled) {
+                return;
+            }
 #endif
 
             if ((head_block_num() % STEEMIT_LIQUIDITY_REWARD_BLOCKS) == 0) {
@@ -2922,9 +2924,11 @@ namespace steemit {
 
 
         void database::validate_transaction(const signed_transaction &trx) {
-            auto session = start_undo_session(true);
-            _apply_transaction(trx);
-            session.undo();
+            database::with_write_lock([&]() {
+                auto session = start_undo_session(true);
+                _apply_transaction(trx);
+                session.undo();
+            });
         }
 
         void database::notify_changed_objects() {
@@ -3016,12 +3020,12 @@ namespace steemit {
                             x += now % span;
                         }
                         _next_flush_block = x;
-                        ilog("Next flush scheduled at block ${b}", ("b", x));
+//                        ilog("Next flush scheduled at block ${b}", ("b", x));
                     }
 
                     if (_next_flush_block == block_num) {
                         _next_flush_block = 0;
-                        ilog("Flushing database shared memory at block ${b}", ("b", block_num));
+//                        ilog("Flushing database shared memory at block ${b}", ("b", block_num));
                         chainbase::database::flush();
                     }
                 }
@@ -3233,8 +3237,9 @@ namespace steemit {
                             fho.current_median_history = copy[copy.size() / 2];
 
 #ifdef STEEMIT_BUILD_TESTNET
-                            if( skip_price_feed_limit_check )
-               return;
+                            if (skip_price_feed_limit_check) {
+                                return;
+                            }
 #endif
                             if (has_hardfork(STEEMIT_HARDFORK_0_14__230)) {
                                 const auto &gpo = get_dynamic_global_properties();
@@ -4137,17 +4142,17 @@ namespace steemit {
                 case STEEMIT_HARDFORK_0_1:
                     perform_vesting_share_split(10000);
 #ifdef STEEMIT_BUILD_TESTNET
-                {
-            custom_operation test_op;
-            string op_msg = "Testnet: Hardfork applied";
-            test_op.data = vector< char >( op_msg.begin(), op_msg.end() );
-            test_op.required_auths.insert( STEEMIT_INIT_MINER_NAME );
-            operation op = test_op;   // we need the operation object to live to the end of this scope
-            operation_notification note( op );
-            notify_pre_apply_operation( note );
-            notify_post_apply_operation( note );
-         }
-         break;
+                    {
+                        custom_operation test_op;
+                        string op_msg = "Testnet: Hardfork applied";
+                        test_op.data = vector<char>(op_msg.begin(), op_msg.end());
+                        test_op.required_auths.insert(STEEMIT_INIT_MINER_NAME);
+                        operation op = test_op;   // we need the operation object to live to the end of this scope
+                        operation_notification note(op);
+                        notify_pre_apply_operation(note);
+                        notify_post_apply_operation(note);
+                    }
+                    break;
 #endif
                     break;
                 case STEEMIT_HARDFORK_0_2:
@@ -4470,10 +4475,9 @@ namespace steemit {
                 if (itr->parent_author != STEEMIT_ROOT_POST_PARENT) {
 // Low memory nodes only need immediate child count, full nodes track total children
 #ifdef IS_LOW_MEM
-                    modify( get_comment( itr->parent_author, itr->parent_permlink ), [&]( comment_object& c )
-         {
-            c.children++;
-         });
+                    modify(get_comment(itr->parent_author, itr->parent_permlink), [&](comment_object &c) {
+                        c.children++;
+                    });
 #else
                     const comment_object *parent = &get_comment(itr->parent_author, itr->parent_permlink);
                     while (parent) {
@@ -4547,6 +4551,5 @@ namespace steemit {
                 }
             }
         }
-
     }
 } //steemit::chain

libraries/chain/database.cpp

@@ -21,6 +21,8 @@ namespace steemit {
         class account_object
                 : public object<account_object_type, account_object> {
         public:
+            account_object() = delete;
+
             template<typename Constructor, typename Allocator>
             account_object(Constructor &&c, allocator<Allocator> a)
                     :json_metadata(a) {
@@ -117,6 +119,8 @@ namespace steemit {
         class account_authority_object
                 : public object<account_authority_object_type, account_authority_object> {
         public:
+            account_authority_object() = delete;
+
             template<typename Constructor, typename Allocator>
             account_authority_object(Constructor &&c, allocator<Allocator> a)
                     : owner(a), active(a), posting(a) {
@@ -157,6 +161,8 @@ namespace steemit {
         class owner_authority_history_object
                 : public object<owner_authority_history_object_type, owner_authority_history_object> {
         public:
+            owner_authority_history_object() = delete;
+
             template<typename Constructor, typename Allocator>
             owner_authority_history_object(Constructor &&c, allocator<Allocator> a)
                     :previous_owner_authority(shared_authority::allocator_type(a.get_segment_manager())) {
@@ -173,6 +179,8 @@ namespace steemit {
         class account_recovery_request_object
                 : public object<account_recovery_request_object_type, account_recovery_request_object> {
         public:
+            account_recovery_request_object() = delete;
+
             template<typename Constructor, typename Allocator>
             account_recovery_request_object(Constructor &&c, allocator<Allocator> a)
                     :new_owner_authority(shared_authority::allocator_type(a.get_segment_manager())) {

libraries/chain/include/steemit/chain/account_object.hpp

@@ -37,6 +37,8 @@ namespace steemit {
         class category_object
                 : public object<category_object_type, category_object> {
         public:
+            category_object() = delete;
+
             template<typename Constructor, typename Allocator>
             category_object(Constructor &&c, allocator <Allocator> a)
                     :name(a) {
@@ -100,6 +102,8 @@ namespace steemit {
         class comment_object
                 : public object<comment_object_type, comment_object> {
         public:
+            comment_object() = delete;
+
             template<typename Constructor, typename Allocator>
             comment_object(Constructor &&c, allocator <Allocator> a)
                     :category(a), parent_permlink(a), permlink(a), title(a),