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('lock held finalizing and running lock.release()')

            lock.release()

    def lock(self):

        """

        locking function, if lock is present it

        will raise LockHeld exception

        """

        lockname = str(os.getpid())

        if self.debug:

            print('running lock')

        self.trylock()

        self.makelock(lockname, self.pidfile)

        return True

    def trylock(self):

        running_pid = False

        if self.debug:

            print('checking for already running process')

        try:

            with open(self.pidfile, 'r') as f:

                try:

                    running_pid = int(f.readline())

                except ValueError:

                    running_pid = -1

            if self.debug:

                print('lock file present running_pid: %s, '

                      'checking for execution' % (running_pid,))

            # Now we check the PID from lock file matches to the current

            # process PID

            if running_pid:

                try:

                    kill(running_pid, 0)

                except OSError as exc:

                    if exc.errno in (errno.ESRCH, errno.EPERM):

                        print ("Lock File is there but"

                               " the program is not running")

                        print("Removing lock file for the: %s" % running_pid)

                        self.release()

                    else:

                        raise

                else:

                    print("You already have an instance of the program running")

                    print("It is running as process %s" % running_pid)

                    raise LockHeld()

        except IOError as e:

            if e.errno != 2:

                raise

    def release(self):

        """releases the pid by removing the pidfile

        """

        if self.debug:

            print('trying to release the pidlock')

        if self.callbackfn:

            #execute callback function on release

            if self.debug:

                print('executing callback function %s' % self.callbackfn)

            self.callbackfn()

        try:

            if self.debug:

                print('removing pidfile %s' % self.pidfile)

            os.remove(self.pidfile)

            self.held = False

        except OSError as e:

            if self.debug:

                print('removing pidfile failed %s' % e)

            pass

    def makelock(self, lockname, pidfile):

        """

        this function will make an actual lock

        :param lockname: actual pid of file

        :param pidfile: the file to write the pid in

        """

        if self.debug:

            print('creating a file %s and pid: %s' % (pidfile, lockname))

        dir_, file_ = os.path.split(pidfile)

        if not os.path.isdir(dir_):

            os.makedirs(dir_)

            f.write(lockname)

        self.held = True

import datetime

import io

import os

import tarfile

import tempfile

import zipfile

import pytest

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.lib.vcs.nodes import FileNode

from kallithea.tests.vcs.base import _BackendTestMixin

from kallithea.tests.vcs.conf import TESTS_TMP_PATH

class ArchivesTestCaseMixin(_BackendTestMixin):

    @classmethod

    def _get_commits(cls):

        start_date = datetime.datetime(2010, 1, 1, 20)

        for x in xrange(5):

            yield {

                'message': 'Commit %d' % x,

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': start_date + datetime.timedelta(hours=12 * x),

                'added': [

                    FileNode('%d/file_%d.txt' % (x, x),

                        content='Foobar %d' % x),

                ],

            }

    def test_archive_zip(self):

        path = tempfile.mkstemp(dir=TESTS_TMP_PATH, prefix='test_archive_zip-')[1]

        with open(path, 'wb') as f:

            self.tip.fill_archive(stream=f, kind='zip', prefix='repo')

        out = zipfile.ZipFile(path)

        for x in xrange(5):

            node_path = '%d/file_%d.txt' % (x, x)

            decompressed = out.read('repo/' + node_path)

            assert decompressed == self.tip.get_node(node_path).content

    def test_archive_tgz(self):

        path = tempfile.mkstemp(dir=TESTS_TMP_PATH, prefix='test_archive_tgz-')[1]

        with open(path, 'wb') as f:

            self.tip.fill_archive(stream=f, kind='tgz', prefix='repo')

        outdir = tempfile.mkdtemp(dir=TESTS_TMP_PATH, prefix='test_archive_tgz-', suffix='-outdir')

        outfile = tarfile.open(path, 'r|gz')

        outfile.extractall(outdir)

        for x in xrange(5):

            node_path = '%d/file_%d.txt' % (x, x)

    def test_archive_tbz2(self):

        path = tempfile.mkstemp(dir=TESTS_TMP_PATH, prefix='test_archive_tbz2-')[1]

        with open(path, 'w+b') as f:

            self.tip.fill_archive(stream=f, kind='tbz2', prefix='repo')

        outdir = tempfile.mkdtemp(dir=TESTS_TMP_PATH, prefix='test_archive_tbz2-', suffix='-outdir')

        outfile = tarfile.open(path, 'r|bz2')

        outfile.extractall(outdir)

        for x in xrange(5):

            node_path = '%d/file_%d.txt' % (x, x)

    def test_archive_default_stream(self):

        tmppath = tempfile.mkstemp(dir=TESTS_TMP_PATH, prefix='test_archive_default_stream-')[1]

        with open(tmppath, 'wb') as stream:

            self.tip.fill_archive(stream=stream)

        mystream = io.BytesIO()

        self.tip.fill_archive(stream=mystream)

        mystream.seek(0)

        with open(tmppath, 'rb') as f:

            file_content = f.read()

            stringio_content = mystream.read()

            # the gzip header contains a MTIME header

            # because is takes a little bit of time from one fill_archive call to the next

            # this part may differ so don't include that part in the comparison

            assert file_content[:4] == stringio_content[:4]

            assert file_content[8:] == stringio_content[8:]

    def test_archive_wrong_kind(self):

        with pytest.raises(VCSError):

            self.tip.fill_archive(kind='wrong kind')

    def test_archive_empty_prefix(self):

        with pytest.raises(VCSError):

            self.tip.fill_archive(prefix='')

    def test_archive_prefix_with_leading_slash(self):

        with pytest.raises(VCSError):

            self.tip.fill_archive(prefix='/any')

class TestGitArchive(ArchivesTestCaseMixin):

    backend_alias = 'git'

class TestHgArchive(ArchivesTestCaseMixin):

    backend_alias = 'hg'

#!/usr/bin/env python2

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

import os

import platform

import sys

import setuptools

# monkey patch setuptools to use distutils owner/group functionality

from setuptools.command import sdist

if sys.version_info < (2, 6) or sys.version_info >= (3,):

    raise Exception('Kallithea requires python 2.7')

here = os.path.abspath(os.path.dirname(__file__))

def _get_meta_var(name, data, callback_handler=None):

    import re

    matches = re.compile(r'(?:%s)\s*=\s*(.*)' % name).search(data)

    if matches:

        if not callable(callback_handler):

            callback_handler = lambda v: v

        return callback_handler(eval(matches.groups()[0]))

_metadata = _meta.read()

_meta.close()

callback = lambda V: ('.'.join(map(str, V[:3])) + '.'.join(V[3:]))

__version__ = _get_meta_var('VERSION', _metadata, callback)

__license__ = _get_meta_var('__license__', _metadata)

__author__ = _get_meta_var('__author__', _metadata)

__url__ = _get_meta_var('__url__', _metadata)

# defines current platform

__platform__ = platform.system()

is_windows = __platform__ in ['Windows']

requirements = [

    "alembic >= 0.8.0, < 1.1",

    "gearbox >= 0.1.0, < 1",

    "waitress >= 0.8.8, < 1.4",

    "WebOb >= 1.7, < 1.9",

    "backlash >= 0.1.2, < 1",

    "TurboGears2 >= 2.3.10, < 2.5",

    "tgext.routes >= 0.2.0, < 1",

    "Beaker >= 1.7.0, < 2",

    "WebHelpers2 >= 2.0, < 2.1",

    "FormEncode >= 1.3.0, < 1.4",

    "SQLAlchemy >= 1.1, < 1.4",

    "Mako >= 0.9.0, < 1.1",

    "Pygments >= 2.2.0, < 2.5",

    "Whoosh >= 2.5.0, < 2.8",

    "celery >= 3.1, < 4.0", # TODO: celery 4 doesn't work

    "Babel >= 1.3, < 2.8",

    "python-dateutil >= 1.5.0, < 2.9",

    "Markdown >= 2.2.1, < 3.2",

    "docutils >= 0.11, < 0.15",

    "URLObject >= 2.3.4, < 2.5",

    "Routes >= 2.0, < 2.5",

    "dulwich >= 0.14.1, < 0.20",

    "mercurial >= 5.1, < 5.3",

    "decorator >= 3.3.2, < 4.5",

    "Paste >= 2.0.3, < 3.1",

    "bleach >= 3.0, < 3.2",

    "Click >= 7.0, < 8",

    "ipaddr >= 2.1.10, < 2.3",

    "paginate >= 0.5, < 0.6",

    "paginate_sqlalchemy >= 0.3.0, < 0.4",

]

if not is_windows:

    requirements.append("bcrypt >= 3.1.0, < 3.2")

dependency_links = [

]

classifiers = [

    'Development Status :: 4 - Beta',

    'Environment :: Web Environment',

    'Framework :: Pylons',

    'Intended Audience :: Developers',

    'License :: OSI Approved :: GNU General Public License (GPL)',

    'Operating System :: OS Independent',

    'Programming Language :: Python',

    'Programming Language :: Python :: 2.7',

    'Topic :: Software Development :: Version Control',

]

# additional files from project that goes somewhere in the filesystem

# relative to sys.prefix

data_files = []

description = ('Kallithea is a fast and powerful management tool '

               'for Mercurial and Git with a built in push/pull server, '

               'full text search and code-review.')

keywords = ' '.join([

    'kallithea', 'mercurial', 'git', 'code review',

    'repo groups', 'ldap', 'repository management', 'hgweb replacement',

    'hgwebdir', 'gitweb replacement', 'serving hgweb',

])

# long description

README_FILE = 'README.rst'

try:

    long_description = open(README_FILE).read()

except IOError as err:

    sys.stderr.write(

        "[WARNING] Cannot find file specified as long_description (%s)\n"

        % README_FILE

    )

    long_description = description

sdist_org = sdist.sdist

class sdist_new(sdist_org):

    def initialize_options(self):

        sdist_org.initialize_options(self)

        self.owner = self.group = 'root'