# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.error

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~

    RhodeCode error controller

    :created_on: Dec 8, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program 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 General Public License for more details.

#

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

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import os

import cgi

import logging

import paste.fileapp

from pylons import tmpl_context as c, request, config, url

from pylons.i18n.translation import _

from pylons.middleware import  media_path

from rhodecode.lib.base import BaseController, render

log = logging.getLogger(__name__)

class ErrorController(BaseController):

    """Generates error documents as and when they are required.

    The ErrorDocuments middleware forwards to ErrorController when error

    related status codes are returned from the application.

    This behavior can be altered by changing the parameters to the

    ErrorDocuments middleware in your config/middleware.py file.

    """

    def __before__(self):

        #disable all base actions since we don't need them here

        pass

    def document(self):

        resp = request.environ.get('pylons.original_response')

        c.rhodecode_name = config.get('rhodecode_title')

        log.debug('### %s ###' % resp.status)

        e = request.environ

        c.serv_p = r'%(protocol)s://%(host)s/' \

                                    % {'protocol': e.get('wsgi.url_scheme'),

                                       'host': e.get('HTTP_HOST'), }

        c.error_message = cgi.escape(request.GET.get('code', str(resp.status)))

        c.error_explanation = self.get_error_explanation(resp.status_int)

        #  redirect to when error with given seconds

        c.redirect_time = 0

        c.redirect_module = _('Home page')

        c.url_redirect = "/"

        return render('/errors/error_document.html')

    def img(self, id):

        """Serve Pylons' stock images"""

        return self._serve_file(os.path.join(media_path, 'img', id))

    def style(self, id):

        """Serve Pylons' stock stylesheets"""

        return self._serve_file(os.path.join(media_path, 'style', id))

    def _serve_file(self, path):

        """Call Paste's FileApp (a WSGI application) to serve the file

        at the specified path

        """

        fapp = paste.fileapp.FileApp(path)

        return fapp(request.environ, self.start_response)

    def get_error_explanation(self, code):

        try:

            code = int(code)

        except Exception:

            code = 500

        if code == 400:

            return _('The request could not be understood by the server'

                     ' due to malformed syntax.')

        if code == 401:

            return _('Unauthorized access to resource')

        if code == 403:

            return _("You don't have permission to view this page")

        if code == 404:

            return _('The resource could not be found')

        if code == 500:

            return _('The server encountered an unexpected condition'

                     ' which prevented it from fulfilling the request.')

"""

Code to generate a Python model from a database or differences

between a model and database.

Some of this is borrowed heavily from the AutoCode project at:

http://code.google.com/p/sqlautocode/

"""

import sys

import logging

import sqlalchemy

from rhodecode.lib.dbmigrate import migrate

from rhodecode.lib.dbmigrate.migrate import changeset

log = logging.getLogger(__name__)

HEADER = """

## File autogenerated by genmodel.py

from sqlalchemy import *

meta = MetaData()

"""

DECLARATIVE_HEADER = """

## File autogenerated by genmodel.py

from sqlalchemy import *

from sqlalchemy.ext import declarative

Base = declarative.declarative_base()

"""

class ModelGenerator(object):

    """Various transformations from an A, B diff.

    In the implementation, A tends to be called the model and B

    the database (although this is not true of all diffs).

    The diff is directionless, but transformations apply the diff

    in a particular direction, described in the method name.

    """

    def __init__(self, diff, engine, declarative=False):

        self.diff = diff

        self.engine = engine

        self.declarative = declarative

    def column_repr(self, col):

        kwarg = []

        if col.key != col.name:

            kwarg.append('key')

        if col.primary_key:

            col.primary_key = True  # otherwise it dumps it as 1

            kwarg.append('primary_key')

        if not col.nullable:

            kwarg.append('nullable')

        if col.onupdate:

            kwarg.append('onupdate')

        if col.default:

            if col.primary_key:

                # I found that PostgreSQL automatically creates a

                # default value for the sequence, but let's not show

                # that.

                pass

            else:

                kwarg.append('default')

        args = ['%s=%r' % (k, getattr(col, k)) for k in kwarg]

        # crs: not sure if this is good idea, but it gets rid of extra

        # u''

        name = col.name.encode('utf8')

        type_ = col.type

        for cls in col.type.__class__.__mro__:

            if cls.__module__ == 'sqlalchemy.types' and \

                not cls.__name__.isupper():

                if cls is not type_.__class__:

                    type_ = cls()

                break

        type_repr = repr(type_)

        if type_repr.endswith('()'):

            type_repr = type_repr[:-2]

        constraints = [repr(cn) for cn in col.constraints]

        data = {

            'name': name,

            'commonStuff': ', '.join([type_repr] + constraints + args),

        }

        if self.declarative:

            return """%(name)s = Column(%(commonStuff)s)""" % data

        else:

            return """Column(%(name)r, %(commonStuff)s)""" % data

    def _getTableDefn(self, table, metaName='meta'):

        out = []

        tableName = table.name

        if self.declarative:

            out.append("class %(table)s(Base):" % {'table': tableName})

            out.append("    __tablename__ = '%(table)s'\n" %

                            {'table': tableName})

            for col in table.columns:

                out.append("    %s" % self.column_repr(col))

            out.append('\n')

        else:

            out.append("%(table)s = Table('%(table)s', %(meta)s," %

                       {'table': tableName, 'meta': metaName})

            for col in table.columns:

                out.append("    %s," % self.column_repr(col))

            out.append(")\n")

        return out

    def _get_tables(self,missingA=False,missingB=False,modified=False):

        to_process = []

        for bool_,names,metadata in (

            (missingA,self.diff.tables_missing_from_A,self.diff.metadataB),

            (missingB,self.diff.tables_missing_from_B,self.diff.metadataA),

            (modified,self.diff.tables_different,self.diff.metadataA),

                ):

            if bool_:

                for name in names:

                    yield metadata.tables.get(name)

    def genBDefinition(self):

        """Generates the source code for a definition of B.

        Assumes a diff where A is empty.

        Was: toPython. Assume database (B) is current and model (A) is empty.

        """

        out = []

        if self.declarative:

            out.append(DECLARATIVE_HEADER)

        else:

            out.append(HEADER)

        out.append("")

        for table in self._get_tables(missingA=True):

            out.extend(self._getTableDefn(table))

        return '\n'.join(out)

    def genB2AMigration(self, indent='    '):

        Was: toUpgradeDowngradePython

        Assume model (A) is most current and database (B) is out-of-date.

        decls = ['from migrate.changeset import schema',

                 'pre_meta = MetaData()',

                 'post_meta = MetaData()',

                ]

        upgradeCommands = ['pre_meta.bind = migrate_engine',

                           'post_meta.bind = migrate_engine']

        downgradeCommands = list(upgradeCommands)

        for tn in self.diff.tables_missing_from_A:

            pre_table = self.diff.metadataB.tables[tn]

            decls.extend(self._getTableDefn(pre_table, metaName='pre_meta'))

            upgradeCommands.append(

                "pre_meta.tables[%(table)r].drop()" % {'table': tn})

            downgradeCommands.append(

                "pre_meta.tables[%(table)r].create()" % {'table': tn})

        for tn in self.diff.tables_missing_from_B:

            post_table = self.diff.metadataA.tables[tn]

            decls.extend(self._getTableDefn(post_table, metaName='post_meta'))

            upgradeCommands.append(

                "post_meta.tables[%(table)r].create()" % {'table': tn})

            downgradeCommands.append(

                "post_meta.tables[%(table)r].drop()" % {'table': tn})

        for (tn, td) in self.diff.tables_different.iteritems():

            if td.columns_missing_from_A or td.columns_different:

                pre_table = self.diff.metadataB.tables[tn]

                decls.extend(self._getTableDefn(

                    pre_table, metaName='pre_meta'))

            if td.columns_missing_from_B or td.columns_different:

                post_table = self.diff.metadataA.tables[tn]

                decls.extend(self._getTableDefn(

                    post_table, metaName='post_meta'))

            for col in td.columns_missing_from_A:

                upgradeCommands.append(

                    'pre_meta.tables[%r].columns[%r].drop()' % (tn, col))

                downgradeCommands.append(

                    'pre_meta.tables[%r].columns[%r].create()' % (tn, col))

            for col in td.columns_missing_from_B:

                upgradeCommands.append(

                    'post_meta.tables[%r].columns[%r].create()' % (tn, col))

                downgradeCommands.append(

                    'post_meta.tables[%r].columns[%r].drop()' % (tn, col))

            for modelCol, databaseCol, modelDecl, databaseDecl in td.columns_different:

                upgradeCommands.append(

                    'assert False, "Can\'t alter columns: %s:%s=>%s"' % (

                    tn, modelCol.name, databaseCol.name))

                downgradeCommands.append(

                    'assert False, "Can\'t alter columns: %s:%s=>%s"' % (

                    tn, modelCol.name, databaseCol.name))

        return (

            '\n'.join(decls),

            '\n'.join('%s%s' % (indent, line) for line in upgradeCommands),

            '\n'.join('%s%s' % (indent, line) for line in downgradeCommands))

    def _db_can_handle_this_change(self,td):

        """Check if the database can handle going from B to A."""

        if (td.columns_missing_from_B

            and not td.columns_missing_from_A

            and not td.columns_different):

            # Even sqlite can handle column additions.

            return True

        else:

            return not self.engine.url.drivername.startswith('sqlite')

    def runB2A(self):

        """Goes from B to A.

        Was: applyModel. Apply model (A) to current database (B).

        """

        meta = sqlalchemy.MetaData(self.engine)

        for table in self._get_tables(missingA=True):

            table = table.tometadata(meta)

            table.drop()

        for table in self._get_tables(missingB=True):

            table = table.tometadata(meta)

            table.create()

        for modelTable in self._get_tables(modified=True):

            tableName = modelTable.name

            modelTable = modelTable.tometadata(meta)

            dbTable = self.diff.metadataB.tables[tableName]

            td = self.diff.tables_different[tableName]

            if self._db_can_handle_this_change(td):

                for col in td.columns_missing_from_B:

                    modelTable.columns[col].create()

                for col in td.columns_missing_from_A:

                    dbTable.columns[col].drop()

                # XXX handle column changes here.

            else:

                # Sqlite doesn't support drop column, so you have to

                # do more: create temp table, copy data to it, drop

                # old table, create new table, copy data back.

                #

                # I wonder if this is guaranteed to be unique?

                tempName = '_temp_%s' % modelTable.name

                def getCopyStatement():

                    preparer = self.engine.dialect.preparer

                    commonCols = []

                    for modelCol in modelTable.columns:

                        if modelCol.name in dbTable.columns:

                            commonCols.append(modelCol.name)

                    commonColsStr = ', '.join(commonCols)

                    return 'INSERT INTO %s (%s) SELECT %s FROM %s' % \

                        (tableName, commonColsStr, commonColsStr, tempName)

                # Move the data in one transaction, so that we don't

                # leave the database in a nasty state.

                connection = self.engine.connect()

                trans = connection.begin()

                try:

                    connection.execute(

                        'CREATE TEMPORARY TABLE %s as SELECT * from %s' % \

                            (tempName, modelTable.name))

                    # make sure the drop takes place inside our

                    # transaction with the bind parameter

                    modelTable.drop(bind=connection)

                    modelTable.create(bind=connection)

                    connection.execute(getCopyStatement())

                    connection.execute('DROP TABLE %s' % tempName)

                    trans.commit()

                except:

                    trans.rollback()

                    raise

      The :class:`~sqlalchemy.schema.Column` object for A.

    .. attribute:: col_B

      The :class:`~sqlalchemy.schema.Column` object for B.

    .. attribute:: type_A

      The most generic type of the :class:`~sqlalchemy.schema.Column`

      object in A.

    .. attribute:: type_B

      The most generic type of the :class:`~sqlalchemy.schema.Column`

      object in A.

    """

    diff = False

    def __init__(self,col_A,col_B):

        self.col_A = col_A

        self.col_B = col_B

        self.type_A = col_A.type

        self.type_B = col_B.type

        self.affinity_A = self.type_A._type_affinity

        self.affinity_B = self.type_B._type_affinity

        if self.affinity_A is not self.affinity_B:

            self.diff = True

            return

        if isinstance(self.type_A,Float) or isinstance(self.type_B,Float):

            if not (isinstance(self.type_A,Float) and isinstance(self.type_B,Float)):

                self.diff=True

                return

        for attr in ('precision','scale','length'):

            A = getattr(self.type_A,attr,None)

            B = getattr(self.type_B,attr,None)

            if not (A is None or B is None) and A!=B:

                self.diff=True

                return

    def __nonzero__(self):

        return self.diff

class TableDiff(object):

    """

    Container for differences in one :class:`~sqlalchemy.schema.Table`

    between two :class:`~sqlalchemy.schema.MetaData` instances, ``A``

    and ``B``.

    .. attribute:: columns_missing_from_A

      A sequence of column names that were found in B but weren't in

      A.

    .. attribute:: columns_missing_from_B

      A sequence of column names that were found in A but weren't in

      B.

    .. attribute:: columns_different

      A dictionary containing information about columns that were

      found to be different.

      It maps column names to a :class:`ColDiff` objects describing the

      differences found.

    """

    __slots__ = (

        'columns_missing_from_A',

        'columns_missing_from_B',

        'columns_different',

        )

    def __nonzero__(self):

        return bool(

            self.columns_missing_from_A or

            self.columns_missing_from_B or

            self.columns_different

            )

class SchemaDiff(object):

    """

    Compute the difference between two :class:`~sqlalchemy.schema.MetaData`

    objects.

    The string representation of a :class:`SchemaDiff` will summarise

    the changes found between the two

    :class:`~sqlalchemy.schema.MetaData` objects.

    The length of a :class:`SchemaDiff` will give the number of

    changes found, enabling it to be used much like a boolean in

    expressions.

    :param metadataA:

      First :class:`~sqlalchemy.schema.MetaData` to compare.

    :param metadataB:

      Second :class:`~sqlalchemy.schema.MetaData` to compare.

    :param labelA:

      The label to use in messages about the first

      :class:`~sqlalchemy.schema.MetaData`.

    :param labelB:

      The label to use in messages about the second

      :class:`~sqlalchemy.schema.MetaData`.

    :param excludeTables:

      A sequence of table names to exclude.

    .. attribute:: tables_missing_from_A

      A sequence of table names that were found in B but weren't in

      A.

    .. attribute:: tables_missing_from_B

      A sequence of table names that were found in A but weren't in

      B.

    .. attribute:: tables_different

      A dictionary containing information about tables that were found

      to be different.

      It maps table names to a :class:`TableDiff` objects describing the

      differences found.

    """

    def __init__(self,

                 metadataA, metadataB,

                 labelA='metadataA',

                 labelB='metadataB',

                 excludeTables=None):

        self.metadataA, self.metadataB = metadataA, metadataB

        self.labelA, self.labelB = labelA, labelB

        self.label_width = max(len(labelA),len(labelB))

        excludeTables = set(excludeTables or [])

        A_table_names = set(metadataA.tables.keys())

        B_table_names = set(metadataB.tables.keys())

        self.tables_missing_from_A = sorted(

            B_table_names - A_table_names - excludeTables

            )

        self.tables_missing_from_B = sorted(

            A_table_names - B_table_names - excludeTables

            )

        self.tables_different = {}

        for table_name in A_table_names.intersection(B_table_names):

            td = TableDiff()

            A_table = metadataA.tables[table_name]

            B_table = metadataB.tables[table_name]

            A_column_names = set(A_table.columns.keys())

            B_column_names = set(B_table.columns.keys())

            td.columns_missing_from_A = sorted(

                B_column_names - A_column_names

                )

            td.columns_missing_from_B = sorted(

                A_column_names - B_column_names

                )

            td.columns_different = {}

            for col_name in A_column_names.intersection(B_column_names):

                cd = ColDiff(

                    A_table.columns.get(col_name),

                    B_table.columns.get(col_name)

                    )

                if cd:

                    td.columns_different[col_name]=cd

            # XXX - index and constraint differences should

            #       be checked for here

            if td:

                self.tables_different[table_name]=td

    def __str__(self):

        out = []

        column_template ='      %%%is: %%r' % self.label_width

        for names,label in (

            (self.tables_missing_from_A,self.labelA),

            (self.tables_missing_from_B,self.labelB),

            ):

            if names:

                out.append(

                    '  tables missing from %s: %s' % (

                        label,', '.join(sorted(names))

                        )

                    )

        for name,td in sorted(self.tables_different.items()):

            out.append(

               '  table with differences: %s' % name

               )

            for names,label in (

                (td.columns_missing_from_A,self.labelA),

                (td.columns_missing_from_B,self.labelB),

                ):

                if names:

                    out.append(

                        '    %s missing these columns: %s' % (

                            label,', '.join(sorted(names))

                            )

                        )

            for name,cd in td.columns_different.items():

                out.append('    column with differences: %s' % name)

                out.append(column_template % (self.labelA,cd.col_A))

                out.append(column_template % (self.labelB,cd.col_B))

        if out:

            out.insert(0, 'Schema diffs:')

            return '\n'.join(out)

        else:

            return 'No schema diffs'

    def __len__(self):

        """

        Used in bool evaluation, return of 0 means no diffs.

        """

        return (

            len(self.tables_missing_from_A) +

            len(self.tables_missing_from_B) +

            len(self.tables_different)

            )

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

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

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

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

Copyright (c) 2011  Daniel Dotsenko <dotsa@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 os

import subprocess

from rhodecode.lib.vcs.utils.compat import deque, Event, Thread, _bytes, _bytearray

class StreamFeeder(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

            if type(source) in (int, long):  # file pointer it is

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

                try:

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

                except Exception:

                    pass

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

            try:

                filelike = source.read

            except Exception:

                pass

        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(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 = Event()

        self.data_added.clear()

        self.keep_reading = Event()

        self.keep_reading.set()

        self.EOF = Event()

        self.EOF.clear()

        self.go = Event()

        self.go.set()

    def stop(self):

        self.go.clear()

        self.EOF.set()

        try:

            # this is not proper, but is done to force the reader thread let

            # go of the input because, if successful, .close() will send EOF

            # down the pipe.

            self.source.close()

        except:

            pass

    def run(self):

        s = self.source

        t = self.target

        cs = self.chunk_size

        ccm = self.chunk_count_max

        kr = self.keep_reading

        da = self.data_added

        go = self.go

        try:

            b = s.read(cs)

        except ValueError:

            b = ''

        while b and go.is_set():

            if len(t) > ccm:

                kr.clear()

                kr.wait(2)

#                # this only works on 2.7.x and up

#                if not kr.wait(10):

#                    raise Exception("Timed out while waiting for input to be read.")

                # instead we'll use this

                if len(t) > ccm + 3:

                    raise IOError("Timed out while waiting for input from subprocess.")

            t.append(b)

            da.set()

            b = s.read(cs)

        self.EOF.set()

        da.set()  # for cases when done but there was no input.

class BufferedGenerator():

    Class behaves as a non-blocking, buffered pipe reader.

    Reads chunks of data (through a thread)

    from a blocking pipe, and attaches these to an array (Deque) of chunks.

    Reading is halted in the thread when max chunks is internally buffered.

    The .next() may operate in blocking or non-blocking fashion by yielding

    '' if no data is ready

    to be sent or by not returning until there is some data to send

    When we get EOF from underlying source pipe we raise the marker to raise

    StopIteration after the last chunk of data is yielded.

    def __init__(self, source, buffer_size=65536, chunk_size=4096,

                 starting_values=[], bottomless=False):

        if bottomless:

            maxlen = int(buffer_size / chunk_size)

        else:

            maxlen = None

        self.data = deque(starting_values, maxlen)

        self.worker = InputStreamChunker(source, self.data, buffer_size,

                                         chunk_size)

        if starting_values:

            self.worker.data_added.set()

        self.worker.start()

    ####################

    # Generator's methods

    ####################

    def __iter__(self):

        return self

    def next(self):

        while not len(self.data) and not self.worker.EOF.is_set():

            self.worker.data_added.clear()

            self.worker.data_added.wait(0.2)

        if len(self.data):

            self.worker.keep_reading.set()

            return _bytes(self.data.popleft())

        elif self.worker.EOF.is_set():

            raise StopIteration

    def throw(self, type, value=None, traceback=None):

        if not self.worker.EOF.is_set():

            raise type(value)

    def start(self):

        self.worker.start()

    def stop(self):

        self.worker.stop()

    def close(self):

        try:

            self.worker.stop()

            self.throw(GeneratorExit)

        except (GeneratorExit, StopIteration):

            pass

    def __del__(self):

        self.close()

    ####################

    # Threaded reader's infrastructure.

    ####################

    @property

    def input(self):

        return self.worker.w