yunlian | 8a3bdcb | 2013-02-19 20:42:48 +0000 | [diff] [blame] | 1 | #!/usr/bin/python |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 2 | # |
| 3 | # Copyright 2010 Google Inc. All Rights Reserved. |
| 4 | |
yunlian | 52a6c57 | 2013-02-19 20:42:07 +0000 | [diff] [blame] | 5 | """Script to lock/unlock machines.""" |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 6 | |
| 7 | __author__ = "asharif@google.com (Ahmad Sharif)" |
| 8 | |
| 9 | import datetime |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 10 | import fcntl |
asharif | da8e93b | 2013-02-15 22:49:27 +0000 | [diff] [blame] | 11 | import getpass |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 12 | import glob |
yunlian | 8a3bdcb | 2013-02-19 20:42:48 +0000 | [diff] [blame] | 13 | import json |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 14 | import optparse |
| 15 | import os |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 16 | import socket |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 17 | import sys |
| 18 | import time |
yunlian | 52a6c57 | 2013-02-19 20:42:07 +0000 | [diff] [blame] | 19 | |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 20 | from utils import logger |
| 21 | |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 22 | LOCK_SUFFIX = "_check_lock_liveness" |
| 23 | |
Caroline Tice | 6a00af9 | 2015-10-14 11:24:09 -0700 | [diff] [blame] | 24 | # The locks file directory REQUIRES that 'group' only has read/write |
| 25 | # privileges and 'world' has no privileges. So the mask must be |
| 26 | # '0027': 0777 - 0027 = 0750. |
| 27 | LOCK_MASK = 0027 |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 28 | |
| 29 | def FileCheckName(name): |
| 30 | return name + LOCK_SUFFIX |
| 31 | |
| 32 | |
| 33 | def OpenLiveCheck(file_name): |
Caroline Tice | 6a00af9 | 2015-10-14 11:24:09 -0700 | [diff] [blame] | 34 | with FileCreationMask(LOCK_MASK): |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 35 | fd = open(file_name, "a+w") |
| 36 | try: |
| 37 | fcntl.lockf(fd, fcntl.LOCK_EX | fcntl.LOCK_NB) |
| 38 | except IOError: |
| 39 | raise |
| 40 | return fd |
| 41 | |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 42 | |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 43 | class FileCreationMask(object): |
| 44 | def __init__(self, mask): |
| 45 | self._mask = mask |
| 46 | |
| 47 | def __enter__(self): |
| 48 | self._old_mask = os.umask(self._mask) |
| 49 | |
| 50 | def __exit__(self, type, value, traceback): |
| 51 | os.umask(self._old_mask) |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 52 | |
| 53 | |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 54 | class LockDescription(object): |
yunlian | 8a3bdcb | 2013-02-19 20:42:48 +0000 | [diff] [blame] | 55 | """The description of the lock.""" |
| 56 | |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 57 | def __init__(self, desc=None): |
yunlian | 8a3bdcb | 2013-02-19 20:42:48 +0000 | [diff] [blame] | 58 | try: |
| 59 | self.owner = desc["owner"] |
| 60 | self.exclusive = desc["exclusive"] |
| 61 | self.counter = desc["counter"] |
| 62 | self.time = desc["time"] |
| 63 | self.reason = desc["reason"] |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 64 | self.auto = desc["auto"] |
yunlian | 8a3bdcb | 2013-02-19 20:42:48 +0000 | [diff] [blame] | 65 | except (KeyError, TypeError): |
| 66 | self.owner = "" |
| 67 | self.exclusive = False |
| 68 | self.counter = 0 |
| 69 | self.time = 0 |
| 70 | self.reason = "" |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 71 | self.auto = False |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 72 | |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 73 | def IsLocked(self): |
| 74 | return self.counter or self.exclusive |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 75 | |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 76 | def __str__(self): |
| 77 | return " ".join(["Owner: %s" % self.owner, |
| 78 | "Exclusive: %s" % self.exclusive, |
| 79 | "Counter: %s" % self.counter, |
| 80 | "Time: %s" % self.time, |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 81 | "Reason: %s" % self.reason, |
| 82 | "Auto: %s" % self.auto]) |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 83 | |
| 84 | |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 85 | class FileLock(object): |
yunlian | 8a3bdcb | 2013-02-19 20:42:48 +0000 | [diff] [blame] | 86 | """File lock operation class.""" |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 87 | FILE_OPS = [] |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 88 | |
| 89 | def __init__(self, lock_filename): |
yunlian | 52a6c57 | 2013-02-19 20:42:07 +0000 | [diff] [blame] | 90 | self._filepath = lock_filename |
| 91 | lock_dir = os.path.dirname(lock_filename) |
| 92 | assert os.path.isdir(lock_dir), ( |
| 93 | "Locks dir: %s doesn't exist!" % lock_dir) |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 94 | self._file = None |
| 95 | |
| 96 | @classmethod |
| 97 | def AsString(cls, file_locks): |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 98 | stringify_fmt = "%-30s %-15s %-4s %-4s %-15s %-40s %-4s" |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 99 | header = stringify_fmt % ("machine", "owner", "excl", "ctr", |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 100 | "elapsed", "reason", "auto") |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 101 | lock_strings = [] |
| 102 | for file_lock in file_locks: |
| 103 | |
| 104 | elapsed_time = datetime.timedelta( |
| 105 | seconds=int(time.time() - file_lock._description.time)) |
| 106 | elapsed_time = "%s ago" % elapsed_time |
| 107 | lock_strings.append(stringify_fmt % |
| 108 | (os.path.basename(file_lock._filepath), |
| 109 | file_lock._description.owner, |
| 110 | file_lock._description.exclusive, |
| 111 | file_lock._description.counter, |
| 112 | elapsed_time, |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 113 | file_lock._description.reason, |
| 114 | file_lock._description.auto)) |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 115 | table = "\n".join(lock_strings) |
| 116 | return "\n".join([header, table]) |
| 117 | |
| 118 | @classmethod |
yunlian | 52a6c57 | 2013-02-19 20:42:07 +0000 | [diff] [blame] | 119 | def ListLock(cls, pattern, locks_dir): |
| 120 | if not locks_dir: |
| 121 | locks_dir = Machine.LOCKS_DIR |
| 122 | full_pattern = os.path.join(locks_dir, pattern) |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 123 | file_locks = [] |
| 124 | for lock_filename in glob.glob(full_pattern): |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 125 | if LOCK_SUFFIX in lock_filename: |
| 126 | continue |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 127 | file_lock = FileLock(lock_filename) |
| 128 | with file_lock as lock: |
| 129 | if lock.IsLocked(): |
| 130 | file_locks.append(file_lock) |
| 131 | logger.GetLogger().LogOutput("\n%s" % cls.AsString(file_locks)) |
| 132 | |
| 133 | def __enter__(self): |
Caroline Tice | 6a00af9 | 2015-10-14 11:24:09 -0700 | [diff] [blame] | 134 | with FileCreationMask(LOCK_MASK): |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 135 | try: |
| 136 | self._file = open(self._filepath, "a+") |
| 137 | self._file.seek(0, os.SEEK_SET) |
| 138 | |
| 139 | if fcntl.flock(self._file.fileno(), fcntl.LOCK_EX) == -1: |
| 140 | raise IOError("flock(%s, LOCK_EX) failed!" % self._filepath) |
| 141 | |
| 142 | try: |
yunlian | 8a3bdcb | 2013-02-19 20:42:48 +0000 | [diff] [blame] | 143 | desc = json.load(self._file) |
| 144 | except (EOFError, ValueError): |
| 145 | desc = None |
| 146 | self._description = LockDescription(desc) |
| 147 | |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 148 | if self._description.exclusive and self._description.auto: |
| 149 | locked_byself = False |
| 150 | for fd in self.FILE_OPS: |
| 151 | if fd.name == FileCheckName(self._filepath): |
| 152 | locked_byself = True |
| 153 | break |
| 154 | if not locked_byself: |
| 155 | try: |
| 156 | fp = OpenLiveCheck(FileCheckName(self._filepath)) |
| 157 | except IOError: |
| 158 | pass |
| 159 | else: |
| 160 | self._description = LockDescription() |
| 161 | fcntl.lockf(fp, fcntl.LOCK_UN) |
| 162 | fp.close() |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 163 | return self._description |
| 164 | # Check this differently? |
| 165 | except IOError as ex: |
| 166 | logger.GetLogger().LogError(ex) |
| 167 | return None |
| 168 | |
| 169 | def __exit__(self, type, value, traceback): |
| 170 | self._file.truncate(0) |
yunlian | 8a3bdcb | 2013-02-19 20:42:48 +0000 | [diff] [blame] | 171 | self._file.write(json.dumps(self._description.__dict__, skipkeys=True)) |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 172 | self._file.close() |
| 173 | |
| 174 | def __str__(self): |
| 175 | return self.AsString([self]) |
| 176 | |
| 177 | |
| 178 | class Lock(object): |
yunlian | 77dc571 | 2013-02-19 21:13:33 +0000 | [diff] [blame] | 179 | def __init__(self, lock_file, auto=True): |
yunlian | 52a6c57 | 2013-02-19 20:42:07 +0000 | [diff] [blame] | 180 | self._to_lock = os.path.basename(lock_file) |
| 181 | self._lock_file = lock_file |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 182 | self._logger = logger.GetLogger() |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 183 | self._auto = auto |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 184 | |
| 185 | def NonBlockingLock(self, exclusive, reason=""): |
yunlian | 52a6c57 | 2013-02-19 20:42:07 +0000 | [diff] [blame] | 186 | with FileLock(self._lock_file) as lock: |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 187 | if lock.exclusive: |
| 188 | self._logger.LogError( |
| 189 | "Exclusive lock already acquired by %s. Reason: %s" % |
| 190 | (lock.owner, lock.reason)) |
| 191 | return False |
| 192 | |
| 193 | if exclusive: |
| 194 | if lock.counter: |
| 195 | self._logger.LogError("Shared lock already acquired") |
| 196 | return False |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 197 | lock_file_check = FileCheckName(self._lock_file) |
| 198 | fd = OpenLiveCheck(lock_file_check) |
| 199 | FileLock.FILE_OPS.append(fd) |
| 200 | |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 201 | lock.exclusive = True |
| 202 | lock.reason = reason |
asharif | da8e93b | 2013-02-15 22:49:27 +0000 | [diff] [blame] | 203 | lock.owner = getpass.getuser() |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 204 | lock.time = time.time() |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 205 | lock.auto = self._auto |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 206 | else: |
| 207 | lock.counter += 1 |
| 208 | self._logger.LogOutput("Successfully locked: %s" % self._to_lock) |
| 209 | return True |
| 210 | |
| 211 | def Unlock(self, exclusive, force=False): |
yunlian | 52a6c57 | 2013-02-19 20:42:07 +0000 | [diff] [blame] | 212 | with FileLock(self._lock_file) as lock: |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 213 | if not lock.IsLocked(): |
Caroline Tice | 570b2ce | 2013-08-07 12:46:30 -0700 | [diff] [blame] | 214 | self._logger.LogWarning("Can't unlock unlocked machine!") |
| 215 | return True |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 216 | |
| 217 | if lock.exclusive != exclusive: |
| 218 | self._logger.LogError("shared locks must be unlocked with --shared") |
| 219 | return False |
| 220 | |
| 221 | if lock.exclusive: |
asharif | da8e93b | 2013-02-15 22:49:27 +0000 | [diff] [blame] | 222 | if lock.owner != getpass.getuser() and not force: |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 223 | self._logger.LogError("%s can't unlock lock owned by: %s" % |
asharif | da8e93b | 2013-02-15 22:49:27 +0000 | [diff] [blame] | 224 | (getpass.getuser(), lock.owner)) |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 225 | return False |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 226 | if lock.auto != self._auto: |
| 227 | self._logger.LogError("Can't unlock lock with different -a" |
| 228 | " parameter.") |
| 229 | return False |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 230 | lock.exclusive = False |
| 231 | lock.reason = "" |
| 232 | lock.owner = "" |
yunlian | b0eaee8 | 2013-02-19 21:13:28 +0000 | [diff] [blame] | 233 | |
| 234 | if self._auto: |
| 235 | del_list = [i for i in FileLock.FILE_OPS |
| 236 | if i.name == FileCheckName(self._lock_file)] |
| 237 | for i in del_list: |
| 238 | FileLock.FILE_OPS.remove(i) |
| 239 | for f in del_list: |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 240 | fcntl.lockf(f, fcntl.LOCK_UN) |
| 241 | f.close() |
yunlian | b0eaee8 | 2013-02-19 21:13:28 +0000 | [diff] [blame] | 242 | del del_list |
| 243 | os.remove(FileCheckName(self._lock_file)) |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 244 | |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 245 | else: |
| 246 | lock.counter -= 1 |
| 247 | return True |
| 248 | |
| 249 | |
| 250 | class Machine(object): |
Caroline Tice | 6a00af9 | 2015-10-14 11:24:09 -0700 | [diff] [blame] | 251 | LOCKS_DIR = "/google/data/rw/users/mo/mobiletc-prebuild/locks" |
yunlian | 8a3bdcb | 2013-02-19 20:42:48 +0000 | [diff] [blame] | 252 | |
yunlian | 77dc571 | 2013-02-19 21:13:33 +0000 | [diff] [blame] | 253 | def __init__(self, name, locks_dir=LOCKS_DIR, auto=True): |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 254 | self._name = name |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 255 | self._auto = auto |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 256 | try: |
| 257 | self._full_name = socket.gethostbyaddr(name)[0] |
| 258 | except socket.error: |
| 259 | self._full_name = self._name |
yunlian | 52a6c57 | 2013-02-19 20:42:07 +0000 | [diff] [blame] | 260 | self._full_name = os.path.join(locks_dir, self._full_name) |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 261 | |
| 262 | def Lock(self, exclusive=False, reason=""): |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 263 | lock = Lock(self._full_name, self._auto) |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 264 | return lock.NonBlockingLock(exclusive, reason) |
| 265 | |
shenhan | e0a6d8a | 2013-02-19 20:42:29 +0000 | [diff] [blame] | 266 | def TryLock(self, timeout=300, exclusive=False, reason=""): |
| 267 | locked = False |
yunlian | 8a3bdcb | 2013-02-19 20:42:48 +0000 | [diff] [blame] | 268 | sleep = timeout / 10 |
shenhan | e0a6d8a | 2013-02-19 20:42:29 +0000 | [diff] [blame] | 269 | while True: |
| 270 | locked = self.Lock(exclusive, reason) |
| 271 | if locked or not timeout >= 0: |
| 272 | break |
| 273 | print "Lock not acquired for {0}, wait {1} seconds ...".format( |
yunlian | 8a3bdcb | 2013-02-19 20:42:48 +0000 | [diff] [blame] | 274 | self._name, sleep) |
shenhan | e0a6d8a | 2013-02-19 20:42:29 +0000 | [diff] [blame] | 275 | time.sleep(sleep) |
| 276 | timeout -= sleep |
| 277 | return locked |
| 278 | |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 279 | def Unlock(self, exclusive=False, ignore_ownership=False): |
yunlian | 8c9419b | 2013-02-19 21:11:29 +0000 | [diff] [blame] | 280 | lock = Lock(self._full_name, self._auto) |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 281 | return lock.Unlock(exclusive, ignore_ownership) |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 282 | |
| 283 | |
| 284 | def Main(argv): |
| 285 | """The main function.""" |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 286 | parser = optparse.OptionParser() |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 287 | parser.add_option("-r", |
| 288 | "--reason", |
| 289 | dest="reason", |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 290 | default="", |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 291 | help="The lock reason.") |
| 292 | parser.add_option("-u", |
| 293 | "--unlock", |
| 294 | dest="unlock", |
| 295 | action="store_true", |
| 296 | default=False, |
| 297 | help="Use this to unlock.") |
| 298 | parser.add_option("-l", |
| 299 | "--list_locks", |
| 300 | dest="list_locks", |
| 301 | action="store_true", |
| 302 | default=False, |
| 303 | help="Use this to list locks.") |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 304 | parser.add_option("-f", |
| 305 | "--ignore_ownership", |
| 306 | dest="ignore_ownership", |
| 307 | action="store_true", |
| 308 | default=False, |
| 309 | help="Use this to force unlock on a lock you don't own.") |
| 310 | parser.add_option("-s", |
| 311 | "--shared", |
| 312 | dest="shared", |
| 313 | action="store_true", |
| 314 | default=False, |
| 315 | help="Use this for a shared (non-exclusive) lock.") |
yunlian | 52a6c57 | 2013-02-19 20:42:07 +0000 | [diff] [blame] | 316 | parser.add_option("-d", |
| 317 | "--dir", |
| 318 | dest="locks_dir", |
| 319 | action="store", |
| 320 | default=Machine.LOCKS_DIR, |
| 321 | help="Use this to set different locks_dir") |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 322 | |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 323 | options, args = parser.parse_args(argv) |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 324 | |
yunlian | 52a6c57 | 2013-02-19 20:42:07 +0000 | [diff] [blame] | 325 | options.locks_dir = os.path.abspath(options.locks_dir) |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 326 | exclusive = not options.shared |
| 327 | |
| 328 | if not options.list_locks and len(args) != 2: |
| 329 | logger.GetLogger().LogError( |
| 330 | "Either --list_locks or a machine arg is needed.") |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 331 | return 1 |
| 332 | |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 333 | if len(args) > 1: |
yunlian | 77dc571 | 2013-02-19 21:13:33 +0000 | [diff] [blame] | 334 | machine = Machine(args[1], options.locks_dir, auto=False) |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 335 | else: |
| 336 | machine = None |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 337 | |
| 338 | if options.list_locks: |
yunlian | 52a6c57 | 2013-02-19 20:42:07 +0000 | [diff] [blame] | 339 | FileLock.ListLock("*", options.locks_dir) |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 340 | retval = True |
| 341 | elif options.unlock: |
| 342 | retval = machine.Unlock(exclusive, options.ignore_ownership) |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 343 | else: |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 344 | retval = machine.Lock(exclusive, options.reason) |
| 345 | |
| 346 | if retval: |
| 347 | return 0 |
| 348 | else: |
| 349 | return 1 |
asharif | b237bca | 2013-02-15 20:54:57 +0000 | [diff] [blame] | 350 | |
| 351 | if __name__ == "__main__": |
asharif | 455157b | 2013-02-15 21:15:05 +0000 | [diff] [blame] | 352 | sys.exit(Main(sys.argv)) |