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 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