moved files around

lbrynet/tests/integration/test_wallet.py

@@ -1,73 +0,0 @@
-import time
-import shutil
-import logging
-import tempfile
-from binascii import hexlify
-
-from twisted.internet import defer, reactor, threads
-from twisted.trial import unittest
-from orchstr8.services import BaseLbryServiceStack
-
-from lbrynet.core.call_later_manager import CallLaterManager
-from lbrynet.database.storage import SQLiteStorage
-
-from lbrynet.wallet.basecoin import CoinRegistry
-from lbrynet.wallet.manager import WalletManager
-from lbrynet.wallet.constants import COIN
-
-
-class WalletTestCase(unittest.TestCase):
-
-    VERBOSE = False
-
-    def setUp(self):
-        logging.getLogger('lbrynet').setLevel(logging.INFO)
-        self.data_path = tempfile.mkdtemp()
-        self.db = SQLiteStorage(self.data_path)
-        CallLaterManager.setup(reactor.callLater)
-        self.service = BaseLbryServiceStack(self.VERBOSE)
-        return self.service.startup()
-
-    def tearDown(self):
-        CallLaterManager.stop()
-        shutil.rmtree(self.data_path, ignore_errors=True)
-        return self.service.shutdown()
-
-    @property
-    def lbrycrd(self):
-        return self.service.lbrycrd
-
-
-class StartupTests(WalletTestCase):
-
-    VERBOSE = True
-
-    @defer.inlineCallbacks
-    def test_balance(self):
-        coin_id = 'lbc_regtest'
-        manager = WalletManager.from_config({
-            'ledgers': {coin_id: {'default_servers': [('localhost', 50001)]}}
-        })
-        wallet = manager.create_wallet(None, CoinRegistry.get_coin_class(coin_id))
-        ledger = manager.ledgers.values()[0]
-        account = wallet.default_account
-        coin = account.coin
-        yield manager.start_ledgers()
-        address = account.get_least_used_receiving_address()
-        sendtxid = yield self.lbrycrd.sendtoaddress(address, 2.5)
-        yield self.lbrycrd.generate(1)
-        #yield manager.wallet.history.on_transaction.
-        yield threads.deferToThread(time.sleep, 10)
-        utxo = account.get_unspent_utxos()[0]
-        address2 = account.get_least_used_receiving_address()
-        tx_class = ledger.transaction_class
-        Input, Output = tx_class.input_class, tx_class.output_class
-        tx = tx_class()\
-            .add_inputs([Input.spend(utxo)])\
-            .add_outputs([Output.pay_pubkey_hash(2.49*COIN, coin.address_to_hash160(address2))])\
-            .sign(account)
-
-        yield self.lbrycrd.decoderawtransaction(hexlify(tx.raw))
-        yield self.lbrycrd.sendrawtransaction(hexlify(tx.raw))
-
-        yield manager.stop_ledgers()

lbrynet/tests/integration/wallet/test_basic_transactions.py

@@ -0,0 +1,61 @@
+import asyncio
+from binascii import hexlify
+from orchstr8.testcase import IntegrationTestCase
+from torba.constants import COIN
+
+
+class StartupTests(IntegrationTestCase):
+
+    VERBOSE = True
+
+    async def test_balance(self):
+        account = self.wallet.default_account
+        coin = account.coin
+        ledger = self.manager.ledgers[coin.ledger_class]
+        address = account.get_least_used_receiving_address()
+        sendtxid = await self.lbrycrd.sendtoaddress(address.decode(), 2.5)
+        await self.lbrycrd.generate(1)
+        await ledger.on_transaction.where(
+            lambda tx: tx.id.decode() == sendtxid
+        )
+        utxo = account.get_unspent_utxos()[0]
+        address2 = account.get_least_used_receiving_address()
+        tx_class = ledger.transaction_class
+        Input, Output = tx_class.input_class, tx_class.output_class
+        tx = tx_class() \
+            .add_inputs([Input.spend(utxo)]) \
+            .add_outputs([Output.pay_pubkey_hash(int(2.49*COIN), coin.address_to_hash160(address2))]) \
+            .sign(account)
+        await self.lbrycrd.decoderawtransaction(hexlify(tx.raw))
+        sendtxid = await self.lbrycrd.sendrawtransaction(hexlify(tx.raw))
+        await self.lbrycrd.generate(1)
+        await ledger.on_transaction.where(
+            lambda tx: tx.id.decode() == sendtxid
+        )
+
+
+class AbandonClaimLookup(IntegrationTestCase):
+
+    async def skip_test_abandon_claim(self):
+        address = yield self.lbry.wallet.get_least_used_address()
+        yield self.lbrycrd.sendtoaddress(address, 0.0003 - 0.0000355)
+        yield self.lbrycrd.generate(1)
+        yield self.lbry.wallet.update_balance()
+        yield threads.deferToThread(time.sleep, 5)
+        print(self.lbry.wallet.get_balance())
+        claim = yield self.lbry.wallet.claim_new_channel('@test', 0.000096)
+        yield self.lbrycrd.generate(1)
+        print('='*10 + 'CLAIM' + '='*10)
+        print(claim)
+        yield self.lbrycrd.decoderawtransaction(claim['tx'])
+        abandon = yield self.lbry.wallet.abandon_claim(claim['claim_id'], claim['txid'], claim['nout'])
+        print('='*10 + 'ABANDON' + '='*10)
+        print(abandon)
+        yield self.lbrycrd.decoderawtransaction(abandon['tx'])
+        yield self.lbrycrd.generate(1)
+        yield self.lbrycrd.getrawtransaction(abandon['txid'])
+
+        yield self.lbry.wallet.update_balance()
+        yield threads.deferToThread(time.sleep, 5)
+        print('='*10 + 'FINAL BALANCE' + '='*10)
+        print(self.lbry.wallet.get_balance())

scripts/publish_performance.py

@@ -0,0 +1,133 @@
+import os
+import time
+from random import Random
+
+from pyqtgraph.Qt import QtCore, QtGui
+app = QtGui.QApplication([])
+from qtreactor import pyqt4reactor
+pyqt4reactor.install()
+
+from twisted.internet import defer, task, threads
+from orchstr8.services import LbryServiceStack
+
+import pyqtgraph as pg
+
+
+class Profiler:
+    pens = [
+        (230, 25, 75),   # red
+        (60, 180, 75),   # green
+        (255, 225, 25),  # yellow
+        (0, 130, 200),   # blue
+        (245, 130, 48),  # orange
+        (145, 30, 180),  # purple
+        (70, 240, 240),  # cyan
+        (240, 50, 230),  # magenta
+        (210, 245, 60),  # lime
+        (250, 190, 190),  # pink
+        (0, 128, 128),   # teal
+    ]
+
+    def __init__(self, graph=None):
+        self.times = {}
+        self.graph = graph
+
+    def start(self, name):
+        if name in self.times:
+            self.times[name]['start'] = time.time()
+        else:
+            self.times[name] = {
+                'start': time.time(),
+                'data': [],
+                'plot': self.graph.plot(
+                    pen=self.pens[len(self.times)],
+                    symbolBrush=self.pens[len(self.times)],
+                    name=name
+                )
+            }
+
+    def stop(self, name):
+        elapsed = time.time() - self.times[name]['start']
+        self.times[name]['start'] = None
+        self.times[name]['data'].append(elapsed)
+
+    def draw(self):
+        for plot in self.times.values():
+            plot['plot'].setData(plot['data'])
+
+
+class ThePublisherOfThings:
+
+    def __init__(self, blocks=100, txns_per_block=100, seed=2015, start_blocks=110):
+        self.blocks = blocks
+        self.txns_per_block = txns_per_block
+        self.start_blocks = start_blocks
+        self.random = Random(seed)
+        self.profiler = Profiler()
+        self.service = LbryServiceStack(verbose=True, profiler=self.profiler)
+        self.publish_file = None
+
+    @defer.inlineCallbacks
+    def start(self):
+        yield self.service.startup(
+            after_lbrycrd_start=lambda: self.service.lbrycrd.generate(1010)
+        )
+        wallet = self.service.lbry.wallet
+        address = yield wallet.get_least_used_address()
+        sendtxid = yield self.service.lbrycrd.sendtoaddress(address, 100)
+        yield self.service.lbrycrd.generate(1)
+        yield wallet.wait_for_tx_in_wallet(sendtxid)
+        yield wallet.update_balance()
+        self.publish_file = os.path.join(self.service.lbry.download_directory, 'the_file')
+        with open(self.publish_file, 'w') as _publish_file:
+            _publish_file.write('message that will be heard around the world\n')
+        yield threads.deferToThread(time.sleep, 0.5)
+
+    @defer.inlineCallbacks
+    def generate_publishes(self):
+
+        win = pg.GraphicsLayoutWidget(show=True)
+        win.setWindowTitle('orchstr8: performance monitor')
+        win.resize(1800, 600)
+
+        p4 = win.addPlot()
+        p4.addLegend()
+        p4.setDownsampling(mode='peak')
+        p4.setClipToView(True)
+        self.profiler.graph = p4
+
+        for block in range(self.blocks):
+            for txn in range(self.txns_per_block):
+                name = 'block{}txn{}'.format(block, txn)
+                self.profiler.start('total')
+                yield self.service.lbry.daemon.jsonrpc_publish(
+                    name=name, bid=self.random.randrange(1, 5)/1000.0,
+                    file_path=self.publish_file, metadata={
+                        "description": "Some interesting content",
+                        "title": "My interesting content",
+                        "author": "Video shot by me@example.com",
+                        "language": "en", "license": "LBRY Inc", "nsfw": False
+                    }
+                )
+                self.profiler.stop('total')
+                self.profiler.draw()
+
+            yield self.service.lbrycrd.generate(1)
+
+    def stop(self):
+        return self.service.shutdown(cleanup=False)
+
+
+@defer.inlineCallbacks
+def generate_publishes(_):
+    pub = ThePublisherOfThings(50, 10)
+    yield pub.start()
+    yield pub.generate_publishes()
+    yield pub.stop()
+    print('lbrycrd: {}'.format(pub.service.lbrycrd.data_path))
+    print('lbrynet: {}'.format(pub.service.lbry.data_path))
+    print('lbryumserver: {}'.format(pub.service.lbryumserver.data_path))
+
+
+if __name__ == "__main__":
+    task.react(generate_publishes)