def test_expand_to_seconds_fail(self):
try:
tankcore.expand_to_seconds("100n")
raise RuntimeError("Exception expected")
except ValueError, ex:
# it's ok, we have excpected exception
print ex
def test_expand_to_seconds_fail(self):
try:
tankcore.expand_to_seconds("100n")
raise RuntimeError("Exception expected")
except ValueError, ex:
# it's ok, we have excpected exception
print ex
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.seconds_count = 0
self.autostop = autostop
self.threads_limit = 1
level_str = param_str.split(',')[0].strip()
if level_str[-1:] == '%':
self.level = float(level_str[:-1]) / 100
self.is_relative = True
else:
self.level = int(level_str)
self.is_relative = False
self.seconds_limit = tankcore.expand_to_seconds(
param_str.split(',')[1])
try:
phantom = autostop.core.get_plugin_of_type(PhantomPlugin)
info = phantom.get_info()
if info:
self.threads_limit = info.instances
if not self.threads_limit:
raise ValueError(
"Cannot create 'instances' criteria with zero instances limit")
except KeyError:
self.log.warning(
"No phantom module, 'instances' autostop disabled")
def configure(self):
self.config = self.get_option("config", 'auto').strip()
self.default_target = self.get_option("default_target", 'localhost')
self.monitoring.ssh_timeout = tankcore.expand_to_seconds(
self.get_option('ssh_timeout', "5s"))
if self.config == 'none' or self.config == 'auto':
self.die_on_fail = False
else:
if self.config[0] == '<':
xmlfile = self.core.mkstemp(".xml", "monitoring_")
self.core.add_artifact_file(xmlfile)
xml = open(xmlfile, 'w')
xml.write(self.config)
xml.close()
self.config = xmlfile
if not os.path.exists(self.config):
raise OSError("Monitoring config file not found: %s" %
self.config)
if self.config == 'none':
self.monitoring = None
if self.config == 'auto':
self.config = os.path.dirname(
__file__) + '/monitoring_default_config.xml'
try:
autostop = self.core.get_plugin_of_type(AutostopPlugin)
autostop.add_criteria_class(MetricHigherCriteria)
autostop.add_criteria_class(MetricLowerCriteria)
except KeyError:
self.log.debug(
"No autostop plugin found, not adding instances criteria")
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.seconds_count = 0
self.autostop = autostop
level_str = param_str.split(',')[0].strip()
if level_str[-1:] == '%':
self.level = float(level_str[:-1]) / 100
self.is_relative = True
else:
self.level = int(level_str)
self.is_relative = False
self.seconds_limit = tankcore.expand_to_seconds(
param_str.split(',')[1])
try:
phantom = autostop.core.get_plugin_of_type(PhantomPlugin)
self.threads_limit = phantom.phantom.instances
if not self.threads_limit:
raise ValueError(
"Cannot create 'instances' criteria with zero instances limit"
)
except KeyError:
self.log.warning(
"No phantom module, 'instances' autostop disabled")
def configure(self):
self.config = self.get_option("config", "auto").strip()
self.default_target = self.get_option("default_target", "localhost")
self.monitoring.ssh_timeout = tankcore.expand_to_seconds(self.get_option("ssh_timeout", "5s"))
if self.config == "none" or self.config == "auto":
self.die_on_fail = False
else:
if self.config[0] == "<":
xmlfile = self.core.mkstemp(".xml", "monitoring_")
self.core.add_artifact_file(xmlfile)
xml = open(xmlfile, "w")
xml.write(self.config)
xml.close()
self.config = xmlfile
if not os.path.exists(self.config):
raise OSError("Monitoring config file not found: %s" % self.config)
if self.config == "none":
self.monitoring = None
if self.config == "auto":
self.config = os.path.dirname(__file__) + "/monitoring_default_config.xml"
try:
autostop = self.core.get_plugin_of_type(AutostopPlugin)
autostop.add_criteria_class(MetricHigherCriteria)
autostop.add_criteria_class(MetricLowerCriteria)
except KeyError:
self.log.debug("No autostop plugin found, not adding instances criteria")
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.seconds_count = 0
self.quantile = float(param_str.split(',')[0])
self.rt_limit = tankcore.expand_to_milliseconds(param_str.split(',')[1])
self.seconds_limit = tankcore.expand_to_seconds(param_str.split(',')[2])
self.autostop = autostop
def load_step(start, end, step, duration,):
'''
Stepping load pattern
'''
dur = tankcore.expand_to_seconds(duration)
(steps, loads, total) = ([], '', 0)
if end > start:
for rps_level in range(start, end + 1, step):
steps.append([rps_level, dur])
loads += '%s,step,%s,%s,(%s,%s,%s,%s)\n' % (
dur,
rps_level,
rps_level,
start,
end,
step,
duration,
)
total += rps_level * dur
else:
for rps_level in range(start, end - 1, -step):
steps.append([rps_level, dur])
loads += '%s,step,%s,%s,(%s,%s,%s,%s)\n' % (
dur,
rps_level,
rps_level,
start,
end,
step,
duration,
)
total += rps_level * dur
return [steps, loads, total]
def load_line(start, end, duration):
'''
Linear load pattern
'''
dur = tankcore.expand_to_seconds(duration)
diff_k = float((end - start) / float(dur - 1))
(cnt, last_x, total) = (1, start, 0)
loads = '%s,line,%s,%s,(%s,%s,%s)\n' % (
dur,
start,
end,
start,
end,
duration,
)
steps = []
for sec_i in range(1, dur + 1):
cur_x = int(start + diff_k * sec_i)
if cur_x == last_x:
cnt += 1
else:
steps.append([last_x, cnt])
total += cnt * last_x
(cnt, last_x) = (1, cur_x)
return [steps, loads, total]
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.seconds_count = 0
self.quantile = float(param_str.split(',')[0])
self.rt_limit = tankcore.expand_to_milliseconds(param_str.split(',')[1])
self.seconds_limit = tankcore.expand_to_seconds(param_str.split(',')[2])
self.autostop = autostop
def load_step(start, end, step, duration,):
'''
Stepping load pattern
'''
dur = tankcore.expand_to_seconds(duration)
(steps, loads, total) = ([], '', 0)
if end > start:
for rps_level in range(start, end + 1, step):
steps.append([rps_level, dur])
loads += '%s,step,%s,%s,(%s,%s,%s,%s)\n' % (
dur,
rps_level,
rps_level,
start,
end,
step,
duration,
)
total += rps_level * dur
else:
for rps_level in range(start, end - 1, -step):
steps.append([rps_level, dur])
loads += '%s,step,%s,%s,(%s,%s,%s,%s)\n' % (
dur,
rps_level,
rps_level,
start,
end,
step,
duration,
)
total += rps_level * dur
return [steps, loads, total]
def load_line(start, end, duration):
'''
Linear load pattern
'''
dur = tankcore.expand_to_seconds(duration)
diff_k = float((end - start) / float(dur - 1))
(cnt, last_x, total) = (1, start, 0)
loads = '%s,line,%s,%s,(%s,%s,%s)\n' % (
dur,
start,
end,
start,
end,
duration,
)
steps = []
for sec_i in range(1, dur + 1):
cur_x = int(start + diff_k * sec_i)
if cur_x == last_x:
cnt += 1
else:
steps.append([last_x, cnt])
total += cnt * last_x
(cnt, last_x) = (1, cur_x)
return [steps, loads, total]
def configure(self):
self.port = int(self.get_option("port", self.port))
self.interval = int(
tankcore.expand_to_seconds(self.get_option("interval", '1m')))
self.redirect = self.get_option("redirect", self.redirect)
self.manual_stop = int(self.get_option('manual_stop',
self.manual_stop))
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
param = param_str.split(',')
self.seconds_count = 0
self.rt_limit = tankcore.expand_to_milliseconds(param[0])
self.frac = param[1][:-1]
self.seconds_limit = tankcore.expand_to_seconds(param[2])
self.autostop = autostop
self.data = deque()
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
param = param_str.split(',')
self.seconds_count = 0
self.rt_limit = tankcore.expand_to_milliseconds(param[0])
self.frac = param[1][:-1]
self.seconds_limit = tankcore.expand_to_seconds(param[2])
self.autostop = autostop
self.data = deque()
self.second_window = deque()
self.real_frac = float()
def load_const(req, duration):
"""
Constant load pattern
"""
dur = tankcore.expand_to_seconds(duration)
steps = []
steps.append([req, dur])
loads = "%s,const,%s,%s,(%s,%s)\n" % (dur, req, req, req, duration)
time = dur * int(req)
if int(req) == 0:
time = dur
return [steps, loads, time]
def load_const(req, duration):
'''
Constant load pattern
'''
dur = tankcore.expand_to_seconds(duration)
steps = []
steps.append([req, dur])
loads = '%s,const,%s,%s,(%s,%s)\n' % (dur, req, req, req, duration)
time = dur * int(req)
if int(req) == 0:
time = dur
return [steps, loads, time]
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.seconds_count = 0
self.codes_mask = param_str.split(',')[0].lower()
self.codes_regex = re.compile(self.codes_mask.replace("x", '.'))
self.autostop = autostop
self.tangents = deque()
self.second_window = deque()
self.total_tan = float()
self.tangents.append(0)
self.last = 0
self.seconds_limit = tankcore.expand_to_seconds(param_str.split(',')[1])
self.measurement_error = float()
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.seconds_count = 0
self.codes_mask = param_str.split(',')[0].lower()
self.codes_regex = re.compile(self.codes_mask.replace("x", '.'))
self.autostop = autostop
self.tangents = deque()
self.second_window = deque()
self.total_tan = float()
self.tangents.append(0)
self.last = 0
self.seconds_limit = tankcore.expand_to_seconds(param_str.split(',')[1])
self.measurement_error = float()
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.autostop = autostop
self.data = deque()
self.second_window = deque()
params = param_str.split(',')
# qunatile in ms
self.timing = tankcore.expand_to_milliseconds(params[0])
# width of time in seconds
self.width = tankcore.expand_to_seconds(params[1])
# max height of deviations in percents
self.height = float(params[2].split('%')[0])
# last deviation in percents
self.deviation = float()
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.seconds_count = 0
self.codes_mask = param_str.split(',')[0].lower()
self.codes_regex = re.compile(self.codes_mask.replace("x", '.'))
self.autostop = autostop
level_str = param_str.split(',')[1].strip()
if level_str[-1:] == '%':
self.level = float(level_str[:-1]) / 100
self.is_relative = True
else:
self.level = int(level_str)
self.is_relative = False
self.seconds_limit = tankcore.expand_to_seconds(param_str.split(',')[2])
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.seconds_count = 0
self.codes_mask = param_str.split(',')[0].lower()
self.codes_regex = re.compile(self.codes_mask.replace("x", '.'))
self.autostop = autostop
level_str = param_str.split(',')[1].strip()
if level_str[-1:] == '%':
self.level = float(level_str[:-1]) / 100
self.is_relative = True
else:
self.level = int(level_str)
self.is_relative = False
self.seconds_limit = tankcore.expand_to_seconds(param_str.split(',')[2])
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.autostop = autostop
self.data = deque()
self.second_window = deque()
params = param_str.split(',')
# qunatile in ms
self.quantile = tankcore.expand_to_milliseconds(params[0])
# width of time in seconds
self.width = tankcore.expand_to_seconds(params[1])
# max height of deviations in percents
self.height = float(params[2][0:-1])
# last deviation in percents
self.deviation = float()
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
MonitoringDataDecoder.__init__(self)
try:
self.mon = autostop.core.get_plugin_of_type(MonitoringPlugin)
self.mon.monitoring.add_listener(self)
except KeyError:
self.log.warning("No monitoring module, mon autostop disabled")
self.triggered = False
self.autostop = autostop
self.host = param_str.split(",")[0].strip()
self.metric = param_str.split(",")[1].strip()
self.value_limit = float(param_str.split(",")[2])
self.seconds_limit = tankcore.expand_to_seconds(param_str.split(",")[3])
self.last_second = None
self.seconds_count = 0
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
MonitoringDataDecoder.__init__(self)
try:
self.mon = autostop.core.get_plugin_of_type(MonitoringPlugin)
self.mon.monitoring.add_listener(self)
except KeyError:
self.log.warning("No monitoring module, mon autostop disabled")
self.triggered = False
self.autostop = autostop
self.host = param_str.split(',')[0].strip()
self.metric = param_str.split(',')[1].strip()
self.value_limit = float(param_str.split(',')[2])
self.seconds_limit = tankcore.expand_to_seconds(
param_str.split(',')[3])
self.last_second = None
self.seconds_count = 0
def constf(req, duration):
"""
Float const load pattern
"""
pattern = re.match("(\d+)\/(\d+)", req)
if pattern:
(a, b) = (int(pattern.group(1)), int(pattern.group(2)))
(dur, e) = (tankcore.expand_to_seconds(duration), int(a / b))
fract = "%.3f" % (float(a) / b)
loads = "%s,const,%s,%s,(%s,%s)\n" % (dur, fract, fract, req, duration)
a = a % b
req = "%s/%s" % (a, b)
out = []
tail = dur % b
for x in range(1, int(dur / b) + 1):
out += frps(req)
if tail:
out += frps_cut(tail, req)
if e > 0:
out = frps_expand(out, e)
return (out, loads, frps_ammo(out))
else:
raise RuntimeError("Error in 'const_f' function. rps: %s, duration: %s" % (req, duration))
def constf(req, duration):
'''
Float const load pattern
'''
pattern = re.match("(\d+)\/(\d+)", req)
if pattern:
(a, b) = (int(pattern.group(1)), int(pattern.group(2)))
(dur, e) = (tankcore.expand_to_seconds(duration), int(a / b))
fract = '%.3f' % (float(a) / b)
loads = '%s,const,%s,%s,(%s,%s)\n' % (dur, fract, fract, req, duration)
a = a % b
req = '%s/%s' % (a, b)
out = []
tail = dur % b
for x in range(1, int(dur / b) + 1):
out += frps(req)
if tail:
out += frps_cut(tail, req)
if e > 0:
out = frps_expand(out, e)
return (out, loads, frps_ammo(out))
else:
raise RuntimeError("Error in 'const_f' function. rps: %s, duration: %s" % (req, duration))
def configure(self):
self.port = int(self.get_option("port", self.port))
self.interval = int(tankcore.expand_to_seconds(self.get_option("interval", '1m')))
self.redirect = self.get_option("redirect", self.redirect)
self.manual_stop = int(self.get_option('manual_stop', self.manual_stop))
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.start_time = time.time()
self.end_time = time.time()
self.time_limit = tankcore.expand_to_seconds(param_str)
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.seconds_count = 0
self.hash = ""
self.seconds_limit = tankcore.expand_to_seconds(param_str.split(',')[0])
self.autostop = autostop
def test_expand_to_seconds(self):
for i in self.stest:
self.assertEqual(tankcore.expand_to_seconds(i[0]), i[1])
def configure(self):
self.interval = tankcore.expand_to_seconds(self.get_option("interval", self.interval))
self.disk_limit = int(self.get_option("disk_limit", self.disk_limit))
self.mem_limit = int(self.get_option("mem_limit", self.mem_limit))
def __init__(self, autostop, param_str):
AbstractCriteria.__init__(self)
self.seconds_count = 0
self.hash = ""
self.seconds_limit = tankcore.expand_to_seconds(param_str.split(',')[0])
self.autostop = autostop
def configure(self):
self.interval = tankcore.expand_to_seconds(
self.get_option("interval", self.interval))
self.disk_limit = int(self.get_option("disk_limit", self.disk_limit))
self.mem_limit = int(self.get_option("mem_limit", self.mem_limit))
def test_expand_to_seconds(self):
for i in self.stest:
self.assertEqual(tankcore.expand_to_seconds(i[0]), i[1])
