/**
* Executes the command in the executor it is currently set to.
*
* @param source that sent the command
* @param args command arguments
* @throws CommandException if the command executor is null or if {@link
* Executor#execute(CommandSource, Command, CommandArguments)} throws a CommandException.
*/
public void process(CommandSource source, CommandArguments args) throws CommandException {
// check permissions
if (permission != null && !source.hasPermission(permission)) {
throw new CommandException("You do not have permission to execute this command.");
}
args.flags().registerFlags(this.flags);
// no child found, try to execute
for (CommandFilter filter : filters) {
filter.validate(this, source, args);
}
// execute a child if applicable
if (children.size() > 0) {
Command child = getChild(args.popString("child"), false);
if (child != null) {
if (executor != null) {
executor.execute(source, this, args);
}
child.process(source, args);
} else {
throw args.failure("child", "Unknown child!", false);
}
} else {
if (executor == null) {
throw new CommandException("CommandDescription exists but has no set executor.");
}
args.flags().parse();
executor.execute(source, this, args);
}
}
public Builder with(@CheckForNull Computer computer) {
if (computer == null) {
return this;
}
if (computer.isOnline()) {
final List<Executor> executors = computer.getExecutors();
final boolean acceptingTasks = computer.isAcceptingTasks();
for (Executor e : executors) {
definedExecutors++;
onlineExecutors++;
if (e.getCurrentWorkUnit() != null) {
busyExecutors++;
} else {
idleExecutors++;
if (acceptingTasks) availableExecutors++;
}
}
} else {
final int numExecutors = computer.getNumExecutors();
definedExecutors += numExecutors;
if (computer.isConnecting()) {
connectingExecutors += numExecutors;
}
}
return this;
}
/** Returns the number of idle {@link Executor}s that can start working immediately. */
public int countIdle() {
int n = 0;
for (Executor e : executors) {
if (e.isIdle()) n++;
}
return n;
}
private ValidationResult getValidationResult() {
if (!myValidationResultValid) {
myLastValidationResult = null;
try {
RunnerAndConfigurationSettings snapshot = getSnapshot();
if (snapshot != null) {
snapshot.setName(getNameText());
snapshot.checkSettings();
for (ProgramRunner runner : RunnerRegistry.getInstance().getRegisteredRunners()) {
for (Executor executor : ExecutorRegistry.getInstance().getRegisteredExecutors()) {
if (runner.canRun(executor.getId(), snapshot.getConfiguration())) {
checkConfiguration(runner, snapshot);
break;
}
}
}
}
} catch (RuntimeConfigurationException exception) {
myLastValidationResult =
exception != null
? new ValidationResult(
exception.getLocalizedMessage(), exception.getTitle(), exception.getQuickFix())
: null;
} catch (ConfigurationException e) {
myLastValidationResult =
new ValidationResult(
e.getLocalizedMessage(),
ExecutionBundle.message("invalid.data.dialog.title"),
null);
}
myValidationResultValid = true;
}
return myLastValidationResult;
}
@Override
protected void hyperlinkActivated(HyperlinkEvent e) {
final Module moduleByName =
ModuleManager.getInstance(myProject).findModuleByName(e.getDescription());
if (moduleByName != null) {
myConfiguration.getConfigurationModule().setModule(moduleByName);
try {
final Executor executor =
myConsoleProperties.isDebug()
? DefaultDebugExecutor.getDebugExecutorInstance()
: DefaultRunExecutor.getRunExecutorInstance();
final ProgramRunner runner =
RunnerRegistry.getInstance().getRunner(executor.getId(), myConfiguration);
assert runner != null;
runner.execute(
executor,
new ExecutionEnvironment(
myConfiguration,
myProject,
getRunnerSettings(),
getConfigurationSettings(),
null));
final Balloon balloon = myToolWindowManager.getToolWindowBalloon(myTestRunDebugId);
if (balloon != null) {
balloon.hide();
}
} catch (ExecutionException e1) {
LOG.error(e1);
}
}
}
public <E> List<E> query(
MappedStatement ms,
Object parameterObject,
RowBounds rowBounds,
ResultHandler resultHandler,
CacheKey key,
BoundSql boundSql)
throws SQLException {
Cache cache = ms.getCache();
if (cache != null) {
flushCacheIfRequired(ms);
if (ms.isUseCache() && resultHandler == null) {
ensureNoOutParams(ms, parameterObject, boundSql);
if (!dirty) {
cache.getReadWriteLock().readLock().lock();
try {
@SuppressWarnings("unchecked")
List<E> cachedList = (List<E>) cache.getObject(key);
if (cachedList != null) return cachedList;
} finally {
cache.getReadWriteLock().readLock().unlock();
}
}
List<E> list =
delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
tcm.putObject(
cache, key, list); // issue #578. Query must be not synchronized to prevent deadlocks
return list;
}
}
return delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
public static void run(
InvocationOutputHandler outputHandler,
Map<String, String> envVarsForApp,
CommandLine command,
File projectRoot,
long timeout)
throws ProjectCannotStartException {
long startTime = logStartInfo(command, projectRoot);
ExecuteWatchdog watchDog = new ExecuteWatchdog(timeout);
Executor executor = createExecutor(outputHandler, command, projectRoot, watchDog);
try {
int exitValue = executor.execute(command, envVarsForApp);
if (executor.isFailure(exitValue)) {
String message =
watchDog.killedProcess()
? "Timed out waiting for " + command
: "Exit code " + exitValue + " returned from " + command;
throw new ProjectCannotStartException(message);
}
} catch (Exception e) {
String message =
"Error running: "
+ dirPath(projectRoot)
+ "> "
+ StringUtils.join(command.toStrings(), " ");
outputHandler.consumeLine(message);
outputHandler.consumeLine(e.toString());
throw new ProjectCannotStartException(message, e);
}
logEndTime(command, startTime);
}
@Override
public void execute(Executor executor) {
setActive(); /*
currentRequestor = null;
Check if there is a valid host to which return the task output
for(int i=0; i<delegationChain.size() && currentRequestor == null; i++){
if(myRouter.getPresenceCollector().isHostInRange(delegationChain.get(i))){
currentRequestor = delegationChain.get(i);
}
} */
if (
/*currentRequestor != null*/ myRouter.getPresenceCollector().isHostInRange(requestor)
&& executor.moreCommunicatorsAvailable()) {
int[] missingRestOfMap =
((M2MShareRouter) requestor.getRouter()).getIntervalsForDownloadFwd(getID());
if (missingRestOfMap == null) {
setCompleted();
return;
}
System.err.println(
myRouter.getHost() + " - in DTNDownloadFwd.execute comincio a trasferire a " + requestor);
executor.addCommunicator(
myRouter.getPresenceCollector().getConnectionFor(requestor),
myRouter.getHost(),
filehash,
missingRestOfMap);
/* keep state = ACTIVE */
return;
}
// no communicator started
setIncomplete();
}
public static <R> R execute(
String url, String traceHearName, HttpRequest httpRequest, Executor<R> executor)
throws IOException {
if (!AuthDesc.isAuth()) {
return executor.execute();
}
try {
httpRequest.setHeader(
traceHearName,
"ContextData="
+ sender
.beforeSend(
Identification.newBuilder()
.viewPoint(url)
.spanType(WEBBuriedPointType.instance())
.build())
.toString());
return executor.execute();
} catch (IOException e) {
sender.handleException(e);
throw e;
} finally {
sender.afterSend();
}
}
protected void appendForkInfo(Executor executor) throws ExecutionException {
final String forkMode = getForkMode();
if (Comparing.strEqual(forkMode, "none")) {
if (forkPerModule()) {
if (isExecutorDisabledInForkedMode()) {
final String actionName = UIUtil.removeMnemonic(executor.getStartActionText());
throw new CantRunException(
"'"
+ actionName
+ "' is disabled when per-module working directory is configured.<br/>"
+ "Please specify single working directory, or change test scope to single module.");
}
} else {
return;
}
} else if (isExecutorDisabledInForkedMode()) {
final String actionName = executor.getActionName();
throw new CantRunException(
actionName
+ " is disabled in fork mode.<br/>Please change fork mode to <none> to "
+ actionName.toLowerCase(Locale.ENGLISH)
+ ".");
}
final JavaParameters javaParameters = getJavaParameters();
final Sdk jdk = javaParameters.getJdk();
if (jdk == null) {
throw new ExecutionException(
ExecutionBundle.message("run.configuration.error.no.jdk.specified"));
}
try {
final File tempFile = FileUtil.createTempFile("command.line", "", true);
final PrintWriter writer = new PrintWriter(tempFile, CharsetToolkit.UTF8);
try {
if (JdkUtil.useDynamicClasspath(getConfiguration().getProject())) {
String classpath = PathUtil.getJarPathForClass(CommandLineWrapper.class);
final String utilRtPath = PathUtil.getJarPathForClass(StringUtilRt.class);
if (!classpath.equals(utilRtPath)) {
classpath += File.pathSeparator + utilRtPath;
}
writer.println(classpath);
} else {
writer.println("");
}
writer.println(((JavaSdkType) jdk.getSdkType()).getVMExecutablePath(jdk));
for (String vmParameter : javaParameters.getVMParametersList().getList()) {
writer.println(vmParameter);
}
} finally {
writer.close();
}
passForkMode(forkMode, tempFile);
} catch (Exception e) {
LOG.error(e);
}
}
/**
* Stops this build if it's still going.
*
* <p>If we use this/executor/stop URL, it causes 404 if the build is already killed, as {@link
* #getExecutor()} returns null.
*/
public synchronized void doStop(StaplerRequest req, StaplerResponse rsp)
throws IOException, ServletException {
Executor e = getExecutor();
if (e != null) e.doStop(req, rsp);
else
// nothing is building
rsp.forwardToPreviousPage(req);
}
/**
* Receives users command until 'Esc' entered
*
* @param args
*/
public static void main(String[] args) {
Executor e = new Executor();
Scanner input = new Scanner(System.in);
String userData = "-help";
e.about();
while (!"Esc".equals(userData)) {
e.execute(userData);
userData = input.nextLine();
}
}
/**
* Returns the time when this computer last became idle.
*
* <p>If this computer is already idle, the return value will point to the time in the past since
* when this computer has been idle.
*
* <p>If this computer is busy, the return value will point to the time in the future where this
* computer will be expected to become free.
*/
public final long getIdleStartMilliseconds() {
long firstIdle = Long.MIN_VALUE;
for (Executor e : oneOffExecutors) {
firstIdle = Math.max(firstIdle, e.getIdleStartMilliseconds());
}
for (Executor e : executors) {
firstIdle = Math.max(firstIdle, e.getIdleStartMilliseconds());
}
return firstIdle;
}
public static void main(String[] args) {
Executor ex = new GameLogExecutorNate();
try {
ex.execute();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private void addNewExecutorIfNecessary() {
Set<Integer> availableNumbers = new HashSet<Integer>();
for (int i = 0; i < numExecutors; i++) availableNumbers.add(i);
for (Executor executor : executors) availableNumbers.remove(executor.getNumber());
for (Integer number : availableNumbers) {
Executor e = new Executor(this, number);
e.start();
executors.add(e);
}
}
@Override
protected void performDelete() throws IOException, InterruptedException {
// if a build is in progress. Cancel it.
RunT lb = getLastBuild();
if (lb != null) {
Executor e = lb.getExecutor();
if (e != null) {
e.interrupt();
// should we block until the build is cancelled?
}
}
super.performDelete();
}
public ExePane(Executor mdl, UiCommon texts) {
super(new BorderLayout());
ui = texts;
model = mdl;
mdl.getParent()
.addPropertyChangeListener(
new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent evt) {
if (evt.getSource() == model) {
if (EventQueue.isDispatchThread()) {
refresh();
} else {
EventQueue.invokeLater(
new Runnable() {
public void run() {
refresh();
}
});
}
}
}
});
mdl.setInputStream(new TextAreaStream(std));
mdl.setErrorStream(new TextAreaStream(err));
SwingHelper h = new SwingHelper(this);
h.with("header", new BorderLayout(), BorderLayout.PAGE_START)
.add("line", new JLabel(model.getCommand().getLine()), BorderLayout.CENTER)
.add("state", stateLabel, BorderLayout.LINE_END)
.back();
// h.add("streams", new JSplitPane(JSplitPane.VERTICAL_SPLIT,
// new JScrollPane(std), new JScrollPane(err)), BorderLayout.CENTER);
h.with("streams", new JTabbedPane(), BorderLayout.CENTER)
.add("std", new JScrollPane(std))
.add("err", new JScrollPane(err))
.back();
// streams =
std.setEditable(false);
err.setEditable(false);
h.with("buttons", new FlowLayout(), BorderLayout.PAGE_END).add("button", activeButton);
}
private synchronized void setNumExecutors(int n) {
if (numExecutors == n) return; // no-op
int diff = n - numExecutors;
this.numExecutors = n;
if (diff < 0) {
// send signal to all idle executors to potentially kill them off
for (Executor e : executors) if (e.isIdle()) e.interrupt();
} else {
// if the number is increased, add new ones
addNewExecutorIfNecessary();
}
}
@SuppressWarnings("unchecked")
public Map<String, String> getBuildVariables(AbstractBuild build, EnvInjectLogger logger)
throws EnvInjectException {
Map<String, String> result = new HashMap<String, String>();
// Add build process variables
result.putAll(build.getCharacteristicEnvVars());
try {
// EnvVars envVars = new EnvVars();
// for (EnvironmentContributor ec : EnvironmentContributor.all()) {
// ec.buildEnvironmentFor(build, envVars, new LogTaskListener(LOG, Level.ALL));
// result.putAll(envVars);
// }
JDK jdk = build.getProject().getJDK();
if (jdk != null) {
Node node = build.getBuiltOn();
if (node != null) {
jdk = jdk.forNode(node, logger.getListener());
}
jdk.buildEnvVars(result);
}
} catch (IOException ioe) {
throw new EnvInjectException(ioe);
} catch (InterruptedException ie) {
throw new EnvInjectException(ie);
}
Executor e = build.getExecutor();
if (e != null) {
result.put("EXECUTOR_NUMBER", String.valueOf(e.getNumber()));
}
String rootUrl = Hudson.getInstance().getRootUrl();
if (rootUrl != null) {
result.put("BUILD_URL", rootUrl + build.getUrl());
result.put("JOB_URL", rootUrl + build.getParent().getUrl());
}
// Add build variables such as parameters, plugins contributions, ...
result.putAll(build.getBuildVariables());
// Retrieve triggered cause
Map<String, String> triggerVariable = new BuildCauseRetriever().getTriggeredCause(build);
result.putAll(triggerVariable);
return result;
}
/** {@inheritDoc} */
@Override
public void run() {
List<Grid> clientGrids = runGrid();
assert clientGrids.size() == clientNodes;
int threadsCnt = clientNodes * threadsPerClient;
Executor e = Executors.newFixedThreadPool(threadsCnt);
for (Grid grid : clientGrids) {
for (int j = 0; j < threadsPerClient; j++)
e.execute(new GridJobLoadTestSubmitter(grid, taskParams, cancelRate, submitDelay));
}
}
public void submit(final EventHandler eh) {
Executor executor = getExecutor(getExecutorServiceType(eh.getEventType()));
if (executor == null) {
// This happens only when events are submitted after shutdown() was
// called, so dropping them should be "ok" since it means we're
// shutting down.
LOG.error(
"Cannot submit ["
+ eh
+ "] because the executor is missing."
+ " Is this process shutting down?");
} else {
executor.submit(eh);
}
}
public void execute() throws ExecuteException {
if (executor == null) {
throw new ExecuteException(name + ": is not defined");
} else {
executor.execute();
}
}
/**
* Schedules runnable task for execution.
*
* @param w Runnable task.
* @throws GridException Thrown if any exception occurred.
*/
@SuppressWarnings({"CatchGenericClass", "ProhibitedExceptionThrown"})
public void execute(final GridWorker w) throws GridException {
workers.add(w);
try {
exec.execute(
new Runnable() {
@Override
public void run() {
try {
w.run();
} finally {
workers.remove(w);
}
}
});
} catch (RejectedExecutionException e) {
workers.remove(w);
throw new GridComputeExecutionRejectedException(
"Failed to execute worker due to execution rejection.", e);
} catch (RuntimeException e) {
workers.remove(w);
throw new GridException("Failed to execute worker due to runtime exception.", e);
} catch (Error e) {
workers.remove(w);
throw e;
}
}
/** Do Unwind state transition. */
@Override
protected void i_unwind(Executor e) throws CALExecutorException {
// Simply push the single argument of this application
// and update the current instruction pointer.
e.stack.push(record);
e.setIP(getCode());
}
void refresh() {
Command cmd = model.getCommand();
stateLabel.setForeground(ui.getColor(cmd));
stateLabel.setText(ui.getState(cmd));
activeButton.setAction(getActionMap().get(cmd.isRunning() ? "stop" : "close"));
}
public void restart() {
final Project project =
PlatformDataKeys.PROJECT.getData(
DataManager.getInstance().getDataContext(myDescriptor.getComponent()));
if (ExecutorRegistry.getInstance()
.isStarting(project, myExecutor.getId(), myRunner.getRunnerId())) {
return;
}
try {
final ExecutionEnvironment old = myEnvironment;
myRunner.execute(
myExecutor,
new ExecutionEnvironment(
old.getRunProfile(),
old.getExecutionTarget(),
project,
old.getRunnerSettings(),
old.getConfigurationSettings(),
myDescriptor,
old.getRunnerAndConfigurationSettings()));
} catch (RunCanceledByUserException ignore) {
} catch (ExecutionException e1) {
Messages.showErrorDialog(
project, e1.getMessage(), ExecutionBundle.message("restart.error.message.title"));
}
}
@Override
public Object queryForObject(SqlStatement sql, Class requiredType) throws DatabaseException {
if (sql instanceof SelectFromDatabaseChangeLogLockStatement) {
return false;
}
return delegatedReadExecutor.queryForObject(sql, requiredType);
}
private void reallyStart() {
synchronized (syncLock) {
threadStarted = true;
}
if (logMINOR) Logger.minor(this, "Starting thread... " + name + " : " + runner);
realExecutor.execute(runner, name);
}
public static void main(String[] args) throws IOException {
ServerSocket socket = new ServerSocket(9001);
while (true) {
final Socket connection = socket.accept();
exec.execute(new ConnectionHandlerTask(connection));
}
}
boolean isEnabled() {
ProcessHandler processHandler = myDescriptor.getProcessHandler();
boolean isTerminating = processHandler != null && processHandler.isProcessTerminating();
boolean isStarting =
ExecutorRegistry.getInstance()
.isStarting(myEnvironment.getProject(), myExecutor.getId(), myRunner.getRunnerId());
return !isStarting && !isTerminating;
}
