added exclusive lock capabilities after seeing it is possible for many processes to overlap eachother

Author: Tim Vaillancourt

MongoBackup/Backup.py

@@ -8,6 +8,7 @@
 from signal import signal, SIGINT, SIGTERM
 from time import time
 
+from Common import Lock
 from DB import DB
 from ShardingHandler import ShardingHandler
 from Mongodumper import Mongodumper
@@ -62,6 +63,7 @@ def __init__(self, options):
         self.backup_duration = None
         self.end_time = None
 
+        self._lock = None
         self.log_level = logging.INFO
         self.start_time = time()
         self.oplog_threads = []
@@ -72,6 +74,10 @@ def __init__(self, options):
         for option in vars(options):
             setattr(self, option, getattr(options, option))
 
+        # Set default lock file:
+	if not self.lock_file:
+            self.lock_file = '/tmp/%s.lock' % self.program_name
+
         # Setup logging
         if self.verbose:
             self.log_level = logging.DEBUG
@@ -138,13 +144,21 @@ def cleanup_and_exit(self, code, frame):
                 ))
 
             logging.info("Cleanup complete. Exiting")
+
+            self._lock.release()
             sys.exit(1)
 
     def exception(self, error_message):
         logging.exception(error_message)
         return self.cleanup_and_exit(None, None)
 
     def run(self):
+        try:
+            self._lock = Lock(self.lock_file)
+        except Exception, e:
+            logging.fatal("Could not acquire lock! Is another %s process running? Exiting" % self.program_name)
+            sys.exit(1)
+
         if not self.is_mongos:
             logging.info("Starting backup of %s:%s in replset mode" % (self.host, self.port))
 
@@ -284,4 +298,6 @@ def run(self):
             except Exception, e:
                 self.exception("Problem running NSCA notifier! Error: %s" % e)
 
+        self._lock.release()
+
         logging.info("Backup completed in %s sec" % self.backup_duration)

MongoBackup/Common/Lock.py

@@ -0,0 +1,28 @@
+import os
+import logging
+
+from fcntl import flock, LOCK_EX, LOCK_NB
+
+class Lock:
+    def __init__(self, lock_file):
+        self.lock_file = lock_file
+    
+        self._lock = None
+        self.acquire()
+    
+    def acquire(self):
+        try:
+            self._lock = open(self.lock_file, "w")
+            flock(self._lock, LOCK_EX | LOCK_NB)
+            logging.debug("Acquired exclusive lock on file: %s" % self.lock_file)
+            return self._lock
+        except Exception, e:
+            logging.debug("Error acquiring lock on file: %s" % self.lock_file)
+            if self._lock:
+                self._lock.close()
+            raise Exception, "Could not acquire lock!", None
+    
+    def release(self):
+        logging.debug("Releasing exclusive lock on file: %s" % self.lock_file)
+        self._lock.close()
+        return os.remove(self.lock_file)

MongoBackup/Common/__init__.py

@@ -1 +1,2 @@
 from LocalCommand import LocalCommand
+from Lock import Lock

MongoBackup/__init__.py

@@ -81,6 +81,7 @@ def run():
     parser.add_option("--no-archive", dest="no_archiver", help="Disable archiving of backups directories post-resolving", action="store_true", default=False)
     parser.add_option("--no-archive-gzip", dest="no_archiver_gzip", help="Disable gzip compression of archive files", action="store_true", default=False)
     parser.add_option("--lazy", dest="no_oplog_tailer", help="Disable tailing/resolving of clusterwide oplogs. This makes a shard-consistent, not cluster-consistent backup", action="store_true", default=False)
+    parser.add_option("--lock-file", dest="lock_file", help="Location of lock file (default: /tmp/%s.lock)" % os.path.basename(sys.argv[0]), default="/tmp/%s.lock" % os.path.basename(sys.argv[0]))
     parser.set_defaults()
 
     options = handle_options(parser)