eventlet/eventlet/api.py

   1 import errno
   2 import sys
   3 import socket
   4 import string
   5 import linecache
   6 import inspect
   7 import warnings
   8
   9 from eventlet.support import greenlets as greenlet
  10 from eventlet import hubs
  11 from eventlet import greenthread
  12 from eventlet import debug
  13 from eventlet import Timeout
  14
  15 __all__ = [
  16     'call_after', 'exc_after', 'getcurrent', 'get_default_hub', 'get_hub',
  17     'GreenletExit', 'kill', 'sleep', 'spawn', 'spew', 'switch',
  18     'ssl_listener', 'tcp_listener', 'trampoline',
  19     'unspew', 'use_hub', 'with_timeout', 'timeout']
  20
  21 warnings.warn(
  22     "eventlet.api is deprecated!  Nearly everything in it has moved "
  23     "to the eventlet module.", DeprecationWarning, stacklevel=2)
  24
  25
  26 def get_hub(*a, **kw):
  27     warnings.warn(
  28         "eventlet.api.get_hub has moved to eventlet.hubs.get_hub",
  29         DeprecationWarning, stacklevel=2)
  30     return hubs.get_hub(*a, **kw)
  31
  32
  33 def get_default_hub(*a, **kw):
  34     warnings.warn(
  35         "eventlet.api.get_default_hub has moved to"
  36         " eventlet.hubs.get_default_hub",
  37         DeprecationWarning, stacklevel=2)
  38     return hubs.get_default_hub(*a, **kw)
  39
  40
  41 def use_hub(*a, **kw):
  42     warnings.warn(
  43         "eventlet.api.use_hub has moved to eventlet.hubs.use_hub",
  44         DeprecationWarning, stacklevel=2)
  45     return hubs.use_hub(*a, **kw)
  46
  47
  48 def switch(coro, result=None, exc=None):
  49     if exc is not None:
  50         return coro.throw(exc)
  51     return coro.switch(result)
  52
  53 Greenlet = greenlet.greenlet
  54
  55
  56 def tcp_listener(address, backlog=50):
  57     """
  58     Listen on the given ``(ip, port)`` *address* with a TCP socket.  Returns a
  59     socket object on which one should call ``accept()`` to accept a connection
  60     on the newly bound socket.
  61     """
  62     warnings.warn(
  63         """eventlet.api.tcp_listener is deprecated.  Please use eventlet.listen instead.""",
  64         DeprecationWarning, stacklevel=2)
  65
  66     from eventlet import greenio, util
  67     socket = greenio.GreenSocket(util.tcp_socket())
  68     util.socket_bind_and_listen(socket, address, backlog=backlog)
  69     return socket
  70
  71
  72 def ssl_listener(address, certificate, private_key):
  73     """Listen on the given (ip, port) *address* with a TCP socket that
  74     can do SSL.  Primarily useful for unit tests, don't use in production.
  75
  76     *certificate* and *private_key* should be the filenames of the appropriate
  77     certificate and private key files to use with the SSL socket.
  78
  79     Returns a socket object on which one should call ``accept()`` to
  80     accept a connection on the newly bound socket.
  81     """
  82     warnings.warn("""eventlet.api.ssl_listener is deprecated.  Please use eventlet.wrap_ssl(eventlet.listen(
  83         )) instead.""",
  84                   DeprecationWarning, stacklevel=2)
  85     from eventlet import util
  86     import socket
  87
  88     socket = util.wrap_ssl(socket.socket(), certificate, private_key, True)
  89     socket.bind(address)
  90     socket.listen(50)
  91     return socket
  92
  93
  94 def connect_tcp(address, localaddr=None):
  95     """
  96     Create a TCP connection to address ``(host, port)`` and return the socket.
  97     Optionally, bind to localaddr ``(host, port)`` first.
  98     """
  99     warnings.warn(
 100         """eventlet.api.connect_tcp is deprecated.  Please use eventlet.connect instead.""",
 101         DeprecationWarning, stacklevel=2)
 102
 103     from eventlet import greenio, util
 104     desc = greenio.GreenSocket(util.tcp_socket())
 105     if localaddr is not None:
 106         desc.bind(localaddr)
 107     desc.connect(address)
 108     return desc
 109
 110 TimeoutError = greenthread.TimeoutError
 111
 112 trampoline = hubs.trampoline
 113
 114 spawn = greenthread.spawn
 115 spawn_n = greenthread.spawn_n
 116
 117
 118 kill = greenthread.kill
 119
 120 call_after = greenthread.call_after
 121 call_after_local = greenthread.call_after_local
 122 call_after_global = greenthread.call_after_global
 123
 124
 125 class _SilentException(BaseException):
 126     pass
 127
 128
 129 class FakeTimer(object):
 130     def cancel(self):
 131         pass
 132
 133
 134 class timeout(object):
 135     """Raise an exception in the block after timeout.
 136
 137     Example::
 138
 139     with timeout(10):
 140         urllib2.open('http://example.com')
 141
 142     Assuming code block is yielding (i.e. gives up control to the hub),
 143     an exception provided in *exc* argument will be raised
 144     (:class:`~eventlet.api.TimeoutError` if *exc* is omitted)::
 145
 146     try:
 147         with timeout(10, MySpecialError, error_arg_1):
 148             urllib2.open('http://example.com')
 149     except MySpecialError as e:
 150         print("special error received")
 151
 152     When *exc* is ``None``, code block is interrupted silently.
 153     """
 154
 155     def __init__(self, seconds, *throw_args):
 156         self.seconds = seconds
 157         if seconds is None:
 158             return
 159         if not throw_args:
 160             self.throw_args = (TimeoutError(), )
 161         elif throw_args == (None, ):
 162             self.throw_args = (_SilentException(), )
 163         else:
 164             self.throw_args = throw_args
 165
 166     def __enter__(self):
 167         if self.seconds is None:
 168             self.timer = FakeTimer()
 169         else:
 170             self.timer = exc_after(self.seconds, *self.throw_args)
 171         return self.timer
 172
 173     def __exit__(self, typ, value, tb):
 174         self.timer.cancel()
 175         if typ is _SilentException and value in self.throw_args:
 176             return True
 177
 178
 179 with_timeout = greenthread.with_timeout
 180
 181 exc_after = greenthread.exc_after
 182
 183 sleep = greenthread.sleep
 184
 185 getcurrent = greenlet.getcurrent
 186 GreenletExit = greenlet.GreenletExit
 187
 188 spew = debug.spew
 189 unspew = debug.unspew
 190
 191
 192 def named(name):
 193     """Return an object given its name.
 194
 195     The name uses a module-like syntax, eg::
 196
 197       os.path.join
 198
 199     or::
 200
 201       mulib.mu.Resource
 202     """
 203     toimport = name
 204     obj = None
 205     import_err_strings = []
 206     while toimport:
 207         try:
 208             obj = __import__(toimport)
 209             break
 210         except ImportError as err:
 211             # print('Import error on %s: %s' % (toimport, err))  # debugging spam
 212             import_err_strings.append(err.__str__())
 213             toimport = '.'.join(toimport.split('.')[:-1])
 214     if obj is None:
 215         raise ImportError('%s could not be imported.  Import errors: %r' % (name, import_err_strings))
 216     for seg in name.split('.')[1:]:
 217         try:
 218             obj = getattr(obj, seg)
 219         except AttributeError:
 220             dirobj = dir(obj)
 221             dirobj.sort()
 222             raise AttributeError('attribute %r missing from %r (%r) %r.  Import errors: %r' % (
 223                 seg, obj, dirobj, name, import_err_strings))
 224     return obj