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
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("Не вдалось синхронізувати час! Будь-ласка, " "перевірте з'єднання з Інтернет або дзеркала серверів синхронізації.")
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 __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_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 __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 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_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 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 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 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 collect(self, _): if StrictVersion(agent_version) >= StrictVersion("1.4.6"): from ntplib import NTPClient else: self.logger.warning("This plugin requires agent version 1.4.6 or newer") return Status.CRITICAL # Set how much drift is acceptable before failing, by default 5 mins (300 secs) drift = int(self.get("drift", "300")) hosts = self.get("ntp-hosts", "0.pool.ntp.org,1.pool.ntp.org,2.pool.ntp.org").split(",") random.shuffle(hosts) for h in hosts: try: ntp_ts = NTPClient().request(h).orig_time if ntp_ts: break except Exception as e: self.logger.warning(f"NTP host request '{h}' failed") ntp_ts = None continue if not ntp_ts: return Status.CRITICAL delta_seconds = int(datetime.now().timestamp() - ntp_ts) self.gauge('ntp_drift', {}).set(delta_seconds) if abs(delta_seconds) < drift: return Status.OK else: return Status.CRITICAL
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 main(): ntp_client = NTPClient() date_obj = get_timestamp(ntp_client) first_day = date_obj.replace(day=1).day days_in_month = monthrange(date_obj.year, date_obj.month)[1] month = [day for day in range(first_day, days_in_month)] print(month)
def ntp_now(self)->datetime: """ NTP time now :return: datetime from NTP server. :rtype: datetime.datetime """ response = NTPClient().request(self.poolservers,version=self.version) return datetime.fromtimestamp(response.tx_time)
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()
async def repire_time(): hosts = [ '0.cn.pool.ntp.org', '1.cn.pool.ntp.org', '2.cn.pool.ntp.org', '3.cn.pool.ntp.org' ] r = NTPClient().request(random.choice(hosts), port='ntp', version=4, timeout=5) t = r.tx_time _date, _time = str(datetime.datetime.fromtimestamp(t))[:22].split(' ') os.system('date {} && time {}'.format(_date, _time))
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 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 set_time(self, time=None): """ Sets the time on the clock with a simple Zigbee message. Uses NTP to find the current time if time argument is not given. """ if not time: req = NTPClient().request(TIME_SERVER) time = datetime.fromtimestamp(req.tx_time) hour = 12 if ((time.hour % 12) == 0) else (time.hour % 12) minute, second, pm = time.minute, time.second, (time.hour > 11) else: hour, minute, second, pm = time msg = SET_TIME_COMMAND % (chr(hour), chr(minute), chr(second), chr(pm)) self.xbee.SendData(dbus.ByteArray(msg), dbus.UInt64(self.device_addr), 1)
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
#!/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()
port_o = 8080 host_t = '192.168.192.253' #serwer czasu port_t = 8123 host = '192.168.192.12' port = 52345 #utworzenie połączeń sock_exch = functions.SockClient(host_e, port_e) sock_outdoor = functions.SockClient(host_o, port_o) sock_log = functions.SockClient(host_l, port_l) sock_con = functions.SockClient(host_k, port_k) #połączenie z serwerem czasu time_client = NTPClient() t = functions.get_time(host_t, port_t, time_client) while True: rec_zco = sock_exch.receive() T_ZCO = rec_zco['Tzco'] resp = sock_exch & sock_outdoor if T_ZCO == 0: resp = False state = {'Tpco': T_PCO, 'Fcob': F_COB, "Tr": T_R, "timestamp": t} sock_log.sock.send(b'') sock_outdoor.sock.send(b'1')
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
from __future__ import print_function import time, warnings, sys from time import time as local_timestamp from ntplib import NTPClient, NTPException DEFAULT_SERVER = 'us.pool.ntp.org' DEFAULT_TIMEOUT = 0.25 ntp_client = NTPClient() def ntp_timestamp_generator( server=DEFAULT_SERVER, timeout=DEFAULT_TIMEOUT, ): #this function computes latency corrected timestamps def get_corrected_timestamps(): local_send_time = local_timestamp() resp = ntp_client.request(server, timeout=timeout) local_recv_time = local_timestamp() local_time = (local_send_time + local_recv_time) / 2.0 latency = (local_recv_time - local_send_time) / 2.0 corrected_send_time = resp.recv_timestamp - latency corrected_recv_time = resp.tx_timestamp + latency return (local_time, corrected_send_time, corrected_recv_time) #initialize the time cache last_lt, last_cst, last_crt = get_corrected_timestamps() while True: try: last_lt, last_cst, last_crt = get_corrected_timestamps()
# sock_exch = functions.SockClient(host_e, port_e) print('tk5') # 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
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
addres_kamil = '192.168.192.100' #Kamil port_kamil = 4790 address_michal = '192.168.192.123' #Michał port_michal = 43516 address_przemek = '192.168.192.120' #Przemek port_przemek = 55555 address_adam = '192.168.192.15' #Adam port_adam = 8080 host_t = '192.168.192.253' port_t = 8123 host = '192.168.192.12' port = 52345 host = '127.0.0.1' port = 52344 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 sock_michal = functions.SockClient(address_michal, port_michal) sock_przemek = functions.SockClient(address_przemek, port_przemek) sock_adam = functions.SockClient(address_adam, port_adam) sock_kamil = functions.SockClient(addres_kamil, port_kamil) print("a") last_t = t while True: rec_zco = sock_michal.receive() T_ZCO = rec_zco['Tzco']
def _current_time(self): return NTPClient().request('gps.ntp.br').tx_time
# Data dict we'll be modifying and sending 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
def getTime(): # Get actual time from internet clock c = NTPClient()