class DaemonServer(object): def __init__(self, analytics_manager=None): self._daemon = None self.root = None self.server_port = None self.analytics_manager = analytics_manager def _setup_server(self, use_auth): self.root = IndexResource() self._daemon = Daemon(self.analytics_manager) self.root.putChild("", self._daemon) # TODO: DEPRECATED, remove this and just serve the API at the root self.root.putChild(conf.settings['API_ADDRESS'], self._daemon) lbrynet_server = 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._daemon.setup() def stop(self): if reactor.running: log.info("Stopping the reactor") reactor.fireSystemEvent("shutdown")
class DaemonServer(object): def __init__(self, analytics_manager=None): self._daemon = None self.root = None self.server_port = None self.analytics_manager = analytics_manager def _setup_server(self, use_auth): self.root = IndexResource() self._daemon = Daemon(self.analytics_manager) self.root.putChild("", self._daemon) # TODO: DEPRECATED, remove this and just serve the API at the root self.root.putChild(conf.settings['API_ADDRESS'], self._daemon) lbrynet_server = get_site_base(use_auth, self.root) 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._daemon.setup() def stop(self): if reactor.running: log.info("Stopping the reactor") reactor.fireSystemEvent("shutdown")
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 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