Changeset 341:7b9ad4f6bf22

Timestamp:

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

Author:

delmitz

Branch:

default

Convert:

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

Message:

added NtpSyncService.

Location:

kraken-ntp

Files:

• pom.xml (modified) (2 diffs)
• src/main/java/org/krakenapps/ntp/NtpClient.java (modified) (1 diff)
• src/main/java/org/krakenapps/ntp/NtpSyncService.java (added)
• src/main/java/org/krakenapps/ntp/impl/NtpClientImpl.java (deleted)
• src/main/java/org/krakenapps/ntp/impl/NtpSyncServiceImpl.java (added)
• src/main/java/org/krakenapps/ntp/msgbus/NtpPlugin.java (modified) (6 diffs)
• src/main/java/org/krakenapps/ntp/script/NtpScript.java (modified) (5 diffs)
• src/main/java/org/krakenapps/ntp/script/NtpScriptFactory.java (modified) (2 diffs)
• src/main/resources/metadata.xml (modified) (1 diff)

kraken-ntp/pom.xml

@@ -11 +11 @@
         <groupId>org.krakenapps</groupId>
         <artifactId>kraken-ntp</artifactId>
-        <version>1.0.3</version>
+        <version>1.1.0</version>
         <packaging>bundle</packaging>
         <name>Kraken NTP Client</name>
@@ -66 +66 @@
                 </dependency>
                 <dependency>
+                        <groupId>org.krakenapps</groupId>
+                        <artifactId>kraken-cron</artifactId>
+                        <version>1.5.0</version>
+                        <optional>true</optional>
+                </dependency>
+                <dependency>
                         <groupId>org.apache.felix</groupId>
                         <artifactId>org.apache.felix.ipojo.annotations</artifactId>

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);
+        }
 }

kraken-ntp/src/main/java/org/krakenapps/ntp/msgbus/NtpPlugin.java

@@ -30 +30 @@
 import org.krakenapps.msgbus.handler.MsgbusMethod;
 import org.krakenapps.msgbus.handler.MsgbusPlugin;
-import org.krakenapps.ntp.NtpClient;
+import org.krakenapps.ntp.NtpSyncService;
 
 /**
@@ -39 +39 @@
 public class NtpPlugin {
         @Requires
-        private NtpClient ntpClient;
+        private NtpSyncService syncService;
 
         @MsgbusMethod
@@ -48 +48 @@
         @MsgbusMethod
         public void getNtpClientConfig(Request req, Response resp) {
-                resp.put("time_server", ntpClient.getTimeServer().getHostName());
-                resp.put("timeout", ntpClient.getTimeout());
+                resp.put("time_server", syncService.getTimeServer().getHostName());
+                resp.put("timeout", syncService.getTimeout());
         }
 
@@ -57 +57 @@
                 int timeout = req.getInteger("timeout");
                 try {
-                        ntpClient.setTimeServer(InetAddress.getByName(server));
-                        ntpClient.setTimeout(timeout);
+                        syncService.setTimeServer(InetAddress.getByName(server));
+                        syncService.setTimeout(timeout);
                 } catch (UnknownHostException e) {
                         throw new MsgbusException("ntp", "unknown host");
@@ -66 +66 @@
         @MsgbusMethod
         public void sync(Request req, Response resp) {
-                resp.put("synced_time", ntpClient.sync());
+                resp.put("synced_time", syncService.getNtpClient().sync());
         }
 
@@ -80 +80 @@
                 try {
                         Date d = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(s);
-                        ntpClient.setSystemTime(d);
+                        syncService.getNtpClient().setSystemTime(d);
                 } catch (ParseException e) {
                         throw new MsgbusException("ntp", "date parse exception");

kraken-ntp/src/main/java/org/krakenapps/ntp/script/NtpScript.java

@@ -25 +25 @@
 import org.krakenapps.api.ScriptContext;
 import org.krakenapps.api.ScriptUsage;
-import org.krakenapps.ntp.NtpClient;
+import org.krakenapps.ntp.NtpSyncService;
 
 /**
@@ -32 +32 @@
 public class NtpScript implements Script {
         private ScriptContext context;
-        private NtpClient ntpClient;
+        private NtpSyncService syncService;
 
-        public NtpScript(NtpClient ntpClient) {
-                this.ntpClient = ntpClient;
+        public NtpScript(NtpSyncService syncService) {
+                this.syncService = syncService;
         }
 
@@ -49 +49 @@
                         try {
                                 InetAddress server = InetAddress.getByName(args[0]);
-                                ntpClient.setTimeServer(server);
+                                syncService.setTimeServer(server);
                         } catch (UnknownHostException e) {
                                 context.println("unknown host");
@@ -55 +55 @@
                 }
 
-                context.println(ntpClient.getTimeServer());
+                context.println(syncService.getTimeServer());
         }
 
@@ -63 +63 @@
                 if (args.length > 0) {
                         Integer millisecond = Integer.parseInt(args[0]);
-                        ntpClient.setTimeout(millisecond);
+                        syncService.setTimeout(millisecond);
                 }
 
-                context.println(ntpClient.getTimeout());
+                context.println(syncService.getTimeout());
         }
 
         public void sync(String[] args) {
-                Date result = ntpClient.sync();
+                Date result = syncService.getNtpClient().sync();
                 if (result != null)
-                        context.printf("The time has been successfully synchronized with %s on %s\n", ntpClient.getTimeServer()
+                        context.printf("The time has been successfully synchronized with %s on %s\n", syncService.getTimeServer()
                                         .getHostName(), new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS 'UTC'").format(result));
                 else

kraken-ntp/src/main/java/org/krakenapps/ntp/script/NtpScriptFactory.java

@@ -22 +22 @@
 import org.krakenapps.api.Script;
 import org.krakenapps.api.ScriptFactory;
-import org.krakenapps.ntp.NtpClient;
+import org.krakenapps.ntp.NtpSyncService;
 
 /**
@@ -35 +35 @@
 
         @Requires
-        private NtpClient ntpClient;
+        private NtpSyncService syncService;
 
         @Override
         public Script createScript() {
-                return new NtpScript(ntpClient);
+                return new NtpScript(syncService);
         }
 

kraken-ntp/src/main/resources/metadata.xml

@@ -2 +2 @@
         xsi:schemaLocation="org.apache.felix.ipojo http://felix.apache.org/ipojo/schemas/CURRENT/core.xsd"
         xmlns="org.apache.felix.ipojo">
-        <instance component="ntp-client" />
+        <instance component="ntp-sync-service" />
         <instance component="ntp-script-factory" />
         <instance component="ntp-plugin" />