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

"""

    rhodecode.lib.compat

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

    Python backward compatibility functions and common libs

    :created_on: Oct 7, 2011

    :author: marcink

    :copyright: (C) 2009-2010 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/>.

#==============================================================================

# json

#==============================================================================

try:

    import json

except ImportError:

    import simplejson as json

#==============================================================================

# izip_longest

#==============================================================================

try:

    from itertools import izip_longest

except ImportError:

    import itertools

    def izip_longest(*args, **kwds): # noqa

        fillvalue = kwds.get("fillvalue")

        def sentinel(counter=([fillvalue] * (len(args) - 1)).pop):

            yield counter() # yields the fillvalue, or raises IndexError

        fillers = itertools.repeat(fillvalue)

        iters = [itertools.chain(it, sentinel(), fillers)

                    for it in args]

        try:

            for tup in itertools.izip(*iters):

                yield tup

        except IndexError:

            pass

#==============================================================================

# OrderedDict

#==============================================================================

# Python Software Foundation License

# XXX: it feels like using the class with "is" and "is not" instead of "==" and

# "!=" should be faster.

class _Nil(object):

    def __repr__(self):

        return "nil"

    def __eq__(self, other):

        if (isinstance(other, _Nil)):

        """

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lt')

        while curr_key != _nil:

            pred_key, val, _ = dict_impl.__getitem__(self, curr_key)

            yield curr_key, val

            curr_key = pred_key

    def ritems(self):

        """List of the (key, value) in reversed order.

        """

        return list(self.riteritems())

    def firstkey(self):

        if self:

            return self._dict_impl().__getattribute__(self, 'lh')

        else:

            raise KeyError("'firstkey(): ordered dictionary is empty'")

    def lastkey(self):

        if self:

            return self._dict_impl().__getattribute__(self, 'lt')

        else:

            raise KeyError("'lastkey(): ordered dictionary is empty'")

    def as_dict(self):

        return self._dict_impl()(self.items())

    def _repr(self):

        """_repr(): low level repr of the whole data contained in the odict.

        Useful for debugging.

        """

        dict_impl = self._dict_impl()

        form = "odict low level repr lh,lt,data: %r, %r, %s"

        return form % (dict_impl.__getattribute__(self, 'lh'),

                       dict_impl.__getattribute__(self, 'lt'),

                       dict_impl.__repr__(self))

class OrderedDict(_odict, dict):

    def _dict_impl(self):

        return dict

#==============================================================================

# OrderedSet

#==============================================================================

from sqlalchemy.util import OrderedSet

import os

import sys

import time

import errno

from warnings import warn

from multiprocessing.util import Finalize

class LockHeld(Exception):

    pass

class DaemonLock(object):

    """daemon locking

    USAGE:

    try:

        l = DaemonLock(file_='/path/tolockfile',desc='test lock')

        main()

        l.release()

    except LockHeld:

        sys.exit(1)

    """

    def __init__(self, file_=None, callbackfn=None,

                 desc='daemon lock', debug=False):

        self.pidfile = file_ if file_ else os.path.join(

                                                    os.path.dirname(__file__),

                                                    'running.lock')

        self.callbackfn = callbackfn

        self.desc = desc

        self.debug = debug

        self.held = False

        #run the lock automatically !

        self.lock()

        self._finalize = Finalize(self, DaemonLock._on_finalize,

                                    args=(self, debug), exitpriority=10)

    @staticmethod

    def _on_finalize(lock, debug):

        if lock.held:

            if debug:

                print 'leck held finilazing and running lock.release()'

            lock.release()

    def lock(self):

        """

        locking function, if lock is present it

        will raise LockHeld exception

        """

        lockname = '%s' % (os.getpid())

        if self.debug:

            print 'running lock'

        self.trylock()

        self.makelock(lockname, self.pidfile)