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