コード例 #1
0
    async def exact_time():
        host = app.config['NTP_SERVER']
        port = app.config['NTP_PORT']

        stream = await asyncio_dgram.connect((host, port))

        ntp_request = ExactTimeService.create_ntp_request_data()

        await stream.send(ntp_request)
        response_data, remote_addr = await stream.recv()

        stream.close()

        ntp_stats = ExactTimeService.get_ntp_stats(response_data)

        struct_time = localtime(ntp_stats.tx_time)

        result = {
            'host': host,
            'offset': ntp_stats.offset,
            'date': strftime('%Y.%m.%d', struct_time),
            'time': strftime('%H:%M:%S', struct_time),
            'zone': strftime('%z', struct_time),
            'full_time': strftime('%Y.%m.%d %H:%M:%S %z', struct_time),
            'ref_id': ntp.ref_id_to_text(ntp_stats.ref_id),
        }

        return result
コード例 #2
0
def check_time():
    client = ntplib.NTPClient()
    rsps = client.request('asia.pool.ntp.org', version=3)

    print('Server:', ntplib.ref_id_to_text(rsps.ref_id))
    print('Offset:', rsps.offset)
    print('Time:', format_ts(rsps.tx_time))
コード例 #3
0
ファイル: ntp-tools.py プロジェクト: sbz/ntp-tools
def ntp_request(host: str) -> Union[None, NTPResponse]:
    """
    Request NTP server host to retrieve attributes
    """
    try:
        socket.getaddrinfo(host, "ntp")
    except socket.gaierror as error:
        sys.stderr.write("Cannot resolve host '{}': {}\n".format(host, error))
        sys.stderr.flush()
        return None

    client = ntplib.NTPClient()
    attrs = {}
    try:
        response = client.request(host)

        for attr in [
            "offset",
            "delay",
            "root_delay",
            "leap",
            "version",
            "stratum",
            "mode",
            "ref_id",
        ]:
            attrs[attr] = getattr(response, attr)

        attrs["ref_id"] = ref_id_to_text(attrs["ref_id"], attrs["stratum"])
    except NTPException as error:
        sys.stderr.write("Cannot convert reference: {}\n".format(error))
        sys.stderr.flush()
        return None

    return NTPResponse(host, **attrs)
コード例 #4
0
def clock_state():
    """
    Determine the state of the system clock and return a hash of
    information conforming to the definition of a SystemClockStatus
    object as described in the JSON dictionary.

    time - Current system time as an ISO 8601 string

    synchronized - Whether or not the clock is synchronized to an
    outside source.

    source - The source of synchronization.  Currently, the only valid
    value is "ntp."  Not provided if not synchronized.

    reference - A human-readable string describing the source.  Not
    provided if not synchronized.

    offset - A float indicating the estimated clock offset.  Not
    provided if not synchronized.

    error -

    """

    adjtime = ntp_adjtime()
    system_synchronized = adjtime.synchronized

    # Format the local time with offset as ISO 8601.  Python's
    # strftime() only does "-0400" format; we need "-04:00".

    utc = datetime.datetime.utcnow()
    local_tz = tzlocal.get_localzone()
    time_here = pytz.utc.localize(utc).astimezone(local_tz)

    raw_offset = time_here.strftime("%z")
    if len(raw_offset):
        offset = raw_offset[:3] + ":" + raw_offset[-2:]
    else:
        offset = ""

    result = {
        "time": time_here.strftime("%Y-%m-%dT%H:%M:%S.%f") + offset,
        "synchronized": system_synchronized
    }

    if system_synchronized:

        # Assume NTP for the time being

        try:
            ntp = ntplib.NTPClient().request("127.0.0.1")
            result["offset"] = ntp.offset
            result["source"] = "ntp"
            result["reference"] = "%s from %s" % (ntplib.stratum_to_text(
                ntp.stratum), ntplib.ref_id_to_text(ntp.ref_id))
        except Exception as ex:
            result["synchronized"] = False
            result["error"] = str(ex)

    return result
コード例 #5
0
ファイル: clockstate.py プロジェクト: perfsonar/pscheduler
def clock_state():

    """
    Determine the state of the system clock and return a hash of
    information conforming to the definition of a SystemClockStatus
    object as described in the JSON dictionary.

    time - Current system time as an ISO 8601 string

    synchronized - Whether or not the clock is synchronized to an
    outside source.

    source - The source of synchronization.  Currently, the only valid
    value is "ntp."  Not provided if not synchronized.

    reference - A human-readable string describing the source.  Not
    provided if not synchronized.

    offset - A float indicating the estimated clock offset.  Not
    provided if not synchronized.

    error - 

    """

    adjtime = ntp_adjtime()
    system_synchronized = adjtime.synchronized

    # Format the local time with offset as ISO 8601.  Python's
    # strftime() only does "-0400" format; we need "-04:00".

    utc = datetime.datetime.utcnow()
    local_tz = tzlocal.get_localzone()
    time_here = pytz.utc.localize(utc).astimezone(local_tz)

    raw_offset = time_here.strftime("%z")
    if len(raw_offset):
        offset = raw_offset[:3] + ":" + raw_offset[-2:]
    else:
        offset = ""

    result = {"time": time_here.strftime("%Y-%m-%dT%H:%M:%S.%f") + offset, "synchronized": system_synchronized}

    if system_synchronized:

        # Assume NTP for the time being

        try:
            ntp = ntplib.NTPClient().request("127.0.0.1")
            result["offset"] = ntp.offset
            result["source"] = "ntp"
            result["reference"] = "%s from %s" % (
                ntplib.stratum_to_text(ntp.stratum),
                ntplib.ref_id_to_text(ntp.ref_id),
            )
        except Exception as ex:
            result["error"] = str(ex)

    return result
コード例 #6
0
ファイル: vmtimed.py プロジェクト: tb0hdan/vmtimed
 def query_detail(self, response):
     if response:
         offset = response.offset
         refid = ntplib.ref_id_to_text(response.ref_id)
         rdelay = response.root_delay
     else:
         offset = refid = rdelay = None
     return offset, refid, rdelay
コード例 #7
0
def main(address, v):
    c = ntplib.NTPClient()
    response = c.request(address, version=v)
    print("Response Offset: ", response.offset)
    print("Version: ", response.version)
    print("Response (Time): ", ctime(response.tx_time))
    print("Leap: ", ntplib.leap_to_text(response.leap))
    print("Root Delay: ", response.root_delay)
    print(ntplib.ref_id_to_text(response.ref_id))
コード例 #8
0
ファイル: znt.py プロジェクト: noaaerma/noaadata
    def get_status(self, talker="NT", hostname="127.0.0.1", flag_proprietary=True):
        """Query a NTP server to get the status of time

        FIX: I do not like that I save a string into self.params
        """
        params = {}
        client = ntplib.NTPClient()

        timestamp1 = time.time()
        response = client.request(hostname)  # , version=4)
        timestamp2 = time.time()
        if flag_proprietary and talker[0] != "P":
            talker = "P" + talker
        params["talker"] = talker
        params["timestamp"] = (timestamp1 + timestamp2) / 2.0
        params["host"] = hostname  # Must be IP4 ip address
        params["ref_clock"] = ntplib.ref_id_to_text(response.ref_id, response.stratum)
        params["stratum"] = response.stratum
        params["last_update"] = response.ref_time
        params["offset"] = "%f" % response.offset
        params["precision"] = response.precision
        params["root_delay"] = "%.6f" % response.root_delay
        params["root_dispersion"] = "%.6f" % response.root_dispersion

        # nmea_str = '${talker}ZNT,{timestamp},{host},{ref_clock},{stratum},{last_update},'
        # nmea_str += '{offset},{precision},{root_delay},{root_dispersion}'
        # nmea_str = nmea_str.format(**params)
        fields = []
        for key in (
            "timestamp",
            "host",
            "ref_clock",
            "stratum",
            "last_update",
            "offset",
            "precision",
            "root_delay",
            "root_dispersion",
        ):
            fields.append(str(params[key]))
        nmea_str = "$" + talker + "ZNT," + ",".join(fields)

        checksum = checksum_str(nmea_str)
        nmea_str += "*" + checksum

        self.nmea_str = nmea_str
        self.params = params

        try:
            match = znt_regex.search(nmea_str).groupdict()
        except:
            print "results are wrong???"
            print_response(response)

        return nmea_str
コード例 #9
0
def ntp_logging():
    '''
    Compute a timestamp using NIST Internet Time Servers as an additional 
    level of assurance for database. This function is called by search 
    function or can be called via XML or JSON remote procedure calls.
    
    Example for XMLRPC:
    >>> from xmlrpclib import ServerProxy
    >>> s = ServerProxy('http://ml-lab.bioinformatics.org/init/plugin_notalogger/call/xmlrpc')
    >>> s.ntp_logging()
    '''
    ntp_pool = ['asia.pool.ntp.org',
                'europe.pool.ntp.org',
                'oceania.pool.ntp.org',
                'north-america.pool.ntp.org',
                'south-america.pool.ntp.org',
                'africa.pool.ntp.org']
    client = ntplib.NTPClient()
    server = random.choice(ntp_pool)
    response = client.request(server, version=3)
    try:
        results = ['Network time server: ' + server,
                   'Offset : %f' % response.offset,
                   'Stratum : %s (%d)' % (ntplib.stratum_to_text(response.stratum),
                                          response.stratum),
                   'Precision : %d' % response.precision,
                   'Root delay : %f ' % response.root_delay,
                   'Root dispersion : %f' % response.root_dispersion,
                   'Delay : %f' % response.delay,
                   'Leap indicator : %s (%d)' % (ntplib.leap_to_text(response.leap),
                                                 response.leap),
                   'Poll : %d' % response.poll,
                   'Mode : %s (%d)' % (ntplib.mode_to_text(response.mode),
                                       response.mode),
                   'Reference clock identifier : ' + \
                                        ntplib.ref_id_to_text(response.ref_id,
                                        response.stratum),
                   'Original timestamp : ' + time.ctime(response.orig_time),
                   'Receive timestamp : ' + time.ctime(response.recv_time),
                   'Transmit timestamp : ' + time.ctime(response.tx_time),
                   'Destination timestamp : ' + time.ctime(response.dest_time)]
        results = ' | '.join(results)
    except:
        results = 'Failure to connect to network time server or there is \
        an internet error. Please try again later.'
    notalogger_db.logger.insert(notarizecode='',
                                name='',
                                pidentifier='',
                                email='',
                                usage='NTP pool server time check',
                                comments=results,
                                datetimeserver=str(server),
                                seconds_since_epoch=str(time.time()))
    notalogger_db.commit()
コード例 #10
0
ファイル: cynote.py プロジェクト: mauriceling/cynote2
def ntp_stamp():
    if session.username == None: 
        redirect(URL(r=request, f='../account/log_in'))
    form = FORM(
            TABLE(
                TR('Network Time Servers: ',
                   SELECT('asia.pool.ntp.org',
                          'europe.pool.ntp.org',
                          'oceania.pool.ntp.org',
                          'north-america.pool.ntp.org',
                          'south-america.pool.ntp.org',
                          'africa-america.pool.ntp.org',
                          _name='server')),
                TR(INPUT(_type='submit', _value='Stamp'))))
    if form.accepts(request.vars, session):
        from time import ctime
        import ntplib
        client = ntplib.NTPClient()
        try:
            response = client.request(form.vars.server, version=3)
            results = ['Network time server: ' + form.vars.server,
                       'Offset : %f' % response.offset,
                       'Stratum : %s (%d)' % (ntplib.stratum_to_text(response.stratum),
                            response.stratum),
                       'Precision : %d' % response.precision,
                       'Root delay : %f ' % response.root_delay,
                       'Root dispersion : %f' % response.root_dispersion,
                       'Delay : %f' % response.delay,
                       'Leap indicator : %s (%d)' % (ntplib.leap_to_text(response.leap),
                            response.leap),
                       'Poll : %d' % response.poll,
                       'Mode : %s (%d)' % (ntplib.mode_to_text(response.mode), 
                            response.mode),
                       'Reference clock identifier : ' + \
                            ntplib.ref_id_to_text(response.ref_id,
                            response.stratum), 
                       'Original timestamp : ' + ctime(response.orig_time),
                       'Receive timestamp : ' + ctime(response.recv_time),
                       'Transmit timestamp : ' + ctime(response.tx_time),
                       'Destination timestamp : ' + ctime(response.dest_time)]
            db.log.insert(event='NTP timestamp. ' + ' | '.join(results), 
                      user=session.username)
            db.user_event.insert(event='NTP timestamp. ' + ' | '.join(results), 
                      user=session.username)
            db.entry_hash.insert(eid='NTP', edatetime='NTP', etitle='NTP', 
                        ehash='NTP timestamp. ' + ' | '.join(results))
            db.comment_hash.insert(cid='NTP', cdatetime='NTP', eid='NTP', 
                        chash='NTP timestamp. ' + ' | '.join(results))
        except: 
            results = 'Failure to connect to network time server or there is \
            an internet error. Please try again later.'
        session.result = results
        redirect(URL(r=request, f='ntp_stamp_output'))
    return dict(form=form)
コード例 #11
0
ファイル: apiv1.py プロジェクト: connectical/ntpapi
def stats():
    response = get_data()

    return {
        "time": asctime(gmtime(response.tx_time)),
        "offset": response.offset,
        "leap": ntplib.leap_to_text(response.leap),
        "delay": response.root_delay,
        "ref": ntplib.ref_id_to_text(response.ref_id),
        "stratum": ntplib.stratum_to_text(response.stratum),
        "timestamp": response.tx_time
    }
コード例 #12
0
def main():
    #sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    #sock.sendto("hello!", ("127.0.0.1", 1234))
    c = ntplib.NTPClient()
    rep = c.request("localhost", port=16384)
    rep = c.request("pool.ntp.org")
    print "version", rep.version
    print "offset", rep.offset
    print "root_delay", rep.root_delay
    print "ref_id", rep.ref_id
    print "ref_id text", ntplib.ref_id_to_text(rep.ref_id)
    print "tx_time", rep.tx_time, time.time()
    print "ctime", time.ctime(rep.tx_time)
コード例 #13
0
    def get_status(self,
                   talker='NT',
                   hostname='127.0.0.1',
                   flag_proprietary=True):
        '''Query a NTP server to get the status of time

        FIX: I do not like that I save a string into self.params
        '''
        params = {}
        client = ntplib.NTPClient()

        timestamp1 = time.time()
        response = client.request(hostname)  #, version=4)
        timestamp2 = time.time()
        if flag_proprietary and talker[0] != 'P':
            talker = 'P' + talker
        params['talker'] = talker
        params['timestamp'] = (timestamp1 + timestamp2) / 2.
        params['host'] = hostname  # Must be IP4 ip address
        params['ref_clock'] = ntplib.ref_id_to_text(response.ref_id,
                                                    response.stratum)
        params['stratum'] = response.stratum
        params['last_update'] = response.ref_time
        params['offset'] = '%f' % response.offset
        params['precision'] = response.precision
        params['root_delay'] = '%.6f' % response.root_delay
        params['root_dispersion'] = '%.6f' % response.root_dispersion

        #nmea_str = '${talker}ZNT,{timestamp},{host},{ref_clock},{stratum},{last_update},'
        #nmea_str += '{offset},{precision},{root_delay},{root_dispersion}'
        #nmea_str = nmea_str.format(**params)
        fields = []
        for key in ('timestamp', 'host', 'ref_clock', 'stratum', 'last_update',
                    'offset', 'precision', 'root_delay', 'root_dispersion'):
            fields.append(str(params[key]))
        nmea_str = '$' + talker + 'ZNT,' + ','.join(fields)

        checksum = checksum_str(nmea_str)
        nmea_str += '*' + checksum

        self.nmea_str = nmea_str
        self.params = params

        try:
            match = znt_regex.search(nmea_str).groupdict()
        except:
            print 'results are wrong???'
            print_response(response)

        return nmea_str
コード例 #14
0
    def test_helpers(self):
        """Helper methods tests."""
        client = ntplib.NTPClient()

        time.sleep(self.POLL_DELAY)
        info = client.request(self.NTP_SERVER)

        self.assertEqual(int(info.tx_time), ntplib.ntp_to_system_time(
                         ntplib.system_to_ntp_time(int(info.tx_time))))

        self.assertTrue(isinstance(ntplib.leap_to_text(info.leap), str))
        self.assertTrue(isinstance(ntplib.mode_to_text(info.mode), str))
        self.assertTrue(isinstance(ntplib.stratum_to_text(info.stratum), str))
        self.assertTrue(isinstance(ntplib.ref_id_to_text(info.ref_id,
                                                         info.stratum), str))
コード例 #15
0
    def test_helpers(self):
        """Helper methods tests."""
        client = ntplib.NTPClient()

        time.sleep(self.POLL_DELAY)
        info = client.request(self.NTP_SERVER)

        self.assertEqual(
            int(info.tx_time),
            ntplib.ntp_to_system_time(
                ntplib.system_to_ntp_time(int(info.tx_time))))

        self.assertTrue(isinstance(ntplib.leap_to_text(info.leap), str))
        self.assertTrue(isinstance(ntplib.mode_to_text(info.mode), str))
        self.assertTrue(isinstance(ntplib.stratum_to_text(info.stratum), str))
        self.assertTrue(
            isinstance(ntplib.ref_id_to_text(info.ref_id, info.stratum), str))
コード例 #16
0
ファイル: znt.py プロジェクト: noaaerma/noaadata
def print_response(response):
    print ("Version number : %d" % response.version)
    print ("Offset : %f" % response.offset)
    print ("Stratum : %s (%d)" % (ntplib.stratum_to_text(response.stratum), response.stratum))
    print ("Precision : %d" % response.precision)
    print ("Root delay : %f " % response.root_delay)
    print ("Root dispersion : %f" % response.root_dispersion)
    print ("Delay : %f" % response.delay)
    print ("Leap indicator : %s (%d)" % (ntplib.leap_to_text(response.leap), response.leap))
    print ("Poll : %d" % response.poll)
    print ("Mode : %s (%d)" % (ntplib.mode_to_text(response.mode), response.mode))
    print ("Python time: %f, %s" % (time.time(), str(datetime.datetime.utcnow())))
    print ("Transmit timestamp : " + time.ctime(response.tx_time))
    print ("Reference timestamp : " + time.ctime(response.ref_time))
    print ("Original timestamp : " + time.ctime(response.orig_time))
    print ("Receive timestamp : " + time.ctime(response.recv_time))
    print ("Destination timestamp : " + time.ctime(response.dest_time))
    print ("Reference clock identifier : " + ntplib.ref_id_to_text(response.ref_id, response.stratum))
コード例 #17
0
ファイル: znt.py プロジェクト: schwehr/noaadata
  def get_status(self, talker='NT', hostname='127.0.0.1', flag_proprietary=True):
    """Query a NTP server to get the status of time

    TODO(schwehr): I do not like that I save a string into self.params
    """
    params = {}
    client = ntplib.NTPClient()

    timestamp1 = time.time()
    response = client.request(hostname) #, version=4)
    timestamp2 = time.time()
    if flag_proprietary and talker[0] != 'P':
      talker = 'P' + talker
    params['talker'] = talker
    params['timestamp'] = (timestamp1 + timestamp2) /2.
    params['host'] = hostname # Must be IP4 ip address
    params['ref_clock'] = ntplib.ref_id_to_text(response.ref_id, response.stratum)
    params['stratum'] = response.stratum
    params['last_update'] = response.ref_time
    params['offset'] = '%f' % response.offset
    params['precision'] = response.precision
    params['root_delay'] = '%.6f' % response.root_delay
    params['root_dispersion'] = '%.6f' % response.root_dispersion

    fields = []
    for key in ('timestamp', 'host', 'ref_clock', 'stratum', 'last_update',
                'offset','precision','root_delay','root_dispersion'):
      fields.append(str(params[key]))
    nmea_str = '$' + talker + 'ZNT,' + ','.join(fields)

    checksum = checksum_str(nmea_str)
    nmea_str += '*' + checksum

    self.nmea_str = nmea_str
    self.params = params

    try:
      match = znt_regex.search(nmea_str).groupdict()
    except:
      print 'Results are wrong?'
      print_response(response)

    return nmea_str
コード例 #18
0
ファイル: znt.py プロジェクト: schwehr/noaadata
def print_response(response):
    print('Version number : %d' % response.version)
    print('Offset : %f' % response.offset)
    print('Stratum : %s (%d)' % (ntplib.stratum_to_text(response.stratum),
        response.stratum))
    print('Precision : %d' % response.precision)
    print('Root delay : %f ' % response.root_delay)
    print('Root dispersion : %f' % response.root_dispersion)
    print('Delay : %f' % response.delay)
    print('Leap indicator : %s (%d)' % (ntplib.leap_to_text(response.leap), response.leap))
    print('Poll : %d' % response.poll)
    print('Mode : %s (%d)' % (ntplib.mode_to_text(response.mode), response.mode))
    print('Python time: %f, %s' % (time.time(), str(datetime.datetime.utcnow())))
    print('Transmit timestamp : ' + time.ctime(response.tx_time))
    print('Reference timestamp : ' + time.ctime(response.ref_time))
    print('Original timestamp : ' + time.ctime(response.orig_time))
    print('Receive timestamp : ' + time.ctime(response.recv_time))
    print('Destination timestamp : ' + time.ctime(response.dest_time))
    print('Reference clock identifier : ' + ntplib.ref_id_to_text(response.ref_id, response.stratum))
コード例 #19
0
ファイル: neotool_class.py プロジェクト: neo1seok/neoPyTool
	def doRun(self):
		c = ntplib.NTPClient()
		response = c.request('time.google.com', version=3)

		self.print_view(response.offset)
		self.print_view(response.version)
		self.print_view("서버시간:", ctime(response.tx_time))
		self.print_view("시스템시간:", ctime(time.time()))

		neolib4Win._win_set_time(
			datetime.datetime.fromtimestamp(int(response.tx_time + response.root_delay)).timetuple())
		self.print_view("시스템시간:", ctime(time.time()))

		self.print_view(response.tx_time - time.time())

		self.print_view(ntplib.leap_to_text(response.leap))

		self.print_view(response.root_delay)

		self.print_view(ntplib.ref_id_to_text(response.ref_id))
コード例 #20
0
def print_response(response):
    print('Version number : %d' % response.version)
    print('Offset : %f' % response.offset)
    print('Stratum : %s (%d)' %
          (ntplib.stratum_to_text(response.stratum), response.stratum))
    print('Precision : %d' % response.precision)
    print('Root delay : %f ' % response.root_delay)
    print('Root dispersion : %f' % response.root_dispersion)
    print('Delay : %f' % response.delay)
    print('Leap indicator : %s (%d)' %
          (ntplib.leap_to_text(response.leap), response.leap))
    print('Poll : %d' % response.poll)
    print('Mode : %s (%d)' %
          (ntplib.mode_to_text(response.mode), response.mode))
    print('Python time: %f, %s' %
          (time.time(), str(datetime.datetime.utcnow())))
    print('Transmit timestamp : ' + time.ctime(response.tx_time))
    print('Reference timestamp : ' + time.ctime(response.ref_time))
    print('Original timestamp : ' + time.ctime(response.orig_time))
    print('Receive timestamp : ' + time.ctime(response.recv_time))
    print('Destination timestamp : ' + time.ctime(response.dest_time))
    print('Reference clock identifier : ' +
          ntplib.ref_id_to_text(response.ref_id, response.stratum))
コード例 #21
0

if len(sys.argv) > 1:
    hostname = sys.argv[1]
else:
    sys.stdout.write('NTP server ? ')
    hostname = sys.stdin.readline().strip()

client = ntplib.NTPClient()
response = client.request(hostname, version=3)

print('Version number : %d' % response.version)
print('Offset : %f' % response.offset)
print('Stratum : %s (%d)' % (ntplib.stratum_to_text(response.stratum),
    response.stratum))
print('Precision : %d' % response.precision)
print('Root delay : %f ' % response.root_delay)
print('Root dispersion : %f' % response.root_dispersion)
print('Delay : %f' % response.delay)
print('Leap indicator : %s (%d)' % (ntplib.leap_to_text(response.leap),
    response.leap))
print('Poll : %d' % response.poll)
print('Mode : %s (%d)' % (ntplib.mode_to_text(response.mode), response.mode))
print('Transmit timestamp : ' + str(response.tx_time))
print('Reference timestamp : ' + str(response.ref_time))
print('Original timestamp : ' + str(response.orig_time))
print('Receive timestamp : ' + str(response.recv_time))
print('Destination timestamp : ' + str(response.dest_time))
print('Reference clock identifier : ' + ntplib.ref_id_to_text(response.ref_id,
    response.stratum))
コード例 #22
0
#
#   La lista de algunos servidores se hora:
#   https://tf.nist.gov/tf-cgi/servers.cgi
#   http://support.ntp.org/bin/view/Servers/StratumOneTimeServers
#

import datetime
from time import ctime
import ntplib
import os

try:
    servidor_de_tiempo = "https://tf.nist.gov/tf-cgi/servers.cgi"
    client = ntplib.NTPClient()
    response = client.request(servidor_de_tiempo, version=4)
    print("====================================")
    print("Pidiendo hora a: " + servidor_de_tiempo)
    print(" Offset : " + str(response.offset))
    print(" Version : " + str(response.version))
    print(" Date Time : " + str(ctime(response.tx_time)))
    print(" Leap : " + str(ntplib.leap_to_text(response.leap)))
    print(" Root Delay : " + str(response.root_delay))
    print(" Ref Id : " + str(ntplib.ref_id_to_text(response.ref_id)))
    os.system("sudo date -s '" + str(ctime(response.tx_time)) + "'")
    print("Hora actualizada")
    print("====================================")
except:
    os.system("sudo date")
    print("NTP Server Down Date Time NOT Set At The Startup")
    pass
コード例 #23
0
#!/usr/bin/env python3
import ntplib
import os
import mod_log

from time import ctime
c = ntplib.NTPClient()
response = c.request('it.pool.ntp.org')
print (response.offset)
print (response.version)
print (ctime(response.tx_time))
print (ntplib.leap_to_text(response.leap))
print (response.root_delay)
print (ntplib.ref_id_to_text(response.ref_id))

print(ctime(response.tx_time))
print(ntplib.system_to_ntp_time)

#print (os.system)
#os.system('/etc/init.d/ntpd stop, /usr/sbin/ntpdate -b -s it.pool.ntp.org, /etc/init.d/ntpd start')
current_time = ctime(response.tx_time)
#os.system("sudo date -s '{0}'".format(current_time))
os.system("service ntp stop")
os.system(ntpdate .format(current_time)
os.system("service ntp start")


#self.logger.info('Raptor rozpoczal prace: {0}'.format(current_time))


#os.system('/etc/init.d/ntpd stop, /usr/sbin/ntpdate -b -s it.pool.ntp.org, /etc/init.d/ntpd start')
コード例 #24
0
#!/usr/bin/env python
import ntplib
from time import ctime

HOST_NAME = '85.199.214.98'

if __name__ == '__main__':
    params = {}
    client = ntplib.NTPClient()
    response = client.request(HOST_NAME)
    print('Received time: %s' %ctime(response.tx_time))
    print('ref_clock: ',ntplib.ref_id_to_text(response.ref_id, response.stratum))
    print('stratum: ',response.stratum)
    print('last_update: ', response.ref_time)
    print('offset:  %f' %response.offset)
    print('precision: ', response.precision)
    print('root_delay: %.6f' %response.root_delay)
    print('root_dispersion: %.6f' %response.root_dispersion)

コード例 #25
0
#!/usr/bin/env python
import ntplib
from time import ctime

HOST_NAME = 'pool.ntp.org'

if __name__ == '__main__':
    params = {}
    client = ntplib.NTPClient()
    response = client.request(HOST_NAME)
    print('Received time: %s' % ctime(response.tx_time))
    print('ref_clock: ',
          ntplib.ref_id_to_text(response.ref_id, response.stratum))
    print('stratum: ', response.stratum)
    print('last_update: ', response.ref_time)
    print('offset:  %f' % response.offset)
    print('precision: ', response.precision)
    print('root_delay: %.6f' % response.root_delay)
    print('root_dispersion: %.6f' % response.root_dispersion)