Application: gvSIG desktop » gvSIG scripting

from __future__ import absolute_import

import socket

try:

    from select import poll, POLLIN

except ImportError:  # `poll` doesn't exist on OSX and other platforms

    poll = False

    try:

        from select import select

    except ImportError:  # `select` doesn't exist on AppEngine.

        select = False

def is_connection_dropped(conn):  # Platform-specific

    """

    Returns True if the connection is dropped and should be closed.

    :param conn:

        :class:`httplib.HTTPConnection` object.

    Note: For platforms like AppEngine, this will always return ``False`` to

    let the platform handle connection recycling transparently for us.

    """

    sock = getattr(conn, 'sock', False)

    if sock is False:  # Platform-specific: AppEngine

        return False

    if sock is None:  # Connection already closed (such as by httplib).

        return True

    if not poll:

        if not select:  # Platform-specific: AppEngine

            return False

        try:

            return select([sock], [], [], 0.0)[0]

        except socket.error:

            return True

    # This version is better on platforms that support it.

    p = poll()

    p.register(sock, POLLIN)

    for (fno, ev) in p.poll(0.0):

        if fno == sock.fileno():

            # Either data is buffered (bad), or the connection is dropped.

            return True

# This function is copied from socket.py in the Python 2.7 standard

# library test suite. Added to its signature is only `socket_options`.

def create_connection(address, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,

                      source_address=None, socket_options=None):

    """Connect to *address* and return the socket object.

    Convenience function.  Connect to *address* (a 2-tuple ``(host,

    port)``) and return the socket object.  Passing the optional

    *timeout* parameter will set the timeout on the socket instance

    before attempting to connect.  If no *timeout* is supplied, the

    global default timeout setting returned by :func:`getdefaulttimeout`

    is used.  If *source_address* is set it must be a tuple of (host, port)

    for the socket to bind as a source address before making the connection.

    An host of '' or port 0 tells the OS to use the default.

    """

    host, port = address

    if host.startswith('['):

        host = host.strip('[]')

    err = None

    for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):

        af, socktype, proto, canonname, sa = res

        sock = None

        try:

            sock = socket.socket(af, socktype, proto)

            # If provided, set socket level options before connecting.

            # This is the only addition urllib3 makes to this function.

            _set_socket_options(sock, socket_options)

            if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:

                sock.settimeout(timeout)

            if source_address:

                sock.bind(source_address)

            sock.connect(sa)

            return sock

        except socket.error as e:

            err = e

            if sock is not None:

                sock.close()

                sock = None

    if err is not None:

        raise err

    raise socket.error("getaddrinfo returns an empty list")

def _set_socket_options(sock, options):

    if options is None:

        return

    for opt in options:

        sock.setsockopt(*opt)