def composition_cores(request, name):
q_from = request.GET.get('from', "-60minutes")
q_az = request.GET.get('az', "melbourne")
targets = []
if q_az in settings.COMPOSITION_QUERY:
targets.extend([
graphite.Target(target % name)
for target in settings.COMPOSITION_QUERY[q_az]
])
else:
targets.append(graphite.Target("az.%s.%s.*.used_vcpus" % (q_az, name)))
req = graphite.get(from_date=q_from, targets=targets)
cleaned = defaultdict(dict)
for item in req.json():
item_name = '.'.join(item['target'].split('.')[-2].split('_'))
data = cleaned[item_name]
data['target'] = item_name
try:
count = next(choose_first(item['datapoints']))
except Exception:
count = 0
if data.get('value'):
data['value'] += count
else:
data['value'] = count
cleaned = list(cleaned.values())
sorted(cleaned, key=lambda x: x['value'])
return HttpResponse(dumps(cleaned), req.headers['content-type'])
def total_cores_per_domain(request):
q_from = request.GET.get('from', "-60minutes")
q_az = request.GET.get('az', "melbourne")
targets = []
if q_az in QUERY:
targets.extend([graphite.Target(target)
for target in QUERY[q_az]])
else:
targets.append(graphite.Target("az.%s.domain.*.used_vcpus" % q_az))
req = graphite.get(from_date=q_from, targets=targets)
cleaned = defaultdict(dict)
for domain in req.json():
domain_name = '.'.join(domain['target'].split('.')[-2].split('_'))
data = cleaned[domain_name]
data['target'] = domain_name
try:
count = choose_first(domain['datapoints']).next()
except:
count = 0
if data.get('value'):
data['value'] += count
else:
data['value'] = count
cleaned = cleaned.values()
cleaned.sort(key=itemgetter('value'))
return HttpResponse(dumps(cleaned), req.headers['content-type'])
def test_get_targets(mock_get):
targets = [
graphite.Target("test.az.something").alias("foo"),
graphite.Target("test.az.something_else").alias("bar")
]
response = graphite.get(from_date='-1year', targets=targets)
mock_get.assert_called_with(
'http://graphite.dev.rc.nectar.org.au/render/'
'?format=json'
'&target=alias%28test.az.something%2C+%22foo%22%29'
'&target=alias%28test.az.something_else%2C+%22bar%22%29'
'&from=-1year')
assert response == mock_get()
def test_project_details_queries_graphite(self, mock_date, mock_get,
mock_response):
mock_date.today.return_value = date(2014, 12, 1)
mock_response.json.return_value = []
mock_get.return_value = mock_response
response = project_details.find_current_project_resource_usage('xxxxx')
targetStr0 = "alias(smartSummarize(tenant.xxxxx.total_instances, " + \
"\"1d\", \"max\"), \"instance_count\")"
target0 = graphite.Target(targetStr0)
targetStr1 = "alias(smartSummarize(tenant.xxxxx.used_vcpus, " + \
"\"1d\", \"max\"), \"core_count\")"
target1 = graphite.Target(targetStr1)
mock_get.assert_called_with(from_date='20141201',
targets=[target0, target1])
assert response == []
def find_daily_accumulated_users():
'''
Retrieve the history of the cumulative and frequency counts of users
added by the end of each day.
'''
targets = []
targets.append(
graphite.Target('users.total').smartSummarize(
'1d', 'max').alias('Cumulative'))
targets.append(
graphite.Target('users.total').smartSummarize(
'1d', 'max').derivative().alias('Frequency'))
response = graphite.get(from_date=settings.USER_STATISTICS_START_DATE,
targets=targets)
return graphite.filter_null_datapoints(response.json())
def total_used_cores(request):
q_from = request.GET.get('from', "-6months")
q_summarise = request.GET.get('summarise', None)
targets = [graphite.Target(target).summarize(q_summarise).alias(alias)
for alias, target in CORES_TARGETS]
req = graphite.get(from_date=q_from, targets=targets)
data = graphite.fill_null_datapoints(req.json())
return HttpResponse(dumps(data), req.headers['content-type'])
def total_capacity(request, ram_size=4096):
q_from = request.GET.get('from', "-6months")
q_summarise = request.GET.get('summarise', None)
targets = [graphite.Target(
target % {'ram_size': ram_size}).summarize(q_summarise).alias(alias)
for alias, target in CAPACITY_TARGETS]
req = graphite.get(from_date=q_from, targets=targets)
data = graphite.fill_null_datapoints(req.json())
return HttpResponse(dumps(data), req.headers['content-type'])
def total_instance_count(request):
q_from = request.GET.get('from', "-6months")
q_until = request.GET.get('until', None)
q_summarise = request.GET.get('summarise', None)
targets = [
graphite.Target(target).summarize(q_summarise).alias(alias)
for alias, target in settings.INST_TARGETS
]
req = graphite.get(from_date=q_from, until_date=q_until, targets=targets)
data = graphite.fill_null_datapoints(req.json(), q_summarise)
return HttpResponse(dumps(data), req.headers['content-type'])
def test_target_summarise():
target = graphite.Target("test.az.something")
assert str(target.summarize('1d')) \
== 'summarize(test.az.something, "1d", "avg")'
assert str(target.summarize('1d', 'sum')) \
== 'summarize(test.az.something, "1d", "sum")'
assert str(target.summarize(None)) \
== 'test.az.something'
# Test chaining
assert isinstance(target, graphite.Target)
def find_current_project_resource_usage(tenancy_id):
'''
Retrieve the last daily value for the project/tenancy
usage of instances and cores.
'''
today = date.today()
today_str = today.strftime('%Y%m%d')
targets = []
target_name = "tenant.%s.total_instances" % tenancy_id
targets.append(
graphite.Target(target_name).smartSummarize(
'1d', 'max').alias('instance_count'))
target_name = "tenant.%s.used_vcpus" % tenancy_id
targets.append(
graphite.Target(target_name).smartSummarize('1d',
'max').alias('core_count'))
response = graphite.get(from_date=today_str, targets=targets)
return graphite.filter_null_datapoints(response.json())
def test_target():
target = graphite.Target("test.az.something")
assert str(target) == 'test.az.something'
# Test chaining
assert isinstance(target, graphite.Target)
def test_target_derivitave():
target = graphite.Target("test.az.something").derivative()
assert str(target) == 'derivative(test.az.something)'
# Test chaining
assert isinstance(target, graphite.Target)
def test_target_alias():
target = graphite.Target("test.az.something").alias('name1')
assert str(target) == 'alias(test.az.something, "name1")'
# Test chaining
assert isinstance(target, graphite.Target)
def test_target_not_equals():
target0 = graphite.Target("test.az.something0")
target1 = graphite.Target("test.az.something1")
assert target0 != target1
