Attachment #75754 for bug #156681

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 156681
Collapse All | Expand All





package org.netbeans.modules.j2ee.deployment.devmodules.api;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

    private static boolean alsoStartTargets = true;    //TODO - make it a property? is it really needed?
    
    private static Deployment instance = null;

    /**
     * Deployment mode enumeration
     */
    public static enum Mode {
        RUN, DEBUG, PROFILE;
    }

    public static synchronized Deployment getDefault () {
        if (instance == null) {
            instance = new Deployment ();

    private Deployment () {
    }
    
    /*Deploys a web J2EE module to server.
     * @param clientModuleUrl URL of module within a J2EE Application that 
     * should be used as a client (can be null for standalone modules)
     * <div class="nonnormative">
     * <p>Note: if null for J2EE application the first web or client module will be used.</p>
     * </div>
     * @return complete URL to be displayed in browser (server part plus the client module and/or client part provided as a parameter)
     * @deprecated Should use {@link Deployment#deploy(org.netbeans.modules.j2ee.deployment.devmodules.spi.J2eeModuleProvider, org.netbeans.modules.j2ee.deployment.devmodules.api.Deployment.Mode, java.lang.String, java.lang.String, boolean) } instead
     */
    public String deploy (J2eeModuleProvider jmp, boolean debug, String clientModuleUrl, String clientUrlPart, boolean forceRedeploy) throws DeploymentException {
        return deploy(jmp, debug ? Mode.DEBUG : Mode.RUN, clientModuleUrl, clientUrlPart, forceRedeploy, null);
    }

    /** Deploys a web J2EE module to server.
     * @param clientModuleUrl URL of module within a J2EE Application that 
     * should be used as a client (can be null for standalone modules)

     * </div>
     * @return complete URL to be displayed in browser (server part plus the client module and/or client part provided as a parameter)
     */
    public String deploy (J2eeModuleProvider jmp, Mode mode, String clientModuleUrl, String clientUrlPart, boolean forceRedeploy) throws DeploymentException {
        return deploy(jmp, mode, clientModuleUrl, clientUrlPart, forceRedeploy, null);
    }

    /**
     * @deprecated Should use {@link Deployment#deploy(org.netbeans.modules.j2ee.deployment.devmodules.spi.J2eeModuleProvider, org.netbeans.modules.j2ee.deployment.devmodules.api.Deployment.Mode, java.lang.String, java.lang.String, boolean, org.netbeans.modules.j2ee.deployment.devmodules.api.Deployment.Logger) } instead
     */
    public String deploy (J2eeModuleProvider jmp, boolean debug, String clientModuleUrl, String clientUrlPart, boolean forceRedeploy, Logger logger) throws DeploymentException {
        return deploy(jmp, debug ? Mode.DEBUG : Mode.RUN, clientModuleUrl, clientUrlPart, forceRedeploy, logger);
    }

    public String deploy (J2eeModuleProvider jmp, Mode mode, String clientModuleUrl, String clientUrlPart, boolean forceRedeploy, Logger logger) throws DeploymentException {
        
        DeploymentTargetImpl deploymentTarget = new DeploymentTargetImpl(jmp, clientModuleUrl);
        TargetModule[] modules = null;

            boolean serverReady = false;
            TargetServer targetserver = new TargetServer(deploymentTarget);

            if (alsoStartTargets || mode != Mode.RUN) {
                targetserver.startTargets(mode, progress);
            } else { //PENDING: how do we know whether target does not need to start when deploy only
                server.getServerInstance().start(progress);
            }




    public void startDebug(ProgressUI ui) throws ServerException {
        try {
            setServerState(STATE_WAITING);
            startTarget(null, ui, Deployment.Mode.DEBUG);
            _retrieveDebugInfo(null);
        } finally {
            refresh();

        try {
            setServerState(STATE_WAITING);
            // target == null - admin server
            _startProfile(null, settings, forceRestart, ui);
        } finally {
            refresh();
        }

            if (stopped) {
                // restart in the mode the server was running in before
                if (inProfile) {
                    _startProfile(null, profilerSettings, true, ui);
                } else if (inDebug) {
                    startDebugTarget(null, ui);
                } else {

     * @throws ServerException if the target cannot be started.
     */
    public void startTarget(Target target, ProgressUI ui) throws ServerException {
        startTarget(target, ui, Deployment.Mode.RUN);
    }
    
    /**

     * @throws ServerException if the server cannot be started.
     */
    public void startDebugTarget(Target target, ProgressUI ui) throws ServerException {
        startTarget(target, ui, Deployment.Mode.DEBUG);
        _retrieveDebugInfo(target);
    }
    

    /**
     * @throws ServerException if the server cannot be started.
     */
    private void startTarget(Target target, ProgressUI ui, Deployment.Mode mode) throws ServerException {
        StartServer ss = getStartServer();
        
        // No StartServer, have to assume manually started

        boolean needsRestart = ss.needsRestart(target);
        
        if (ss.isAlsoTargetServer(target)) {
            switch(mode) {
                case PROFILE: {
                    assert false; // should never come this far
                }
                case DEBUG: {
                    if (ss.isDebuggable(target)) { // already running in debug mode
                        if (! needsRestart) {
                            return;
                        }
                        if (!canControlAdmin || !canDebug) {
                            String msg = NbBundle.getMessage(ServerInstance.class, "MSG_RestartingThisServerNotSupported", getDisplayName());
                            throw new ServerException(msg);
                        }
                        _stop(ui);
                    } else if (isReallyRunning()) { // running but not debuggable
                        if (!canControlAdmin || !canDebug) {
                            String msg = NbBundle.getMessage(ServerInstance.class, "MSG_DebugginThisServerNotSupported", getDisplayName());
                            throw new ServerException(msg);
                        }
                        _stop(ui);
                    }
                    // the server is stopped now
                    if (!canDebug) {
                        throw new ServerException(msg);
                    }
                    _stop(ui);
                } else if (isReallyRunning()) { // running but not debuggable
                    if (!canControlAdmin || !canDebug) {
                        String msg = NbBundle.getMessage(ServerInstance.class, "MSG_DebugginThisServerNotSupported", getDisplayName());
                        throw new ServerException(msg);
                    }
                    // resolve conflicts with other servers
                    ConflictData cd = anotherServerDebuggable(target);
                    if (cd != null) { // another server instance with the same parameters
                        resolveServerConflict(target, ui, cd);
                    }
                    _startDebug(target, ui);
                    break;
                }
                case RUN: {
                    if (isReallyRunning()) { // already running
                        if (! needsRestart) {
                            return;
                        }
                        if (!canControlAdmin) {
                            String msg = NbBundle.getMessage(ServerInstance.class, "MSG_RestartingThisServerNotSupported", getDisplayName());
                            throw new ServerException(msg);
                        }
                        _stop(ui);
                    }
                    if (!canControlAdmin) {
                        String msg = NbBundle.getMessage(ServerInstance.class, "MSG_StartingThisServerNotSupported", getDisplayName());
                        throw new ServerException(msg);
                    }
                    _start(ui);
                    break;
                }
                if (!canControlAdmin) {
                    String msg = NbBundle.getMessage(ServerInstance.class, "MSG_StartingThisServerNotSupported", getDisplayName());
                    throw new ServerException(msg);
                }
                _start(ui);
            }
        } else { // not also target server
            // this block ensure a running admin server to control other targets

                }
                _start(ui);
            }
            switch (mode) {
                case DEBUG: {
                    if (ss.isDebuggable(target)) {
                        if ( ! needsRestart) {
                            return;
                        }
                        _stop(target, ui);
                    } else if (ss.isRunning(target)) {
                        _stop(target, ui);
                    }
                    ConflictData cd = anotherServerDebuggable(target);
                    if (cd != null) { //another server instance with the same parameters
                        resolveServerConflict(target, ui, cd);
                    }
                    _startDebug(target, ui);
                    break;
                }
                case RUN: {
                    if (ss.isRunning(target)) {
                        if (! needsRestart) {
                            return;
                        }
                        _stop(target, ui);
                    }
                    _start(target, ui);
                    break;
                }
                _startDebug(target, ui);
            } else {
                if (ss.isRunning(target)) {
                    if (! needsRestart) {
                        return;
                    }
                    _stop(target, ui);
                }
                _start(target, ui);
            }
        }
    }

    }
    
    /** start server in the profile mode */
    private void _startProfile(
                                    Target target, 
                                    ProfilerServerSettings settings,
                                    boolean forceRestart,




 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */


package org.netbeans.modules.j2ee.deployment.impl;

import java.io.File;

import javax.enterprise.deploy.spi.TargetModuleID;
import javax.enterprise.deploy.spi.exceptions.TargetException;
import javax.enterprise.deploy.spi.status.ProgressObject;
import org.netbeans.modules.j2ee.deployment.devmodules.api.Deployment.Mode;
import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eeApplication;
import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eeModule;
import org.netbeans.modules.j2ee.deployment.devmodules.api.ModuleChangeReporter;

import org.netbeans.modules.j2ee.deployment.plugins.spi.IncrementalDeployment;
import org.netbeans.modules.j2ee.deployment.plugins.spi.config.ModuleConfiguration;
import org.netbeans.modules.j2ee.deployment.plugins.spi.TargetModuleIDResolver;
import org.netbeans.modules.j2ee.deployment.profiler.api.ProfilerServerSettings;
import org.netbeans.modules.j2ee.deployment.profiler.spi.Profiler;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;

/**
 * Encapsulates a set of ServerTarget(s), provides a wrapper for deployment

public class TargetServer {

    private static final Logger LOGGER = Logger.getLogger(TargetServer.class.getName());

    private Target[] targets;
    private final ServerInstance instance;
    private final DeploymentTarget dtarget;

        }

        incremental = instance.getIncrementalDeployment();
        if (incremental != null && !checkServiceImplementations()) 
            incremental = null;

        try {

            return false;
        }

        if (deployable == null || null == deployable.getContentDirectory() || !instance.getIncrementalDeployment().canFileDeploy(targetz[0], deployable)) 
            return false;

        return true;

                }
                if (! redeployHasSharer ||
                    toDistribute.contains(sharer.getTarget())) {
                    shared = true;
                    addToUndeployWhenSharedDetected.add(sharer.delegate());
                } else {
                    removeFromRedeployWhenSharedDetected.add(sharer);
                    addToDistributeWhenSharedDetected.add(sharer.getTarget());

        Set toRedeploy = new HashSet(); //type TargetModule
        for (int i=0; i<targetModules.length; i++) {
            // not my module
           if (! targetModules[i].getInstanceUrl().equals(instance.getUrl()) ||
            ! targetNames.contains(targetModules[i].getTargetName()))
                continue;


        }
    }

    public void startTargets(Mode mode, ProgressUI ui) throws ServerException {
        if (instance.getStartServer().isAlsoTargetServer(null)) {
            switch (mode) {
                case DEBUG: {
                    instance.startDebug(ui);
                    break;
                }
                case PROFILE: {
                    ProfilerServerSettings settings = Lookup.getDefault().lookup(Profiler.class).getSettings(instance.getUrl());
                    instance.startProfile(settings, false, ui);
                    break;
                }
                case RUN: {
                    instance.start(ui);
                }
            }

            this.targets = dtarget.getServer().toTargets();
            return;
        }
        instance.start(ui);
        this.targets = dtarget.getServer().toTargets();
        switch (mode) {
            case DEBUG: {
                for (int i = 0; i < targets.length; i++) {
                    instance.startDebugTarget(targets[i], ui);
                }
                break;
            }
            case RUN: {
                for (int i = 0; i < targets.length; i++) {
                    instance.startTarget(targets[i], ui);
                }
                break;
            }
        }
    }

Return to bug 156681

Lines 41-47 Link Here

(-)a/j2eeserver/src/org/netbeans/modules/j2ee/deployment/devmodules/api/Deployment.java (-8 / +34 lines)
41		41
42	package org.netbeans.modules.j2ee.deployment.devmodules.api;	42	package org.netbeans.modules.j2ee.deployment.devmodules.api;
43		43
44	import java.io.IOException;
45	import java.util.ArrayList;	44	import java.util.ArrayList;
46	import java.util.Collection;	45	import java.util.Collection;
47	import java.util.Iterator;	46	import java.util.Iterator;
Lines 83-89 Link Here
83	private static boolean alsoStartTargets = true; //TODO - make it a property? is it really needed?	82	private static boolean alsoStartTargets = true; //TODO - make it a property? is it really needed?
84		83
85	private static Deployment instance = null;	84	private static Deployment instance = null;
86		85
		86	/**
		87	* Deployment mode enumeration
		88	*/
		89	public static enum Mode {
		90	RUN, DEBUG, PROFILE;
		91	}
		92
87	public static synchronized Deployment getDefault () {	93	public static synchronized Deployment getDefault () {
88	if (instance == null) {	94	if (instance == null) {
89	instance = new Deployment ();	95	instance = new Deployment ();
Lines 94-99 Link Here
94	private Deployment () {	100	private Deployment () {
95	}	101	}
96		102
		103	/*Deploys a web J2EE module to server.
		104	* @param clientModuleUrl URL of module within a J2EE Application that
		105	* should be used as a client (can be null for standalone modules)
		106	* <div class="nonnormative">
		107	* <p>Note: if null for J2EE application the first web or client module will be used.</p>
		108	* </div>
		109	* @return complete URL to be displayed in browser (server part plus the client module and/or client part provided as a parameter)
		110	* @deprecated Should use {@link Deployment#deploy(org.netbeans.modules.j2ee.deployment.devmodules.spi.J2eeModuleProvider, org.netbeans.modules.j2ee.deployment.devmodules.api.Deployment.Mode, java.lang.String, java.lang.String, boolean) } instead
		111	*/
		112	public String deploy (J2eeModuleProvider jmp, boolean debug, String clientModuleUrl, String clientUrlPart, boolean forceRedeploy) throws DeploymentException {
		113	return deploy(jmp, debug ? Mode.DEBUG : Mode.RUN, clientModuleUrl, clientUrlPart, forceRedeploy, null);
		114	}
		115
97	/** Deploys a web J2EE module to server.	116	/** Deploys a web J2EE module to server.
98	* @param clientModuleUrl URL of module within a J2EE Application that	117	* @param clientModuleUrl URL of module within a J2EE Application that
99	* should be used as a client (can be null for standalone modules)	118	* should be used as a client (can be null for standalone modules)
Lines 102-112 Link Here
102	* </div>	121	* </div>
103	* @return complete URL to be displayed in browser (server part plus the client module and/or client part provided as a parameter)	122	* @return complete URL to be displayed in browser (server part plus the client module and/or client part provided as a parameter)
104	*/	123	*/
105	public String deploy (J2eeModuleProvider jmp, boolean debugmode, String clientModuleUrl, String clientUrlPart, boolean forceRedeploy) throws DeploymentException {	124	public String deploy (J2eeModuleProvider jmp, Mode mode, String clientModuleUrl, String clientUrlPart, boolean forceRedeploy) throws DeploymentException {
106	return deploy(jmp, debugmode, clientModuleUrl, clientUrlPart, forceRedeploy, null);	125	return deploy(jmp, mode, clientModuleUrl, clientUrlPart, forceRedeploy, null);
107	}	126	}
108		127
109	public String deploy (J2eeModuleProvider jmp, boolean debugmode, String clientModuleUrl, String clientUrlPart, boolean forceRedeploy, Logger logger) throws DeploymentException {	128	/**
		129	* @deprecated Should use {@link Deployment#deploy(org.netbeans.modules.j2ee.deployment.devmodules.spi.J2eeModuleProvider, org.netbeans.modules.j2ee.deployment.devmodules.api.Deployment.Mode, java.lang.String, java.lang.String, boolean, org.netbeans.modules.j2ee.deployment.devmodules.api.Deployment.Logger) } instead
		130	*/
		131	public String deploy (J2eeModuleProvider jmp, boolean debug, String clientModuleUrl, String clientUrlPart, boolean forceRedeploy, Logger logger) throws DeploymentException {
		132	return deploy(jmp, debug ? Mode.DEBUG : Mode.RUN, clientModuleUrl, clientUrlPart, forceRedeploy, logger);
		133	}
		134
		135	public String deploy (J2eeModuleProvider jmp, Mode mode, String clientModuleUrl, String clientUrlPart, boolean forceRedeploy, Logger logger) throws DeploymentException {
110		136
111	DeploymentTargetImpl deploymentTarget = new DeploymentTargetImpl(jmp, clientModuleUrl);	137	DeploymentTargetImpl deploymentTarget = new DeploymentTargetImpl(jmp, clientModuleUrl);
112	TargetModule[] modules = null;	138	TargetModule[] modules = null;
Lines 151-158 Link Here
151	boolean serverReady = false;	177	boolean serverReady = false;
152	TargetServer targetserver = new TargetServer(deploymentTarget);	178	TargetServer targetserver = new TargetServer(deploymentTarget);
153		179
154	if (alsoStartTargets \|\| debugmode) {	180	if (alsoStartTargets \|\| mode != Mode.RUN) {
155	targetserver.startTargets(debugmode, progress);	181	targetserver.startTargets(mode, progress);
156	} else { //PENDING: how do we know whether target does not need to start when deploy only	182	} else { //PENDING: how do we know whether target does not need to start when deploy only
157	server.getServerInstance().start(progress);	183	server.getServerInstance().start(progress);
158	}	184	}

Lines 965-971 Link Here

(-)a/j2eeserver/src/org/netbeans/modules/j2ee/deployment/impl/ServerInstance.java (-60 / +73 lines)
965	public void startDebug(ProgressUI ui) throws ServerException {	965	public void startDebug(ProgressUI ui) throws ServerException {
966	try {	966	try {
967	setServerState(STATE_WAITING);	967	setServerState(STATE_WAITING);
968	startTarget(null, ui, true);	968	startTarget(null, ui, Deployment.Mode.DEBUG);
969	_retrieveDebugInfo(null);	969	_retrieveDebugInfo(null);
970	} finally {	970	} finally {
971	refresh();	971	refresh();
Lines 997-1003 Link Here
997	try {	997	try {
998	setServerState(STATE_WAITING);	998	setServerState(STATE_WAITING);
999	// target == null - admin server	999	// target == null - admin server
1000	startProfileImpl(null, settings, forceRestart, ui);	1000	_startProfile(null, settings, forceRestart, ui);
1001	} finally {	1001	} finally {
1002	refresh();	1002	refresh();
1003	}	1003	}
Lines 1021-1027 Link Here
1021	if (stopped) {	1021	if (stopped) {
1022	// restart in the mode the server was running in before	1022	// restart in the mode the server was running in before
1023	if (inProfile) {	1023	if (inProfile) {
1024	startProfileImpl(null, profilerSettings, true, ui);	1024	_startProfile(null, profilerSettings, true, ui);
1025	} else if (inDebug) {	1025	} else if (inDebug) {
1026	startDebugTarget(null, ui);	1026	startDebugTarget(null, ui);
1027	} else {	1027	} else {
Lines 1075-1081 Link Here
1075	* @throws ServerException if the target cannot be started.	1075	* @throws ServerException if the target cannot be started.
1076	*/	1076	*/
1077	public void startTarget(Target target, ProgressUI ui) throws ServerException {	1077	public void startTarget(Target target, ProgressUI ui) throws ServerException {
1078	startTarget(target, ui, false);	1078	startTarget(target, ui, Deployment.Mode.RUN);
1079	}	1079	}
1080		1080
1081	/**	1081	/**
Lines 1087-1093 Link Here
1087	* @throws ServerException if the server cannot be started.	1087	* @throws ServerException if the server cannot be started.
1088	*/	1088	*/
1089	public void startDebugTarget(Target target, ProgressUI ui) throws ServerException {	1089	public void startDebugTarget(Target target, ProgressUI ui) throws ServerException {
1090	startTarget(target, ui, true);	1090	startTarget(target, ui, Deployment.Mode.DEBUG);
1091	_retrieveDebugInfo(target);	1091	_retrieveDebugInfo(target);
1092	}	1092	}
1093		1093
Lines 1203-1209 Link Here
1203	/**	1203	/**
1204	* @throws ServerException if the server cannot be started.	1204	* @throws ServerException if the server cannot be started.
1205	*/	1205	*/
1206	private void startTarget(Target target, ProgressUI ui, boolean debugMode) throws ServerException {	1206	private void startTarget(Target target, ProgressUI ui, Deployment.Mode mode) throws ServerException {
1207	StartServer ss = getStartServer();	1207	StartServer ss = getStartServer();
1208		1208
1209	// No StartServer, have to assume manually started	1209	// No StartServer, have to assume manually started
Lines 1221-1270 Link Here
1221	boolean needsRestart = ss.needsRestart(target);	1221	boolean needsRestart = ss.needsRestart(target);
1222		1222
1223	if (ss.isAlsoTargetServer(target)) {	1223	if (ss.isAlsoTargetServer(target)) {
1224	if (debugMode) {	1224	switch(mode) {
1225	if (ss.isDebuggable(target)) { // already running in debug mode	1225	case PROFILE: {
1226	if (! needsRestart) {	1226	assert false; // should never come this far
1227	return;	1227	}
		1228	case DEBUG: {
		1229	if (ss.isDebuggable(target)) { // already running in debug mode
		1230	if (! needsRestart) {
		1231	return;
		1232	}
		1233	if (!canControlAdmin \|\| !canDebug) {
		1234	String msg = NbBundle.getMessage(ServerInstance.class, "MSG_RestartingThisServerNotSupported", getDisplayName());
		1235	throw new ServerException(msg);
		1236	}
		1237	_stop(ui);
		1238	} else if (isReallyRunning()) { // running but not debuggable
		1239	if (!canControlAdmin \|\| !canDebug) {
		1240	String msg = NbBundle.getMessage(ServerInstance.class, "MSG_DebugginThisServerNotSupported", getDisplayName());
		1241	throw new ServerException(msg);
		1242	}
		1243	_stop(ui);
1228	}	1244	}
1229	if (!canControlAdmin \|\| !canDebug) {	1245	// the server is stopped now
1230	String msg = NbBundle.getMessage(ServerInstance.class, "MSG_RestartingThisServerNotSupported", getDisplayName());	1246	if (!canDebug) {
1231	throw new ServerException(msg);
1232	}
1233	_stop(ui);
1234	} else if (isReallyRunning()) { // running but not debuggable
1235	if (!canControlAdmin \|\| !canDebug) {
1236	String msg = NbBundle.getMessage(ServerInstance.class, "MSG_DebugginThisServerNotSupported", getDisplayName());	1247	String msg = NbBundle.getMessage(ServerInstance.class, "MSG_DebugginThisServerNotSupported", getDisplayName());
1237	throw new ServerException(msg);	1248	throw new ServerException(msg);
1238	}	1249	}
1239	_stop(ui);	1250	// resolve conflicts with other servers
1240	}	1251	ConflictData cd = anotherServerDebuggable(target);
1241	// the server is stopped now	1252	if (cd != null) { // another server instance with the same parameters
1242	if (!canDebug) {	1253	resolveServerConflict(target, ui, cd);
1243	String msg = NbBundle.getMessage(ServerInstance.class, "MSG_DebugginThisServerNotSupported", getDisplayName());	1254	}
1244	throw new ServerException(msg);	1255	_startDebug(target, ui);
		1256	break;
1245	}	1257	}
1246	// resolve conflicts with other servers	1258	case RUN: {
1247	ConflictData cd = anotherServerDebuggable(target);	1259	if (isReallyRunning()) { // already running
1248	if (cd != null) { // another server instance with the same parameters	1260	if (! needsRestart) {
1249	resolveServerConflict(target, ui, cd);	1261	return;
1250	}	1262	}
1251	_startDebug(target, ui);	1263	if (!canControlAdmin) {
1252	} else {	1264	String msg = NbBundle.getMessage(ServerInstance.class, "MSG_RestartingThisServerNotSupported", getDisplayName());
1253	if (isReallyRunning()) { // already running	1265	throw new ServerException(msg);
1254	if (! needsRestart) {	1266	}
1255	return;	1267	_stop(ui);
1256	}	1268	}
1257	if (!canControlAdmin) {	1269	if (!canControlAdmin) {
1258	String msg = NbBundle.getMessage(ServerInstance.class, "MSG_RestartingThisServerNotSupported", getDisplayName());	1270	String msg = NbBundle.getMessage(ServerInstance.class, "MSG_StartingThisServerNotSupported", getDisplayName());
1259	throw new ServerException(msg);	1271	throw new ServerException(msg);
1260	}	1272	}
1261	_stop(ui);	1273	_start(ui);
		1274	break;
1262	}	1275	}
1263	if (!canControlAdmin) {
1264	String msg = NbBundle.getMessage(ServerInstance.class, "MSG_StartingThisServerNotSupported", getDisplayName());
1265	throw new ServerException(msg);
1266	}
1267	_start(ui);
1268	}	1276	}
1269	} else { // not also target server	1277	} else { // not also target server
1270	// this block ensure a running admin server to control other targets	1278	// this block ensure a running admin server to control other targets
Lines 1275-1302 Link Here
1275	}	1283	}
1276	_start(ui);	1284	_start(ui);
1277	}	1285	}
1278	if (debugMode) {	1286	switch (mode) {
1279	if (ss.isDebuggable(target)) {	1287	case DEBUG: {
1280	if ( ! needsRestart) {	1288	if (ss.isDebuggable(target)) {
1281	return;	1289	if ( ! needsRestart) {
		1290	return;
		1291	}
		1292	_stop(target, ui);
		1293	} else if (ss.isRunning(target)) {
		1294	_stop(target, ui);
1282	}	1295	}
1283	_stop(target, ui);	1296	ConflictData cd = anotherServerDebuggable(target);
1284	} else if (ss.isRunning(target)) {	1297	if (cd != null) { //another server instance with the same parameters
1285	_stop(target, ui);	1298	resolveServerConflict(target, ui, cd);
		1299	}
		1300	_startDebug(target, ui);
		1301	break;
1286	}	1302	}
1287	ConflictData cd = anotherServerDebuggable(target);	1303	case RUN: {
1288	if (cd != null) { //another server instance with the same parameters	1304	if (ss.isRunning(target)) {
1289	resolveServerConflict(target, ui, cd);	1305	if (! needsRestart) {
		1306	return;
		1307	}
		1308	_stop(target, ui);
		1309	}
		1310	_start(target, ui);
		1311	break;
1290	}	1312	}
1291	_startDebug(target, ui);
1292	} else {
1293	if (ss.isRunning(target)) {
1294	if (! needsRestart) {
1295	return;
1296	}
1297	_stop(target, ui);
1298	}
1299	_start(target, ui);
1300	}	1313	}
1301	}	1314	}
1302	}	1315	}
Lines 1345-1351 Link Here
1345	}	1358	}
1346		1359
1347	/** start server in the profile mode */	1360	/** start server in the profile mode */
1348	private void startProfileImpl(	1361	private void _startProfile(
1349	Target target,	1362	Target target,
1350	ProfilerServerSettings settings,	1363	ProfilerServerSettings settings,
1351	boolean forceRestart,	1364	boolean forceRestart,

Lines 38-45 Link Here

(-)a/j2eeserver/src/org/netbeans/modules/j2ee/deployment/impl/TargetServer.java (-19 / +35 lines)
38	* Version 2 license, then the option applies only if the new code is	38	* Version 2 license, then the option applies only if the new code is
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41
42
43	package org.netbeans.modules.j2ee.deployment.impl;	41	package org.netbeans.modules.j2ee.deployment.impl;
44		42
45	import java.io.File;	43	import java.io.File;
Lines 71-76 Link Here
71	import javax.enterprise.deploy.spi.TargetModuleID;	69	import javax.enterprise.deploy.spi.TargetModuleID;
72	import javax.enterprise.deploy.spi.exceptions.TargetException;	70	import javax.enterprise.deploy.spi.exceptions.TargetException;
73	import javax.enterprise.deploy.spi.status.ProgressObject;	71	import javax.enterprise.deploy.spi.status.ProgressObject;
		72	import org.netbeans.modules.j2ee.deployment.devmodules.api.Deployment.Mode;
74	import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eeApplication;	73	import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eeApplication;
75	import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eeModule;	74	import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eeModule;
76	import org.netbeans.modules.j2ee.deployment.devmodules.api.ModuleChangeReporter;	75	import org.netbeans.modules.j2ee.deployment.devmodules.api.ModuleChangeReporter;
Lines 82-88 Link Here
82	import org.netbeans.modules.j2ee.deployment.plugins.spi.IncrementalDeployment;	81	import org.netbeans.modules.j2ee.deployment.plugins.spi.IncrementalDeployment;
83	import org.netbeans.modules.j2ee.deployment.plugins.spi.config.ModuleConfiguration;	82	import org.netbeans.modules.j2ee.deployment.plugins.spi.config.ModuleConfiguration;
84	import org.netbeans.modules.j2ee.deployment.plugins.spi.TargetModuleIDResolver;	83	import org.netbeans.modules.j2ee.deployment.plugins.spi.TargetModuleIDResolver;
		84	import org.netbeans.modules.j2ee.deployment.profiler.api.ProfilerServerSettings;
		85	import org.netbeans.modules.j2ee.deployment.profiler.spi.Profiler;
85	import org.openide.util.Exceptions;	86	import org.openide.util.Exceptions;
		87	import org.openide.util.Lookup;
86		88
87	/**	89	/**
88	* Encapsulates a set of ServerTarget(s), provides a wrapper for deployment	90	* Encapsulates a set of ServerTarget(s), provides a wrapper for deployment
Lines 99-105 Link Here
99	public class TargetServer {	101	public class TargetServer {
100		102
101	private static final Logger LOGGER = Logger.getLogger(TargetServer.class.getName());	103	private static final Logger LOGGER = Logger.getLogger(TargetServer.class.getName());
102
103	private Target[] targets;	104	private Target[] targets;
104	private final ServerInstance instance;	105	private final ServerInstance instance;
105	private final DeploymentTarget dtarget;	106	private final DeploymentTarget dtarget;
Lines 136-142 Link Here
136	}	137	}
137		138
138	incremental = instance.getIncrementalDeployment();	139	incremental = instance.getIncrementalDeployment();
139	if (incremental != null && !checkServiceImplementations())	140	if (incremental != null && !checkServiceImplementations())
140	incremental = null;	141	incremental = null;
141		142
142	try {	143	try {
Lines 186-192 Link Here
186	return false;	187	return false;
187	}	188	}
188		189
189	if (deployable == null \|\| null == deployable.getContentDirectory() \|\| !instance.getIncrementalDeployment().canFileDeploy(targetz[0], deployable))	190	if (deployable == null \|\| null == deployable.getContentDirectory() \|\| !instance.getIncrementalDeployment().canFileDeploy(targetz[0], deployable))
190	return false;	191	return false;
191		192
192	return true;	193	return true;
Lines 359-366 Link Here
359	}	360	}
360	if (! redeployHasSharer \|\|	361	if (! redeployHasSharer \|\|
361	toDistribute.contains(sharer.getTarget())) {	362	toDistribute.contains(sharer.getTarget())) {
362	shared = true;	363	shared = true;
363	addToUndeployWhenSharedDetected.add(sharer.delegate());	364	addToUndeployWhenSharedDetected.add(sharer.delegate());
364	} else {	365	} else {
365	removeFromRedeployWhenSharedDetected.add(sharer);	366	removeFromRedeployWhenSharedDetected.add(sharer);
366	addToDistributeWhenSharedDetected.add(sharer.getTarget());	367	addToDistributeWhenSharedDetected.add(sharer.getTarget());
Lines 423-429 Link Here
423	Set toRedeploy = new HashSet(); //type TargetModule	424	Set toRedeploy = new HashSet(); //type TargetModule
424	for (int i=0; i<targetModules.length; i++) {	425	for (int i=0; i<targetModules.length; i++) {
425	// not my module	426	// not my module
426	if (! targetModules[i].getInstanceUrl().equals(instance.getUrl()) \|\|	427	if (! targetModules[i].getInstanceUrl().equals(instance.getUrl()) \|\|
427	! targetNames.contains(targetModules[i].getTargetName()))	428	! targetNames.contains(targetModules[i].getTargetName()))
428	continue;	429	continue;
429		430
Lines 481-505 Link Here
481	}	482	}
482	}	483	}
483		484
484	public void startTargets(boolean debugMode, ProgressUI ui) throws ServerException {	485	public void startTargets(Mode mode, ProgressUI ui) throws ServerException {
485	if (instance.getStartServer().isAlsoTargetServer(null)) {	486	if (instance.getStartServer().isAlsoTargetServer(null)) {
486	if (debugMode) {	487	switch (mode) {
487	instance.startDebug(ui);	488	case DEBUG: {
488	} else {	489	instance.startDebug(ui);
489	instance.start(ui);	490	break;
		491	}
		492	case PROFILE: {
		493	ProfilerServerSettings settings = Lookup.getDefault().lookup(Profiler.class).getSettings(instance.getUrl());
		494	instance.startProfile(settings, false, ui);
		495	break;
		496	}
		497	case RUN: {
		498	instance.start(ui);
		499	}
490	}	500	}
		501
491	this.targets = dtarget.getServer().toTargets();	502	this.targets = dtarget.getServer().toTargets();
492	return;	503	return;
493	}	504	}
494	instance.start(ui);	505	instance.start(ui);
495	this.targets = dtarget.getServer().toTargets();	506	this.targets = dtarget.getServer().toTargets();
496	if (debugMode) {	507	switch (mode) {
497	for (int i=0; i<targets.length; i++) {	508	case DEBUG: {
498	instance.startDebugTarget(targets[i], ui);	509	for (int i = 0; i < targets.length; i++) {
		510	instance.startDebugTarget(targets[i], ui);
		511	}
		512	break;
499	}	513	}
500	} else {	514	case RUN: {
501	for (int i=0; i<targets.length; i++) {	515	for (int i = 0; i < targets.length; i++) {
502	instance.startTarget(targets[i], ui);	516	instance.startTarget(targets[i], ui);
		517	}
		518	break;
503	}	519	}
504	}	520	}
505	}	521	}