From 5b5b280b87b87b820c9bbf9023a18bc6e21c5bf8 Mon Sep 17 00:00:00 2001 From: Arvid Norberg Date: Fri, 26 Oct 2018 15:42:10 +0200 Subject: [PATCH 1/2] only make snubbed peers invert the piece picking strategy when we're doing rarest first (i.e. snubbed peers do common-first). Specifically, this prevents snubbed peers from picking from the end of the torrent when in sequential mode --- src/peer_connection.cpp | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/src/peer_connection.cpp b/src/peer_connection.cpp index 5962ae5de..0b9dd6d69 100644 --- a/src/peer_connection.cpp +++ b/src/peer_connection.cpp @@ -880,15 +880,16 @@ namespace libtorrent else { ret |= piece_picker::rarest_first; - } - if (m_snubbed) - { - // snubbed peers should request - // the common pieces first, just to make - // it more likely for all snubbed peers to - // request blocks from the same piece - ret |= piece_picker::reverse; + if (m_snubbed) + { + // snubbed peers should request + // the common pieces first, just to make + // it more likely for all snubbed peers to + // request blocks from the same piece + ret |= piece_picker::reverse; + } + } if (m_settings.get_bool(settings_pack::prioritize_partial_pieces)) From 939b380fda5f9ec3fe05ab98350fe4a8eb454f5e Mon Sep 17 00:00:00 2001 From: Arvid Norberg Date: Sat, 27 Oct 2018 15:24:05 +0200 Subject: [PATCH 2/2] fix build against boost-1.69 --- bindings/python/Jamfile | 6 +- bindings/python/src/error_code.cpp | 91 ++++++++++++++++++++++-------- bindings/python/test.py | 16 ++++++ src/bdecode.cpp | 2 +- src/error_code.cpp | 2 +- src/socks5_stream.cpp | 2 +- src/upnp.cpp | 2 +- test/test_bdecode.cpp | 2 +- 8 files changed, 92 insertions(+), 31 deletions(-) diff --git a/bindings/python/Jamfile b/bindings/python/Jamfile index 8b32b5536..202d15398 100644 --- a/bindings/python/Jamfile +++ b/bindings/python/Jamfile @@ -12,8 +12,8 @@ BOOST_ROOT = [ modules.peek : BOOST_ROOT ] ; # this is used to make bjam use the same version of python which is executing setup.py LIBTORRENT_PYTHON_INTERPRETER = [ modules.peek : LIBTORRENT_PYTHON_INTERPRETER ] ; -feature visibility : default hidden : composite ; -feature.compose hidden : -fvisibility=hidden -fvisibility-inlines-hidden ; +feature lt-visibility : default hidden : composite ; +feature.compose hidden : -fvisibility=hidden -fvisibility-inlines-hidden ; feature libtorrent-link : shared static : composite propagated ; feature libtorrent-python-pic : off on : composite propagated link-incompatible ; @@ -100,7 +100,7 @@ rule libtorrent_linking ( properties * ) || clang in $(properties) || clang-darwin in $(properties) { - result += hidden ; + result += hidden ; if ( gcc in $(properties) ) { diff --git a/bindings/python/src/error_code.cpp b/bindings/python/src/error_code.cpp index b2bec8747..dce1e32d1 100644 --- a/bindings/python/src/error_code.cpp +++ b/bindings/python/src/error_code.cpp @@ -112,11 +112,58 @@ namespace { }; } +struct category_holder +{ + category_holder(boost::system::error_category const& cat) : m_cat(&cat) {} + char const* name() const { return m_cat->name(); } + std::string message(int const v) const { return m_cat->message(v); } + + friend bool operator==(category_holder const lhs, category_holder const rhs) + { return *lhs.m_cat == *rhs.m_cat; } + + friend bool operator!=(category_holder const lhs, category_holder const rhs) + { return *lhs.m_cat != *rhs.m_cat; } + + friend bool operator<(category_holder const lhs, category_holder const rhs) + { return *lhs.m_cat < *rhs.m_cat; } + + boost::system::error_category const& ref() const { return *m_cat; } + operator boost::system::error_category const&() const { return *m_cat; } +private: + boost::system::error_category const* m_cat; +}; + +void error_code_assign(boost::system::error_code& self, int const v, category_holder const cat) +{ + self.assign(v, cat.ref()); +} + +category_holder error_code_category(boost::system::error_code const& self) +{ + return category_holder(self.category()); +} + +#define WRAP_CAT(name) \ + category_holder wrap_ ##name## _category() { return category_holder(name## _category()); } + +WRAP_CAT(libtorrent) +WRAP_CAT(upnp) +WRAP_CAT(http) +WRAP_CAT(socks) +WRAP_CAT(bdecode) +#if TORRENT_USE_I2P +WRAP_CAT(i2p) +#endif +WRAP_CAT(generic) +WRAP_CAT(system) + +#undef WRAP_CAT + void bind_error_code() { - class_("error_category", no_init) - .def("name", &error_category::name) - .def("message", &error_category::message) + class_("error_category", no_init) + .def("name", &category_holder::name) + .def("message", &category_holder::message) .def(self == self) .def(self < self) .def(self != self) @@ -124,39 +171,37 @@ void bind_error_code() class_("error_code") .def(init<>()) - .def("message", &error_code::message) + .def(init()) + .def("message", static_cast(&error_code::message)) .def("value", &error_code::value) .def("clear", &error_code::clear) - .def("category", &error_code::category - , return_internal_reference<>()) - .def("assign", &error_code::assign) + .def("category", &error_code_category) + .def("assign", &error_code_assign) .def_pickle(ec_pickle_suite()) ; -typedef return_value_policy return_existing; - - def("libtorrent_category", &libtorrent_category, return_existing()); - def("upnp_category", &upnp_category, return_existing()); - def("http_category", &http_category, return_existing()); - def("socks_category", &socks_category, return_existing()); - def("bdecode_category", &bdecode_category, return_existing()); + def("libtorrent_category", &wrap_libtorrent_category); + def("upnp_category", &wrap_upnp_category); + def("http_category", &wrap_http_category); + def("socks_category", &wrap_socks_category); + def("bdecode_category", &wrap_bdecode_category); #if TORRENT_USE_I2P - def("i2p_category", &i2p_category, return_existing()); + def("i2p_category", &wrap_i2p_category); #endif #ifndef TORRENT_NO_DEPRECATE - def("get_libtorrent_category", &libtorrent_category, return_existing()); - def("get_upnp_category", &upnp_category, return_existing()); - def("get_http_category", &http_category, return_existing()); - def("get_socks_category", &socks_category, return_existing()); - def("get_bdecode_category", &bdecode_category, return_existing()); + def("get_libtorrent_category", &wrap_libtorrent_category); + def("get_upnp_category", &wrap_upnp_category); + def("get_http_category", &wrap_http_category); + def("get_socks_category", &wrap_socks_category); + def("get_bdecode_category", &wrap_bdecode_category); #if TORRENT_USE_I2P - def("get_i2p_category", &i2p_category, return_existing()); + def("get_i2p_category", &wrap_i2p_category); #endif #endif // TORRENT_NO_DEPRECATE - def("generic_category", &boost::system::generic_category, return_existing()); + def("generic_category", &wrap_generic_category); - def("system_category", &boost::system::system_category, return_existing()); + def("system_category", &wrap_system_category); } diff --git a/bindings/python/test.py b/bindings/python/test.py index 5ec99ec47..dad26322a 100644 --- a/bindings/python/test.py +++ b/bindings/python/test.py @@ -466,6 +466,22 @@ class test_session(unittest.TestCase): default = lt.default_settings() print(default) +class test_error_code(unittest.TestCase): + + def test_error_code(self): + + a = lt.error_code(); + a = lt.error_code(10, lt.libtorrent_category()) + self.assertEqual(a.category().name(), 'libtorrent') + + self.assertEqual(lt.libtorrent_category().name(), 'libtorrent') + self.assertEqual(lt.upnp_category().name(), 'upnp') + self.assertEqual(lt.http_category().name(), 'http') + self.assertEqual(lt.socks_category().name(), 'socks') + self.assertEqual(lt.bdecode_category().name(), 'bdecode') + self.assertEqual(lt.generic_category().name(), 'generic') + self.assertEqual(lt.system_category().name(), 'system') + if __name__ == '__main__': print(lt.__version__) shutil.copy(os.path.join('..', '..', 'test', 'test_torrents', 'url_seed_multi.torrent'), '.') diff --git a/src/bdecode.cpp b/src/bdecode.cpp index 1cb58dd19..644647370 100644 --- a/src/bdecode.cpp +++ b/src/bdecode.cpp @@ -172,7 +172,7 @@ namespace libtorrent const char* bdecode_error_category::name() const BOOST_SYSTEM_NOEXCEPT { - return "bdecode error"; + return "bdecode"; } std::string bdecode_error_category::message(int ev) const BOOST_SYSTEM_NOEXCEPT diff --git a/src/error_code.cpp b/src/error_code.cpp index f2e02e927..1e53324e4 100644 --- a/src/error_code.cpp +++ b/src/error_code.cpp @@ -290,7 +290,7 @@ namespace libtorrent struct TORRENT_EXPORT http_error_category : boost::system::error_category { virtual const char* name() const BOOST_SYSTEM_NOEXCEPT - { return "http error"; } + { return "http"; } virtual std::string message(int ev) const BOOST_SYSTEM_NOEXCEPT { std::string ret; diff --git a/src/socks5_stream.cpp b/src/socks5_stream.cpp index 75d831521..bed7d39cf 100644 --- a/src/socks5_stream.cpp +++ b/src/socks5_stream.cpp @@ -48,7 +48,7 @@ namespace libtorrent struct socks_error_category : boost::system::error_category { virtual const char* name() const BOOST_SYSTEM_NOEXCEPT - { return "socks error"; } + { return "socks"; } virtual std::string message(int ev) const BOOST_SYSTEM_NOEXCEPT { static char const* messages[] = diff --git a/src/upnp.cpp b/src/upnp.cpp index babca8c57..01dca0124 100644 --- a/src/upnp.cpp +++ b/src/upnp.cpp @@ -1159,7 +1159,7 @@ struct upnp_error_category : boost::system::error_category { virtual const char* name() const BOOST_SYSTEM_NOEXCEPT { - return "UPnP error"; + return "upnp"; } virtual std::string message(int ev) const BOOST_SYSTEM_NOEXCEPT diff --git a/test/test_bdecode.cpp b/test/test_bdecode.cpp index c33c7d946..2bcc1721a 100644 --- a/test/test_bdecode.cpp +++ b/test/test_bdecode.cpp @@ -338,7 +338,7 @@ TORRENT_TEST(bdecode_error) { error_code ec(bdecode_errors::overflow); TEST_EQUAL(ec.message(), "integer overflow"); - TEST_EQUAL(ec.category().name(), std::string("bdecode error")); + TEST_EQUAL(ec.category().name(), std::string("bdecode")); ec.assign(5434, get_bdecode_category()); TEST_EQUAL(ec.message(), "Unknown error"); }