LBRYCommunity/lbrycrd
1
0
Fork 0
Code Issues 29 Pull requests 1 Projects Releases 32 Packages Wiki Activity

Use fully static linkage #364

Closed
bvbfan wants to merge 78 commits from static_link into master
pull from: static_link
merge into: LBRYCommunity:master
Conversation 2 Commits 78 Files changed 312 +208 -127
13 changed files with 208 additions and 127 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files
Showing only changes of commit 6d0b8e8196 - Show all commits

101
src/claimtrie/CMakeLists.txt
View file

@ -1,7 +1,7 @@
cmake_minimum_required(VERSION 3.10)
project(claimtrie)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
include(../../contrib/cmake/cmake/CPM.cmake)
@ -12,90 +12,43 @@ set(CLAIMTRIE_SRC
forks.cpp
hashes.cpp
log.cpp
prefixtrie.cpp
trie.cpp
txoutpoint.cpp
uints.cpp
sqlite/sqlite3.c
)
if(BIND)
find_program(SWIG NAMES swig)
string(TOLOWER ${BIND} BIND)
set(INTERFACE_NAME libclaimtrie)
if(${BIND} STREQUAL "python")
find_package(PythonInterp 3.6 REQUIRED)
find_package(PythonLibs 3.6 REQUIRED)
set(BIND_INCLUDE_DIRS ${PYTHON_INCLUDE_DIRS})
set(SWIG_OPTIONS -python;-py3)
set(CMAKE_SHARED_LIBRARY_PREFIX _lib)
else()
message(FATAL_ERROR "Implement a handler for ${BIND}")
endif()
add_custom_command(OUTPUT ${INTERFACE_NAME}_wrap.cxx
COMMAND ${SWIG}
ARGS -c++ ${SWIG_OPTIONS} -outcurrentdir ${CMAKE_CURRENT_SOURCE_DIR}/${INTERFACE_NAME}.i
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
set(CLAIMTRIE_SRC ${CLAIMTRIE_SRC}
${INTERFACE_NAME}_wrap.cxx
)
endif()
add_library(claimtrie SHARED ${CLAIMTRIE_SRC})
target_include_directories(claimtrie PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
# TODO remove leveldb depends
set(LEVELDB_SRC
../leveldb/db/builder.cc
../leveldb/db/c.cc
../leveldb/db/dbformat.cc
../leveldb/db/db_impl.cc
../leveldb/db/db_iter.cc
../leveldb/db/dumpfile.cc
../leveldb/db/filename.cc
../leveldb/db/log_reader.cc
../leveldb/db/log_writer.cc
../leveldb/db/memtable.cc
../leveldb/db/repair.cc
../leveldb/db/table_cache.cc
../leveldb/db/version_edit.cc
../leveldb/db/version_set.cc
../leveldb/db/write_batch.cc
../leveldb/table/block_builder.cc
../leveldb/table/block.cc
../leveldb/table/filter_block.cc
../leveldb/table/format.cc
../leveldb/table/iterator.cc
../leveldb/table/merger.cc
../leveldb/table/table_builder.cc
../leveldb/table/table.cc
../leveldb/table/two_level_iterator.cc
../leveldb/util/arena.cc
../leveldb/util/bloom.cc
../leveldb/util/cache.cc
../leveldb/util/coding.cc
../leveldb/util/comparator.cc
../leveldb/util/crc32c.cc
../leveldb/util/env.cc
../leveldb/util/env_posix.cc
../leveldb/util/filter_policy.cc
../leveldb/util/hash.cc
../leveldb/util/histogram.cc
../leveldb/util/logging.cc
../leveldb/util/options.cc
../leveldb/util/status.cc
)
if(WIN32)
set(LEVELDB_SRC ${LEVELDB_SRC}
../leveldb/util/env_win.cc
../leveldb/port/port_win.cc
)
else()
set(LEVELDB_SRC ${LEVELDB_SRC}
../leveldb/port/port_posix.cc
)
if(BIND_INCLUDE_DIRS)
target_include_directories(claimtrie PRIVATE ${BIND_INCLUDE_DIRS})
endif()
add_library(leveldb STATIC ${LEVELDB_SRC})
target_include_directories(leveldb PRIVATE ../leveldb ../leveldb/include)
if(WIN32)
target_compile_definitions(leveldb PRIVATE -DLEVELDB_PLATFORM_WINDOWS -DWINVER=0x0500 -D__USE_MINGW_ANSI_STDIO=1)
else()
target_compile_definitions(leveldb PRIVATE -DLEVELDB_PLATFORM_POSIX)
endif()
target_compile_definitions(leveldb PRIVATE -DLEVELDB_ATOMIC_PRESENT -D__STDC_LIMIT_MACROS)
target_link_libraries(claimtrie PRIVATE leveldb)
# leveldb depends end here
# TODO remove BITCOIN depends
target_include_directories(claimtrie PRIVATE ../ ../leveldb/include)
# it's needed a configure call to create config files
target_compile_definitions(claimtrie PRIVATE -DHAVE_CONFIG_H)
# bitcoin depends end here
CPMAddPackage(
NAME OpenSSL
GITHUB_REPOSITORY openssl/openssl

5
src/claimtrie/data.cpp
View file

@ -77,8 +77,3 @@ CNameOutPointHeightType::CNameOutPointHeightType(std::string name, CTxOutPoint o
: name(std::move(name)), outPoint(std::move(outPoint)), nValidHeight(nValidHeight)
{
}
CClaimIndexElement::CClaimIndexElement(std::string name, CClaimValue claim)
: name(std::move(name)), claim(std::move(claim))
{
}

13
src/claimtrie/data.h
View file

@ -2,7 +2,7 @@
#ifndef CLAIMTRIE_DATA_H
#define CLAIMTRIE_DATA_H
#include <claimtrie/sqlite/sqlite3.h>
#include <sqlite/sqlite3.h>
#include <txoutpoint.h>
#include <uints.h>
@ -29,7 +29,7 @@ namespace sqlite
}
}
#include <claimtrie/sqlite/hdr/sqlite_modern_cpp.h>
#include <sqlite/hdr/sqlite_modern_cpp.h>
namespace sqlite
{
@ -119,13 +119,4 @@ struct CNameOutPointHeightType
CNameOutPointHeightType(std::string name, CTxOutPoint outPoint, int nValidHeight);
};
struct CClaimIndexElement
{
std::string name;
CClaimValue claim;
CClaimIndexElement() = default;
CClaimIndexElement(std::string name, CClaimValue claim);
};
#endif // CLAIMTRIE_DATA_H

57
src/claimtrie/libclaimtrie.i Normal file
View file

@ -0,0 +1,57 @@
%module libclaimtrie
%{
#include "uints.h"
#include "txoutpoint.h"
#include "data.h"
#include "trie.h"
#include "forks.h"
%}
%feature("directors", 1);
%feature("flatnested", 1);
%include stl.i
%include stdint.i
%include std_pair.i
%ignore CBaseBlob(CBaseBlob &&);
%ignore CClaimIndexElement(CClaimIndexElement &&);
%ignore CClaimNsupports(CClaimNsupports &&);
%ignore CClaimTrieProof(CClaimTrieProof &&);
%ignore CClaimTrieProofNode(CClaimTrieProofNode &&);
%ignore CClaimValue(CClaimValue &&);
%ignore CSupportValue(CSupportValue &&);
%ignore CTxOutPoint(CTxOutPoint &&);
#define SWIG_INTERFACE
%include "uints.h"
%include "txoutpoint.h"
%include "data.h"
%include "trie.h"
%include "forks.h"
%template(CUint160) CBaseBlob<160>;
%template(CUint256) CBaseBlob<256>;
%template(uint8vec) std::vector<uint8_t>;
%template(claimEntryType) std::vector<CClaimValue>;
%template(supportEntryType) std::vector<CSupportValue>;
%template(claimsNsupports) std::vector<CClaimNsupports>;
%template(proofPair) std::pair<bool, CUint256>;
%template(proofNodePair) std::pair<unsigned char, CUint256>;
%template(claimUndoPair) std::pair<std::string, CClaimValue>;
%template(supportUndoPair) std::pair<std::string, CSupportValue>;
%template(takeoverUndoPair) std::pair<std::string, <std::pair<int, CUint160>>;
%template(proofNodes) std::vector<CClaimTrieProofNode>;
%template(proofPairs) std::vector<std::pair<bool, CUint256>>;
%template(proofNodeChildren) std::vector<std::pair<unsigned char, CUint256>>;
%template(claimUndoType) std::vector<claimUndoPair>;
%template(supportUndoType) std::vector<supportUndoPair>;
%template(insertUndoType) std::vector<CNameOutPointHeightType>;
%template(takeoverUndoType) std::vector<takeoverUndoPair>;
%rename(CClaimTrieCache) CClaimTrieCacheHashFork;

86
src/claimtrie/libclaimtrie_test.py Normal file
View file

@ -0,0 +1,86 @@
from libclaimtrie import *
import unittest
class TestClaimTrieTypes(unittest.TestCase):
def setUp(self):
self.uint256s = "1234567890987654321012345678909876543210123456789098765432101234"
self.uint160 = CUint160S("1234567890987654321012345678909876543210")
self.uint = CUint256S(self.uint256s)
self.txp = CTxOutPoint(self.uint, 1)
def assertClaimEqual(self, claim, txo, cid, amount, effe, height, validHeight, msg):
self.assertEqual(claim.outPoint, txo, msg)
self.assertEqual(claim.claimId, cid, msg)
self.assertEqual(claim.nAmount, amount, msg)
self.assertEqual(claim.nEffectiveAmount, effe, msg)
self.assertEqual(claim.nHeight, height, msg)
self.assertEqual(claim.nValidAtHeight, validHeight, msg)
def assertSupportEqual(self, support, txo, cid, amount, height, validHeight, msg):
self.assertEqual(support.outPoint, txo, msg)
self.assertEqual(support.supportedClaimId, cid, msg)
self.assertEqual(support.nAmount, amount, msg)
self.assertEqual(support.nHeight, height, msg)
self.assertEqual(support.nValidAtHeight, validHeight, msg)
def test_uint256(self):
uint = self.uint
self.assertFalse(uint.IsNull(), "incorrect CUint256S or CBaseBlob::IsNull")
self.assertEqual(uint.GetHex(), self.uint256s, "incorrect CBaseBlob::GetHex")
self.assertEqual(uint.GetHex(), uint.ToString(), "incorrect CBaseBlob::ToString")
self.assertEqual(uint.size(), 32, "incorrect CBaseBlob::size")
copy = CUint256()
self.assertNotEqual(copy, uint, "incorrect CBaseBlob::operator!=")
self.assertTrue(copy.IsNull(), "incorrect CBaseBlob::IsNull")
copy = CUint256(uint)
self.assertEqual(copy, uint, "incorrect CBaseBlob::operator==")
copy.SetNull()
self.assertTrue(copy.IsNull()), "incorrect CBaseBlob::SetNull"
def test_txoupoint(self):
txp = self.txp
uint = self.uint
self.assertEqual(txp.hash, uint, "incorrect CTxOutPoint::CTxOutPoint")
self.assertEqual(txp.n, 1, "incorrect CTxOutPoint::CTxOutPoint")
self.assertFalse(txp.IsNull(), "incorrect CTxOutPoint::IsNull")
pcopy = CTxOutPoint()
self.assertTrue(pcopy.IsNull(), "incorrect CTxOutPoint::IsNull")
self.assertEqual(pcopy.hash, CUint256(), "incorrect CTxOutPoint::CTxOutPoint")
self.assertNotEqual(pcopy, txp, "incorrect CTxOutPoint::operator!=")
self.assertIn(uint.ToString()[:10], txp.ToString(), "incorrect CTxOutPoint::ToString")
def test_claim(self):
txp = self.txp
uint160 = self.uint160
self.assertEqual(uint160.size(), 20, "incorrect CBaseBlob::size")
claim = CClaimValue(txp, uint160, 20, 1, 10)
self.assertClaimEqual(claim, txp, uint160, 20, 20, 1, 10, "incorrect CClaimValue::CClaimValue")
def test_support(self):
txp = self.txp
uint160 = self.uint160
claim = CClaimValue(txp, uint160, 20, 1, 10)
support = CSupportValue(txp, uint160, 20, 1, 10)
self.assertSupportEqual(support, claim.outPoint, claim.claimId, claim.nAmount, claim.nHeight, claim.nValidAtHeight, "incorrect CSupportValue::CSupportValue")
def test_claimtrie(self):
txp = self.txp
uint160 = self.uint160
claim = CClaimValue(txp, uint160, 20, 1, 10)
data = CClaimTrieData()
data.insertClaim(claim)
wipe = True; height = 0; data_dir = "."
trie = CClaimTrie(wipe, height, data_dir)
cache = CClaimTrieCacheBase(trie)
self.assertTrue(cache.empty(), "incorrect CClaimtrieCache::empty")
self.assertFalse(cache.haveClaim("test", txp), "incorrect CClaimtrieCache::haveClaim")
self.assertTrue(cache.addClaim("tes", txp, uint160, 20, 0), "incorrect CClaimtrieCache::addClaim")
self.assertEqual(cache.getTotalNamesInTrie(), 1, "incorrect CClaimtrieCache::getTotalNamesInTrie")
self.assertEqual(cache.getTotalClaimsInTrie(), 1, "incorrect CClaimtrieCache::getTotalClaimsInTrie")
claimsToName = cache.getClaimsForName("test")
claims = claimsToName.claimsNsupports
self.assertEqual(claims.size(), 1, "incorrect CClaimTrieCache::getClaimsForName")
self.assertFalse(claims[0].IsNull(), "incorrect CClaimNsupports::IsNull")
unittest.main()

4
src/claimtrie/trie.cpp
View file

@ -452,7 +452,7 @@ CUint256 CClaimTrieCacheBase::recursiveComputeMerkleHash(const std::string& name
std::vector<std::tuple<std::string, std::unique_ptr<CUint256>, int>> children;
childHashQuery << name >> [&children](std::string name, std::unique_ptr<CUint256> hash, int takeoverHeight) {
children.push_back(std::make_tuple(std::move(name), std::move(hash), takeoverHeight));
}
};
childHashQuery++;
for (auto& child: children) {
@ -460,7 +460,7 @@ CUint256 CClaimTrieCacheBase::recursiveComputeMerkleHash(const std::string& name
auto& hash = std::get<1>(child);
if (!hash) hash = std::make_unique<CUint256>();
if (hash->IsNull())
hash = recursiveComputeMerkleHash(name, std::get<2>(child), checkOnly);
*hash = recursiveComputeMerkleHash(name, std::get<2>(child), checkOnly);
completeHash(*hash, name, pos);
vchToHash.push_back(name[pos]);
vchToHash.insert(vchToHash.end(), hash->begin(), hash->end());

30
src/claimtrie/trie.h
View file

@ -55,17 +55,18 @@ class CClaimTrie
friend class CClaimTrieCacheHashFork;
friend class CClaimTrieCacheExpirationFork;
friend class CClaimTrieCacheNormalizationFork;
public:
CClaimTrie() = default;
CClaimTrie(CClaimTrie&&) = delete;
CClaimTrie(const CClaimTrie&) = delete;
CClaimTrie(bool fWipe, int height,
const std::string& dataDir,
int nNormalizedNameForkHeight,
int64_t nOriginalClaimExpirationTime,
int64_t nExtendedClaimExpirationTime,
int64_t nExtendedClaimExpirationForkHeight,
int64_t nAllClaimsInMerkleForkHeight,
int nNormalizedNameForkHeight = -1,
int64_t nOriginalClaimExpirationTime = -1,
int64_t nExtendedClaimExpirationTime = -1,
int64_t nExtendedClaimExpirationForkHeight = -1,
int64_t nAllClaimsInMerkleForkHeight = -1,
int proportionalDelayFactor = 32);
CClaimTrie& operator=(CClaimTrie&&) = delete;
@ -77,7 +78,7 @@ public:
protected:
int nNextHeight = 0;
sqlite::database db;
const int nProportionalDelayFactor = 0;
const int nProportionalDelayFactor = 1;
const int nNormalizedNameForkHeight = -1;
const int64_t nOriginalClaimExpirationTime = -1;
@ -90,6 +91,7 @@ struct CClaimTrieProofNode
{
CClaimTrieProofNode(std::vector<std::pair<unsigned char, CUint256>> children, bool hasValue, CUint256 valHash);
CClaimTrieProofNode() = default;
CClaimTrieProofNode(CClaimTrieProofNode&&) = default;
CClaimTrieProofNode(const CClaimTrieProofNode&) = default;
CClaimTrieProofNode& operator=(CClaimTrieProofNode&&) = default;
@ -118,10 +120,20 @@ struct CClaimTrieProof
template <typename T>
using queueEntryType = std::pair<std::string, T>;
typedef std::vector<queueEntryType<CClaimValue>> claimUndoType;
typedef std::vector<queueEntryType<CSupportValue>> supportUndoType;
#ifdef SWIG_INTERFACE // swig has a problem with using in typedef
using claimUndoPair = std::pair<std::string, CClaimValue>;
using supportUndoPair = std::pair<std::string, CSupportValue>;
using takeoverUndoPair = std::pair<std::string, <std::pair<int, CUint160>>;
#else
using claimUndoPair = queueEntryType<CClaimValue>;
using supportUndoPair = queueEntryType<CSupportValue>;
using takeoverUndoPair = queueEntryType<std::pair<int, CUint160>>;
#endif
typedef std::vector<claimUndoPair> claimUndoType;
typedef std::vector<supportUndoPair> supportUndoType;
typedef std::vector<CNameOutPointHeightType> insertUndoType;
typedef std::vector<queueEntryType<std::pair<int, CUint160>>> takeoverUndoType;
typedef std::vector<takeoverUndoPair> takeoverUndoType;
class CClaimTrieCacheBase
{

5
src/claimtrie/txoutpoint.h
View file

@ -5,6 +5,7 @@
#include <uints.h>
#include <algorithm>
#include <string>
#include <type_traits>
#include <vector>
#include <utility>
@ -34,4 +35,8 @@ public:
std::string ToString() const;
};
#ifndef SWIG_INTERFACE
#endif // SWIG_INTERFACE
#endif // CLAIMTRIE_TXOUTPUT_H

14
src/claimtrie_serial.h
View file

@ -88,18 +88,4 @@ void Unserialize(Stream& s, CNameOutPointHeightType& u)
Unserialize(s, u.nValidHeight);
}
template<typename Stream>
void Serialize(Stream& s, const CClaimIndexElement& u)
{
Serialize(s, u.name);
Serialize(s, u.claim);
}
template<typename Stream>
void Unserialize(Stream& s, CClaimIndexElement& u)
{
Unserialize(s, u.name);
Unserialize(s, u.claim);
}
#endif // CLAIMTRIE_SERIAL_H

2
src/init.cpp
View file

@ -1540,7 +1540,7 @@ bool AppInitMain()
}
auto tip = chainActive.Tip();
assert(tip);
if (!CClaimTrieCache(pclaimTrie).validateDb(tip->hashClaimTrie))
if (!CClaimTrieCache(pclaimTrie).validateDb(tip->hashClaimTrie)) {
strLoadError = _("Error loading the claim trie from disk");
break;
}

8
src/test/claimtriebranching_tests.cpp
View file

@ -440,15 +440,15 @@ BOOST_AUTO_TEST_CASE(claimtrie_update_takeover_test)
fixture.getLastTakeoverForName("test", cid2, takeover);
CClaimValue value;
BOOST_REQUIRE(fixture.getInfoForName("test", value) && value.nAmount == 3);
BOOST_CHECK_EQUAL(cid, cid2);
BOOST_CHECK_EQUAL(cid, uint160(cid2));
BOOST_CHECK_EQUAL(height, takeover);
fixture.DecrementBlocks(1);
fixture.getLastTakeoverForName("test", cid2, takeover);
BOOST_CHECK_EQUAL(cid, cid2);
BOOST_CHECK_EQUAL(cid, uint160(cid2));
BOOST_CHECK_EQUAL(height, takeover);
fixture.DecrementBlocks(1);
fixture.getLastTakeoverForName("test", cid2, takeover);
BOOST_CHECK_EQUAL(cid, cid2);
BOOST_CHECK_EQUAL(cid, uint160(cid2));
BOOST_CHECK_EQUAL(height, takeover);
}
@ -1924,7 +1924,7 @@ BOOST_AUTO_TEST_CASE(update_on_support2_test)
int lastTakeover;
BOOST_CHECK(fixture.getLastTakeoverForName(name, claimId, lastTakeover));
BOOST_CHECK_EQUAL(lastTakeover, height + 1);
BOOST_CHECK_EQUAL(ClaimIdHash(tx1.GetHash(), 0), claimId);
BOOST_CHECK_EQUAL(ClaimIdHash(tx1.GetHash(), 0), uint160(claimId));
fixture.Spend(s1);
fixture.Spend(s2);

8
src/test/claimtrieexpirationfork_tests.cpp
View file

@ -276,9 +276,6 @@ BOOST_AUTO_TEST_CASE(hardfork_disk_test)
BOOST_CHECK_EQUAL(fixture.expirationTime(), 3);
fixture.IncrementBlocks(7, true);
BOOST_CHECK_EQUAL(fixture.expirationTime(), 6);
auto tip = chainActive.Tip();
pclaimTrie->ReadFromDisk(tip->nHeight, tip->hashClaimTrie);
BOOST_CHECK_EQUAL(fixture.expirationTime(), 6);
// Create a claim and support 1 block before the fork height that will expire after the fork height.
// Reset to disk, increment past the fork height and make sure we get
@ -288,8 +285,6 @@ BOOST_AUTO_TEST_CASE(hardfork_disk_test)
CMutableTransaction s1 = fixture.MakeSupport(fixture.GetCoinbase(), tx1, "test", 1);
fixture.IncrementBlocks(1);
tip = chainActive.Tip();
pclaimTrie->ReadFromDisk(tip->nHeight, tip->hashClaimTrie);
BOOST_CHECK_EQUAL(fixture.expirationTime(), 3);
fixture.IncrementBlocks(1);
BOOST_CHECK_EQUAL(fixture.expirationTime(), 6);
@ -310,8 +305,7 @@ BOOST_AUTO_TEST_CASE(hardfork_disk_test)
CMutableTransaction tx2 = fixture.MakeClaim(fixture.GetCoinbase(),"test2","one",1);
CMutableTransaction s2 = fixture.MakeSupport(fixture.GetCoinbase(),tx2,"test2",1);
fixture.IncrementBlocks(1);
tip = chainActive.Tip();
pclaimTrie->ReadFromDisk(tip->nHeight, tip->hashClaimTrie);
CMutableTransaction u2 = fixture.MakeUpdate(tx2, "test2", "two", ClaimIdHash(tx2.GetHash(), 0), 1);
// increment to fork
fixture.IncrementBlocks(2);

2
src/test/claimtriefixture.h
View file

@ -28,6 +28,8 @@
extern ::CChainState g_chainstate;
extern ::ArgsManager gArgs;
extern std::vector<std::string> random_strings(std::size_t count);
CMutableTransaction BuildTransaction(const uint256& prevhash);
CMutableTransaction BuildTransaction(const CTransaction& prev, uint32_t prevout=0, unsigned int numOutputs=1, int locktime=0);