예제 #1
0
파일: Console.py 프로젝트: iarebatman/lbry
 def get_blob_request_handler_factory(rate):
     self.blob_request_payment_rate_manager = PaymentRateManager(
         self.session.base_payment_rate_manager, rate)
     handlers.append(
         BlobRequestHandlerFactory(
             self.session.blob_manager, self.session.wallet,
             self.blob_request_payment_rate_manager))
예제 #2
0
파일: Components.py 프로젝트: nasht12/lbry
    def start(self):
        wallet = self.component_manager.get_component(WALLET_COMPONENT)
        upnp = self.component_manager.get_component(UPNP_COMPONENT)
        peer_port = GCS('peer_port')
        query_handlers = {
            handler.get_primary_query_identifier(): handler
            for handler in [
                BlobRequestHandlerFactory(
                    self.component_manager.get_component(
                        BLOB_COMPONENT), wallet,
                    self.component_manager.get_component(
                        PAYMENT_RATE_COMPONENT),
                    self.component_manager.analytics_manager),
                wallet.get_wallet_info_query_handler_factory(),
            ]
        }
        server_factory = ServerProtocolFactory(
            self.component_manager.get_component(RATE_LIMITER_COMPONENT),
            query_handlers,
            self.component_manager.get_component(DHT_COMPONENT).peer_manager)

        try:
            log.info("Peer protocol listening on TCP %i (ext port %i)",
                     peer_port, upnp.upnp_redirects.get("TCP", peer_port))
            self.lbry_server_port = yield reactor.listenTCP(
                peer_port, server_factory)
        except error.CannotListenError as e:
            import traceback
            log.error(
                "Couldn't bind to port %d. Visit lbry.io/faq/how-to-change-port for"
                " more details.", peer_port)
            log.error("%s", traceback.format_exc())
            raise ValueError(
                "%s lbrynet may already be running on your computer." % str(e))
예제 #3
0
    def _start_server(self):
        query_handler_factories = [
            CryptBlobInfoQueryHandlerFactory(self.stream_info_manager, self.session.wallet,
                                             self.payment_rate_manager),
            BlobAvailabilityHandlerFactory(self.session.blob_manager),
            BlobRequestHandlerFactory(self.session.blob_manager, self.session.wallet,
                                      self.payment_rate_manager),
            self.session.wallet.get_wallet_info_query_handler_factory()
        ]

        self.server_factory = ServerProtocolFactory(self.session.rate_limiter,
                                                    query_handler_factories,
                                                    self.session.peer_manager)
        from twisted.internet import reactor
        self.lbry_server_port = reactor.listenTCP(self.peer_port, self.server_factory)
예제 #4
0
    def start_listening():
        logging.debug("Starting the server protocol")
        query_handler_factories = {
            CryptBlobInfoQueryHandlerFactory(stream_info_manager, session.wallet, session.payment_rate_manager):
            True,
            BlobRequestHandlerFactory(session.blob_manager, session.wallet, session.payment_rate_manager,
                                      analytics.Track()):
            True,
            session.wallet.get_wallet_info_query_handler_factory():
            True,
        }

        server_factory = ServerProtocolFactory(session.rate_limiter,
                                               query_handler_factories,
                                               session.peer_manager)
        server_port.append(reactor.listenTCP(5553, server_factory))
        logging.debug("Server protocol has started")
예제 #5
0
파일: test_misc.py 프로젝트: tml/lbry
 def start_server(self):
     session = self.session
     query_handler_factories = {
         1: BlobAvailabilityHandlerFactory(session.blob_manager),
         2: BlobRequestHandlerFactory(
             session.blob_manager, session.wallet,
             session.payment_rate_manager,
             analytics.Track()),
         3: session.wallet.get_wallet_info_query_handler_factory(),
     }
     server_factory = ServerProtocolFactory(session.rate_limiter,
                                            query_handler_factories,
                                            session.peer_manager)
     self.server_port = self.reactor.listenTCP(5553, server_factory)
     logging.debug("Started listening")
     self.kill_check = task.LoopingCall(self.check_for_kill)
     self.kill_check.start(1.0)
     return True
예제 #6
0
    def start_server():

        server_port = None

        query_handler_factories = {
            1:
            BlobAvailabilityHandlerFactory(session.blob_manager),
            2:
            BlobRequestHandlerFactory(session.blob_manager, session.wallet,
                                      session.payment_rate_manager, None),
            3:
            session.wallet.get_wallet_info_query_handler_factory(),
        }

        server_factory = ServerProtocolFactory(session.rate_limiter,
                                               query_handler_factories,
                                               session.peer_manager)

        server_port = reactor.listenTCP(peer_port, server_factory)
        logging.debug("Started listening")

        def kill_server():
            ds = []
            ds.append(session.shut_down())
            ds.append(lbry_file_manager.stop())
            if server_port:
                ds.append(server_port.stopListening())
            ds.append(rm_db_and_blob_dir(db_dir, blob_dir))
            kill_check.stop()
            dead_event.set()
            dl = defer.DeferredList(ds)
            dl.addCallback(lambda _: reactor.stop())
            return dl

        def check_for_kill():
            if kill_event.is_set():
                kill_server()

        kill_check = task.LoopingCall(check_for_kill)
        kill_check.start(1.0)
        ready_event.set()
        logging.debug("set the ready event")
예제 #7
0
    def setup(self):
        init_conf_windows()

        self.db_dir, self.blob_dir = mk_db_and_blob_dir()
        self.wallet = FakeWallet()
        self.peer_manager = PeerManager()
        self.rate_limiter = RateLimiter()
        if self.ul_rate_limit is not None:
            self.rate_limiter.set_ul_limit(self.ul_rate_limit)
        self.prm = OnlyFreePaymentsManager()
        self.storage = SQLiteStorage(self.db_dir)
        self.blob_manager = DiskBlobManager(self.blob_dir, self.storage)
        self.lbry_file_manager = EncryptedFileManager(
            FakePeerFinder(5553, self.peer_manager, 1), self.rate_limiter,
            self.blob_manager, self.wallet, self.prm, self.storage,
            StreamDescriptorIdentifier())

        yield self.storage.setup()
        yield self.blob_manager.setup()
        yield self.lbry_file_manager.setup()

        query_handler_factories = {
            1:
            BlobAvailabilityHandlerFactory(self.blob_manager),
            2:
            BlobRequestHandlerFactory(self.blob_manager, self.wallet, self.prm,
                                      None),
            3:
            self.wallet.get_wallet_info_query_handler_factory(),
        }
        server_factory = ServerProtocolFactory(self.rate_limiter,
                                               query_handler_factories,
                                               self.peer_manager)
        self.server_port = reactor.listenTCP(5553,
                                             server_factory,
                                             interface="localhost")
        test_file = GenFile(self.file_size,
                            b''.join([chr(i) for i in xrange(0, 64, 6)]))
        lbry_file = yield create_lbry_file(self.blob_manager, self.storage,
                                           self.prm, self.lbry_file_manager,
                                           "test_file", test_file)
        defer.returnValue(lbry_file.sd_hash)