def test_open_filter(self):
"""If OPEN filter applied value will be accepted if: lower_bound < value < upper_bound"""
open_filter = RangeFilter(Type.OPEN, self.lower_bound, self.upper_bound)
out_range_value = open_filter.filter(self.lower_bound)
in_range_value = open_filter.filter(self.middle_value)
self.assertEquals(out_range_value, None)
self.assertEquals(in_range_value, self.middle_value)
def test_closed_open_filter(self):
"""If CLOSED_OPEN filter applied value will be accepted if: lower_bound <= value < upper_bound """
closed_open_filter = RangeFilter(Type.CLOSED_OPEN, self.lower_bound, self.upper_bound)
out_range_value = closed_open_filter.filter(self.upper_bound)
in_range_value = closed_open_filter.filter(self.lower_bound)
self.assertEquals(out_range_value, None)
self.assertEquals(in_range_value, self.lower_bound)
def test_greater_than(self):
"""If GREATER_THAN filter applied value will be accepted if: value > upper_bound"""
greater_than_filter = RangeFilter(Type.GREATER_THAN, self.lower_bound, self.upper_bound)
out_range_value = greater_than_filter.filter(self.upper_bound)
in_range_value = greater_than_filter.filter(self.more_than_upper_bound)
self.assertEquals(out_range_value, None)
self.assertEquals(in_range_value, self.more_than_upper_bound)
def test_at_least(self):
"""If AT_LEAST filter applied value will be accepted if: value >= upper_bound"""
at_least_filter = RangeFilter(Type.AT_LEAST, self.lower_bound, self.upper_bound)
out_range_value = at_least_filter.filter(self.less_than_lower_bound)
in_range_value = at_least_filter.filter(self.more_than_upper_bound)
self.assertEquals(out_range_value, None)
self.assertEquals(in_range_value, self.more_than_upper_bound)
def test_less_than(self):
"""If LESS_THAN filter applied value will be accepted if: value < lower_bound"""
less_than_filter = RangeFilter(Type.LESS_THAN, self.lower_bound, self.upper_bound)
out_range_value = less_than_filter.filter(self.lower_bound)
in_range_value = less_than_filter.filter(self.less_than_lower_bound)
self.assertEquals(out_range_value, None)
self.assertEquals(in_range_value, self.less_than_lower_bound)
def test_open_closed_reject(self):
"""If OPEN_CLOSED_REJECT filter applied value will be discarded if: lower_bound < value <= upper_bound"""
open_closed_reject = RangeFilter(Type.OPEN_CLOSED_REJECT, self.lower_bound, self.upper_bound)
out_range_value = open_closed_reject.filter(self.lower_bound)
in_range_value = open_closed_reject.filter(self.upper_bound)
self.assertEquals(out_range_value, self.lower_bound)
self.assertEquals(in_range_value, None)
def test_open_reject(self):
"""If OPEN_REJECT filter applied value will be discarded if: lower_bound < value < upper_bound"""
open_reject_filter = RangeFilter(Type.OPEN_REJECT, self.lower_bound, self.upper_bound)
out_range_value = open_reject_filter.filter(self.lower_bound)
in_range_value = open_reject_filter.filter(self.middle_value)
self.assertEquals(out_range_value, self.lower_bound)
self.assertEquals(in_range_value, None)
def test_closed_reject(self):
"""If CLOSED_REJECT filter applied value will be discarded if: lower_bound <= value <= upper_bound"""
closed_reject_filter = RangeFilter(Type.CLOSED_REJECT, self.lower_bound, self.upper_bound)
out_range_value = closed_reject_filter.filter(self.more_than_upper_bound)
in_range_value = closed_reject_filter.filter(self.lower_bound)
self.assertEquals(out_range_value, self.more_than_upper_bound)
self.assertEquals(in_range_value, None)
def setUp(self):
"""Initialize lower bound, upper bound and a filter for Windowing scheme test"""
self.lower_bound = 10
self.upper_bound = 20
self.middle_value = (self.lower_bound + self.upper_bound) / 2
self.more_than_upper_bound = self.upper_bound + 10
self.window_test_filter = RangeFilter(Type.CLOSED, self.lower_bound,
self.upper_bound)
from linux_metrics import cpu_stat, disk_stat, net_stat
from liota.core.package_manager import LiotaPackage
from liota.lib.utilities.utility import get_default_network_interface, get_disk_name
from liota.lib.utilities.filters.range_filter import RangeFilter, Type
from liota.lib.utilities.filters.windowing_scheme.windowing_scheme import WindowingScheme
dependencies = ["graphite"]
# Getting edge_system's network interface and disk name
network_interface = get_default_network_interface()
disk_name = get_disk_name()
# Filters to filter data at Sampling Functions
# Simple filters
cpu_pro_filter = RangeFilter(Type.CLOSED_REJECT, 5,
10) # If no of CPU processes <=5 or >=10
cpu_util_filter = RangeFilter(Type.AT_LEAST, None, 85) # CPU util >= 85
disk_usage_filter = RangeFilter(Type.AT_LEAST, None, 80) # Disk usage >= 80%
net_usage_filter = RangeFilter(Type.AT_LEAST, None,
1000000) # Network usage >= 1Mb
# Filter with windowing scheme
cpu_util_filter_with_window = WindowingScheme(cpu_util_filter, 30)
# ---------------------------------------------------------------------------
# User defined methods with RangeFilters
def read_cpu_procs():
cnt = cpu_stat.procs_running()
return cpu_pro_filter.filter(cnt)
def test_closed_filter(self):
"""If CLOSED filter applied value will be accepted if: lower_bound <= value <= upper_bound"""
closed_filter = RangeFilter(Type.CLOSED, self.lower_bound, self.upper_bound)
value = closed_filter.filter(self.middle_value)
self.assertEquals(value, self.middle_value)
def test_number_closed(self):
"""If any filter applied on value which is not a number, value will be returned as it is"""
closed_filter = RangeFilter(Type.CLOSED, self.lower_bound, self.upper_bound)
value = closed_filter.filter("6")
self.assertEquals(value, "6")
