Merge pull request #3979 from xoriole/devel_to_next_7.1.1

Devel to next for Tribler 7.1.1 release

Tribler/Core/APIImplementation/LaunchManyCore.py

@@ -831,11 +831,12 @@ def resume_download(self, filename, setupDelay=0):
         if tdef and dscfg:
             if dscfg.get_dest_dir() != '':  # removed torrent ignoring
                 try:
-                    if not self.download_exists(tdef.get_infohash()):
-                        self.add(tdef, dscfg, pstate, setupDelay=setupDelay)
-                    else:
+                    if self.download_exists(tdef.get_infohash()):
                         self._logger.info("tlm: not resuming checkpoint because download has already been added")
-
+                    elif dscfg.get_credit_mining() and not self.session.config.get_credit_mining_enabled():
+                        self._logger.info("tlm: not resuming checkpoint since token mining is disabled")
+                    else:
+                        self.add(tdef, dscfg, pstate, setupDelay=setupDelay)
                 except Exception as e:
                     self._logger.exception("tlm: load check_point: exception while adding download %s", tdef)
             else:

Tribler/Core/CacheDB/sqlitecachedb.py

@@ -131,6 +131,9 @@ def _open_connection(self):
         if os.path.exists(shm_file) or os.path.exists(wal_file):
             self.do_quick_integrity_check()
 
+        # Enable memory map in sqlite (256MB)
+        cursor.execute(u"PRAGMA mmap_size=268435456;")
+
         # apply pragma
         page_size, = next(cursor.execute(u"PRAGMA page_size"))
         if page_size < 8192:

Tribler/Core/Config/config.spec

@@ -65,8 +65,8 @@ directory = string(default='')
 enabled = boolean(default=True)
 port = integer(min=-1, max=65536, default=-1)
 proxy_type = integer(min=0, max=5, default=0)
-proxy_server = string(default='')
-proxy_auth = string(default='')
+proxy_server = string_list(default=list('', ''))
+proxy_auth = string_list(default=list('', ''))
 max_connections_download = integer(default=-1)
 max_download_rate = integer(default=0)
 max_upload_rate = integer(default=0)

Tribler/Core/Libtorrent/LibtorrentDownloadImpl.py

@@ -876,6 +876,20 @@ def get_peerlist(self):
             peers.append(peer_dict)
         return peers
 
+    def get_num_connected_seeds_peers(self):
+        """ Returns number of connected seeders and leechers """
+        num_seeds = num_peers = 0
+        if not self.handle or not self.handle.is_valid():
+            return 0, 0
+
+        for peer_info in self.handle.get_peer_info():
+            if peer_info.flags & peer_info.seed:
+                num_seeds += 1
+            else:
+                num_peers += 1
+
+        return num_seeds, num_peers
+
     @checkHandleAndSynchronize(default={})
     def get_tracker_status(self):
         # Make sure all trackers are in the tracker_status dict

Tribler/Core/Modules/payout_manager.py

@@ -35,7 +35,7 @@ def on_nodes(nodes):
 
         if total_bytes >= 1024 * 1024:  # Do at least 1MB payouts
             self.logger.info("Doing direct payout to %s (%d bytes)", mid.encode('hex'), total_bytes)
-            self.dht.connect_peer(mid).addCallback(on_nodes)
+            self.dht.connect_peer(mid).addCallbacks(on_nodes, lambda _: on_nodes([]))
 
         # Remove the outstanding bytes; otherwise we will payout again
         self.tribler_peers.pop(mid, None)

Tribler/Core/Modules/restapi/channels/channels_torrents_endpoint.py

@@ -1,4 +1,5 @@
 import base64
+from twisted.web.error import SchemeNotSupported
 
 from twisted.internet.defer import Deferred
 from twisted.web import http
@@ -201,7 +202,7 @@ def _on_added(added):
             request.finish()
 
         def _on_add_failed(failure):
-            failure.trap(ValueError, DuplicateTorrentFileError)
+            failure.trap(ValueError, DuplicateTorrentFileError, SchemeNotSupported)
             self._logger.exception(failure.value)
             request.write(BaseChannelsEndpoint.return_500(self, request, failure.value))
             request.finish()

Tribler/Core/Modules/restapi/downloads_endpoint.py

@@ -212,6 +212,7 @@ def render_GET(self, request):
                 tracker_info.append({"url": url, "peers": url_info[0], "status": url_info[1]})
 
             num_seeds, num_peers = state.get_num_seeds_peers()
+            num_connected_seeds, num_connected_peers = download.get_num_connected_seeds_peers()
 
             download_json = {"name": tdef.get_name_utf8(), "progress": state.get_progress(),
                              "infohash": tdef.get_infohash().encode('hex'),
@@ -220,6 +221,7 @@ def render_GET(self, request):
                              "status": dlstatus_strings[state.get_status()],
                              "size": tdef.get_length(), "eta": state.get_eta(),
                              "num_peers": num_peers, "num_seeds": num_seeds,
+                             "num_connected_peers": num_connected_peers, "num_connected_seeds": num_connected_seeds,
                              "total_up": state.get_total_transferred(UPLOAD),
                              "total_down": state.get_total_transferred(DOWNLOAD), "ratio": state.get_seeding_ratio(),
                              "trackers": tracker_info, "hops": download.get_hops(),

Tribler/Core/Modules/restapi/wallets_endpoint.py

@@ -36,6 +36,9 @@ def render_GET(self, request):
                     "wallets": [{
                         "created": True,
                         "name": "Bitcoin",
+                        "unlocked": True,
+                        "precision": 8,
+                        "min_unit": 100000,
                         "address": "17AVS7n3zgBjPq1JT4uVmEXdcX3vgB2wAh",
                         "balance": {
                             "available": 0.000126,
@@ -54,7 +57,8 @@ def render_GET(self, request):
                 'unlocked': wallet.unlocked,
                 'address': wallet.get_address(),
                 'name': wallet.get_name(),
-                'precision': wallet.precision()
+                'precision': wallet.precision(),
+                'min_unit': wallet.min_unit()
             }
             balance_deferreds.append(wallet.get_balance().addCallback(
                 lambda balance, wid=wallet_id: (wid, balance)))

Tribler/Core/Session.py

@@ -188,6 +188,10 @@ def unhandled_error_observer(self, event):
                 self._logger.error("Could not send data: socket is busy.")
                 return
 
+            if 'socket.error' in text and '[Errno 10053]' in text:
+                self._logger.error("An established connection was aborted by the software in your host machine.")
+                return
+
             if 'socket.error' in text and '[Errno 10054]' in text:
                 self._logger.error("Connection forcibly closed by the remote host.")
                 return

Tribler/Test/Community/Market/test_community.py

@@ -1,5 +1,8 @@
+from twisted.python.failure import Failure
+
 from Tribler.Core.Modules.wallet.dummy_wallet import DummyWallet1, DummyWallet2
 from Tribler.Core.Modules.wallet.tc_wallet import TrustchainWallet
+from Tribler.Test.Core.base_test import MockObject
 from Tribler.community.market.block import MarketBlock
 from Tribler.community.market.community import MarketCommunity, PingRequestCache
 from Tribler.community.market.core.assetamount import AssetAmount
@@ -271,7 +274,10 @@ def test_address_resolv_fail(self):
         """
         yield self.introduce_nodes()
 
-        self.nodes[1].overlay.get_address_for_trader = lambda *_: succeed(None)
+        # Clean the mid register of node 1 and make sure DHT peer connection fails
+        self.nodes[1].overlay.mid_register = {}
+        self.nodes[1].overlay.dht = MockObject()
+        self.nodes[1].overlay.dht.connect_peer = lambda *_: fail(Failure(RuntimeError()))
 
         ask_order = yield self.nodes[0].overlay.create_ask(
             AssetPair(AssetAmount(1, 'DUM1'), AssetAmount(1, 'DUM2')), 3600)

Tribler/Test/Core/Libtorrent/test_libtorrent_download_impl.py

@@ -308,6 +308,32 @@ def mocked_set_share_mode(val):
         self.libtorrent_download_impl.set_share_mode(True)
         self.assertTrue(mocked_set_share_mode.called)
 
+    def test_get_num_connected_seeds_peers(self):
+        """
+        Test whether connected peers and seeds are correctly returned
+        """
+        def get_peer_info(seeders, leechers):
+            peer_info = []
+            for _ in xrange(seeders):
+                seeder = MockObject()
+                seeder.flags = 140347   # some value where seed flag(1024) is true
+                seeder.seed = 1024
+                peer_info.append(seeder)
+            for _ in xrange(leechers):
+                leecher = MockObject()
+                leecher.flags = 131242  # some value where seed flag(1024) is false
+                leecher.seed = 1024
+                peer_info.append(leecher)
+            return peer_info
+
+        mock_seeders = 15
+        mock_leechers = 6
+        self.libtorrent_download_impl.handle.get_peer_info = lambda: get_peer_info(mock_seeders, mock_leechers)
+
+        num_seeds, num_peers = self.libtorrent_download_impl.get_num_connected_seeds_peers()
+        self.assertEqual(num_seeds, mock_seeders, "Expected seeders differ")
+        self.assertEqual(num_peers, mock_leechers, "Expected peers differ")
+
     def test_set_priority(self):
         """
         Test whether setting the priority calls the right methods in LibtorrentDownloadImpl

Tribler/Test/Core/test_session.py

@@ -135,6 +135,7 @@ def on_tribler_exception(_):
         self.session.unhandled_error_observer({'isError': True, 'log_failure': 'socket.error: [Errno 113]'})
         self.session.unhandled_error_observer({'isError': True, 'log_failure': 'socket.error: [Errno 51]'})
         self.session.unhandled_error_observer({'isError': True, 'log_failure': 'socket.error: [Errno 16]'})
+        self.session.unhandled_error_observer({'isError': True, 'log_failure': 'socket.error: [Errno 10053]'})
         self.session.unhandled_error_observer({'isError': True, 'log_failure': 'socket.error: [Errno 10054]'})
         self.session.unhandled_error_observer({'isError': True,
                                                'log_failure': 'socket.error: [Errno %s]' % SOCKET_BLOCK_ERRORCODE})

Tribler/community/market/community.py

@@ -218,7 +218,11 @@ def on_peers(peers):
                 self.update_ip(trader_id, peers[0].address)
                 deferred.callback(peers[0].address)
 
-        self.dht.connect_peer(str(trader_id).decode('hex')).addCallback(on_peers)
+        def on_dht_error(failure):
+            self._logger.warning("Unable to get address for trader %s", trader_id)
+            deferred.errback(failure)
+
+        self.dht.connect_peer(str(trader_id).decode('hex')).addCallbacks(on_peers, on_dht_error)
 
         return deferred
 
@@ -832,7 +836,8 @@ def on_peer_address(address):
             self.endpoint.send(address, packet)
 
         def get_address():
-            self.get_address_for_trader(recipient_order_id.trader_id).addCallback(on_peer_address)
+            err_handler = lambda _: on_peer_address(None)
+            self.get_address_for_trader(recipient_order_id.trader_id).addCallbacks(on_peer_address, err_handler)
 
         reactor.callFromThread(get_address)
 
@@ -902,7 +907,9 @@ def on_peer_address(address):
         # Fetch the address of the target peer (we are not guaranteed to know it at this point since we might have
         # received the order indirectly)
         def get_address():
-            self.get_address_for_trader(propose_trade.recipient_order_id.trader_id).addCallback(on_peer_address)
+            err_handler = lambda _: on_peer_address(None)
+            self.get_address_for_trader(propose_trade.recipient_order_id.trader_id)\
+                .addCallbacks(on_peer_address, err_handler)
 
         reactor.callFromThread(get_address)
 

Tribler/community/triblertunnel/community.py

@@ -38,8 +38,8 @@ def __init__(self, *args, **kwargs):
         num_random_slots = kwargs.pop('random_slots', 5)
         self.bandwidth_wallet = kwargs.pop('bandwidth_wallet', None)
         socks_listen_ports = kwargs.pop('socks_listen_ports', None)
-        self.exitnode_cache = kwargs.pop('exitnode_cache', (self.tribler_session.config.get_state_dir()
-                                                            if self.tribler_session else '') + 'exitnode_cache.dat')
+        state_path = self.tribler_session.config.get_state_dir() if self.tribler_session else ''
+        self.exitnode_cache = kwargs.pop('exitnode_cache', os.path.join(state_path, 'exitnode_cache.dat'))
         super(TriblerTunnelCommunity, self).__init__(*args, **kwargs)
         self._use_main_thread = True
 

TriblerGUI/dialogs/newmarketorderdialog.py

@@ -10,14 +10,19 @@ class NewMarketOrderDialog(DialogContainer):
 
     button_clicked = pyqtSignal(int)
 
-    def __init__(self, parent, is_ask, asset1_type, asset2_type):
+    def __init__(self, parent, is_ask, asset1_type, asset2_type, wallets):
         DialogContainer.__init__(self, parent)
 
         self.is_ask = is_ask
         self.price = 0.0
         self.price_type = asset2_type
         self.quantity = -1
         self.quantity_type = asset1_type
+        self.wallets = wallets
+
+        # These asset amount values are only set when the order has been verified on the GUI side
+        self.asset1_amount = 0
+        self.asset2_amount = 0
 
         uic.loadUi(get_ui_file_path('newmarketorderdialog.ui'), self.dialog_widget)
 
@@ -40,19 +45,47 @@ def __init__(self, parent, is_ask, asset1_type, asset2_type):
     def on_create_clicked(self):
         # Validate user input
         try:
-            self.quantity = int(self.dialog_widget.order_quantity_input.text())
+            self.quantity = float(self.dialog_widget.order_quantity_input.text())
         except ValueError:
-            self.dialog_widget.error_text_label.setText("The volume must be a valid whole number.")
+            self.dialog_widget.error_text_label.setText("The quantity must be a valid number.")
             self.dialog_widget.error_text_label.show()
             return
 
         try:
             self.price = float(self.dialog_widget.order_price_input.text())
         except ValueError:
-            self.dialog_widget.error_text_label.setText("The price must be a valid whole number.")
+            self.dialog_widget.error_text_label.setText("The price must be a valid number.")
+            self.dialog_widget.error_text_label.show()
+            return
+
+        # Check whether we are trading at least the minimum amount of assets
+        asset1_amount = int(self.quantity * (10 ** self.wallets[self.quantity_type]["precision"]))
+        if asset1_amount < self.wallets[self.quantity_type]['min_unit']:
+            min_amount = float(self.wallets[self.quantity_type]["min_unit"]) / \
+                         float(10 ** self.wallets[self.quantity_type]["precision"])
+            self.dialog_widget.error_text_label.setText("The quantity is less than the minimum amount (%g %s)." %
+                                                        (min_amount, self.quantity_type))
+            self.dialog_widget.error_text_label.show()
+            return
+
+        price_num = self.price * (10 ** self.wallets[self.price_type]["precision"])
+        price_denom = float(10 ** self.wallets[self.quantity_type]["precision"])
+        price = price_num / price_denom
+        asset2_amount = int(asset1_amount * price)
+
+        # Check whether the price will lead to a trade where at least the minimum amount of assets are exchanged
+        if asset2_amount < self.wallets[self.price_type]['min_unit']:
+            min_amount = float(self.wallets[self.price_type]["min_unit"]) / \
+                         float(10 ** self.wallets[self.price_type]["precision"])
+            self.dialog_widget.error_text_label.setText("The price leads to a trade where less than the minimum amount "
+                                                        "of assets are exchanged (%g %s)." %
+                                                        (min_amount, self.price_type))
             self.dialog_widget.error_text_label.show()
             return
 
+        # Everything is valid, proceed with order creation
+        self.asset1_amount = asset1_amount
+        self.asset2_amount = asset2_amount
         self.update_window()
         self.button_clicked.emit(1)
 

TriblerGUI/qt_resources/newmarketorderdialog.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>538</width>
-    <height>232</height>
+    <height>248</height>
    </rect>
   </property>
   <property name="sizePolicy">
@@ -166,6 +166,9 @@ margin-top: 4px;
         <property name="styleSheet">
          <string notr="true"/>
         </property>
+        <property name="placeholderText">
+         <string>Quantity</string>
+        </property>
        </widget>
       </item>
       <item>
@@ -192,7 +195,11 @@ margin-top: 4px;
        </widget>
       </item>
       <item>
-       <widget class="QLineEdit" name="order_price_input"/>
+       <widget class="QLineEdit" name="order_price_input">
+        <property name="placeholderText">
+         <string>Price</string>
+        </property>
+       </widget>
       </item>
       <item>
        <spacer name="verticalSpacer_2">

TriblerGUI/widgets/downloadwidgetitem.py

@@ -65,8 +65,8 @@ def update_item(self):
             self.setText(3, "Streaming")
         else:
             self.setText(3, DLSTATUS_STRINGS[eval(self.download_info["status"])])
-        self.setText(4, str(self.download_info["num_seeds"]))
-        self.setText(5, str(self.download_info["num_peers"]))
+        self.setText(4, "%s (%s)" % (self.download_info["num_connected_seeds"], self.download_info["num_seeds"]))
+        self.setText(5, "%s (%s)" % (self.download_info["num_connected_peers"], self.download_info["num_peers"]))
         self.setText(6, format_speed(self.download_info["speed_down"]))
         self.setText(7, format_speed(self.download_info["speed_up"]))
         self.setText(8, "%.3f" % float(self.download_info["ratio"]))

TriblerGUI/widgets/home_recommended_item.py

@@ -76,6 +76,8 @@ def on_download_button_clicked(self):
         self.window().start_download_from_uri(self.download_uri)
 
     def update_with_torrent(self, torrent):
+        if not torrent:
+            return
         self.show_torrent = True
         self.torrent_info = torrent
         self.thumbnail_widget.initialize(torrent["name"], HOME_ITEM_FONT_SIZE)
@@ -87,6 +89,8 @@ def update_with_torrent(self, torrent):
         self.detail_label.setText("Size: " + format_size(torrent["size"]))
 
     def update_with_channel(self, channel):
+        if not channel:
+            return
         self.show_torrent = False
         self.channel_info = channel
         self.thumbnail_widget.initialize(channel["name"], HOME_ITEM_FONT_SIZE)