" 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 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")