lbry-sdk/lbrynet/file_manager/EncryptedFileDownloader.py

193 lines
7.5 KiB
Python
Raw Normal View History

2015-08-20 17:27:15 +02:00
"""
Download LBRY Files from LBRYnet and save them to disk.
"""
import logging
import binascii
2015-08-20 17:27:15 +02:00
from zope.interface import implements
2016-10-28 20:22:37 +02:00
from twisted.internet import defer
from lbrynet import conf
2015-08-20 17:27:15 +02:00
from lbrynet.core.client.StreamProgressManager import FullStreamProgressManager
from lbrynet.core.HTTPBlobDownloader import HTTPBlobDownloader
from lbrynet.core.utils import short_hash
from lbrynet.lbry_file.client.EncryptedFileDownloader import EncryptedFileSaver
from lbrynet.lbry_file.client.EncryptedFileDownloader import EncryptedFileDownloader
from lbrynet.file_manager.EncryptedFileStatusReport import EncryptedFileStatusReport
2015-08-20 17:27:15 +02:00
from lbrynet.interfaces import IStreamDownloaderFactory
from lbrynet.core.StreamDescriptor import save_sd_info
log = logging.getLogger(__name__)
2015-08-20 17:27:15 +02:00
def log_status(sd_hash, status):
if status == ManagedEncryptedFileDownloader.STATUS_RUNNING:
status_string = "running"
elif status == ManagedEncryptedFileDownloader.STATUS_STOPPED:
status_string = "stopped"
elif status == ManagedEncryptedFileDownloader.STATUS_FINISHED:
status_string = "finished"
else:
status_string = "unknown"
2017-12-29 20:09:21 +01:00
log.debug("stream %s is %s", short_hash(sd_hash), status_string)
2016-09-27 20:18:16 +02:00
class ManagedEncryptedFileDownloader(EncryptedFileSaver):
2015-08-20 17:27:15 +02:00
STATUS_RUNNING = "running"
STATUS_STOPPED = "stopped"
STATUS_FINISHED = "finished"
def __init__(self, rowid, stream_hash, peer_finder, rate_limiter, blob_manager, storage, lbry_file_manager,
payment_rate_manager, wallet, download_directory, file_name, stream_name, sd_hash, key,
suggested_file_name, download_mirrors=None):
EncryptedFileSaver.__init__(
self, stream_hash, peer_finder, rate_limiter, blob_manager, storage, payment_rate_manager, wallet,
download_directory, key, stream_name, file_name
)
self.sd_hash = sd_hash
self.rowid = rowid
self.suggested_file_name = binascii.unhexlify(suggested_file_name)
2015-08-20 17:27:15 +02:00
self.lbry_file_manager = lbry_file_manager
2017-01-11 18:53:43 +01:00
self._saving_status = False
self.claim_id = None
self.outpoint = None
self.claim_name = None
self.txid = None
self.nout = None
self.channel_claim_id = None
self.channel_name = None
self.metadata = None
self.mirror = None
if download_mirrors or conf.settings['download_mirrors']:
self.mirror = HTTPBlobDownloader(
self.blob_manager, servers=download_mirrors or conf.settings['download_mirrors']
)
2018-05-09 15:50:44 +02:00
def set_claim_info(self, claim_info):
self.claim_id = claim_info['claim_id']
self.txid = claim_info['txid']
self.nout = claim_info['nout']
self.channel_claim_id = claim_info['channel_claim_id']
self.outpoint = "%s:%i" % (self.txid, self.nout)
self.claim_name = claim_info['name']
self.channel_name = claim_info['channel_name']
self.metadata = claim_info['value']['stream']['metadata']
@defer.inlineCallbacks
def get_claim_info(self, include_supports=True):
claim_info = yield self.storage.get_content_claim(self.stream_hash, include_supports)
if claim_info:
2018-05-09 15:50:44 +02:00
self.set_claim_info(claim_info)
defer.returnValue(claim_info)
2017-01-11 18:53:43 +01:00
@property
def saving_status(self):
return self._saving_status
2015-08-20 17:27:15 +02:00
2017-12-29 20:10:16 +01:00
def restore(self, status):
if status == ManagedEncryptedFileDownloader.STATUS_RUNNING:
# start returns self.finished_deferred
# which fires when we've finished downloading the file
# and we don't want to wait for the entire download
self.start()
elif status == ManagedEncryptedFileDownloader.STATUS_STOPPED:
2017-12-29 20:10:16 +01:00
pass
elif status == ManagedEncryptedFileDownloader.STATUS_FINISHED:
self.completed = True
else:
raise Exception("Unknown status for stream %s: %s" % (self.stream_hash, status))
2015-08-20 17:27:15 +02:00
2017-01-11 18:53:43 +01:00
@defer.inlineCallbacks
def stop(self, err=None, change_status=True):
log.debug('Stopping download for stream %s', short_hash(self.stream_hash))
if self.mirror:
self.mirror.stop()
# EncryptedFileSaver deletes metadata when it's stopped. We don't want that here.
2017-01-11 18:53:43 +01:00
yield EncryptedFileDownloader.stop(self, err=err)
2015-08-20 17:27:15 +02:00
if change_status is True:
2017-01-11 18:53:43 +01:00
status = yield self._save_status()
defer.returnValue(status)
2015-08-20 17:27:15 +02:00
@defer.inlineCallbacks
2015-08-20 17:27:15 +02:00
def status(self):
blobs = yield self.storage.get_blobs_for_stream(self.stream_hash)
blob_hashes = [b.blob_hash for b in blobs if b.blob_hash is not None]
completed_blobs = yield self.blob_manager.completed_blobs(blob_hashes)
num_blobs_completed = len(completed_blobs)
num_blobs_known = len(blob_hashes)
if self.completed:
status = "completed"
elif self.stopped:
status = "stopped"
else:
status = "running"
defer.returnValue(EncryptedFileStatusReport(
self.file_name, num_blobs_completed, num_blobs_known, status
))
2015-08-20 17:27:15 +02:00
@defer.inlineCallbacks
def _start(self):
yield EncryptedFileSaver._start(self)
2016-12-30 07:51:03 +01:00
status = yield self._save_status()
log_status(self.sd_hash, status)
if self.mirror:
self.mirror.download_stream(self.stream_hash, self.sd_hash)
2016-12-30 07:51:03 +01:00
defer.returnValue(status)
2015-08-20 17:27:15 +02:00
def _get_finished_deferred_callback_value(self):
if self.completed is True:
return "Download successful"
else:
return "Download stopped"
@defer.inlineCallbacks
2015-08-20 17:27:15 +02:00
def _save_status(self):
self._saving_status = True
2015-08-20 17:27:15 +02:00
if self.completed is True:
status = ManagedEncryptedFileDownloader.STATUS_FINISHED
2015-08-20 17:27:15 +02:00
elif self.stopped is True:
status = ManagedEncryptedFileDownloader.STATUS_STOPPED
2015-08-20 17:27:15 +02:00
else:
status = ManagedEncryptedFileDownloader.STATUS_RUNNING
status = yield self.lbry_file_manager.change_lbry_file_status(self, status)
self._saving_status = False
defer.returnValue(status)
2015-08-20 17:27:15 +02:00
def save_status(self):
return self._save_status()
2015-08-20 17:27:15 +02:00
def _get_progress_manager(self, download_manager):
2016-11-30 21:20:45 +01:00
return FullStreamProgressManager(self._finished_downloading,
self.blob_manager, download_manager)
2015-08-20 17:27:15 +02:00
2016-09-27 20:18:16 +02:00
class ManagedEncryptedFileDownloaderFactory(object):
2015-08-20 17:27:15 +02:00
implements(IStreamDownloaderFactory)
def __init__(self, lbry_file_manager, blob_manager):
2015-08-20 17:27:15 +02:00
self.lbry_file_manager = lbry_file_manager
self.blob_manager = blob_manager
2015-08-20 17:27:15 +02:00
def can_download(self, sd_validator):
# TODO: add a sd_validator for non live streams, use it
return True
2015-08-20 17:27:15 +02:00
@defer.inlineCallbacks
def make_downloader(self, metadata, data_rate, payment_rate_manager, download_directory, file_name=None,
download_mirrors=None):
stream_hash = yield save_sd_info(self.blob_manager,
metadata.source_blob_hash,
metadata.validator.raw_info)
if file_name:
file_name = binascii.hexlify(file_name)
lbry_file = yield self.lbry_file_manager.add_downloaded_file(
stream_hash, metadata.source_blob_hash, binascii.hexlify(download_directory), payment_rate_manager,
data_rate, file_name=file_name, download_mirrors=download_mirrors
)
defer.returnValue(lbry_file)
2015-08-20 17:27:15 +02:00
@staticmethod
def get_description():
return "Save the file to disk"