| /* |
| * Copyright (c) 2003, 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 |
| */ |
| |
| package devtests.deployment.jsr88.apitests; |
| |
| import java.io.*; |
| import java.util.*; |
| import javax.enterprise.deploy.spi.*; |
| import javax.enterprise.deploy.spi.status.ProgressEvent; |
| import javax.enterprise.deploy.spi.status.DeploymentStatus; |
| import javax.enterprise.deploy.shared.ModuleType; |
| import devtests.deployment.util.JSR88Deployer; |
| |
| public class TestClient { |
| |
| /** |
| *system property (integer) specifying the sleep delay to introduce into ProgressobjectImpl event notification |
| *to make sure a possible race condition does not occur. The property also has a default value. |
| */ |
| private final String SLEEP_TIME_PROPERTY_NAME = "devtests.sleepDurationForProgressObjectImplRaceTest"; |
| private final Integer SLEEP_TIME_DEFAULT = new Integer(4000); |
| |
| JSR88Deployer depl = null; |
| |
| private void initDeployer(String[] args) throws Exception { |
| log("Getting access to JSR88 deployer: using URI = " + args[1]); |
| depl = new JSR88Deployer(args[1], args[2], args[3]); |
| } |
| |
| private boolean checkIfAppsArePresent(TargetModuleID[] reportedApps, HashMap expectedApps) { |
| for(int i=0; i<reportedApps.length; i++) { |
| String modId = reportedApps[i].getModuleID(); |
| log("Reported application name = " + modId); |
| if(expectedApps.containsKey(modId)) |
| expectedApps.remove(modId); |
| } |
| if(expectedApps.size() != 0) { |
| log("Not all expected applications have been reported"); |
| return(false); |
| } |
| log("All expected applications have been reported"); |
| return(true); |
| } |
| |
| private boolean checkReportedApps(String[] args, Boolean state) |
| throws Exception { |
| log("Checking if application names reported are valid"); |
| |
| HashMap set = new HashMap(); |
| set.put(args[4], "app"); |
| set.put(args[5], "app"); |
| set.put(args[6], "app"); |
| |
| TargetModuleID[] apps = depl.getAllApplications(state); |
| log("Total count = " + apps.length); |
| return(checkIfAppsArePresent(apps, set)); |
| } |
| |
| private int testProgressObjectImplRace(String[] args) throws Exception { |
| /* |
| *This test works like testStartStop except that it uses only one application and sets the system |
| *property to introduce a sleep into listener notification to test race conditions. See ProgressObjectImpl |
| *for more details on the possible problem and how the test probes for it. |
| */ |
| String appOfInterest = args[4]; |
| boolean appIsRunning = true; |
| |
| try { |
| /* |
| *The system property to control the test code in ProgressObjectImpl could have been set on the |
| *command line that ran this test. If not, use the default value. |
| */ |
| Integer sleepTime = Integer.getInteger(SLEEP_TIME_PROPERTY_NAME, SLEEP_TIME_DEFAULT); |
| log("ProgressObjectImpl race test is using " + SLEEP_TIME_PROPERTY_NAME + " = " + sleepTime); |
| |
| /* |
| *Stop the first application specified on the command line. |
| */ |
| log("Stopping application " + appOfInterest); |
| if (depl.stop(appOfInterest) == null) { |
| log("Failed to stop " + appOfInterest); |
| return -1; |
| } |
| log("Stop request completed"); |
| |
| /* |
| *Wait a while for the stop operation to complete and the events to be delivered. |
| */ |
| try { |
| Thread.currentThread().sleep(sleepTime.intValue()); |
| } catch (InterruptedException ie) { |
| log("ProgressObjectImpl race test was interrupted during a sleep waiting for the app to stop."); |
| return -1; |
| } |
| |
| appIsRunning = false; |
| |
| /* |
| *Now that the app is stopped, start it and pay attention to the events. |
| */ |
| log("Starting application " + appOfInterest); |
| depl.clearReceivedEvents(); |
| if (depl.start(appOfInterest, sleepTime.intValue() / 2 ) == null) { |
| log("Failed to start " + appOfInterest); |
| return -1; |
| } |
| |
| appIsRunning = true; |
| |
| /* |
| *Wait before retrieving the events to give the start operation time to complete. |
| */ |
| |
| try { |
| Thread.currentThread().sleep(sleepTime.intValue()); |
| } catch (InterruptedException ie) { |
| throw new RuntimeException("TestClient was interrupted waiting for start operation events to accumulate before retrieving them.", ie); |
| } |
| |
| log("About to retrieve events"); |
| ProgressEvent receivedEvents[] = depl.getReceivedEvents(); |
| |
| /* |
| *We expect two events, one corresponding to the start operation entering the "running" state and |
| *one for the operation completing. If the race condition has occurred, then we won't see both of |
| *the events. We're going to look at the first one, expecting it to be the "running" event. |
| */ |
| if (receivedEvents.length < 2) { |
| log("ProgressObjectImpl race test expected two events (running and completed), but found " + receivedEvents.length + "."); |
| if (receivedEvents.length == 1) { |
| log("...and the event that was recorded was " + receivedEvents[0].getDeploymentStatus().getMessage()); |
| } |
| return -1; |
| } |
| |
| ProgressEvent event = receivedEvents[0]; |
| DeploymentStatus dStatus = event.getDeploymentStatus(); |
| |
| if ( ! dStatus.isRunning()) { |
| log("ProgressObjectImpl race test's first recorded event was not what was expected; expected running but found " + dStatus.getMessage()); |
| return -1; |
| } else { |
| log("ProgressObjectImpl race test completed normally."); |
| return 0; |
| } |
| |
| } finally { |
| /* |
| *Restart the application if it isn't running. |
| */ |
| if ( ! appIsRunning) { |
| log("Restarting application " + appOfInterest); |
| if (depl.start(appOfInterest) == null) { |
| log("Failed to restart application " + appOfInterest); |
| return -1; |
| } |
| } |
| } |
| } |
| |
| private int testStartStop(String[] args) { |
| try { |
| log("Stopping all Applications"); |
| for(int i=4; i<7; i++) { |
| if(depl.stop(args[i]) == null) { |
| log("Failed to stop " + args[i]); |
| return(-1); |
| } |
| } |
| boolean ret = checkReportedApps(args, Boolean.FALSE); |
| if(!ret) |
| return(-1); |
| log("Starting all Applications"); |
| for(int j=4; j<7; j++) { |
| if (depl.start(args[j]) == null) {; |
| log("Failed to start " + args[j]); |
| return(-1); |
| } |
| } |
| ret = checkReportedApps(args, Boolean.TRUE); |
| if(!ret) |
| return(-1); |
| } catch(Exception e) { |
| log("testStartStop recd exception : " + e.getMessage()); |
| return(-1); |
| } |
| return(0); |
| } |
| |
| private int getModulesByType(String args[], ModuleType type, Boolean state) { |
| log("Getting list of Applications with type = " + type.toString()); |
| log("Required running state = " + state); |
| try { |
| TargetModuleID[] apps = depl.getApplications(type, state); |
| log("Total count = " + apps.length); |
| |
| HashMap set = new HashMap(); |
| set.put(args[4], "app"); |
| |
| boolean ret = checkIfAppsArePresent(apps, set); |
| if(!ret) |
| return(-1); |
| } catch(Exception e) { |
| log("getModulesByType recd exception : " + e.getMessage()); |
| return(-1); |
| } |
| return(0); |
| } |
| |
| private int testEmptyModule() { |
| try { |
| TargetModuleID[] apps = depl.getApplications(ModuleType.WAR, null); |
| if(apps.length != 0) { |
| log("# of WARs expected = 0"); |
| log("# of WARs reported = " + apps.length); |
| return(-1); |
| } |
| apps = depl.getApplications(ModuleType.EJB, null); |
| if(apps.length != 0) { |
| log("# of EJB-JARs expected = 0"); |
| log("# of EJB-JARs reported = " + apps.length); |
| return(-1); |
| } |
| apps = depl.getApplications(ModuleType.EAR, null); |
| if(apps.length != 0) { |
| log("# of EARs expected = 0"); |
| log("# of EARs reported = " + apps.length); |
| return(-1); |
| } |
| } catch(Exception e) { |
| log("testEmptyModule recd exception : " + e.getMessage()); |
| return(-1); |
| } |
| return(0); |
| } |
| |
| public static void main(String[] args) { |
| int exitVal = 0; |
| TestClient client = new TestClient(); |
| try { |
| int testCase = (new Integer(args[0])).intValue(); |
| client.initDeployer(args); |
| switch(testCase) { |
| case 1 : |
| exitVal = client.getModulesByType(args,ModuleType.WAR,null); |
| break; |
| case 2 : |
| exitVal = client.getModulesByType(args,ModuleType.EJB,null); |
| break; |
| case 3 : |
| exitVal = client.getModulesByType(args,ModuleType.EAR,null); |
| break; |
| case 4 : |
| exitVal = client.testStartStop(args); |
| break; |
| case 5 : |
| exitVal = client.testEmptyModule(); |
| break; |
| case 6 : |
| exitVal = client.testProgressObjectImplRace(args); |
| break; |
| default: |
| log("Wrong test number given !!!"); |
| exitVal = -1; |
| break; |
| } |
| } catch (Exception e) { |
| log("Caught Exception = " + e.getMessage()); |
| System.exit(-1); |
| } |
| System.exit(exitVal); |
| } |
| |
| private static void log(String message) { |
| System.out.println("[JSR88APITest]:: " + message); |
| } |
| } |