Beispiel #1
0
 def _read(self, n, initial=False,
           _errnos=(errno.ENOENT, errno.EAGAIN, errno.EINTR)):
     # According to SSL_read(3), it can at most return 16kb of data.
     # Thus, we use an internal read buffer like TCPTransport._read
     # to get the exact number of bytes wanted.
     recv = self._quick_recv
     rbuf = self._read_buffer
     try:
         while len(rbuf) < n:
             try:
                 s = recv(n - len(rbuf))  # see note above
             except socket.error as exc:
                 # ssl.sock.read may cause a SSLerror without errno
                 # http://bugs.python.org/issue10272
                 if isinstance(exc, SSLError) and 'timed out' in str(exc):
                     raise socket.timeout()
                 # ssl.sock.read may cause ENOENT if the
                 # operation couldn't be performed (Issue celery#1414).
                 if exc.errno in _errnos:
                     if initial and self.raise_on_initial_eintr:
                         raise socket.timeout()
                     continue
                 raise
             if not s:
                 raise IOError('Server unexpectedly closed connection')
             rbuf += s
     except:  # noqa
         self._read_buffer = rbuf
         raise
     result, self._read_buffer = rbuf[:n], rbuf[n:]
     return result
Beispiel #2
0
    def sendall(self, data, flags=0):
        """
        - Use select() to simulate a socket timeout without setting the socket
            to non-blocking mode.
        - Don't use pyOpenSSL's sendall() either, since it just loops on WantRead
            or WantWrite, consuming 100% CPU, and never times out.
        """
        timeout = self.__dict__["timeout"]
        con = self.__dict__["conn"]
        (read, write, excpt) = select.select([], [con], [], timeout)
        if not con in write:
            raise socket.timeout((110, "Operation timed out."))

        starttime = time.time()
        origlen = len(data)
        sent = -1
        while len(data):
            curtime = time.time()
            if curtime - starttime > timeout:
                raise socket.timeout((110, "Operation timed out."))

            try:
                sent = con.send(data, flags)
            except SSL.SysCallError, e:
                if e[0] == 32:      # Broken Pipe
                    self.close()
                    sent = 0
                else:
                    raise socket.error(e)
            except (SSL.WantWriteError, SSL.WantReadError):
                time.sleep(0.2)
                continue
 def _check_timeout(self):
     self._lock()
     conns = self._sock_dict.values()
     self._unlock()
     now = self.get_time()
     # the socking listening is not in _sock_dict, so it'll not be touched
     self._last_checktimeout = now
     for conn in conns:
         inact_time = now - conn.last_ts
         if conn.status_rd == ConnState.IDLE and self._idle_timeout > 0 and inact_time > self._idle_timeout:
             if callable(conn.idle_timeout_cb):
                 conn.error = socket.timeout("idle timeout")
                 conn.idle_timeout_cb(conn, *conn.readable_cb_args)
             self.close_conn(conn)
         elif conn.status_rd == ConnState.TOREAD and self._rw_timeout > 0 and inact_time > self._rw_timeout:
             if callable(conn.read_err_cb):
                 conn.error = socket.timeout("read timeout")
                 self._exec_callback(
                     conn.read_err_cb, (conn,) + conn.read_cb_args, conn.read_tb)
             self.close_conn(conn)
         elif conn.status_wr == ConnState.TOWRITE and self._rw_timeout > 0 and inact_time > self._rw_timeout:
             if callable(conn.write_err_cb):
                 conn.error = socket.timeout("write timeout")
                 self._exec_callback(
                     conn.write_err_cb, (conn,) + conn.write_cb_args, conn.write_tb)
             self.close_conn(conn)
Beispiel #4
0
 def connect_ex(self, address):
     if self.act_non_blocking:
         return self.fd.connect_ex(address)
     fd = self.fd
     if self.gettimeout() is None:
         while not socket_connect(fd, address):
             try:
                 self._trampoline(fd, write=True)
                 socket_checkerr(fd)
             except socket.error as ex:
                 return get_errno(ex)
             except IOClosed:
                 return errno.EBADFD
     else:
         end = time.time() + self.gettimeout()
         while True:
             try:
                 if socket_connect(fd, address):
                     return 0
                 if time.time() >= end:
                     raise socket.timeout(errno.EAGAIN)
                 self._trampoline(fd, write=True, timeout=end - time.time(),
                            timeout_exc=socket.timeout(errno.EAGAIN))
                 socket_checkerr(fd)
             except socket.error as ex:
                 return get_errno(ex)
             except IOClosed:
                 return errno.EBADFD
    def test_new_crash_with_fail_retry(self):
        config = self._setup_config()
        config.transaction_executor_class = \
            TransactionExecutorWithInfiniteBackoff
        crash_store = RabbitMQCrashStorage(config)

        iterable = [
            ('1', '1', 'crash_id'),
            timeout(),
            timeout(),
            ('2', '2', 'other_id')
        ]
        def an_iterator(queue):
            item =  iterable.pop()
            if isinstance(item, Exception):
                raise item
            return item

        crash_store.rabbitmq.operational_exceptions = (
          timeout,
        )
        crash_store.rabbitmq.return_value.__enter__.return_value  \
            .channel.basic_get = MagicMock(side_effect=an_iterator)

        expected = ('other_id', 'crash_id', )
        for expected, result in zip(expected,  crash_store.new_crashes()):
            eq_(expected, result)
Beispiel #6
0
def chk_con(kms):
    #parse kms
    hostname = None
    port = None
    result = None
    ip = None
    ipaddr = None    
    hostname = re.search('https://(.*?):',kms[0],flags=0).group(1)
    logging.info('KMS FQDN : %s' %hostname)
    port = re.search('https://.*:(.*)/',kms[0],flags=0).group(1)
    logging.info ('KMS WebAPI Port : %s' %port)
    #DNS resolve
    try:
        socket.gethostbyname(hostname)
    except :
        logging.error('DNS resolve problem for this KMS server FQDN : %s' %hostname)
        print '!!! DNS resolve issue for FQDN : %s!!!' %hostname
        return (False)
    else :
        result = socket.gethostbyaddr(hostname)
        ip = result[2]        
        ipaddr = ip[0]
        logging.info('KMS IP address : %s' %ipaddr)
    #TCP connect
    socket.timeout(30)
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        s.connect((ipaddr,int(port)))        
    except Exception, e:
        logging.exception('TCP connection error with %s:%d. Exception type is %s' % (ipaddr, int(port), `e`))
        print 'TCP connection error with KMS server %s port %d. Error type %s'% (ipaddr, int(port), `e`)
        return (False)
Beispiel #7
0
 def connect(self, address):
     if self.act_non_blocking:
         return self.fd.connect(address)
     fd = self.fd
     if self.gettimeout() is None:
         while not socket_connect(fd, address):
             try:
                 self._trampoline(fd, write=True)
             except IOClosed:
                 raise socket.error(errno.EBADFD)
             socket_checkerr(fd)
     else:
         end = time.time() + self.gettimeout()
         while True:
             if socket_connect(fd, address):
                 return
             if time.time() >= end:
                 raise socket.timeout("timed out")
             try:
                 self._trampoline(fd, write=True, timeout=end - time.time(),
                        timeout_exc=socket.timeout("timed out"))
             except IOClosed:
                 # ... we need some workable errno here.
                 raise socket.error(errno.EBADFD)
             socket_checkerr(fd)
Beispiel #8
0
    def _check_timeout (self):

        self._lock ()
        conns = self._sock_dict.values ()
        self._unlock ()
        now = self.get_time ()
        #the socking listening is not in _sock_dict, so it'll not be touched
        self._last_checktimeout = now
        def __is_timeout (conn):
            inact_time = now - conn.last_ts
            if conn.status == ConnState.IDLE and self._idle_timeout > 0  and inact_time > self._idle_timeout:
                return True
            elif (conn.status == ConnState.TOREAD or conn.status == ConnState.TOWRITE) \
                    and self._rw_timeout > 0 and inact_time > self._rw_timeout:
                return True
            return False
        timeout_list = filter (__is_timeout, conns)
        for conn in timeout_list:
            if conn.status == ConnState.IDLE:
                if callable (conn.idle_timeout_cb):
                    conn.error = socket.timeout ("idle timeout")
                    conn.idle_timeout_cb (conn, *conn.readable_cb_args)
            elif callable(conn.unblock_err_cb):
                conn.error = socket.timeout ("timeout")
                self._exec_callback (conn.unblock_err_cb, (conn,) + conn.unblock_cb_args, conn.unblock_tb)
            self._close_conn (conn)
Beispiel #9
0
    def recv(self, bufsize, flags=0):
        """
        Use select() to simulate a socket timeout without setting the socket
        to non-blocking mode
        """
        timeout = self.__dict__["timeout"]
        con = self.__dict__["conn"]
        (read, write, excpt) = select.select([con], [], [], timeout)
        if not con in read:
            raise socket.timeout((110, "Operation timed out."))

        starttime = time.time()
        while True:
            curtime = time.time()
            if curtime - starttime > timeout:
                raise socket.timeout((110, "Operation timed out."))

            try:
                return con.recv(bufsize, flags)
            except SSL.ZeroReturnError:
                return None
            except SSL.WantReadError:
                time.sleep(0.2)
            except Exception, e:
                if canIgnoreSSLError(e):
                    return None
                else:
                    raise e
    def blocking_read(self, timeout=None):
        read_frame = self.transport.read_frame
        if timeout is None:
            return self.on_inbound_frame(read_frame())

        # XXX use select
        sock = self.sock
        prev = sock.gettimeout()
        if prev != timeout:
            sock.settimeout(timeout)
        try:
            try:
                frame = read_frame()
            except SSLError as exc:
                # http://bugs.python.org/issue10272
                if 'timed out' in str(exc):
                    raise socket.timeout()
                # Non-blocking SSL sockets can throw SSLError
                if 'The operation did not complete' in str(exc):
                    raise socket.timeout()
                raise
            else:
                self.on_inbound_frame(frame)
        finally:
            if prev != timeout:
                sock.settimeout(prev)
Beispiel #11
0
 def having_timeout(self, timeout):
     if timeout is None:
         yield self.sock
     else:
         sock = self.sock
         prev = sock.gettimeout()
         if prev != timeout:
             sock.settimeout(timeout)
         try:
             yield self.sock
         except SSLError as exc:
             if 'timed out' in str(exc):
                 # http://bugs.python.org/issue10272
                 raise socket.timeout()
             elif 'The operation did not complete' in str(exc):
                 # Non-blocking SSL sockets can throw SSLError
                 raise socket.timeout()
             raise
         except socket.error as exc:
             if get_errno(exc) == errno.EWOULDBLOCK:
                 raise socket.timeout()
             raise
         finally:
             if timeout != prev:
                 sock.settimeout(prev)
Beispiel #12
0
def _safe_ssl_call(suppress_ragged_eofs, sock, call, *args, **kwargs):
    """Wrap the given call with SSL error-trapping."""
    start = time.time()
    while True:
        try:
            return getattr(sock, call)(*args, **kwargs)

        except (ossl.WantReadError, ossl.WantWriteError):
            if select is None:
                if time.time() - start > sock.gettimeout():
                    raise socket.timeout()
                time.sleep(SSL_RETRY)
            elif not select.select([sock], [], [], sock.gettimeout())[0]:
                raise socket.timeout()

        except ossl.SysCallError as e:
            if suppress_ragged_eofs and e.args[0] == (-1, 'Unexpected EOF'):
                return b''
            elif e.args[0] == 0:
                raise SSLEOFError(*e.args)
            raise SSLSysCallError(*e.args)

        except ossl.ZeroReturnError as e:
            raise SSLZeroReturnError(*e.args)

        except ossl.Error as e:
            raise SSLError(*e.args)
Beispiel #13
0
    def recv(self, nbytes):
        """
        Receive data from the channel.  The return value is a string
        representing the data received.  The maximum amount of data to be
        received at once is specified by C{nbytes}.  If a string of length zero
        is returned, the channel stream has closed.

        @param nbytes: maximum number of bytes to read.
        @type nbytes: int
        @return: data.
        @rtype: str
        
        @raise socket.timeout: if no data is ready before the timeout set by
            L{settimeout}.
        """
        out = ''
        self.lock.acquire()
        try:
            if len(self.in_buffer) == 0:
                if self.closed or self.eof_received:
                    return out
                # should we block?
                if self.timeout == 0.0:
                    raise socket.timeout()
                # loop here in case we get woken up but a different thread has grabbed everything in the buffer
                timeout = self.timeout
                while (len(self.in_buffer) == 0) and not self.closed and not self.eof_received:
                    then = time.time()
                    self.in_buffer_cv.wait(timeout)
                    if timeout != None:
                        timeout -= time.time() - then
                        if timeout <= 0.0:
                            raise socket.timeout()
            # something in the buffer and we have the lock
            if len(self.in_buffer) <= nbytes:
                out = self.in_buffer
                self.in_buffer = ''
                if self.pipe is not None:
                    # clear the pipe, since no more data is buffered
                    self.pipe.clear()
            else:
                out = self.in_buffer[:nbytes]
                self.in_buffer = self.in_buffer[nbytes:]
            ack = self._check_add_window(len(out))
        finally:
            self.lock.release()

        # no need to hold the channel lock when sending this
        if ack > 0:
            m = Message()
            m.add_byte(chr(MSG_CHANNEL_WINDOW_ADJUST))
            m.add_int(self.remote_chanid)
            m.add_int(ack)
            self.transport._send_user_message(m)

        return out
Beispiel #14
0
def HttpPostData(postdata):
  socket.timeout(HTTPTIMEOUT)
  try:
    headers = {"Content-type": "application/json", "Accept": "application/json", "Authorization": AUTHTOKEN}
    req = urllib2.Request(SOSSERVER + SOSJSON, postdata, headers)
    response = urllib2.urlopen(req)
    return response.read()
  except urllib2.HTTPError as e:
    print '  error: ' + str(e.code)
    return "ERROR:HTTP " + str(e.code)
Beispiel #15
0
def getTime():
    TIME_1970 = 2208988800L
    client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    socket.timeout(5)
    data = '\x1b' + 47 * '\0'
    client.sendto(data, (TimeServer, Port))
    data, address = client.recvfrom(1024)
    data_result = struct.unpack('!12I', data)[10]
    data_result -= TIME_1970
    return data_result
Beispiel #16
0
 def test_connection(self, proxy):
     socket.timeout(30)
     try:
         http = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         http.connect((proxy[0], int(proxy[1])))
         request = "GET /search?output=search&q=habrahabr HTTP/1.1\r\n"
         request += "Host: https://www.google.com\r\n"
         http.send(request.encode("utf-8", "strict"))
         http.recv(65535)
         return True
     except socket.error:
         return False
Beispiel #17
0
 def _recv(self, length):
     if self._timeout:
         if hasattr(select, 'poll'):
             poller = select.poll()
             poller.register(self._sock.fileno())
             ready = poller.poll(self._timeout)
             if not ready:
                 raise socket.timeout("timed out (poll)")
         else:
             ready = select.select([self._sock], [], [], self._timeout)
             if not ready[0]:
                 raise socket.timeout("timed out (select)")
     return self._sock.recv(length)
Beispiel #18
0
    def _connect(self):
        self.usage = 0
        try:
            socket.timeout(self._timeout)
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
            s.connect((self._host, self._port))

            self._stream = iostream.IOStream(s)
            self._stream.set_close_callback(self._socket_close)

            self._connected = True
        except socket.error, error:
            raise InterfaceError(error)
Beispiel #19
0
def open_socket():
    port = 9999
    mpstate.status.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        mpstate.status.sock.connect(('localhost', port))
        mpstate.status.socket_open = True    
        print("connecting to socket: {}\n".format(port))

    except socket.error:
        if not mpstate.status.sock_failure_data:
            print("socket not availible\n")
        mpstate.status.socket_open = False
    socket.timeout(0.1)
    time.sleep(0.2)
Beispiel #20
0
    def recv_stderr(self, nbytes):
        """
        Receive data from the channel's stderr stream.  Only channels using
        L{exec_command} or L{invoke_shell} without a pty will ever have data
        on the stderr stream.  The return value is a string representing the
        data received.  The maximum amount of data to be received at once is
        specified by C{nbytes}.  If a string of length zero is returned, the
        channel stream has closed.

        @param nbytes: maximum number of bytes to read.
        @type nbytes: int
        @return: data.
        @rtype: str
        
        @raise socket.timeout: if no data is ready before the timeout set by
            L{settimeout}.
        
        @since: 1.1
        """
        out = ''
        self.lock.acquire()
        try:
            if len(self.in_stderr_buffer) == 0:
                if self.closed or self.eof_received:
                    return out
                # should we block?
                if self.timeout == 0.0:
                    raise socket.timeout()
                # loop here in case we get woken up but a different thread has grabbed everything in the buffer
                timeout = self.timeout
                while (len(self.in_stderr_buffer) == 0) and not self.closed and not self.eof_received:
                    then = time.time()
                    self.in_stderr_buffer_cv.wait(timeout)
                    if timeout != None:
                        timeout -= time.time() - then
                        if timeout <= 0.0:
                            raise socket.timeout()
            # something in the buffer and we have the lock
            if len(self.in_stderr_buffer) <= nbytes:
                out = self.in_stderr_buffer
                self.in_stderr_buffer = ''
            else:
                out = self.in_stderr_buffer[:nbytes]
                self.in_stderr_buffer = self.in_stderr_buffer[nbytes:]
            self._check_add_window(len(out))
        finally:
            self.lock.release()
        return out
 def testRecvTimeout(self):
     sock = ws.WebSocket()
     s = sock.sock = SockMock()
     s.add_packet(six.b("\x81"))
     s.add_packet(socket.timeout())
     s.add_packet(six.b("\x8dabcd\x29\x07\x0f\x08\x0e"))
     s.add_packet(socket.timeout())
     s.add_packet(six.b("\x4e\x43\x33\x0e\x10\x0f\x00\x40"))
     with self.assertRaises(ws.WebSocketTimeoutException):
         data = sock.recv()
     with self.assertRaises(ws.WebSocketTimeoutException):
         data = sock.recv()
     data = sock.recv()
     self.assertEqual(data, "Hello, World!")
     with self.assertRaises(ws.WebSocketConnectionClosedException):
         data = sock.recv()
Beispiel #22
0
 def recv(self, count):
     if sys.stdin.closed:
         return b''
     r, w, x = select.select([sys.stdin], [], [], self.timeout)
     if sys.stdin in r:
         return os.read(sys.stdin.fileno(), count)
     raise socket.timeout()
Beispiel #23
0
 def read_frame(self, unpack=unpack):
     read = self._read
     read_frame_buffer = EMPTY_BUFFER
     try:
         frame_header = read(7, True)
         read_frame_buffer += frame_header
         frame_type, channel, size = unpack('>BHI', frame_header)
         payload = read(size)
         read_frame_buffer += payload
         ch = ord(read(1))
     except socket.timeout:
         self._read_buffer = read_frame_buffer + self._read_buffer
         raise
     except (OSError, IOError, socket.error) as exc:
         # Don't disconnect for ssl read time outs
         # http://bugs.python.org/issue10272
         if isinstance(exc, SSLError) and 'timed out' in str(exc):
             raise socket.timeout()
         if get_errno(exc) not in _UNAVAIL:
             self.connected = False
         raise
     if ch == 206:  # '\xce'
         return frame_type, channel, payload
     else:
         raise UnexpectedFrame(
             'Received {0:#04x} while expecting 0xce'.format(ch))
Beispiel #24
0
 def test_url_timeout(self):
     reason = socket.timeout('too slow')
     self.urlopen_mock.side_effect = urllib2.URLError(reason)
     tasks.fetch_manifest('url', self.upload.pk)
     self.check_validation(
         'No manifest was found at that URL. Check the address and try '
         'again.')
Beispiel #25
0
    def recv(self, nbytes):
        """
        Receive data from the channel.  The return value is a string
        representing the data received.  The maximum amount of data to be
        received at once is specified by ``nbytes``.  If a string of length zero
        is returned, the channel stream has closed.

        :param int nbytes: maximum number of bytes to read.
        :return: received data, as a `bytes`

        :raises socket.timeout:
            if no data is ready before the timeout set by `settimeout`.
        """
        try:
            out = self.in_buffer.read(nbytes, self.timeout)
        except PipeTimeout:
            raise socket.timeout()

        ack = self._check_add_window(len(out))
        # no need to hold the channel lock when sending this
        if ack > 0:
            m = Message()
            m.add_byte(cMSG_CHANNEL_WINDOW_ADJUST)
            m.add_int(self.remote_chanid)
            m.add_int(ack)
            self.transport._send_user_message(m)

        return out
Beispiel #26
0
    def recv_stderr(self, nbytes):
        """
        Receive data from the channel's stderr stream.  Only channels using
        `exec_command` or `invoke_shell` without a pty will ever have data
        on the stderr stream.  The return value is a string representing the
        data received.  The maximum amount of data to be received at once is
        specified by ``nbytes``.  If a string of length zero is returned, the
        channel stream has closed.

        :param int nbytes: maximum number of bytes to read.
        :return: received data as a `str`

        :raises socket.timeout: if no data is ready before the timeout set by
            `settimeout`.

        .. versionadded:: 1.1
        """
        try:
            out = self.in_stderr_buffer.read(nbytes, self.timeout)
        except PipeTimeout:
            raise socket.timeout()

        ack = self._check_add_window(len(out))
        # no need to hold the channel lock when sending this
        if ack > 0:
            m = Message()
            m.add_byte(cMSG_CHANNEL_WINDOW_ADJUST)
            m.add_int(self.remote_chanid)
            m.add_int(ack)
            self.transport._send_user_message(m)

        return out
Beispiel #27
0
    def _recvfrom(self):
        ret = (None, None)

        try:
            if self._interval_finished(
                    interval=self._wakeupInterval,
                    last=self._lastWakeup,
            ):
                raise socket.timeout()

            self._socket.settimeout(
                max(
                    self._wakeupInterval - self._total_seconds(
                        datetime.datetime.utcnow(),
                        self._lastWakeup
                    ),
                    1,
                )
            )

            ret = self._socket.recvfrom(self._BUF_SIZE)
        except socket.timeout:
            self._lastWakeup = datetime.datetime.utcnow()

        return ret
Beispiel #28
0
    def drain_events(self, connection, timeout=None):
        loop = 0
        time_start = time()
        get = self.cycle.get
        polling_interval = self.polling_interval
        while 1:
            try:
                item, channel = get(timeout=timeout)
            except Empty:
                if timeout and time() - time_start >= timeout:
                    raise socket.timeout()
                loop += 1
                if polling_interval is not None:
                    sleep(polling_interval)
            else:
                break

        message, queue = item

        if not queue or queue not in self._callbacks:
            raise KeyError(
                "Received message for queue '%s' without consumers: %s" % (
                    queue, message))

        self._callbacks[queue](message)
Beispiel #29
0
	def waitSocket(self, sock):
		fileno = sock.fileno()
		n = 0
		while not n:
			if time.time() >= self.timeouttime:
				raise socket.timeout("timed out")
			n = select.select([fileno], (), (), self.timeouttime - time.time())
Beispiel #30
0
    def wrap_socket(self, sock, server_side=False,
                    do_handshake_on_connect=True, suppress_ragged_eofs=True,
                    server_hostname=None):
        cnx = OpenSSL.SSL.Connection(self._ctx, sock)

        if isinstance(server_hostname, six.text_type):  # Platform-specific: Python 3
            server_hostname = server_hostname.encode('utf-8')

        if server_hostname is not None:
            cnx.set_tlsext_host_name(server_hostname)

        cnx.set_connect_state()

        while True:
            try:
                cnx.do_handshake()
            except OpenSSL.SSL.WantReadError:
                rd = util.wait_for_read(sock, sock.gettimeout())
                if not rd:
                    raise timeout('select timed out')
                continue
            except OpenSSL.SSL.Error as e:
                raise ssl.SSLError('bad handshake: %r' % e)
            break

        return WrappedSocket(cnx, sock)
Beispiel #31
0
Datei: aei.py Projekt: TFiFiE/AEI
 def readline(self, timeout=None):
     try:
         msg = self.proc_com.outq.get(timeout=timeout)
     except Empty:
         raise socket.timeout()
     return msg
Beispiel #32
0
Datei: aei.py Projekt: TFiFiE/AEI
 def get_response(self, timeout=None):
     rstr = self.engine.readline(timeout=timeout)
     if rstr == "":
         raise socket.timeout()
     return self._parse_resp(rstr)
Beispiel #33
0
 def se(*args, **kwargs):
     c.should_stop = True
     raise socket.timeout()
Beispiel #34
0
 def side_effect(url, timeout=None):
     raise socket.timeout()
Beispiel #35
0
 def custom_raise(*_):
     if self.raised:
         return 1
     self.raised = True
     raise socket.timeout()
Beispiel #36
0
 def accept(self):  # pylint: disable=no-self-use
     if not connections:
         raise socket.timeout()
     return connections.pop(), 'address'
Beispiel #37
0
 def side_effect(*args, **kwargs):
     if acquire_mock.drain_events.call_count == 0:
         raise socket.timeout()
     raise TestException()
Beispiel #38
0
                thirdarg = None
                try:
                    thirdarg = e.args[0][0][2]
                except IndexError:
                    pass

                if thirdarg == 'http request':
                    # The client is talking HTTP to an HTTPS server.
                    raise wsgiserver.NoSSLError()

                raise wsgiserver.FatalSSLAlert(*e.args)
            except:
                raise

            if time.time() - start > self.ssl_timeout:
                raise socket.timeout("timed out")

    def recv(self, size):
        return self._safe_call(True, super(SSL_fileobject, self).recv, size)

    def sendall(self, *args, **kwargs):
        return self._safe_call(False,
                               super(SSL_fileobject, self).sendall, *args,
                               **kwargs)

    def send(self, *args, **kwargs):
        return self._safe_call(False,
                               super(SSL_fileobject, self).send, *args,
                               **kwargs)

Beispiel #39
0
 def _search(self, title, filepath, langs, season, episode, tvshow, year):
     raise socket.timeout()
Beispiel #40
0
 def recv_exit_status(self):
     event = self.exec_channel.status_event
     status = event.wait(self.client.timeout)
     if status == False:
         raise socket.timeout()
     return self.exec_channel.exit_status
Beispiel #41
0
 def socket_timeout(err):
     raise socket.timeout(err)
Beispiel #42
0
 def drain_events(self, **kwargs):
     if not self.calls:
         self.calls += 1
         raise socket.timeout()
     self.obj.connection = None
     controller.box._node_shutdown.set()
Beispiel #43
0
 def accept(self):  # pylint: disable=no-self-use
     if connections:
         return connections.pop(), 'address'
     quit_event.set()
     raise socket.timeout()
Beispiel #44
0
 def drain_events(self, **kwargs):
     if self.should_raise_timeout:
         raise socket.timeout()
     for consumer in MockConsumer.consumers:
         for callback in consumer.callbacks:
             callback('body', 'message')
Beispiel #45
0
 def _wait(self, readable, writable, read_timeout=None):
     assert readable or writable
     if not self._wait_for_socket(
             self._sock, read=readable, write=writable,
             timeout=read_timeout):
         raise socket.timeout()  # XX use a backend-agnostic exception
Beispiel #46
0
 def test_socket_error(self):
     sp = servermanager.ServerPool()
     with mock.patch(HTTPCON) as conmock:
         conmock.return_value.request.side_effect = socket.timeout()
         resp = sp.servers[0].rest_call('GET', '/')
         self.assertEqual(resp, (0, None, None, None))
Beispiel #47
0
            )
<<<<<<< HEAD
            result = Security.SSLSetCertificate(
                self.context, self._client_cert_chain
            )
=======
            result = Security.SSLSetCertificate(self.context, self._client_cert_chain)
>>>>>>> development
            _assert_no_error(result)

        while True:
            with self._raise_on_error():
                result = Security.SSLHandshake(self.context)

                if result == SecurityConst.errSSLWouldBlock:
                    raise socket.timeout("handshake timed out")
                elif result == SecurityConst.errSSLServerAuthCompleted:
                    self._custom_validate(verify, trust_bundle)
                    continue
                else:
                    _assert_no_error(result)
                    break

    def fileno(self):
        return self.socket.fileno()

    # Copy-pasted from Python 3.5 source code
    def _decref_socketios(self):
        if self._makefile_refs > 0:
            self._makefile_refs -= 1
        if self._closed:
    def read_frame(self, unpack=unpack):
        """Parse AMQP frame.

        Frame has following format::

            0      1         3         7                   size+7      size+8
            +------+---------+---------+   +-------------+   +-----------+
            | type | channel |  size   |   |   payload   |   | frame-end |
            +------+---------+---------+   +-------------+   +-----------+
             octet    short     long        'size' octets        octet

        """
        read = self._read
        read_frame_buffer = EMPTY_BUFFER
        try:
            frame_header = read(7, True)
            read_frame_buffer += frame_header
            frame_type, channel, size = unpack('>BHI', frame_header)
            # >I is an unsigned int, but the argument to sock.recv is signed,
            # so we know the size can be at most 2 * SIGNED_INT_MAX
            if size > SIGNED_INT_MAX:
                part1 = read(SIGNED_INT_MAX)

                try:
                    part2 = read(size - SIGNED_INT_MAX)
                except (socket.timeout, OSError, SSLError):
                    # In case this read times out, we need to make sure to not
                    # lose part1 when we retry the read
                    read_frame_buffer += part1
                    raise

                payload = b''.join([part1, part2])
            else:
                payload = read(size)
            read_frame_buffer += payload
            frame_end = ord(read(1))
        except socket.timeout:
            self._read_buffer = read_frame_buffer + self._read_buffer
            raise
        except (OSError, SSLError) as exc:
            if (isinstance(exc, socket.error) and os.name == 'nt'
                    and exc.errno == errno.EWOULDBLOCK  # noqa
                ):
                # On windows we can get a read timeout with a winsock error
                # code instead of a proper socket.timeout() error, see
                # https://github.com/celery/py-amqp/issues/320
                self._read_buffer = read_frame_buffer + self._read_buffer
                raise socket.timeout()

            if isinstance(exc, SSLError) and 'timed out' in str(exc):
                # Don't disconnect for ssl read time outs
                # http://bugs.python.org/issue10272
                self._read_buffer = read_frame_buffer + self._read_buffer
                raise socket.timeout()

            if exc.errno not in _UNAVAIL:
                self.connected = False
            raise
        # frame-end octet must contain '\xce' value
        if frame_end == 206:
            return frame_type, channel, payload
        else:
            raise UnexpectedFrame(
                f'Received frame_end {frame_end:#04x} while expecting 0xce')
Beispiel #49
0
def test_socket_error():
    sc = _client()
    sc._sock.sendto.side_effect = socket.timeout()
    sc.incr('foo')
    _sock_check(sc, 1, 'foo:1|c')
Beispiel #50
0
 def test_connection_timeout(self, output_spy, virtual_socket):
     vsocket = virtual_socket
     vsocket.errors['connect'] = socket.timeout('timed out')
     lines = self._audit(output_spy, exit_expected=True)
     assert len(lines) == 1
     assert 'timed out' in lines[-1]
Beispiel #51
0
 def connect(self, *args):
     super().connect(*args)
     if not next(self._connector):
         raise socket.timeout("mock reconnect timeout")
Beispiel #52
0
def test_timeout(mock_urlopen):
    exc = URLError(reason=socket.timeout('timed_out'))
    mock_urlopen.side_effect = exc
    generator = request.stream('http://fakeassurl.gov/timeout_test', timeout=1)
    with pytest.raises(MaxRetriesExceeded):
        next(generator)
Beispiel #53
0

def wait_port(port, timeout=10):
    """Wait up to timeout for port to be connectable."""
    if timeout:
        deadline = time.time() + timeout
    while (timeout is None or time.time() < deadline):
        try:
            s = socket.create_connection((None, port),
                                         timeout)  # Works for IPv6 and v4
            s.close()
            return
        except socket.error, e:
            if e.errno != errno.ECONNREFUSED:  # Only retry on connection refused error.
                raise
    raise socket.timeout()


class BrokerTestCase(ExampleTestCase):
    """
    ExampleTest that starts a broker in setUpClass and kills it in tearDownClass.
    Subclass must set `broker_exe` class variable with the name of the broker executable.
    """
    @classmethod
    def setUpClass(cls):
        cls.port = pick_port()
        cls.addr = "127.0.0.1:%s/examples" % (cls.port)
        cls.broker = None  # In case Proc throws, create the attribute.
        cls.broker = Proc(cls.broker_exe + ["-a", cls.addr])
        try:
            wait_port(cls.port)
Beispiel #54
0
address = os.environ.get('HLDS_ADDRESS', '127.0.0.1')
port = int(os.environ.get('HLDS_PORT', 27111))

server_name = os.environ.get('HLDS_NAME', 'Test auto')
map_name = os.environ.get('HLDS_MAP', 'de_dust2')
game_name = os.environ.get('HLDS_GAME', 'Counter-Strike')

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(3)

request_data = 'ffffffff54536f7572636520456e67696e6520517565727900'
retries = 10
request_bytes = bytearray(bytes.fromhex(request_data))

while retries:
    retries -= 1
    try:
        sock.sendto(request_bytes, (address, port))
        response_data, remote_addr = sock.recvfrom(1024)
    except socket.timeout:
        if not retries:
            raise socket.timeout('Nothing was received from HLDS')

expected = '.*{0}.*{1}.*{2}.*'.format(server_name, map_name, game_name)
match = re.match(str.encode(expected, 'ASCII'), response_data)

assert match, ("Server discovery test failed!"
               "Recieved : {0}").format(response_data)
print("SUCCESS!")
    def handshake(
        self,
        server_hostname,
        verify,
        trust_bundle,
        min_version,
        max_version,
        client_cert,
        client_key,
        client_key_passphrase,
    ):
        """
        Actually performs the TLS handshake. This is run automatically by
        wrapped socket, and shouldn't be needed in user code.
        """
        # First, we do the initial bits of connection setup. We need to create
        # a context, set its I/O funcs, and set the connection reference.
        self.context = Security.SSLCreateContext(None,
                                                 SecurityConst.kSSLClientSide,
                                                 SecurityConst.kSSLStreamType)
        result = Security.SSLSetIOFuncs(self.context, _read_callback_pointer,
                                        _write_callback_pointer)
        _assert_no_error(result)

        # Here we need to compute the handle to use. We do this by taking the
        # id of self modulo 2**31 - 1. If this is already in the dictionary, we
        # just keep incrementing by one until we find a free space.
        with _connection_ref_lock:
            handle = id(self) % 2147483647
            while handle in _connection_refs:
                handle = (handle + 1) % 2147483647
            _connection_refs[handle] = self

        result = Security.SSLSetConnection(self.context, handle)
        _assert_no_error(result)

        # If we have a server hostname, we should set that too.
        if server_hostname:
            if not isinstance(server_hostname, bytes):
                server_hostname = server_hostname.encode("utf-8")

            result = Security.SSLSetPeerDomainName(self.context,
                                                   server_hostname,
                                                   len(server_hostname))
            _assert_no_error(result)

        # Setup the ciphers.
        self._set_ciphers()

        # Set the minimum and maximum TLS versions.
        result = Security.SSLSetProtocolVersionMin(self.context, min_version)
        _assert_no_error(result)

        # TLS 1.3 isn't necessarily enabled by the OS
        # so we have to detect when we error out and try
        # setting TLS 1.3 if it's allowed. kTLSProtocolMaxSupported
        # was added in macOS 10.13 along with kTLSProtocol13.
        result = Security.SSLSetProtocolVersionMax(self.context, max_version)
        if result != 0 and max_version == SecurityConst.kTLSProtocolMaxSupported:
            result = Security.SSLSetProtocolVersionMax(
                self.context, SecurityConst.kTLSProtocol12)
        _assert_no_error(result)

        # If there's a trust DB, we need to use it. We do that by telling
        # SecureTransport to break on server auth. We also do that if we don't
        # want to validate the certs at all: we just won't actually do any
        # authing in that case.
        if not verify or trust_bundle is not None:
            result = Security.SSLSetSessionOption(
                self.context, SecurityConst.kSSLSessionOptionBreakOnServerAuth,
                True)
            _assert_no_error(result)

        # If there's a client cert, we need to use it.
        if client_cert:
            self._keychain, self._keychain_dir = _temporary_keychain()
            self._client_cert_chain = _load_client_cert_chain(
                self._keychain, client_cert, client_key)
            result = Security.SSLSetCertificate(self.context,
                                                self._client_cert_chain)
            _assert_no_error(result)

        while True:
            with self._raise_on_error():
                result = Security.SSLHandshake(self.context)

                if result == SecurityConst.errSSLWouldBlock:
                    raise socket.timeout("handshake timed out")
                elif result == SecurityConst.errSSLServerAuthCompleted:
                    self._custom_validate(verify, trust_bundle)
                    continue
                else:
                    _assert_no_error(result)
                    break
Beispiel #56
0
 def first(*args, **kwargs):
     mock.side_effect = socket.error()
     raise socket.timeout()
Beispiel #57
0
 def connect(self, *args):
     if self.raise_connect_timeout:
         raise socket.timeout("mock failed socket.connect")
Beispiel #58
0
 def test_io_receive_raises_socket_timeout(self):
     connection = FakeConnection()
     io = IO(connection.parameters)
     io.socket = mock.Mock(name='socket', spec=socket.socket)
     io.socket.recv.side_effect = socket.timeout('timeout')
     io._receive()
Beispiel #59
0
 def drain_events(self, **kwargs):
     self.obj.connection = None
     raise socket.timeout(10)
Beispiel #60
0
 def read_message(self):
     self.status.append("I was unable to read data.")
     raise socket.timeout()