| /* | |
| * 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 | |
| */ | |
| /* | |
| * TestJSR88Concurrency.java | |
| * | |
| * Created on September 19, 2006, 3:52 PM | |
| * | |
| */ | |
| package devtests.deployment.jsr88.apitests; | |
| import com.sun.enterprise.deployapi.SunDeploymentFactory; | |
| import java.text.ParseException; | |
| import java.text.SimpleDateFormat; | |
| import java.util.ArrayList; | |
| import java.util.Arrays; | |
| import java.util.Calendar; | |
| import java.util.Date; | |
| import java.util.HashMap; | |
| import java.util.List; | |
| import java.util.concurrent.atomic.AtomicBoolean; | |
| import javax.enterprise.deploy.shared.ModuleType; | |
| import javax.enterprise.deploy.spi.DeploymentManager; | |
| import javax.enterprise.deploy.spi.Target; | |
| import javax.enterprise.deploy.spi.TargetModuleID; | |
| import javax.enterprise.deploy.spi.exceptions.DeploymentManagerCreationException; | |
| import javax.enterprise.deploy.spi.exceptions.TargetException; | |
| import javax.enterprise.deploy.spi.factories.DeploymentFactory; | |
| /** | |
| *Tests concurrent use of the same deployment connection to the back-end. | |
| *<p> | |
| *You can use this program to create multiple threads in the same JVM (all | |
| *running the same task) or to run multiple copies of the program in different | |
| *JVMs but synchronized. | |
| *<p> | |
| *arguments: | |
| * --host <host> | |
| * --port <port> | |
| * --username <username> | |
| * --password <password> | |
| * --operation <operation>[*<n>] | |
| * --startTime <testStartTime> (as H:mm:ss) | |
| * --delay <delayTime) (in ms) | |
| * --secure <true or false> | |
| *<p> | |
| *where <operation> can be getTargets, getApps, loopGetTargets"); | |
| * n (default=1) is the number of concurrent threads to share the connection at once | |
| * testStartTime is a time in the current day, specified as [H]H:mm:ss default is to start immediately | |
| *<p> | |
| *The getTargets and getApps tasks invoke the corresponding back-end method only | |
| *once in each thread. The loopGetTargets is more likely to induce problems if | |
| *there are race conditions somewhere in the code path, since it invokes the | |
| *getTargets method multiple times from each thread. | |
| *<p> | |
| *The system property sleep.time, if set, is used as the delay between when | |
| *multiple threads are started. This is normally not needed but could be used | |
| *to stagger the requests from the threads that are started to see if doing | |
| *so avoids any race conditon that is revealed by starting the threads | |
| *without delay. | |
| * | |
| *The classpath must include: | |
| * javaee.jar | |
| * appserv-deployment-client.jar | |
| * appserv-admin.jar | |
| * | |
| * @author tjquinn | |
| */ | |
| public class TestJSR88Concurrency { | |
| private DeploymentFactory factory; | |
| private DeploymentManager manager; | |
| private static final String HOST = "--host"; | |
| private static final String PORT = "--port"; | |
| private static final String USERNAME = "--username"; | |
| private static final String PASSWORD = "--password"; | |
| private static final String OPERATION = "--operation"; | |
| private static final String START_TIME = "--startTime"; | |
| private static final String DELAY = "--delay"; | |
| private static final String SECURE = "--secure"; | |
| private static final String TIMEOUT = "--timeout"; | |
| /** initialization info for the command-line option names and defaults, if any */ | |
| private static final String[][] optionsAndDefaults = new String[][] | |
| { {HOST, "localhost"}, | |
| {PORT, "4848"}, | |
| {USERNAME, "admin"}, | |
| {PASSWORD, "adminadmin"}, | |
| {OPERATION, null}, // no default value | |
| {START_TIME, null}, // no default value | |
| {DELAY, "0"}, | |
| {SECURE, "false"}, | |
| {TIMEOUT, "10000"} // 10 seconds | |
| }; | |
| /* command-line option names and values */ | |
| private HashMap<String,String> options; | |
| /* used to control how many iterations of the loopGetTargets will run */ | |
| private static final int LOOP_MAX = 100; | |
| /** | |
| * Creates a new instance of TestJSR88Concurrency | |
| */ | |
| public TestJSR88Concurrency() { | |
| } | |
| /** | |
| * @param args the command line arguments | |
| */ | |
| public static void main(String[] args) { | |
| try { | |
| new TestJSR88Concurrency().run(args); | |
| } catch (Throwable thr) { | |
| thr.printStackTrace(); | |
| System.exit(1); | |
| } | |
| } | |
| private void run(String[] args) throws DeploymentManagerCreationException, TargetException, InterruptedException, ParseException, UserException { | |
| try { | |
| prepareArgs(args); | |
| factory = initFactory(); | |
| manager = initManager( | |
| getHost(), | |
| getPort(), | |
| getUsername(), | |
| getPassword(), | |
| options.get(SECURE).equalsIgnoreCase("true")); | |
| waitForTargetTime(); | |
| processFunction(getOperation()); | |
| } catch (UserException ue) { | |
| System.err.println("User error: " + ue.getMessage()); | |
| System.exit(1); | |
| } | |
| } | |
| private void waitForTargetTime() throws ParseException, InterruptedException { | |
| if (getTargetTimeText() == null) { | |
| System.out.println("No start delay specified; continuing immediately"); | |
| return; | |
| } | |
| SimpleDateFormat targetTimeFormat = new SimpleDateFormat("H:mm:ss"); | |
| Calendar targetTime = Calendar.getInstance(); | |
| targetTime.setTime(targetTimeFormat.parse(getTargetTimeText())); | |
| Calendar now = Calendar.getInstance(); | |
| targetTime.set(now.get(Calendar.YEAR), now.get(Calendar.MONTH), now.get(Calendar.DAY_OF_MONTH)); | |
| System.out.println("Currently it is " + now.getTime().toString()); | |
| System.out.println("Waiting until " + targetTime.getTime().toString()); | |
| Thread.sleep(targetTime.getTimeInMillis() - System.currentTimeMillis()); | |
| System.out.println("Proceeding"); | |
| } | |
| private void prepareArgs(String[] args) throws UserException { | |
| options = initOptionsMap(); | |
| int i = 0; | |
| while (i < args.length) { | |
| if (options.containsKey(args[i])) { | |
| options.put(args[i], getRequiredOptionValue(args, ++i)); | |
| } else if (args[i].startsWith("--")) { | |
| throw new UserException("Unrecognized option " + args[i]); | |
| } | |
| i++; | |
| } | |
| ensureRequiredInfoSupplied(); | |
| } | |
| private void ensureRequiredInfoSupplied() throws UserException { | |
| if (getOperation() == null) { | |
| throw new UserException("Expected --operation <operation[*n]> but none was found"); | |
| } | |
| } | |
| private HashMap<String,String> initOptionsMap() { | |
| HashMap<String,String> result = new HashMap<String,String>(); | |
| for (String[] optionAndValue : optionsAndDefaults) { | |
| result.put(optionAndValue[0], optionAndValue[1]); | |
| } | |
| return result; | |
| } | |
| private String getRequiredOptionValue(String[] args, int valuePosition) throws UserException { | |
| if ((valuePosition >= args.length) || (args[valuePosition].startsWith("--"))) { | |
| throw new UserException("No value available for " + args[valuePosition - 1]); | |
| } | |
| return args[valuePosition]; | |
| } | |
| private void usage() { | |
| System.out.println("devtests.deployment.jsr88.apitests.TestJSR88Concurrency --host <host> --port <port> --username <username> --password <password> --operation <operation>[*<n>] --startTime testStartTime (as H:mm:ss) --delay <delay-in-ms> --secure true/false"); | |
| System.out.println(" where <operation> can be getTargets, getApps, loopGetTargets"); | |
| System.out.println(" n (default=1) is the number of concurrent threads to share the connection at once"); | |
| System.out.println(" testStartTime is a time in the current day, specified as [H]H:mm:ss default is to start immediately"); | |
| System.out.println(" delay is the number of milliseconds to wait between starting threads"); | |
| } | |
| private DeploymentFactory initFactory() { | |
| /* | |
| *We know we are testing our factory, so just instantiate it. | |
| */ | |
| return new SunDeploymentFactory(); | |
| } | |
| private DeploymentManager initManager( | |
| String host, | |
| String port, | |
| String username, | |
| String password, | |
| boolean secure) throws DeploymentManagerCreationException { | |
| String url = "deployer:Sun:AppServer::" + host + ":" + port + getConnectionStringSuffix(secure); | |
| return factory.getDeploymentManager(url, username, password); | |
| } | |
| private void processFunction(String function) throws TargetException, InterruptedException { | |
| /* | |
| *The star, if present, separates the operation name from the number of | |
| *threads on which to run that operation. | |
| */ | |
| String[] pieces = function.split("\\*"); | |
| long delay = getDelay(); | |
| int parallelThreadCount = 1; | |
| if (pieces.length > 1) { | |
| parallelThreadCount = Integer.parseInt(pieces[1]); | |
| } | |
| if (parallelThreadCount == 1) { | |
| performFunction(pieces[0], 1); | |
| } else { | |
| Thread[] threads = new Thread[parallelThreadCount]; | |
| AtomicBoolean[] threadOK = new AtomicBoolean[parallelThreadCount]; | |
| for (int i = 0; i < parallelThreadCount; i++) { | |
| threadOK[i] = new AtomicBoolean(); | |
| threads[i] = new Thread(new Runner(pieces[0], i, threadOK[i])); | |
| threads[i].start(); | |
| /* | |
| *No need to wait if we just started the last thread. | |
| */ | |
| if (delay != 0 && i < parallelThreadCount - 1) { | |
| Thread.currentThread().sleep(delay); | |
| } | |
| } | |
| boolean allThreadsOK = true; | |
| for (int i = 0; i < parallelThreadCount; i++) { | |
| Thread t = threads[i]; | |
| t.join(getTimeout()); | |
| allThreadsOK &= threadOK[i].get(); | |
| } | |
| if ( ! allThreadsOK) { | |
| throw new RuntimeException("At least one thread failed"); | |
| } | |
| } | |
| } | |
| private void printTargets(int threadID) { | |
| System.out.println("[" + threadID + "]Targets:"); | |
| for (Target t : getTargets()) { | |
| System.out.println("[" + threadID + "] " + t.getName()); | |
| } | |
| System.out.println(); | |
| } | |
| private Target[] getTargets() { | |
| return manager.getTargets(); | |
| } | |
| private TargetModuleID[] getApps() throws TargetException { | |
| Target[] targets = getTargets(); | |
| ModuleType[] types = new ModuleType[] {ModuleType.EJB, ModuleType.EAR, ModuleType.CAR, ModuleType.RAR}; | |
| List<TargetModuleID> result = new ArrayList<TargetModuleID>(); | |
| for (ModuleType mt : types) { | |
| result.addAll(Arrays.asList(manager.getAvailableModules(mt, targets))); | |
| } | |
| return result.toArray(new TargetModuleID[result.size()]); | |
| } | |
| private void printApps(int threadID) throws TargetException { | |
| System.out.println("[" + threadID + "]Applications:"); | |
| for (TargetModuleID id : getApps()) { | |
| System.out.println("[" + threadID + "] " + id.getModuleID()); | |
| } | |
| System.out.println("[" + threadID + "]"); | |
| } | |
| private void loopGetTargets() { | |
| getTargets(); // to warm up the connection | |
| long startTime = System.currentTimeMillis(); | |
| for (int i = 0; i < LOOP_MAX; i++) { | |
| getTargets(); | |
| } | |
| System.out.println((System.currentTimeMillis() - startTime)); | |
| } | |
| private void performFunction(String function, int threadID) throws TargetException { | |
| if (function.equals("getTargets")) { | |
| printTargets(threadID); | |
| } else if (function.equals("getApps")) { | |
| printApps(threadID); | |
| } else if (function.equals("loopGetTargets")) { | |
| loopGetTargets(); | |
| } else { | |
| System.err.println("No recognized function in thread " + threadID); | |
| } | |
| } | |
| private void multiGetApps() { | |
| } | |
| private String getStartTimeText() { | |
| return options.get(START_TIME); | |
| } | |
| private String getHost() { | |
| return options.get(HOST); | |
| } | |
| private String getPort() { | |
| return options.get(PORT); | |
| } | |
| private String getUsername() { | |
| return options.get(USERNAME); | |
| } | |
| private String getPassword() { | |
| return options.get(PASSWORD); | |
| } | |
| private String getOperation() { | |
| return options.get(OPERATION); | |
| } | |
| private String getTargetTimeText() { | |
| return options.get(START_TIME); | |
| } | |
| private long getDelay() { | |
| return Long.parseLong(options.get(DELAY)); | |
| } | |
| private String getConnectionStringSuffix(boolean secure) { | |
| return secure ? ":https" : ""; | |
| } | |
| private long getTimeout() { | |
| return Long.parseLong(options.get(TIMEOUT)); | |
| } | |
| private class Runner implements Runnable { | |
| private String function; | |
| private int threadID; | |
| private AtomicBoolean result; | |
| public Runner(String function, int threadID, AtomicBoolean result) { | |
| Runner.this.function = function; | |
| this.threadID = threadID; | |
| this.result = result; | |
| } | |
| public void run() { | |
| try { | |
| performFunction(function, threadID); | |
| result.set(true); | |
| } catch (Throwable thr) { | |
| result.set(false); | |
| synchronized (TestJSR88Concurrency.this) { | |
| System.err.println(Thread.currentThread().getName()); | |
| thr.printStackTrace(); | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| *Indicates a user error, such as a missing command-line value, that should | |
| *be displayed without a stack trace. | |
| */ | |
| public class UserException extends Exception { | |
| public UserException(String msg) { | |
| super(msg); | |
| } | |
| } | |
| } |