def get_time_via_ntp(time_server_address): """ Query some server for atomic time via NTP Notes: * NTP is not an truly adequate solution to this question since it is less accurate than an atomic clock. From Wikipedia: NTP uses Marzullo's algorithm, and includes support for features such as leap seconds. NTPv4 can usually maintain time to within 10 milliseconds (1/100 s) over the public Internet, and can achieve accuracies of 200 microseconds (1/5000 s) or better in local area networks under ideal conditions. * This also feels like cheating :( """ ntp_conn = NTPClient() server_response = ntp_conn.request(time_server_address) return server_response.tx_time
class ServerTime: """ server client class """ def __init__(self): self.hosts = ['ntp1.stratum2.ru', 'ntp2.stratum2.ru', 'pool.ntp.org'] self.client = NTPClient() self.time_obj = None self.get_time() self.TIMEZONE = datetime.now( timezone.utc).astimezone().utcoffset() // timedelta( seconds=1) // 3600 def print_time(self): """ prints the server time """ print(ctime(self.client.request(self.hosts[0]).tx_time)) def get_time(self): for host in self.hosts: try: self.time_obj = localtime(self.client.request(host).tx_time) if bool(self.time_obj): return { 'day': self.time_obj[2], 'month': self.time_obj[1], 'year': self.time_obj[0], 'hours': self.time_obj[3] - self.TIMEZONE, 'minutes': self.time_obj[4], 'seconds': self.time_obj[5], 'day of week': self.time_obj[6] } except Exception: pass def get_time_float(self): return self.time_obj
def get_status(self): server = self.target c = NTPClient() time_start = time.time() try: c.request(server, version=3) return True, time.time() - time_start except NTPException as e: print( f"!!! NTP error encountered for {self.target}, error: {repr(e)}" ) return False, 0.0
def ntptime(is_loc=True, is_errmsg=False): '''Повертає час синхронізований з Інтернет Із файлу _sidnt проекту WorkPrint для Python 2. version: 0.2.1 ''' c = NTPClient() ntp_mirrors = ('ntp.time.in.ua', 'ntp2.time.in.ua', 'pool.ntp.org') # Пошук прийнятного з'єднання (відповіді) із доступних NTP-серверів. for mirror in ntp_mirrors: try: response = c.request(mirror) # Очікування відповіді з NTP-сервера. except: continue else: break try: response.tx_time # UTC-час. fdt = datetime.fromtimestamp if is_loc else datetime.utcfromtimestamp return fdt(response.tx_time) except: if is_errmsg: raise Exception("Не вдалось синхронізувати час! Будь-ласка, " "перевірте з'єднання з Інтернет або дзеркала серверів синхронізації.")
def get_ntp_response(): try: ntp_client = NTPClient() response = ntp_client.request(ntp_server, version=version) except Exception as e: logger.exception(e) sys.exit(0) return response
def get_time_from_ntp_server(): c = NTPClient() for i in range(1, 3): try: response = c.request('in.pool.ntp.org', version=i) break except: pass response.offset return datetime.fromtimestamp(response.tx_time, timezone.utc)
def ntpsync(self): """Perform an NTP synchronization""" self._ntpsynced = True self._command('Attention') if not self._ntp_ip: raise NetStationNoNTPIP() c = NTPClient() response = c.request(self._ntp_ip, version=3) t = time.time() ntp_t = system_to_ntp_time(t + response.offset) _ = self._command('NTPClockSync', ntp_t) self._offset = response.offset self._syncepoch = t
def get_ntp_response(): for retry in range(NTP_RETRIES): ntp_server = config.user.ntp_servers[retry % len(config.user.ntp_servers)] try: ntp_client = NTPClient() response = ntp_client.request(ntp_server, version=NTP_VERSION) except Exception as e: logger.warning(e) continue return response # FIXME: Provide some proper clean before exiting logger.fatal("Could not contact NTP servers after %d retries", NTP_RETRIES) sys.exit(-1)
def get_ntp_response(): for retry in range(NTP_RETRIES): ntp_server = ntp_servers[retry % len(ntp_servers)] try: ntp_client = NTPClient() response = ntp_client.request(ntp_server, version=NTP_VERSION) except Exception as e: logger.warning(e) continue return response # FIXME: Provide some proper clean before exiting logger.fatal("Could not contact NTP servers after %d retries", NTP_RETRIES) sys.exit(-1)
def ntp_time(ntp_server): """ Devuelve timestamp de la fecha y hora obtenida del servidor de tiempo """ from ntplib import NTPClient, NTPException from socket import gaierror ntp_server_tuple = ( 'ar.pool.ntp.org', 'south-america.pool.ntp.org', ) # Genero el objeto NTPclient client = NTPClient() # Obtengo la fecha del ntp_server si este fue suministrado if ntp_server: try: timestamp = client.request(ntp_server).tx_time except (NTPException, gaierror): timestamp = None else: timestamp = None # Si no obtuve respuesta del ntp_server o hubo una excepción, recorro la # tupla ntp_server_tuple hasta que obtengo la primer respuesta if not timestamp: for server in ntp_server_tuple: try: timestamp = client.request(server).tx_time except (NTPException, gaierror): timestamp = None else: # Se ejecuta si no hubo excepciones break return timestamp
def check_expired_date_by_ntp(): from ntplib import NTPClient from time import mktime, strptime NTP_SERVER = 'europe.pool.ntp.org' EXPIRED_DATE = '20190202' print('The license will be expired on %s' % EXPIRED_DATE) print('Check internet time from %s ...' % NTP_SERVER) c = NTPClient() response = c.request(NTP_SERVER, version=3) if response.tx_time > mktime(strptime(EXPIRED_DATE, '%Y%m%d')): print("The license has been expired") sys.exit(1) print("The license is not expired")
def resync(self): """Perform a re-synchronization: NOT RECOMMENDED; INCLUDED FOR COMPLETENESS""" if not self._ntp_ip: raise NetStationNoNTPIP() if not self._ntpsynced: self.ntpsync() c = NTPClient() response = c.request(self._ntp_ip, version=3) t = time.time() ntp_t = system_to_ntp_time(t) _ = self._command('NTPReturnClock', ntp_t + response.offset) self._offset = response.offset # TODO: Turn into a debug option # print('Sent local time: ' + format_time(t)) # print(f'NTP offset is approx {self._offset}') self.send_event(event_type="RESY")
def ntp_time(servers): """ Retorna a hora oficial do Brasil (NTP.br) Returns the official time of Brazil (NTP.br). """ ntp_time = None client = NTPClient() for host in servers: try: response = client.request(host) ntp_time = ctime(response.orig_time) break except (NTPException, socket.gaierror): pass return ntp_time
def checktime(): require_root() ntp = NTPClient() timeservers = cfg.config.getlist('general', 'time_servers') for tserver in timeservers: log.debug('Trying time server [{}]'.format(tserver)) try: response = ntp.request(tserver, version=3) except: log.warning( 'Time server [{}] is not responding, trying next server'. format(tserver)) else: newtime = ctime(response.tx_time) log.info('Time server [{}] returned [{}] with an offset of \ {}'.format(tserver, newtime, response.offset)) log.debug('Updating system time with new queried time') cmddate = subprocess.Popen(['date', '-s', newtime], stdout=subprocess.PIPE) return cmddate.wait()
class SntpNew: def __init__(self, host, port): self.host = host self.port = port self.delta = 0 self.current_time = 0 self.previous_time = 0 self.client = NTPClient() def get_time(self): try: timestamp = self.client.request(self.host, 3, self.port) if self.current_time == 0: self.current_time = timestamp.tx_time return self.delta = timestamp.tx_time - self.current_time self.previous_time = deepcopy(self.current_time) self.current_time = timestamp.tx_time except socket.timeout: return
logging_client.connect() # new_to = 'Timeout' # new_tzco = 'Timeout' while True: try: # send_to_logging('192.168.192.120', 55555, data) logging_client.send() new_to = energy_client.receive() to = new_to if new_to != 'Timeout' else to # print(to) # tzco = request_data(heat_exchanger[0], heat_exchanger[1], 'Tzco') new_tzco = heat_client.receive() tzco = new_tzco if new_tzco != 'Timeout' else tzco # print(tzco) try: new_t = ntp.request(time_server[0], port=time_server[1]).tx_time # new_t = t + 6 except NTPException: new_t = t time_delta = new_t - t t = new_t # print(t) data['timestamp'] = t time_info = datetime.datetime.fromtimestamp(t) day = time_info.weekday() hour = time_info.hour target_temp = 20 if day <= 5 and 7 <= hour <= 22 else 15 error = target_temp - tr error_derivative = (error - last_error)/time_delta error_integral += error*time_delta fcob = max(0, min(max_flow, P*error + I*error_integral + D*error_derivative))
def get_avail_and_rsp_time(service): time_start = time.time() if service["type"] == "https" or service["type"] == "http": try: response = requests.get(service["target"]) except BaseException as e: log_console(f"!!! Exception in HTTP service monitoring: {repr(e)}") return False, None if response.status_code == requests.codes.ok: availability = True response_time = time.time() - time_start else: return False, None elif service["type"] == "dns": target_resolver = Resolver() target_resolver.nameservers = [service["target"]] time_start = time.time() try: response = target_resolver.query(service["data"]) except NXDOMAIN as e: log_console( f'!!! DNS monitor: nonexistent domain name {service["data"]}') return False, None except Timeout as e: log_console( f'!!! DNS monitor: DNS request timed out for {service["target"]}' ) return False, None except BaseException as e: log_console(f"!!! DNS monitor: Exception occurred: {repr(e)}") return False, None if (response is not None and response.response is not None and len(response.response.answer) > 0): availability = True response_time = time.time() - time_start else: return False, None elif service["type"] == "ntp": server = service["target"] c = NTPClient() time_start = time.time() try: result = c.request(server, version=3) except NTPException as e: log_console( f"!!! NTP error encountered for {service['target']}, error: {repr(e)}" ) return False, None availability = True response_time = time.time() - time_start else: log_console(f"!!! Unknown service type: {service['type']}") return False, None return availability, response_time
class AsyncNTPClient(_Interface): """异步NTP客户端类 """ @classmethod async def create(cls, host): client = cls(host) await client.calibrate_offset() client.start() return client def __init__(self, host, *, version=2, port=r'ntp', timeout=5, interval=3600, sampling=5): self._settings = { r'host': host, r'version': version, r'port': port, r'timeout': timeout, } self._client = NTPClient() self._offset = 0 self._thread_pool = ThreadPool(1) self._sync_task = IntervalTask(self.calibrate_offset, interval) self._sampling = sampling def start(self): return self._sync_task.start() def stop(self): return self._sync_task.stop() def is_running(self): return self._sync_task.is_running() async def calibrate_offset(self): return await self._thread_pool.run(self._calibrate_offset) def _calibrate_offset(self): samples = [] host_name = self._settings[r'host'] # 多次采样取中位数,减少抖动影响 for _ in range(self._sampling): try: resp = self._client.request(**self._settings) samples.append(resp.offset) except Exception as err: Utils.log.error(f'NTP server {host_name} request error: {err}') if samples: self._offset = float(numpy.median(samples)) Utils.log.debug( f'NTP server {host_name} offset median {self._offset} samples: {samples}' ) else: raise NTPCalibrateError( f'NTP server {host_name} not available, timestamp uncalibrated' ) @property def offset(self): return self._offset @property def timestamp(self): return time.time() + self._offset
def get_remote_time(ntp_server, ntp_port=123): ntp_client = NTPClient() result = ntp_client.request(ntp_server, port=ntp_port) return datetime.datetime.fromtimestamp(result.tx_time)
#!/usr/bin/python # Demo using ntplib, smtplib, getpass # Get current time from ntp server and send it by email using yahoo account # 28.05.2017, Nicolae Erast from ntplib import NTPClient from time import ctime import smtplib import getpass import sys # add bellow email address to = '*****@*****.**' c = NTPClient() r = c.request('2.ro.pool.ntp.org') print 'Current date and time is: ', ctime(r.tx_time) try: # using ssl ## m = smtplib.SMTP_SSL() ## m.connect('smtp.mail.yahoo.com',465) # cu tls m = smtplib.SMTP() m.connect('smtp.mail.yahoo.com', 587) m.starttls() except smtplib.SMTPConnectError, e: print 'Error connecting to mail server: ', e sys.exit(1) account = str()
def system_data(self, requery_timeoffset=False): """ Returns a dictionary of data containing information about the agent. This is the information that is also passed along to the master. """ # query the time offset and then cache it since # this is typically a blocking operation if config["agent_time_offset"] == "auto": config["agent_time_offset"] = None if requery_timeoffset or config["agent_time_offset"] is None: ntplog.info( "Querying ntp server %r for current time", config["agent_ntp_server"]) ntp_client = NTPClient() try: pool_time = ntp_client.request( config["agent_ntp_server"], version=config["agent_ntp_server_version"]) except Exception as e: ntplog.warning("Failed to determine network time: %s", e) else: config["agent_time_offset"] = \ int(pool_time.tx_time - time.time()) # format the offset for logging purposes utcoffset = datetime.utcfromtimestamp(pool_time.tx_time) iso_timestamp = utcoffset.isoformat() ntplog.debug( "network time: %s (local offset: %r)", iso_timestamp, config["agent_time_offset"]) if config["agent_time_offset"] != 0: ntplog.warning( "Agent is %r second(s) off from ntp server at %r", config["agent_time_offset"], config["agent_ntp_server"]) data = { "id": config["agent_id"], "hostname": config["agent_hostname"], "version": config.version, "os_class": system.operating_system(), "os_fullname": platform(), "ram": int(config["agent_ram"]), "cpus": config["agent_cpus"], "cpu_name": cpu.cpu_name(), "port": config["agent_api_port"], "free_ram": memory.free_ram(), "time_offset": config["agent_time_offset"] or 0, "state": config["state"], "mac_addresses": list(network.mac_addresses()), "current_assignments": config.get( "current_assignments", {}), # may not be set yet "disks": disks.disks(as_dict=True) } try: gpu_names = graphics.graphics_cards() data["gpus"] = gpu_names except graphics.GPULookupError: pass if "remote_ip" in config: data.update(remote_ip=config["remote_ip"]) if config["farm_name"]: data["farm_name"] = config["farm_name"] return data
# sock_outdoor = functions.SockClient(host_o, port_o) print('tk1') # sock_log = functions.SockClient(host_l, port_l) print('tk2') # sock_con = functions.SockClient(host_k, port_k) print('tk3') sock_send = functions.SockClient(host, port) # sock_other = functions.SockClient(host, 52344) resp = True time_client = NTPClient() #serwer t = functions.get_time(host_t, port_t, time_client) ntp = NTPClient() t = ntp.request('europe.pool.ntp.org').tx_time state = {'Tpco': T_PCO, 'Fcob': F_COB, "Tr": T_R, "timestamp": t} while True: while resp: try: # t_prim = functions.get_time(host_t, port_t, time_client) # dt = t_prim-t # t = t_prim # rec_zco = sock_exch.receive() # rec_o = sock_outdoor.receive()
data = {'Tpcob': tpco, 'Fcob': fcob, 'Tr': tr} lock = Lock() host = 'localhost' port = 50009 server = ServerThread(data, host, port) server.start() # Used for local logging and visualization, probably will be deleted later so we don't get a MemoryError because # these get too big. Another option would be to serialize them and save to file but who's got time for that? time_vector = [] tpco_vector = [] tr_vector = [] ntp = NTPClient() t = t_0 = ntp.request('1.pl.pool.ntp.org').tx_time last_error = 0 error_integral = 0 while True: try: to = request_data(energy_provider[0], energy_provider[1], 'To') tzco = request_data(heat_exchanger[0], heat_exchanger[1], 'Tzco') new_t = ntp.request('1.pl.pool.ntp.org').tx_time time_delta = new_t - t t = new_t time_info = datetime.datetime.fromtimestamp(t) day = time_info.weekday() hour = time_info.hour target_temp = 20 if day <= 5 and 7 <= hour <= 22 else 15 error = target_temp - tr error_derivative = (error - last_error) / time_delta