lbry-sdk/lbrynet/lbrynet_daemon/Daemon.py

2681 lines
94 KiB
Python
Raw Normal View History

import binascii
import logging.handlers
2016-06-03 09:45:46 +02:00
import mimetypes
2016-02-29 19:25:47 +01:00
import os
import random
import re
import base58
import requests
2017-01-02 20:52:24 +01:00
import urllib
import simplejson as json
2017-01-03 20:13:01 +01:00
import textwrap
from requests import exceptions as requests_exceptions
from decimal import Decimal
from twisted.web import server
2016-08-11 20:41:42 +02:00
from twisted.internet import defer, threads, error, reactor, task
from twisted.internet.task import LoopingCall
from twisted.python.failure import Failure
2016-02-29 19:25:47 +01:00
# TODO: importing this when internet is disabled raises a socket.gaierror
2016-06-28 08:06:04 +02:00
from lbryum.version import LBRYUM_VERSION as lbryum_version
from lbrynet import __version__ as lbrynet_version
from lbrynet import conf, reflector, analytics
2016-11-10 20:26:21 +01:00
from lbrynet.conf import LBRYCRD_WALLET, LBRYUM_WALLET, PTC_WALLET
from lbrynet.metadata.Fee import FeeValidator
from lbrynet.metadata.Metadata import verify_name_characters
2016-11-30 21:20:45 +01:00
from lbrynet.lbryfile.client.EncryptedFileDownloader import EncryptedFileSaverFactory
from lbrynet.lbryfile.client.EncryptedFileDownloader import EncryptedFileOpenerFactory
2016-09-27 20:18:16 +02:00
from lbrynet.lbryfile.client.EncryptedFileOptions import add_lbry_file_to_sd_identifier
from lbrynet.lbryfile.EncryptedFileMetadataManager import DBEncryptedFileMetadataManager
from lbrynet.lbryfile.StreamDescriptor import EncryptedFileStreamType
from lbrynet.lbryfilemanager.EncryptedFileManager import EncryptedFileManager
from lbrynet.lbrynet_daemon.UIManager import UIManager
from lbrynet.lbrynet_daemon.Downloader import GetStream
from lbrynet.lbrynet_daemon.Publisher import Publisher
from lbrynet.lbrynet_daemon.ExchangeRateManager import ExchangeRateManager
2016-09-22 03:36:06 +02:00
from lbrynet.lbrynet_daemon.auth.server import AuthJSONRPCServer
from lbrynet.core import log_support, utils, file_utils
2016-12-10 21:01:29 +01:00
from lbrynet.core import system_info
2016-11-30 21:20:45 +01:00
from lbrynet.core.StreamDescriptor import StreamDescriptorIdentifier, download_sd_blob
from lbrynet.core.StreamDescriptor import BlobStreamDescriptorReader
2016-10-22 01:12:38 +02:00
from lbrynet.core.Session import Session
from lbrynet.core.Wallet import LBRYumWallet, SqliteStorage
from lbrynet.core.looping_call_manager import LoopingCallManager
from lbrynet.core.server.BlobRequestHandler import BlobRequestHandlerFactory
from lbrynet.core.server.ServerProtocol import ServerProtocolFactory
from lbrynet.core.Error import InsufficientFundsError
2016-06-07 10:19:51 +02:00
log = logging.getLogger(__name__)
2016-06-28 20:28:59 +02:00
INITIALIZING_CODE = 'initializing'
LOADING_DB_CODE = 'loading_db'
2017-01-03 20:13:01 +01:00
LOADING_WALLET_CODE = 'loading_wallet'
LOADING_FILE_MANAGER_CODE = 'loading_file_manager'
LOADING_SERVER_CODE = 'loading_server'
STARTED_CODE = 'started'
2016-05-11 08:47:33 +02:00
WAITING_FOR_FIRST_RUN_CREDITS = 'waiting_for_credits'
STARTUP_STAGES = [
2017-01-03 20:13:01 +01:00
(INITIALIZING_CODE, 'Initializing'),
(LOADING_DB_CODE, 'Loading databases'),
(LOADING_WALLET_CODE, 'Catching up with the blockchain'),
(LOADING_FILE_MANAGER_CODE, 'Setting up file manager'),
(LOADING_SERVER_CODE, 'Starting lbrynet'),
(STARTED_CODE, 'Started lbrynet'),
(WAITING_FOR_FIRST_RUN_CREDITS, 'Waiting for first run credits'),
]
# TODO: make this consistent with the stages in Downloader.py
DOWNLOAD_METADATA_CODE = 'downloading_metadata'
DOWNLOAD_TIMEOUT_CODE = 'timeout'
DOWNLOAD_RUNNING_CODE = 'running'
DOWNLOAD_STOPPED_CODE = 'stopped'
STREAM_STAGES = [
2017-01-04 23:10:36 +01:00
(INITIALIZING_CODE, 'Initializing'),
2017-01-03 20:13:01 +01:00
(DOWNLOAD_METADATA_CODE, 'Downloading metadata'),
(DOWNLOAD_RUNNING_CODE, 'Started %s, got %s/%s blobs, stream status: %s'),
(DOWNLOAD_STOPPED_CODE, 'Paused stream'),
(DOWNLOAD_TIMEOUT_CODE, 'Stream timed out')
]
CONNECTION_STATUS_CONNECTED = 'connected'
CONNECTION_STATUS_VERSION_CHECK = 'version_check'
CONNECTION_STATUS_NETWORK = 'network_connection'
CONNECTION_MESSAGES = {
CONNECTION_STATUS_CONNECTED: 'No connection problems detected',
CONNECTION_STATUS_VERSION_CHECK: "There was a problem checking for updates on github",
CONNECTION_STATUS_NETWORK: "Your internet connection appears to have been interrupted",
}
2016-12-19 19:27:45 +01:00
PENDING_ID = "not set"
SHORT_ID_LEN = 20
2016-10-19 01:09:35 +02:00
class Checker:
"""The looping calls the daemon runs"""
INTERNET_CONNECTION = 'internet_connection_checker'
VERSION = 'version_checker'
2017-01-03 20:13:01 +01:00
CONNECTION_STATUS = 'connection_status_checker'
2016-10-19 01:09:35 +02:00
PENDING_CLAIM = 'pending_claim_checker'
class FileID:
"""The different ways a file can be identified"""
NAME = 'name'
SD_HASH = 'sd_hash'
FILE_NAME = 'file_name'
# TODO add login credentials in a conf file
# TODO alert if your copy of a lbry file is out of date with the name record
2016-12-19 19:27:45 +01:00
class NoValidSearch(Exception):
pass
class CheckInternetConnection(object):
def __init__(self, daemon):
self.daemon = daemon
def __call__(self):
self.daemon.connected_to_internet = utils.check_connection()
class CheckRemoteVersions(object):
def __init__(self, daemon):
self.daemon = daemon
def __call__(self):
d = threads.deferToThread(self._get_lbrynet_version)
d.addErrback(self._trap_and_log_error, 'lbrynet')
2017-02-02 17:31:31 +01:00
d.addCallback(lambda _: threads.deferToThread(self._get_lbryum_version))
d.addErrback(self._trap_and_log_error, 'lbryum')
d.addErrback(log.fail(), 'Failure checking versions on github')
def _trap_and_log_error(self, err, module_checked):
# KeyError is thrown by get_version_from_github
# It'd be better to catch the error before trying to parse the response
err.trap(requests_exceptions.RequestException, KeyError)
if err.check(requests_exceptions.RequestException, KeyError):
log.warning("Failed to check latest %s version from github", module_checked)
def _get_lbryum_version(self):
self.daemon.git_lbryum_version = get_lbryum_version_from_github()
log.info(
"remote lbryum %s > local lbryum %s = %s",
self.daemon.git_lbryum_version, lbryum_version,
utils.version_is_greater_than(self.daemon.git_lbryum_version, lbryum_version)
)
def _get_lbrynet_version(self):
self.daemon.git_lbrynet_version = get_lbrynet_version_from_github()
log.info(
"remote lbrynet %s > local lbrynet %s = %s",
self.daemon.git_lbrynet_version, lbrynet_version,
utils.version_is_greater_than(self.daemon.git_lbrynet_version, lbryum_version)
)
2016-10-11 19:50:44 +02:00
class AlwaysSend(object):
def __init__(self, value_generator, *args, **kwargs):
self.value_generator = value_generator
self.args = args
self.kwargs = kwargs
def __call__(self):
d = defer.maybeDeferred(self.value_generator, *self.args, **self.kwargs)
d.addCallback(lambda v: (True, v))
return d
2017-01-20 19:47:53 +01:00
# If an instance has a lot of blobs, this call might get very expensive.
# For reflector, with 50k blobs, it definitely has an impact on the first run
# But doesn't seem to impact performance after that.
@defer.inlineCallbacks
2016-10-05 21:45:17 +02:00
def calculate_available_blob_size(blob_manager):
blob_hashes = yield blob_manager.get_all_verified_blobs()
2017-01-20 18:35:34 +01:00
blobs = yield defer.DeferredList([blob_manager.get_blob(b, True) for b in blob_hashes])
defer.returnValue(sum(b.length for success, b in blobs if success and b.length))
class Daemon(AuthJSONRPCServer):
"""
2016-03-24 03:27:48 +01:00
LBRYnet daemon, a jsonrpc interface to lbry functions
"""
2017-01-17 04:23:20 +01:00
def __init__(self, root, analytics_manager, upload_logs_on_shutdown=True):
AuthJSONRPCServer.__init__(self, conf.settings['use_auth_http'])
reactor.addSystemEventTrigger('before', 'shutdown', self._shutdown)
2017-01-17 04:23:20 +01:00
self.upload_logs_on_shutdown = upload_logs_on_shutdown
self.allowed_during_startup = [
'stop', 'status', 'version',
# delete these once they are fully removed:
'is_running', 'is_first_run', 'get_time_behind_blockchain', 'daemon_status',
'get_start_notice',
]
last_version = {'last_version': {'lbrynet': lbrynet_version, 'lbryum': lbryum_version}}
conf.settings.update(last_version)
2017-01-17 04:23:20 +01:00
self.db_dir = conf.settings['data_dir']
self.download_directory = conf.settings['download_directory']
self.created_data_dir = False
if not os.path.exists(self.db_dir):
os.mkdir(self.db_dir)
self.created_data_dir = True
2017-01-17 04:23:20 +01:00
if conf.settings['BLOBFILES_DIR'] == "blobfiles":
self.blobfile_dir = os.path.join(self.db_dir, "blobfiles")
else:
2017-01-17 04:23:20 +01:00
log.info("Using non-default blobfiles directory: %s", conf.settings['BLOBFILES_DIR'])
self.blobfile_dir = conf.settings['BLOBFILES_DIR']
self.run_on_startup = conf.settings['run_on_startup']
self.data_rate = conf.settings['data_rate']
self.max_key_fee = conf.settings['max_key_fee']
self.max_upload = conf.settings['max_upload']
self.max_download = conf.settings['max_download']
self.upload_log = conf.settings['upload_log']
self.search_timeout = conf.settings['search_timeout']
self.download_timeout = conf.settings['download_timeout']
self.max_search_results = conf.settings['max_search_results']
self.run_reflector_server = conf.settings['run_reflector_server']
self.wallet_type = conf.settings['wallet']
self.delete_blobs_on_remove = conf.settings['delete_blobs_on_remove']
self.peer_port = conf.settings['peer_port']
self.reflector_port = conf.settings['reflector_port']
self.dht_node_port = conf.settings['dht_node_port']
self.use_upnp = conf.settings['use_upnp']
self.cache_time = conf.settings['cache_time']
self.startup_status = STARTUP_STAGES[0]
self.connected_to_internet = True
2017-01-03 20:13:01 +01:00
self.connection_status_code = None
2016-07-30 04:36:30 +02:00
self.git_lbrynet_version = None
self.git_lbryum_version = None
self.platform = None
self.first_run = None
self.log_file = conf.settings.get_log_filename()
self.current_db_revision = 2
self.db_revision_file = conf.settings.get_db_revision_filename()
self.session = None
self.uploaded_temp_files = []
2017-01-17 04:23:20 +01:00
self._session_id = conf.settings.get_session_id()
2016-10-22 01:12:38 +02:00
# TODO: this should probably be passed into the daemon, or
# possibly have the entire log upload functionality taken out
# of the daemon, but I don't want to deal with that now
self.log_uploader = log_support.LogUploader.load('lbrynet', self.log_file)
self.analytics_manager = analytics_manager
self.lbryid = utils.generate_id()
2016-05-14 23:36:30 +02:00
self.wallet_user = None
self.wallet_password = None
self.query_handlers = {}
self.waiting_on = {}
self.streams = {}
self.pending_claims = {}
self.name_cache = {}
self.exchange_rate_manager = ExchangeRateManager()
2016-10-19 01:09:35 +02:00
calls = {
Checker.INTERNET_CONNECTION: LoopingCall(CheckInternetConnection(self)),
Checker.VERSION: LoopingCall(CheckRemoteVersions(self)),
2017-01-03 20:13:01 +01:00
Checker.CONNECTION_STATUS: LoopingCall(self._update_connection_status),
2016-10-19 01:09:35 +02:00
Checker.PENDING_CLAIM: LoopingCall(self._check_pending_claims),
}
self.looping_call_manager = LoopingCallManager(calls)
2016-05-14 23:36:30 +02:00
self.sd_identifier = StreamDescriptorIdentifier()
self.stream_info_manager = DBEncryptedFileMetadataManager(self.db_dir)
self.lbry_ui_manager = UIManager(root)
2016-05-14 23:36:30 +02:00
self.lbry_file_manager = None
@defer.inlineCallbacks
def setup(self, launch_ui):
self._modify_loggly_formatter()
def _announce_startup():
2016-05-11 08:47:33 +02:00
def _wait_for_credits():
2017-01-12 18:51:44 +01:00
if float(self.session.wallet.get_balance()) == 0.0:
2016-05-11 08:47:33 +02:00
self.startup_status = STARTUP_STAGES[6]
return reactor.callLater(1, _wait_for_credits)
else:
return _announce()
def _announce():
self.announced_startup = True
self.startup_status = STARTUP_STAGES[5]
log.info("Started lbrynet-daemon")
2016-05-30 21:49:25 +02:00
if self.first_run:
2016-05-21 01:59:49 +02:00
d = self._upload_log(log_type="first_run")
elif self.upload_log:
2016-05-21 01:59:49 +02:00
d = self._upload_log(exclude_previous=True, log_type="start")
else:
d = defer.succeed(None)
d.addCallback(lambda _: _announce())
return d
log.info("Starting lbrynet-daemon")
2016-02-25 23:17:07 +01:00
2016-10-19 01:09:35 +02:00
self.looping_call_manager.start(Checker.INTERNET_CONNECTION, 3600)
self.looping_call_manager.start(Checker.VERSION, 1800)
self.looping_call_manager.start(Checker.CONNECTION_STATUS, 30)
2016-07-28 11:30:13 +02:00
self.exchange_rate_manager.start()
2017-01-17 04:23:20 +01:00
if conf.settings['host_ui']:
self.lbry_ui_manager.update_checker.start(1800, now=False)
yield self.lbry_ui_manager.setup()
2017-01-03 21:51:42 +01:00
if launch_ui:
self.lbry_ui_manager.launch()
yield self._initial_setup()
yield threads.deferToThread(self._setup_data_directory)
yield self._check_db_migration()
yield self._load_caches()
yield self._get_session()
yield self._get_analytics()
yield add_lbry_file_to_sd_identifier(self.sd_identifier)
yield self._setup_stream_identifier()
yield self._setup_lbry_file_manager()
yield self._setup_query_handlers()
yield self._setup_server()
2017-01-12 18:51:44 +01:00
log.info("Starting balance: " + str(self.session.wallet.get_balance()))
yield _announce_startup()
2016-09-28 18:07:25 +02:00
2016-05-30 21:49:25 +02:00
def _get_platform(self):
if self.platform is None:
2016-12-10 21:01:29 +01:00
self.platform = system_info.get_platform()
self.platform["ui_version"] = self.lbry_ui_manager.loaded_git_version
return self.platform
2016-05-30 21:49:25 +02:00
2016-03-24 03:27:48 +01:00
def _initial_setup(self):
def _log_platform():
log.info("Platform: %s", json.dumps(self._get_platform()))
return defer.succeed(None)
d = _log_platform()
return d
def _load_caches(self):
2016-12-19 19:27:45 +01:00
name_cache_filename = os.path.join(self.db_dir, "stream_info_cache.json")
if os.path.isfile(name_cache_filename):
with open(name_cache_filename, "r") as name_cache:
self.name_cache = json.loads(name_cache.read())
log.info("Loaded claim info cache")
def _check_network_connection(self):
self.connected_to_internet = utils.check_connection()
def _check_lbrynet_connection(self):
def _log_success():
log.info("lbrynet connectivity test passed")
2017-01-03 20:13:01 +01:00
def _log_failure():
log.info("lbrynet connectivity test failed")
2016-11-30 21:20:45 +01:00
wonderfullife_sh = ("6f3af0fa3924be98a54766aa2715d22c6c1509c3f7fa32566df4899"
"a41f3530a9f97b2ecb817fa1dcbf1b30553aefaa7")
d = download_sd_blob(self.session, wonderfullife_sh, self.session.base_payment_rate_manager)
d.addCallbacks(lambda _: _log_success, lambda _: _log_failure)
2017-01-03 20:13:01 +01:00
def _update_connection_status(self):
self.connection_status_code = CONNECTION_STATUS_CONNECTED
2016-07-30 04:36:30 +02:00
if not self.git_lbrynet_version or not self.git_lbryum_version:
2017-01-03 20:13:01 +01:00
self.connection_status_code = CONNECTION_STATUS_VERSION_CHECK
if not self.connected_to_internet:
2017-01-03 20:13:01 +01:00
self.connection_status_code = CONNECTION_STATUS_NETWORK
2016-11-28 20:23:10 +01:00
# claim_out is dictionary containing 'txid' and 'nout'
def _add_to_pending_claims(self, claim_out, name):
txid = claim_out['txid']
2016-12-14 00:08:29 +01:00
nout = claim_out['nout']
log.info("Adding lbry://%s to pending claims, txid %s nout %d" % (name, txid, nout))
2016-11-28 20:23:10 +01:00
self.pending_claims[name] = (txid, nout)
return claim_out
2016-07-27 09:00:44 +02:00
def _check_pending_claims(self):
# TODO: this was blatantly copied from jsonrpc_start_lbry_file. Be DRY.
def _start_file(f):
d = self.lbry_file_manager.toggle_lbry_file_running(f)
return defer.succeed("Started LBRY file")
def _get_and_start_file(name):
2016-11-30 21:20:45 +01:00
def start_stopped_file(l):
if l.stopped:
return _start_file(l)
else:
return "LBRY file was already running"
2017-01-03 20:13:01 +01:00
2016-07-27 09:00:44 +02:00
d = defer.succeed(self.pending_claims.pop(name))
2016-10-19 01:09:35 +02:00
d.addCallback(lambda _: self._get_lbry_file(FileID.NAME, name, return_json=False))
2016-11-30 21:20:45 +01:00
d.addCallback(start_stopped_file)
2016-07-27 09:00:44 +02:00
2016-07-28 19:16:33 +02:00
def re_add_to_pending_claims(name):
log.warning("Re-add %s to pending claims", name)
txid, nout = self.pending_claims.pop(name)
2017-01-03 20:13:01 +01:00
claim_out = {'txid': txid, 'nout': nout}
self._add_to_pending_claims(claim_out, name)
2016-07-28 19:16:33 +02:00
def _process_lbry_file(name, lbry_file):
2016-09-27 20:18:16 +02:00
# lbry_file is an instance of ManagedEncryptedFileDownloader or None
# TODO: check for sd_hash in addition to txid
ready_to_start = (
2016-07-27 20:59:26 +02:00
lbry_file and
2016-11-28 20:23:10 +01:00
self.pending_claims[name] == (lbry_file.txid, lbry_file.nout)
)
if ready_to_start:
2016-07-28 19:16:33 +02:00
_get_and_start_file(name)
else:
re_add_to_pending_claims(name)
2016-07-27 09:00:44 +02:00
for name in self.pending_claims:
log.info("Checking if new claim for lbry://%s is confirmed" % name)
d = self._resolve_name(name, force_refresh=True)
d.addCallback(lambda _: self._get_lbry_file_by_uri(name))
d.addCallbacks(
lambda lbry_file: _process_lbry_file(name, lbry_file),
lambda _: re_add_to_pending_claims(name)
)
2016-07-27 09:00:44 +02:00
def _start_server(self):
if self.peer_port is not None:
server_factory = ServerProtocolFactory(self.session.rate_limiter,
self.query_handlers,
self.session.peer_manager)
2016-08-09 18:07:26 +02:00
try:
self.lbry_server_port = reactor.listenTCP(self.peer_port, server_factory)
except error.CannotListenError as e:
import traceback
log.error("Couldn't bind to port %d. %s", self.peer_port, traceback.format_exc())
raise ValueError("%s lbrynet may already be running on your computer.", str(e))
return defer.succeed(True)
2016-08-09 18:07:26 +02:00
def _start_reflector(self):
if self.run_reflector_server:
log.info("Starting reflector server")
if self.reflector_port is not None:
2016-08-10 14:44:41 +02:00
reflector_factory = reflector.ServerFactory(
self.session.peer_manager,
self.session.blob_manager
)
try:
2016-11-30 21:20:45 +01:00
self.reflector_server_port = reactor.listenTCP(
self.reflector_port, reflector_factory)
2016-08-11 02:04:03 +02:00
log.info('Started reflector on port %s', self.reflector_port)
except error.CannotListenError as e:
2016-08-10 14:44:41 +02:00
log.exception("Couldn't bind reflector to port %d", self.reflector_port)
2016-11-30 21:20:45 +01:00
raise ValueError(
"{} lbrynet may already be running on your computer.".format(e))
2016-08-09 18:07:26 +02:00
return defer.succeed(True)
def _stop_reflector(self):
if self.run_reflector_server:
log.info("Stopping reflector server")
try:
if self.reflector_server_port is not None:
self.reflector_server_port, p = None, self.reflector_server_port
return defer.maybeDeferred(p.stopListening)
except AttributeError:
2016-08-09 18:07:26 +02:00
return defer.succeed(True)
return defer.succeed(True)
2016-08-09 18:07:26 +02:00
def _stop_file_manager(self):
if self.lbry_file_manager:
self.lbry_file_manager.stop()
return defer.succeed(True)
def _stop_server(self):
2016-05-30 21:49:25 +02:00
try:
if self.lbry_server_port is not None:
self.lbry_server_port, old_port = None, self.lbry_server_port
log.info('Stop listening to %s', old_port)
return defer.maybeDeferred(old_port.stopListening)
2016-05-30 21:49:25 +02:00
else:
return defer.succeed(True)
except AttributeError:
return defer.succeed(True)
def _setup_server(self):
self.startup_status = STARTUP_STAGES[4]
d = self._start_server()
d.addCallback(lambda _: self._start_reflector())
return d
def _setup_query_handlers(self):
handlers = [
2016-10-18 16:40:13 +02:00
BlobRequestHandlerFactory(
self.session.blob_manager,
self.session.wallet,
self.session.payment_rate_manager,
self.analytics_manager.track
),
self.session.wallet.get_wallet_info_query_handler_factory(),
]
return self._add_query_handlers(handlers)
def _add_query_handlers(self, query_handlers):
for handler in query_handlers:
2016-10-22 01:12:38 +02:00
query_id = handler.get_primary_query_identifier()
self.query_handlers[query_id] = handler
return defer.succeed(None)
2016-05-21 01:59:49 +02:00
def _upload_log(self, log_type=None, exclude_previous=False, force=False):
if self.upload_log or force:
try:
self.log_uploader.upload(exclude_previous,
conf.settings.installation_id[:SHORT_ID_LEN],
log_type)
except requests.RequestException:
log.warning('Failed to upload log file')
2016-10-22 01:12:38 +02:00
return defer.succeed(None)
def _clean_up_temp_files(self):
for path in self.uploaded_temp_files:
try:
2016-11-04 19:15:27 +01:00
log.debug('Removing tmp file: %s', path)
os.remove(path)
except OSError:
pass
def _shutdown(self):
2016-03-24 03:27:48 +01:00
log.info("Closing lbrynet session")
log.info("Status at time of shutdown: " + self.startup_status[0])
self.looping_call_manager.shutdown()
if self.analytics_manager:
self.analytics_manager.shutdown()
if self.lbry_ui_manager.update_checker.running:
self.lbry_ui_manager.update_checker.stop()
self._clean_up_temp_files()
2017-01-17 04:23:20 +01:00
if self.upload_logs_on_shutdown:
try:
d = self._upload_log(
log_type="close", exclude_previous=False if self.first_run else True)
except Exception:
log.warn('Failed to upload log', exc_info=True)
d = defer.succeed(None)
else:
d = defer.succeed(None)
d.addCallback(lambda _: self._stop_server())
2016-12-10 20:42:57 +01:00
d.addErrback(log.fail(), 'Failure while shutting down')
2016-08-09 18:07:26 +02:00
d.addCallback(lambda _: self._stop_reflector())
2016-12-10 20:42:57 +01:00
d.addErrback(log.fail(), 'Failure while shutting down')
d.addCallback(lambda _: self._stop_file_manager())
2016-12-10 20:42:57 +01:00
d.addErrback(log.fail(), 'Failure while shutting down')
if self.session is not None:
d.addCallback(lambda _: self.session.shut_down())
2016-12-10 20:42:57 +01:00
d.addErrback(log.fail(), 'Failure while shutting down')
return d
2016-03-24 03:27:48 +01:00
def _update_settings(self, settings):
setting_types = {
'run_on_startup': bool,
'data_rate': float,
'max_key_fee': float,
'download_directory': str,
'max_upload': float,
'max_download': float,
'upload_log': bool,
'download_timeout': int,
'search_timeout': float,
'cache_time': int
}
2017-01-03 20:13:01 +01:00
2016-11-30 21:20:45 +01:00
def can_update_key(settings, key, setting_type):
return (
isinstance(settings[key], setting_type) or
(
key == "max_key_fee" and
isinstance(FeeValidator(settings[key]).amount, setting_type)
)
)
for key, setting_type in setting_types.iteritems():
if key in settings:
2016-11-30 21:20:45 +01:00
if can_update_key(settings, key, setting_type):
conf.settings.update({key: settings[key]},
data_types=(conf.TYPE_RUNTIME, conf.TYPE_PERSISTED))
else:
try:
converted = setting_type(settings[key])
conf.settings.update({key: converted},
data_types=(conf.TYPE_RUNTIME, conf.TYPE_PERSISTED))
except Exception as err:
log.warning(err.message)
log.warning("error converting setting '%s' to type %s", key, setting_type)
2017-01-17 04:23:20 +01:00
conf.settings.save_conf_file_settings()
self.run_on_startup = conf.settings['run_on_startup']
self.data_rate = conf.settings['data_rate']
self.max_key_fee = conf.settings['max_key_fee']
self.download_directory = conf.settings['download_directory']
self.max_upload = conf.settings['max_upload']
self.max_download = conf.settings['max_download']
self.upload_log = conf.settings['upload_log']
self.download_timeout = conf.settings['download_timeout']
self.search_timeout = conf.settings['search_timeout']
self.cache_time = conf.settings['cache_time']
2016-03-24 03:27:48 +01:00
return defer.succeed(True)
2016-11-28 20:23:10 +01:00
def _write_db_revision_file(self, version_num):
with open(self.db_revision_file, mode='w') as db_revision:
db_revision.write(str(version_num))
def _setup_data_directory(self):
old_revision = 1
self.startup_status = STARTUP_STAGES[1]
2017-01-04 23:10:36 +01:00
log.info("Loading databases")
if self.created_data_dir:
self._write_db_revision_file(self.current_db_revision)
log.debug("Created the db revision file: %s", self.db_revision_file)
if not os.path.exists(self.blobfile_dir):
os.mkdir(self.blobfile_dir)
log.debug("Created the blobfile directory: %s", str(self.blobfile_dir))
2016-11-28 20:23:10 +01:00
if not os.path.exists(self.db_revision_file):
log.warning("db_revision file not found. Creating it")
self._write_db_revision_file(old_revision)
def _check_db_migration(self):
old_revision = 1
if os.path.exists(self.db_revision_file):
old_revision = int(open(self.db_revision_file).read().strip())
2016-10-25 23:49:08 +02:00
if old_revision > self.current_db_revision:
2016-11-30 21:20:45 +01:00
raise Exception('This version of lbrynet is not compatible with the database')
def update_version_file_and_print_success():
self._write_db_revision_file(self.current_db_revision)
log.info("Finished upgrading the databases.")
if old_revision < self.current_db_revision:
from lbrynet.db_migrator import dbmigrator
2017-01-04 23:10:36 +01:00
log.info("Upgrading your databases")
2016-11-30 21:20:45 +01:00
d = threads.deferToThread(
dbmigrator.migrate_db, self.db_dir, old_revision, self.current_db_revision)
d.addCallback(lambda _: update_version_file_and_print_success())
return d
return defer.succeed(True)
def _modify_loggly_formatter(self):
log_support.configure_loggly_handler(
installation_id=conf.settings.installation_id,
session_id=self._session_id
)
def _setup_lbry_file_manager(self):
self.startup_status = STARTUP_STAGES[3]
d = self.stream_info_manager.setup()
def set_lbry_file_manager():
2016-11-03 20:22:16 +01:00
self.lbry_file_manager = EncryptedFileManager(
self.session, self.stream_info_manager,
2016-11-03 20:22:16 +01:00
self.sd_identifier, download_directory=self.download_directory)
return self.lbry_file_manager.setup()
2017-01-03 20:13:01 +01:00
d.addCallback(lambda _: set_lbry_file_manager())
return d
def _get_analytics(self):
if not self.analytics_manager.is_started:
self.analytics_manager.start()
self.analytics_manager.register_repeating_metric(
analytics.BLOB_BYTES_AVAILABLE,
AlwaysSend(calculate_available_blob_size, self.session.blob_manager),
frequency=300
)
def _get_session(self):
def get_wallet():
2016-11-10 20:26:21 +01:00
if self.wallet_type == LBRYCRD_WALLET:
raise ValueError('LBRYcrd Wallet is no longer supported')
2016-11-10 20:26:21 +01:00
elif self.wallet_type == LBRYUM_WALLET:
2016-07-09 19:31:07 +02:00
log.info("Using lbryum wallet")
2016-11-20 01:29:58 +01:00
config = {'auto_connect': True}
2017-01-17 04:23:20 +01:00
if conf.settings['lbryum_wallet_dir']:
config['lbryum_path'] = conf.settings['lbryum_wallet_dir']
storage = SqliteStorage(self.db_dir)
wallet = LBRYumWallet(storage, config)
return defer.succeed(wallet)
2016-11-10 20:26:21 +01:00
elif self.wallet_type == PTC_WALLET:
2016-02-25 23:17:07 +01:00
log.info("Using PTC wallet")
from lbrynet.core.PTCWallet import PTCWallet
return defer.succeed(PTCWallet(self.db_dir))
else:
raise ValueError('Wallet Type {} is not valid'.format(self.wallet_type))
d = get_wallet()
def create_session(wallet):
2016-11-30 21:20:45 +01:00
self.session = Session(
2017-01-17 04:23:20 +01:00
conf.settings['data_rate'],
2016-11-30 21:20:45 +01:00
db_dir=self.db_dir,
lbryid=self.lbryid,
blob_dir=self.blobfile_dir,
dht_node_port=self.dht_node_port,
2017-01-17 04:23:20 +01:00
known_dht_nodes=conf.settings['known_dht_nodes'],
2016-11-30 21:20:45 +01:00
peer_port=self.peer_port,
use_upnp=self.use_upnp,
wallet=wallet,
2017-01-17 04:23:20 +01:00
is_generous=conf.settings['is_generous_host']
2016-11-30 21:20:45 +01:00
)
self.startup_status = STARTUP_STAGES[2]
d.addCallback(create_session)
d.addCallback(lambda _: self.session.setup())
return d
def _setup_stream_identifier(self):
2016-11-30 21:20:45 +01:00
file_saver_factory = EncryptedFileSaverFactory(
self.session.peer_finder,
self.session.rate_limiter,
self.session.blob_manager,
self.stream_info_manager,
self.session.wallet,
self.download_directory
)
self.sd_identifier.add_stream_downloader_factory(
EncryptedFileStreamType, file_saver_factory)
file_opener_factory = EncryptedFileOpenerFactory(
self.session.peer_finder,
self.session.rate_limiter,
self.session.blob_manager,
self.stream_info_manager,
self.session.wallet
)
self.sd_identifier.add_stream_downloader_factory(
EncryptedFileStreamType, file_opener_factory)
return defer.succeed(None)
def _download_sd_blob(self, sd_hash, timeout=None):
2017-01-17 04:23:20 +01:00
timeout = timeout if timeout is not None else conf.settings['sd_download_timeout']
2017-01-03 20:13:01 +01:00
2016-08-02 08:54:04 +02:00
def cb(result):
2016-08-02 22:03:47 +02:00
if not r.called:
r.callback(result)
2016-08-02 08:54:04 +02:00
def eb():
if not r.called:
2017-01-29 22:40:39 +01:00
log.error("sd blob download timed out: %s", sd_hash)
2016-08-02 08:54:04 +02:00
r.errback(Exception("sd timeout"))
r = defer.Deferred(None)
2016-08-03 23:57:26 +02:00
reactor.callLater(timeout, eb)
d = download_sd_blob(self.session, sd_hash, self.session.payment_rate_manager)
2017-01-29 22:40:39 +01:00
d.addErrback(log.fail(), "Error downloading sd blob: %s", sd_hash)
2016-08-02 05:15:32 +02:00
d.addCallback(BlobStreamDescriptorReader)
d.addCallback(lambda blob: blob.get_info())
2016-08-02 08:54:04 +02:00
d.addCallback(cb)
return r
2016-08-02 05:15:32 +02:00
@defer.inlineCallbacks
def _download_name(self, name, timeout=None, download_directory=None,
file_name=None, stream_info=None, wait_for_write=True):
"""
Add a lbry file to the file manager, start the download, and return the new lbry file.
If it already exists in the file manager, return the existing lbry file
"""
2017-01-17 04:23:20 +01:00
timeout = timeout if timeout is not None else conf.settings['download_timeout']
2016-12-30 18:37:11 +01:00
helper = _DownloadNameHelper(
self, name, timeout, download_directory, file_name, wait_for_write)
if not stream_info:
self.waiting_on[name] = True
stream_info = yield self._resolve_name(name)
del self.waiting_on[name]
lbry_file = yield helper.setup_stream(stream_info)
sd_hash, file_path = yield helper.wait_or_get_stream(stream_info, lbry_file)
defer.returnValue((sd_hash, file_path))
@defer.inlineCallbacks
def _publish_stream(self, name, bid, metadata, file_path=None, fee=None):
publisher = Publisher(self.session, self.lbry_file_manager, self.session.wallet)
verify_name_characters(name)
if bid <= 0.0:
raise Exception("Invalid bid")
if fee:
metadata = yield publisher.add_fee_to_metadata(metadata, fee)
if not file_path:
claim_out = yield publisher.update_stream(name, bid, metadata)
else:
claim_out = yield publisher.publish_stream(name, file_path, bid, metadata)
yield threads.deferToThread(self._reflect, publisher.lbry_file)
log.info("Success! Published to lbry://%s txid: %s nout: %d", name, claim_out['txid'],
claim_out['nout'])
yield self._add_to_pending_claims(claim_out, name)
self.looping_call_manager.start(Checker.PENDING_CLAIM, 30)
defer.returnValue(claim_out)
def add_stream(self, name, timeout, download_directory, file_name, stream_info):
"""Makes, adds and starts a stream"""
self.streams[name] = GetStream(self.sd_identifier,
self.session,
self.session.wallet,
self.lbry_file_manager,
2016-08-05 12:00:35 +02:00
self.exchange_rate_manager,
max_key_fee=self.max_key_fee,
data_rate=self.data_rate,
timeout=timeout,
download_directory=download_directory,
file_name=file_name)
d = self.streams[name].start(stream_info, name)
return d
def _get_long_count_timestamp(self):
2017-01-02 20:52:24 +01:00
dt = utils.utcnow() - utils.datetime_obj(year=2012, month=12, day=21)
return int(dt.total_seconds())
def _update_claim_cache(self):
f = open(os.path.join(self.db_dir, "stream_info_cache.json"), "w")
f.write(json.dumps(self.name_cache))
f.close()
return defer.succeed(True)
2016-05-30 21:49:25 +02:00
def _resolve_name(self, name, force_refresh=False):
"""Resolves a name. Checks the cache first before going out to the blockchain.
Args:
name: the lbry://<name> to resolve
force_refresh: if True, always go out to the blockchain to resolve.
"""
if name.startswith('lbry://'):
2016-09-25 23:41:44 +02:00
raise ValueError('name {} should not start with lbry://'.format(name))
helper = _ResolveNameHelper(self, name, force_refresh)
return helper.get_deferred()
2016-05-30 21:49:25 +02:00
def _delete_lbry_file(self, lbry_file, delete_file=True):
d = self.lbry_file_manager.delete_lbry_file(lbry_file)
def finish_deletion(lbry_file):
d = lbry_file.delete_data()
d.addCallback(lambda _: _delete_stream_data(lbry_file))
return d
def _delete_stream_data(lbry_file):
s_h = lbry_file.stream_hash
d = self.lbry_file_manager.get_count_for_stream_hash(s_h)
# TODO: could possibly be a timing issue here
d.addCallback(lambda c: self.stream_info_manager.delete_stream(s_h) if c == 0 else True)
2016-05-30 21:49:25 +02:00
if delete_file:
2016-11-30 21:20:45 +01:00
def remove_if_file():
filename = os.path.join(self.download_directory, lbry_file.file_name)
if os.path.isfile(filename):
os.remove(filename)
else:
return defer.succeed(None)
2017-01-03 20:13:01 +01:00
2016-11-30 21:20:45 +01:00
d.addCallback(lambda _: remove_if_file)
return d
d.addCallback(lambda _: finish_deletion(lbry_file))
d.addCallback(lambda _: log.info("Delete lbry file"))
return d
2016-11-30 22:23:48 +01:00
def _get_or_download_sd_blob(self, blob, sd_hash):
if blob:
return self.session.blob_manager.get_blob(blob[0], True)
def _check_est(downloader):
if downloader.result is not None:
downloader.cancel()
d = defer.succeed(None)
reactor.callLater(self.search_timeout, _check_est, d)
2016-12-07 16:10:46 +01:00
d.addCallback(
lambda _: download_sd_blob(
self.session, sd_hash, self.session.payment_rate_manager))
2016-11-30 22:23:48 +01:00
return d
def get_or_download_sd_blob(self, sd_hash):
2016-12-07 16:10:46 +01:00
"""Return previously downloaded sd blob if already in the blob
manager, otherwise download and return it
2016-11-30 22:23:48 +01:00
"""
d = self.session.blob_manager.completed_blobs([sd_hash])
d.addCallback(self._get_or_download_sd_blob, sd_hash)
return d
def get_size_from_sd_blob(self, sd_blob):
"""
Get total stream size in bytes from a sd blob
"""
d = self.sd_identifier.get_metadata_for_sd_blob(sd_blob)
d.addCallback(lambda metadata: metadata.validator.info_to_show())
d.addCallback(lambda info: int(dict(info)['stream_size']))
return d
2016-12-02 20:39:01 +01:00
def _get_est_cost_from_stream_size(self, size):
2016-11-30 22:23:48 +01:00
"""
Calculate estimated LBC cost for a stream given its size in bytes
"""
if self.session.payment_rate_manager.generous:
return 0.0
2017-01-17 04:23:20 +01:00
return size / (10 ** 6) * conf.settings['data_rate']
2016-11-30 22:23:48 +01:00
2016-12-02 20:39:01 +01:00
def get_est_cost_using_known_size(self, name, size):
"""
Calculate estimated LBC cost for a stream given its size in bytes
"""
cost = self._get_est_cost_from_stream_size(size)
d = self._resolve_name(name)
d.addCallback(lambda metadata: self._add_key_fee_to_est_data_cost(metadata, cost))
return d
2016-11-30 22:23:48 +01:00
def get_est_cost_from_sd_hash(self, sd_hash):
"""
Get estimated cost from a sd hash
"""
d = self.get_or_download_sd_blob(sd_hash)
d.addCallback(self.get_size_from_sd_blob)
2016-12-02 20:39:01 +01:00
d.addCallback(self._get_est_cost_from_stream_size)
return d
def _get_est_cost_from_metadata(self, metadata, name):
2016-11-30 22:23:48 +01:00
d = self.get_est_cost_from_sd_hash(metadata['sources']['lbry_sd_hash'])
def _handle_err(err):
if isinstance(err, Failure):
2016-12-07 16:10:46 +01:00
log.warning(
"Timeout getting blob for cost est for lbry://%s, using only key fee", name)
return 0.0
raise err
d.addErrback(_handle_err)
2016-12-02 20:39:01 +01:00
d.addCallback(lambda data_cost: self._add_key_fee_to_est_data_cost(metadata, data_cost))
return d
2016-12-02 20:39:01 +01:00
def _add_key_fee_to_est_data_cost(self, metadata, data_cost):
fee = self.exchange_rate_manager.to_lbc(metadata.get('fee', None))
fee_amount = 0.0 if fee is None else fee.amount
return data_cost + fee_amount
2016-11-30 22:23:48 +01:00
def get_est_cost_from_name(self, name):
"""
Resolve a name and return the estimated stream cost
"""
2016-11-30 22:23:48 +01:00
d = self._resolve_name(name)
d.addCallback(self._get_est_cost_from_metadata, name)
return d
2016-12-02 20:39:01 +01:00
def get_est_cost(self, name, size=None):
2016-12-07 16:10:46 +01:00
"""Get a cost estimate for a lbry stream, if size is not provided the
sd blob will be downloaded to determine the stream size
2016-11-30 22:23:48 +01:00
"""
2016-12-02 20:39:01 +01:00
2016-11-30 22:23:48 +01:00
if size is not None:
2016-12-02 20:39:01 +01:00
return self.get_est_cost_using_known_size(name, size)
2016-11-30 22:23:48 +01:00
return self.get_est_cost_from_name(name)
def _get_lbry_file_by_uri(self, name):
def _get_file(stream_info):
sd = stream_info['sources']['lbry_sd_hash']
for l in self.lbry_file_manager.lbry_files:
if l.sd_hash == sd:
return defer.succeed(l)
return defer.succeed(None)
2017-01-03 20:13:01 +01:00
d = self._resolve_name(name)
d.addCallback(_get_file)
return d
def _get_lbry_file_by_sd_hash(self, sd_hash):
for l in self.lbry_file_manager.lbry_files:
if l.sd_hash == sd_hash:
return defer.succeed(l)
return defer.succeed(None)
def _get_lbry_file_by_file_name(self, file_name):
for l in self.lbry_file_manager.lbry_files:
if l.file_name == file_name:
return defer.succeed(l)
return defer.succeed(None)
def _get_lbry_file(self, search_by, val, return_json=True):
return _GetFileHelper(self, search_by, val, return_json).retrieve_file()
def _get_lbry_files(self):
def safe_get(sd_hash):
d = self._get_lbry_file(FileID.SD_HASH, sd_hash)
d.addErrback(log.fail(), 'Failed to get file for hash: %s', sd_hash)
return d
d = defer.DeferredList([
2017-01-03 20:13:01 +01:00
safe_get(l.sd_hash)
for l in self.lbry_file_manager.lbry_files
])
return d
2016-08-18 03:33:41 +02:00
def _reflect(self, lbry_file):
if not lbry_file:
return defer.fail(Exception("no lbry file given to reflect"))
if lbry_file.stream_hash is None:
2016-08-21 06:58:25 +02:00
return defer.fail(Exception("no stream hash"))
2016-08-18 03:33:41 +02:00
factory = reflector.ClientFactory(
self.session.blob_manager,
self.lbry_file_manager.stream_info_manager,
lbry_file.stream_hash,
lbry_file.uri
2016-08-18 03:33:41 +02:00
)
2016-11-10 20:55:31 +01:00
return run_reflector_factory(factory)
2016-08-18 03:33:41 +02:00
2016-08-27 01:58:53 +02:00
def _reflect_blobs(self, blob_hashes):
if not blob_hashes:
return defer.fail(Exception("no lbry file given to reflect"))
log.info("Reflecting %i blobs" % len(blob_hashes))
2016-08-27 02:22:11 +02:00
factory = reflector.BlobClientFactory(
2016-08-27 01:58:53 +02:00
self.session.blob_manager,
blob_hashes
)
2016-11-10 20:55:31 +01:00
return run_reflector_factory(factory)
2017-01-03 20:13:01 +01:00
############################################################################
# #
# JSON-RPC API methods start here #
# #
############################################################################
@defer.inlineCallbacks
def jsonrpc_status(self, session_status=False, blockchain_status=False):
2016-03-24 03:27:48 +01:00
"""
2017-01-03 20:13:01 +01:00
Return daemon status
Args:
2017-01-03 20:13:01 +01:00
session_status: bool
blockchain_status: bool
Returns:
daemon status
"""
has_wallet = self.session and self.session.wallet
2017-01-03 20:13:01 +01:00
response = {
'lbry_id': base58.b58encode(self.lbryid)[:SHORT_ID_LEN],
'installation_id': conf.settings.get_installation_id()[:SHORT_ID_LEN],
2017-01-03 20:13:01 +01:00
'is_running': self.announced_startup,
'is_first_run': self.session.wallet.is_first_run if has_wallet else None,
2017-01-03 20:13:01 +01:00
'startup_status': {
'code': self.startup_status[0],
'message': self.startup_status[1],
},
'connection_status': {
'code': self.connection_status_code,
'message': (
CONNECTION_MESSAGES[self.connection_status_code]
if self.connection_status_code is not None
else ''
),
},
'blocks_behind': (
self.session.wallet.blocks_behind
if has_wallet and self.wallet_type == LBRYUM_WALLET
2017-01-03 20:13:01 +01:00
else 'unknown'
),
}
if session_status:
blobs = yield self.session.blob_manager.get_all_verified_blobs()
response['session_status'] = {
'managed_blobs': len(blobs),
'managed_streams': len(self.lbry_file_manager.lbry_files),
}
if blockchain_status and has_wallet:
2017-01-03 20:13:01 +01:00
# calculate blocks_behind more accurately
local_height = self.session.wallet.network.get_local_height()
remote_height = self.session.wallet.network.get_server_height()
response['blocks_behind'] = remote_height - local_height
best_hash = yield self.session.wallet.get_best_blockhash()
response['blockchain_status'] = {'best_blockhash': best_hash}
defer.returnValue(response)
2017-01-03 20:13:01 +01:00
def jsonrpc_get_best_blockhash(self):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `status blockchain_status=True` instead
"""
d = self.jsonrpc_status(blockchain_status=True)
d.addCallback(lambda x: self._render_response(
x['blockchain_status']['best_blockhash']))
return d
2017-01-03 20:13:01 +01:00
def jsonrpc_is_running(self):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `status` instead
"""
d = self.jsonrpc_status()
d.addCallback(lambda x: self._render_response(x['is_running']))
return d
2017-01-03 20:13:01 +01:00
def jsonrpc_daemon_status(self):
"""
DEPRECATED. Use `status` instead
"""
def _simulate_old_daemon_status(status):
message = status['startup_status']['message']
problem_code = None
progress = None
if self.connection_status_code != CONNECTION_STATUS_CONNECTED:
problem_code = self.connection_status_code
message = CONNECTION_MESSAGES[self.connection_status_code]
elif status['startup_status']['code'] == LOADING_WALLET_CODE:
message = "Catching up with the blockchain."
progress = 0
if status['blocks_behind'] > 0:
message += ' ' + str(status['blocks_behind']) + " blocks behind."
progress = status['blocks_behind']
return {
'message': message,
'code': status['startup_status']['code'],
'progress': progress,
'is_lagging': self.connection_status_code != CONNECTION_STATUS_CONNECTED,
'problem_code': problem_code,
}
d = self.jsonrpc_status()
d.addCallback(_simulate_old_daemon_status)
d.addCallback(lambda x: self._render_response(x)) # is this necessary?
return d
2017-01-03 20:13:01 +01:00
def jsonrpc_is_first_run(self):
"""
DEPRECATED. Use `status` instead
"""
d = self.jsonrpc_status(blockchain_status=True)
d.addCallback(lambda x: self._render_response(x['is_first_run']))
return d
2017-01-03 20:13:01 +01:00
def jsonrpc_get_lbry_session_info(self):
"""
DEPRECATED. Use `status` instead
"""
d = self.jsonrpc_status(session_status=True)
d.addCallback(lambda x: self._render_response({
'lbry_id': x['lbry_id'],
'managed_blobs': x['session_status']['managed_blobs'],
'managed_streams': x['session_status']['managed_streams'],
}))
return d
2017-01-03 20:13:01 +01:00
def jsonrpc_get_time_behind_blockchain(self):
"""
DEPRECATED. Use `status` instead
"""
d = self.jsonrpc_status(blockchain_status=True)
d.addCallback(lambda x: self._render_response(x['blocks_behind']))
return d
def jsonrpc_version(self):
"""
Get lbry version information
Args:
None
Returns:
"platform": platform string
"os_release": os release string
"os_system": os name
"lbrynet_version: ": lbrynet_version,
"lbryum_version: ": lbryum_version,
"ui_version": commit hash of ui version being used
2016-04-14 04:07:27 +02:00
"remote_lbrynet": most recent lbrynet version available from github
"remote_lbryum": most recent lbryum version available from github
"""
2016-05-30 21:49:25 +02:00
platform_info = self._get_platform()
try:
lbrynet_update_available = utils.version_is_greater_than(
self.git_lbrynet_version, lbrynet_version)
except TypeError:
lbrynet_update_available = False
try:
lbryum_update_available = utils.version_is_greater_than(
self.git_lbryum_version, lbryum_version)
except TypeError:
lbryum_update_available = False
msg = {
2016-05-30 21:49:25 +02:00
'platform': platform_info['platform'],
'os_release': platform_info['os_release'],
'os_system': platform_info['os_system'],
'lbrynet_version': lbrynet_version,
'lbryum_version': lbryum_version,
2017-01-02 18:19:28 +01:00
'ui_version': platform_info['ui_version'],
2016-07-30 04:36:30 +02:00
'remote_lbrynet': self.git_lbrynet_version,
'remote_lbryum': self.git_lbryum_version,
'lbrynet_update_available': lbrynet_update_available,
'lbryum_update_available': lbryum_update_available
}
log.info("Get version info: " + json.dumps(msg))
return self._render_response(msg)
def jsonrpc_report_bug(self, message=None):
2017-01-02 20:52:24 +01:00
"""
Report a bug to slack
Args:
'message': string, message to send
Returns:
True if successful
"""
platform_name = self._get_platform()['platform']
report_bug_to_slack(
message,
conf.settings.installation_id,
platform_name,
lbrynet_version
)
return self._render_response(True)
2017-01-02 20:52:24 +01:00
2017-01-03 20:13:01 +01:00
def jsonrpc_get_settings(self):
2016-11-28 20:16:21 +01:00
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `settings_get` instead.
2016-11-28 20:16:21 +01:00
"""
2017-01-03 20:13:01 +01:00
return self.jsonrpc_settings_get()
2016-11-28 20:16:21 +01:00
2017-01-03 20:13:01 +01:00
def jsonrpc_settings_get(self):
"""
Get daemon settings
Returns:
'run_on_startup': bool,
'data_rate': float,
'max_key_fee': float,
'download_directory': string,
'max_upload': float, 0.0 for unlimited
'max_download': float, 0.0 for unlimited
'upload_log': bool,
'search_timeout': float,
'download_timeout': int
'max_search_results': int,
'wallet_type': string,
'delete_blobs_on_remove': bool,
'peer_port': int,
'dht_node_port': int,
'use_upnp': bool,
"""
log.info("Get daemon settings")
2017-01-17 04:23:20 +01:00
return self._render_response(conf.settings.get_current_settings_dict())
@AuthJSONRPCServer.auth_required
def jsonrpc_set_settings(self, **kwargs):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `settings_set` instead.
"""
return self.jsonrpc_settings_set(**kwargs)
2017-01-03 20:13:01 +01:00
@AuthJSONRPCServer.auth_required
def jsonrpc_settings_set(self, **kwargs):
"""
Set daemon settings
Args:
'run_on_startup': bool,
'data_rate': float,
'max_key_fee': float,
'download_directory': string,
'max_upload': float, 0.0 for unlimited
'max_download': float, 0.0 for unlimited
'upload_log': bool,
2016-04-23 00:18:17 +02:00
'download_timeout': int
Returns:
settings dict
"""
def _log_settings_change():
2016-12-07 16:10:46 +01:00
log.info(
"Set daemon settings to %s",
json.dumps(conf.settings.get_adjustable_settings_dict()))
d = self._update_settings(kwargs)
d.addErrback(lambda err: log.info(err.getTraceback()))
d.addCallback(lambda _: _log_settings_change())
2016-12-07 16:10:46 +01:00
d.addCallback(
lambda _: self._render_response(conf.settings.get_adjustable_settings_dict()))
return d
def jsonrpc_help(self, command=None):
2017-01-03 20:13:01 +01:00
"""
2017-01-11 21:31:08 +01:00
Return a useful message for an API command
Args:
2017-01-11 21:31:08 +01:00
'command': optional, command to retrieve documentation for
Returns:
2017-01-11 21:31:08 +01:00
if given a command, returns documentation about that command
otherwise returns general help message
"""
if command is None:
return self._render_response(textwrap.dedent(self.jsonrpc_help.__doc__))
2017-01-03 20:13:01 +01:00
fn = self.callable_methods.get(command)
if fn is None:
return self._render_response(
"No help available for '{}'. It is not a valid command.".format(command)
)
return self._render_response(textwrap.dedent(fn.__doc__))
2017-01-03 20:13:01 +01:00
def jsonrpc_commands(self):
"""
Return a list of available commands
Returns:
list
"""
return self._render_response(sorted(self.callable_methods.keys()))
2016-03-24 03:27:48 +01:00
def jsonrpc_get_balance(self):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `wallet_balance` instead.
"""
return self.jsonrpc_wallet_balance()
def jsonrpc_wallet_balance(self):
"""
Return the balance of the wallet
2016-03-24 03:27:48 +01:00
Returns:
balance, float
"""
2017-01-12 18:51:44 +01:00
return self._render_response(float(self.session.wallet.get_balance()))
2016-03-24 03:27:48 +01:00
def jsonrpc_stop(self):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `daemon_stop` instead.
"""
return self.jsonrpc_daemon_stop()
def jsonrpc_daemon_stop(self):
"""
Stop lbrynet-daemon
2016-03-24 03:27:48 +01:00
Returns:
shutdown message
"""
2017-01-03 20:13:01 +01:00
def _display_shutdown_message():
2016-03-24 03:27:48 +01:00
log.info("Shutting down lbrynet daemon")
d = self._shutdown()
2017-01-03 20:13:01 +01:00
d.addCallback(lambda _: _display_shutdown_message())
d.addCallback(lambda _: reactor.callLater(0.0, reactor.stop))
return self._render_response("Shutting down")
2016-03-24 03:27:48 +01:00
def jsonrpc_get_lbry_files(self):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `file_list` instead.
"""
return self.jsonrpc_file_list()
def jsonrpc_file_list(self):
"""
List files
Args:
None
Returns:
2017-01-03 20:13:01 +01:00
List of files, with the following keys:
'completed': bool
'file_name': string
'key': hex string
'points_paid': float
'stopped': bool
'stream_hash': base 58 string
'stream_name': string
'suggested_file_name': string
'upload_allowed': bool
'sd_hash': string
"""
d = self._get_lbry_files()
d.addCallback(lambda r: self._render_response([d[1] for d in r if d[0]]))
return d
def jsonrpc_get_lbry_file(self, **kwargs):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `file_get` instead.
"""
return self.jsonrpc_file_get(**kwargs)
2017-01-03 20:13:01 +01:00
def jsonrpc_file_get(self, **kwargs):
2017-01-03 20:13:01 +01:00
"""
Get a file
Args:
'name': get file by lbry uri,
'sd_hash': get file by the hash in the name claim,
'file_name': get file by its name in the downloads folder,
Returns:
'completed': bool
'file_name': string
'key': hex string
'points_paid': float
'stopped': bool
'stream_hash': base 58 string
'stream_name': string
'suggested_file_name': string
'upload_allowed': bool
'sd_hash': string
"""
d = self._get_deferred_for_lbry_file(kwargs)
d.addCallback(lambda r: self._render_response(r))
return d
def _get_deferred_for_lbry_file(self, search_fields):
try:
searchtype, value = get_lbry_file_search_value(search_fields)
except NoValidSearch:
return defer.fail()
else:
return self._get_lbry_file(searchtype, value)
def jsonrpc_resolve_name(self, name, force=False):
"""
Resolve stream info from a LBRY uri
Args:
'name': name to look up, string, do not include lbry:// prefix
Returns:
metadata from name claim
"""
if not name:
return self._render_response(None)
2016-07-27 03:46:04 +02:00
d = self._resolve_name(name, force_refresh=force)
2017-01-09 20:03:29 +01:00
d.addCallback(self._render_response)
return d
def jsonrpc_get_claim_info(self, **kwargs):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `claim_show` instead.
"""
return self.jsonrpc_claim_show(**kwargs)
def jsonrpc_claim_show(self, name, txid=None, nout=None):
2016-07-28 22:12:20 +02:00
"""
Resolve claim info from a LBRY uri
Args:
'name': name to look up, string, do not include lbry:// prefix
'txid': optional, if specified, look for claim with this txid
'nout': optional, if specified, look for claim with this nout
2016-12-14 00:08:29 +01:00
2016-07-28 22:12:20 +02:00
Returns:
txid, amount, value, n, height
"""
def _convert_amount_to_float(r):
if not r:
return False
else:
2017-01-03 20:13:01 +01:00
r['amount'] = float(r['amount']) / 10 ** 8
return r
d = self.session.wallet.get_claim_info(name, txid, nout)
d.addCallback(_convert_amount_to_float)
d.addCallback(lambda r: self._render_response(r))
return d
@AuthJSONRPCServer.auth_required
@defer.inlineCallbacks
def jsonrpc_get(
self, name, file_name=None, stream_info=None, timeout=None,
download_directory=None, wait_for_write=True):
2017-01-03 20:13:01 +01:00
"""
Download stream from a LBRY uri.
Args:
'name': name to download, string
'file_name': optional, a user specified name for the downloaded file
'stream_info': optional, specified stream info overrides name
2016-07-21 19:32:50 +02:00
'timeout': optional
'download_directory': optional, path to directory where file will be saved, string
'wait_for_write': optional, defaults to True. When set, waits for the file to
only start to be written before returning any results.
Returns:
'stream_hash': hex string
'path': path of download
"""
timeout = timeout if timeout is not None else self.download_timeout
download_directory = download_directory or self.download_directory
sd_hash = get_sd_hash(stream_info)
if name in self.waiting_on:
# TODO: return a useful error message here, like "already
# waiting for name to be resolved"
defer.returnValue(server.failure)
# first check if we already have this
lbry_file = yield self._get_lbry_file(FileID.NAME, name, return_json=False)
if lbry_file:
log.info('Already have a file for %s', name)
message = {
'stream_hash': sd_hash if stream_info else lbry_file.sd_hash,
'path': os.path.join(lbry_file.download_directory, lbry_file.file_name)
}
response = yield self._render_response(message)
defer.returnValue(response)
2016-12-30 19:35:17 +01:00
download_id = utils.random_string()
self.analytics_manager.send_download_started(download_id, name, stream_info)
tries = 1
max_tries = 3
while tries <= max_tries:
try:
log.info(
'Making try %s / %s to start download of %s', tries, max_tries, name)
new_sd_hash, file_path = yield self._download_name(
name=name,
timeout=timeout,
download_directory=download_directory,
stream_info=stream_info,
file_name=file_name,
wait_for_write=wait_for_write
2016-12-30 19:35:17 +01:00
)
break
except Exception as e:
log.exception('Failed to get %s', name)
if tries == max_tries:
self.analytics_manager.send_download_errored(download_id, name, stream_info)
response = yield self._render_response(str(e))
defer.returnValue(response)
tries += 1
# TODO: should stream_hash key be changed to sd_hash?
message = {
'stream_hash': sd_hash if stream_info else new_sd_hash,
'path': file_path
}
stream = self.streams.get(name)
if stream:
stream.downloader.finished_deferred.addCallback(
lambda _: self.analytics_manager.send_download_finished(
download_id, name, stream_info)
)
response = yield self._render_response(message)
defer.returnValue(response)
2015-12-08 06:37:49 +01:00
@AuthJSONRPCServer.auth_required
def jsonrpc_stop_lbry_file(self, **kwargs):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `file_seed status=stop` instead.
"""
return self.jsonrpc_file_seed(status='stop', **kwargs)
@AuthJSONRPCServer.auth_required
def jsonrpc_start_lbry_file(self, **kwargs):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `file_seed status=start` instead.
"""
return self.jsonrpc_file_seed(status='start', **kwargs)
2017-01-03 20:13:01 +01:00
@AuthJSONRPCServer.auth_required
@defer.inlineCallbacks
def jsonrpc_file_seed(self, status, **kwargs):
2017-01-03 20:13:01 +01:00
"""
Start or stop seeding a file
Args:
2017-01-03 20:13:01 +01:00
'status': "start" or "stop"
'name': start file by lbry uri,
'sd_hash': start file by the hash in the name claim,
'file_name': start file by its name in the downloads folder,
Returns:
confirmation message
"""
2017-01-03 20:13:01 +01:00
if status not in ['start', 'stop']:
raise Exception('Status must be "start" or "stop".')
search_type, value = get_lbry_file_search_value(kwargs)
2017-01-03 20:13:01 +01:00
lbry_file = yield self._get_lbry_file(search_type, value, return_json=False)
if not lbry_file:
raise Exception('Unable to find a file for {}:{}'.format(search_type, value))
2017-01-03 20:13:01 +01:00
if status == 'start' and lbry_file.stopped or status == 'stop' and not lbry_file.stopped:
yield self.lbry_file_manager.toggle_lbry_file_running(lbry_file)
msg = "Started seeding file" if status == 'start' else "Stopped seeding file"
else:
2017-01-10 02:05:27 +01:00
msg = (
"File was already being seeded" if status == 'start' else "File was already stopped"
)
response = yield self._render_response(msg)
defer.returnValue(response)
2016-01-17 05:06:24 +01:00
2017-01-03 20:13:01 +01:00
@AuthJSONRPCServer.auth_required
def jsonrpc_delete_lbry_file(self, **kwargs):
2016-07-28 22:12:20 +02:00
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `file_delete` instead
2016-07-28 22:12:20 +02:00
"""
return self.jsonrpc_file_delete(**kwargs)
2016-07-28 22:12:20 +02:00
@AuthJSONRPCServer.auth_required
def jsonrpc_file_delete(self, delete_target_file=True, **kwargs):
2016-03-24 03:27:48 +01:00
"""
Delete a lbry file
2016-01-21 04:00:28 +01:00
Args:
'file_name': downloaded file name, string
Returns:
confirmation message
2016-03-24 03:27:48 +01:00
"""
2016-01-21 04:00:28 +01:00
def _delete_file(f):
if not f:
return False
file_name = f.file_name
d = self._delete_lbry_file(f, delete_file=delete_target_file)
2017-01-03 20:13:01 +01:00
d.addCallback(lambda _: "Deleted file: " + file_name)
return d
2016-01-21 04:00:28 +01:00
try:
searchtype, value = get_lbry_file_search_value(kwargs)
except NoValidSearch:
d = defer.fail()
else:
d = self._get_lbry_file(searchtype, value, return_json=False)
d.addCallback(_delete_file)
d.addCallback(lambda r: self._render_response(r))
return d
def jsonrpc_get_est_cost(self, **kwargs):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `stream_cost_estimate` instead
"""
return self.jsonrpc_stream_cost_estimate(**kwargs)
2017-01-03 20:13:01 +01:00
def jsonrpc_stream_cost_estimate(self, name, size=None):
2017-01-03 20:13:01 +01:00
"""
Get estimated cost for a lbry stream
Args:
'name': lbry uri
'size': stream size, in bytes. if provided an sd blob won't be downloaded.
Returns:
estimated cost
"""
d = self.get_est_cost(name, size)
d.addCallback(lambda r: self._render_response(r))
2017-01-03 20:13:01 +01:00
return d
@AuthJSONRPCServer.auth_required
def jsonrpc_publish(self, name, bid, metadata, file_path=None, fee=None):
2016-03-24 03:27:48 +01:00
"""
Make a new name claim and publish associated data to lbrynet
2016-01-21 04:00:28 +01:00
Args:
'name': str, name to be claimed, string
'bid': float, amount of credits to commit in this claim,
'metadata': dict, Metadata compliant (can be missing sources if a file is provided)
'file_path' (optional): str, path to file to be associated with name, if not given
the stream from your existing claim for the name will be used
'fee' (optional): dict, FeeValidator compliant
Returns:
2017-01-03 20:13:01 +01:00
'success' : True if claim was succesful , False otherwise
'reason' : if not succesful, give reason
'txid' : txid of resulting transaction if succesful
'nout' : nout of the resulting support claim if succesful
'fee' : fee paid for the claim transaction if succesful
2017-01-13 18:19:26 +01:00
'claim_id' : claim id of the resulting transaction
2016-03-24 03:27:48 +01:00
"""
log.info("Publish: %s", {
'name': name,
'file_path': file_path,
'bid': bid,
'metadata': metadata,
'fee': fee,
})
d = self._publish_stream(name, bid, metadata, file_path, fee)
d.addCallback(lambda r: self._render_response(r))
2016-01-21 04:00:28 +01:00
return d
@AuthJSONRPCServer.auth_required
def jsonrpc_abandon_claim(self, **kwargs):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `claim_abandon` instead
"""
return self.jsonrpc_claim_abandon(**kwargs)
2017-01-03 20:13:01 +01:00
@AuthJSONRPCServer.auth_required
def jsonrpc_claim_abandon(self, txid, nout):
2016-03-24 03:27:48 +01:00
"""
Abandon a name and reclaim credits from the claim
2016-12-09 04:05:31 +01:00
Args:
'txid': txid of claim, string
'nout': nout of claim, integer
Return:
txid : txid of resulting transaction if succesful
2016-11-28 20:23:10 +01:00
fee : fee paid for the transaction if succesful
2016-03-24 03:27:48 +01:00
"""
def _disp(x):
log.info("Abandoned name claim tx " + str(x))
return self._render_response(x)
d = defer.Deferred()
d.addCallback(lambda _: self.session.wallet.abandon_claim(txid, nout))
d.addCallback(_disp)
2017-01-03 20:13:01 +01:00
d.callback(None) # TODO: is this line necessary???
return d
@AuthJSONRPCServer.auth_required
def jsonrpc_abandon_name(self, **kwargs):
"""
DEPRECIATED, use abandon_claim
Args:
'txid': txid of claim, string
Return:
txid
"""
return self.jsonrpc_abandon_claim(**kwargs)
@AuthJSONRPCServer.auth_required
def jsonrpc_support_claim(self, **kwargs):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `claim_abandon` instead
"""
return self.jsonrpc_claim_new_support(**kwargs)
2017-01-03 20:13:01 +01:00
@AuthJSONRPCServer.auth_required
def jsonrpc_claim_new_support(self, name, claim_id, amount):
2016-08-08 08:32:56 +02:00
"""
Support a name claim
Args:
'name': name
'claim_id': claim id of claim to support
'amount': amount to support by
Return:
txid : txid of resulting transaction if succesful
nout : nout of the resulting support claim if succesful
2016-11-30 21:20:45 +01:00
fee : fee paid for the transaction if succesful
2016-08-08 08:32:56 +02:00
"""
d = self.session.wallet.support_claim(name, claim_id, amount)
d.addCallback(lambda r: self._render_response(r))
2016-08-08 08:32:56 +02:00
return d
2017-01-03 20:13:01 +01:00
# TODO: merge this into claim_list
@AuthJSONRPCServer.auth_required
def jsonrpc_get_my_claim(self, name):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. This method will be removed in a future release.
Return existing claim for a given name
Args:
'name': name to look up
Returns:
claim info, False if no such claim exists
"""
d = self.session.wallet.get_my_claim(name)
d.addCallback(lambda r: self._render_response(r))
2017-01-03 20:13:01 +01:00
return d
@AuthJSONRPCServer.auth_required
2016-03-24 03:27:48 +01:00
def jsonrpc_get_name_claims(self):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `claim_list_mine` instead
"""
return self.jsonrpc_claim_list_mine()
# TODO: claim_list_mine should be merged into claim_list, but idk how to authenticate it -Grin
@AuthJSONRPCServer.auth_required
def jsonrpc_claim_list_mine(self):
"""
List my name claims
2016-03-24 03:27:48 +01:00
Args:
None
Returns
list of name claims
2016-03-24 03:27:48 +01:00
"""
def _clean(claims):
for c in claims:
for k in c.keys():
2016-02-11 14:32:48 +01:00
if isinstance(c[k], Decimal):
c[k] = float(c[k])
return defer.succeed(claims)
d = self.session.wallet.get_name_claims()
d.addCallback(_clean)
d.addCallback(lambda claims: self._render_response(claims))
return d
def jsonrpc_get_claims_for_name(self, **kwargs):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `claim_list` instead.
"""
return self.jsonrpc_claim_list(**kwargs)
2017-01-03 20:13:01 +01:00
def jsonrpc_get_claims_for_tx(self, **kwargs):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `claim_list` instead.
"""
return self.jsonrpc_claim_list(**kwargs)
2017-01-03 20:13:01 +01:00
def jsonrpc_claim_list(self, name=None, txid=None):
2016-08-08 07:43:10 +02:00
"""
Get claims for a name
Args:
2017-01-03 20:13:01 +01:00
name: file name
txid: transaction id of a name claim transaction
2016-08-08 07:43:10 +02:00
Returns
list of name claims
"""
if name is not None:
d = self.session.wallet.get_claims_for_name(name)
elif txid is not None:
d = self.session.wallet.get_claims_from_tx(txid)
2017-01-03 20:13:01 +01:00
else:
return server.failure
d.addCallback(lambda r: self._render_response(r))
2016-08-08 07:43:10 +02:00
return d
@AuthJSONRPCServer.auth_required
def jsonrpc_get_transaction_history(self):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `transaction_list` instead
"""
return self.jsonrpc_transaction_list()
@AuthJSONRPCServer.auth_required
def jsonrpc_transaction_list(self):
"""
List transactions
Args:
None
Returns:
list of transactions
"""
d = self.session.wallet.get_history()
d.addCallback(lambda r: self._render_response(r))
return d
def jsonrpc_get_transaction(self, txid):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `transaction_show` instead
"""
return self.jsonrpc_transaction_show(txid)
2017-01-03 20:13:01 +01:00
def jsonrpc_transaction_show(self, txid):
2017-01-03 20:13:01 +01:00
"""
Get a decoded transaction from a txid
Args:
txid: txid hex string
Returns:
JSON formatted transaction
"""
d = self.session.wallet.get_transaction(txid)
d.addCallback(lambda r: self._render_response(r))
2017-01-03 20:13:01 +01:00
return d
@AuthJSONRPCServer.auth_required
def jsonrpc_address_is_mine(self, address):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `wallet_is_address_mine` instead
"""
return self.jsonrpc_wallet_is_address_mine(address)
2017-01-03 20:13:01 +01:00
@AuthJSONRPCServer.auth_required
def jsonrpc_wallet_is_address_mine(self, address):
2016-09-02 07:27:30 +02:00
"""
Checks if an address is associated with the current wallet.
Args:
address: string
Returns:
is_mine: bool
"""
d = self.session.wallet.address_is_mine(address)
d.addCallback(lambda is_mine: self._render_response(is_mine))
2016-09-02 07:27:30 +02:00
return d
@AuthJSONRPCServer.auth_required
def jsonrpc_get_public_key_from_wallet(self, wallet):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `wallet_is_address_mine` instead
"""
return self.jsonrpc_wallet_public_key(wallet)
2017-01-03 20:13:01 +01:00
@AuthJSONRPCServer.auth_required
def jsonrpc_wallet_public_key(self, wallet):
"""
Get public key from wallet address
Args:
wallet: wallet address, base58
Returns:
public key
"""
d = self.session.wallet.get_pub_keys(wallet)
d.addCallback(lambda r: self._render_response(r))
2017-01-03 20:13:01 +01:00
@AuthJSONRPCServer.auth_required
def jsonrpc_get_new_address(self):
2016-03-24 03:27:48 +01:00
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `wallet_new_address` instead
2016-03-24 03:27:48 +01:00
"""
2017-01-03 20:13:01 +01:00
return self.jsonrpc_wallet_new_address()
@AuthJSONRPCServer.auth_required
2017-01-03 20:13:01 +01:00
def jsonrpc_wallet_new_address(self):
2016-03-24 03:27:48 +01:00
"""
Generate a new wallet address
Args:
None
Returns:
new wallet address, base 58 string
2016-03-24 03:27:48 +01:00
"""
2016-02-25 23:17:07 +01:00
def _disp(address):
log.info("Got new wallet address: " + address)
return defer.succeed(address)
2016-02-25 23:17:07 +01:00
d = self.session.wallet.get_new_address()
d.addCallback(_disp)
d.addCallback(lambda address: self._render_response(address))
2016-02-25 23:17:07 +01:00
return d
@AuthJSONRPCServer.auth_required
def jsonrpc_send_amount_to_address(self, amount, address):
"""
Send credits to an address
Args:
amount: the amount to send
address: the address of the recipient
Returns:
True if payment successfully scheduled
"""
reserved_points = self.session.wallet.reserve_points(address, amount)
if reserved_points is None:
return defer.fail(InsufficientFundsError())
d = self.session.wallet.send_points_to_address(reserved_points, amount)
d.addCallback(lambda _: self._render_response(True))
return d
def jsonrpc_get_block(self, **kwargs):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `block_show` instead
"""
return self.jsonrpc_block_show(**kwargs)
def jsonrpc_block_show(self, blockhash=None, height=None):
"""
Get contents of a block
Args:
blockhash: hash of the block to look up
Returns:
requested block
"""
if blockhash is not None:
d = self.session.wallet.get_block(blockhash)
elif height is not None:
d = self.session.wallet.get_block_info(height)
d.addCallback(lambda b: self.session.wallet.get_block(b))
else:
# TODO: return a useful error message
return server.failure
d.addCallback(lambda r: self._render_response(r))
return d
2017-01-03 20:13:01 +01:00
@AuthJSONRPCServer.auth_required
def jsonrpc_download_descriptor(self, **kwargs):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `blob_get` instead
"""
return self.jsonrpc_blob_get(**kwargs)
@AuthJSONRPCServer.auth_required
def jsonrpc_blob_get(self, sd_hash, timeout=None):
2016-08-02 04:31:49 +02:00
"""
Download and return a sd blob
Args:
sd_hash
timeout (optional)
2016-08-02 04:31:49 +02:00
Returns
sd blob, dict
"""
if timeout is None:
timeout = conf.settings['sd_download_timeout']
2016-08-03 23:57:26 +02:00
d = self._download_sd_blob(sd_hash, timeout)
d.addCallbacks(
lambda r: self._render_response(r),
lambda _: self._render_response(False))
return d
def jsonrpc_get_nametrie(self):
"""
Get the nametrie
Args:
None
Returns:
Name claim trie
"""
d = self.session.wallet.get_nametrie()
d.addCallback(lambda r: [i for i in r if 'txid' in i.keys()])
d.addCallback(lambda r: self._render_response(r))
return d
def jsonrpc_log(self, message):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. This method will be removed in a future release.
2016-05-30 21:49:25 +02:00
Log message
Args:
'message': message to be logged
Returns:
2016-05-30 21:49:25 +02:00
True
"""
log.info("API client log request: %s" % message)
return self._render_response(True)
def jsonrpc_upload_log(self, name_prefix=None, log_type=None, exclude_previous=True,
message=None, force=False):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. This method will be removed in a future release.
Upload log
2016-04-18 09:41:16 +02:00
Args, optional:
'name_prefix': prefix to indicate what is requesting the log upload
2016-11-30 21:20:45 +01:00
'exclude_previous': true/false, whether or not to exclude
previous sessions from upload, defaults on true
2016-05-30 21:49:25 +02:00
Returns:
2016-04-18 09:41:16 +02:00
True
2016-11-30 21:20:45 +01:00
2016-04-18 09:41:16 +02:00
"""
if name_prefix is not None:
log_type = name_prefix + '_api'
elif log_type is not None:
log_type += '_api'
else:
log_type = 'api'
if message is not None:
log.info("Upload log message: " + str(message))
2016-05-21 01:59:49 +02:00
d = self._upload_log(log_type=log_type, exclude_previous=exclude_previous, force=force)
d.addCallback(lambda _: self._render_response(True))
return d
2016-05-30 21:49:25 +02:00
@AuthJSONRPCServer.auth_required
def jsonrpc_configure_ui(self, branch=None, path=None, check_requirements=True):
2016-05-30 21:49:25 +02:00
"""
Configure the UI being hosted
Args, optional:
'branch': a branch name on lbryio/lbry-web-ui
'path': path to a ui folder
"""
if path is not None:
2016-10-22 01:12:38 +02:00
d = self.lbry_ui_manager.setup(
user_specified=path, check_requirements=check_requirements)
elif branch is not None:
d = self.lbry_ui_manager.setup(branch=branch, check_requirements=check_requirements)
else:
d = self.lbry_ui_manager.setup(check_requirements=check_requirements)
d.addCallback(lambda r: self._render_response(r))
2016-05-30 21:49:25 +02:00
return d
2017-01-11 07:20:09 +01:00
@AuthJSONRPCServer.auth_required
@defer.inlineCallbacks
def jsonrpc_open(self, sd_hash):
2017-01-11 07:20:09 +01:00
"""
Instruct the OS to open a file with its default program.
2017-01-11 07:20:09 +01:00
Args:
'sd_hash': SD hash of file to be opened
2017-01-11 07:20:09 +01:00
Returns:
True, opens file
"""
lbry_file = yield self._get_lbry_file(FileID.SD_HASH, sd_hash)
if not lbry_file:
raise Exception('Unable to find file for {}'.format(sd_hash))
try:
file_utils.start(lbry_file['download_path'])
except IOError:
pass
defer.returnValue(True)
2017-01-11 07:20:09 +01:00
@defer.inlineCallbacks
@AuthJSONRPCServer.auth_required
def jsonrpc_reveal(self, sd_hash):
2016-05-30 21:49:25 +02:00
"""
Reveal a file or directory in file browser
2016-05-30 21:49:25 +02:00
Args:
'path': path to be revealed in file browser
2016-05-30 21:49:25 +02:00
Returns:
True, opens file browser
2016-05-30 21:49:25 +02:00
"""
lbry_file = yield self._get_lbry_file(FileID.SD_HASH, sd_hash)
if not lbry_file:
raise Exception('Unable to find file for {}'.format(sd_hash))
try:
file_utils.reveal(lbry_file['download_path'])
except IOError:
pass
defer.returnValue(True)
def jsonrpc_get_peers_for_hash(self, blob_hash):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `peer_list` instead
"""
return self.jsonrpc_peer_list(blob_hash)
2017-01-03 20:13:01 +01:00
def jsonrpc_peer_list(self, blob_hash):
2016-08-03 09:16:06 +02:00
"""
Get peers for blob hash
Args:
'blob_hash': blob hash
Returns:
List of contacts
"""
d = self.session.peer_finder.find_peers_for_blob(blob_hash)
d.addCallback(lambda r: [[c.host, c.port, c.is_available()] for c in r])
d.addCallback(lambda r: self._render_response(r))
2016-08-03 09:16:06 +02:00
return d
2016-08-11 18:36:13 +02:00
def jsonrpc_announce_all_blobs_to_dht(self):
"""
2017-01-03 20:13:01 +01:00
DEPRECATED. Use `blob_announce_all` instead.
"""
return self.jsonrpc_blob_announce_all()
def jsonrpc_blob_announce_all(self):
"""
Announce all blobs to the DHT
2016-08-11 18:36:13 +02:00
Args:
None
Returns:
"""
d = self.session.blob_manager.immediate_announce_all_blobs()
d.addCallback(lambda _: self._render_response("Announced"))
2016-08-11 18:36:13 +02:00
return d
2016-08-11 18:38:10 +02:00
def jsonrpc_reflect(self, sd_hash):
2016-08-18 03:33:41 +02:00
"""
Reflect a stream
Args:
2016-08-27 01:58:53 +02:00
sd_hash: sd_hash of lbry file
2016-08-18 03:33:41 +02:00
Returns:
True or traceback
"""
d = self._get_lbry_file(FileID.SD_HASH, sd_hash, return_json=False)
2016-08-18 03:33:41 +02:00
d.addCallback(self._reflect)
2016-10-27 20:28:56 +02:00
d.addCallbacks(
lambda _: self._render_response(True),
lambda err: self._render_response(err.getTraceback()))
2016-08-18 03:33:41 +02:00
return d
2016-08-26 06:32:33 +02:00
def jsonrpc_get_blob_hashes(self):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `blob_list` instead
"""
return self.jsonrpc_blob_list()
def jsonrpc_blob_list(self):
2016-08-19 08:41:23 +02:00
"""
2016-08-26 06:32:33 +02:00
Returns all blob hashes
Args:
None
Returns:
list of blob hashes
2016-08-19 08:41:23 +02:00
"""
2016-08-26 06:32:33 +02:00
d = self.session.blob_manager.get_all_verified_blobs()
d.addCallback(lambda r: self._render_response(r))
2016-08-27 01:58:53 +02:00
return d
def jsonrpc_reflect_all_blobs(self):
2017-01-03 20:13:01 +01:00
"""
DEPRECATED. Use `blob_reflect_all` instead
"""
return self.jsonrpc_blob_reflect_all()
def jsonrpc_blob_reflect_all(self):
2016-08-27 01:58:53 +02:00
"""
Reflects all saved blobs
Args:
None
Returns:
True
"""
d = self.session.blob_manager.get_all_verified_blobs()
d.addCallback(self._reflect_blobs)
d.addCallback(lambda r: self._render_response(r))
2016-08-19 08:41:23 +02:00
return d
def jsonrpc_get_mean_availability(self):
"""
Get mean blob availability
Args:
None
Returns:
Mean peers for a blob
"""
d = self._render_response(self.session.blob_tracker.last_mean_availability)
return d
def jsonrpc_get_availability(self, name):
2016-09-30 19:28:01 +02:00
"""
Get stream availability for a winning claim
Arg:
name (str): lbry uri
Returns:
peers per blob / total blobs
"""
def _get_mean(blob_availabilities):
peer_counts = []
for blob_availability in blob_availabilities:
for blob, peers in blob_availability.iteritems():
peer_counts.append(peers)
2016-09-30 19:35:13 +02:00
if peer_counts:
return round(1.0 * sum(peer_counts) / len(peer_counts), 2)
else:
return 0.0
2016-09-30 19:28:01 +02:00
d = self._resolve_name(name, force_refresh=True)
2016-09-30 19:28:01 +02:00
d.addCallback(get_sd_hash)
d.addCallback(self._download_sd_blob)
2016-10-27 20:28:56 +02:00
d.addCallbacks(
lambda descriptor: [blob.get('blob_hash') for blob in descriptor['blobs']],
lambda _: [])
2016-09-30 19:28:01 +02:00
d.addCallback(self.session.blob_tracker.get_availability_for_blobs)
d.addCallback(_get_mean)
d.addCallback(lambda result: self._render_response(result))
2016-09-30 19:28:01 +02:00
return d
def jsonrpc_get_start_notice(self):
"""
DEPRECATED.
Get special message to be displayed at startup
Args:
None
Returns:
Startup message, such as first run notification
"""
def _get_startup_message(status):
if status['is_first_run'] and self.session.wallet.wallet_balance:
return self._render_response(None)
else:
return self._render_response(status['startup_status']['message'])
d = self.jsonrpc_status()
d.addCallback(_get_startup_message)
return d
def get_lbryum_version_from_github():
return get_version_from_github('https://api.github.com/repos/lbryio/lbryum/releases/latest')
def get_lbrynet_version_from_github():
return get_version_from_github('https://api.github.com/repos/lbryio/lbry/releases/latest')
def get_version_from_github(url):
"""Return the latest released version from github."""
response = requests.get(url, timeout=20)
release = response.json()
tag = release['tag_name']
# githubs documentation claims this should never happen, but we'll check just in case
if release['prerelease']:
raise Exception('Release {} is a pre-release'.format(tag))
return get_version_from_tag(tag)
def get_version_from_tag(tag):
match = re.match('v([\d.]+)', tag)
if match:
return match.group(1)
else:
raise Exception('Failed to parse version from tag {}'.format(tag))
def get_sd_hash(stream_info):
if not stream_info:
return None
try:
return stream_info['sources']['lbry_sd_hash']
except KeyError:
return stream_info.get('stream_hash')
class _DownloadNameHelper(object):
2016-11-30 21:20:45 +01:00
def __init__(self, daemon, name,
timeout=None,
2016-11-30 21:20:45 +01:00
download_directory=None, file_name=None,
wait_for_write=True):
self.daemon = daemon
self.name = name
2017-01-17 04:23:20 +01:00
self.timeout = timeout if timeout is not None else conf.settings['download_timeout']
if not download_directory or not os.path.isdir(download_directory):
self.download_directory = daemon.download_directory
else:
self.download_directory = download_directory
self.file_name = file_name
self.wait_for_write = wait_for_write
@defer.inlineCallbacks
def setup_stream(self, stream_info):
sd_hash = get_sd_hash(stream_info)
lbry_file = yield self.daemon._get_lbry_file_by_sd_hash(sd_hash)
if self._does_lbry_file_exists(lbry_file):
defer.returnValue(lbry_file)
else:
defer.returnValue(None)
def _does_lbry_file_exists(self, lbry_file):
return lbry_file and os.path.isfile(self._full_path(lbry_file))
def _full_path(self, lbry_file):
return os.path.join(self.download_directory, lbry_file.file_name)
@defer.inlineCallbacks
def wait_or_get_stream(self, stream_info, lbry_file):
if lbry_file:
2016-08-11 20:41:42 +02:00
log.debug('Wait on lbry_file')
# returns the lbry_file
yield self._wait_on_lbry_file(lbry_file)
defer.returnValue((lbry_file.sd_hash, self._full_path(lbry_file)))
else:
2016-08-11 20:41:42 +02:00
log.debug('No lbry_file, need to get stream')
# returns an instance of ManagedEncryptedFileDownloaderFactory
sd_hash, file_path = yield self._get_stream(stream_info)
defer.returnValue((sd_hash, file_path))
def _wait_on_lbry_file(self, f):
file_path = self._full_path(f)
written_bytes = self._get_written_bytes(file_path)
if written_bytes:
log.info("File has bytes: %s --> %s", f.sd_hash, file_path)
return defer.succeed(True)
return task.deferLater(reactor, 1, self._wait_on_lbry_file, f)
@defer.inlineCallbacks
def _get_stream(self, stream_info):
was_successful, sd_hash, download_path = yield self.daemon.add_stream(
self.name, self.timeout, self.download_directory, self.file_name, stream_info)
if not was_successful:
log.warning("lbry://%s timed out, removing from streams", self.name)
del self.daemon.streams[self.name]
self.remove_from_wait("Timed out")
raise Exception("Timed out")
if self.wait_for_write:
yield self._wait_for_write()
defer.returnValue((sd_hash, download_path))
def _wait_for_write(self):
d = defer.succeed(None)
if not self._has_downloader_wrote():
d.addCallback(lambda _: reactor.callLater(1, self._wait_for_write))
return d
def _has_downloader_wrote(self):
stream = self.daemon.streams.get(self.name, False)
if stream:
file_path = self._full_path(stream.downloader)
return self._get_written_bytes(file_path)
else:
return False
def _get_written_bytes(self, file_path):
"""Returns the number of bytes written to `file_path`.
Returns False if there were issues reading `file_path`.
"""
try:
if os.path.isfile(file_path):
with open(file_path) as written_file:
written_file.seek(0, os.SEEK_END)
written_bytes = written_file.tell()
else:
written_bytes = False
except Exception:
writen_bytes = False
return written_bytes
def remove_from_wait(self, reason):
if self.name in self.daemon.waiting_on:
del self.daemon.waiting_on[self.name]
return reason
class _ResolveNameHelper(object):
def __init__(self, daemon, name, force_refresh):
self.daemon = daemon
self.name = name
self.force_refresh = force_refresh
def get_deferred(self):
if self.need_fresh_stream():
log.info("Resolving stream info for lbry://%s", self.name)
d = self.wallet.get_stream_info_for_name(self.name)
2016-10-27 20:28:56 +02:00
d.addCallback(self._cache_stream_info)
else:
2016-08-08 20:58:31 +02:00
log.debug("Returning cached stream info for lbry://%s", self.name)
d = defer.succeed(self.name_data['claim_metadata'])
return d
@property
def name_data(self):
return self.daemon.name_cache[self.name]
@property
def wallet(self):
return self.daemon.session.wallet
def now(self):
return self.daemon._get_long_count_timestamp()
def _add_txid(self, txid):
self.name_data['txid'] = txid
return defer.succeed(None)
def _cache_stream_info(self, stream_info):
self.daemon.name_cache[self.name] = {
'claim_metadata': stream_info,
'timestamp': self.now()
}
d = self.wallet.get_txid_for_name(self.name)
d.addCallback(self._add_txid)
d.addCallback(lambda _: self.daemon._update_claim_cache())
d.addCallback(lambda _: self.name_data['claim_metadata'])
return d
def need_fresh_stream(self):
return self.force_refresh or not self.is_in_cache() or self.is_cached_name_expired()
def is_in_cache(self):
return self.name in self.daemon.name_cache
def is_cached_name_expired(self):
time_in_cache = self.now() - self.name_data['timestamp']
return time_in_cache >= self.daemon.cache_time
class _GetFileHelper(object):
def __init__(self, daemon, search_by, val, return_json=True):
self.daemon = daemon
self.search_by = search_by
self.val = val
self.return_json = return_json
def retrieve_file(self):
2016-09-30 21:09:56 +02:00
d = self.search_for_file()
if self.return_json:
d.addCallback(self._get_json)
return d
def search_for_file(self):
2016-10-19 01:09:35 +02:00
if self.search_by == FileID.NAME:
return self.daemon._get_lbry_file_by_uri(self.val)
2016-10-19 01:09:35 +02:00
elif self.search_by == FileID.SD_HASH:
return self.daemon._get_lbry_file_by_sd_hash(self.val)
2016-10-19 01:09:35 +02:00
elif self.search_by == FileID.FILE_NAME:
return self.daemon._get_lbry_file_by_file_name(self.val)
raise Exception('{} is not a valid search operation'.format(self.search_by))
def _get_json(self, lbry_file):
if lbry_file:
d = lbry_file.get_total_bytes()
d.addCallback(self._generate_reply, lbry_file)
d.addCallback(self._add_metadata, lbry_file)
return d
else:
return False
def _generate_reply(self, size, lbry_file):
written_bytes = self._get_written_bytes(lbry_file)
code, message = self._get_status(lbry_file)
if code == DOWNLOAD_RUNNING_CODE:
d = lbry_file.status()
2016-09-30 21:09:56 +02:00
d.addCallback(self._get_msg_for_file_status)
d.addCallback(
lambda msg: self._get_properties_dict(lbry_file, code, msg, written_bytes, size))
else:
d = defer.succeed(
self._get_properties_dict(lbry_file, code, message, written_bytes, size))
return d
2016-10-19 01:09:35 +02:00
2016-09-30 21:09:56 +02:00
def _get_msg_for_file_status(self, file_status):
message = STREAM_STAGES[2][1] % (
file_status.name, file_status.num_completed, file_status.num_known,
file_status.running_status)
return defer.succeed(message)
def _get_key(self, lbry_file):
return binascii.b2a_hex(lbry_file.key) if lbry_file.key else None
def _full_path(self, lbry_file):
return os.path.join(lbry_file.download_directory, lbry_file.file_name)
def _get_status(self, lbry_file):
2016-10-19 01:09:35 +02:00
if self.search_by == FileID.NAME:
if self.val in self.daemon.streams.keys():
status = self.daemon.streams[self.val].code
elif lbry_file in self.daemon.lbry_file_manager.lbry_files:
status = STREAM_STAGES[2]
else:
status = [False, False]
else:
status = [False, False]
return status
def _get_written_bytes(self, lbry_file):
full_path = self._full_path(lbry_file)
if os.path.isfile(full_path):
with open(full_path) as written_file:
written_file.seek(0, os.SEEK_END)
written_bytes = written_file.tell()
else:
written_bytes = False
return written_bytes
2016-10-19 01:09:35 +02:00
def _get_properties_dict(self, lbry_file, code, message, written_bytes, size):
key = self._get_key(lbry_file)
full_path = self._full_path(lbry_file)
mime_type = mimetypes.guess_type(full_path)[0]
return {
'completed': lbry_file.completed,
'file_name': lbry_file.file_name,
'download_directory': lbry_file.download_directory,
'points_paid': lbry_file.points_paid,
'stopped': lbry_file.stopped,
'stream_hash': lbry_file.stream_hash,
'stream_name': lbry_file.stream_name,
'suggested_file_name': lbry_file.suggested_file_name,
'upload_allowed': lbry_file.upload_allowed,
'sd_hash': lbry_file.sd_hash,
'lbry_uri': lbry_file.uri,
'txid': lbry_file.txid,
'claim_id': lbry_file.claim_id,
'download_path': full_path,
'mime_type': mime_type,
'key': key,
'total_bytes': size,
'written_bytes': written_bytes,
'code': code,
'message': message
}
2016-10-01 17:47:37 +02:00
def _add_metadata(self, message, lbry_file):
def _add_to_dict(metadata):
message['metadata'] = metadata
return defer.succeed(message)
if lbry_file.txid:
2016-09-30 21:09:56 +02:00
d = self.daemon._resolve_name(lbry_file.uri)
d.addCallbacks(_add_to_dict, lambda _: _add_to_dict("Pending confirmation"))
else:
d = defer.succeed(message)
return d
2017-01-02 20:52:24 +01:00
def loggly_time_string(dt):
formatted_dt = dt.strftime("%Y-%m-%dT%H:%M:%S")
2017-01-03 20:13:01 +01:00
milliseconds = str(round(dt.microsecond * (10.0 ** -5), 3))
2017-01-02 22:09:28 +01:00
return urllib.quote_plus(formatted_dt + milliseconds + "Z")
2017-01-02 20:52:24 +01:00
def get_loggly_query_string(installation_id):
2017-01-02 22:09:28 +01:00
base_loggly_search_url = "https://lbry.loggly.com/search#"
2017-01-02 20:52:24 +01:00
now = utils.now()
yesterday = now - utils.timedelta(days=1)
2017-01-02 22:09:28 +01:00
params = {
'terms': 'json.installation_id:{}*'.format(installation_id[:SHORT_ID_LEN]),
2017-01-02 22:09:28 +01:00
'from': loggly_time_string(yesterday),
'to': loggly_time_string(now)
}
data = urllib.urlencode(params)
return base_loggly_search_url + data
2017-01-02 20:52:24 +01:00
def report_bug_to_slack(message, installation_id, platform_name, app_version):
webhook = utils.deobfuscate(conf.settings['SLACK_WEBHOOK'])
2017-01-02 20:52:24 +01:00
payload_template = "os: %s\n version: %s\n<%s|loggly>\n%s"
payload_params = (
platform_name,
app_version,
get_loggly_query_string(installation_id),
2017-01-02 20:52:24 +01:00
message
)
payload = {
"text": payload_template % payload_params
}
requests.post(webhook, json.dumps(payload))
def get_lbry_file_search_value(search_fields):
for searchtype in (FileID.SD_HASH, FileID.NAME, FileID.FILE_NAME):
value = search_fields.get(searchtype)
if value:
return searchtype, value
raise NoValidSearch('{} is missing a valid search type'.format(search_fields))
2016-10-27 20:28:56 +02:00
2016-11-10 20:55:31 +01:00
def run_reflector_factory(factory):
2017-01-17 04:23:20 +01:00
reflector_server = random.choice(conf.settings['reflector_servers'])
2016-11-10 20:55:31 +01:00
reflector_address, reflector_port = reflector_server
log.info("Start reflector client")
d = reactor.resolve(reflector_address)
d.addCallback(lambda ip: reactor.connectTCP(ip, reflector_port, factory))
d.addCallback(lambda _: factory.finished_deferred)
2016-12-19 19:40:33 +01:00
return d