def version_comparable(self, executable):
''' Returns the detected comparable version given executable '''
self.lock.acquire()
try:
if executable in self._info and self._info[executable] is not None:
return '%03d%03d%03d' %(int(self._info[executable]['version_major']), \
int(self._info[executable]['version_minor']), \
int(self._info[executable]['version_patch']))
return None
finally:
self.lock.release()
def version_comparable(self, executable):
""" Returns the detected comparable version given executable """
self.lock.acquire()
try:
if executable in self._info and self._info[
executable] is not None:
return "%03d%03d%03d" % (
int(self._info[executable]["version_major"]),
int(self._info[executable]["version_minor"]),
int(self._info[executable]["version_patch"]),
)
return None
finally:
self.lock.release()
def get_filters(self):
filters = self.DEFAULT_FILTERS.copy()
filter_field = self.table.get_filter_field()
filter_string = self.table.get_filter_string()
filter_action = self.table._meta._filter_action
if filter_field and filter_string and (
filter_action.is_api_filter(filter_field)):
if filter_field in ['size_min', 'size_max']:
invalid_msg = ('API query is not valid and is ignored: '
'%(field)s=%(string)s')
try:
filter_string = builtins.int(
float(filter_string) * (units.Mi))
if filter_string >= 0:
filters[filter_field] = filter_string
else:
LOG.warning(invalid_msg, {
'field': filter_field,
'string': filter_string
})
except ValueError:
LOG.warning(invalid_msg, {
'field': filter_field,
'string': filter_string
})
elif (filter_field == 'disk_format'
and filter_string.lower() == 'docker'):
filters['disk_format'] = 'raw'
filters['container_format'] = 'docker'
else:
filters[filter_field] = filter_string
return filters
def get_filters(self):
filters = self.DEFAULT_FILTERS.copy()
filter_field = self.table.get_filter_field()
filter_string = self.table.get_filter_string()
filter_action = self.table._meta._filter_action
if filter_field and filter_string and (
filter_action.is_api_filter(filter_field)):
if filter_field in ['size_min', 'size_max']:
invalid_msg = ('API query is not valid and is ignored: '
'%(field)s=%(string)s')
try:
filter_string = builtins.int(float(filter_string) *
(units.Mi))
if filter_string >= 0:
filters[filter_field] = filter_string
else:
LOG.warning(invalid_msg,
{'field': filter_field,
'string': filter_string})
except ValueError:
LOG.warning(invalid_msg,
{'field': filter_field,
'string': filter_string})
elif (filter_field == 'disk_format' and
filter_string.lower() == 'docker'):
filters['disk_format'] = 'raw'
filters['container_format'] = 'docker'
else:
filters[filter_field] = filter_string
return filters
def isodate(now=int(time.time()), utc=False, short=False):
"""
This function converts seconds since epoch into ISO 8601 timestamp
"""
if utc:
my_time_u = time.gmtime(now)
if short:
return time.strftime("%Y%m%dT%H%M%SZ", my_time_u)
else:
return time.strftime("%Y-%m-%dT%H:%M:%SZ", my_time_u)
else:
my_time_l = time.localtime(now)
my_offset = int(calendar.timegm(my_time_l) - time.mktime(my_time_l))
offset = "%+03d%02d" % (my_offset / 3600, (abs(my_offset) % 3600) / 60)
if short:
return time.strftime("%Y%m%dT%H%M%S", my_time_l) + offset
else:
return time.strftime("%Y-%m-%dT%H:%M:%S", my_time_l) + offset
def isodate(now=int(time.time()), utc=False, short=False):
"""
This function converts seconds since epoch into ISO 8601 timestamp
"""
if utc:
my_time_u = time.gmtime(now)
if short:
return time.strftime("%Y%m%dT%H%M%SZ", my_time_u)
else:
return time.strftime("%Y-%m-%dT%H:%M:%SZ", my_time_u)
else:
my_time_l = time.localtime(now)
my_offset = int(calendar.timegm(my_time_l) - time.mktime(my_time_l))
offset = "%+03d%02d" % (my_offset / 3600, (abs(my_offset) % 3600) / 60)
if short:
return time.strftime("%Y%m%dT%H%M%S", my_time_l) + offset
else:
return time.strftime("%Y-%m-%dT%H:%M:%S", my_time_l) + offset
def make_boolean(value):
# purpose: convert an input string into something boolean
# paramtr: $x (IN): a property value
# returns: 0 (false) or 1 (true)
my_val = str(value)
if (my_val.lower() == "true" or my_val.lower() == "on"
or my_val.lower() == "yes" or my_val.isdigit() and int(value) > 0):
return 1
return 0
def adjust_type(data_type, value):
if not value:
return value
if data_type == "float":
new_value = float(value)
elif data_type == "long":
new_value = builtins.int(value)
elif data_type == "integer":
new_value = int(value)
else:
new_value = value
return new_value
def write_pid_file(pid_filename, ts=int(time.time())):
"""
This function writes a pid file with name 'filename' containing
the current pid and timestamp.
"""
try:
PIDFILE = open(pid_filename, "w")
PIDFILE.write("pid %s\n" % (os.getpid()))
PIDFILE.write("timestamp %s\n" % (isodate(ts)))
except IOError:
logger.error("cannot write PID file %s" % (pid_filename))
else:
PIDFILE.close()
def write_pid_file(pid_filename, ts=int(time.time())):
"""
This function writes a pid file with name 'filename' containing
the current pid and timestamp.
"""
try:
PIDFILE = open(pid_filename, "w")
PIDFILE.write("pid %s\n" % (os.getpid()))
PIDFILE.write("timestamp %s\n" % (isodate(ts)))
except IOError:
logger.error("cannot write PID file %s" % (pid_filename))
else:
PIDFILE.close()
def epochdate(timestamp):
"""
This function converts an ISO timestamp into seconds since epoch
"""
try:
# Split date/time and timezone information
m = parse_iso8601.search(timestamp)
if m is None:
logger.warn('unable to match "%s" to ISO 8601' % timestamp)
return None
else:
dt = "%04d-%02d-%02d %02d:%02d:%02d" % (
int(m.group(1)),
int(m.group(2)),
int(m.group(3)),
int(m.group(4)),
int(m.group(5)),
int(m.group(6)),
)
tz = m.group(8)
# my_time = datetime.datetime.strptime(dt, "%Y-%m-%d %H:%M:%S")
my_time = datetime.datetime(*(time.strptime(dt, "%Y-%m-%d %H:%M:%S")[0:6]))
if tz.upper() != "Z":
# no zulu time, has zone offset
my_offset = datetime.timedelta(
hours=int(m.group(9)), minutes=int(m.group(10))
)
# adjust for time zone offset
if tz[0] == "-":
my_time = my_time + my_offset
else:
my_time = my_time - my_offset
# Turn my_time into Epoch format
return int(calendar.timegm(my_time.timetuple()))
except:
logger.warn('unable to parse timestamp "%s"' % timestamp)
return None
def epochdate(timestamp):
"""
This function converts an ISO timestamp into seconds since epoch
"""
try:
# Split date/time and timezone information
m = parse_iso8601.search(timestamp)
if m is None:
logger.warn('unable to match "%s" to ISO 8601' % timestamp)
return None
else:
dt = "%04d-%02d-%02d %02d:%02d:%02d" % (
int(m.group(1)),
int(m.group(2)),
int(m.group(3)),
int(m.group(4)),
int(m.group(5)),
int(m.group(6)),
)
tz = m.group(8)
# my_time = datetime.datetime.strptime(dt, "%Y-%m-%d %H:%M:%S")
my_time = datetime.datetime(*(time.strptime(dt, "%Y-%m-%d %H:%M:%S")[0:6]))
if tz.upper() != "Z":
# no zulu time, has zone offset
my_offset = datetime.timedelta(
hours=int(m.group(9)), minutes=int(m.group(10))
)
# adjust for time zone offset
if tz[0] == "-":
my_time = my_time + my_offset
else:
my_time = my_time - my_offset
# Turn my_time into Epoch format
return int(calendar.timegm(my_time.timetuple()))
except:
logger.warn('unable to parse timestamp "%s"' % timestamp)
return None
def make_boolean(value):
# purpose: convert an input string into something boolean
# paramtr: $x (IN): a property value
# returns: 0 (false) or 1 (true)
my_val = str(value)
if (
my_val.lower() == "true"
or my_val.lower() == "on"
or my_val.lower() == "yes"
or my_val.isdigit()
and int(value) > 0
):
return 1
return 0
from six.moves import builtins c1 = complex() d1 = dict() f1 = float() i1 = int() l1 = list() s1 = str() t1 = tuple() c2 = builtins.complex() d2 = builtins.dict() f2 = builtins.float() i2 = builtins.int() l2 = builtins.list() s2 = builtins.str() t2 = builtins.tuple()
def find(self, executable, version_arg=None, version_regex=None, path_prepend=None):
self.lock.acquire()
try:
if executable in self._info:
if self._info[executable] is None:
return None
return self._info[executable]
logger.debug("Trying to detect availability/location of tool: %s"
%(executable))
# initialize the global tool info for this executable
self._info[executable] = {}
self._info[executable]['full_path'] = None
self._info[executable]['version'] = None
self._info[executable]['version_major'] = None
self._info[executable]['version_minor'] = None
self._info[executable]['version_patch'] = None
# figure out the full path to the executable
path_entries = os.environ["PATH"].split(":")
if "" in path_entries:
path_entries.remove("")
# if we have PEGASUS_HOME set, and try to invoke a Pegasus tool, prepend
if 'PEGASUS_HOME' in os.environ and executable.find("pegasus-") == 0:
path_entries.insert(0, os.environ['PEGASUS_HOME'] + '/bin')
if path_prepend is not None:
for entry in path_prepend:
path_entries.insert(0, entry)
# now walk the path
full_path = None
for entry in path_entries:
full_path = entry + "/" + executable
if os.path.isfile(full_path) and os.access(full_path, os.X_OK):
break
full_path = None
if full_path == None:
logger.info("Command '%s' not found in the current environment"
%(executable))
self._info[executable] = None
return self._info[executable]
self._info[executable]['full_path'] = full_path
# version
if version_regex is None:
version = "N/A"
else:
version = backticks(executable + " " + version_arg + " 2>&1")
version = version.replace('\n', "")
re_version = re.compile(version_regex)
result = re_version.search(version)
if result:
version = result.group(1)
self._info[executable]['version'] = version
# if possible, break up version into major, minor, patch
re_version = re.compile("([0-9]+)\.([0-9]+)(\.([0-9]+)){0,1}")
result = re_version.search(version)
if result:
self._info[executable]['version_major'] = int(result.group(1))
self._info[executable]['version_minor'] = int(result.group(2))
self._info[executable]['version_patch'] = result.group(4)
if self._info[executable]['version_patch'] is None or \
self._info[executable]['version_patch'] == "":
self._info[executable]['version_patch'] = None
else:
self._info[executable]['version_patch'] = \
int(self._info[executable]['version_patch'])
logger.info("Tool found: %s Version: %s Path: %s"
% (executable, version, full_path))
return self._info[executable]['full_path']
finally:
self.lock.release()
def pid_running(filename):
"""
This function takes a file containing a single line in the format
of pid 'xxxxxx'. If the file exists, it reads the line and checks if
the process id 'xxxxxx' is still running. The function returns True
if the process is still running, or False if not.
"""
# First, we check if file exists
if os.access(filename, os.F_OK):
try:
# Open pid file
PIDFILE = open(filename, "r")
# Look for pid line
for line in PIDFILE:
line = line.strip()
if line.startswith("pid"):
# Get pid
my_pid = int(line.split(" ")[1])
# We are done with this file, just close it...
PIDFILE.close()
# Now let's see if process still around...
try:
os.kill(my_pid, 0)
except OSError as err:
if err.errno == errno.ESRCH:
# pid is not found, monitoring cannot be running
logger.info("pid %d not running anymore..." % (my_pid))
return False
elif err.errno == errno.EPERM:
# pid cannot be killed because we don't have permission
logger.debug(
"no permission to talk to pid %d..." % (my_pid)
)
return True
else:
logger.warning(
"unknown error while sending signal to pid %d"
% (my_pid)
)
logger.warning(traceback.format_exc())
return True
except:
logger.warning(
"unknown error while sending signal to pid %d" % (my_pid)
)
logger.warning(traceback.format_exc())
return True
else:
logger.debug("pid %d still running..." % (my_pid))
return True
logger.warning(
"could not find pid line in file %s. continuing..." % (filename)
)
# Don't forget to close file
PIDFILE.close()
except:
logger.warning("error processing file %s. continuing..." % (filename))
logger.warning(traceback.format_exc())
return True
# PID file doesn't exist
return False
def version_comparable(self, executable):
''' Returns the detected comparable version given executable '''
self.lock.acquire()
try:
if executable in self._info and self._info[executable] is not None:
return '%03d%03d%03d' %(int(self._info[executable]['version_major']), \
int(self._info[executable]['version_minor']), \
int(self._info[executable]['version_patch']))
return None
finally:
self.lock.release()
if __name__ == "__main__":
current_time = int(time.time())
print("Testing isodate() function from now=%lu" % (current_time))
print(" long local timestamp:", isodate(now=current_time))
print(" long utc timestamp:", isodate(now=current_time, utc=True))
print("short local timestamp:", isodate(now=current_time, short=True))
print(" short utc timestamp:", isodate(now=current_time, utc=True, short=True))
print()
print("Testing epochdate() function from above ISO dates")
print(" long local epochdate:", epochdate(isodate(now=current_time)))
print(" long utc epochdate:", epochdate(isodate(now=current_time, utc=True)))
print("short local timestamp:", epochdate(isodate(now=current_time, short=True)))
print(
" short utc timestamp:",
epochdate(isodate(now=current_time, utc=True, short=True)),
)
print()
# returns: 0 (false) or 1 (true)
my_val = str(value)
if (
my_val.lower() == "true"
or my_val.lower() == "on"
or my_val.lower() == "yes"
or my_val.isdigit()
and int(value) > 0
):
return 1
return 0
if __name__ == "__main__":
current_time = int(time.time())
print("Testing isodate() function from now=%lu" % (current_time))
print(" long local timestamp:", isodate(now=current_time))
print(" long utc timestamp:", isodate(now=current_time, utc=True))
print("short local timestamp:", isodate(now=current_time, short=True))
print(" short utc timestamp:", isodate(now=current_time, utc=True, short=True))
print()
print("Testing epochdate() function from above ISO dates")
print(" long local epochdate:", epochdate(isodate(now=current_time)))
print(" long utc epochdate:", epochdate(isodate(now=current_time, utc=True)))
print("short local timestamp:", epochdate(isodate(now=current_time, short=True)))
print(
" short utc timestamp:",
epochdate(isodate(now=current_time, utc=True, short=True)),
)
print()
def pid_running(filename):
"""
This function takes a file containing a single line in the format
of pid 'xxxxxx'. If the file exists, it reads the line and checks if
the process id 'xxxxxx' is still running. The function returns True
if the process is still running, or False if not.
"""
# First, we check if file exists
if os.access(filename, os.F_OK):
try:
# Open pid file
PIDFILE = open(filename, "r")
# Look for pid line
for line in PIDFILE:
line = line.strip()
if line.startswith("pid"):
# Get pid
my_pid = int(line.split(" ")[1])
# We are done with this file, just close it...
PIDFILE.close()
# Now let's see if process still around...
try:
os.kill(my_pid, 0)
except OSError as err:
if err.errno == errno.ESRCH:
# pid is not found, monitoring cannot be running
logger.info("pid %d not running anymore..." % (my_pid))
return False
elif err.errno == errno.EPERM:
# pid cannot be killed because we don't have permission
logger.debug(
"no permission to talk to pid %d..." % (my_pid)
)
return True
else:
logger.warning(
"unknown error while sending signal to pid %d"
% (my_pid)
)
logger.warning(traceback.format_exc())
return True
except:
logger.warning(
"unknown error while sending signal to pid %d" % (my_pid)
)
logger.warning(traceback.format_exc())
return True
else:
logger.debug("pid %d still running..." % (my_pid))
return True
logger.warning(
"could not find pid line in file %s. continuing..." % (filename)
)
# Don't forget to close file
PIDFILE.close()
except:
logger.warning("error processing file %s. continuing..." % (filename))
logger.warning(traceback.format_exc())
return True
# PID file doesn't exist
return False
