| /* |
| * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0, which is available at |
| * http://www.eclipse.org/legal/epl-2.0. |
| * |
| * This Source Code may also be made available under the following Secondary |
| * Licenses when the conditions for such availability set forth in the |
| * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, |
| * version 2 with the GNU Classpath Exception, which is available at |
| * https://www.gnu.org/software/classpath/license.html. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 |
| */ |
| |
| /* |
| * AutoDeployMonitor.java |
| * |
| * Created on May 11, 2004, 3:08 PM |
| */ |
| |
| package autodeploy.test; |
| |
| import java.util.Date; |
| import java.text.SimpleDateFormat; |
| import java.text.ParseException; |
| import java.io.File; |
| import java.io.FileFilter; |
| import java.io.FileNotFoundException; |
| |
| import org.glassfish.deployment.autodeploy.AutoDeployConstants; |
| |
| /** |
| *Autodeploys an archive to the specified autodeploy directory. |
| *<p> |
| *To autodeploy the app, follow these steps: |
| *1. Record the modification time of the archive file in the autodeploy directory as the start time. |
| *2. Copy the archive to the autodeploy directory. |
| *3. Monitor the autodeploy directory until it contains a marker file (for either success or |
| * failure) with a creation date and time later than the earlier-recorded timestamp. |
| *4. Choose whether to return success or failure based on which kind of marker file has appeared |
| * in the autodeploy directory. |
| * |
| * @author tjquinn |
| */ |
| public class AutoDeployMonitor { |
| |
| private static boolean DEBUG = Boolean.getBoolean("monitor.debug"); |
| |
| private static int ITERATION_LIMIT = Integer.getInteger("monitor.iterationLimit", 60 * 2 /* default = two minutes */).intValue(); |
| |
| private String archiveName = null; |
| |
| // private String autodeployDirSpec = null; |
| |
| private File autodeployDir = null; |
| |
| // private String timestampFormat = null; |
| |
| // private String timestampString = null; |
| |
| private long timestamp; |
| |
| private Date startTime = null; |
| |
| private final static String LINE_SEP = System.getProperty("line.separator"); |
| |
| /** Creates a new instance of AutoDeployer */ |
| public AutoDeployMonitor() { |
| } |
| |
| /** |
| * @param args the command line arguments |
| */ |
| public static void main(String[] args) { |
| int result = new AutoDeployMonitor().run(args); |
| System.exit(result); |
| } |
| |
| private void processArguments(String[] args) { |
| if (args.length < 4) { |
| usage(); |
| System.exit(1); |
| } |
| |
| archiveName = args[0]; |
| String autodeployDirSpec = args[1]; |
| String timestampFormat = args[2]; |
| String timestampString = args[3]; |
| |
| autodeployDir = new File(autodeployDirSpec); |
| |
| debug("Archive to autodeploy: " + archiveName); |
| debug("Autodeploy directory: " + autodeployDir.getAbsolutePath()); |
| |
| StringBuffer result = new StringBuffer(); |
| |
| /* |
| *Check auto-deploy directory. |
| */ |
| if ( ! autodeployDir.exists()) { |
| result.append(LINE_SEP).append("Autodeploy directory " + autodeployDir.getAbsolutePath() + " does not exist but should."); |
| } |
| |
| /* |
| *Check archive file name. |
| */ |
| if (archiveName.length() == 0) { |
| result.append(LINE_SEP).append("Archive file name must not be empty but is."); |
| } |
| |
| /* |
| *Check the timestamp format and value. |
| */ |
| SimpleDateFormat simpleDateFormat = new SimpleDateFormat(timestampFormat); |
| Date timestampDate = null; |
| try { |
| timestampDate = simpleDateFormat.parse(timestampString); |
| timestamp = timestampDate.getTime(); |
| debug("Timestamp to use for filtering autodeploy status files: " + timestampDate.toString()); |
| } catch (ParseException pe) { |
| result.append(LINE_SEP).append("Could not interpret timestamp " + timestampString + " using format " + timestampFormat).append(LINE_SEP).append(" ").append(pe.getMessage()); |
| } |
| |
| if (result.length() > 0) { |
| throw new IllegalArgumentException(result.toString()); |
| } |
| } |
| |
| private int run(String[] args) { |
| /* |
| *The calling script should pass these command line arguments: |
| * |
| *arg[0] archive file name and type |
| *arg[1] auto-deploy directory spec |
| *arg[2] SimpleDateFormat pattern to use in parsing the timestamp string |
| *arg[3] timestamp string |
| * |
| */ |
| |
| try { |
| processArguments(args); |
| |
| /* |
| *The timestamp handling allows the logic below to identify a marker file (..._deployed, |
| *..._undeployed, ..._deployFailed, ..._undeployFailed) that was created after the |
| *archive was deposited into (for autodeploy) or removed from (for autoundeploy) the |
| *autodeploy directory. We need to do this to make sure we do not accidentally take |
| *action on an old marker file that is still there because the autodeployer has not |
| *yet acted on the new file. |
| */ |
| |
| /* |
| *For auto-deploy, the archive will have just been copied into the autodeploy directory. |
| *For auto-undeploy, the archive will have just been deleted from there. The file filter |
| *below uses both the file name and also a timestamp to make sure it accepts |
| *marker files created after the archive itself. |
| * |
| *Note that the following is both a declaration of the filter and its initialization by |
| *invoking its init method. |
| */ |
| |
| FileFilter filter = new FileFilter () { |
| |
| private long timestamp; |
| private String archiveName = null; |
| |
| public boolean accept(File candidateFile) { |
| /* |
| *Make sure the name of the candidate starts with the name of the archive and that |
| *the candidate is no older than the archive file. Make sure it's one of the marker |
| *file types we're interested in. |
| */ |
| String candidateFileSpec = candidateFile.getAbsolutePath(); |
| long candidateTimestamp = candidateFile.lastModified(); |
| String candidateNameAndType = candidateFileSpec.substring(candidateFileSpec.lastIndexOf(File.separator) + 1); |
| String candidateType = candidateFileSpec.substring(candidateFileSpec.lastIndexOf('.') + 1); |
| |
| boolean answer = (candidateTimestamp > this.timestamp) |
| && (candidateNameAndType.equals(archiveName + AutoDeployConstants.DEPLOYED) || |
| candidateNameAndType.equals(archiveName + AutoDeployConstants.UNDEPLOYED) || |
| candidateNameAndType.equals(archiveName + AutoDeployConstants.DEPLOY_FAILED) || |
| candidateNameAndType.equals(archiveName + AutoDeployConstants.UNDEPLOY_FAILED) |
| ); |
| if (DEBUG) { |
| Date candidateTimestampDate = new Date(candidateTimestamp); |
| debug("Result of filtering file " + candidateFileSpec + " with modification date " + candidateTimestampDate.toString() + " : " + answer); |
| } |
| return answer; |
| } |
| |
| public FileFilter init(String archiveName, long timestamp) { |
| this.archiveName = archiveName; |
| this.timestamp = timestamp; |
| return this; |
| } |
| }.init(archiveName, timestamp); |
| |
| File [] matches = null; |
| |
| /* |
| *Begin waiting for a new marker file to appear in the autodeploy directory. Don't wait longer than |
| *two minutes (by default) in case there is some problem. |
| */ |
| int iterationCount = 0; |
| do { |
| debug("Starting polling iteration " + iterationCount + "..."); |
| Thread.currentThread().sleep(1000); |
| /* |
| *List the files that have the same name as the archive but are not the archive itself. |
| *This should mean we get only the marker file(s) for this archive. |
| */ |
| matches = autodeployDir.listFiles(filter); |
| |
| } while ( (matches.length == 0) && (iterationCount++ < ITERATION_LIMIT)); |
| |
| /* |
| *Return 0 if the marker file found ends with _deployed, 1 if the marker ends with |
| *_deployFailed, and -1 otherwise. |
| */ |
| if (DEBUG) { |
| System.out.println("Matched files:"); |
| for (int i = 0; i < matches.length; i++) { |
| System.out.println(" " + matches[i].getAbsolutePath()); |
| } |
| } |
| String matchFileSpec = matches[0].getAbsolutePath(); |
| int answer = -1; |
| if (matchFileSpec.endsWith(AutoDeployConstants.DEPLOYED) || matchFileSpec.endsWith(AutoDeployConstants.UNDEPLOYED)) { |
| answer = 0; |
| debug("Found successful marker file: " + matchFileSpec); |
| } else if (matchFileSpec.endsWith(AutoDeployConstants.DEPLOY_FAILED) || matchFileSpec.endsWith(AutoDeployConstants.UNDEPLOY_FAILED)) { |
| answer = 1; |
| debug("Found unsuccessful marker file: " + matchFileSpec); |
| } else { |
| debug("Found no marker file at all"); |
| } |
| return answer; |
| } catch (Throwable thr) { |
| System.err.println("Error monitoring autodeployment/autoundeployment"); |
| thr.printStackTrace(); |
| return -1; |
| } |
| } |
| |
| private void usage() { |
| System.err.println("Usage:"); |
| System.err.println(" autodeploy.loader.client.AutoDeployMonitor <archive-name> <autodeploy-directory> <SimpleDateFormat-pattern-for-timestamp> <timestamp-value>"); |
| } |
| |
| private void debug(String msg) { |
| if (DEBUG) { |
| System.out.println(msg); |
| } |
| } |
| } |