EVOLUTION-MANAGER

Edit File: ProcrunService.java

import java.io.File;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
//import java.util.Enumeration;
import java.util.Iterator;
//import java.util.List;
//import java.util.Map;
import java.util.Properties;
import java.util.TreeSet;
//import java.net.InterfaceAddress;
//import java.net.NetworkInterface;
//import java.net.SocketException;

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

/**
 * Sample service implementation for use with Windows Procrun.
 * <p>
 * Use the main() method for running as a Java (external) service.
 * Use the start() and stop() methods for running as a jvm (in-process) service
 */
public class ProcrunService implements Runnable {

private static final int DEFAULT_PAUSE = 60; // Wait 1 minute
    private static final long MS_PER_SEC = 1000L; // Milliseconds in a second

private static volatile Thread thrd; // start and stop are called from different threads

private final long pause; // How long to pause in service loop

private final File stopFile;

/**
     *
     * @param wait seconds to wait in loop
     * @param filename optional filename - if non-null, run loop will stop when it disappears
     * @throws IOException
     */
    private ProcrunService(long wait, File file) {
        pause=wait;
        stopFile = file;
    }

private static File tmpFile(String filename) {
        return new File(System.getProperty("java.io.tmpdir"),
                filename != null ? filename : "ProcrunService.tmp");
    }

private static void usage(){
        System.err.println("Must supply the argument 'start' or 'stop'");
    }

/**
     * Helper method for process args with defaults.
     *
     * @param args array of string arguments, may be empty
     * @param argnum which argument to extract
     * @return the argument or null
     */
    private static String getArg(String[] args, int argnum){
        if (args.length > argnum) {
            return args[argnum];
        } else {
            return null;
        }
    }

private static void logSystemEnvironment()
    {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        if (cl == null)
            log("Missing currentThread context ClassLoader");
        else
            log("Using context ClassLoader : " + cl.toString());
        log("Program environment: ");

// Java 1.5+ code
//        Map        em = System.getenv();
//        TreeSet    es = new TreeSet(em.keySet());
//        for (Iterator i = es.iterator(); i.hasNext();) {
//            String n = (String)i.next();
//            log(n + " ->  " + em.get(n));
//        }

log("System properties: ");
        Properties ps = System.getProperties();
        TreeSet    ts = new TreeSet(ps.keySet());
        for (Iterator i = ts.iterator(); i.hasNext();) {
            String n = (String)i.next();
            log(n + " ->  " + ps.get(n));
        }

// Java 1.6+ code
//        log("Network interfaces: ");
//        log("LVPMU (L)oopback (V)irtual (P)ointToPoint (M)multicastSupport (U)p");
//        try {
//            for (Enumeration e = NetworkInterface.getNetworkInterfaces(); e.hasMoreElements();) {
//                NetworkInterface n = (NetworkInterface)e.nextElement();
//                char [] flags = { '-', '-', '-', '-', '-'};
//                if (n.isLoopback())
//                    flags[0] = 'x';
//                if (n.isVirtual())
//                    flags[1] = 'x';
//                if (n.isPointToPoint())
//                    flags[2] = 'x';
//                if (n.supportsMulticast())
//                    flags[3] = 'x';
//                if (n.isUp())
//                    flags[4] = 'x';
//                String neti = new String(flags) + "   " + n.getName() + "\t";
//                for (Enumeration i = n.getSubInterfaces(); i.hasMoreElements();) {
//                    NetworkInterface s = (NetworkInterface)i.nextElement();
//                    neti += " [" + s.getName() + "]";
//                }
//                log(neti + " -> " + n.getDisplayName());
//                List i = n.getInterfaceAddresses();
//                if (!i.isEmpty()) {
//                    for (int x = 0; x < i.size(); x++) {
//                        InterfaceAddress a = (InterfaceAddress)i.get(x);
//                        log("        " + a.toString());
//                    }
//                }
//            }
//        } catch (SocketException e) {
//            // Ignore
//        }
    }

/**
     * Common entry point for start and stop service functions.
     * To allow for use with Java mode, a temporary file is created
     * by the start service, and a deleted by the stop service.
     *
     * @param args [start [pause time] | stop]
     * @throws IOException if there are problems creating or deleting the temporary file
     */
    public static void main(String[] args) throws IOException {
        final int argc = args.length;
        log("ProcrunService called with "+argc+" arguments from thread: "+Thread.currentThread());
        for(int i=0; i < argc; i++) {
            System.out.println("["+i+"] "+args[i]);
        }
        String mode=getArg(args, 0);
        if ("start".equals(mode)){
            File f = tmpFile(getArg(args, 2));
            log("Creating file: "+f.getPath());
            f.createNewFile();
            startThread(getArg(args, 1), f);
        } else if ("stop".equals(mode)) {
            final File tmpFile = tmpFile(getArg(args, 1));
            log("Deleting file: "+tmpFile.getPath());
            tmpFile.delete();
        } else {
            usage();
        }
    }

/**
     * Start the jvm version of the service, and waits for it to complete.
     *
     * @param args optional, arg[0] = timeout (seconds)
     */
    public static void start(String [] args) {
        startThread(getArg(args, 0), null);
        while(thrd.isAlive()){
            try {
                thrd.join();
            } catch (InterruptedException ie){
                // Ignored
            }
        }
    }

private static void startThread(String waitParam, File file) {
        long wait = DEFAULT_PAUSE;
        if (waitParam != null) {
            wait = Integer.valueOf(waitParam).intValue();
        }
        log("Starting the thread, wait(seconds): "+wait);
        thrd = new Thread(new ProcrunService(wait*MS_PER_SEC,file));
        thrd.start();
    }

/**
     * Stop the JVM version of the service.
     *
     * @param args ignored
     */
    public static void stop(String [] args){
        if (thrd != null) {
            log("Interrupting the thread");
            thrd.interrupt();
        } else {
            log("No thread to interrupt");
        }
    }

/**
     * This method performs the work of the service.
     * In this case, it just logs a message every so often.
     */
    public void run() {
        log("Started thread in "+System.getProperty("user.dir"));
        logSystemEnvironment();
        while(stopFile == null || stopFile.exists()){
            try {
                log("pausing...");
                Thread.sleep(pause);
            } catch (InterruptedException e) {
                log("Exitting");
                break;
            }
        }
    }

private static void log(String msg){
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss ");
        System.out.println(df.format(new Date())+msg);
    }

protected void finalize(){
        log("Finalize called from thread "+Thread.currentThread());
    }
}