class DaemonServer(object): def __init__(self, analytics_manager=None): self._api = None self.root = None self.server_port = None self.analytics_manager = analytics_manager def _setup_server(self, use_auth): ui_path = os.path.join(conf.settings.ensure_data_dir(), "lbry-ui", "active") self.root = LBRYindex(ui_path) self._api = Daemon(self.root, self.analytics_manager) self.root.putChild("view", HostedEncryptedFile(self._api)) self.root.putChild("upload", EncryptedFileUpload(self._api)) self.root.putChild(conf.settings['API_ADDRESS'], self._api) lbrynet_server = server.Site(get_site_base(use_auth, self.root)) lbrynet_server.requestFactory = DaemonRequest try: self.server_port = reactor.listenTCP( conf.settings['api_port'], lbrynet_server, interface=conf.settings['api_host']) except error.CannotListenError: log.info('Daemon already running, exiting app') raise return defer.succeed(True) @defer.inlineCallbacks def start(self, use_auth): yield self._setup_server(use_auth) yield self._api.setup() @defer.inlineCallbacks def stop(self): if self._api is not None: yield self._api._shutdown() if self.server_port is not None: yield self.server_port.stopListening()
class CLIIntegrationTest(unittest.TestCase): USE_AUTH = False @defer.inlineCallbacks def setUp(self): skip = [ DATABASE_COMPONENT, BLOB_COMPONENT, HEADERS_COMPONENT, WALLET_COMPONENT, DHT_COMPONENT, HASH_ANNOUNCER_COMPONENT, STREAM_IDENTIFIER_COMPONENT, FILE_MANAGER_COMPONENT, PEER_PROTOCOL_SERVER_COMPONENT, REFLECTOR_COMPONENT, UPNP_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT, RATE_LIMITER_COMPONENT, PAYMENT_RATE_COMPONENT ] conf.initialize_settings(load_conf_file=False) conf.settings['use_auth_http'] = self.USE_AUTH conf.settings["components_to_skip"] = skip conf.settings.initialize_post_conf_load() Daemon.component_attributes = {} self.daemon = Daemon(analytics_manager=FakeAnalytics()) yield self.daemon.start_listening() def tearDown(self): return self.daemon._shutdown()
class CommandTestCase(IntegrationTestCase): timeout = 180 WALLET_MANAGER = LbryWalletManager async def setUp(self): await super().setUp() if self.VERBOSE: log.setLevel(logging.DEBUG) logging.getLogger('lbrynet.core').setLevel(logging.DEBUG) lbry_conf.settings = None lbry_conf.initialize_settings(load_conf_file=False) lbry_conf.settings['data_dir'] = self.stack.wallet.data_path lbry_conf.settings['lbryum_wallet_dir'] = self.stack.wallet.data_path lbry_conf.settings['download_directory'] = self.stack.wallet.data_path lbry_conf.settings['use_upnp'] = False lbry_conf.settings['reflect_uploads'] = False lbry_conf.settings['blockchain_name'] = 'lbrycrd_regtest' lbry_conf.settings['lbryum_servers'] = [('localhost', 50001)] lbry_conf.settings['known_dht_nodes'] = [] lbry_conf.settings.node_id = None await d2f(self.account.ensure_address_gap()) address = (await d2f( self.account.receiving.get_addresses(limit=1, only_usable=True)))[0] sendtxid = await self.blockchain.send_to_address(address, 10) await self.confirm_tx(sendtxid) await self.generate(5) def wallet_maker(component_manager): self.wallet_component = WalletComponent(component_manager) self.wallet_component.wallet_manager = self.manager self.wallet_component._running = True return self.wallet_component skip = [ #UPNP_COMPONENT, PEER_PROTOCOL_SERVER_COMPONENT, REFLECTOR_COMPONENT ] analytics_manager = FakeAnalytics() self.daemon = Daemon( analytics_manager, ComponentManager(analytics_manager=analytics_manager, skip_components=skip, wallet=wallet_maker, dht=FakeDHT, hash_announcer=FakeHashAnnouncerComponent, exchange_rate_manager=FakeExchangeRateComponent, upnp=FakeUPnP)) await d2f(self.daemon.setup()) self.daemon.wallet_manager = self.wallet_component.wallet_manager self.manager.old_db = self.daemon.storage async def tearDown(self): await super().tearDown() self.wallet_component._running = False await d2f(self.daemon._shutdown()) async def confirm_tx(self, txid): """ Wait for tx to be in mempool, then generate a block, wait for tx to be in a block. """ await self.on_transaction_id(txid) await self.generate(1) await self.on_transaction_id(txid) def d_confirm_tx(self, txid): return defer.Deferred.fromFuture( asyncio.ensure_future(self.confirm_tx(txid))) async def generate(self, blocks): """ Ask lbrycrd to generate some blocks and wait until ledger has them. """ await self.blockchain.generate(blocks) await self.ledger.on_header.where(self.blockchain.is_expected_block) def d_generate(self, blocks): return defer.Deferred.fromFuture( asyncio.ensure_future(self.generate(blocks))) def out(self, d): """ Converts Daemon API call results (dictionary) to JSON and then back to a dictionary. """ d.addCallback(lambda o: json.loads( jsonrpc_dumps_pretty(o, ledger=self.ledger))['result']) return d