def generateQueryAndQueryVectorMap(line_tmp):
sentencevector = []
# print "Number of Records Left:\t" + str(corpuscount - tmpcount)
query = line_tmp.lower()
component_word = query.split(' ')
for one_word in component_word:
if redis_handle.exists(one_word):
vector_tmp = redis_handle.get(one_word)
vector_final = normalize_redis_vector(vector_tmp)
sentencevector.append(vector_final)
#indexnum = vocab_dict.get(one_word)
#sentencevector.append((repvector[indexnum]).tolist())
else:
sentencevector.append([float(0)] * vector_size)
l = numpy.array(sentencevector)
# Centroid Calculation - each sentence.
# Sums up all vectors (columns) and generates a final list (1D)of size vector_size
lmt = numpy.array(l.sum(axis=0, dtype=numpy.float32)).tolist()
if (lmt != 0.0):
# Averages the vectors based on the number of words in each sentence.
query_vector = [x / len(component_word) for x in lmt]
else:
query_vector = [float(0)] * vector_size
filename = getRandomOutputFilename()
lock = LockFile(filename)
lock.acquire()
# Open a file handle to the lock file
fh = open(filename, 'w')
fh.write(str(query)+"\t")
for item in query_vector:
fh.write("%s " % str(item))
fh.close()
lock.release()
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 ReadTestCase( resourcefile ) :
list = []
row_index = 0
from lockfile import LockFile
lock = LockFile(resourcefile)
lockid = lock.is_locked()
print lockid
for a in xrange(1, 2):
if lockid == False:
lock.acquire()
print "I have locked Resource File"
break
else:
time.sleep (10)
lockid = lock.is_locked()
rb = open_workbook(resourcefile)
r_sheet = rb.sheet_by_index(0)
wb = copy(rb)
w_sheet = wb.get_sheet(0)
keys = [r_sheet.cell(0, col_index).value for col_index in xrange(r_sheet.ncols)]
j = r_sheet.nrows
q = r_sheet.ncols
print col_index
while row_index < j:
d = {keys[col_index]: r_sheet.cell(row_index, col_index).value for col_index in xrange(r_sheet.ncols)}
temp = ""
if ( d['Execution'] == "yes") :
temp = d['TC Name']
print temp
list.append(temp)
wb.save(resourcefile)
row_index = row_index + 1
lock.release()
return list
def GetPassword( resourcefile , list ) :
count = 0
pwd = []
rb = open_workbook(resourcefile)
r_sheet = rb.sheet_by_index(0)
from lockfile import LockFile
lock = LockFile(resourcefile)
lockid = lock.is_locked()
print lockid
for a in xrange(1, 10):
if lockid == False:
lock.acquire()
print "I have locked Resource File"
break
else:
time.sleep (10)
lockid = lock.is_locked()
wb = copy(rb)
w_sheet = wb.get_sheet(0)
keys = [r_sheet.cell(0, col_index).value for col_index in xrange(r_sheet.ncols)]
for row_index in xrange(1, r_sheet.nrows):
d = {keys[col_index]: r_sheet.cell(row_index, col_index).value
for col_index in xrange(r_sheet.ncols)}
if ( d['IP'] in list) :
count = count + 1
pwd = d['Password']
wb.save(resourcefile)
lock.release()
if(count == len(list)+1) :
break
return pwd
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 get_auth_token(use_client_file=True, **kwargs):
current_node = utils.get_node_or_source_node()
if use_client_file:
current_instance = utils.get_instance_or_source_instance()
if constants.AUTH_TOKEN_VALUE in current_instance.runtime_properties:
token = current_instance.runtime_properties[constants.AUTH_TOKEN_VALUE]
if constants.AUTH_TOKEN_EXPIRY in current_instance.runtime_properties:
token_expires = current_instance.runtime_properties[constants.AUTH_TOKEN_EXPIRY]
else:
token_expires = 0
else:
token = None
token_expires = 0
if os.path.isfile(constants.default_path_to_local_azure_token_file):
token, token_expires = _generate_token_if_expired(constants.default_path_to_local_azure_token_file,
token, token_expires)
return token
try:
config_path = current_node.properties.get(constants.path_to_azure_conf_key) or constants.default_path_to_azure_conf
lock = LockFile(config_path)
lock.acquire()
token, token_expires = _get_token_from_file(config_path)
except:
err_message = "Failures while locking or using {}".format(config_path)
ctx.logger.debug(err_message)
lock.release()
raise NonRecoverableError(err_message)
token, token_expires = _generate_token_if_expired(config_path, token, token_expires)
lock.release()
return token
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 IoOperat_multi(tmpfile, mode, statisticArr, chunker):
# tmpfile = "value_" + md5 + ".dat"
with open(tmpfile, "rb") as f:
fields = pickle.load(f)
samples = pickle.load(f)
headers = pickle.load(f)
filepath_json = pickle.load(f)
recordstring, infonum, infoSpecial = chunker2string(
chunker, fields, samples, mode)
if sys.platform.startswith('linux'):
with open(filepath_json, "a") as fp:
fcntl.flock(fp.fileno(), fcntl.LOCK_EX)
statisticArr[0] += chunker[1]
statisticArr[1] += infonum
statisticArr[2] += infoSpecial
fp.write(recordstring)
else:
lock = LockFile(filepath_json)
lock.acquire()
with open(filepath_json, "a") as fp:
statisticArr[0] += chunker[1]
statisticArr[1] += infonum
statisticArr[2] += infoSpecial
fp.write(recordstring)
lock.release()
return
def addScanResult( self,\
scanResult,\
ADD_MODE = NEW_SCAN_RESULT ):
lock = LockFile(self.m_TokenFileName)
#ОБРАБОТКА НЕВОЗМОЖНОСТИ ДОЖДАТЬСЯ РАЗБЛОКИРОВАНИЯ ФАЙЛА
lock.acquire(SECONDS_WAIT_FOR_UNLOCK)
f = open(self.m_TokenFileName,\
'r+')
listScanResult = self.loadScanResults(f)
idToken = 0
if (ADD_MODE == TO_EXIST_SCAN_RESULT):
listScanResult.setScanResultByIdToken(scanResult)
else:
idToken = listScanResult.addScanResult(scanResult)
f.seek(0)
f.write(listScanResult.toJSON())
f.close()
lock.release()
return idToken
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 generateQueryAndQueryVectorMap(line_tmp):
sentencevector = []
# print "Number of Records Left:\t" + str(corpuscount - tmpcount)
query = line_tmp.lower()
component_word = query.split(' ')
for one_word in component_word:
if redis_handle.exists(one_word):
vector_tmp = redis_handle.get(one_word)
vector_final = normalize_redis_vector(vector_tmp)
sentencevector.append(vector_final)
#indexnum = vocab_dict.get(one_word)
#sentencevector.append((repvector[indexnum]).tolist())
else:
sentencevector.append([float(0)] * vector_size)
l = numpy.array(sentencevector)
# Centroid Calculation - each sentence.
# Sums up all vectors (columns) and generates a final list (1D)of size vector_size
lmt = numpy.array(l.sum(axis=0, dtype=numpy.float32)).tolist()
if (lmt != 0.0):
# Averages the vectors based on the number of words in each sentence.
query_vector = [x / len(component_word) for x in lmt]
else:
query_vector = [float(0)] * vector_size
filename = getRandomOutputFilename()
lock = LockFile(filename)
lock.acquire()
# Open a file handle to the lock file
fh = open(filename, 'w')
fh.write(str(query) + "\t")
for item in query_vector:
fh.write("%s " % str(item))
fh.close()
lock.release()
def write_dsn(self, wdmpath, dsn, data):
"""Write to self.wdmfp/dsn the time-series data."""
dsn_desc = self.describe_dsn(wdmpath, dsn)
tcode = dsn_desc['tcode']
tstep = dsn_desc['tstep']
tsfill = dsn_desc['tsfill']
data.fillna(tsfill, inplace=True)
start_date = data.index[0]
dstart_date = start_date.timetuple()[:6]
llsdat = self._tcode_date(tcode, dstart_date)
if dsn_desc['base_year'] > llsdat[0]:
raise ValueError("""
*
* The base year for this DSN is {0}. All data to insert must be after the
* base year. Instead the first year of the series is {1}.
*
""".format(dsn_desc['base_year'], llsdat[0]))
nval = len(data)
lock = LockFile(wdmpath)
lock.acquire()
wdmfp = self._open(wdmpath, 58)
retcode = self.wdtput(wdmfp, dsn, tstep, llsdat, nval, 1, 0, tcode,
data)
lock.release()
self._close(wdmpath)
self._retcode_check(retcode, additional_info='wdtput')
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 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 log_output(self, status_str, target, meas, x_opt, Xtrue, r, m, t1, t2,
t3, mem_used, A, y):
# write output to a file
# we should use a different file for each trial and then just do
# a "reduce". This way any individual task isn't too long
try:
lock = LockFile(self.filename)
except:
raise "Could not open file"
tol = 1e-2
err0 = 0
err1 = np.linalg.norm(Xtrue - x_opt, 'fro') / np.linalg.norm(Xtrue)
# if (m > 25):
# temp = Xtrue - x_opt
# scipy.io.savemat('out.mat', mdict={'true': Xtrue, 'opt' : x_opt, 'A':A, 'y':y})
# print temp
# exit(0)
if err1 > tol:
err0 = 1
lock.acquire()
with open(self.filename, 'a') as my_file:
try:
date_str = datetime.datetime.now().strftime("%b-%d-%I:%M%p")
my_file.write(
self.formatstring %
(date_str, status_str, common.TARGET_NAMES[target],
common.ENSEMBLE_NAMES[meas], self.n, r, m, err1, err0, t1,
t2, t3, mem_used))
except:
print "Could not open file!"
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 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 save_Y(pos, move, text_count):
log_move = "Y:{}:{}".format(pos.get_board_piece(move[0]), render(119-move[1]))
lock = LockFile("log_Y.txt")
lock.acquire()
with open("log_Y.txt", "a") as log_Y:
log_Y.write(str(text_count) + " " + log_move + "\n")
lock.release()
def get( arquivo ):
lock = LockFile(arquivo) # abrir chamada com LockFile
lock.acquire() # bloquear arquivo
if( isEmpty(arquivo) ): # verifica se arquivo de entrada esta vazio
return
arq = open(arquivo, 'r') # abre arquivo no modo leitura
firstLine = arq.readline() # le e excluir a primeira linha do arquivo
linhas = arq.read() # le arquivo todo
arq.close() # fecha arquivo
# Gravando elementos no arquivo sem a primeira linha
arq = open(arquivo, 'w')
arq.writelines(linhas)
arq.close()
lock.release() # desbloquear arquivo
runn = 'data/running.txt'
lock = LockFile(runn) # abrir chamada de arquivo running com LockFile
lock.acquire() # bloquear arquivo
arq = open(runn, 'a')
arq.write(firstLine)
arq.close()
lock.release() # desbloquear arquivo
return firstLine
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 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 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 store(email,nickname,number,rate,strs,regressions):
# User-entered data hits the filesystem here.
if not validate_email(email):
return
newcontrib = [ bleach.clean(email),
bleach.clean(nickname),
bleach.clean(number),
bleach.clean(rate),
bleach.clean(strs),
bleach.clean(regressions)]
lock = LockFile("/var/local/bz-triage/contributors.cfg")
lock.acquire()
try:
contributors = json.load(open("/var/local/bz-triage/contributors.cfg"))
except:
logging.info("Failed to open the file...")
contributors = list()
for existing in contributors:
if existing[0] == newcontrib[0]:
contributors.remove(existing)
contributors.append( newcontrib )
with open("/var/local/bz-triage/contributors.cfg", 'w') as outfile:
json.dump(contributors, outfile)
lock.release()
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_target_runtime_properties_to_file(required_keys, prefixed_keys=None, need_suffix=None):
try:
current_runtime_folder = constants.default_path_to_runtime_folder
current_instance_key = "{0}{1}".format(ctx.source.node.id, ctx.source.instance.id)
current_runtime_file_path = "{0}{1}".format(current_runtime_folder, current_instance_key)
ctx.logger.info("current_runtime_file_path is {0}".format(current_runtime_file_path))
lock = LockFile(current_runtime_file_path)
lock.acquire()
ctx.logger.info("{} is locked".format(lock.path))
with open(current_runtime_file_path, 'a') as f:
for curr_runtime_property in ctx.target.instance.runtime_properties:
orig_runtime_property = curr_runtime_property
if required_keys and curr_runtime_property in required_keys:
if need_suffix and (curr_runtime_property in need_suffix):
curr_runtime_property = "{0}{1}{2}".format(curr_runtime_property, ctx.source.node.id, ctx.source.instance.id)
ctx.logger.info("curr_runtime_property is {0}".format(curr_runtime_property))
current_line = "{0}={1}\n".format(curr_runtime_property, ctx.target.instance.runtime_properties[orig_runtime_property])
f.write(current_line)
else:
if prefixed_keys is not None:
for curr_prefixed_key in prefixed_keys:
if curr_runtime_property.startswith(curr_prefixed_key):
current_line = "{0}={1}\n".format(curr_runtime_property, ctx.target.instance.runtime_properties[curr_runtime_property])
f.write(current_line)
f.close()
except:
ctx.logger.info("Failures while locking or using {}".format(current_runtime_file_path))
lock.release()
raise NonRecoverableError("Failures while locking or using {}".format(current_runtime_file_path))
lock.release()
ctx.logger.info("{} is released".format(current_runtime_file_path))
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 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 addScanResult( self,\
scanResult,\
ADD_MODE = NEW_SCAN_RESULT ):
lock = LockFile(self.m_TokenFileName)
#ОБРАБОТКА НЕВОЗМОЖНОСТИ ДОЖДАТЬСЯ РАЗБЛОКИРОВАНИЯ ФАЙЛА
lock.acquire( SECONDS_WAIT_FOR_UNLOCK )
f = open(self.m_TokenFileName,\
'r+')
listScanResult = self.loadScanResults( f )
idToken = 0
if ( ADD_MODE == TO_EXIST_SCAN_RESULT ):
listScanResult.setScanResultByIdToken( scanResult )
else:
idToken = listScanResult.addScanResult( scanResult )
f.seek(0)
f.write( listScanResult.toJSON() )
f.close()
lock.release()
return idToken
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
def write(self, path):
"""Writes the PlPlugMapM contents to a file."""
try:
from lockfile import LockFile
useLockFile = True
except:
useLockFile = False
if useLockFile:
# Get locked file
lock = LockFile(path)
if not lock.is_locked():
# Write plugmap file
lock.acquire()
ff = open(path, 'w')
ff.write(self.data._contents)
ff.close()
lock.release()
else:
raise PlPlugMapMFileException(
'path {0} is locked'.format(path))
else:
ff = open(path, 'w')
ff.write(self.data._contents)
ff.close()
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 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 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 __setitem__(self, key, item):
saved = False
try:
saved = self._save(os.path.join(self._path, key), item)
except:
saved = False
if not saved:
return
lock = LockFile(self._lock_filename)
lock.acquire()
try:
with open(self._index_filename, "r") as f:
index = json.load(f)
except:
index = dict()
index[key] = type(item).__name__
with open(self._index_filename, "w") as f:
json.dump(index, f, indent=4)
lock.release()
def on_post(self, req, resp, id):
try:
user = req.context['user']
# Kontrola existence ulohy
task = session.query(model.Task).get(id)
if task is None:
req.context['result'] = 'Neexistujici uloha'
resp.status = falcon.HTTP_404
return
# Kontrola existence git_branch a git_path
if (task.git_path is None) or (task.git_branch is None):
req.context['result'] = 'Uloha nema zadanou gitovskou vetev nebo adresar'
resp.status = falcon.HTTP_400
return
if task.git_branch == "master":
req.context['result'] = 'Uloha je j*z ve vetvi master'
resp.status = falcon.HTTP_400
return
wave = session.query(model.Wave).get(task.wave)
# Merge mohou provadet pouze administratori a garant vlny
if (not user.is_logged_in()) or ((not user.is_admin()) and (user.id != wave.garant)):
req.context['result'] = 'Nedostatecna opravneni'
resp.status = falcon.HTTP_400
return
# Kontrola zamku
lock = util.lock.git_locked()
if lock:
req.context['result'] = 'GIT uzamcen zámkem '+lock + "\nNekdo momentalne provadi akci s gitem, opakujte prosim akci za 20 sekund."
resp.status = falcon.HTTP_409
return
try:
mergeLock = LockFile(util.admin.taskMerge.LOCKFILE)
mergeLock.acquire(60) # Timeout zamku je 1 minuta
# Fetch repozitare
repo = git.Repo(util.git.GIT_SEMINAR_PATH)
if task.git_branch in repo.heads:
# Cannot delete branch we are on
repo.git.checkout("master")
repo.git.branch('-D', task.git_branch)
task.git_branch = 'master'
session.commit()
resp.status = falcon.HTTP_200
finally:
mergeLock.release()
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def locked_cache_dir(config, cache_key, timeout=900, tag=None):
if LockFile is DummyLock:
cache_key = cache_key + os.environ.get('PYTEST_XDIST_WORKER', '')
base_dir = config.cache.makedir(cache_key)
lockfile = join(six.text_type(base_dir), 'lock')
cache_dir = join(six.text_type(base_dir), 'cache')
lock = LockFile(lockfile)
lock.acquire(timeout=timeout)
try:
# Clear cache dir contents if it was generated with different
# asv version
tag_fn = join(six.text_type(base_dir), 'tag.json')
tag_content = [asv.__version__, repr(tag)]
if os.path.isdir(cache_dir):
try:
if util.load_json(tag_fn) != tag_content:
raise ValueError()
except (IOError, ValueError, util.UserError):
shutil.rmtree(cache_dir)
if not os.path.isdir(cache_dir):
os.makedirs(cache_dir)
yield cache_dir
util.write_json(tag_fn, tag_content)
finally:
lock.release()
def locked_cache_dir(config, cache_key, timeout=900, tag=None):
if LockFile is DummyLock:
cache_key = cache_key + os.environ.get('PYTEST_XDIST_WORKER', '')
base_dir = config.cache.makedir(cache_key)
lockfile = join(six.text_type(base_dir), 'lock')
cache_dir = join(six.text_type(base_dir), 'cache')
lock = LockFile(lockfile)
lock.acquire(timeout=timeout)
try:
# Clear cache dir contents if it was generated with different
# asv version
tag_fn = join(six.text_type(base_dir), 'tag.json')
tag_content = [asv.__version__, repr(tag)]
if os.path.isdir(cache_dir):
try:
if util.load_json(tag_fn) != tag_content:
raise ValueError()
except (IOError, ValueError, util.UserError):
shutil.rmtree(cache_dir)
if not os.path.isdir(cache_dir):
os.makedirs(cache_dir)
yield cache_dir
util.write_json(tag_fn, tag_content)
finally:
lock.release()
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 dumpTasks(filename, tasklist):
lock = LockFile(LOCK_FILE)
lock.acquire()
with open(filename, 'w') as f:
f.write("[\n ")
f.write(",\n ".join(json.dumps(task) for task in tasklist))
f.write("\n]\n")
lock.release()
def on_post(self, req, resp, id):
try:
user = req.context['user']
if (not user.is_logged_in()) or (not user.is_org()):
resp.status = falcon.HTTP_400
return
# Kontrola zamku
lock = util.lock.git_locked()
if lock:
req.context['result'] = ('GIT uzamcen zamkem ' + lock +
'\nNekdo momentalne provadi akci s '
'gitem, opakujte prosim akci za 20 '
'sekund.')
resp.status = falcon.HTTP_409
return
pullLock = LockFile(util.admin.waveDiff.LOCKFILE)
pullLock.acquire(60) # Timeout zamku je 1 minuta
# Fetch
repo = git.Repo(util.git.GIT_SEMINAR_PATH)
repo.remotes.origin.fetch()
# Ulohy ve vlne
tasks = session.query(model.Task).\
filter(model.Task.wave == id).all()
# Diffujeme adresare uloh task.git_commit oproti HEAD
for task in tasks:
if ((not task.git_branch) or (not task.git_path)
or (not task.git_commit)):
task.deploy_status = 'default'
continue
# Checkout && pull vetve ve ktere je uloha
repo.git.checkout(task.git_branch)
repo.remotes.origin.pull()
# Kontrola existence adresare ulohy
if os.path.isdir(util.git.GIT_SEMINAR_PATH + task.git_path):
hcommit = repo.head.commit
diff = hcommit.diff(task.git_commit, paths=[task.git_path])
if len(diff) > 0:
task.deploy_status = 'diff'
else:
task.deploy_status = 'default'
session.commit()
req.context['result'] = {}
except SQLAlchemyError:
session.rollback()
req.context['result'] = 'Nastala vyjimka backendu'
raise
finally:
pullLock.release()
session.close()
def get_auth_token(use_client_file=True, **kwargs):
ctx.logger.info("In auth.get_auth_token")
if use_client_file:
if constants.AUTH_TOKEN_VALUE in ctx.instance.runtime_properties:
# If you are here , it means that this is during bootstrap
ctx.logger.info("In auth.get_auth_token returning token from runtime props")
ctx.logger.info("In auth.get_auth_token token from runtime props is:{}".format(ctx.instance.runtime_properties[constants.AUTH_TOKEN_VALUE]))
return ctx.instance.runtime_properties[constants.AUTH_TOKEN_VALUE]
# Check if token file exists on the client's VM. If so, take the value from it and set it in the runtime
ctx.logger.info("In auth.get_auth_token checking local azure file path {}".format(constants.path_to_local_azure_token_file))
if os.path.isfile(constants.path_to_local_azure_token_file):
# If you are here , it means that this is during bootstrap
ctx.logger.info("{} exists".format(constants.path_to_local_azure_token_file))
token, token_expires = get_token_from_client_file()
ctx.logger.info("get_auth_token expiry is {} ".format(token_expires))
ctx.instance.runtime_properties[constants.AUTH_TOKEN_VALUE] = token
ctx.instance.runtime_properties[constants.AUTH_TOKEN_EXPIRY] = token_expires
ctx.logger.info("get_auth_token token1 is {} ".format(token))
return token
# From here, this is not during bootstrap, which also means that this code runs on the manager's VM.
try:
ctx.logger.info("In auth.get_auth_token b4 locking {}".format(constants.path_to_azure_conf))
lock = LockFile(constants.path_to_azure_conf)
lock.acquire()
ctx.logger.info("{} is locked".format(lock.path))
with open(constants.path_to_azure_conf, 'r') as f:
json_data = json.load(f)
token_expires = json_data["token_expires"]
token = json_data["auth_token"]
ctx.logger.info("get_auth_token token2 is {} ".format(token))
except:
raise NonRecoverableError("Failures while locking or using {}".format(constants.path_to_azure_conf))
ctx.logger.info("In auth.get_auth_token b4 timestamp")
timestamp = int(time.time())
ctx.logger.info("In auth.get_auth_token timestamp is {}".format(timestamp))
ctx.logger.info("In auth.get_auth_token token_expires1 is {}".format(token_expires))
token_expires = int(token_expires)
ctx.logger.info("In auth.get_auth_token token_expires2 is {}".format(token_expires))
if token_expires-timestamp <= 600 or token_expires == 0 or token is None or token == "":
ctx.logger.info("In auth.get_auth_token token_expires-timestamp {}".format(token_expires-timestamp))
endpoints, payload = _get_payload_endpoints()
token, token_expires = _get_token_value_expiry(endpoints, payload)
ctx.logger.info("get_auth_token token3 is {} ".format(token))
ctx.logger.info("In auth.get_auth_token b4 opening {}".format(constants.path_to_azure_conf))
with open(constants.path_to_azure_conf, 'r+') as f:
json_data = json.load(f)
json_data["auth_token"] = token
json_data["token_expires"] = token_expires
f.seek(0)
f.write(json.dumps(json_data))
f.close()
lock.release()
ctx.logger.info("{} is released".format(lock.path))
ctx.logger.info("get_auth_token token4 is {} ".format(token))
return token
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()
def on_post(self, req, resp, id):
try:
user = req.context['user']
# Kontrola opravneni
if (not user.is_logged_in()) or (not user.is_org()):
req.context['result'] = 'Nedostatecna opravneni'
resp.status = falcon.HTTP_400
return
# Kontrola existence ulohy
task = session.query(model.Task).get(id)
if task is None:
req.context['result'] = 'Neexistujici uloha'
resp.status = falcon.HTTP_404
return
# Zverejnene ulohy mohou deployovat pouze admini
wave = session.query(model.Wave).get(task.wave)
if (datetime.datetime.utcnow() > wave.time_published) and (not user.is_admin()):
req.context['result'] = 'Po zverejneni ulohy muze deploy provest pouze administrator'
resp.status = falcon.HTTP_404
return
# Kontrola existence gitovske vetve a adresare v databazi
if (task.git_branch is None) or (task.git_path is None):
req.context['result'] = 'Uloha nema zadanou gitovskou vetev nebo adresar'
resp.status = falcon.HTTP_400
return
# Kontrola zamku
lock = util.lock.git_locked()
if lock:
req.context['result'] = 'GIT uzamcen zamkem ' + lock + "\nNekdo momentalne provadi akci s gitem, opakujte prosim akci za 20 sekund."
resp.status = falcon.HTTP_409
return
# Stav na deploying je potreba nastavit v tomto vlakne
task.deploy_status = 'deploying'
session.commit()
try:
deployLock = LockFile(util.admin.taskDeploy.LOCKFILE)
deployLock.acquire(60) # Timeout zamku je 1 minuta
deployThread = threading.Thread(target=util.admin.taskDeploy.deploy, args=(task.id, deployLock, scoped_session(_session)), kwargs={})
deployThread.start()
finally:
deployLock.release()
resp.status = falcon.HTTP_200
except SQLAlchemyError:
session.rollback()
raise
finally:
session.close()
def pre_process(self, params):
"""
Converts the files
First pass is to create striped tiff using kakadu if available
and second pass is to convert to tiled tiff.
A third file path is used for lock, if the lock can be acquired
and the output is not ready then create it. If the lock cannot
be acquired then perhaps other process is processing it.
TODO: Decide when to declare not possible ?
"""
# Split the requested filename
dirname, filename = os.path.split(params["fname"])
_, ext = os.path.splitext(filename)
# assert that ext is as expected
assert ext in [".jp2", ".j2k"]
output1 = os.path.join(dirname, filename + "_striped.tif")
output2 = os.path.join(dirname, filename + "_tiled.tif")
lock_path = os.path.join(dirname, filename + ".lock")
lock = LockFile(lock_path)
# logger.info('waiting for lock')
lock.acquire()
# If the file is missing then create it
if not os.path.exists(output2):
# Make sure the processing lock can be acquired
logger.info('processing')
logger.info('# Convert to striped tiff')
if self.kakadu_dir is None:
params = ["gdal_translate", params["fname"], output1]
subprocess.call(params)
else:
# Additional LD_LIBRARY_PATH
environ = os.environ.copy()
if "LD_LIBRARY_PATH" not in environ:
environ["LD_LIBRARY_PATH"] = ""
environ["LD_LIBRARY_PATH"] = self.kakadu_dir + ":" + environ["LD_LIBRARY_PATH"]
params = [os.path.join(self.kakadu_dir, "kdu_expand"), "-i", params["fname"], "-o", output1]
subprocess.call(params, env=environ)
logger.info('# Convert to tiled tiff')
params = ["gdal_translate", "-co", "TILED=YES", "-co", "COMPRESS=JPEG", output1, output2]
subprocess.call(params)
# Then remove output1
os.remove(output1)
lock.release()
return output2
def _download_rpm(self, nvr, arch):
if nvr is None or arch is None:
raise ValueError("Invalid option passed to connector")
filename = '%s.%s.rpm' % (nvr, arch)
file_path = os.path.split(filename)
if file_path[0] != '':
raise ValueError("Nvr can not contain path elements")
if len(arch.split('/')) != 1 or os.path.split(arch)[0] != '':
raise ValueError("Arch can not contain path elements")
rpm_file_path = os.path.join(self._rpm_cache, filename)
if os.path.exists(rpm_file_path):
return rpm_file_path
lockfile = LockFile(file_path)
if lockfile.is_locked():
# block until the lock is released and then assume other
# thread was successful
lockfile.acquire()
lockfile.release()
return rpm_file_path
# acquire the lock and release when done
lockfile.acquire()
try:
info = self.call('getBuild', {'buildInfo': nvr})
if info is None:
return {'error': 'No such build (%s)' % filename}
if not os.path.exists(self._rpm_cache):
os.mkdir(self._rpm_cache, )
url = '%s/%s/%s/%s/%s/%s' % (self._koji_pkg_url, info['name'],
info['version'], info['release'],
arch, filename)
url_file = grabber.urlopen(url, text=filename)
out = os.open(rpm_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
0666)
try:
while 1:
buf = url_file.read(4096)
if not buf:
break
os.write(out, buf)
except Exception as e:
raise e
finally:
os.close(out)
url_file.close()
finally:
lockfile.release()
return rpm_file_path
def _download_rpm(self, nvr, arch):
if nvr is None or arch is None:
raise ValueError("Invalid option passed to connector")
filename = '%s.%s.rpm' % (nvr, arch)
file_path = os.path.split(filename)
if file_path[0] != '':
raise ValueError("Nvr can not contain path elements")
if len(arch.split('/')) != 1 or os.path.split(arch)[0] != '':
raise ValueError("Arch can not contain path elements")
rpm_file_path = os.path.join(self._rpm_cache, filename)
if os.path.exists(rpm_file_path):
return rpm_file_path
lockfile = LockFile(file_path)
if lockfile.is_locked():
# block until the lock is released and then assume other
# thread was successful
lockfile.acquire()
lockfile.release()
return rpm_file_path
# acquire the lock and release when done
lockfile.acquire()
try:
info = self.call('getBuild', {'buildInfo': nvr})
if info is None:
return {'error': 'No such build (%s)' % filename}
if not os.path.exists(self._rpm_cache):
os.mkdir(self._rpm_cache,)
url = '%s/%s/%s/%s/%s/%s' % (
self._koji_pkg_url, info['name'], info['version'],
info['release'], arch, filename)
url_file = grabber.urlopen(url, text=filename)
out = os.open(
rpm_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0666)
try:
while 1:
buf = url_file.read(4096)
if not buf:
break
os.write(out, buf)
except Exception as e:
raise e
finally:
os.close(out)
url_file.close()
finally:
lockfile.release()
return rpm_file_path
def loadTasks(filename): lock = LockFile(LOCK_FILE) lock.acquire() with open(filename) as f: content = f.read() if len(content.strip()) == 0: ret = [] else: ret = json.loads(content) lock.release() return ret
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 State(object):
def __init__(self, path=None, lock=False):
self.path = path
self.lock = lock
if not self.path:
self.path = join(util.get_home_dir(), "appstate.json")
self._state = {}
self._prev_state = {}
self._lockfile = None
def __enter__(self):
try:
self._lock_state_file()
if isfile(self.path):
self._state = util.load_json(self.path)
except ValueError:
self._state = {}
self._prev_state = deepcopy(self._state)
return self._state
def __exit__(self, type_, value, traceback):
if self._prev_state != self._state:
with open(self.path, "w") as fp:
if "dev" in __version__:
json.dump(self._state, fp, indent=4)
else:
json.dump(self._state, fp)
self._unlock_state_file()
def _lock_state_file(self):
if not self.lock:
return
self._lockfile = LockFile(self.path)
if self._lockfile.is_locked() and \
(time() - getmtime(self._lockfile.lock_file)) > 10:
self._lockfile.break_lock()
try:
self._lockfile.acquire()
except LockFailed:
raise exception.PlatformioException(
"The directory `{0}` or its parent directory is not owned by "
"the current user and PlatformIO can not store configuration "
"data. \nPlease check the permissions and owner of that "
"directory. Otherwise, please remove manually `{0}` "
"directory and PlatformIO will create new from the current "
"user.".format(dirname(self.path)))
def _unlock_state_file(self):
if self._lockfile:
self._lockfile.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)
def renumber_dsn(self, wdmpath, odsn, ndsn):
"""Will renumber the odsn to the ndsn."""
odsn = int(odsn)
ndsn = int(ndsn)
lock = LockFile(wdmpath)
lock.acquire()
wdmfp = self._open(wdmpath, 51)
retcode = self.wddsrn(wdmfp, odsn, ndsn)
lock.release()
self._close(wdmpath)
self._retcode_check(retcode, additional_info='wddsrn')
class State(object):
def __init__(self, path=None, lock=False):
self.path = path
self.lock = lock
if not self.path:
self.path = join(util.get_home_dir(), "appstate.json")
self._state = {}
self._prev_state = {}
self._lockfile = None
def __enter__(self):
try:
self._lock_state_file()
if isfile(self.path):
self._state = util.load_json(self.path)
except exception.PlatformioException:
self._state = {}
self._prev_state = deepcopy(self._state)
return self._state
def __exit__(self, type_, value, traceback):
if self._prev_state != self._state:
with open(self.path, "w") as fp:
if "dev" in __version__:
json.dump(self._state, fp, indent=4)
else:
json.dump(self._state, fp)
self._unlock_state_file()
def _lock_state_file(self):
if not self.lock:
return
self._lockfile = LockFile(self.path)
if self._lockfile.is_locked() and \
(time() - getmtime(self._lockfile.lock_file)) > 10:
self._lockfile.break_lock()
try:
self._lockfile.acquire()
except LockFailed:
raise exception.PlatformioException(
"The directory `{0}` or its parent directory is not owned by "
"the current user and PlatformIO can not store configuration "
"data. \nPlease check the permissions and owner of that "
"directory. Otherwise, please remove manually `{0}` "
"directory and PlatformIO will create new from the current "
"user.".format(dirname(self.path)))
def _unlock_state_file(self):
if self._lockfile:
self._lockfile.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
