def start(self):
     self.end = time.time() + self.ttl
     context = daemon.DaemonContext(working_directory=os.getcwd(),
                                    umask=0o002,
                                    pidfile=PIDLockFile(self.pid_file))
     with context:
         self.run_http_server()
Esempio n. 2
0
def make_pidlockfile(path):
    """ Make a LockFile instance with the given filesystem path. """
    if not isinstance(path, basestring):
        raise ValueError("Not a filesystem path: %(path)r" % vars())
    if not os.path.isabs(path):
        raise ValueError("Not an absolute path: %(path)r" % vars())
    return PIDLockFile(path)
    def execute(self, *args, **options):
        if options["daemon"]:
            pid_file = options["pid-file"]
            if os.path.exists(pid_file + ".lock") or os.path.exists(pid_file):
                try:
                    pid = int(open(pid_file).read())
                    os.kill(pid, 0)
                except (ValueError, OSError, IOError):
                    # Not running, delete stale PID file
                    sys.stderr.write("Removing stale PID file\n")
                    import errno

                    try:
                        os.remove(pid_file)
                    except OSError as e:
                        if e.errno != errno.ENOENT:
                            raise e
                    try:
                        os.remove(pid_file + ".lock")
                    except OSError as e:
                        if e.errno != errno.ENOENT:
                            raise e
                else:
                    # Running, we should refuse to run
                    raise RuntimeError("Daemon is already running (PID %s)" %
                                       pid)

            with DaemonContext(pidfile=PIDLockFile(pid_file)):
                self._execute_inner(*args, **options)
        else:
            self._execute_inner(*args, **options)
Esempio n. 4
0
    def __init__(self, pidfile):
        """
        Create exclusive app lock
        """
        if pidfile.startswith("/"):
            piddir = os.path.dirname(pidfile)
            pidpath = pidfile  # use explicit path
        else:
            piddir = "/var/lib/zabbixsrv/"
            pidpath = "{dir}{file}".format(dir=piddir, file=pidfile)

        # Check lockdir exists
        if not os.path.exists(piddir):
            raise PidlockConflict("directory {0} is missing or insufficient permission".format(
                piddir
            )
            )

        # Check for orphaned pids
        if os.path.isfile(pidpath):
            with open(pidpath) as f:
                conflictpid = f.read()
            raise PidlockConflict("process {0} has lock in {1}".format(
                conflictpid.strip(), pidpath
            )
            )

        # Acquire lock
        self.pidfile = PIDLockFile(pidpath)
        self.locked = False
        if not self.pidfile.is_locked():
            self.pidfile.acquire()
            self.locked = True
Esempio n. 5
0
def pidfile(tmpdir):
    try:
        from daemon.pidlockfile import PIDLockFile
    except ImportError:
        from daemon.pidfile import PIDLockFile
    # Create a tmpdir for the pidfile and overwrite
    # the current util.PID_FILE constant
    util.PID = PIDLockFile(tmpdir.join('plight.pid').strpath)
    return util.PID
Esempio n. 6
0
class Command(BaseCommand):
    requires_model_validation = False
    help = """Run a single ChromaService in a new plugin."""
    option_list = BaseCommand.option_list + (
        make_option(
            '--gevent', action='store_true', dest='gevent', default=False),
        make_option('--lightweight-rpc',
                    action='store_true',
                    dest='lightweight_rpc',
                    default=False),
        make_option(
            '--verbose', action='store_true', dest='verbose', default=False),
        make_option(
            '--console', action='store_true', dest='console', default=False),
        make_option('--name', dest='name', default='chroma_service'),
        make_option(
            '--daemon', dest='daemon', action='store_true', default=None),
        make_option('--trace', dest='trace', action='store_true',
                    default=None),
        make_option('--pid-file', dest='pid-file', default=None),
    )

    def execute(self, *args, **options):
        if options['daemon']:
            pid_file = options['pid-file']
            if os.path.exists(pid_file + ".lock") or os.path.exists(pid_file):
                try:
                    pid = int(open(pid_file).read())
                    os.kill(pid, 0)
                except (ValueError, OSError, IOError):
                    # Not running, delete stale PID file
                    sys.stderr.write("Removing stale PID file\n")
                    import errno
                    try:
                        os.remove(pid_file)
                    except OSError, e:
                        if e.errno != errno.ENOENT:
                            raise e
                    try:
                        os.remove(pid_file + ".lock")
                    except OSError, e:
                        if e.errno != errno.ENOENT:
                            raise e
                else:
                    # Running, we should refuse to run
                    raise RuntimeError("Daemon is already running (PID %s)" %
                                       pid)

            with DaemonContext(pidfile=PIDLockFile(pid_file)):
                self._execute_inner(*args, **options)
Esempio n. 7
0
def acquire_pidlock(pidfile):
    """Get the :class:`daemon.pidlockfile.PIDLockFile` handler for
    ``pidfile``.

    If the ``pidfile`` already exists, but the process is not running the
    ``pidfile`` will be removed, a ``"stale pidfile"`` message is emitted
    and execution continues as normally. However, if the process is still
    running the program will exit complaning that the program is already
    running in the background somewhere.

    """
    from daemon.pidlockfile import PIDLockFile
    import errno
    pidlock = PIDLockFile(pidfile)
    if not pidlock.is_locked():
        return pidlock
    pid = pidlock.read_pid()
    try:
        os.kill(pid, 0)
    except os.error, exc:
        if exc.errno == errno.ESRCH:
            sys.stderr.write("Stale pidfile exists. Removing it.\n")
            os.unlink(pidfile)
            return PIDLockFile(pidfile)
def main():
    """Daemonize and handle unexpected exceptions"""
    parser = argparse.ArgumentParser(
        description="Intel® Manager for Lustre* software Agent")
    parser.add_argument("--foreground", action="store_true")
    parser.add_argument("--publish-zconf", action="store_true")
    parser.add_argument("--pid-file", default="/var/run/chroma-agent.pid")
    args = parser.parse_args()

    # FIXME: at startup, if there is a PID file hanging around, find any
    # processes which are children of that old PID, and kill them: prevent
    # orphaned processes from an old agent run hanging around where they
    # could cause trouble (think of a 2 hour mkfs)

    if not args.foreground:
        if os.path.exists(args.pid_file):
            pid = None
            try:
                pid = int(open(args.pid_file).read())
                os.kill(pid, 0)
            except (ValueError, OSError, IOError):
                # Not running, delete stale PID file
                sys.stderr.write("Removing stale PID file\n")
                try:
                    os.remove(args.pid_file)
                    os.remove(args.pid_file + ".lock")
                except OSError, e:
                    import errno
                    if e.errno != errno.ENOENT:
                        raise e

                if pid is not None:
                    kill_orphans_of(pid)
            else:
                # Running, we should refuse to run
                raise RuntimeError("Daemon is already running (PID %s)" % pid)
        else:
            if os.path.exists(args.pid_file + ".lock"):
                sys.stderr.write("Removing stale lock file\n")
                os.remove(args.pid_file + ".lock")

        signal.signal(signal.SIGHUP, signal.SIG_IGN)
        context = DaemonContext(pidfile=PIDLockFile(args.pid_file))
        context.open()

        daemon_log_setup()
        console_log_setup()
        daemon_log.info("Starting in the background")
Esempio n. 9
0
class AcquireRunLock(object):
    """
    Establishes a lockfile to avoid duplicate runs for same config.
    """

    def __init__(self, pidfile):
        """
        Create exclusive app lock
        """
        if pidfile.startswith("/"):
            piddir = os.path.dirname(pidfile)
            pidpath = pidfile  # use explicit path
        else:
            piddir = "/var/lib/zabbixsrv/"
            pidpath = "{dir}{file}".format(dir=piddir, file=pidfile)

        # Check lockdir exists
        if not os.path.exists(piddir):
            raise PidlockConflict("directory {0} is missing or insufficient permission".format(
                piddir
            )
            )

        # Check for orphaned pids
        if os.path.isfile(pidpath):
            with open(pidpath) as f:
                conflictpid = f.read()
            raise PidlockConflict("process {0} has lock in {1}".format(
                conflictpid.strip(), pidpath
            )
            )

        # Acquire lock
        self.pidfile = PIDLockFile(pidpath)
        self.locked = False
        if not self.pidfile.is_locked():
            self.pidfile.acquire()
            self.locked = True

    def release(self):
        """
        Releases exclusive lock
        """
        if self.pidfile.is_locked():
            self.locked = False
            return self.pidfile.release()

    def islocked(self):
        """
        Return true if exclusively locked
        """
        return self.pidfile.is_locked()
Esempio n. 10
0
def start(args):
    if not os.path.exists(args.out_dir):
        os.makedirs(args.out_dir)
    if os.path.exists(get_pid_path(args)):
        if args.ignore_stale_pid:
            os.remove(get_pid_path(args))
        else:
            print >> sys.stderr, '{0}: File exists. Already running?'.format(
                get_pid_path(args))
            sys.exit(1)

    pid_file = PIDLockFile(get_pid_path(args))
    log_file = open(get_log_path(args), 'a')

    if not args.foreground:
        with daemon.DaemonContext(pidfile=pid_file,
                                  stdout=log_file,
                                  stderr=log_file):
            do_dsm(args.port)
    else:
        do_dsm(args.port)
Esempio n. 11
0
 def __init__(self, lockfile, timeout, **kwargs):
     PIDLockFile.__init__(self, lockfile, **kwargs)
     self.timeout = timeout
Esempio n. 12
0
 def __init__(self, lockfile, timeout, **kwargs):
   PIDLockFile.__init__(self, lockfile, **kwargs)
   self.timeout = timeout
Esempio n. 13
0
 def start_service(self, host, port, logfile, pidfile, server):
     log = open(logfile, 'a')
     pid = PIDLockFile(pidfile)
     with daemon.DaemonContext(stderr=log, pidfile=pid):
         run(host=host, port=port, server=server)
Esempio n. 14
0
        else:
            logger.error("no vm found with mac %s", mac)

        return True

    def run(self):
        try:
            self.serve_forever()
        except Exception, e:
            logger.info(e)


if __name__ == '__main__':

    logger.setLevel(logging.INFO)
    formatter = logging.Formatter(
        "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    handler = logging.FileHandler("/var/lib/jenkins/wolproxy.log")
    handler.setFormatter(formatter)
    logger.addHandler(handler)

    listen = ('0.0.0.0', 8000)
    logger.info("wolproxy server listening on %s:%s", listen[0], listen[1])

    with daemon.DaemonContext(
            detach_process=True,
            files_preserve=[handler.stream],
            pidfile=PIDLockFile('/var/lib/jenkins/wolproxy.pid')):
        server = WolproxyServer(listen)
        server.run()
Esempio n. 15
0
            print "west toggle"
            west.toggle()
            print "waiting..."
            #チャタリングと長押し対策
            time.sleep(0.5)
            continue
        if int(open("/sys/class/gpio/gpio110/value", "r").read().split("\n")[0]) == 0:
            #右ボタンが押された時の処理
            print "heater toggle"
            heater.toggle()
            print "waiting..."
            #チャタリングと長押し対策
            time.sleep(0.5)
            continue
        print "nothing loop"
        time.sleep(0.2)

#スクリプトとして動作された場合、ここから実行される
if __name__ == '__main__':
    #daemonとして動作する場合の処理
    #pidファイルは/etc/init.d/wemo内の指定と同じファイルにする
    with daemon.DaemonContext(pidfile=PIDLockFile('/var/run/wemo.pid')):
        #daemonとして起動した際に、networking側の処理が追いつかずにネットワークが確立していない場合がある。
        #その場合Environment()などでexceptionを吐いて終了してしまう。
        #対応として、exceptで全部のexceptionを受け止めてもう一度wemo_main()をやり直すようにした。
        while True:
            try:
                wemo_main()
            except:
                time.sleep(3)
Esempio n. 16
0
import signal
try:
    import BaseHTTPServer
except ImportError:
    import http.server as BaseHTTPServer
from daemon import DaemonContext
try:
    from daemon.pidlockfile import PIDLockFile
except ImportError:
    from daemon.pidfile import PIDLockFile
import logging
from logging.handlers import RotatingFileHandler
import plight
import plight.config as plconfig

PID = PIDLockFile(plconfig.PID_FILE)


def start_server(config):
    os.umask(0o022)
    weblogger = logging.getLogger('plight_httpd')
    weblogger.setLevel(config['web_log_level'])
    if weblogger.handlers == []:
        weblogging_handler = RotatingFileHandler(config['web_log_file'],
                                                 mode='a',
                                                 maxBytes=config[
                                                     'web_log_filesize'],
                                                 backupCount=config[
                                                     'web_log_rotation_count'])
        weblogger.addHandler(weblogging_handler)