lbry-sdk/lbrynet/lbrynet_console/plugins/BlindRepeater/BlindRepeaterControlHandlers.py

from lbrynet.lbrynet_console.ControlHandlers import ControlHandler, ControlHandlerFactory
from lbrynet.lbrynet_console.ControlHandlers import RecursiveControlHandler, ModifyPaymentRate
from twisted.internet import defer


class StartRepeater(ControlHandler):
    prompt_description = "Start the blind repeater"

    def __init__(self, repeater, settings):
        self.repeater = repeater
        self.settings = settings

    def handle_line(self, line):
        assert line is None, "Start repeater should not be passed any arguments"
        d = self.settings.save_repeater_status(running=True)
        d.addCallback(lambda _: self.repeater.start())
        d.addCallback(lambda _: "Started the repeater")
        return True, d


class StartRepeaterFactory(ControlHandlerFactory):
    control_handler_class = StartRepeater


class StopRepeater(ControlHandler):
    prompt_description = "Stop the blind repeater"

    def __init__(self, repeater, settings):
        self.repeater = repeater
        self.settings = settings

    def handle_line(self, line):
        assert line is None, "Stop repeater should not be passed any arguments"
        d = self.settings.save_repeater_status(running=False)
        d.addCallback(lambda _: self.repeater.stop())
        d.addCallback(lambda _: "Stopped the repeater")
        return True, d


class StopRepeaterFactory(ControlHandlerFactory):
    control_handler_class = StopRepeater


class UpdateMaxSpace(ControlHandler):
    prompt_description = "Set the maximum space to be used by the blind repeater"
    line_prompt = "Maximum space (in bytes):"

    def __init__(self, repeater, settings):
        self.repeater = repeater
        self.settings = settings

    def handle_line(self, line):
        if line is None:
            return False, defer.succeed(self.line_prompt)
        return True, self._set_max_space(line)

    def _set_max_space(self, line):
        max_space = int(line)
        d = self.settings.save_max_space(max_space)
        d.addCallback(lambda _: self.repeater.set_max_space(max_space))
        d.addCallback(lambda _: "Set the maximum space to " + str(max_space) + " bytes")
        return d


class UpdateMaxSpaceFactory(ControlHandlerFactory):
    control_handler_class = UpdateMaxSpace


class AddApprovedPeer(ControlHandler):
    prompt_description = "Add a peer to the approved list of peers to check for valuable blob hashes"
    host_prompt = "Peer host in dotted quad (e.g. 127.0.0.1)"
    port_prompt = "Peer port (e.g. 4444)"

    def __init__(self, repeater, peer_manager, settings):
        self.repeater = repeater
        self.peer_manager = peer_manager
        self.settings = settings
        self.host_to_add = None

    def handle_line(self, line):
        if line is None:
            return False, defer.succeed(self.host_prompt)
        elif self.host_to_add is None:
            self.host_to_add = line
            return False, defer.succeed(self.port_prompt)
        else:
            self.host_to_add, host = None, self.host_to_add
            return True, self._add_peer(host, line)

    def _add_peer(self, host, port):
        peer = self.peer_manager.get_peer(host, int(port))
        d = self.settings.save_approved_peer(host, int(port))
        d.addCallback(lambda _: self.repeater.add_approved_peer(peer))
        d.addCallback(lambda _: "Successfully added peer")
        return d


class AddApprovedPeerFactory(ControlHandlerFactory):
    control_handler_class = AddApprovedPeer


class ApprovedPeerChooser(RecursiveControlHandler):

    def __init__(self, repeater, factory_class, *args, **kwargs):
        self.repeater = repeater
        self.factory_class = factory_class
        self.args = args
        RecursiveControlHandler.__init__(self, **kwargs)

    def _get_control_handler_factories(self):
        control_handler_factories = []
        for peer in self.repeater.approved_peers:
            control_handler_factories.append(self.factory_class(peer, *self.args))
        return control_handler_factories


class ApprovedPeerChooserFactory(ControlHandlerFactory):
    def get_prompt_description(self):
        peer = self.args[0]
        return str(peer)


class DeleteApprovedPeerChooser(ApprovedPeerChooser):
    prompt_description = "Remove a peer from the approved list of peers to check for valuable blob hashes"

    def __init__(self, repeater, settings):
        ApprovedPeerChooser.__init__(self, repeater, DeleteApprovedPeerFactory, repeater, settings,
                                     exit_after_one_done=True)


class DeleteApprovedPeerChooserFactory(ControlHandlerFactory):
    control_handler_class = DeleteApprovedPeerChooser


class DeleteApprovedPeer(ControlHandler):
    prompt_description = "Remove a peer from the approved list of peers to check for valuable blob hashes"

    def __init__(self, peer, repeater, settings):
        self.repeater = repeater
        self.settings = settings
        self.peer_to_remove = peer

    def handle_line(self, line):
        return True, self._remove_peer()

    def _remove_peer(self):
        d = self.settings.remove_approved_peer(self.peer_to_remove.host, int(self.peer_to_remove.port))
        d.addCallback(lambda _: self.repeater.remove_approved_peer(self.peer_to_remove))
        d.addCallback(lambda _: "Successfully removed peer")
        return d


class DeleteApprovedPeerFactory(ApprovedPeerChooserFactory):
    control_handler_class = DeleteApprovedPeer


class ShowApprovedPeers(ControlHandler):
    prompt_description = "Show the list of peers approved to be checked for valuable blob hashes"

    def __init__(self, repeater):
        self.repeater = repeater

    def handle_line(self, line):
        assert line is None, "Show approved peers should not be passed any arguments"
        return True, self._show_peers()

    def _show_peers(self):
        peer_string = "Approved peers:\n"
        for peer in self.repeater.approved_peers:
            peer_string += str(peer) + "\n"
        return defer.succeed(peer_string)


class ShowApprovedPeersFactory(ControlHandlerFactory):
    control_handler_class = ShowApprovedPeers


class RepeaterStatus(ControlHandler):
    prompt_description = "Show the repeater's status"

    def __init__(self, repeater):
        self.repeater = repeater

    def handle_line(self, line):
        assert line is None, "Show repeater status should not be passed any arguments"
        return True, defer.maybeDeferred(self._get_status)

    def _get_status(self):
        status_string = "Repeater status: " + self.repeater.status() + "\n"

        if self.repeater.stopped is False:
            max_space = self.repeater.progress_manager.max_space
            space_used = 0
            for blob in self.repeater.download_manager.blobs:
                if blob.is_validated():
                    space_used += blob.get_length()

            status_string += "Maximum space: " + str(max_space) + " bytes\n"
            status_string += "Space used: " + str(space_used) + " bytes\n"
        return defer.succeed(status_string)


class RepeaterStatusFactory(ControlHandlerFactory):
    control_handler_class = RepeaterStatus


class ModifyDataPaymentRate(ModifyPaymentRate):
    prompt_description = "Modify Blind Repeater data payment rate"

    def __init__(self, repeater, settings):
        ModifyPaymentRate.__init__(self)
        self._prompt_choices['unset'] = (self._unset, "Use the application default data rate")
        self.payment_rate_manager = repeater.payment_rate_manager
        self.settings = settings

    def _unset(self):
        self._set_rate(None)
        return True, defer.succeed("Using the application default data rate")

    def _set_rate(self, rate):

        def set_data_payment_rate(rate):
            self.payment_rate_manager.min_blob_data_payment_rate = rate

        d = self.settings.save_data_payment_rate(rate)
        d.addCallback(lambda _: set_data_payment_rate(rate))
        return d

    def _get_current_status(self):
        effective_rate = self.payment_rate_manager.get_effective_min_blob_data_payment_rate()
        if self.payment_rate_manager.min_blob_data_payment_rate is None:
            status = "The current data payment rate is set to use the application default, "
            status += str(effective_rate)
        else:
            status = "The current data payment rate is "
            status += str(effective_rate)
        return status


class ModifyDataPaymentRateFactory(ControlHandlerFactory):
    control_handler_class = ModifyDataPaymentRate


class ModifyInfoPaymentRate(ModifyPaymentRate):
    prompt_description = "Modify Blind Repeater valuable info payment rate"

    def __init__(self, repeater, settings):
        ModifyPaymentRate.__init__(self)
        self.payment_rate_manager = repeater.payment_rate_manager
        self.settings = settings

    def _set_rate(self, rate):

        def set_info_payment_rate(rate):
            self.payment_rate_manager.min_valuable_blob_info_payment_rate = rate

        d = self.settings.save_valuable_info_payment_rate(rate)
        d.addCallback(lambda _: set_info_payment_rate(rate))
        return d

    def _get_current_status(self):
        status = "The current valuable blob info payment rate is "
        status += str(self.payment_rate_manager.min_valuable_blob_info_payment_rate)
        return status


class ModifyInfoPaymentRateFactory(ControlHandlerFactory):
    control_handler_class = ModifyInfoPaymentRate


class ModifyHashPaymentRate(ModifyPaymentRate):
    prompt_description = "Modify Blind Repeater valuable hash payment rate"

    def __init__(self, repeater, settings):
        ModifyPaymentRate.__init__(self)
        self.payment_rate_manager = repeater.payment_rate_manager
        self.settings = settings

    def _set_rate(self, rate):

        def set_hash_payment_rate(rate):
            self.payment_rate_manager.min_valuable_blob_hash_payment_rate = rate

        d = self.settings.save_valuable_hash_payment_rate(rate)
        d.addCallback(lambda _: set_hash_payment_rate(rate))
        return d

    def _get_current_status(self):
        status = "The current valuable blob hash payment rate is "
        status += str(self.payment_rate_manager.min_valuable_blob_hash_payment_rate)
        return status


class ModifyHashPaymentRateFactory(ControlHandlerFactory):
    control_handler_class = ModifyHashPaymentRate


class ModifyRepeaterOptions(RecursiveControlHandler):
    prompt_description = "Modify Blind Repeater options"

    def __init__(self, repeater, lbry_session, settings):
        self.repeater = repeater
        self.lbry_session = lbry_session
        self.settings = settings
        RecursiveControlHandler.__init__(self)

    def _get_control_handler_factories(self):
        return [ModifyDataPaymentRateFactory(self.repeater, self.settings),
                ModifyInfoPaymentRateFactory(self.repeater, self.settings),
                ModifyHashPaymentRateFactory(self.repeater, self.settings),
                UpdateMaxSpaceFactory(self.repeater, self.settings),
                AddApprovedPeerFactory(self.repeater, self.lbry_session.peer_manager, self.settings),
                DeleteApprovedPeerChooserFactory(self.repeater, self.settings),
                ]


class ModifyRepeaterOptionsFactory(ControlHandlerFactory):
    control_handler_class = ModifyRepeaterOptions