summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorCaleb Tennis <caleb@gentoo.org>2008-02-05 18:22:38 +0000
committerCaleb Tennis <caleb@gentoo.org>2008-02-05 18:22:38 +0000
commitcc18370fe4422dd4f5f6cc050d17b2c31d0de4ea (patch)
treebd1ba3730a8ca0295a06a6ca1d012874cf91365e /dev-util/lockrun/files
parentStable for HPPA (bug #208929). Fixed an unquoted variable. (diff)
downloadgentoo-2-cc18370fe4422dd4f5f6cc050d17b2c31d0de4ea.tar.gz
gentoo-2-cc18370fe4422dd4f5f6cc050d17b2c31d0de4ea.tar.bz2
gentoo-2-cc18370fe4422dd4f5f6cc050d17b2c31d0de4ea.zip
Initial import
(Portage version: 2.1.4.1)
Diffstat (limited to 'dev-util/lockrun/files')
-rw-r--r--dev-util/lockrun/files/lockrun.c275
1 files changed, 275 insertions, 0 deletions
diff --git a/dev-util/lockrun/files/lockrun.c b/dev-util/lockrun/files/lockrun.c
new file mode 100644
index 000000000000..bccc0db7bcb7
--- /dev/null
+++ b/dev-util/lockrun/files/lockrun.c
@@ -0,0 +1,275 @@
+/*
+ * $Id: lockrun.c,v 1.1 2008/02/05 18:22:38 caleb Exp $
+ *
+ * written by : Stephen J. Friedl
+ * Software Consultant
+ * steve@unixwiz.net
+ * http://www.unixwiz.net/tools/
+ *
+ * ===================================================================
+ * ======== This software is in the public domain, and can be ========
+ * ======== used by anybody for any purpose ========
+ * ===================================================================
+ *
+ * Lockrun: This program is used to launch a program out with a lockout
+ * so that only one can run at a time. It's mainly intended for use out
+ * of cron so that our five-minute running jobs which run long don't get
+ * walked on. We find this a *lot* with Cacti jobs which just get hung
+ * up: it's better to miss a polling period than to stack them up and
+ * slow each other down.
+ *
+ * So we use a file which is used for locking: this program attempts to
+ * lock the file, and if the lock exists, we have to either exit with
+ * an error, or wait for it to release.
+ *
+ * lockrun --lockfile=FILE -- my command here
+ *
+ * COMMAND LINE
+ * ------------
+ *
+ * --lockfile=F
+ *
+ * Specify the name of a file which is used for locking. The file is
+ * created if necessary (with mode 0666), and no I/O of any kind is
+ * done. The file is never removed.
+ *
+ * --maxtime=N
+ *
+ * The script being controlled should run for no more than <N> seconds,
+ * and if it's beyond that time, we should report it to the standard
+ * error (which probably gets routed to the user via cron's email).
+ *
+ * --wait
+ *
+ * When a lock is hit, we normally exit with error, but --wait causes
+ * it to loop until the lock is released.
+ *
+ * --verbose
+ *
+ * Show a bit more runtime debugging.
+ *
+ * --
+ *
+ * Mark the end of the options: the command to run follows.
+ *
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/file.h>
+
+#ifndef __GNUC__
+# define __attribute__(x) /* nothing */
+#endif
+
+
+#define STRMATCH(a,b) (strcmp((a),(b)) == 0)
+
+#define UNUSED_PARAMETER(v) ((void)(v))
+
+#define TRUE 1
+#define FALSE 0
+
+static const char *lockfile = 0;
+static int wait_for_lock = FALSE;
+static mode_t openmode = 0666;
+static int sleeptime = 10; /* seconds */
+static int Verbose = FALSE;
+static int Maxtime = 0;
+
+static char *getarg(char *opt, char ***pargv);
+
+static void die(const char *format, ...)
+ __attribute__((noreturn))
+ __attribute__((format(printf, 1, 2)));
+
+int main(int argc, char **argv)
+{
+ char *Argv0 = *argv;
+ int rc;
+ int lfd;
+ pid_t childpid;
+ time_t starttime;
+
+ UNUSED_PARAMETER(argc);
+
+ time(&starttime);
+
+ for ( argv++ ; *argv ; argv++ )
+ {
+ char *arg = *argv;
+ char *opt = strchr(arg, '=');
+
+ /* the -- token marks the end of the list */
+
+ if ( strcmp(*argv, "--") == 0 )
+ {
+ argv++;
+ break;
+ }
+
+ if (opt) *opt++ = '\0'; /* pick off the =VALUE part */
+
+ if ( STRMATCH(arg, "-L") || STRMATCH(arg, "--lockfile"))
+ {
+ lockfile = getarg(opt, &argv);
+ }
+
+ else if ( STRMATCH(arg, "-W") || STRMATCH(arg, "--wait"))
+ {
+ wait_for_lock = TRUE;
+ }
+
+ else if ( STRMATCH(arg, "-S") || STRMATCH(arg, "--sleep"))
+ {
+ sleeptime = atoi(getarg(opt, &argv));
+ }
+
+ else if ( STRMATCH(arg, "-T") || STRMATCH(arg, "--maxtime"))
+ {
+ Maxtime = atoi(getarg(opt, &argv));
+ }
+
+ else if ( STRMATCH(arg, "-V") || STRMATCH(arg, "--verbose"))
+ {
+ Verbose++;
+ }
+
+ else
+ {
+ die("ERROR: \"%s\" is an invalid cmdline param", arg);
+ }
+ }
+
+ /*----------------------------------------------------------------
+ * SANITY CHECKING
+ *
+ * Make sure that we have all the parameters we require
+ */
+ if (*argv == 0)
+ die("ERROR: missing command to %s (must follow \"--\" marker) ", Argv0);
+
+ if (lockfile == 0)
+ die("ERROR: missing --lockfile=F parameter");
+
+ /*----------------------------------------------------------------
+ * Open or create the lockfile, then try to acquire the lock. If
+ * the lock is acquired immediately (==0), then we're done, but
+ * if the lock is not available, we have to wait for it.
+ *
+ * We can either loop trying for the lock (for --wait), or exit
+ * with error.
+ */
+
+ if ( (lfd = open(lockfile, O_RDWR|O_CREAT, openmode)) < 0)
+ die("ERROR: cannot open(%s) [err=%s]", lockfile, strerror(errno));
+
+ while ( flock(lfd, LOCK_EX | LOCK_NB) != 0 )
+ {
+ if ( ! wait_for_lock )
+ {
+ die("ERROR: cannot launch %s - run is locked", argv[0]);
+ }
+
+ /* waiting */
+ if ( Verbose ) printf("(locked: sleeping %d secs)\n", sleeptime);
+
+ sleep(sleeptime);
+ }
+
+ fflush(stdout);
+
+ /* run the child */
+
+
+ if ( (childpid = fork()) == 0 )
+ {
+ close(lfd); // don't need the lock file
+
+ execvp(argv[0], argv);
+ }
+ else if ( childpid > 0 )
+ {
+ time_t endtime;
+ pid_t pid;
+
+ if ( Verbose )
+ printf("Waiting for process %ld\n", (long) childpid);
+
+ pid = waitpid(childpid, &rc, 0);
+
+ time(&endtime);
+
+ endtime -= starttime;
+
+ if ( Verbose || (Maxtime > 0 && endtime > Maxtime) )
+ printf("pid %d exited with status %d (time=%ld sec)\n", pid, rc, endtime);
+ }
+ else
+ {
+ die("ERROR: cannot fork [%s]", strerror(errno));
+ }
+
+ exit(rc);
+}
+
+
+/*! \fn static char *getarg(char *opt, char ***pargv)
+ * \brief A function to parse calling parameters
+ *
+ * This is a helper for the main arg-processing loop: we work with
+ * options which are either of the form "-X=FOO" or "-X FOO"; we
+ * want an easy way to handle either one.
+ *
+ * The idea is that if the parameter has an = sign, we use the rest
+ * of that same argv[X] string, otherwise we have to get the *next*
+ * argv[X] string. But it's an error if an option-requiring param
+ * is at the end of the list with no argument to follow.
+ *
+ * The option name could be of the form "-C" or "--conf", but we
+ * grab it from the existing argv[] so we can report it well.
+ *
+ * \return character pointer to the argument
+ *
+ */
+static char *getarg(char *opt, char ***pargv)
+{
+ const char *const optname = **pargv;
+
+ /* option already set? */
+ if (opt) return opt;
+
+ /* advance to next argv[] and try that one */
+ if ((opt = *++(*pargv)) == 0)
+ die("ERROR: option %s requires a parameter", optname);
+
+ return opt;
+}
+
+/*
+ * die()
+ *
+ * Given a printf-style argument list, format it to the standard error,
+ * append a newline, then exit with error status.
+ */
+
+static void die(const char *format, ...)
+{
+va_list args;
+
+ va_start(args, format);
+ vfprintf(stderr, format, args);
+ putc('\n', stderr);
+ va_end(args);
+
+ exit(EXIT_FAILURE);
+}
+