Ejemplo n.º 1
0
    def listen(self, pubkey):
        self._log.info("Listening at: %s:%s" % (self._ip, self._port))
        self.ctx = zmq.Context()
        self.socket = self.ctx.socket(zmq.REP)

        if network_util.is_loopback_addr(self._ip):
            try:
                # we are in local test mode so bind that socket on the
                # specified IP
                self.socket.bind(self._uri)
            except Exception as e:
                error_message = "\n\nTransportLayer.listen() error!!!: Could not bind socket to " + self._uri
                error_message += " (" + str(e) + ")"
                import platform
                if platform.system() == 'Darwin':
                    error_message += "\n\nPerhaps you have not added a loopback alias yet.\nTry this on your terminal and restart OpenBazaar in development mode again:\n\n\t$ sudo ifconfig lo0 alias 127.0.0.2\n\n"
                raise Exception(error_message)

        else:
            self.socket.bind('tcp://*:%s' % self._port)
            

        self.stream = zmqstream.ZMQStream(self.socket, io_loop=ioloop.IOLoop.current())

        def handle_recv(message):
            for msg in message:
                self._on_raw_message(msg)
            self.stream.send(json.dumps({'type': 'ok', 'senderGUID': self._guid, 'pubkey': pubkey, 'senderNick':self._nickname}))

        self.stream.on_recv(handle_recv)
Ejemplo n.º 2
0
    def _listen(self, pubkey):
        self._log.info("Listening at: %s:%s" % (self._ip, self._port))
        ctx = zmq.Context()
        socket = ctx.socket(zmq.REP)

        if network_util.is_loopback_addr(self._ip):
            # we are in local test mode so bind that socket on the
            # specified IP
            socket.bind(self._uri)
        else:
            socket.bind('tcp://*:%s' % self._port)

        #while True:

        stream = zmqstream.ZMQStream(socket, io_loop=ioloop.IOLoop.current())

        def handle_recv(message):
            for msg in message:
                self.on_raw_message(msg)



            self._log.info('Sending back OK')
            #self._socket.send(json.dumps({'type': 'ok', 'senderGUID': self._guid, 'pubkey': pubkey}), flags=zmq.NOBLOCK)
            stream.send(json.dumps({'type': 'ok', 'senderGUID': self._guid, 'pubkey': pubkey}))

        stream.on_recv(handle_recv)
Ejemplo n.º 3
0
    def listen(self):
        self.log.info("Listening at: %s:%s", self.ip, self.port)
        self.socket = self.ctx.socket(zmq.REP)

        if network_util.is_loopback_addr(self.ip):
            try:
                # we are in local test mode so bind that socket on the
                # specified IP
                self.log.info("PeerListener.socket.bind('%s') LOOPBACK",
                              self.uri)
                self.socket.bind(self.uri)
            except ZMQError as e:
                error_message = "".join([
                    "PeerListener.listen() error: ",
                    "Could not bind socket to %s. " % self.uri, "Details:\n",
                    "(%s)" % e
                ])

                if platform.system() == 'Darwin':
                    error_message.join([
                        "\n\nPerhaps you have not added a ",
                        "loopback alias yet.\n",
                        "Try this on your terminal and restart ",
                        "OpenBazaar in development mode again:\n",
                        "\n\t$ sudo ifconfig lo0 alias 127.0.0.2", "\n\n"
                    ])
                raise Exception(error_message)
        elif '[' in self.ip:
            self.log.info("PeerListener.socket.bind('tcp://[*]:%s') IPV6",
                          self.port)
            self.socket.ipv6 = True
            self.socket.bind('tcp://[*]:%s' % self.port)
        else:
            self.log.info("PeerListener.socket.bind('tcp://*:%s') IPV4",
                          self.port)
            self.socket.bind('tcp://*:%s' % self.port)

        self.stream = zmqstream.ZMQStream(self.socket,
                                          io_loop=ioloop.IOLoop.current())

        def handle_recv(messages):
            # FIXME: investigate if we really get more than one messages here
            for msg in messages:
                self._on_raw_message(msg)

            if self._ok_msg:
                self.stream.send(json.dumps(self._ok_msg))

        self.is_listening = True

        self.stream.on_recv(handle_recv)
Ejemplo n.º 4
0
    def listen(self):
        self.log.info("Listening at: %s:%s", self.ip, self.port)
        self.socket = self.ctx.socket(zmq.REP)

        if network_util.is_loopback_addr(self.ip):
            try:
                # we are in local test mode so bind that socket on the
                # specified IP
                self.log.info("PeerListener.socket.bind('%s') LOOPBACK", self.uri)
                self.socket.bind(self.uri)
            except ZMQError as e:
                error_message = "".join([
                    "PeerListener.listen() error: ",
                    "Could not bind socket to %s. " % self.uri,
                    "Details:\n",
                    "(%s)" % e])

                if platform.system() == 'Darwin':
                    error_message.join([
                        "\n\nPerhaps you have not added a ",
                        "loopback alias yet.\n",
                        "Try this on your terminal and restart ",
                        "OpenBazaar in development mode again:\n",
                        "\n\t$ sudo ifconfig lo0 alias 127.0.0.2",
                        "\n\n"])
                raise Exception(error_message)
        elif '[' in self.ip:
            self.log.info("PeerListener.socket.bind('tcp://[*]:%s') IPV6", self.port)
            self.socket.ipv6 = True
            self.socket.bind('tcp://[*]:%s' % self.port)
        else:
            self.log.info("PeerListener.socket.bind('tcp://*:%s') IPV4", self.port)
            self.socket.bind('tcp://*:%s' % self.port)

        self.stream = zmqstream.ZMQStream(
            self.socket, io_loop=ioloop.IOLoop.current()
        )

        def handle_recv(messages):
            # FIXME: investigate if we really get more than one messages here
            for msg in messages:
                self._on_raw_message(msg)

            if self._ok_msg:
                self.stream.send(json.dumps(self._ok_msg))

        self.is_listening = True

        self.stream.on_recv(handle_recv)
Ejemplo n.º 5
0
    def listen(self, pubkey):
        self.log.info("Listening at: %s:%s" % (self.ip, self.port))
        self.ctx = zmq.Context()
        self.socket = self.ctx.socket(zmq.REP)

        if network_util.is_loopback_addr(self.ip):
            try:
                # we are in local test mode so bind that socket on the
                # specified IP
                self.socket.bind(self.uri)
            except Exception as e:
                error_message = "\n\nTransportLayer.listen() error!!!: "
                error_message += "Could not bind socket to " + self.uri
                error_message += " (" + str(e) + ")"
                import platform
                if platform.system() == 'Darwin':
                    error_message += "\n\nPerhaps you have not added a "\
                                     "loopback alias yet.\n"
                    error_message += "Try this on your terminal and restart "\
                                     "OpenBazaar in development mode again:\n"
                    error_message += "\n\t$ sudo ifconfig lo0 alias 127.0.0.2"
                    error_message += "\n\n"
                raise Exception(error_message)

        else:
            try:
                socket.inet_pton(socket.AF_INET6, self.ip)
                self.socket.ipv6 = True
                self.socket.bind('tcp://[*]:%s' % self.port)
            except (AttributeError, socket.error, ValueError):
                self.socket.bind('tcp://*:%s' % self.port)

        self.stream = zmqstream.ZMQStream(
            self.socket, io_loop=ioloop.IOLoop.current()
        )

        def handle_recv(message):
            for msg in message:
                self._on_raw_message(msg)
            self.stream.send(
                json.dumps({
                    'type': 'ok',
                    'senderGUID': self.guid,
                    'pubkey': pubkey,
                    'senderNick': self.nickname
                })
            )

        self.stream.on_recv(handle_recv)
Ejemplo n.º 6
0
    def _listen(self):
        self._log.info("init server %s %s" % (self._ip, self._port))
        self._ctx = zmq.Context()
        self._socket = self._ctx.socket(zmq.REP)

        if network_util.is_loopback_addr(self._ip):
            # we are in local test mode so bind that socket on the
            # specified IP
            self._socket.bind(self._uri)
        else:
            self._socket.bind('tcp://*:%s' % self._port)

        while True:
            message = self._socket.recv()
            self.on_raw_message(message)
            self._socket.send(json.dumps({'type': "ok"}))
Ejemplo n.º 7
0
    def _listen(self):
        self._log.info("init server %s %s" % (self._ip, self._port))
        self._ctx = zmq.Context()
        self._socket = self._ctx.socket(zmq.REP)

        if network_util.is_loopback_addr(self._ip): 
            # we are in local test mode so bind that socket on the 
            # specified IP
            self._socket.bind(self._uri)
        else: 
            self._socket.bind('tcp://*:%s' % self._port)

        while True:
            message = self._socket.recv()
            self.on_raw_message(message)
            self._socket.send(json.dumps({'type': "ok"}))
Ejemplo n.º 8
0
    def _listen(self, pubkey):
        self._log.info("Listening at: %s:%s" % (self._ip, self._port))
        self._ctx = zmq.Context()
        self._socket = self._ctx.socket(zmq.REP)

        if network_util.is_loopback_addr(self._ip):
            # we are in local test mode so bind that socket on the
            # specified IP
            self._socket.bind(self._uri)
        else:
            try:
              self._socket.bind('tcp://*:%s' % self._port)
            except:
              pass

        while True:
            message = self._socket.recv()
            self.on_raw_message(message)
            self._socket.send(json.dumps({'type': 'ok', 'senderGUID':self._guid, 'pubkey':pubkey}))
Ejemplo n.º 9
0
    def listen(self, pubkey):
        self._log.info("Listening at: %s:%s" % (self._ip, self._port))
        self.ctx = zmq.Context()
        self.socket = self.ctx.socket(zmq.REP)

        if network_util.is_loopback_addr(self._ip):
            # we are in local test mode so bind that socket on the
            # specified IP
            self.socket.bind(self._uri)
        else:
            self.socket.bind('tcp://*:%s' % self._port)

        self.stream = zmqstream.ZMQStream(self.socket, io_loop=ioloop.IOLoop.current())

        def handle_recv(message):
            for msg in message:
                self._on_raw_message(msg)
            self.stream.send(json.dumps({'type': 'ok', 'senderGUID': self._guid, 'pubkey': pubkey, 'senderNick':self._nickname}))

        self.stream.on_recv(handle_recv)
Ejemplo n.º 10
0
    def listen(self, pubkey):
        self._log.info("Listening at: %s:%s" % (self._ip, self._port))
        self.ctx = zmq.Context()
        self.socket = self.ctx.socket(zmq.REP)

        if network_util.is_loopback_addr(self._ip):
            # we are in local test mode so bind that socket on the
            # specified IP
            self.socket.bind(self._uri)
        else:
            self.socket.bind('tcp://*:%s' % self._port)

        self.stream = zmqstream.ZMQStream(self.socket, io_loop=ioloop.IOLoop.current())

        def handle_recv(message):
            for msg in message:
                self._on_raw_message(msg)
            self.stream.send(json.dumps({'type': 'ok', 'senderGUID': self._guid, 'pubkey': pubkey, 'senderNick':self._nickname}))

        self.stream.on_recv(handle_recv)
Ejemplo n.º 11
0
    def listen(self, pubkey):
        self.log.info("Listening at: %s:%s" % (self.ip, self.port))
        self.ctx = zmq.Context()
        self.socket = self.ctx.socket(zmq.REP)

        if network_util.is_loopback_addr(self.ip):
            try:
                # we are in local test mode so bind that socket on the
                # specified IP
                self.socket.bind(self.uri)
            except Exception as e:
                error_message = "\n\nTransportLayer.listen() error!!!: "
                error_message += "Could not bind socket to " + self.uri
                error_message += " (" + str(e) + ")"
                import platform

                if platform.system() == "Darwin":
                    error_message += "\n\nPerhaps you have not added a " "loopback alias yet.\n"
                    error_message += "Try this on your terminal and restart " "OpenBazaar in development mode again:\n"
                    error_message += "\n\t$ sudo ifconfig lo0 alias 127.0.0.2"
                    error_message += "\n\n"
                raise Exception(error_message)

        else:
            try:
                socket.inet_pton(socket.AF_INET6, self.ip)
                self.socket.ipv6 = True
                self.socket.bind("tcp://[*]:%s" % self.port)
            except (AttributeError, socket.error, ValueError):
                self.socket.bind("tcp://*:%s" % self.port)

        self.stream = zmqstream.ZMQStream(self.socket, io_loop=ioloop.IOLoop.current())

        def handle_recv(message):
            for msg in message:
                self._on_raw_message(msg)
            self.stream.send(
                json.dumps({"type": "ok", "senderGUID": self.guid, "pubkey": pubkey, "senderNick": self.nickname})
            )

        self.stream.on_recv(handle_recv)
Ejemplo n.º 12
0
    def _listen(self, pubkey):
        self._log.info("Listening at: %s:%s" % (self._ip, self._port))
        self._ctx = zmq.Context()
        self._socket = self._ctx.socket(zmq.REP)

        if network_util.is_loopback_addr(self._ip):
            # we are in local test mode so bind that socket on the
            # specified IP
            self._socket.bind(self._uri)
        else:
            try:
                self._socket.bind('tcp://*:%s' % self._port)
            except:
                pass

        while True:
            message = self._socket.recv()
            self.on_raw_message(message)
            self._socket.send(
                json.dumps({
                    'type': 'ok',
                    'senderGUID': self._guid,
                    'pubkey': pubkey
                }))
Ejemplo n.º 13
0
 def test_is_loopback_addr(self):
     self.assertTrue(network_util.is_loopback_addr("127.0.0.1"))
     self.assertTrue(network_util.is_loopback_addr("localhost"))
     self.assertFalse(network_util.is_loopback_addr("10.0.0.1"))
     self.assertFalse(network_util.is_loopback_addr("192.168.0.1"))
Ejemplo n.º 14
0
 def test_is_loopback_addr(self):
     self.assertTrue(network_util.is_loopback_addr("127.0.0.1"))
     self.assertTrue(network_util.is_loopback_addr("localhost"))
     self.assertFalse(network_util.is_loopback_addr("10.0.0.1"))
     self.assertFalse(network_util.is_loopback_addr("192.168.0.1"))