import os

import sys

import time

import errno

from warnings import warn

from multiprocessing.util import Finalize

from rhodecode import __platform__, PLATFORM_WIN

if __platform__ in PLATFORM_WIN:

    import ctypes

        """kill function for Win32"""

        kernel32 = ctypes.windll.kernel32

        handle = kernel32.OpenProcess(1, 0, pid)

        return (0 != kernel32.TerminateProcess(handle, 0))

else:

    kill = os.kill

class LockHeld(Exception):

    pass

class DaemonLock(object):

    """daemon locking

    USAGE:

    try:

        l = DaemonLock(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):

        """