1 /*
   2  * Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package jdk.jpackager.runtime.singleton;
  27 
  28 import java.io.BufferedReader;
  29 import java.io.File;
  30 import java.io.FileReader;
  31 import java.io.IOException;
  32 import java.io.InputStreamReader;
  33 import java.io.OutputStream;
  34 import java.io.PrintStream;
  35 import java.net.Socket;
  36 import java.nio.charset.Charset;
  37 
  38 /**
  39  * The {@code SingleInstanceService} class provides public methods for using
  40  * Single Instance functionality for Java Packager. To use these methods,
  41  * the option named "-singleton" must be specified on jpackager command line.
  42  *
  43  * @since 12
  44  */
  45 public class SingleInstanceService {
  46 
  47     static private boolean DEBUG = false;
  48     static private PrintStream DEBUG_STREAM = null;
  49 
  50     static private int currPort;
  51     static private String stringId = null;
  52     static private String randomNumberString = null;
  53 
  54     static private SingleInstanceImpl instance = null;
  55 
  56     static final int ENCODING_PLATFORM = 1;
  57     static final int ENCODING_UNICODE = 2;
  58 
  59     static final String ENCODING_PLATFORM_NAME = "UTF-8";
  60     static final String ENCODING_UNICODE_NAME = "UTF-16LE";
  61 
  62     static final String APP_ID_PREFIX = "jpackager.si.";
  63 
  64     private SingleInstanceService() {}
  65 
  66     static void enableDebug(boolean enable, PrintStream stream) {
  67         DEBUG = enable;
  68         DEBUG_STREAM = stream;
  69     }
  70 
  71     static void trace(String message) {
  72         if (DEBUG && DEBUG_STREAM != null) {
  73             DEBUG_STREAM.println(message);
  74         }
  75     }
  76 
  77     static void trace(Throwable t) {
  78         if (DEBUG && DEBUG_STREAM != null) {
  79             t.printStackTrace(DEBUG_STREAM);
  80         }
  81     }
  82 
  83     /**
  84      * Registers {@code SingleInstanceListener} for current process.
  85      * If the {@code SingleInstanceListener} object is already registered, or
  86      * {@code slistener} is {@code null}, then the registration is skipped.
  87      *
  88      * @param slistener the listener to handle the single instance behaviour.
  89      */
  90     public static void registerSingleInstance(
  91             SingleInstanceListener slistener) {
  92         registerSingleInstance(slistener, false);
  93     }
  94 
  95     /**
  96      * Registers {@code SingleInstanceListener} for current process.
  97      * If the {@code SingleInstanceListener} object is already registered, or
  98      * {@code slistener} is {@code null}, then the registration is skipped.
  99      *
 100      * @param slistener the listener to handle the single instance behaviour.
 101      * @param setFileHandler if {@code true}, the listener is notified when the
 102      *         application is asked to open a list of files. If OS is not MacOS,
 103      *         the parameter is ignored.
 104      */
 105     public static void registerSingleInstance(SingleInstanceListener slistener,
 106                                               boolean setFileHandler) {
 107         String appId = APP_ID_PREFIX + ProcessHandle.current().pid();
 108         registerSingleInstanceForId(slistener, appId, setFileHandler);
 109     }
 110 
 111     static void registerSingleInstanceForId(SingleInstanceListener slistener,
 112             String stringId, boolean setFileHandler) {
 113         // register SingleInstanceListener for given Id
 114         instance = new SingleInstanceImpl();
 115         instance.addSingleInstanceListener(slistener, stringId);
 116         if (setFileHandler) {
 117             instance.setOpenFileHandler();
 118         }
 119     }
 120 
 121     /**
 122      * Unregisters {@code SingleInstanceListener} for current process.
 123      * If the {@code SingleInstanceListener} object is not registered, or
 124      * {@code slistener} is {@code null}, then the unregistration is skipped.
 125      *
 126      * @param slistener the listener for unregistering.
 127      */
 128     public static void unregisterSingleInstance(
 129             SingleInstanceListener slistener) {
 130         instance.removeSingleInstanceListener(slistener);
 131     }
 132 
 133     /**
 134      * Returns true if single instance server is running for the id
 135      */
 136     static boolean isServerRunning(String id) {
 137         trace("isServerRunning ? : "+ id);
 138         File siDir = new File(SingleInstanceImpl.SI_FILEDIR);
 139         String[] fList = siDir.list();
 140         if (fList != null) {
 141             String prefix = SingleInstanceImpl.getSingleInstanceFilePrefix(id);
 142             for (String file : fList) {
 143                 trace("isServerRunning: " + file);
 144                 trace("\t String id: " + id);
 145                 trace("\t SingleInstanceFilePrefix: " + prefix);
 146                 // if file with the same prefix already exist, server is running
 147                 if (file.startsWith(prefix)) {
 148                     try {
 149                         currPort = Integer.parseInt(
 150                                     file.substring(file.lastIndexOf('_') + 1));
 151                         trace("isServerRunning: " + file
 152                                 + ": port: " + currPort);
 153                     } catch (NumberFormatException nfe) {
 154                         trace("isServerRunning: " + file
 155                                 + ": port parsing failed");
 156                         trace(nfe);
 157                         return false;
 158                     }
 159 
 160                     trace("Server running at port: " + currPort);
 161                     File siFile = new File(SingleInstanceImpl.SI_FILEDIR, file);
 162 
 163                     // get random number from single instance file
 164                     try (BufferedReader br = new BufferedReader(
 165                             new FileReader(siFile))) {
 166                         randomNumberString = br.readLine();
 167                         trace("isServerRunning: " + file + ": magic: "
 168                                 + randomNumberString);
 169                     } catch (IOException ioe ) {
 170                         trace("isServerRunning: " + file
 171                                 + ": reading magic failed");
 172                         trace(ioe);
 173                     }
 174                     trace("isServerRunning: " + file + ": setting id - OK");
 175                     stringId = id;
 176                     return true;
 177                 } else {
 178                     trace("isServerRunning: " + file + ": prefix NOK");
 179                 }
 180             }
 181         } else {
 182             trace("isServerRunning: empty file list");
 183         }
 184         trace("isServerRunning: false");
 185         return false;
 186     }
 187 
 188     /**
 189      * Returns true if we connect successfully to the server for the stringId
 190      */
 191     static boolean connectToServer(String[] args) {
 192         trace("Connect to: " + stringId + " " + currPort);
 193 
 194         if (randomNumberString == null) {
 195             // should not happen
 196             trace("MAGIC number is null, bail out.");
 197             return false;
 198         }
 199 
 200         // Now we open the tcpSocket and the stream
 201         Socket socket = null;
 202         OutputStream os = null;
 203         PrintStream out = null;
 204         InputStreamReader isr = null;
 205         BufferedReader br = null;
 206         try {
 207             socket = new Socket("127.0.0.1", currPort);
 208             os = socket.getOutputStream();
 209             byte[] encoding = new byte[1];
 210             encoding[0] = ENCODING_PLATFORM;
 211             os.write(encoding);
 212             String encodingName = Charset.defaultCharset().name();
 213 
 214             out = new PrintStream(os, true, encodingName);
 215             isr = new InputStreamReader(socket.getInputStream(), encodingName);
 216             br = new BufferedReader(isr);
 217 
 218             // send random number
 219             out.println(randomNumberString);
 220             // send MAGICWORD
 221             out.println(SingleInstanceImpl.SI_MAGICWORD);
 222 
 223             for (String arg : args) {
 224                 out.println(arg);
 225             }
 226 
 227             // indicate end of file transmission
 228             out.println(SingleInstanceImpl.SI_EOF);
 229             out.flush();
 230 
 231             // wait for ACK (OK) response
 232             trace("Waiting for ack");
 233             final int tries = 5;
 234 
 235             // try to listen for ACK
 236             for (int i=0; i < tries; i++) {
 237                 String str = br.readLine();
 238                 if (str != null && str.equals(SingleInstanceImpl.SI_ACK)) {
 239                     trace("Got ACK");
 240                     return true;
 241                 }
 242             }
 243         } catch (java.net.SocketException se) {
 244             // no server is running - continue launch
 245             trace("No server is running - continue launch.");
 246             trace(se);
 247         } catch (Exception ioe) {
 248             trace(ioe);
 249         }
 250         finally {
 251             try {
 252                 if (br != null) {
 253                     br.close();
 254                 }
 255                 if (isr != null) {
 256                     isr.close();
 257                 }
 258                 if (out != null) {
 259                     out.close();
 260                 }
 261                 if (os != null) {
 262                     os.close();
 263                 }
 264                 if (socket != null) {
 265                     socket.close();
 266                 }
 267             } catch (IOException ioe) {
 268                 trace(ioe);
 269             }
 270         }
 271         trace("No ACK from server, bail out.");
 272         return false;
 273     }
 274 }