• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• torngas-master
  • demo
    • run_gunicorn.py
    • gunicorn.conf.py
    • helloworld
      • models
        • main_models.py
        • __init__.py
      • handlers
        • main_handler.py
        • __init__.py
      • urls.py
      • sync_db.py
      • __init__.py
    • middleware
      • __init__.py
    • templates
      • index.html
    • runserver.py
    • logs
      • readme.txt
    • settings
      • __init__.py
      • setting.py
  • LICENSE
  • torngas
    • handler.py
    • application.py
    • resource
      • exception.html
    • signal.py
    • urlhelper.py
    • decorators
      • async_execute.py
      • whitelist.py
      • __init__.py
    • db
      • basedb.py
      • dbalchemy.py
      • __init__.py
    • webserver.py
    • settings_manager.py
    • middleware
      • signal.py
      • dbalchemy.py
      • manager.py
      • accesslog.py
      • __init__.py
      • session.py
    • global_settings.py
    • template
      • jinja2_loader.py
      • __init__.py
      • mako_loader.py
    • httpmodule
      • httpmodule.py
      • __init__.py
    • __init__.py
    • utils.py
    • exception.py
    • storage.py
    • cache
      • backends
        • rediscache.py
        • localcache.py
        • memcached.py
        • dummy.py
        • __init__.py
        • base.py
      • lru_cache.py
      • __init__.py
    • dispatch
      • weakref_backports.py
      • __init__.py
      • dispatcher.py
    • logger
      • loggers.py
      • client.py
      • __init__.py
    • mixins
      • flash_message.py
      • __init__.py
      • exception.py
      • miiddleware.py
  • setup.py
  • .travis.yml
  • README.md
  • requirements.txt
  • .gitignore

#!/usr/bin/env python
# -*- coding: utf-8  -*-

import sys
from tornado.util import import_object
from tornado.concurrent import Future
from tornado import ioloop
from tornado.util import ObjectDict
try:
    import futures
except ImportError:
    futures = None

if futures is None:
    FUTURES = Future
else:
    FUTURES = (futures.Future, Future)


def is_future(x):
    return isinstance(x, FUTURES)


import types
import contextlib
import itertools

try:
    import threading
except ImportError:
    import dummy_threading as threading

iters = [list, tuple]
PY2 = sys.version_info[0] == 2
PY3 = sys.version_info[0] == 3

if PY3:
    string_types = str,
    integer_types = int,
    class_types = type,
    text_type = str
    binary_type = bytes

    MAXSIZE = sys.maxsize
else:
    string_types = basestring,
    integer_types = (int, long)
    class_types = (type, types.ClassType)
    text_type = unicode
    binary_type = str


class RWLock(object):
    """
    Classic implementation of reader-writer lock with preference to writers.

    Readers can access a resource simultaneously.
    Writers get an exclusive access.

    API is self-descriptive:
        reader_enters()
        reader_leaves()
        writer_enters()
        writer_leaves()
    """

    def __init__(self):
        self.mutex = threading.RLock()
        self.can_read = threading.Semaphore(0)
        self.can_write = threading.Semaphore(0)
        self.active_readers = 0
        self.active_writers = 0
        self.waiting_readers = 0
        self.waiting_writers = 0

    def reader_enters(self):
        with self.mutex:
            if self.active_writers == 0 and self.waiting_writers == 0:
                self.active_readers += 1
                self.can_read.release()
            else:
                self.waiting_readers += 1
        self.can_read.acquire()

    def reader_leaves(self):
        with self.mutex:
            self.active_readers -= 1
            if self.active_readers == 0 and self.waiting_writers != 0:
                self.active_writers += 1
                self.waiting_writers -= 1
                self.can_write.release()

    @contextlib.contextmanager
    def reader(self):
        self.reader_enters()
        try:
            yield
        finally:
            self.reader_leaves()

    def writer_enters(self):
        with self.mutex:
            if self.active_writers == 0 and self.waiting_writers == 0 and self.active_readers == 0:
                self.active_writers += 1
                self.can_write.release()
            else:
                self.waiting_writers += 1
        self.can_write.acquire()

    def writer_leaves(self):
        with self.mutex:
            self.active_writers -= 1
            if self.waiting_writers != 0:
                self.active_writers += 1
                self.waiting_writers -= 1
                self.can_write.release()
            elif self.waiting_readers != 0:
                t = self.waiting_readers
                self.waiting_readers = 0
                self.active_readers += t
                while t > 0:
                    self.can_read.release()
                    t -= 1

    @contextlib.contextmanager
    def writer(self):
        self.writer_enters()
        try:
            yield
        finally:
            self.writer_leaves()


class cached_property(object):
    """
    Decorator that converts a method with a single self argument into a
    property cached on the instance.
    """

    def __init__(self, func):
        self.func = func

    def __get__(self, instance, type=None):
        if instance is None:
            return self
        res = instance.__dict__[self.func.__name__] = self.func(instance)
        return res


class LazyImport:
    """lazy import module"""

    def __init__(self, module_name):
        self.module_name = module_name
        self.module = None

    def __getattr__(self, func_name):
        if self.module is None:
            self.module = import_object(self.module_name)
        return getattr(self.module, func_name)


lazyimport = LazyImport


class Null(object):
    def __new__(cls, *args, **kwargs):
        if '_instance' not in vars(cls):
            cls._instance = super(Null, cls).__new__(cls, *args, **kwargs)
        return cls._instance

    def __init__(self, *args, **kwargs): pass

    def __call__(self, *args, **kwargs): return self

    def __repr__(self): return ""

    def __nonzero__(self): return False

    def __getattr__(self, item): return self

    def __setattr__(self, key, value): return self

    def __delattr__(self, item): return self

    def __len__(self): return 0

    def __iter__(self): return iter(())

    def __getitem__(self, item): return self

    def __delitem__(self, key): return self

    def __setitem__(self, key, value): return self


def safeunicode(obj, encoding='utf-8'):
    """
    Converts any given object to unicode string.

        >>> safeunicode('hello')
        u'hello'
        >>> safeunicode(2)
        u'2'
        >>> safeunicode('\xe1\x88\xb4')
        u'\u1234'
    """
    t = type(obj)
    if t is unicode:
        return obj
    elif t is str:
        return obj.decode(encoding)
    elif t in [int, float, bool]:
        return unicode(obj)
    elif hasattr(obj, '__unicode__') or isinstance(obj, unicode):
        return unicode(obj)
    else:
        return str(obj).decode(encoding)


def safestr(obj, encoding='utf-8'):
    r"""
    Converts any given object to utf-8 encoded string.

        >>> safestr('hello')
        'hello'
        >>> safestr(u'\u1234')
        '\xe1\x88\xb4'
        >>> safestr(2)
        '2'
    """
    if isinstance(obj, unicode):
        return obj.encode(encoding)
    elif isinstance(obj, str):
        return obj
    elif hasattr(obj, 'next'):  # iterator
        return itertools.imap(safestr, obj)
    else:
        return str(obj)

# for backward-compatibility
utf8 = safestr


def _strips(direction, text, remove):
    if isinstance(remove, iters):
        for subr in remove:
            text = _strips(direction, text, subr)
        return text

    if direction == 'l':
        if text.startswith(remove):
            return text[len(remove):]
    elif direction == 'r':
        if text.endswith(remove):
            return text[:-len(remove)]
    else:
        raise ValueError, "Direction needs to be r or l."
    return text


def rstrips(text, remove):
    """
    removes the string `remove` from the right of `text`

        >>> rstrips("foobar", "bar")
        'foo'

    """
    return _strips('r', text, remove)


def lstrips(text, remove):
    """
    removes the string `remove` from the left of `text`

        >>> lstrips("foobar", "foo")
        'bar'
        >>> lstrips('http://foo.org/', ['http://', 'https://'])
        'foo.org/'
        >>> lstrips('FOOBARBAZ', ['FOO', 'BAR'])
        'BAZ'
        >>> lstrips('FOOBARBAZ', ['BAR', 'FOO'])
        'BARBAZ'

    """
    return _strips('l', text, remove)


def strips(text, remove):
    """
    removes the string `remove` from the both sides of `text`

        >>> strips("foobarfoo", "foo")
        'bar'

    """
    return rstrips(lstrips(text, remove), remove)


class IterBetter:
    """
    Returns an object that can be used as an iterator
    but can also be used via __getitem__ (although it
    cannot go backwards -- that is, you cannot request
    `iterbetter[0]` after requesting `iterbetter[1]`).

        >>> import itertools
        >>> c = iterbetter(itertools.count())
        >>> c[1]
        1
        >>> c[5]
        5
        >>> c[3]
        Traceback (most recent call last):
            ...
        IndexError: already passed 3

    For boolean test, IterBetter peeps at first value in the itertor without effecting the iteration.

        >>> c = iterbetter(iter(range(5)))
        >>> bool(c)
        True
        >>> list(c)
        [0, 1, 2, 3, 4]
        >>> c = iterbetter(iter([]))
        >>> bool(c)
        False
        >>> list(c)
        []
    """

    def __init__(self, iterator):
        self.i, self.c = iterator, 0

    def __iter__(self):
        if hasattr(self, "_head"):
            yield self._head

        while 1:
            yield self.i.next()
            self.c += 1

    def __getitem__(self, i):
        # todo: slices
        if i < self.c:
            raise IndexError, "already passed " + str(i)
        try:
            while i > self.c:
                self.i.next()
                self.c += 1
                # now self.c == i
            self.c += 1
            return self.i.next()
        except StopIteration:
            raise IndexError, str(i)

    def __nonzero__(self):
        if hasattr(self, "__len__"):
            return len(self) != 0
        elif hasattr(self, "_head"):
            return True
        else:
            try:
                self._head = self.i.next()
            except StopIteration:
                return False
            else:
                return True


iterbetter = IterBetter


def sleep(seconds):
    """
    async sleep .
    yield sleep(5)
    :param seconds:
    :return:
    """
    future = Future()
    ioloop.IOLoop.current().call_later(seconds, lambda: future.set_result(None))
    return future

class ThreadlocalLikeRequestContext(object):
    """
    通过request_context.data,可以在任意位置访问当前请求的request对象，
    以达到类似多线程wsgi程序中全局threadlocal request的目的。
    eg：current_request = request_context.request
    """

    _state = threading.local()
    _state.data = ObjectDict({})

    class __metaclass__(type):
        @property
        def data(cls):
            if not hasattr(cls._state, 'data'):
               return ObjectDict({})
            return ObjectDict(cls._state.data)

        @property
        def request(cls):
            return cls.data.get('request')

    def __init__(self, **data):
        self._data = data

    def __enter__(self):
        self._prev_data = self.__class__.data
        self.__class__._state.data = self._data

    def __exit__(self, *exc):
        self.__class__._state.data = self._prev_data
        del self._prev_data
        return False

request_context = ThreadlocalLikeRequestContext