def run(self): alerts = [] if not os.path.exists(SMART_FILE): return alerts lock = LockFile(SMART_FILE) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: return alerts with open(SMART_FILE, 'rb') as f: try: data = pickle.loads(f.read()) except: data = {} msg = '' for msgs in data.itervalues(): if not msgs: continue msg += '<br />\n'.join(msgs) if msg: alerts.append(Alert(Alert.CRIT, msg)) lock.release() return alerts
def check_sync(self): if not os.path.exists(COLLECTD_FILE): return lock = LockFile(COLLECTD_FILE) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: return with open(COLLECTD_FILE, "rb") as f: try: data = pickle.loads(f.read()) except Exception: data = {} lock.release() alerts = [] for k, v in list(data.items()): if k == "ctl-ha/disk_octets": title = "CTL HA link is actively used, check initiators connectivity" else: title = k if v["Severity"] == "WARNING": level = AlertLevel.WARNING else: level = AlertLevel.CRITICAL alerts.append(Alert(title, level=level)) return alerts
def write_relay_log(relayNumber, relaySeconds, sensor, gpio): if not os.path.exists(lock_directory): os.makedirs(lock_directory) lock = LockFile(relay_log_lock_path) while not lock.i_am_locking(): try: logging.debug("[Write Relay Log] Acquiring Lock: %s", lock.path) lock.acquire(timeout=60) # wait up to 60 seconds except: logging.warning("[Write Relay Log] Breaking Lock to Acquire: %s", lock.path) lock.break_lock() lock.acquire() logging.debug("[Write Relay Log] Gained lock: %s", lock.path) try: with open(relay_log_file_tmp, "ab") as relaylog: relaylog.write('{0} {1:d} {2:d} {3:d} {4:.2f}\n'.format( datetime.datetime.now().strftime("%Y/%m/%d-%H:%M:%S"), sensor, relayNumber, gpio, relaySeconds)) except: logging.warning("[Write Relay Log] Unable to append data to %s", relay_log_file_tmp) logging.debug("[Write Relay Log] Removing lock: %s", lock.path) lock.release()
def write_ht_sensor_log(sensor_ht_read_temp_c, sensor_ht_read_hum, sensor_ht_dewpt_c, sensor): if not os.path.exists(lock_directory): os.makedirs(lock_directory) lock = LockFile(sensor_ht_log_lock_path) while not lock.i_am_locking(): try: logging.debug("[Write Sensor Log] Acquiring Lock: %s", lock.path) lock.acquire(timeout=60) # wait up to 60 seconds except: logging.warning("[Write Sensor Log] Breaking Lock to Acquire: %s", lock.path) lock.break_lock() lock.acquire() logging.debug("[Write Sensor Log] Gained lock: %s", lock.path) try: with open(sensor_ht_log_file_tmp, "ab") as sensorlog: sensorlog.write('{0} {1:.1f} {2:.1f} {3:.1f} {4:d}\n'.format( datetime.datetime.now().strftime("%Y/%m/%d-%H:%M:%S"), sensor_ht_read_temp_c[sensor], sensor_ht_read_hum[sensor], sensor_ht_dewpt_c[sensor], sensor)) logging.debug("[Write Sensor Log] Data appended to %s", sensor_ht_log_file_tmp) except: logging.warning("[Write Sensor Log] Unable to append data to %s", sensor_ht_log_file_tmp) logging.debug("[Write Sensor Log] Removing lock: %s", lock.path) lock.release()
def main(): lock = LockFile(SMART_FILE) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: lock.break_lock() data = {} if os.path.exists(SMART_FILE): with open(SMART_FILE, 'rb') as f: try: data = pickle.loads(f.read()) except: pass device = os.environ.get('SMARTD_DEVICE') if device not in data: data[device] = [] message = os.environ.get('SMARTD_MESSAGE') if message not in data[device]: data[device].append(message) with open(SMART_FILE, 'wb') as f: f.write(pickle.dumps(data)) lock.release()
def read(self): """ Takes a reading from the K30 and updates the self._co2 value :returns: None on success or 1 on error """ lock = LockFile(K30_LOCK_FILE) try: # Acquire lock on K30 to ensure more than one read isn't # being attempted at once. while not lock.i_am_locking(): try: lock.acquire(timeout=60) # wait up to 60 seconds before breaking lock except Exception as e: logger.error("{cls} 60 second timeout, {lock} lock broken: " "{err}".format(cls=type(self).__name__, lock=K30_LOCK_FILE, err=e)) lock.break_lock() lock.acquire() self._co2 = self.get_measurement() lock.release() if self._co2 is None: return 1 return # success - no errors except Exception as e: logger.error("{cls} raised an exception when taking a reading: " "{err}".format(cls=type(self).__name__, err=e)) lock.release() return 1
def write_relay_log(relayNumber, relaySeconds): config = ConfigParser.RawConfigParser() if not os.path.exists(lock_directory): os.makedirs(lock_directory) if not Terminate: lock = LockFile(relay_lock_path) while not lock.i_am_locking(): try: logging.info("[Write Relay Log] Acquiring Lock: %s", lock.path) lock.acquire(timeout=60) # wait up to 60 seconds except: logging.warning("[Write Relay Log] Breaking Lock to Acquire: %s", lock.path) lock.break_lock() lock.acquire() logging.info("[Write Relay Log] Gained lock: %s", lock.path) relay = [0] * 9 for n in range(1, 9): if n == relayNumber: relay[relayNumber] = relaySeconds try: with open(relay_log_file_tmp, "ab") as relaylog: relaylog.write('{0} {1} {2} {3} {4} {5} {6} {7} {8}\n'.format( datetime.datetime.now().strftime("%Y %m %d %H %M %S"), relay[1], relay[2], relay[3], relay[4], relay[5], relay[6], relay[7], relay[8])) except: logging.warning("[Write Relay Log] Unable to append data to %s", relay_log_file_tmp) logging.info("[Write Relay Log] Removing lock: %s", lock.path) lock.release()
def write_sensor_log(): config = ConfigParser.RawConfigParser() if not os.path.exists(lock_directory): os.makedirs(lock_directory) if not Terminate: lock = LockFile(sensor_lock_path) while not lock.i_am_locking(): try: logging.info("[Write Sensor Log] Acquiring Lock: %s", lock.path) lock.acquire(timeout=60) # wait up to 60 seconds except: logging.warning("[Write Sensor Log] Breaking Lock to Acquire: %s", lock.path) lock.break_lock() lock.acquire() logging.info("[Write Sensor Log] Gained lock: %s", lock.path) try: with open(sensor_log_file_tmp, "ab") as sensorlog: sensorlog.write('{0} {1:.1f} {2:.1f} {3:.1f}\n'.format( datetime.datetime.now().strftime("%Y %m %d %H %M %S"), tempc, humidity, dewpointc)) logging.info("[Write Sensor Log] Data appended to %s", sensor_log_file_tmp) except: logging.warning("[Write Sensor Log] Unable to append data to %s", sensor_log_file_tmp) logging.info("[Write Sensor Log] Removing lock: %s", lock.path) lock.release()
def main(username, password): # Ignore error, logging set up in logging utils from . import logging_utils from .navigation import Leifur from .config import get_config, set_config, get_config_from_user lock = LockFile('/tmp/spoppy') try: # Try for 5s to acquire the lock lock.acquire(5) except LockTimeout: click.echo('Could not acquire lock, is spoppy running?') click.echo( 'If you\'re sure that spoppy is not running, ' 'try removing the lock file %s' % lock.lock_file ) else: if username and password: set_config(username, password) else: username, password = get_config() if not (username and password): username, password = get_config_from_user() navigator = None try: navigator = Leifur(username, password) navigator.start() finally: if navigator: navigator.shutdown() logger.debug('Finally, bye!') finally: if lock.i_am_locking(): lock.release()
def run(self): alerts = [] if not os.path.exists(SMART_FILE): return alerts lock = LockFile(SMART_FILE) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: return alerts with open(SMART_FILE, 'rb') as f: try: data = pickle.loads(f.read()) except: data = {} for msgs in data.itervalues(): if not msgs: continue for msg in msgs: if msg is None: continue alerts.append(Alert(Alert.CRIT, msg, hardware=True)) lock.release() return alerts
class MCP342x_read(object): def __init__(self, logger, address, channel, gain, resolution): self.logger = logger self.i2c_address = address self.channel = channel self.gain = gain self.resolution = resolution if GPIO.RPI_INFO['P1_REVISION'] in [2, 3]: self.I2C_bus_number = 1 else: self.I2C_bus_number = 0 self.bus = smbus.SMBus(self.I2C_bus_number) self.lock_file = "/var/lock/mycodo_adc_0x{:02X}.pid".format( self.i2c_address) def setup_lock(self): self.execution_timer = timeit.default_timer() try: self.lock = LockFile(self.lock_file) while not self.lock.i_am_locking(): try: self.logger.debug( "[Analog->Digital Converter 0x{:02X}] Acquiring Lock: {}" .format(self.i2c_address, self.lock.path)) self.lock.acquire(timeout=60) # wait up to 60 seconds except: self.logger.warning( "[Analog->Digital Converter 0x{:02X}] Waited 60 seconds. Breaking lock to acquire {}" .format(self.i2c_address, self.lock.path)) self.lock.break_lock() self.lock.acquire() self.logger.debug( "[Analog->Digital Converter 0x{:02X}] Acquired Lock: {}". format(self.i2c_address, self.lock.path)) self.logger.debug( "[Analog->Digital Converter 0x{:02X}] Executed in {}ms".format( self.i2c_address, (timeit.default_timer() - self.execution_timer) * 1000)) return 1, "Success" except Exception as msg: return 0, "Analog->Digital Converter Fail: {}".format(msg) def release_lock(self): self.lock.release() def read(self): try: time.sleep(0.1) self.setup_lock() adc = MCP342x(self.bus, self.i2c_address, channel=self.channel - 1, gain=self.gain, resolution=self.resolution) response = adc.convert_and_read() self.release_lock() return 1, response except Exception as msg: self.release_lock() return 0, "Fail: {}".format(msg)
def release(self): """ Method used to release a lock using the lockfile module. """ lock = LockFile(self.lockfile) if lock.i_am_locking(): lock.release()
def run_function_with_lock(self, function, lock_file, timeout=30, args=[], kwargs={}): self.logger.debug('starting function with lock: %s' % lock_file) lock = LockFile(lock_file) try: while not lock.i_am_locking(): try: lock.acquire(timeout=timeout) except (LockTimeout, NotMyLock) as e: self.logger.debug('breaking lock') lock.break_lock() lock.acquire() self.logger.exception(e) self.logger.debug('lock acquired: starting function') return function(*args, **kwargs) finally: self.logger.debug('function done, releasing lock') if lock.is_locked(): try: lock.release() except NotMyLock: try: os.remove(lock_file) except Exception as e: self.logger.exception(e) self.logger.debug('lock released')
def run(self): alerts = [] if not os.path.exists(COLLECTD_FILE): return alerts lock = LockFile(COLLECTD_FILE) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: return alerts with open(COLLECTD_FILE, 'rb') as f: try: data = pickle.loads(f.read()) except: data = {} lock.release() for k, v in list(data.items()): if v['Severity'] == 'WARNING': l = Alert.WARN else: l = Alert.CRIT if k == 'ctl-ha/disk_octets': msg = "CTL HA link is actively used, check initiators connectivity" else: msg = k alerts.append(Alert(l, msg)) return alerts
def run(self): alerts = [] if not os.path.exists(COLLECTD_FILE): return alerts lock = LockFile(COLLECTD_FILE) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: return alerts with open(COLLECTD_FILE, 'rb') as f: try: data = pickle.loads(f.read()) except: data = {} lock.release() for k, v in list(data.items()): if v['Severity'] == 'WARNING': l = Alert.WARN else: l = Alert.CRIT if k == 'ctl-ha/disk_octets': msg = "CTL HA link is actively used, check initiators connectivity" else: msg = k alerts.append(Alert(l, msg)) return alerts
def run(self): self.set_arguments() args = self.parser.parse_args() if args.verbose: set_logging(level=logging.DEBUG) elif args.quiet: set_logging(level=logging.WARNING) else: set_logging(level=logging.INFO) lock = LockFile(os.path.join(Utils.getRoot(), LOCK_FILE)) try: lock.acquire(timeout=-1) args.func(args) except AttributeError: if hasattr(args, 'func'): raise else: self.parser.print_help() except KeyboardInterrupt: pass except AlreadyLocked: logger.error("Could not proceed - there is probably another instance of Atomic App running on this machine.") except Exception as ex: if args.verbose: raise else: logger.error("Exception caught: %s", repr(ex)) logger.error( "Run the command again with -v option to get more information.") finally: if lock.i_am_locking(): lock.release()
def write_ht_sensor_log(sensor_ht_read_temp_c, sensor_ht_read_hum, sensor_ht_dewpt_c, sensor): if not os.path.exists(lock_directory): os.makedirs(lock_directory) lock = LockFile(sensor_ht_log_lock_path) while not lock.i_am_locking(): try: logging.debug("[Write Sensor Log] Acquiring Lock: %s", lock.path) lock.acquire(timeout=60) # wait up to 60 seconds except: logging.warning("[Write Sensor Log] Breaking Lock to Acquire: %s", lock.path) lock.break_lock() lock.acquire() logging.debug("[Write Sensor Log] Gained lock: %s", lock.path) try: with open(sensor_ht_log_file_tmp, "ab") as sensorlog: sensorlog.write('{0} {1:.1f} {2:.1f} {3:.1f} {4}\n'.format( datetime.datetime.now().strftime("%Y %m %d %H %M %S"), sensor_ht_read_temp_c[sensor], sensor_ht_read_hum[sensor], sensor_ht_dewpt_c[sensor], sensor)) logging.debug("[Write Sensor Log] Data appended to %s", sensor_ht_log_file_tmp) except: logging.warning("[Write Sensor Log] Unable to append data to %s", sensor_ht_log_file_tmp) logging.debug("[Write Sensor Log] Removing lock: %s", lock.path) lock.release()
def run(self): alerts = [] if not os.path.exists(SMART_FILE): return alerts lock = LockFile(SMART_FILE) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: return alerts with open(SMART_FILE, 'rb') as f: try: data = pickle.loads(f.read()) except: data = {} msg = '' for msgs in data.itervalues(): if not msgs: continue msg += '<br />\n'.join(msgs) if msg: alerts.append(Alert(Alert.CRIT, msg)) lock.release() return alerts
def query(self, query_str): """ Send command and return reply """ lock_file_amend = '{lf}.{dev}'.format(lf=ATLAS_PH_LOCK_FILE, dev=self.serial_device.replace( "/", "-")) lock = LockFile(lock_file_amend) try: while not lock.i_am_locking(): try: lock.acquire( timeout=10 ) # wait up to 10 seconds before breaking lock except Exception as e: logger.exception( "{cls} 10 second timeout, {lock} lock broken: " "{err}".format(cls=type(self).__name__, lock=lock_file_amend, err=e)) lock.break_lock() lock.acquire() self.send_cmd(query_str) time.sleep(1.3) response = self.read_lines() lock.release() return response except Exception as err: logger.exception( "{cls} raised an exception when taking a reading: " "{err}".format(cls=type(self).__name__, err=err)) lock.release() return None
def read(self): """ Takes a reading from the MH-Z19 and updates the self._co2 value :returns: None on success or 1 on error """ if not self.serial_device: # Don't measure if device isn't validated return None lock = LockFile(self.k30_lock_file) try: # Acquire lock on MHZ19 to ensure more than one read isn't # being attempted at once. while not lock.i_am_locking(): try: # wait 60 seconds before breaking lock lock.acquire(timeout=60) except Exception as e: self.logger.error( "{cls} 60 second timeout, {lock} lock broken: " "{err}".format(cls=type(self).__name__, lock=self.k30_lock_file, err=e)) lock.break_lock() lock.acquire() self._co2 = self.get_measurement() lock.release() if self._co2 is None: return 1 return # success - no errors except Exception as e: self.logger.error( "{cls} raised an exception when taking a reading: " "{err}".format(cls=type(self).__name__, err=e)) lock.release() return 1
def run(self): cmdline = sys.argv[1:] # Grab args from cmdline # If we are running in an openshift pod (via `oc new-app`) then # there is no cmdline but we want to default to "atomicapp run". # In this case copy files to cwd and use the working directory. if Utils.running_on_openshift(): cmdline = 'run -v --dest=none /{}'.format(APP_ENT_PATH).split() # We want to be able to place options anywhere on the command # line. We have added all global options to each subparser, # but subparsers require all options to be after the 'action' # keyword. In order to handle this we just need to figure out # what subparser will be used and move it's keyword to the front # of the line. # NOTE: Also allow "mode" to override 'action' if specified args, _ = self.parser.parse_known_args(cmdline) cmdline.remove(args.action) # Remove 'action' from the cmdline if args.mode: args.action = args.mode # Allow mode to override 'action' cmdline.insert(0, args.action) # Place 'action' at front logger.info("Action/Mode Selected is: %s" % args.action) # Finally, parse args and give error if necessary args = self.parser.parse_args(cmdline) # Set logging level if args.verbose: set_logging(level=logging.DEBUG) elif args.quiet: set_logging(level=logging.WARNING) else: set_logging(level=logging.INFO) lock = LockFile(os.path.join(Utils.getRoot(), LOCK_FILE)) try: lock.acquire(timeout=-1) args.func(args) except AttributeError: if hasattr(args, 'func'): raise else: self.parser.print_help() except KeyboardInterrupt: pass except AlreadyLocked: logger.error("Could not proceed - there is probably another instance of Atomic App running on this machine.") except Exception as ex: if args.verbose: raise else: logger.error("Exception caught: %s", repr(ex)) logger.error( "Run the command again with -v option to get more information.") finally: if lock.i_am_locking(): lock.release()
def main(username, password): # Ignore error, logging set up in logging utils from . import logging_utils from .navigation import Leifur from .config import get_config, set_config, get_config_from_user from .connectivity import check_internet_connection from .update_checker import check_for_updates lock = LockFile('/tmp/spoppy') try: try: # Try for 1s to acquire the lock lock.acquire(1) except LockTimeout: click.echo('Could not acquire lock, is spoppy running?') click.echo( 'If you\'re sure that spoppy is not running, ' 'try removing the lock file %s' % lock.lock_file ) click.echo( 'You can try removing the lock file by responding [rm]. ' 'spoppy will exit on all other inputs' ) try: response = raw_input('') except NameError: response = input('') if response == 'rm': lock.break_lock() else: raise TypeError('Could not get lock') except TypeError: pass else: check_internet_connection() # Check for updates check_for_updates(click, get_version(), lock) if username and password: set_config(username, password) else: username, password = get_config() if not (username and password): username, password = get_config_from_user() navigator = None try: navigator = Leifur(username, password) navigator.start() finally: if navigator: navigator.shutdown() logger.debug('Finally, bye!') finally: if lock.i_am_locking(): lock.release()
def main(username, password): from . import logging_utils logging_utils.configure_logging() from .navigation import Leifur from .config import get_config, set_config, get_config_from_user from .connectivity import check_internet_connection from .update_checker import check_for_updates lock = LockFile('/tmp/spoppy') try: try: # Try for 1s to acquire the lock lock.acquire(1) except LockTimeout: click.echo('Could not acquire lock, is spoppy running?') click.echo( 'If you\'re sure that spoppy is not running, ' 'try removing the lock file %s' % lock.lock_file ) click.echo( 'You can try removing the lock file by responding [rm]. ' 'spoppy will exit on all other inputs' ) try: response = raw_input('') except NameError: response = input('') if response == 'rm': lock.break_lock() else: raise TypeError('Could not get lock') except TypeError: pass else: check_internet_connection() # Check for updates check_for_updates(click, get_version(), lock) if username and password: set_config(username, password) else: username, password = get_config() if not (username and password): username, password = get_config_from_user() navigator = None try: navigator = Leifur(username, password) navigator.start() finally: if navigator: navigator.shutdown() logger.debug('Finally, bye!') finally: if lock.i_am_locking(): lock.release()
class Lock(): """Simple implementation of a mutex lock using the file systems. Works on *nix systems.""" path = None lock = None def __init__(self, path): try: from lockfile import LockFile except ImportError: from lockfile import FileLock # Different naming in older versions of lockfile LockFile = FileLock self.path = path self.lock = LockFile(path) def obtain(self): import os import logging from lockfile import AlreadyLocked logger = logging.getLogger() try: self.lock.acquire(0) logger.debug("Successfully obtained lock: %s" % self.path) except AlreadyLocked: return False return True def release(self): import os import logging logger = logging.getLogger() if not self.has_lock(): raise Exception( "Unable to release lock that is owned by another process") self.lock.release() logger.debug("Successfully released lock: %s" % self.path) def has_lock(self): return self.lock.i_am_locking() def clear(self): import os import logging logger = logging.getLogger() self.lock.break_lock() logger.debug("Successfully cleared lock: %s" % self.path)
class Lock(): """Simple implementation of a mutex lock using the file systems. Works on *nix systems.""" path = None lock = None def __init__(self, path): try: from lockfile import LockFile except ImportError: from lockfile import FileLock # Different naming in older versions of lockfile LockFile = FileLock self.path = path self.lock = LockFile(path) def obtain(self): import os import logging from lockfile import AlreadyLocked logger = logging.getLogger() try: self.lock.acquire(0) logger.debug("Successfully obtained lock: %s" % self.path) except AlreadyLocked: return False return True def release(self): import os import logging logger = logging.getLogger() if not self.has_lock(): raise Exception("Unable to release lock that is owned by another process") self.lock.release() logger.debug("Successfully released lock: %s" % self.path) def has_lock(self): return self.lock.i_am_locking() def clear(self): import os import logging logger = logging.getLogger() self.lock.break_lock() logger.debug("Successfully cleared lock: %s" % self.path)
def append_line_to_mycodo_log(log_file_path, log_lock_path, log_line): """ Appends given line to log file. :return: :rtype: :param log_file_path: Path to the Log File :type log_file_path: str :param log_lock_path: Path to the Lock File :type log_lock_path: str :param log_line: String to write to the Log File :type log_line: str """ lock = LockFile(log_lock_path) while not lock.i_am_locking(): try: logging.debug("[Write Sensor Log] Acquiring Lock: {}".format(lock.path)) lock.acquire(timeout=60) # wait up to 60 seconds except: # TODO Needs better catch statement logging.warning("[Write Sensor Log] Breaking Lock to Acquire: {}".format(lock.path)) lock.break_lock() lock.acquire() finally: logging.debug("[Write Sensor Log] Gained lock: {}".format(lock.path)) try: with open(log_file_path, "ab") as sensorlog: pass sensorlog.write(log_line + "\n") # Temperature: # sensorlog.write('{"%Y/%m/%d-%H:%M:%S"} {:.1f} {}'.format(now(), sensor_t_read_temp_c[sensor], sensor)) # Temperature/Humidity: # sensorlog.write('{"%Y/%m/%d-%H:%M:%S"} {:.1f} {:.1f} {:.1f} {}'.format(now(), sensor_ht_read_temp_c[sensor], sensor_ht_read_hum[sensor], sensor_ht_dewpt_c[sensor], sensor)) # CO2 # sensorlog.write('{"%Y/%m/%d-%H:%M:%S"} {} {}'.format(now(), sensor_co2_read_co2[sensor], sensor)) # Pressure # sensorlog.write('{"%Y/%m/%d-%H:%M:%S"} {:.1f} {} {:.1f} {}'.format(now(), sensor_press_read_temp_c[sensor], sensor_press_read_press[sensor], sensor_press_read_alt[sensor], sensor)) # Relay # relaylog.write('{"%Y/%m/%d-%H:%M:%S"} {} {} {} {:.2f}'.format(now(), sensor, relayNumber, gpio, relaySeconds)) logging.debug("[Write Sensor Log] Data appended to {}".format( log_file_path)) except: # TODO Needs better catch statement logging.warning("[Write Sensor Log] Unable to append data to %s", log_file_path) logging.debug("[Write Sensor Log] Removing lock: {}".format(lock.path)) lock.release()
def do_lock(*args, **kwargs): lock = LockFile(path) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: lock.break_lock() try: rv = f(*args, **kwargs) finally: lock.release() return rv
def do_lock(*args, **kwargs): lock = LockFile(path) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: lock.break_lock() try: rv = f(*args, **kwargs) finally: lock.release() return rv
class MailQueue(object): QUEUE_FILE = '/tmp/mail.queue' MAX_ATTEMPTS = 3 def __init__(self): self.queue = None def append(self, message): self.queue.append(QueueItem(message)) @classmethod def is_empty(cls): if not os.path.exists(cls.QUEUE_FILE): return True try: return os.stat(cls.QUEUE_FILE).st_size == 0 except OSError: return True def _get_queue(self): try: with open(self.QUEUE_FILE, 'rb') as f: self.queue = pickle.loads(f.read()) except (pickle.PickleError, EOFError): self.queue = [] def __enter__(self): self._lock = LockFile(self.QUEUE_FILE) while not self._lock.i_am_locking(): try: self._lock.acquire(timeout=330) except LockTimeout: self._lock.break_lock() if not os.path.exists(self.QUEUE_FILE): open(self.QUEUE_FILE, 'a').close() self._get_queue() return self def __exit__(self, typ, value, traceback): with open(self.QUEUE_FILE, 'wb+') as f: if self.queue: f.write(pickle.dumps(self.queue)) self._lock.release() if typ is not None: raise
class MailQueue(object): QUEUE_FILE = '/tmp/mail.queue' MAX_ATTEMPTS = 3 def __init__(self): self.queue = None def append(self, message): self.queue.append(QueueItem(message)) @classmethod def is_empty(cls): if not os.path.exists(cls.QUEUE_FILE): return True try: return os.stat(cls.QUEUE_FILE).st_size == 0 except OSError: return True def _get_queue(self): try: with open(self.QUEUE_FILE, 'rb') as f: self.queue = pickle.loads(f.read()) except (pickle.PickleError, EOFError): self.queue = [] def __enter__(self): self._lock = LockFile(self.QUEUE_FILE) while not self._lock.i_am_locking(): try: self._lock.acquire(timeout=330) except LockTimeout: self._lock.break_lock() if not os.path.exists(self.QUEUE_FILE): open(self.QUEUE_FILE, 'a').close() self._get_queue() return self def __exit__(self, typ, value, traceback): with open(self.QUEUE_FILE, 'wb+') as f: if self.queue: f.write(pickle.dumps(self.queue)) self._lock.release() if typ is not None: raise
def sync_sources(labels): """ Attempts to run several methods Certificate discovery. This is run on a periodic basis and updates the Lemur datastore with the information it discovers. """ if not labels: sys.stdout.write("Active\tLabel\tDescription\n") for source in source_service.get_all(): sys.stdout.write( "{active}\t{label}\t{description}!\n".format( label=source.label, description=source.description, active=source.active ) ) else: start_time = time.time() lock_file = "/tmp/.lemur_lock" sync_lock = LockFile(lock_file) while not sync_lock.i_am_locking(): try: sync_lock.acquire(timeout=10) # wait up to 10 seconds sys.stdout.write("[+] Staring to sync sources: {labels}!\n".format(labels=labels)) labels = labels.split(",") if labels[0] == 'all': sync() else: sync(labels=labels) sys.stdout.write( "[+] Finished syncing sources. Run Time: {time}\n".format( time=(time.time() - start_time) ) ) except LockTimeout: sys.stderr.write( "[!] Unable to acquire file lock on {file}, is there another sync running?\n".format( file=lock_file ) ) sync_lock.break_lock() sync_lock.acquire() sync_lock.release() sync_lock.release()
class Journal(object): """ Interface for accessing the journal for the queries that couldn't run in the remote side, either for it being offline or failed to execute. This should be used in a context and provides file locking by itself. """ JOURNAL_FILE = '/data/ha-journal' @classmethod def is_empty(cls): if not os.path.exists(cls.JOURNAL_FILE): return True try: return os.stat(cls.JOURNAL_FILE).st_size == 0 except OSError: return True def _get_queries(self): try: with open(self.JOURNAL_FILE, 'rb') as f: self.queries = pickle.loads(f.read()) except (pickle.PickleError, EOFError): self.queries = [] def __enter__(self): self._lock = LockFile(self.JOURNAL_FILE) while not self._lock.i_am_locking(): try: self._lock.acquire(timeout=5) except LockTimeout: self._lock.break_lock() if not os.path.exists(self.JOURNAL_FILE): open(self.JOURNAL_FILE, 'a').close() self._get_queries() return self def __exit__(self, typ, value, traceback): with open(self.JOURNAL_FILE, 'w+') as f: if self.queries: f.write(pickle.dumps(self.queries)) self._lock.release() if typ is not None: raise
class Journal(object): """ Interface for accessing the journal for the queries that couldn't run in the remote side, either for it being offline or failed to execute. This should be used in a context and provides file locking by itself. """ JOURNAL_FILE = '/data/ha-journal' @classmethod def is_empty(cls): if not os.path.exists(cls.JOURNAL_FILE): return True try: return os.stat(cls.JOURNAL_FILE).st_size == 0 except OSError: return True def _get_queries(self): try: with open(self.JOURNAL_FILE, 'rb') as f: self.queries = pickle.loads(f.read()) except (pickle.PickleError, EOFError): self.queries = [] def __enter__(self): self._lock = LockFile(self.JOURNAL_FILE) while not self._lock.i_am_locking(): try: self._lock.acquire(timeout=5) except LockTimeout: self._lock.break_lock() if not os.path.exists(self.JOURNAL_FILE): open(self.JOURNAL_FILE, 'a').close() self._get_queries() return self def __exit__(self, typ, value, traceback): with open(self.JOURNAL_FILE, 'w+') as f: if self.queries: f.write(pickle.dumps(self.queries)) self._lock.release() if typ is not None: raise
def sync(labels): """ Attempts to run several methods Certificate discovery. This is run on a periodic basis and updates the Lemur datastore with the information it discovers. """ if not labels: sys.stdout.write("Active\tLabel\tDescription\n") for source in source_service.get_all(): sys.stdout.write( "{active}\t{label}\t{description}!\n".format( label=source.label, description=source.description, active=source.active ) ) else: start_time = time.time() lock_file = "/tmp/.lemur_lock" sync_lock = LockFile(lock_file) while not sync_lock.i_am_locking(): try: sync_lock.acquire(timeout=10) # wait up to 10 seconds sys.stdout.write("[+] Staring to sync sources: {labels}!\n".format(labels=labels)) labels = labels.split(",") if labels[0] == 'all': source_sync() else: source_sync(labels=labels) sys.stdout.write( "[+] Finished syncing sources. Run Time: {time}\n".format( time=(time.time() - start_time) ) ) except LockTimeout: sys.stderr.write( "[!] Unable to acquire file lock on {file}, is there another sync running?\n".format( file=lock_file ) ) sync_lock.break_lock() sync_lock.acquire() sync_lock.release() sync_lock.release()
class MCP342x_read(object): def __init__(self, logger, address, channel, resolution): self.logger = logger self.i2c_address = address self.channel = channel self.resolution = resolution if GPIO.RPI_INFO['P1_REVISION'] in [2, 3]: self.I2C_bus_number = 1 else: self.I2C_bus_number = 0 self.bus = smbus.SMBus(self.I2C_bus_number) self.lock_file = "/var/lock/mycodo_adc_0x{:02X}.pid".format(self.i2c_address) def setup_lock(self): self.execution_timer = timeit.default_timer() try: self.lock = LockFile(self.lock_file) while not self.lock.i_am_locking(): try: self.logger.debug("[Analog->Digital Converter 0x{:02X}] Acquiring Lock: {}".format(self.i2c_address, self.lock.path)) self.lock.acquire(timeout=60) # wait up to 60 seconds except: self.logger.warning("[Analog->Digital Converter 0x{:02X}] Waited 60 seconds. Breaking lock to acquire {}".format(self.i2c_address, self.lock.path)) self.lock.break_lock() self.lock.acquire() self.logger.debug("[Analog->Digital Converter 0x{:02X}] Acquired Lock: {}".format(self.i2c_address, self.lock.path)) self.logger.debug("[Analog->Digital Converter 0x{:02X}] Executed in {}ms".format(self.i2c_address, (timeit.default_timer()-self.execution_timer)*1000)) return 1, "Success" except Exception as msg: return 0, "Analog->Digital Converter Fail: {}".format(msg) def release_lock(self): self.lock.release() def read(self): try: time.sleep(0.1) self.setup_lock() adc = MCP342x(self.bus, self.i2c_address, channel=self.channel-1, resolution=self.resolution) response = adc.convert_and_read() self.release_lock() return 1, response except Exception as msg: self.release_lock() return 0, "Fail: {}".format(msg)
def safe_flush_file(file_path): lock_f = '%s' % os.path.basename(file_path) lock = LockFile(lock_f) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: lock.break_lock() finally: lock.acquire() with open(file_path, 'w') as cf: try: yield cf finally: cf.close() lock.release()
def read(self): lock = LockFile(K30_LOCK_FILE) try: # Acquire lock on K30 to ensure more than one read isn't # being attempted at once. while not lock.i_am_locking(): try: lock.acquire(timeout=60) # wait up to 60 seconds before breaking lock except: lock.break_lock() lock.acquire() self._co2 = self.get_measurement() lock.release() except: lock.release() return 1
def run(self): self.set_arguments() # Set our arguments cmdline = sys.argv[1:] # Grab args from cmdline # We want to be able to place options anywhere on the command # line. We have added all global options to each subparser, # but subparsers require all options to be after the 'action' # keyword. In order to handle this we just need to figure out # what subparser will be used and move it's keyword to the front # of the line. args, _ = self.parser.parse_known_args(cmdline) cmdline.remove(args.action) # Remove 'action' from the cmdline cmdline.insert(0, args.action) # Place 'action' at front # Finally, parse args and give error if necessary args = self.parser.parse_args(cmdline) if args.verbose: set_logging(level=logging.DEBUG) elif args.quiet: set_logging(level=logging.WARNING) else: set_logging(level=logging.INFO) lock = LockFile(os.path.join(Utils.getRoot(), LOCK_FILE)) try: lock.acquire(timeout=-1) args.func(args) except AttributeError: if hasattr(args, "func"): raise else: self.parser.print_help() except KeyboardInterrupt: pass except AlreadyLocked: logger.error( "Could not proceed - there is probably another instance of Atomic App running on this machine." ) except Exception as ex: if args.verbose: raise else: logger.error("Exception caught: %s", repr(ex)) logger.error("Run the command again with -v option to get more information.") finally: if lock.i_am_locking(): lock.release()
def concat_log_tmp_to_perm(log_file_tmp, log_file_perm, log_lock_path): """ Combines logs on the temporary file system with the logs on the SD card. :return: :rtype: :param log_file_tmp: Path to the Log File on the tmpfs :type log_file_tmp: str :param log_file_perm: Path to the Log File on the SD Card :type log_file_perm: str :param log_lock_path: Path to the lock file :type log_lock_path: str """ # Daemon Logs if not filecmp.cmp(log_file_tmp, log_file_perm): logging.debug("[Log Backup] Concatenating log cache" " ({}) to permanent storage ({})".format(log_file_tmp, log_file_perm)) lock = LockFile(log_lock_path) while not lock.i_am_locking(): try: logging.debug("[Log Backup] Acquiring Lock: {}".format(lock.path)) lock.acquire(timeout=60) # wait up to 60 seconds except: # TODO Needs better catch statement logging.warning("[Log Backup] Breaking Lock to Acquire: {}".format(lock.path)) lock.break_lock() lock.acquire() finally: logging.debug("[Log Backup] Gained lock: {}".format(lock.path)) try: with open(log_file_perm, 'a') as fout, open(log_file_tmp, 'r+') as tmp_log: for line in tmp_log: fout.write(line) logging.debug("[Log Backup] Appended log data to {}".format(log_file_perm)) tmp_log.truncate() # Clear tmp_log if we've copied the lines over except: # TODO Needs better catch statement logging.warning("[Log Backup] Unable to append data to {}".format(log_file_perm)) logging.debug("[Log Backup] Removing lock: {}".format(lock.path)) lock.release() else: logging.debug( "[Log Backup] Logs the same, skipping. ({}) ({})".format(log_file_tmp, log_file_perm))
def read(self): lock = LockFile(K30_LOCK_FILE) try: # Acquire lock on K30 to ensure more than one read isn't # being attempted at once. while not lock.i_am_locking(): try: lock.acquire( timeout=60 ) # wait up to 60 seconds before breaking lock except: lock.break_lock() lock.acquire() self._co2 = self.get_measurement() lock.release() except: lock.release() return 1
class SmartAlert(object): SMART_FILE = '/tmp/.smartalert' def __init__(self): self.data = {} self.lock = LockFile(self.SMART_FILE) def __enter__(self): while not self.lock.i_am_locking(): try: self.lock.acquire(timeout=5) except LockTimeout: self.lock.break_lock() if os.path.exists(self.SMART_FILE): with open(self.SMART_FILE, 'rb') as f: try: self.data = pickle.loads(f.read()) except Exception: pass return self def __exit__(self, typ, value, traceback): with open(self.SMART_FILE, 'wb') as f: f.write(pickle.dumps(self.data)) self.lock.release() if typ is not None: raise def message_add(self, dev, message): if not dev.startswith('/dev/'): dev = '/dev/{0}'.format(dev) if dev not in self.data: self.data[dev] = [] if message not in self.data[dev]: self.data[dev].append(message) def device_delete(self, dev): if not dev.startswith('/dev/'): dev = '/dev/{0}'.format(dev) self.data.pop(dev, None)
def query(self, query_str): """ Send command to board and read response """ lock_file_amend = '{lf}.{dev}'.format(lf=ATLAS_PH_LOCK_FILE, dev=self.current_addr) lock = LockFile(lock_file_amend) try: while not lock.i_am_locking(): try: lock.acquire( timeout=10 ) # wait up to 60 seconds before breaking lock except Exception as e: logger.exception( "{cls} 10 second timeout, {lock} lock broken: " "{err}".format(cls=type(self).__name__, lock=ATLAS_PH_LOCK_FILE, err=e)) lock.break_lock() lock.acquire() # write a command to the board, wait the correct timeout, and read the response self.write(query_str) # the read and calibration commands require a longer timeout if ((query_str.upper().startswith("R")) or (query_str.upper().startswith("CAL"))): time.sleep(self.long_timeout) elif query_str.upper().startswith("SLEEP"): return "sleep mode" else: time.sleep(self.short_timeout) response = self.read() lock.release() return response except Exception as err: logger.exception( "{cls} raised an exception when taking a reading: " "{err}".format(cls=type(self).__name__, err=err)) lock.release() return None
def combine_filecontents(self, forcebuild=False): """ ..py:method:: combine_filecontents([forcebuild : boolean]) -> boolean Combines all content of scripts into one file. Returns True if file generated and False if file already exists. :param boolean forcebuild: should re-build scripts everytime :rtype boolean: """ _built_fname = os.path.join(self.dest, self.get_output_filename()) if self.exists_andnot_force(forcebuild, _built_fname): return False lock_ = LockFile(os.path.join(settings.STATIC_ROOT, _built_fname)) while lock_.i_am_locking(): try: lock_.acquire(timeout=20) except LockTimeout: lock_.break_lock() lock_.acquire() try: _built_fd = self._openfile(_built_fname, 'w') # collect all content of scripts into files to be compressed for script in self.scripts: fd = self._openfile(self.backend.pre_open(script)) content = self.backend.read(fd) _built_fd.write(content + '\n') fd.close() _built_fd.close() except: try: lock_.release() except NotLocked: pass return False return lock_
class SmartAlert(object): SMART_FILE = "/tmp/.smartalert" def __init__(self): self.data = {} self.lock = LockFile(self.SMART_FILE) def __enter__(self): while not self.lock.i_am_locking(): try: self.lock.acquire(timeout=5) except LockTimeout: self.lock.break_lock() if os.path.exists(self.SMART_FILE): with open(self.SMART_FILE, "rb") as f: try: self.data = pickle.loads(f.read()) except: pass return self def __exit__(self, typ, value, traceback): with open(self.SMART_FILE, "wb") as f: f.write(pickle.dumps(self.data)) self.lock.release() if typ is not None: raise def message_add(self, dev, message): if dev not in self.data: self.data[dev] = [] if message not in self.data[dev]: self.data[dev].append(message) def device_delete(self, dev): self.data.pop(dev, None)
def combine_filecontents(self, forcebuild=False): """ ..py:method:: combine_filecontents([forcebuild : boolean]) -> boolean Combines all content of scripts into one file. Returns True if file generated and False if file already exists. :param boolean forcebuild: should re-build scripts everytime :rtype boolean: """ _built_fname = os.path.join(self.dest, self.get_output_filename()) if self.exists_andnot_force(forcebuild, _built_fname): return False lock_ = LockFile(os.path.join(settings.STATIC_ROOT, _built_fname)) while lock_.i_am_locking(): try: lock_.acquire(timeout=20) except LockTimeout: lock_.break_lock() lock_.acquire() try: _built_fd = self._openfile(_built_fname, 'w') # collect all content of scripts into files to be compressed for script in self.scripts: fd = self._openfile(self.backend.pre_open(script)) content = self.backend.read(fd) _built_fd.write(content + '\n') fd.close() _built_fd.close() except: try: lock_.release() except NotLocked: pass return False return lock_
def check_sync(self): if not os.path.exists(COLLECTD_FILE): return lock = LockFile(COLLECTD_FILE) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: return with open(COLLECTD_FILE, "rb") as f: try: data = pickle.loads(f.read()) except Exception: data = {} lock.release() alerts = [] for k, v in list(data.items()): if k == "ctl-ha/disk_octets": text = ( "Storage Controller HA link is in use. Please check that all iSCSI and FC initiators support ALUA " "and are able to connect to the active node." ) else: text = k if v["Severity"] == "WARNING": klass = CollectdWarningAlertClass else: klass = CollectdCriticalAlertClass alerts.append(Alert(klass, text)) return alerts
def check_sync(self): if not os.path.exists(COLLECTD_FILE): return lock = LockFile(COLLECTD_FILE) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: return with open(COLLECTD_FILE, "rb") as f: try: data = pickle.loads(f.read()) except Exception: data = {} lock.release() alerts = [] for k, v in list(data.items()): if k == "ctl-ha/disk_octets": text = ( "Storage Controller HA link is in use. Please check that all iSCSI and FC initiators support ALUA " "and are able to connect to the active node.") else: text = k if v["Severity"] == "WARNING": klass = CollectdWarningAlertClass else: klass = CollectdCriticalAlertClass alerts.append(Alert(klass, text)) return alerts
def main(): lock = LockFile(COLLECTD_FILE) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: lock.break_lock() data = {} if os.path.exists(COLLECTD_FILE): with open(COLLECTD_FILE, 'rb') as f: try: data = pickle.loads(f.read()) except: pass text = sys.stdin.read().replace('\n\n', '\nMessage: ', 1) v = dict(re.findall(r"(?P<name>.*?): (?P<value>.*?)\n", text)) k = v["Plugin"] if "PluginInstance" in v.keys(): k += "-" + v["PluginInstance"] k += "/" + v["Type"] if "TypeInstance" in v.keys(): k += "-" + v["TypeInstance"] if v["Severity"] == "OKAY": data.pop(k, None) else: data[k] = v; with open(COLLECTD_FILE, 'wb') as f: f.write(pickle.dumps(data)) lock.release()
def main(): lock = LockFile(COLLECTD_FILE) while not lock.i_am_locking(): try: lock.acquire(timeout=5) except LockTimeout: lock.break_lock() data = {} if os.path.exists(COLLECTD_FILE): with open(COLLECTD_FILE, 'rb') as f: try: data = pickle.loads(f.read()) except: pass text = sys.stdin.read().replace('\n\n', '\nMessage: ', 1) v = dict(re.findall(r"(?P<name>.*?): (?P<value>.*?)\n", text)) k = v["Plugin"] if "PluginInstance" in v.keys(): k += "-" + v["PluginInstance"] k += "/" + v["Type"] if "TypeInstance" in v.keys(): k += "-" + v["TypeInstance"] if v["Severity"] == "OKAY": data.pop(k, None) else: data[k] = v; with open(COLLECTD_FILE, 'wb') as f: f.write(pickle.dumps(data)) lock.release()
def run(self): self.set_arguments() args = self.parser.parse_args() if args.verbose: set_logging(level=logging.DEBUG) elif args.quiet: set_logging(level=logging.WARNING) else: set_logging(level=logging.INFO) lock = LockFile(os.path.join(Utils.getRoot(), LOCK_FILE)) try: lock.acquire(timeout=-1) args.func(args) except AttributeError: if hasattr(args, 'func'): raise else: self.parser.print_help() except KeyboardInterrupt: pass except AlreadyLocked: logger.error( "Could not proceed - there is probably another instance of Atomic App running on this machine." ) except Exception as ex: if args.verbose: raise else: logger.error("Exception caught: %s", repr(ex)) logger.error( "Run the command again with -v option to get more information." ) finally: if lock.i_am_locking(): lock.release()
def run(self): cmdline = sys.argv[1:] # Grab args from cmdline # Initial setup of logging (to allow for a few early debug statements) Logging.setup_logging(verbose=True, quiet=False) # If we are running in an openshift pod (via `oc new-app`) then # there is no cmdline but we want to default to "atomicapp run". if Utils.running_on_openshift(): cmdline = 'run -v --dest=none --provider=openshift /{}' cmdline = cmdline.format(APP_ENT_PATH).split() # now a list # If the user has elected to provide all arguments via the # ATOMICAPP_ARGS environment variable then set it now argstr = os.environ.get('ATOMICAPP_ARGS') if argstr: logger.debug("Setting cmdline args to: {}".format(argstr)) cmdline = argstr.split() # If the user has elected to provide some arguments via the # ATOMICAPP_APPEND_ARGS environment variable then add those now argstr = os.environ.get('ATOMICAPP_APPEND_ARGS') if argstr: logger.debug("Appending args to cmdline: {}".format(argstr)) cmdline.extend(argstr.split()) # We want to be able to place options anywhere on the command # line. We have added all global options to each subparser, # but subparsers require all options to be after the 'action' # keyword. In order to handle this we just need to figure out # what subparser will be used and move it's keyword to the front # of the line. # NOTE: Also allow "mode" to override 'action' if specified args, _ = self.parser.parse_known_args(cmdline) cmdline.remove(args.action) # Remove 'action' from the cmdline if args.mode: args.action = args.mode # Allow mode to override 'action' cmdline.insert(0, args.action) # Place 'action' at front # Finally, parse args and give error if necessary args = self.parser.parse_args(cmdline) # Setup logging (now with arguments from cmdline) and log a few msgs Logging.setup_logging(args.verbose, args.quiet, args.logtype) logger.info("Action/Mode Selected is: %s" % args.action) logger.debug("Final parsed cmdline: {}".format(' '.join(cmdline))) # In the case of Atomic CLI we want to allow the user to specify # a directory if they want to for "run". For that reason we won't # default the RUN label for Atomic App to provide an app_spec argument. # In this case pick up app_spec from $IMAGE env var (set by RUN label). if args.app_spec is None: if os.environ.get('IMAGE') is not None: logger.debug("Setting app_spec based on $IMAGE env var") args.app_spec = os.environ['IMAGE'] else: print("Error. Too few arguments. Must provide app_spec.") print("Run with '--help' for more info") sys.exit(1) # Take the arguments that correspond to "answers" config file data # and make a dictionary of it to pass along in args. setattr(args, 'cli_answers', {}) for item in ['providerapi', 'providercafile', 'providerconfig', 'providertlsverify', 'namespace']: if hasattr(args, item) and getattr(args, item) is not None: args.cli_answers[item] = getattr(args, item) lock = LockFile(os.path.join(Utils.getRoot(), LOCK_FILE)) try: lock.acquire(timeout=-1) args.func(args) except AttributeError: if hasattr(args, 'func'): raise else: self.parser.print_help() except KeyboardInterrupt: pass except AlreadyLocked: logger.error("Could not proceed - there is probably another instance of Atomic App running on this machine.") except Exception as ex: if args.verbose: raise else: logger.error("Exception caught: %s", repr(ex)) logger.error( "Run the command again with -v option to get more information.") finally: if lock.i_am_locking(): lock.release()
def Concatenate_Logs(): # Temperature Sensor Logs if not filecmp.cmp(sensor_t_log_file_tmp, sensor_t_log_file): logging.debug("[Log Backup] Concatenating T sensor logs to %s", sensor_t_log_file) lock = LockFile(sensor_t_log_lock_path) while not lock.i_am_locking(): try: logging.debug("[Log Backup] Acquiring Lock: %s", lock.path) lock.acquire(timeout=60) # wait up to 60 seconds except: logging.warning("[Log Backup] Breaking Lock to Acquire: %s", lock.path) lock.break_lock() lock.acquire() logging.debug("[Log Backup] Gained lock: %s", lock.path) try: with open(sensor_t_log_file, 'a') as fout: for line in fileinput.input(sensor_t_log_file_tmp): fout.write(line) logging.debug("[Log Backup] Appended T data to %s", sensor_t_log_file) except: logging.warning("[Log Backup] Unable to append data to %s", sensor_t_log_file) open(sensor_t_log_file_tmp, 'w').close() logging.debug("[Log Backup] Removing lock: %s", lock.path) lock.release() else: logging.debug("[Log Backup] T Sensor logs the same, skipping.") # Humidity/Temperature Sensor Logs if not filecmp.cmp(sensor_ht_log_file_tmp, sensor_ht_log_file): logging.debug("[Log Backup] Concatenating HT sensor logs to %s", sensor_ht_log_file) lock = LockFile(sensor_ht_log_lock_path) while not lock.i_am_locking(): try: logging.debug("[Log Backup] Acquiring Lock: %s", lock.path) lock.acquire(timeout=60) # wait up to 60 seconds except: logging.warning("[Log Backup] Breaking Lock to Acquire: %s", lock.path) lock.break_lock() lock.acquire() logging.debug("[Log Backup] Gained lock: %s", lock.path) try: with open(sensor_ht_log_file, 'a') as fout: for line in fileinput.input(sensor_ht_log_file_tmp): fout.write(line) logging.debug("[Log Backup] Appended HT data to %s", sensor_ht_log_file) except: logging.warning("[Log Backup] Unable to append data to %s", sensor_ht_log_file) open(sensor_ht_log_file_tmp, 'w').close() logging.debug("[Log Backup] Removing lock: %s", lock.path) lock.release() else: logging.debug("[Log Backup] HT Sensor logs the same, skipping.") # CO2 Sensor Logs if not filecmp.cmp(sensor_co2_log_file_tmp, sensor_co2_log_file): logging.debug("[Log Backup] Concatenating CO2 sensor logs to %s", sensor_co2_log_file) lock = LockFile(sensor_co2_log_lock_path) while not lock.i_am_locking(): try: logging.debug("[Log Backup] Acquiring Lock: %s", lock.path) lock.acquire(timeout=60) # wait up to 60 seconds except: logging.warning("[Log Backup] Breaking Lock to Acquire: %s", lock.path) lock.break_lock() lock.acquire() logging.debug("[Log Backup] Gained lock: %s", lock.path) try: with open(sensor_co2_log_file, 'a') as fout: for line in fileinput.input(sensor_co2_log_file_tmp): fout.write(line) logging.debug("[Log Backup] Appended CO2 data to %s", sensor_co2_log_file) except: logging.warning("[Log Backup] Unable to append data to %s", sensor_co2_log_file) open(sensor_co2_log_file_tmp, 'w').close() logging.debug("[Log Backup] Removing lock: %s", lock.path) lock.release() else: logging.debug("[Log Backup] CO2 Sensor logs the same, skipping.") # Pressure Sensor Logs if not filecmp.cmp(sensor_press_log_file_tmp, sensor_press_log_file): logging.debug("[Log Backup] Concatenating Press sensor logs to %s", sensor_press_log_file) lock = LockFile(sensor_press_log_lock_path) while not lock.i_am_locking(): try: logging.debug("[Log Backup] Acquiring Lock: %s", lock.path) lock.acquire(timeout=60) # wait up to 60 seconds except: logging.warning("[Log Backup] Breaking Lock to Acquire: %s", lock.path) lock.break_lock() lock.acquire() logging.debug("[Log Backup] Gained lock: %s", lock.path) try: with open(sensor_press_log_file, 'a') as fout: for line in fileinput.input(sensor_press_log_file_tmp): fout.write(line) logging.debug("[Log Backup] Appended Press data to %s", sensor_press_log_file) except: logging.warning("[Log Backup] Unable to append data to %s", sensor_press_log_file) open(sensor_press_log_file_tmp, 'w').close() logging.debug("[Log Backup] Removing lock: %s", lock.path) lock.release() else: logging.debug("[Log Backup] Press Sensor logs the same, skipping.") # Relay Logs if not filecmp.cmp(relay_log_file_tmp, relay_log_file): logging.debug("[Log Backup] Concatenating relay logs to %s", relay_log_file) lock = LockFile(relay_log_lock_path) while not lock.i_am_locking(): try: logging.debug("[Log Backup] Acquiring Lock: %s", lock.path) lock.acquire(timeout=60) # wait up to 60 seconds except: logging.warning("[Log Backup] Breaking Lock to Acquire: %s", lock.path) lock.break_lock() lock.acquire() logging.debug("[Log Backup] Gained lock: %s", lock.path) try: with open(relay_log_file, 'a') as fout: for line in fileinput.input(relay_log_file_tmp): fout.write(line) logging.debug("[Log Backup] Appended data to %s", relay_log_file) except: logging.warning("[Log Backup] Unable to append data to %s", relay_log_file) open(relay_log_file_tmp, 'w').close() logging.debug("[Log Backup] Removing lock: %s", lock.path) lock.release() else: logging.debug("[Log Backup] Relay logs the same, skipping.") # Daemon Logs if not filecmp.cmp(daemon_log_file_tmp, daemon_log_file): logging.debug("[Log Backup] Concatenating daemon logs to %s", daemon_log_file) lock = LockFile(daemon_log_lock_path) while not lock.i_am_locking(): try: logging.debug("[Log Backup] Acquiring Lock: %s", lock.path) lock.acquire(timeout=60) # wait up to 60 seconds except: logging.warning("[Log Backup] Breaking Lock to Acquire: %s", lock.path) lock.break_lock() lock.acquire() logging.debug("[Log Backup] Gained lock: %s", lock.path) try: with open(daemon_log_file, 'a') as fout: for line in fileinput.input(daemon_log_file_tmp): fout.write(line) logging.debug("[Log Backup] Appended daemon log data to %s", daemon_log_file) except: logging.warning("[Log Backup] Unable to append data to %s", daemon_log_file) open(daemon_log_file_tmp, 'w').close() logging.debug("[Log Backup] Removing lock: %s", lock.path) lock.release() else: logging.debug("[Log Backup] Daemon logs the same, skipping.")
def write_config(): config = ConfigParser.RawConfigParser() if not os.path.exists(lock_directory): os.makedirs(lock_directory) lock = LockFile(config_lock_path) while not lock.i_am_locking(): try: logging.info("[Write Config] Waiting, Acquiring Lock: %s", lock.path) lock.acquire(timeout=60) # wait up to 60 seconds except: logging.warning("[Write Config] Breaking Lock to Acquire: %s", lock.path) lock.break_lock() lock.acquire() logging.info("[Write Config] Gained lock: %s", lock.path) logging.info("[Write Config] Writing config file %s", config_file) config.add_section('Sensor') config.set('Sensor', 'dhtsensor', DHTSensor) config.set('Sensor', 'dhtpin', DHTPin) config.set('Sensor', 'dhtseconds', DHTSeconds) config.add_section('RelayNames') config.set('RelayNames', 'relay1name', relayName[1]) config.set('RelayNames', 'relay2name', relayName[2]) config.set('RelayNames', 'relay3name', relayName[3]) config.set('RelayNames', 'relay4name', relayName[4]) config.set('RelayNames', 'relay5name', relayName[5]) config.set('RelayNames', 'relay6name', relayName[6]) config.set('RelayNames', 'relay7name', relayName[7]) config.set('RelayNames', 'relay8name', relayName[8]) config.add_section('RelayPins') config.set('RelayPins', 'relay1pin', relayPin[1]) config.set('RelayPins', 'relay2pin', relayPin[2]) config.set('RelayPins', 'relay3pin', relayPin[3]) config.set('RelayPins', 'relay4pin', relayPin[4]) config.set('RelayPins', 'relay5pin', relayPin[5]) config.set('RelayPins', 'relay6pin', relayPin[6]) config.set('RelayPins', 'relay7pin', relayPin[7]) config.set('RelayPins', 'relay8pin', relayPin[8]) config.add_section('RelayTriggers') config.set('RelayTriggers', 'relay1trigger', relayTrigger[1]) config.set('RelayTriggers', 'relay2trigger', relayTrigger[2]) config.set('RelayTriggers', 'relay3trigger', relayTrigger[3]) config.set('RelayTriggers', 'relay4trigger', relayTrigger[4]) config.set('RelayTriggers', 'relay5trigger', relayTrigger[5]) config.set('RelayTriggers', 'relay6trigger', relayTrigger[6]) config.set('RelayTriggers', 'relay7trigger', relayTrigger[7]) config.set('RelayTriggers', 'relay8trigger', relayTrigger[8]) config.add_section('PID') config.set('PID', 'relaytemp', relayTemp) config.set('PID', 'relayhum', relayHum) config.set('PID', 'tempor', TempOR) config.set('PID', 'humor', HumOR) config.set('PID', 'settemp', setTemp) config.set('PID', 'sethum', setHum) config.set('PID', 'hum_p', Hum_P) config.set('PID', 'hum_i', Hum_I) config.set('PID', 'hum_d', Hum_D) config.set('PID', 'temp_p', Temp_P) config.set('PID', 'temp_i', Temp_I) config.set('PID', 'temp_d', Temp_D) config.set('PID', 'factorhumseconds', factorHumSeconds) config.set('PID', 'factortempseconds', factorTempSeconds) config.add_section('Misc') config.set('Misc', 'numtimers', numTimers) config.set('Misc', 'cameralight', cameraLight) config.add_section('TimerState') config.set('TimerState', 'timer1state', timerState[1]) config.set('TimerState', 'timer2state', timerState[2]) config.set('TimerState', 'timer3state', timerState[3]) config.set('TimerState', 'timer4state', timerState[4]) config.set('TimerState', 'timer5state', timerState[5]) config.set('TimerState', 'timer6state', timerState[6]) config.set('TimerState', 'timer7state', timerState[7]) config.set('TimerState', 'timer8state', timerState[8]) config.add_section('TimerRelay') config.set('TimerRelay', 'timer1relay', timerRelay[1]) config.set('TimerRelay', 'timer2relay', timerRelay[2]) config.set('TimerRelay', 'timer3relay', timerRelay[3]) config.set('TimerRelay', 'timer4relay', timerRelay[4]) config.set('TimerRelay', 'timer5relay', timerRelay[5]) config.set('TimerRelay', 'timer6relay', timerRelay[6]) config.set('TimerRelay', 'timer7relay', timerRelay[7]) config.set('TimerRelay', 'timer8relay', timerRelay[8]) config.add_section('TimerDurationOn') config.set('TimerDurationOn', 'timer1durationon', timerDurationOn[1]) config.set('TimerDurationOn', 'timer2durationon', timerDurationOn[2]) config.set('TimerDurationOn', 'timer3durationon', timerDurationOn[3]) config.set('TimerDurationOn', 'timer4durationon', timerDurationOn[4]) config.set('TimerDurationOn', 'timer5durationon', timerDurationOn[5]) config.set('TimerDurationOn', 'timer6durationon', timerDurationOn[6]) config.set('TimerDurationOn', 'timer7durationon', timerDurationOn[7]) config.set('TimerDurationOn', 'timer8durationon', timerDurationOn[8]) config.add_section('TimerDurationOff') config.set('TimerDurationOff', 'timer1durationoff', timerDurationOff[1]) config.set('TimerDurationOff', 'timer2durationoff', timerDurationOff[2]) config.set('TimerDurationOff', 'timer3durationoff', timerDurationOff[3]) config.set('TimerDurationOff', 'timer4durationoff', timerDurationOff[4]) config.set('TimerDurationOff', 'timer5durationoff', timerDurationOff[5]) config.set('TimerDurationOff', 'timer6durationoff', timerDurationOff[6]) config.set('TimerDurationOff', 'timer7durationoff', timerDurationOff[7]) config.set('TimerDurationOff', 'timer8durationoff', timerDurationOff[8]) config.add_section('Notification') config.set('Notification', 'smtp_host', smtp_host) config.set('Notification', 'smtp_port', smtp_port) config.set('Notification', 'smtp_user', smtp_user) config.set('Notification', 'smtp_pass', smtp_pass) config.set('Notification', 'email_from', email_from) config.set('Notification', 'email_to', email_to) try: with open(config_file, 'wb') as configfile: config.write(configfile) except: logging.warning("[Write Config] Unable to write config: %s", config_lock_path) logging.info("[Write Config] Removing lock: %s", lock.path) lock.release()
class MHZ16Sensor(AbstractSensor): """ A sensor support class that monitors the MH-Z16's CO2 concentration """ def __init__(self, interface, device_loc=None, baud_rate=None, i2c_address=None, i2c_bus=None): super(MHZ16Sensor, self).__init__() self.k30_lock_file = None self._co2 = 0 self.interface = interface if self.interface == 'UART': self.logger = logging.getLogger( "mycodo.sensors.mhz16.{dev}".format( dev=device_loc.replace('/', ''))) # Check if device is valid self.serial_device = is_device(device_loc) if self.serial_device: try: self.k30_lock_file = "/var/lock/sen-mhz16-{}".format( device_loc.replace('/', '')) self.lock = LockFile(self.k30_lock_file) self.ser = serial.Serial(self.serial_device, baudrate=baud_rate, timeout=1) except serial.SerialException: self.logger.exception('Opening serial') else: self.logger.error( 'Could not open "{dev}". ' 'Check the device location is correct.'.format( dev=device_loc)) elif self.interface == 'I2C': self.logger = logging.getLogger( "mycodo.sensors.mhz16.{dev}".format(dev=i2c_address)) self.cmd_measure = [ 0xFF, 0x01, 0x9C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63 ] self.IOCONTROL = 0X0E << 3 self.FCR = 0X02 << 3 self.LCR = 0X03 << 3 self.DLL = 0x00 << 3 self.DLH = 0X01 << 3 self.THR = 0X00 << 3 self.RHR = 0x00 << 3 self.TXLVL = 0X08 << 3 self.RXLVL = 0X09 << 3 self.i2c_address = i2c_address self.i2c = smbus.SMBus(i2c_bus) self.begin() def __repr__(self): """ Representation of object """ return "<{cls}(co2={co2})>".format(cls=type(self).__name__, co2="{0:.2f}".format(self._co2)) def __str__(self): """ Return CO2 information """ return "CO2: {co2}".format(co2="{0:.2f}".format(self._co2)) def __iter__(self): # must return an iterator """ MH-Z16 iterates through live CO2 readings """ return self def next(self): """ Get next CO2 reading """ if self.read(): # raised an error raise StopIteration # required return dict(co2=float('{0:.2f}'.format(self._co2))) def info(self): conditions_measured = [("CO2", "co2", "float", "0.00", self._co2, self.co2)] return conditions_measured @property def co2(self): """ CO2 concentration in ppmv """ if not self._co2: # update if needed self.read() return self._co2 def get_measurement(self): """ Gets the MH-Z16's CO2 concentration in ppmv via UART""" self._co2 = None if self.interface == 'UART': self.ser.flushInput() time.sleep(1) self.ser.write("\xff\x01\x86\x00\x00\x00\x00\x00\x79") time.sleep(.01) resp = self.ser.read(9) if len(resp) != 0: high_level = struct.unpack('B', resp[2])[0] low_level = struct.unpack('B', resp[3])[0] co2 = high_level * 256 + low_level return co2 elif self.interface == 'I2C': self.write_register(self.FCR, 0x07) self.send(self.cmd_measure) try: co2 = self.parse(self.receive()) except Exception: co2 = None return co2 return None def read(self): """ Takes a reading from the MH-Z16 and updates the self._co2 value :returns: None on success or 1 on error """ try: if self.interface == 'UART': if not self.serial_device: # Don't measure if device isn't validated return None # Acquire lock on MHZ16 to ensure more than one read isn't # being attempted at once on the same interface while not self.lock.i_am_locking(): try: # wait 60 seconds before breaking lock self.lock.acquire(timeout=60) except Exception as e: self.logger.error( "{cls} 60 second timeout, {lock} lock broken: " "{err}".format(cls=type(self).__name__, lock=self.k30_lock_file, err=e)) self.lock.break_lock() self.lock.acquire() self._co2 = self.get_measurement() self.lock.release() elif self.interface == 'I2C': self._co2 = self.get_measurement() if self._co2 is None: return 1 return # success - no errors except Exception as e: self.logger.error( "{cls} raised an exception when taking a reading: " "{err}".format(cls=type(self).__name__, err=e)) if self.interface == 'UART': self.lock.release() return 1 def begin(self): try: self.write_register(self.IOCONTROL, 0x08) except IOError: pass self.write_register(self.FCR, 0x07) self.write_register(self.LCR, 0x83) self.write_register(self.DLL, 0x60) self.write_register(self.DLH, 0x00) self.write_register(self.LCR, 0x03) @staticmethod def parse(response): checksum = 0 if len(response) < 9: return None for i in range(0, 9): checksum += response[i] if response[0] == 0xFF: if response[1] == 0x9C: if checksum % 256 == 0xFF: return (response[2] << 24) + (response[3] << 16) + ( response[4] << 8) + response[5] return None def read_register(self, reg_addr): time.sleep(0.01) return self.i2c.read_byte_data(self.i2c_address, reg_addr) def write_register(self, reg_addr, val): time.sleep(0.01) self.i2c.write_byte_data(self.i2c_address, reg_addr, val) def send(self, command): if self.read_register(self.TXLVL) >= len(command): self.i2c.write_i2c_block_data(self.i2c_address, self.THR, command) def receive(self): n = 9 buf = [] start = time.clock() while n > 0: rx_level = self.read_register(self.RXLVL) if rx_level > n: rx_level = n buf.extend( self.i2c.read_i2c_block_data(self.i2c_address, self.RHR, rx_level)) n = n - rx_level if time.clock() - start > 0.2: break return buf
def get(self): """Upon request from a manager, picks the first task available and returns it in JSON format. """ # Validate request args = task_generator_parser.parse_args() task_nolocked = None task = None tasks = {} percentage_done = 0 manager_uuid = args['uuid'] job_types = args['job_types'] worker = args['worker'] if manager_uuid: manager = Manager.query.filter_by(uuid=manager_uuid).one() else: ip_address = request.remote_addr manager = Manager.query.filter_by(ip_address=ip_address).first() if not manager: print('Could not find manager, returning 404') return '', 404 # Get active Jobs if job_types: job_types_list = job_types.split(',') job_type_clauses = or_(*[Job.type == j for j in job_types_list]) active_jobs = Job.query \ .filter(job_type_clauses) \ .filter(or_( Job.status == 'waiting', Job.status == 'active')) \ .order_by(Job.priority.desc(), Job.id.asc()) \ .all() else: active_jobs = Job.query \ .filter(or_( Job.status == 'waiting', Job.status == 'active')) \ .order_by(Job.priority.desc(), Job.id.asc()) \ .all() lock = LockFile(os.path.join(app.config['TMP_FOLDER'], 'server.lock')) while not lock.i_am_locking(): try: lock.acquire(timeout=60) # wait up to 60 seconds except LockTimeout: lock.break_lock() lock.acquire() for job in active_jobs: tasks = Task.query.filter( Task.job_id == job.id, or_(Task.status == 'waiting', Task.status == 'canceled'), Task.manager_id == manager.id). \ order_by(Task.priority.desc(), Task.id.desc()) task = None incomplete_parents = False for t in tasks: # All the parents are completed? for tt in tasks: if tt.child_id == t.id and tt.status != 'completed': incomplete_parents = True break # If False skip this task if incomplete_parents: continue task = t break # Task found? Then break if task: break if not task: # Unlocking Task table on ROLLBACK db.session.rollback() lock.release() print('Unlocking Task table on ROLLBACK, returning 404') return '', 404 task.status = 'processing' job.status = 'active' if worker: task.worker = worker task.last_activity = datetime.now() db.session.commit() lock.release() # job = Job.query.get(task.job_id) frame_count = 1 current_frame = 0 percentage_done = Decimal(current_frame) / Decimal(frame_count) * Decimal(100) percentage_done = round(percentage_done, 1) task = { "id": task.id, "job_id": task.job_id, "name": task.name, "status": task.status, "type": task.type, "settings": json.loads(task.settings), "log": None, "activity": task.activity, "manager_id": task.manager_id, "priority": task.priority, "child_id": task.child_id, "parser": task.parser, "time_cost": task.time_cost, "project_id": job.project_id, "current_frame": 0, "percentage_done": percentage_done} return jsonify(**task)
from lockfile import LockFile, LockTimeout import CONSTANTS filename= CONSTANTS.FILE_DIR+"/password.txt" lock = LockFile(filename) #lock.break_lock() print(lock.i_am_locking()) # lock.break_lock() print(lock.is_locked()) # lock.release() lock.acquire() while lock.i_am_locking(): try: print(lock.is_locked()) # wait up to 60 seconds print(lock.i_am_locking()) fb = open(filename, 'r') da = fb.readlines() for d in da[:1000000]: print(d) fb.close() lock.release() except LockTimeout: print("enterd into exception") lock.break_lock() lock.acquire() print(lock.is_locked()) print(lock.i_am_locking()) print("I locked", lock.path) if lock.is_locked(): lock.release()