def __init__(self, monitoring_latency, stats_interval=None):
super().__init__(monitoring_latency)
self.__name = Cpu.__get_processor_name()
self.__count = psutil.cpu_count()
self.__load = None
self.__temperature = None
# Init temperature reader
self.__temperature_reader = Cpu.__get_processor_temperature_reader()
# Prepare to collect statistics
if stats_interval is None:
stats_interval = timedelta(hours=1)
self.__load_stats = LimitedTimeTable(stats_interval)
self.__temperature_stats = LimitedTimeTable(stats_interval)
# Read updating value at first time
self._monitoring_action()
def __init__(self,
monitoring_latency,
stats_interval=None,
ip_address=None):
super().__init__(monitoring_latency)
self.__name = None
self.__hardware_address = None
if ip_address is None:
ip_address = NetworkInterface.__get_active_ip_address()
self.__ip_address = ip_address
self.__broadcast_address = None
self.__subnet_mask = None
self.__default_route = None
self.__bytes_sent = 0
self.__bytes_recv = 0
# Get interface name, network mask and broadcast address
if self.__ip_address is not None:
for interface in nif.interfaces():
addresses = nif.ifaddresses(interface)
try:
af_inet = addresses[nif.AF_INET][0]
if af_inet['addr'] != self.__ip_address:
continue
af_link = addresses[nif.AF_LINK][0]
self.__name = NetworkInterface.__check_interface_name(
interface)
self.__hardware_address = af_link['addr']
self.__broadcast_address = af_inet['broadcast']
self.__subnet_mask = af_inet['netmask']
break
except (IndexError, KeyError):
# ignore interfaces, which don't have MAC or IP
continue
# Get gateway address
if self.name is not None:
for gateway_info in nif.gateways()[nif.AF_INET]:
if self.name in gateway_info:
self.__default_route = gateway_info[0]
break
# Prepare to collect statistics
if stats_interval is None:
stats_interval = timedelta(hours=1)
self.__bytes_sent_stats = LimitedTimeTable(stats_interval)
self.__bytes_recv_stats = LimitedTimeTable(stats_interval)
# Read updating values at first time
self._monitoring_action()
pass
def __init__(self, monitoring_latency, stats_interval=None):
# Prepare to collect statistic
if stats_interval is None:
stats_interval = timedelta(hours=1)
self.__available_stats = LimitedTimeTable(stats_interval)
self.__used_percent_stats = LimitedTimeTable(stats_interval)
# Get info about total and available memory
try:
self.__total = self._get_total_memory()
self.__available = self._get_available_memory()
now = datetime.now()
self.__available_stats[now] = self.available
self.__used_percent_stats[now] = self.used_percent
except:
self.__total = None
self.__available = None
self.__available_stats.clear()
self.__used_percent_stats.clear()
# Init base class
super().__init__(monitoring_latency)
def __init__(self, monitoring_latency, stats_interval=None):
# Prepare to collect statistic
if stats_interval is None:
stats_interval = timedelta(hours=1)
self.__available_stats = LimitedTimeTable(stats_interval)
self.__used_percent_stats = LimitedTimeTable(stats_interval)
# Get info about total and available memory
try:
self.__total = self._get_total_memory()
self.__available = self._get_available_memory()
now = datetime.now()
self.__available_stats[now] = self.available
self.__used_percent_stats[now] = self.used_percent
except:
self.__total = None
self.__available = None
self.__available_stats.clear()
self.__used_percent_stats.clear()
# Init base class
super().__init__(monitoring_latency)
def test_limited_time_table():
time_span = timedelta(seconds=2)
limited_time_table = LimitedTimeTable(time_span)
assert len(limited_time_table) == 0
with pytest.raises(ArgumentValidationError):
limited_time_table[int()] = 'record #1'
first_record_dtime = datetime.now()
limited_time_table[first_record_dtime] = 'record #1'
assert first_record_dtime in limited_time_table
sleep(0.1)
limited_time_table[datetime.now()] = 'record #2'
assert len(limited_time_table) == 2
with pytest.raises(ValueError):
future = datetime.now() + timedelta(days=1)
limited_time_table[future] = 'record #2'
sleep(2.1)
limited_time_table[datetime.now()] = 'record #3'
assert len(limited_time_table) == 2
class AbsMemory(AbcMonitor, metaclass=ABCMeta):
def __init__(self, monitoring_latency, stats_interval=None):
# Prepare to collect statistic
if stats_interval is None:
stats_interval = timedelta(hours=1)
self.__available_stats = LimitedTimeTable(stats_interval)
self.__used_percent_stats = LimitedTimeTable(stats_interval)
# Get info about total and available memory
try:
self.__total = self._get_total_memory()
self.__available = self._get_available_memory()
now = datetime.now()
self.__available_stats[now] = self.available
self.__used_percent_stats[now] = self.used_percent
except:
self.__total = None
self.__available = None
self.__available_stats.clear()
self.__used_percent_stats.clear()
# Init base class
super().__init__(monitoring_latency)
@property
def total(self):
return self.__total
@property
def available(self):
return self.__available
@property
def used(self):
used_mem = None
if (self.total is not None) and (self.available is not None):
used_mem = self.total - self.available
return used_mem
@property
def used_percent(self):
percent = None
used = self.used
if used is not None:
percent = int(used / self.total * 100)
return percent
@property
def available_stats(self):
return self.__available_stats
@property
def used_percent_stats(self):
return self.__used_percent_stats
def _monitoring_action(self):
try:
self.__available = self._get_available_memory()
now = datetime.now()
self.__available_stats[now] = self.available
self.__used_percent_stats[now] = self.used_percent
except:
self.__available = None
self.__available_stats.clear()
self.__used_percent_stats.clear()
self.stop_monitoring()
@abstractmethod
def _get_total_memory(self):
raise NotImplementedError('Method not implemented by derived class!')
@abstractmethod
def _get_available_memory(self):
raise NotImplementedError('Method not implemented by derived class!')
class AbsMemory(AbcMonitor, metaclass=ABCMeta):
# region initialization
def __init__(self, monitoring_latency, stats_interval=None):
# Prepare to collect statistic
if stats_interval is None:
stats_interval = timedelta(hours=1)
self.__available_stats = LimitedTimeTable(stats_interval)
self.__used_percent_stats = LimitedTimeTable(stats_interval)
# Get info about total and available memory
try:
self.__total = self._get_total_memory()
self.__available = self._get_available_memory()
now = datetime.now()
self.__available_stats[now] = self.available
self.__used_percent_stats[now] = self.used_percent
except:
self.__total = None
self.__available = None
self.__available_stats.clear()
self.__used_percent_stats.clear()
# Init base class
super().__init__(monitoring_latency)
# endregion
# region properties
@property
def total(self):
return self.__total
@property
def available(self):
return self.__available
@property
def used(self):
used_mem = None
if (self.total is not None) and (self.available is not None):
used_mem = self.total - self.available
return used_mem
@property
def used_percent(self):
percent = None
used = self.used
if used is not None:
percent = int(used / self.total * 100)
return percent
@property
def available_stats(self):
return self.__available_stats
@property
def used_percent_stats(self):
return self.__used_percent_stats
# endregion
# region methods
def _monitoring_action(self):
try:
self.__available = self._get_available_memory()
now = datetime.now()
self.__available_stats[now] = self.available
self.__used_percent_stats[now] = self.used_percent
except:
self.__available = None
self.__available_stats.clear()
self.__used_percent_stats.clear()
self.stop_monitoring()
@abstractmethod
def _get_total_memory(self):
raise NotImplementedError('Method not implemented by derived class!')
@abstractmethod
def _get_available_memory(self):
raise NotImplementedError('Method not implemented by derived class!')
# endregion
pass
