Changeset 341:7b9ad4f6bf22 for kraken-ntp/src/main/java/org/krakenapps/ntp/NtpClient.java

Timestamp:

09/17/11 15:19:05 (8 months ago)

Author:

delmitz

Branch:

default

Convert:

svn:7c3792e6-d75b-4784-96a6-b298f655ee64/trunk@2775

Message:

added NtpSyncService.

File:

• kraken-ntp/src/main/java/org/krakenapps/ntp/NtpClient.java (modified) (1 diff)

kraken-ntp/src/main/java/org/krakenapps/ntp/NtpClient.java

@@ -17 +17 @@
 
 import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
 import java.net.InetAddress;
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Calendar;
 import java.util.Date;
+
+import org.krakenapps.ntp.impl.ServerTime;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * @author delmitz
  */
-public interface NtpClient {
-        InetAddress getTimeServer();
-
-        int getTimeout();
-
-        void setTimeServer(InetAddress server);
-
-        void setTimeout(int millisecond);
-
-        Date sync();
-
-        void setSystemTime(Date date) throws IOException;
+public class NtpClient {
+        private static final String DEFAULT_TIME_SERVER = "pool.ntp.org";
+        private static final int NTP_V3_PACKET = 3;
+        private static final int CLIENT_MODE = 3;
+        private static final int STRATUM_INDEX = 1;
+        private static final int POLL_INDEX = 2;
+        private static final int PRECISION_INDEX = 3;
+        private static final int ROOT_DELAY_INDEX = 4;
+        private static final int ROOT_DISPERSION_INDEX = 8;
+        private static final int REFERENCE_IDENTIFIER_INDEX = 12;
+        private static final int REFERENCE_TIMESTAMP_INDEX = 16;
+        private static final int ORIGINATE_TIMESTAMP_INDEX = 24;
+        private static final int RECEIVE_TIMESTAMP_INDEX = 32;
+        private static final int TRANSMIT_TIMESTAMP_INDEX = 40;
+
+        private Logger logger = LoggerFactory.getLogger(NtpClient.class);
+
+        private InetAddress timeServer;
+        private int timeout;
+
+        public NtpClient() throws UnknownHostException {
+                this(null);
+        }
+
+        public NtpClient(String timeServer) throws UnknownHostException {
+                this(timeServer, 5000);
+        }
+
+        public NtpClient(String timeServer, int timeout) throws UnknownHostException {
+                if (timeServer == null)
+                        timeServer = DEFAULT_TIME_SERVER;
+                this.timeServer = InetAddress.getByName(timeServer);
+                this.timeout = timeout;
+        }
+
+        public InetAddress getTimeServer() {
+                return timeServer;
+        }
+
+        public void setTimeServer(InetAddress timeServer) {
+                this.timeServer = timeServer;
+        }
+
+        public int getTimeout() {
+                return timeout;
+        }
+
+        public void setTimeout(int timeout) {
+                this.timeout = timeout;
+        }
+
+        public void setSystemTime(Date time) throws IOException {
+                String os = System.getProperty("os.name");
+                if (os.contains("Windows")) {
+                        String newDate = new SimpleDateFormat("MM-dd-yy").format(time);
+                        Runtime.getRuntime().exec("cmd /c date " + newDate);
+
+                        String newTime = new SimpleDateFormat("HH:mm:ss.SSS").format(time);
+                        newTime = newTime.substring(0, newTime.length() - 1);
+                        Runtime.getRuntime().exec("cmd /c time " + newTime);
+                } else if (os.contains("Linux")) {
+                        String newTime = new SimpleDateFormat("MMddHHmmyyyy.ss").format(time);
+                        Runtime.getRuntime().exec("date " + newTime);
+                } else {
+                        // just pray
+                        String newTime = new SimpleDateFormat("MMddHHmmyyyy.ss").format(time);
+                        Runtime.getRuntime().exec("date " + newTime);
+                }
+        }
+
+        public Date sync() {
+                try {
+                        ServerTime time = getTime();
+                        setSystemTime(addOffset(time));
+                        logger.info("kraken ntp: The time has been successfully synchronized with {} on {}", timeServer,
+                                        new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS 'UTC'").format(time.getTransmit()));
+                        return time.getTransmit();
+                } catch (SocketTimeoutException e) {
+                        logger.error("kraken ntp: receive timeout.", e);
+                } catch (IOException e) {
+                        logger.error("kraken ntp: sync failed.", e);
+                }
+
+                return null;
+        }
+
+        private ServerTime getTime() throws IOException {
+                DatagramSocket socket = new DatagramSocket();
+                socket.setSoTimeout(timeout);
+                transmit(socket, timeServer, 123);
+                ServerTime time = receive(socket);
+                time.setDestination(getUtcTimeMillis());
+                return time;
+        }
+
+        private void transmit(DatagramSocket socket, InetAddress addr, int port) throws IOException {
+                byte[] buf = new byte[48];
+                buf[0] |= NTP_V3_PACKET; // set NTP Packet version 3
+                buf[0] |= (CLIENT_MODE << 3); // set Client mode
+
+                long now = getUtcTimeMillis();
+                now += 2209021200000L; // baseline 1970 to 1900
+
+                long l = (now / 1000) << 32;
+                l |= ((now % 1000) << 32) / 1000;
+                for (int i = 7; i >= 0; i--) { // set Transmit Timestamp
+                        buf[TRANSMIT_TIMESTAMP_INDEX + i] = (byte) (l & 0xff);
+                        l >>>= 8;
+                }
+
+                DatagramPacket p = new DatagramPacket(buf, buf.length);
+                p.setAddress(addr);
+                p.setPort(port);
+                socket.send(p);
+        }
+
+        private long getUtcTimeMillis() {
+                return System.currentTimeMillis() - Calendar.getInstance().getTimeZone().getOffset(0);
+        }
+
+        private ServerTime receive(DatagramSocket socket) throws IOException, SocketTimeoutException {
+                byte[] buf = new byte[48];
+                DatagramPacket p = new DatagramPacket(buf, buf.length);
+                socket.receive(p);
+
+                ServerTime time = new ServerTime();
+                time.setStratum((int) buf[STRATUM_INDEX]);
+                time.setPoll(buf[POLL_INDEX]);
+                time.setPrecision(buf[PRECISION_INDEX]);
+                time.setRootDelay(Arrays.copyOfRange(buf, ROOT_DELAY_INDEX, ROOT_DELAY_INDEX + 4));
+                time.setRootDispersion(Arrays.copyOfRange(buf, ROOT_DISPERSION_INDEX, ROOT_DISPERSION_INDEX + 4));
+                time.setReferenceIdentifier(Arrays.copyOfRange(buf, REFERENCE_IDENTIFIER_INDEX, REFERENCE_IDENTIFIER_INDEX + 4));
+                time.setReference(ntpTimeToJavaDate(buf, REFERENCE_TIMESTAMP_INDEX));
+                time.setOriginate(ntpTimeToJavaDate(buf, ORIGINATE_TIMESTAMP_INDEX));
+                time.setReceive(ntpTimeToJavaDate(buf, RECEIVE_TIMESTAMP_INDEX));
+                time.setTransmit(ntpTimeToJavaDate(buf, TRANSMIT_TIMESTAMP_INDEX));
+
+                return time;
+        }
+
+        private long ntpTimeToJavaDate(byte[] buf, int offset) {
+                long seconds = 0;
+                for (int i = 0; i < 4; i++) {
+                        seconds = seconds << 8;
+                        seconds |= buf[offset + i] & 0xff;
+                }
+                seconds *= 1000L;
+                seconds -= 2209021200000L; // baseline 1900 to 1970
+
+                long fraction = 0;
+                for (int i = 4; i < 8; i++) {
+                        fraction = fraction << 8;
+                        fraction |= buf[offset + i] & 0xff;
+                }
+                fraction *= 1000;
+                fraction >>>= 32;
+
+                return (seconds + fraction);
+        }
+
+        private Date addOffset(ServerTime time) {
+                long millis = System.currentTimeMillis() + time.getClockOffset();
+                return new Date(millis);
+        }
 }