blob: 460c74d2b457069fc7b135e981a6e859a07cc347 [file] [log] [blame]
# Copyright 2020-2024 Open Networking Foundation (ONF) and the ONF Contributors
# delivered by ADTRAN, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import absolute_import
from __future__ import print_function
import inspect
import os
import operator
import requests
# global definition of keys (find in given 'inventory_data')
_NAME = 'name'
_CHILDREN = 'children'
_SENSOR_DATA = 'sensor_data'
_ROOT = 'root'
_INVENTORY = 'inventory'
_UUID = 'uuid'
def test(success):
if success is True:
return True
return False
def unique():
"""Returns the current filename and line number in our program."""
trace = str(os.path.basename(__file__) +
"[" + str(inspect.currentframe().f_back.f_lineno) + "]:")
return trace
# check if given paramter exist in inventory data, search recursive
def check_in_inventory_Component_data(inventory_data, name, element, value):
print(unique(), str(inventory_data), str(name), str(element), str(value))
if inventory_data.get(_NAME) == name and inventory_data.get(element) == value:
return True
for child in inventory_data[_CHILDREN]:
print(unique(), str(child))
if child.get(_NAME) == name and child.get(element) == value:
return True
if _SENSOR_DATA in child:
for sensor_data in child[_SENSOR_DATA]:
print(unique(), str(sensor_data))
if sensor_data.get(element) == value:
return True
if _CHILDREN in child:
result = check_in_inventory_Component_data(child, name, element, value)
if result is True:
return result
return False
# get uuid out of inventory data, search recursive
def get_uuid_from_inventory_Component_data(inventory_data, searchFor):
print(unique(), str(inventory_data), ', ', str(searchFor))
if inventory_data.get(_NAME) == searchFor:
return inventory_data.get(_UUID)
for child in inventory_data[_CHILDREN]:
print(unique(), str(child))
result = None
if child.get(_NAME) == searchFor:
print(unique(), str(child[_NAME]))
result = child.get(_UUID)
print(unique(), child.keys())
if result is None and _CHILDREN in child:
result = get_uuid_from_inventory_Component_data(child, searchFor)
if result is not None:
return result
return None
def get_uuid_from_Inventory_Element(inventory, searchFor):
for children in inventory[_INVENTORY][_ROOT][_CHILDREN]:
return get_uuid_from_inventory_Component_data(children, searchFor)
return None
def check_Inventory_Element(inventory, name, element, value):
for childrens in inventory[_INVENTORY][_ROOT][_CHILDREN]:
return check_in_inventory_Component_data(childrens, name, element, value)
return False
def getWord(line, number):
line_in_list = line.split()
if len(line_in_list) >= number-1:
return line_in_list[number-1]
return ""
def decode(data):
decoded_data = data
print(unique(), str(decoded_data))
# Compares two values using a given operator. The values are converted to float first so that
# numbers as strings are also accepted. Returns True or False.
# operator: ==, !=, <, <=, >, >=
# Example:
# | ${result} | Compare | 100 | > | 5 | # True |
def compare(value1, op, value2):
ops = {"==": operator.eq,
"!=": operator.ne,
"<": operator.lt,
"<=": operator.le,
">": operator.gt,
">=": operator.ge}
return ops[op](float(value1), float(value2))
# Validates two values using a given operator.
# The values are converted to float first so that numbers as strings are also accepted.
# Second value has to be a list in case of operator is 'in' or 'range'
# Returns True or False.
# operator: in, range, ==, !=, <, <=, >, >=
# Example:
# | ${result} | validate | 100 | > | 5 | # True |
# | ${result} | validate | 11 | in | ['11','264','329'] | # True |
# | ${result} | validate | 1 | range | ['0','1'] | # True |
def validate(value1, op, value2):
if op == "in":
return (float(value1) in [float(i) for i in value2])
if op == "range":
return ((compare(value1, ">=", value2[0])) and (compare(value1, "<=", value2[1])))
return compare(value1, op, value2)
def get_memory_consumptions(address, container, namespace="default"):
"""
Query Prometheus and generate instantaneous memory consumptions for given pods under test
:param address: string The address of the Prometheus instance to query
:param container: string The pod name
:param namespace: string The pod namespace
:return: memory consumtion value
"""
container_mem_query = ('container_memory_working_set_bytes{namespace="%s",container="%s"}' %
(namespace, container))
mem_params = {
"query": container_mem_query,
}
r = requests.get("http://%s/api/v1/query" % address, mem_params)
container_cpu = r.json()["data"]["result"]
if len(container_cpu) > 0:
return container_cpu[0]["value"][1]
else:
return -1
def get_memory_consumptions_range(address, container, namespace="default", start=0, end=0):
"""
Query Prometheus and generate instantaneous memory consumptions for given pods under test
:param address: string The address of the Prometheus instance to query
:param container: string The pod name
:param namespace: string The pod namespace
:param start: integer The range start time (epoch)
:param end: integer The range end time
:return: memory consumtion value
"""
container_mem_query = ('sort_desc(container_memory_working_set_bytes{namespace="%s",container="%s"})' %
(namespace, container))
mem_params = {
"query": container_mem_query,
"start":start,
"end":end,
"step":'1m',
}
r = requests.get("http://%s/api/v1/query_range" % address, mem_params)
container_cpu = r.json()["data"]["result"]
if len(container_cpu) > 0:
return container_cpu[0]["values"]
else:
return -1