lbry-sdk/lbrynet/lbryfilemanager/EncryptedFileDownloader.py

201 lines
7.8 KiB
Python
Raw Normal View History

2015-08-20 17:27:15 +02:00
"""
Download LBRY Files from LBRYnet and save them to disk.
"""
from zope.interface import implements
from lbrynet.core.client.StreamProgressManager import FullStreamProgressManager
from lbrynet.core.StreamDescriptor import StreamMetadata
2016-09-27 20:18:16 +02:00
from lbrynet.lbryfile.client.EncryptedFileDownloader import EncryptedFileSaver, EncryptedFileDownloader
from lbrynet.lbryfilemanager.EncryptedFileStatusReport import EncryptedFileStatusReport
2015-08-20 17:27:15 +02:00
from lbrynet.interfaces import IStreamDownloaderFactory
from lbrynet.lbryfile.StreamDescriptor import save_sd_info
from twisted.internet import defer
import logging
log = logging.getLogger(__name__)
2015-08-20 17:27:15 +02:00
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, stream_info_manager,
2015-08-20 17:27:15 +02:00
lbry_file_manager, payment_rate_manager, wallet, download_directory, upload_allowed,
file_name=None):
2016-09-27 20:18:16 +02:00
EncryptedFileSaver.__init__(self, stream_hash, peer_finder, rate_limiter, blob_manager,
2015-08-20 17:27:15 +02:00
stream_info_manager, payment_rate_manager, wallet, download_directory,
upload_allowed, file_name)
self.sd_hash = None
2016-05-11 01:03:14 +02:00
self.txid = None
self.uri = None
self.claim_id = None
self.rowid = rowid
2015-08-20 17:27:15 +02:00
self.lbry_file_manager = lbry_file_manager
self.saving_status = False
def restore(self):
d = self.stream_info_manager._get_sd_blob_hashes_for_stream(self.stream_hash)
def _save_sd_hash(sd_hash):
if len(sd_hash):
self.sd_hash = sd_hash[0]
2016-05-11 01:03:14 +02:00
d = self.wallet._get_claim_metadata_for_sd_hash(self.sd_hash)
else:
d = defer.succeed(None)
return d
def _save_claim_id(claim_id):
self.claim_id = claim_id
return defer.succeed(None)
def _notify_bad_claim(name, txid):
log.error("Error loading name claim for lbry file: lbry://%s, tx %s does not contain a valid claim", name, txid)
log.warning("lbry file for lbry://%s, tx %s has no claim, deleting it", name, txid)
return self.lbry_file_manager.delete_lbry_file(self)
2016-05-11 01:03:14 +02:00
def _save_claim(name, txid):
self.uri = name
self.txid = txid
d = self.wallet.get_claimid(name, txid)
d.addCallbacks(_save_claim_id, lambda err: _notify_bad_claim(name, txid))
return d
d.addCallback(_save_sd_hash)
2016-05-11 01:03:14 +02:00
d.addCallback(lambda r: _save_claim(r[0], r[1]) if r else None)
d.addCallback(lambda _: self.lbry_file_manager.get_lbry_file_status(self))
2015-08-20 17:27:15 +02:00
def restore_status(status):
2016-09-27 20:18:16 +02:00
if status == ManagedEncryptedFileDownloader.STATUS_RUNNING:
2015-08-20 17:27:15 +02:00
return self.start()
2016-09-27 20:18:16 +02:00
elif status == ManagedEncryptedFileDownloader.STATUS_STOPPED:
2015-08-20 17:27:15 +02:00
return defer.succeed(False)
2016-09-27 20:18:16 +02:00
elif status == ManagedEncryptedFileDownloader.STATUS_FINISHED:
2015-08-20 17:27:15 +02:00
self.completed = True
return defer.succeed(True)
d.addCallback(restore_status)
return d
def stop(self, err=None, change_status=True):
2015-08-20 17:27:15 +02:00
def set_saving_status_done():
self.saving_status = False
2016-09-27 20:18:16 +02:00
d = EncryptedFileDownloader.stop(self, err=err) # EncryptedFileSaver deletes metadata when it's stopped. We don't want that here.
2015-08-20 17:27:15 +02:00
if change_status is True:
self.saving_status = True
d.addCallback(lambda _: self._save_status())
d.addCallback(lambda _: set_saving_status_done())
return d
def status(self):
def find_completed_blobhashes(blobs):
blobhashes = [b[0] for b in blobs if b[0] is not None]
def get_num_completed(completed_blobs):
return len(completed_blobs), len(blobhashes)
inner_d = self.blob_manager.completed_blobs(blobhashes)
inner_d.addCallback(get_num_completed)
return inner_d
def make_full_status(progress):
num_completed = progress[0]
num_known = progress[1]
if self.completed is True:
s = "completed"
elif self.stopped is True:
s = "stopped"
else:
s = "running"
2016-09-27 20:18:16 +02:00
status = EncryptedFileStatusReport(self.file_name, num_completed, num_known, s)
2015-08-20 17:27:15 +02:00
return status
d = self.stream_info_manager.get_blobs_for_stream(self.stream_hash)
d.addCallback(find_completed_blobhashes)
d.addCallback(make_full_status)
return d
def _start(self):
2016-09-27 20:18:16 +02:00
d = EncryptedFileSaver._start(self)
2015-08-20 17:27:15 +02:00
d.addCallback(lambda _: self.stream_info_manager._get_sd_blob_hashes_for_stream(self.stream_hash))
def _save_sd_hash(sd_hash):
if len(sd_hash):
self.sd_hash = sd_hash[0]
d = self.wallet._get_claim_metadata_for_sd_hash(self.sd_hash)
else:
d = defer.succeed(None)
return d
def _save_claim(name, txid):
self.uri = name
self.txid = txid
return defer.succeed(None)
d.addCallback(_save_sd_hash)
d.addCallback(lambda r: _save_claim(r[0], r[1]) if r else None)
2015-08-20 17:27:15 +02:00
d.addCallback(lambda _: self._save_status())
return d
def _get_finished_deferred_callback_value(self):
if self.completed is True:
return "Download successful"
else:
return "Download stopped"
def _save_status(self):
if self.completed is True:
2016-09-27 20:18:16 +02:00
s = ManagedEncryptedFileDownloader.STATUS_FINISHED
2015-08-20 17:27:15 +02:00
elif self.stopped is True:
2016-09-27 20:18:16 +02:00
s = ManagedEncryptedFileDownloader.STATUS_STOPPED
2015-08-20 17:27:15 +02:00
else:
2016-09-27 20:18:16 +02:00
s = ManagedEncryptedFileDownloader.STATUS_RUNNING
return self.lbry_file_manager.change_lbry_file_status(self, s)
2015-08-20 17:27:15 +02:00
def _get_progress_manager(self, download_manager):
return FullStreamProgressManager(self._finished_downloading, self.blob_manager, download_manager)
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):
self.lbry_file_manager = lbry_file_manager
def can_download(self, sd_validator):
return True
2015-08-20 17:27:15 +02:00
def make_downloader(self, metadata, options, payment_rate_manager, download_directory=None, file_name=None):
2015-08-20 17:27:15 +02:00
data_rate = options[0]
upload_allowed = options[1]
def save_source_if_blob(stream_hash):
if metadata.metadata_source == StreamMetadata.FROM_BLOB:
d = self.lbry_file_manager.stream_info_manager.save_sd_blob_hash_to_stream(stream_hash,
metadata.source_blob_hash)
else:
d = defer.succeed(True)
d.addCallback(lambda _: stream_hash)
return d
d = save_sd_info(self.lbry_file_manager.stream_info_manager, metadata.validator.raw_info)
d.addCallback(save_source_if_blob)
2015-08-20 17:27:15 +02:00
d.addCallback(lambda stream_hash: self.lbry_file_manager.add_lbry_file(stream_hash,
payment_rate_manager,
data_rate,
upload_allowed,
download_directory=download_directory,
file_name=file_name))
2015-08-20 17:27:15 +02:00
return d
@staticmethod
def get_description():
2015-08-20 17:27:15 +02:00
return "Save the file to disk"