"""

Module provides a class allowing to wrap communication over subprocess.Popen

input, output, error streams into a meaningful, non-blocking, concurrent

stream processor exposing the output data as an iterator fitting to be a

return value passed by a WSGI application to a WSGI server per PEP 3333.

Copyright (c) 2011  Daniel Dotsenko <dotsa[at]hotmail.com>

This file is part of git_http_backend.py Project.

git_http_backend.py Project is free software: you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public License as

published by the Free Software Foundation, either version 2.1 of the License,

or (at your option) any later version.

git_http_backend.py Project is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License

along with git_http_backend.py Project.

If not, see <http://www.gnu.org/licenses/>.

"""

import collections

import os

import subprocess

import threading

class StreamFeeder(threading.Thread):

    """

    Normal writing into pipe-like is blocking once the buffer is filled.

    This thread allows a thread to seep data from a file-like into a pipe

    without blocking the main thread.

    We close inpipe once the end of the source stream is reached.

    """

    def __init__(self, source):

        super(StreamFeeder, self).__init__()

        self.daemon = True

        filelike = False

        self.bytes = bytes()

        if type(source) in (type(''), bytes, bytearray):  # string-like

            self.bytes = bytes(source)

        else:  # can be either file pointer or file-like

                # converting file descriptor (int) stdin into file-like

                source = os.fdopen(source, 'rb', 16384)

            # let's see if source is file-like by now

            filelike = hasattr(source, 'read')

        if not filelike and not self.bytes:

            raise TypeError("StreamFeeder's source object must be a readable "

                            "file-like, a file descriptor, or a string-like.")

        self.source = source

        self.readiface, self.writeiface = os.pipe()

    def run(self):

        t = self.writeiface

        if self.bytes:

            os.write(t, self.bytes)

        else:

            s = self.source

            b = s.read(4096)

            while b:

                os.write(t, b)

                b = s.read(4096)

        os.close(t)

    @property

    def output(self):

        return self.readiface

class InputStreamChunker(threading.Thread):

    def __init__(self, source, target, buffer_size, chunk_size):

        super(InputStreamChunker, self).__init__()

        self.daemon = True  # die die die.

        self.source = source

        self.target = target

        self.chunk_count_max = int(buffer_size / chunk_size) + 1

        self.chunk_size = chunk_size

        self.data_added = threading.Event()

        self.data_added.clear()

        self.keep_reading = threading.Event()

        self.keep_reading.set()

        self.EOF = threading.Event()

        self.EOF.clear()

            # update with attributes from __json__

            if callable(_json_attr):

                _json_attr = _json_attr()

            for k, val in _json_attr.iteritems():

                d[k] = val

        return d

    def get_appstruct(self):

        """return list with keys and values tuples corresponding

        to this model data """

        return [

            (k, getattr(self, k))

            for k in self._get_keys()

        ]

    def populate_obj(self, populate_dict):

        """populate model with data from given populate_dict"""

        for k in self._get_keys():

            if k in populate_dict:

                setattr(self, k, populate_dict[k])

    @classmethod

    def query(cls):

        return Session().query(cls)

    @classmethod

    def get(cls, id_):

        if id_:

            return cls.query().get(id_)

    @classmethod

    def guess_instance(cls, value, callback=None):

        """Haphazardly attempt to convert `value` to a `cls` instance.

        If `value` is None or already a `cls` instance, return it. If `value`

        is a number (or looks like one if you squint just right), assume it's

        a database primary key and let SQLAlchemy sort things out. Otherwise,

        fall back to resolving it using `callback` (if specified); this could

        e.g. be a function that looks up instances by name (though that won't

        work if the name begins with a digit). Otherwise, raise Exception.

        """

        if value is None:

            return None

        if isinstance(value, cls):

            return value

            return cls.get(value)

        if isinstance(value, basestring) and value.isdigit():

            return cls.get(int(value))

        if callback is not None:

            return callback(value)

        raise Exception(

            'given object must be int, long or Instance of %s '

            'got %s, no callback provided' % (cls, type(value))

        )

    @classmethod

    def get_or_404(cls, id_):

        try:

            id_ = int(id_)

        except (TypeError, ValueError):

            raise HTTPNotFound

        res = cls.query().get(id_)

        if res is None:

            raise HTTPNotFound

        return res

    @classmethod

    def delete(cls, id_):

        obj = cls.query().get(id_)

        Session().delete(obj)

    def __repr__(self):

        return '<DB:%s>' % (self.__class__.__name__)

_table_args_default_dict = {'extend_existing': True,

                            'mysql_engine': 'InnoDB',

                            'mysql_charset': 'utf8',

                            'sqlite_autoincrement': True,

                           }

class Setting(Base, BaseDbModel):

    __tablename__ = 'settings'

    __table_args__ = (

        _table_args_default_dict,

    )

    SETTINGS_TYPES = {

        'str': safe_bytes,

        'int': safe_int,

        'unicode': safe_unicode,