lbry-sdk/lbrynet/file_manager/EncryptedFileDownloader.py

"""
Download LBRY Files from LBRYnet and save them to disk.
"""
import logging
import binascii

from zope.interface import implements
from twisted.internet import defer
from lbrynet import conf
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
from lbrynet.interfaces import IStreamDownloaderFactory
from lbrynet.core.StreamDescriptor import save_sd_info

log = logging.getLogger(__name__)


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"
    log.debug("stream %s is %s", short_hash(sd_hash), status_string)


class ManagedEncryptedFileDownloader(EncryptedFileSaver):
    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)
        self.lbry_file_manager = lbry_file_manager
        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']
            )

    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:
            self.set_claim_info(claim_info)

        defer.returnValue(claim_info)

    @property
    def saving_status(self):
        return self._saving_status

    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:
            pass
        elif status == ManagedEncryptedFileDownloader.STATUS_FINISHED:
            self.completed = True
        else:
            raise Exception("Unknown status for stream %s: %s" % (self.stream_hash, status))

    @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.
        yield EncryptedFileDownloader.stop(self, err=err)
        if change_status is True:
            status = yield self._save_status()
            defer.returnValue(status)

    @defer.inlineCallbacks
    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
        ))

    @defer.inlineCallbacks
    def _start(self):
        yield EncryptedFileSaver._start(self)
        status = yield self._save_status()
        log_status(self.sd_hash, status)
        if self.mirror:
            self.mirror.download_stream(self.stream_hash, self.sd_hash)
        defer.returnValue(status)

    def _get_finished_deferred_callback_value(self):
        if self.completed is True:
            return "Download successful"
        else:
            return "Download stopped"

    @defer.inlineCallbacks
    def _save_status(self):
        self._saving_status = True
        if self.completed is True:
            status = ManagedEncryptedFileDownloader.STATUS_FINISHED
        elif self.stopped is True:
            status = ManagedEncryptedFileDownloader.STATUS_STOPPED
        else:
            status = ManagedEncryptedFileDownloader.STATUS_RUNNING
        status = yield self.lbry_file_manager.change_lbry_file_status(self, status)
        self._saving_status = False
        defer.returnValue(status)

    def save_status(self):
        return self._save_status()

    def _get_progress_manager(self, download_manager):
        return FullStreamProgressManager(self._finished_downloading,
                                         self.blob_manager, download_manager)


class ManagedEncryptedFileDownloaderFactory(object):
    implements(IStreamDownloaderFactory)

    def __init__(self, lbry_file_manager, blob_manager):
        self.lbry_file_manager = lbry_file_manager
        self.blob_manager = blob_manager

    def can_download(self, sd_validator):
        # TODO: add a sd_validator for non live streams, use it
        return True

    @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)

    @staticmethod
    def get_description():
        return "Save the file to disk"