def test_get_generic(self):
vm_group = mock.Mock(spec=VMGroup)
vm_group.name.return_value = "Fake VM Group"
vm_group._scenario = mock.Mock(spec=Scenario)
vm_group._scenario.id = "854982789152076068"
expected_query_str = (
"irate("
"node_network_receive_bytes_total{"
"device=\"eth0\", "
"scenario_id=\"854982789152076068\", "
"vm_group=\"Fake VM Group\""
"}"
"[30s])"
)
p = prometheus.PrometheusAdapter()
query_input = (
"irate("
"node_network_receive_bytes_total{"
"device=\"eth0\", "
"__curie_filter_scenario__, "
"__curie_filter_vm_group__"
"}"
"[30s])"
)
with mock.patch.object(p, "query_range") as mock_query_range:
mock_query_range.return_value = "this_is_fake_data"
data = p.get_generic(vm_group, start=1510076387, end=1510076487,
query=query_input)
self.assertEqual("this_is_fake_data", data)
mock_query_range.assert_called_once_with(
expected_query_str, 1510076387, 1510076487, step=None)
def test_get_avg_latency(self):
vm_group = mock.Mock(spec=VMGroup)
vm_group.name.return_value = "Fake VM Group"
vm_group._scenario = mock.Mock(spec=Scenario)
vm_group._scenario.id = "854982789152076068"
expected_query_str = (
"("
"sum("
"irate(node_disk_read_time_seconds_total{"
"scenario_id=\"854982789152076068\", "
"vm_group=\"Fake VM Group\"}[30s]) + "
"irate(node_disk_write_time_seconds_total{"
"scenario_id=\"854982789152076068\", "
"vm_group=\"Fake VM Group\"}[30s])) "
"by(instance) / "
"("
"sum("
"irate(node_disk_reads_completed_total{"
"scenario_id=\"854982789152076068\", "
"vm_group=\"Fake VM Group\"}[30s]) + "
"irate(node_disk_writes_completed_total{"
"scenario_id=\"854982789152076068\", "
"vm_group=\"Fake VM Group\"}[30s])) "
"by(instance) > 5"
")"
") * 1000000.0")
p = prometheus.PrometheusAdapter()
with mock.patch.object(p, "query_range") as mock_query_range:
mock_query_range.return_value = "this_is_fake_data"
data = p.get_avg_disk_latency(vm_group, start=1510076387, end=1510076487)
self.assertEqual("this_is_fake_data", data)
mock_query_range.assert_called_once_with(
expected_query_str, 1510076387, 1510076487, step=None)
def test_query_range_error_400_json_valid(self, mock_requests):
mock_response = mock.Mock(spec=requests.Response)
mock_response.status_code = 400
mock_response.json.return_value = {"error": "OMGWTFBBQ"}
mock_requests.get.return_value = mock_response
p = prometheus.PrometheusAdapter()
with self.assertRaises(prometheus.PrometheusAPIError) as ar:
p.query_range("this_is_the_query", 1510076387, 1510076487)
self.assertEqual("Failed to query_range: 'OMGWTFBBQ'", str(ar.exception))
def test_query_range_error_400_json_invalid(self, mock_requests):
mock_response = mock.Mock(spec=requests.Response)
mock_response.status_code = 400
mock_response.json.side_effect = ValueError("This ain't JSON, fella.")
mock_requests.get.return_value = mock_response
p = prometheus.PrometheusAdapter()
with self.assertRaises(prometheus.PrometheusAPIError) as ar:
p.query_range("this_is_the_query", 1510076387, 1510076487)
self.assertEqual("Failed to query_range: %r" % mock_response,
str(ar.exception))
def test_query_range_error_200_json_invalid(self, mock_requests):
mock_response = mock.Mock(spec=requests.Response)
mock_response.status_code = 200
mock_response.json.side_effect = ValueError("This ain't JSON, fella.")
mock_response.text = "{\"I hope I didn't miss a closing brace somewhere\""
mock_requests.get.return_value = mock_response
p = prometheus.PrometheusAdapter()
with self.assertRaises(prometheus.PrometheusAPIError) as ar:
p.query_range("this_is_the_query", 1510076387, 1510076487)
self.assertEqual("Received status code 200, but JSON could not be "
"decoded: '{\"I hope I didn\\\'t miss a closing brace "
"somewhere\"'", str(ar.exception))
def test_get_disk_octets_aggregate_unsupported(self):
vm_group = mock.Mock(spec=VMGroup)
vm_group._scenario = mock.Mock(spec=Scenario)
vm_group._scenario.id = "854982789152076068"
p = prometheus.PrometheusAdapter()
with mock.patch.object(p, "query_range") as mock_query_range:
mock_query_range.return_value = "this_is_fake_data"
with self.assertRaises(ValueError) as ar:
p.get_disk_octets(vm_group, start=1510076387, end=1510076487,
agg_func="meaner")
self.assertEqual("Unsupported aggregation function 'meaner'",
str(ar.exception))
mock_query_range.assert_not_called()
def test_query_range_start_end_float_floor(self, mock_requests):
data_return_value = {"some_data"}
mock_response = mock.Mock(spec=requests.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"data": data_return_value}
mock_requests.get.return_value = mock_response
p = prometheus.PrometheusAdapter()
p.query_range("this_is_the_query", 1510076387.9, 1510076487.9)
mock_requests.get.assert_called_once_with(
"http://localhost:9090/api/v1/query_range",
params={"query": "this_is_the_query",
"start": "2017-11-07T17:39:47Z",
"end": "2017-11-07T17:41:27Z",
"step": "5s"})
def test_query_range_start_end_tz_None(self, mock_requests, mock_datetime):
data_return_value = {"some_data"}
mock_response = mock.Mock(spec=requests.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"data": data_return_value}
mock_requests.get.return_value = mock_response
now = datetime(2017, 11, 07, 17, 39, 47)
mock_datetime.utcnow.return_value = now
p = prometheus.PrometheusAdapter()
p.query_range("this_is_the_query", None, None)
mock_requests.get.assert_called_once_with(
"http://localhost:9090/api/v1/query_range",
params={"query": "this_is_the_query",
"start": "2017-11-07T17:39:47Z",
"end": "2017-11-07T17:39:47Z",
"step": "5s"})
def get_result_pbs(self):
"""
Produce the results for a given VM Group.
"""
if not self.scenario.prometheus_address:
log.debug("Unable to get protobufs from VMGroupResult: "
"scenario.prometheus_address not configured")
return []
host, port = self.scenario.prometheus_address.split(":")
prometheus_adapter = prometheus.PrometheusAdapter(host=host, port=port)
if self.workload_mask:
run_start = self.workload_mask.iogen().get_workload_start_time()
run_end = self.workload_mask.iogen().get_workload_end_time()
else:
run_start = self.scenario.phase_start_time_secs(Phase.RUN)
run_end = self.scenario.phase_start_time_secs(Phase.TEARDOWN)
if not run_start:
return []
if self.result_type == "iops":
data = prometheus_adapter.get_disk_ops(self.vm_group,
run_start,
run_end,
agg_func=self.aggregate,
step=self.step)
elif self.result_type == "bandwidth":
data = prometheus_adapter.get_disk_octets(self.vm_group,
run_start,
run_end,
agg_func=self.aggregate,
step=self.step)
elif self.result_type == "latency":
data = prometheus_adapter.get_avg_disk_latency(
self.vm_group,
run_start,
run_end,
agg_func=self.aggregate,
step=self.step)
elif self.result_type == "generic":
data = prometheus_adapter.get_generic(self.vm_group,
run_start,
run_end,
query=self.kwargs["query"],
agg_func=self.aggregate,
step=self.step)
else:
raise ValueError("Unexpected result_type %r" % self.result_type)
return self.series_list_to_result_pbs(prometheus.to_series_list(data))
def test_query_range_start_end_tz_datetime(self, mock_requests):
data_return_value = {"some_data"}
mock_response = mock.Mock(spec=requests.Response)
mock_response.status_code = 200
mock_response.json.return_value = {"data": data_return_value}
mock_requests.get.return_value = mock_response
p = prometheus.PrometheusAdapter()
eastern = pytz.timezone("US/Eastern")
p.query_range(
"this_is_the_query",
eastern.localize(datetime(2017, 11, 07, 12, 39, 47)),
eastern.localize(datetime(2017, 11, 07, 12, 41, 27)))
mock_requests.get.assert_called_once_with(
"http://localhost:9090/api/v1/query_range",
params={"query": "this_is_the_query",
"start": "2017-11-07T17:39:47Z",
"end": "2017-11-07T17:41:27Z",
"step": "5s"})
def test_get_disk_octets_aggregate_mean(self):
vm_group = mock.Mock(spec=VMGroup)
vm_group.name.return_value = "Fake VM Group"
vm_group._scenario = mock.Mock(spec=Scenario)
vm_group._scenario.id = "854982789152076068"
expected_query_str = (
"avg("
"sum("
"irate(node_disk_read_bytes_total{"
"scenario_id=\"854982789152076068\", "
"vm_group=\"Fake VM Group\"}[30s]) + "
"irate(node_disk_written_bytes_total{"
"scenario_id=\"854982789152076068\", "
"vm_group=\"Fake VM Group\"}[30s])) "
"by(instance)) "
"by(vm_group)")
p = prometheus.PrometheusAdapter()
with mock.patch.object(p, "query_range") as mock_query_range:
mock_query_range.return_value = "this_is_fake_data"
data = p.get_disk_octets(vm_group, start=1510076387, end=1510076487,
agg_func="mean")
self.assertEqual("this_is_fake_data", data)
mock_query_range.assert_called_once_with(
expected_query_str, 1510076387, 1510076487, step=None)
def test_init_override(self):
p = prometheus.PrometheusAdapter(host="fake_host", port=12345,
protocol="https")
self.assertEqual("https://fake_host:12345/api/v1/", p.base_url)
def test_init_defaults(self):
p = prometheus.PrometheusAdapter()
self.assertEqual("localhost", p.host)
self.assertEqual(9090, p.port)
self.assertEqual("http://localhost:9090/api/v1/", p.base_url)
