ਇੱਕ ਸਧਾਰਨ NTP ਕਲਾਇੰਟ ਲਿਖਣਾ

ਹੈਲੋ, Habrausers. ਅੱਜ ਮੈਂ ਇਸ ਬਾਰੇ ਗੱਲ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਤੁਹਾਡੇ ਆਪਣੇ ਸਧਾਰਨ NTP ਕਲਾਇੰਟ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ. ਅਸਲ ਵਿੱਚ, ਗੱਲਬਾਤ ਪੈਕੇਟ ਦੀ ਬਣਤਰ ਅਤੇ NTP ਸਰਵਰ ਤੋਂ ਜਵਾਬ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਵਿਧੀ ਵੱਲ ਮੁੜੇਗੀ। ਕੋਡ ਪਾਈਥਨ ਵਿੱਚ ਲਿਖਿਆ ਜਾਵੇਗਾ, ਕਿਉਂਕਿ ਇਹ ਮੈਨੂੰ ਜਾਪਦਾ ਹੈ ਕਿ ਅਜਿਹੀਆਂ ਚੀਜ਼ਾਂ ਲਈ ਕੋਈ ਬਿਹਤਰ ਭਾਸ਼ਾ ਨਹੀਂ ਹੈ। ਕੌਨੋਇਸਰਜ਼ ntplib ਕੋਡ ਦੇ ਨਾਲ ਕੋਡ ਦੀ ਸਮਾਨਤਾ ਨੂੰ ਨੋਟ ਕਰਨਗੇ - ਮੈਂ ਇਸ ਤੋਂ "ਪ੍ਰੇਰਿਤ" ਸੀ।

ਤਾਂ ਅਸਲ ਵਿੱਚ NTP ਕੀ ਹੈ? NTP ਸਹੀ ਸਮੇਂ ਦੇ ਸਰਵਰਾਂ ਨਾਲ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਲਈ ਇੱਕ ਪ੍ਰੋਟੋਕੋਲ ਹੈ। ਇਹ ਪ੍ਰੋਟੋਕੋਲ ਬਹੁਤ ਸਾਰੀਆਂ ਆਧੁਨਿਕ ਮਸ਼ੀਨਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਵਿੰਡੋਜ਼ ਵਿੱਚ w32tm ਸੇਵਾ।

ਕੁੱਲ ਮਿਲਾ ਕੇ NTP ਪ੍ਰੋਟੋਕੋਲ ਦੇ 5 ਸੰਸਕਰਣ ਹਨ। ਪਹਿਲਾ, ਸੰਸਕਰਣ 0 (1985, RFC958)), ਵਰਤਮਾਨ ਵਿੱਚ ਪੁਰਾਣਾ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਹੁਣ ਨਵੇਂ ਵਰਤੇ ਜਾਂਦੇ ਹਨ, ਪਹਿਲਾ (1, RFC1988), ਦੂਜਾ (1059, RFC2), ਤੀਜਾ (1989, RFC1119) ਅਤੇ ਚੌਥਾ (3, RFC1992)। ਸੰਸਕਰਣ 1305-4 ਇੱਕ ਦੂਜੇ ਦੇ ਅਨੁਕੂਲ ਹਨ; ਉਹ ਸਿਰਫ ਸਰਵਰ ਓਪਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਵਿੱਚ ਵੱਖਰੇ ਹਨ।

ਪੈਕੇਜ ਫਾਰਮੈਟ

ਲੀਪ ਸੂਚਕ (ਸੁਧਾਰ ਸੂਚਕ) - ਇੱਕ ਸੰਖਿਆ ਜੋ ਤਾਲਮੇਲ ਸੈਕਿੰਡ ਬਾਰੇ ਚੇਤਾਵਨੀ ਦਰਸਾਉਂਦੀ ਹੈ। ਭਾਵ:

• 0 - ਕੋਈ ਸੁਧਾਰ ਨਹੀਂ
• 1 - ਦਿਨ ਦੇ ਆਖਰੀ ਮਿੰਟ ਵਿੱਚ 61 ਸਕਿੰਟ ਹੁੰਦੇ ਹਨ
• 2 - ਦਿਨ ਦੇ ਆਖਰੀ ਮਿੰਟ ਵਿੱਚ 59 ਸਕਿੰਟ ਹੁੰਦੇ ਹਨ
• 3 - ਸਰਵਰ ਖਰਾਬੀ (ਸਮਾਂ ਸਮਕਾਲੀ ਨਹੀਂ ਹੈ)

ਵਰਜਨ ਨੰਬਰ (ਵਰਜਨ ਨੰਬਰ) – NTP ਪ੍ਰੋਟੋਕੋਲ ਵਰਜਨ ਨੰਬਰ (1-4)।

ਮੋਡ (ਮੋਡ) - ਪੈਕੇਟ ਭੇਜਣ ਵਾਲੇ ਦਾ ਓਪਰੇਟਿੰਗ ਮੋਡ। 0 ਤੋਂ 7 ਤੱਕ ਦਾ ਮੁੱਲ, ਸਭ ਤੋਂ ਆਮ:

• 3 - ਗਾਹਕ
• 4 - ਸਰਵਰ
• 5 - ਪ੍ਰਸਾਰਣ ਮੋਡ

ਸਟ੍ਰੈਟਮ (ਲੇਅਰਿੰਗ ਪੱਧਰ) - ਸਰਵਰ ਅਤੇ ਸੰਦਰਭ ਘੜੀ ਦੇ ਵਿਚਕਾਰ ਵਿਚਕਾਰਲੇ ਲੇਅਰਾਂ ਦੀ ਗਿਣਤੀ (1 - ਸਰਵਰ ਹਵਾਲਾ ਘੜੀ ਤੋਂ ਸਿੱਧਾ ਡਾਟਾ ਲੈਂਦਾ ਹੈ, 2 - ਸਰਵਰ ਲੇਅਰ 1, ਆਦਿ ਵਾਲੇ ਸਰਵਰ ਤੋਂ ਡਾਟਾ ਲੈਂਦਾ ਹੈ)।
ਪੂਲ ਲਗਾਤਾਰ ਸੁਨੇਹਿਆਂ ਵਿਚਕਾਰ ਵੱਧ ਤੋਂ ਵੱਧ ਅੰਤਰਾਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਇੱਕ ਹਸਤਾਖਰਿਤ ਪੂਰਨ ਅੰਕ ਹੈ। NTP ਕਲਾਇੰਟ ਇੱਥੇ ਅੰਤਰਾਲ ਨੂੰ ਨਿਰਧਾਰਿਤ ਕਰਦਾ ਹੈ ਜਿਸ 'ਤੇ ਇਹ ਸਰਵਰ ਨੂੰ ਪੋਲ ਕਰਨ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ, ਅਤੇ NTP ਸਰਵਰ ਉਸ ਅੰਤਰਾਲ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜਿਸ 'ਤੇ ਇਹ ਪੋਲ ਕੀਤੇ ਜਾਣ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ। ਮੁੱਲ ਸਕਿੰਟਾਂ ਦੇ ਬਾਈਨਰੀ ਲਘੂਗਣਕ ਦੇ ਬਰਾਬਰ ਹੈ।
ਸ਼ੁੱਧਤਾ (ਸ਼ੁੱਧਤਾ) ਇੱਕ ਹਸਤਾਖਰਿਤ ਪੂਰਨ ਅੰਕ ਹੈ ਜੋ ਸਿਸਟਮ ਕਲਾਕ ਦੀ ਸ਼ੁੱਧਤਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਮੁੱਲ ਸਕਿੰਟਾਂ ਦੇ ਬਾਈਨਰੀ ਲਘੂਗਣਕ ਦੇ ਬਰਾਬਰ ਹੈ।
ਰੂਟ ਦੇਰੀ (ਸਰਵਰ ਦੇਰੀ) - ਘੜੀ ਰੀਡਿੰਗ ਨੂੰ NTP ਸਰਵਰ ਤੱਕ ਪਹੁੰਚਣ ਲਈ ਸਮਾਂ ਲੱਗਦਾ ਹੈ, ਸਕਿੰਟਾਂ ਦੀ ਇੱਕ ਨਿਸ਼ਚਿਤ-ਪੁਆਇੰਟ ਸੰਖਿਆ ਦੇ ਰੂਪ ਵਿੱਚ।
ਰੂਟ ਫੈਲਾਅ (ਸਰਵਰ ਫੈਲਾਅ) - ਇੱਕ ਨਿਸ਼ਚਤ ਬਿੰਦੂ ਦੇ ਨਾਲ ਕਈ ਸਕਿੰਟਾਂ ਦੇ ਰੂਪ ਵਿੱਚ NTP ਸਰਵਰ ਕਲਾਕ ਰੀਡਿੰਗ ਦਾ ਫੈਲਣਾ।
ਰੈਫਰੀ ਆਈ.ਡੀ (ਸਰੋਤ ਪਛਾਣਕਰਤਾ) - ਘੜੀ ਆਈ.ਡੀ. ਜੇਕਰ ਸਰਵਰ ਵਿੱਚ ਸਟ੍ਰੈਟਮ 1 ਹੈ, ਤਾਂ ਰੈਫ ਆਈਡੀ ਪਰਮਾਣੂ ਘੜੀ (4 ASCII ਅੱਖਰ) ਦਾ ਨਾਮ ਹੈ। ਜੇਕਰ ਸਰਵਰ ਕਿਸੇ ਹੋਰ ਸਰਵਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਤਾਂ ਰੈਫ ਆਈਡੀ ਵਿੱਚ ਇਸ ਸਰਵਰ ਦਾ ਪਤਾ ਹੁੰਦਾ ਹੈ।
ਆਖਰੀ 4 ਖੇਤਰ ਸਮੇਂ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ - 32 ਬਿੱਟ - ਪੂਰਨ ਅੰਕ, 32 ਬਿੱਟ - ਫ੍ਰੈਕਸ਼ਨਲ ਹਿੱਸਾ।
ਹਵਾਲਾ - ਸਰਵਰ 'ਤੇ ਨਵੀਨਤਮ ਘੜੀ ਰੀਡਿੰਗ।
ਸ਼ੁਰੂ - ਉਹ ਸਮਾਂ ਜਦੋਂ ਪੈਕੇਟ ਭੇਜਿਆ ਗਿਆ ਸੀ (ਸਰਵਰ ਦੁਆਰਾ ਭਰਿਆ ਗਿਆ - ਹੇਠਾਂ ਇਸ ਬਾਰੇ ਹੋਰ)।
ਪ੍ਰਾਪਤ ਕਰੋ - ਸਰਵਰ ਦੁਆਰਾ ਪੈਕੇਟ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਸਮਾਂ।
ਪ੍ਰਸਾਰਿਤ - ਸਰਵਰ ਤੋਂ ਗਾਹਕ ਨੂੰ ਪੈਕੇਟ ਭੇਜਣ ਦਾ ਸਮਾਂ (ਕਲਾਇੰਟ ਦੁਆਰਾ ਭਰਿਆ ਗਿਆ, ਹੇਠਾਂ ਇਸ ਬਾਰੇ ਹੋਰ)।

ਅਸੀਂ ਆਖਰੀ ਦੋ ਖੇਤਰਾਂ 'ਤੇ ਵਿਚਾਰ ਨਹੀਂ ਕਰਾਂਗੇ।

ਆਓ ਸਾਡਾ ਪੈਕੇਜ ਲਿਖੀਏ:

ਪੈਕੇਜ ਕੋਡ

class NTPPacket:
    _FORMAT = "!B B b b 11I"

    def __init__(self, version_number=2, mode=3, transmit=0):
        # Necessary of enter leap second (2 bits)
        self.leap_indicator = 0
        # Version of protocol (3 bits)
        self.version_number = version_number
        # Mode of sender (3 bits)
        self.mode = mode
        # The level of "layering" reading time (1 byte)
        self.stratum = 0
        # Interval between requests (1 byte)
        self.pool = 0
        # Precision (log2) (1 byte)
        self.precision = 0
        # Interval for the clock reach NTP server (4 bytes)
        self.root_delay = 0
        # Scatter the clock NTP-server (4 bytes)
        self.root_dispersion = 0
        # Indicator of clocks (4 bytes)
        self.ref_id = 0
        # Last update time on server (8 bytes)
        self.reference = 0
        # Time of sending packet from local machine (8 bytes)
        self.originate = 0
        # Time of receipt on server (8 bytes)
        self.receive = 0
        # Time of sending answer from server (8 bytes)
        self.transmit = transmit

ਸਰਵਰ ਨੂੰ ਇੱਕ ਪੈਕੇਟ ਭੇਜਣ (ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਨ) ਲਈ, ਸਾਨੂੰ ਇਸਨੂੰ ਇੱਕ ਬਾਈਟ ਐਰੇ ਵਿੱਚ ਬਦਲਣ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
ਇਸ (ਅਤੇ ਉਲਟ) ਕਾਰਵਾਈ ਲਈ, ਅਸੀਂ ਦੋ ਫੰਕਸ਼ਨ ਲਿਖਾਂਗੇ - pack() ਅਤੇ unpack():

ਪੈਕ ਫੰਕਸ਼ਨ

def pack(self):
        return struct.pack(NTPPacket._FORMAT,
                (self.leap_indicator << 6) + 
                    (self.version_number << 3) + self.mode,
                self.stratum,
                self.pool,
                self.precision,
                int(self.root_delay) + get_fraction(self.root_delay, 16),
                int(self.root_dispersion) + 
                    get_fraction(self.root_dispersion, 16),
                self.ref_id,
                int(self.reference),
                get_fraction(self.reference, 32),
                int(self.originate),
                get_fraction(self.originate, 32),
                int(self.receive),
                get_fraction(self.receive, 32),
                int(self.transmit),
                get_fraction(self.transmit, 32))

ਅਨਪੈਕ ਫੰਕਸ਼ਨ

def unpack(self, data: bytes):
        unpacked_data = struct.unpack(NTPPacket._FORMAT, data)

        self.leap_indicator = unpacked_data[0] >> 6  # 2 bits
        self.version_number = unpacked_data[0] >> 3 & 0b111  # 3 bits
        self.mode = unpacked_data[0] & 0b111  # 3 bits

        self.stratum = unpacked_data[1]  # 1 byte
        self.pool = unpacked_data[2]  # 1 byte
        self.precision = unpacked_data[3]  # 1 byte

        # 2 bytes | 2 bytes
        self.root_delay = (unpacked_data[4] >> 16) +
            (unpacked_data[4] & 0xFFFF) / 2 ** 16
         # 2 bytes | 2 bytes
        self.root_dispersion = (unpacked_data[5] >> 16) +
            (unpacked_data[5] & 0xFFFF) / 2 ** 16 

        # 4 bytes
        self.ref_id = str((unpacked_data[6] >> 24) & 0xFF) + " " + 
                      str((unpacked_data[6] >> 16) & 0xFF) + " " +  
                      str((unpacked_data[6] >> 8) & 0xFF) + " " +  
                      str(unpacked_data[6] & 0xFF)

        self.reference = unpacked_data[7] + unpacked_data[8] / 2 ** 32  # 8 bytes
        self.originate = unpacked_data[9] + unpacked_data[10] / 2 ** 32  # 8 bytes
        self.receive = unpacked_data[11] + unpacked_data[12] / 2 ** 32  # 8 bytes
        self.transmit = unpacked_data[13] + unpacked_data[14] / 2 ** 32  # 8 bytes

        return self

ਆਲਸੀ ਲੋਕਾਂ ਲਈ, ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਰੂਪ ਵਿੱਚ - ਕੋਡ ਜੋ ਇੱਕ ਪੈਕੇਜ ਨੂੰ ਇੱਕ ਸੁੰਦਰ ਸਤਰ ਵਿੱਚ ਬਦਲਦਾ ਹੈ

def to_display(self):
        return "Leap indicator: {0.leap_indicator}n" 
                "Version number: {0.version_number}n" 
                "Mode: {0.mode}n" 
                "Stratum: {0.stratum}n" 
                "Pool: {0.pool}n" 
                "Precision: {0.precision}n" 
                "Root delay: {0.root_delay}n" 
                "Root dispersion: {0.root_dispersion}n" 
                "Ref id: {0.ref_id}n" 
                "Reference: {0.reference}n" 
                "Originate: {0.originate}n" 
                "Receive: {0.receive}n" 
                "Transmit: {0.transmit}"
                .format(self)

ਸਰਵਰ ਨੂੰ ਪੈਕੇਜ ਭੇਜਿਆ ਜਾ ਰਿਹਾ ਹੈ

ਭਰੇ ਹੋਏ ਖੇਤਰਾਂ ਵਾਲਾ ਇੱਕ ਪੈਕੇਟ ਸਰਵਰ ਨੂੰ ਭੇਜਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਵਰਜਨ, ਮੋਡ и ਪ੍ਰਸਾਰਿਤ. The ਪ੍ਰਸਾਰਿਤ ਤੁਹਾਨੂੰ ਸਥਾਨਕ ਮਸ਼ੀਨ 'ਤੇ ਮੌਜੂਦਾ ਸਮਾਂ (1 ਜਨਵਰੀ 1900 ਤੋਂ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ), ਸੰਸਕਰਣ - 1-4 ਵਿੱਚੋਂ ਕੋਈ ਵੀ, ਮੋਡ - 3 (ਕਲਾਇੰਟ ਮੋਡ) ਨਿਰਧਾਰਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।

ਸਰਵਰ, ਬੇਨਤੀ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨ ਤੋਂ ਬਾਅਦ, NTP ਪੈਕੇਟ ਵਿੱਚ ਸਾਰੇ ਖੇਤਰਾਂ ਨੂੰ ਭਰਦਾ ਹੈ, ਖੇਤਰ ਵਿੱਚ ਨਕਲ ਕਰਦਾ ਹੈ ਸ਼ੁਰੂ ਤੋਂ ਮੁੱਲ ਪ੍ਰਸਾਰਿਤ, ਜੋ ਕਿ ਬੇਨਤੀ ਵਿੱਚ ਆਇਆ ਸੀ. ਇਹ ਮੇਰੇ ਲਈ ਇੱਕ ਰਹੱਸ ਹੈ ਕਿ ਗਾਹਕ ਖੇਤਰ ਵਿੱਚ ਆਪਣੇ ਸਮੇਂ ਦੀ ਕੀਮਤ ਨੂੰ ਤੁਰੰਤ ਕਿਉਂ ਨਹੀਂ ਭਰ ਸਕਦਾ ਹੈ ਸ਼ੁਰੂ. ਨਤੀਜੇ ਵਜੋਂ, ਜਦੋਂ ਪੈਕੇਟ ਵਾਪਸ ਆਉਂਦਾ ਹੈ, ਤਾਂ ਕਲਾਇੰਟ ਕੋਲ 4 ਸਮੇਂ ਦੇ ਮੁੱਲ ਹੁੰਦੇ ਹਨ - ਜਦੋਂ ਬੇਨਤੀ ਭੇਜੀ ਗਈ ਸੀ (ਸ਼ੁਰੂ), ਸਰਵਰ ਨੂੰ ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਸਮਾਂ (ਪ੍ਰਾਪਤ ਕਰੋ), ਜਦੋਂ ਸਰਵਰ ਨੇ ਜਵਾਬ ਭੇਜਿਆ (ਪ੍ਰਸਾਰਿਤ) ਅਤੇ ਗਾਹਕ ਨੂੰ ਜਵਾਬ ਮਿਲਣ ਦਾ ਸਮਾਂ - ਪਹੁੰਚੋ (ਪੈਕੇਜ ਵਿੱਚ ਨਹੀਂ)। ਇਹਨਾਂ ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਸੀਂ ਸਹੀ ਸਮਾਂ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹਾਂ।

ਪੈਕੇਜ ਭੇਜਣਾ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਨਾ ਕੋਡ

# Time difference between 1970 and 1900, seconds
FORMAT_DIFF = (datetime.date(1970, 1, 1) - datetime.date(1900, 1, 1)).days * 24 * 3600
# Waiting time for recv (seconds)
WAITING_TIME = 5
server = "pool.ntp.org"
port = 123
    
packet = NTPPacket(version_number=2, mode=3, transmit=time.time() + FORMAT_DIFF)
answer = NTPPacket()
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
    s.settimeout(WAITING_TIME)
    s.sendto(packet.pack(), (server, port))
    data = s.recv(48)
    arrive_time = time.time() + FORMAT_DIFF
    answer.unpack(data)

ਸਰਵਰ ਤੋਂ ਡਾਟਾ ਪ੍ਰੋਸੈਸ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਸਰਵਰ ਤੋਂ ਡੇਟਾ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨਾ ਰੇਮੰਡ ਐਮ. ਸਮੂਲੀਅਨ (1978) ਦੀ ਪੁਰਾਣੀ ਸਮੱਸਿਆ ਤੋਂ ਅੰਗਰੇਜ਼ ਸੱਜਣ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਦੇ ਸਮਾਨ ਹੈ: "ਇੱਕ ਆਦਮੀ ਕੋਲ ਗੁੱਟ ਘੜੀ ਨਹੀਂ ਸੀ, ਪਰ ਘਰ ਵਿੱਚ ਇੱਕ ਸਹੀ ਕੰਧ ਘੜੀ ਸੀ, ਜਿਸਨੂੰ ਉਹ ਕਈ ਵਾਰ ਭੁੱਲ ਜਾਂਦਾ ਸੀ। ਹਵਾ ਨੂੰ. ਇੱਕ ਦਿਨ, ਆਪਣੀ ਘੜੀ ਨੂੰ ਦੁਬਾਰਾ ਚਲਾਉਣਾ ਭੁੱਲ ਗਿਆ, ਉਹ ਆਪਣੇ ਦੋਸਤ ਨੂੰ ਮਿਲਣ ਚਲਾ ਗਿਆ, ਸ਼ਾਮ ਉਸ ਨਾਲ ਬਿਤਾਈ, ਅਤੇ ਜਦੋਂ ਉਹ ਘਰ ਵਾਪਸ ਆਇਆ, ਤਾਂ ਉਸਨੇ ਘੜੀ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਸੈੱਟ ਕੀਤਾ। ਜੇ ਯਾਤਰਾ ਦਾ ਸਮਾਂ ਪਹਿਲਾਂ ਤੋਂ ਪਤਾ ਨਹੀਂ ਸੀ ਤਾਂ ਉਸਨੇ ਅਜਿਹਾ ਕਿਵੇਂ ਕੀਤਾ? ਜਵਾਬ ਹੈ: “ਘਰ ਛੱਡਣ ਵੇਲੇ, ਇੱਕ ਵਿਅਕਤੀ ਆਪਣੀ ਘੜੀ ਨੂੰ ਹਵਾ ਦਿੰਦਾ ਹੈ ਅਤੇ ਯਾਦ ਰੱਖਦਾ ਹੈ ਕਿ ਹੱਥ ਕਿਸ ਸਥਿਤੀ ਵਿੱਚ ਹਨ। ਕਿਸੇ ਦੋਸਤ ਕੋਲ ਆ ਕੇ ਅਤੇ ਮਹਿਮਾਨਾਂ ਨੂੰ ਛੱਡ ਕੇ, ਉਹ ਆਪਣੇ ਆਉਣ ਅਤੇ ਜਾਣ ਦਾ ਸਮਾਂ ਨੋਟ ਕਰਦਾ ਹੈ। ਇਹ ਉਸਨੂੰ ਇਹ ਪਤਾ ਲਗਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਕਿ ਉਹ ਕਿੰਨੇ ਸਮੇਂ ਲਈ ਮੁਲਾਕਾਤ ਕਰ ਰਿਹਾ ਸੀ। ਘਰ ਵਾਪਸ ਆ ਕੇ ਅਤੇ ਘੜੀ ਨੂੰ ਦੇਖ ਕੇ, ਇੱਕ ਵਿਅਕਤੀ ਆਪਣੀ ਗੈਰਹਾਜ਼ਰੀ ਦੀ ਮਿਆਦ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ. ਇਸ ਸਮੇਂ ਤੋਂ ਘਟਾ ਕੇ ਉਸ ਨੇ ਮਿਲਣ ਲਈ ਬਿਤਾਇਆ ਸਮਾਂ, ਇੱਕ ਵਿਅਕਤੀ ਉੱਥੇ ਅਤੇ ਵਾਪਸ ਯਾਤਰਾ ਕਰਨ ਵਿੱਚ ਬਿਤਾਏ ਸਮੇਂ ਦਾ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ। ਮਹਿਮਾਨਾਂ ਨੂੰ ਛੱਡਣ ਦੇ ਸਮੇਂ ਵਿੱਚ ਸੜਕ 'ਤੇ ਬਿਤਾਏ ਅੱਧੇ ਸਮੇਂ ਨੂੰ ਜੋੜ ਕੇ, ਉਸਨੂੰ ਘਰ ਪਹੁੰਚਣ ਦਾ ਸਮਾਂ ਪਤਾ ਕਰਨ ਅਤੇ ਉਸ ਅਨੁਸਾਰ ਆਪਣੀ ਘੜੀ ਦੇ ਹੱਥਾਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰਨ ਦਾ ਮੌਕਾ ਮਿਲਦਾ ਹੈ।

ਸਰਵਰ ਦੁਆਰਾ ਇੱਕ ਬੇਨਤੀ 'ਤੇ ਕੰਮ ਕਰਨ ਦਾ ਸਮਾਂ ਲੱਭੋ:

1. ਗਾਹਕ ਤੋਂ ਸਰਵਰ ਤੱਕ ਪੈਕੇਟ ਦਾ ਯਾਤਰਾ ਸਮਾਂ ਲੱਭੋ: ((ਪਹੁੰਚੋ – ਉਤਪੰਨ ਕਰੋ) – (ਪ੍ਰਸਾਰਿਤ – ਪ੍ਰਾਪਤ ਕਰੋ)) / 2
2. ਕਲਾਇੰਟ ਅਤੇ ਸਰਵਰ ਦੇ ਸਮੇਂ ਵਿੱਚ ਅੰਤਰ ਲੱਭੋ:
   ਪ੍ਰਾਪਤ ਕਰੋ - ਉਤਪੰਨ - ((ਪਹੁੰਚੋ - ਉਤਪੰਨ ਕਰੋ) - (ਪ੍ਰਸਾਰਿਤ ਕਰੋ - ਪ੍ਰਾਪਤ ਕਰੋ)) / 2 =
   2 * ਪ੍ਰਾਪਤ ਕਰੋ - 2 * ਉਤਪੱਤੀ - ਪਹੁੰਚੋ + ਉਤਪੰਨ + ਸੰਚਾਰਿਤ - ਪ੍ਰਾਪਤ ਕਰੋ =
   ਪ੍ਰਾਪਤ ਕਰੋ - ਉਤਪੰਨ - ਪਹੁੰਚੋ + ਟ੍ਰਾਂਸਮਿਟ ਕਰੋ

ਅਸੀਂ ਨਤੀਜਾ ਮੁੱਲ ਨੂੰ ਸਥਾਨਕ ਸਮੇਂ ਵਿੱਚ ਜੋੜਦੇ ਹਾਂ ਅਤੇ ਜੀਵਨ ਦਾ ਅਨੰਦ ਲੈਂਦੇ ਹਾਂ।

ਨਤੀਜੇ ਦਾ ਆਉਟਪੁੱਟ

time_different = answer.get_time_different(arrive_time)
result = "Time difference: {}nServer time: {}n{}".format(
    time_different,
    datetime.datetime.fromtimestamp(time.time() + time_different).strftime("%c"),
    answer.to_display())
print(result)

ਉਪਯੋਗੀ ਲਿੰਕ.

ਸਰੋਤ: www.habr.com