From d850e92f4498da771889c4e387c3f82c92b5d537 Mon Sep 17 00:00:00 2001 From: Eugene Zhuravlev Date: Wed, 17 Jun 2015 10:01:27 +0200 Subject: [PATCH] external javac server refactoring --- .../jps/incremental/IncProjectBuilder.java | 6 +- .../jps/incremental/java/JavaBuilder.java | 34 ++- ...cServer.java => ExternalJavacManager.java} | 200 +++++++++++++++--- .../jps/javac/JavacServerBootstrap.java | 182 ---------------- .../jps/service/SharedThreadPool.java | 6 +- .../jetbrains/jps/service/ThreadExecutor.java | 23 ++ 6 files changed, 227 insertions(+), 224 deletions(-) rename jps/jps-builders/src/org/jetbrains/jps/javac/{ExternalJavacServer.java => ExternalJavacManager.java} (59%) delete mode 100644 jps/jps-builders/src/org/jetbrains/jps/javac/JavacServerBootstrap.java create mode 100644 jps/model-api/src/org/jetbrains/jps/service/ThreadExecutor.java diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java index 9cadca9b0ef8..1301bf530486 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java @@ -52,7 +52,7 @@ import org.jetbrains.jps.incremental.storage.BuildTargetConfiguration; import org.jetbrains.jps.incremental.storage.OneToManyPathsMapping; import org.jetbrains.jps.incremental.storage.OutputToTargetRegistry; import org.jetbrains.jps.indices.ModuleExcludeIndex; -import org.jetbrains.jps.javac.ExternalJavacServer; +import org.jetbrains.jps.javac.ExternalJavacManager; import org.jetbrains.jps.javac.JavacMain; import org.jetbrains.jps.model.java.JpsJavaExtensionService; import org.jetbrains.jps.model.java.compiler.JpsJavaCompilerConfiguration; @@ -313,10 +313,10 @@ public class IncProjectBuilder { pd.timestamps.getStorage().force(); pd.dataManager.flush(false); } - final ExternalJavacServer server = ExternalJavacServer.KEY.get(context); + final ExternalJavacManager server = ExternalJavacManager.KEY.get(context); if (server != null) { server.stop(); - ExternalJavacServer.KEY.set(context, null); + ExternalJavacManager.KEY.set(context, null); } } diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/java/JavaBuilder.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/java/JavaBuilder.java index 71babde60c79..a91de8dcb014 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/java/JavaBuilder.java +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/java/JavaBuilder.java @@ -59,8 +59,10 @@ import org.jetbrains.jps.model.module.JpsModuleType; import org.jetbrains.jps.model.serialization.JpsModelSerializationDataService; import org.jetbrains.jps.model.serialization.PathMacroUtil; import org.jetbrains.jps.service.JpsServiceManager; +import org.jetbrains.jps.service.SharedThreadPool; -import javax.tools.*; +import javax.tools.Diagnostic; +import javax.tools.JavaFileObject; import java.io.*; import java.net.ServerSocket; import java.util.*; @@ -392,9 +394,9 @@ public class JavaBuilder extends ModuleLevelBuilder { } final List vmOptions = getCompilationVMOptions(context, compilingTool); - final ExternalJavacServer server = ensureJavacServerStarted(context); + final ExternalJavacManager server = ensureJavacServerStarted(context); rc = server.forkJavac( - context, options, vmOptions, files, classpath, _platformCp, sourcePath, outs, diagnosticSink, classesConsumer, sdkHome, compilingTool + sdkHome, getExternalJavacHeapSize(context), vmOptions, options, _platformCp, classpath, sourcePath, files, outs, diagnosticSink, classesConsumer, compilingTool, context.getCancelStatus() ); } return rc; @@ -404,6 +406,12 @@ public class JavaBuilder extends ModuleLevelBuilder { } } + private static int getExternalJavacHeapSize(CompileContext context) { + final JpsProject project = context.getProjectDescriptor().getProject(); + final JpsJavaCompilerConfiguration config = JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration(project); + final JpsJavaCompilerOptions options = config.getCurrentCompilerOptions(); + return options.MAXIMUM_HEAP_SIZE; + } @Nullable public static String validateCycle(ModuleChunk chunk, JpsJavaExtensionService javaExt, @@ -517,15 +525,15 @@ public class JavaBuilder extends ModuleLevelBuilder { }); } - private static synchronized ExternalJavacServer ensureJavacServerStarted(@NotNull CompileContext context) throws Exception { - ExternalJavacServer server = ExternalJavacServer.KEY.get(context); + private static synchronized ExternalJavacManager ensureJavacServerStarted(@NotNull CompileContext context) throws Exception { + ExternalJavacManager server = ExternalJavacManager.KEY.get(context); if (server != null) { return server; } final int listenPort = findFreePort(); - server = new ExternalJavacServer(); + server = new ExternalJavacManager(Utils.getSystemRoot(), SharedThreadPool.getInstance()); server.start(listenPort); - ExternalJavacServer.KEY.set(context, server); + ExternalJavacManager.KEY.set(context, server); return server; } @@ -584,7 +592,7 @@ public class JavaBuilder extends ModuleLevelBuilder { } catch (IOException e) { e.printStackTrace(System.err); - return ExternalJavacServer.DEFAULT_SERVER_PORT; + return ExternalJavacManager.DEFAULT_SERVER_PORT; } } @@ -903,7 +911,15 @@ public class JavaBuilder extends ModuleLevelBuilder { public void outputLineAvailable(String line) { if (!StringUtil.isEmpty(line)) { - if (line.contains("java.lang.OutOfMemoryError")) { + if (line.startsWith(ExternalJavacManager.STDOUT_LINE_PREFIX)) { + //noinspection UseOfSystemOutOrSystemErr + System.out.println(line); + } + else if (line.startsWith(ExternalJavacManager.STDERR_LINE_PREFIX)) { + //noinspection UseOfSystemOutOrSystemErr + System.err.println(line); + } + else if (line.contains("java.lang.OutOfMemoryError")) { myContext.processMessage(new CompilerMessage(BUILDER_NAME, BuildMessage.Kind.ERROR, "OutOfMemoryError: insufficient memory")); myErrorCount++; } diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ExternalJavacServer.java b/jps/jps-builders/src/org/jetbrains/jps/javac/ExternalJavacManager.java similarity index 59% rename from jps/jps-builders/src/org/jetbrains/jps/javac/ExternalJavacServer.java rename to jps/jps-builders/src/org/jetbrains/jps/javac/ExternalJavacManager.java index f5ff5b175bd8..faa083d9743b 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/javac/ExternalJavacServer.java +++ b/jps/jps-builders/src/org/jetbrains/jps/javac/ExternalJavacManager.java @@ -15,7 +15,15 @@ */ package org.jetbrains.jps.javac; +import com.intellij.execution.process.BaseOSProcessHandler; +import com.intellij.execution.process.ProcessAdapter; +import com.intellij.execution.process.ProcessEvent; +import com.intellij.execution.process.ProcessOutputTypes; import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.util.Key; +import com.intellij.openapi.util.SystemInfo; +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.util.text.StringUtil; import com.intellij.util.concurrency.Semaphore; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.*; @@ -32,19 +40,17 @@ import io.netty.util.AttributeKey; import io.netty.util.concurrent.ImmediateEventExecutor; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jps.api.CanceledStatus; import org.jetbrains.jps.builders.java.JavaCompilingTool; -import org.jetbrains.jps.incremental.CompileContext; +import org.jetbrains.jps.cmdline.ClasspathBootstrap; import org.jetbrains.jps.incremental.GlobalContextKey; -import org.jetbrains.jps.incremental.Utils; -import org.jetbrains.jps.model.JpsProject; -import org.jetbrains.jps.model.java.JpsJavaExtensionService; -import org.jetbrains.jps.model.java.compiler.JpsJavaCompilerConfiguration; -import org.jetbrains.jps.model.java.compiler.JpsJavaCompilerOptions; import org.jetbrains.jps.service.SharedThreadPool; +import org.jetbrains.jps.service.ThreadExecutor; -import javax.tools.*; +import javax.tools.Diagnostic; import java.io.File; import java.util.*; +import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; /** @@ -52,17 +58,26 @@ import java.util.concurrent.TimeUnit; * Date: 1/22/12 */ @SuppressWarnings("UseOfSystemOutOrSystemErr") -public class ExternalJavacServer { +public class ExternalJavacManager { private static final Logger LOG = Logger.getInstance("#org.jetbrains.jps.javac.ExternalJavacServer"); - public static final GlobalContextKey KEY = GlobalContextKey.create("_external_javac_server_"); + public static final GlobalContextKey KEY = GlobalContextKey.create("_external_javac_server_"); public static final int DEFAULT_SERVER_PORT = 7878; + public static final String STDOUT_LINE_PREFIX = "JAVAC_PROCESS[STDOUT]"; + public static final String STDERR_LINE_PREFIX = "JAVAC_PROCESS[STDERR]"; private static final AttributeKey SESSION_DESCRIPTOR = AttributeKey.valueOf("ExternalJavacServer.JavacProcessDescriptor"); + private final File mySystemRoot; + private final ThreadExecutor myThreadExecutor; private ChannelRegistrar myChannelRegistrar; private final Map myMessageHandlers = new HashMap(); private int myListenPort = DEFAULT_SERVER_PORT; + public ExternalJavacManager(final File systemRoot, @NotNull ThreadExecutor threadExecutor) { + mySystemRoot = systemRoot; + myThreadExecutor = threadExecutor; + } + public void start(int listenPort) { final ServerBootstrap bootstrap = new ServerBootstrap().group(new NioEventLoopGroup(1, SharedThreadPool.getInstance())).channel(NioServerSocketChannel.class); bootstrap.childOption(ChannelOption.TCP_NODELAY, true).childOption(ChannelOption.SO_KEEPALIVE, true); @@ -83,23 +98,16 @@ public class ExternalJavacServer { myListenPort = listenPort; } - private static int getExternalJavacHeapSize(CompileContext context) { - final JpsProject project = context.getProjectDescriptor().getProject(); - final JpsJavaCompilerConfiguration config = JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration(project); - final JpsJavaCompilerOptions options = config.getCurrentCompilerOptions(); - return options.MAXIMUM_HEAP_SIZE; - } - - public boolean forkJavac(CompileContext context, List options, - List vmOptions, Collection files, - Collection classpath, + public boolean forkJavac(final String javaHome, final int heapSize, List vmOptions, List options, Collection platformCp, + Collection classpath, Collection sourcePath, + Collection files, Map> outs, - DiagnosticOutputConsumer diagnosticSink, - OutputFileConsumer outputSink, - final String javaHome, final JavaCompilingTool compilingTool) { + final DiagnosticOutputConsumer diagnosticSink, OutputFileConsumer outputSink, + final JavaCompilingTool compilingTool, + final CanceledStatus cancelStatus) { final ExternalJavacMessageHandler rh = new ExternalJavacMessageHandler(diagnosticSink, outputSink, getEncodingName(options)); final JavacRemoteProto.Message.Request request = JavacProtoUtil.createCompilationRequest(options, files, classpath, platformCp, sourcePath, outs); final UUID uuid = UUID.randomUUID(); @@ -108,9 +116,27 @@ public class ExternalJavacServer { myMessageHandlers.put(uuid, processDescriptor); } try { - final JavacServerBootstrap.ExternalJavacProcessHandler processHandler = JavacServerBootstrap.launchExternalJavacProcess( - uuid, javaHome, getExternalJavacHeapSize(context), myListenPort, Utils.getSystemRoot(), vmOptions, compilingTool + final ExternalJavacProcessHandler processHandler = launchExternalJavacProcess( + uuid, javaHome, heapSize, myListenPort, mySystemRoot, vmOptions, compilingTool ); + processHandler.addProcessListener(new ProcessAdapter() { + public void onTextAvailable(ProcessEvent event, Key outputType) { + final String text = event.getText(); + if (!StringUtil.isEmptyOrSpaces(text)) { + String prefix = null; + if (outputType == ProcessOutputTypes.STDOUT) { + prefix = STDOUT_LINE_PREFIX; + } + else if (outputType == ProcessOutputTypes.STDERR) { + prefix = STDERR_LINE_PREFIX; + } + if (prefix != null) { + diagnosticSink.outputLineAvailable(prefix + ": " + text); + } + } + } + }); + processHandler.startNotify(); while (!processDescriptor.waitFor(300L)) { if (processHandler.isProcessTerminated() && processDescriptor.channel == null && processHandler.getExitCode() != 0) { @@ -118,7 +144,7 @@ public class ExternalJavacServer { processDescriptor.setDone(); break; } - if (context.getCancelStatus().isCanceled()) { + if (cancelStatus.isCanceled()) { processDescriptor.cancelBuild(); } } @@ -163,6 +189,130 @@ public class ExternalJavacServer { myChannelRegistrar.close().awaitUninterruptibly(); } + private ExternalJavacProcessHandler launchExternalJavacProcess(UUID uuid, String sdkHomePath, + int heapSize, + int port, + File workingDir, + List vmOptions, + JavaCompilingTool compilingTool) throws Exception { + final List cmdLine = new ArrayList(); + appendParam(cmdLine, getVMExecutablePath(sdkHomePath)); + //appendParam(cmdLine, "-XX:MaxPermSize=150m"); + //appendParam(cmdLine, "-XX:ReservedCodeCacheSize=64m"); + appendParam(cmdLine, "-Djava.awt.headless=true"); + final int xms = heapSize / 2; + if (xms > 32) { + appendParam(cmdLine, "-Xms" + xms + "m"); + } + appendParam(cmdLine, "-Xmx" + heapSize + "m"); + + // debugging + //appendParam(cmdLine, "-XX:+HeapDumpOnOutOfMemoryError"); + //appendParam(cmdLine, "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5009"); + + // javac's VM should use the same default locale that IDEA uses in order for javac to print messages in 'correct' language + final String encoding = System.getProperty("file.encoding"); + if (encoding != null) { + appendParam(cmdLine, "-Dfile.encoding=" + encoding); + } + final String lang = System.getProperty("user.language"); + if (lang != null) { + //noinspection HardCodedStringLiteral + appendParam(cmdLine, "-Duser.language=" + lang); + } + final String country = System.getProperty("user.country"); + if (country != null) { + //noinspection HardCodedStringLiteral + appendParam(cmdLine, "-Duser.country=" + country); + } + //noinspection HardCodedStringLiteral + final String region = System.getProperty("user.region"); + if (region != null) { + //noinspection HardCodedStringLiteral + appendParam(cmdLine, "-Duser.region=" + region); + } + + appendParam(cmdLine, "-D" + ExternalJavacProcess.JPS_JAVA_COMPILING_TOOL_PROPERTY + "=" + compilingTool.getId()); + + // this will disable standard extensions to ensure javac is loaded from the right tools.jar + appendParam(cmdLine, "-Djava.ext.dirs="); + + appendParam(cmdLine, "-Dlog4j.defaultInitOverride=true"); + + for (String option : vmOptions) { + appendParam(cmdLine, option); + } + + appendParam(cmdLine, "-classpath"); + + final List cp = ClasspathBootstrap.getExternalJavacProcessClasspath(sdkHomePath, compilingTool); + final StringBuilder classpath = new StringBuilder(); + for (File file : cp) { + if (classpath.length() > 0) { + classpath.append(File.pathSeparator); + } + classpath.append(file.getPath()); + } + appendParam(cmdLine, classpath.toString()); + + appendParam(cmdLine, ExternalJavacProcess.class.getName()); + appendParam(cmdLine, uuid.toString()); + appendParam(cmdLine, "127.0.0.1"); + appendParam(cmdLine, Integer.toString(port)); + + workingDir.mkdirs(); + + appendParam(cmdLine, FileUtil.toSystemIndependentName(workingDir.getPath())); + + final ProcessBuilder builder = new ProcessBuilder(cmdLine); + builder.directory(workingDir); + + final Process process = builder.start(); + return new ExternalJavacProcessHandler(process, myThreadExecutor); + } + + private static void appendParam(List cmdLine, String param) { + if (SystemInfo.isWindows) { + if (param.contains("\"")) { + param = StringUtil.replace(param, "\"", "\\\""); + } + else if (param.length() == 0) { + param = "\"\""; + } + } + cmdLine.add(param); + } + + private static String getVMExecutablePath(String sdkHome) { + return sdkHome + "/bin/java"; + } + + private static class ExternalJavacProcessHandler extends BaseOSProcessHandler { + @NotNull + private final ThreadExecutor myExecutorService; + private volatile int myExitCode; + + ExternalJavacProcessHandler(Process process, @NotNull ThreadExecutor executorService) { + super(process, null, null); + myExecutorService = executorService; + addProcessListener(new ProcessAdapter() { + @Override + public void processTerminated(ProcessEvent event) { + myExitCode = event.getExitCode(); + } + }); + } + + @Override + protected Future executeOnPooledThread(Runnable task) { + return myExecutorService.executeOnPooledThread(task); + } + + public int getExitCode() { + return myExitCode; + } + } + @ChannelHandler.Sharable private class CompilationRequestsHandler extends SimpleChannelInboundHandler { @Override diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/JavacServerBootstrap.java b/jps/jps-builders/src/org/jetbrains/jps/javac/JavacServerBootstrap.java deleted file mode 100644 index ecf53395eb53..000000000000 --- a/jps/jps-builders/src/org/jetbrains/jps/javac/JavacServerBootstrap.java +++ /dev/null @@ -1,182 +0,0 @@ -/* - * Copyright 2000-2012 JetBrains s.r.o. - * - * Licensed 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. - */ -package org.jetbrains.jps.javac; - -import com.intellij.execution.process.BaseOSProcessHandler; -import com.intellij.execution.process.ProcessAdapter; -import com.intellij.execution.process.ProcessEvent; -import com.intellij.execution.process.ProcessOutputTypes; -import com.intellij.openapi.util.Key; -import com.intellij.openapi.util.SystemInfo; -import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.util.text.StringUtil; -import org.jetbrains.jps.builders.java.JavaCompilingTool; -import org.jetbrains.jps.cmdline.ClasspathBootstrap; -import org.jetbrains.jps.service.SharedThreadPool; - -import java.io.File; -import java.util.ArrayList; -import java.util.List; -import java.util.UUID; -import java.util.concurrent.Future; - -/** - * @author Eugene Zhuravlev - * Date: 1/24/12 - */ -public class JavacServerBootstrap { - - public static ExternalJavacProcessHandler launchExternalJavacProcess(UUID uuid, String sdkHomePath, - int heapSize, - int port, - File workingDir, - List vmOptions, - JavaCompilingTool compilingTool) throws Exception { - final List cmdLine = new ArrayList(); - appendParam(cmdLine, getVMExecutablePath(sdkHomePath)); - //appendParam(cmdLine, "-XX:MaxPermSize=150m"); - //appendParam(cmdLine, "-XX:ReservedCodeCacheSize=64m"); - appendParam(cmdLine, "-Djava.awt.headless=true"); - final int xms = heapSize / 2; - if (xms > 32) { - appendParam(cmdLine, "-Xms" + xms + "m"); - } - appendParam(cmdLine, "-Xmx" + heapSize + "m"); - - // debugging - //appendParam(cmdLine, "-XX:+HeapDumpOnOutOfMemoryError"); - //appendParam(cmdLine, "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5009"); - - // javac's VM should use the same default locale that IDEA uses in order for javac to print messages in 'correct' language - final String encoding = System.getProperty("file.encoding"); - if (encoding != null) { - appendParam(cmdLine, "-Dfile.encoding=" + encoding); - } - final String lang = System.getProperty("user.language"); - if (lang != null) { - //noinspection HardCodedStringLiteral - appendParam(cmdLine, "-Duser.language=" + lang); - } - final String country = System.getProperty("user.country"); - if (country != null) { - //noinspection HardCodedStringLiteral - appendParam(cmdLine, "-Duser.country=" + country); - } - //noinspection HardCodedStringLiteral - final String region = System.getProperty("user.region"); - if (region != null) { - //noinspection HardCodedStringLiteral - appendParam(cmdLine, "-Duser.region=" + region); - } - - appendParam(cmdLine, "-D" + ExternalJavacProcess.JPS_JAVA_COMPILING_TOOL_PROPERTY + "=" + compilingTool.getId()); - - // this will disable standard extensions to ensure javac is loaded from the right tools.jar - appendParam(cmdLine, "-Djava.ext.dirs="); - - appendParam(cmdLine, "-Dlog4j.defaultInitOverride=true"); - - for (String option : vmOptions) { - appendParam(cmdLine, option); - } - - appendParam(cmdLine, "-classpath"); - - final List cp = ClasspathBootstrap.getExternalJavacProcessClasspath(sdkHomePath, compilingTool); - final StringBuilder classpath = new StringBuilder(); - for (File file : cp) { - if (classpath.length() > 0) { - classpath.append(File.pathSeparator); - } - classpath.append(file.getPath()); - } - appendParam(cmdLine, classpath.toString()); - - appendParam(cmdLine, org.jetbrains.jps.javac.ExternalJavacProcess.class.getName()); - appendParam(cmdLine, uuid.toString()); - appendParam(cmdLine, "127.0.0.1"); - appendParam(cmdLine, Integer.toString(port)); - - workingDir.mkdirs(); - - appendParam(cmdLine, FileUtil.toSystemIndependentName(workingDir.getPath())); - - final ProcessBuilder builder = new ProcessBuilder(cmdLine); - builder.directory(workingDir); - - final Process process = builder.start(); - final ExternalJavacProcessHandler processHandler = new ExternalJavacProcessHandler(process); - processHandler.addProcessListener(new ProcessAdapter() { - @Override - public void processTerminated(ProcessEvent event) { - processHandler.setExitCode(event.getExitCode()); - } - - public void onTextAvailable(ProcessEvent event, Key outputType) { - final String text = event.getText(); - if (!StringUtil.isEmptyOrSpaces(text)) { - if (outputType == ProcessOutputTypes.STDOUT) { - System.out.print("JAVAC_PROCESS: " + text); - } - else if (outputType == ProcessOutputTypes.STDERR) { - System.err.print("JAVAC_PROCESS: " + text); - } - } - } - }); - processHandler.startNotify(); - return processHandler; - } - - - - private static void appendParam(List cmdLine, String param) { - if (SystemInfo.isWindows) { - if (param.contains("\"")) { - param = StringUtil.replace(param, "\"", "\\\""); - } - else if (param.length() == 0) { - param = "\"\""; - } - } - cmdLine.add(param); - } - - public static String getVMExecutablePath(String sdkHome) { - return sdkHome + "/bin/java"; - } - - public static class ExternalJavacProcessHandler extends BaseOSProcessHandler { - private volatile int myExitCode; - - ExternalJavacProcessHandler(Process process) { - super(process, null, null); - } - - @Override - protected Future executeOnPooledThread(Runnable task) { - return SharedThreadPool.getInstance().executeOnPooledThread(task); - } - - void setExitCode(int exitCode) { - myExitCode = exitCode; - } - - public int getExitCode() { - return myExitCode; - } - } -} diff --git a/jps/model-api/src/org/jetbrains/jps/service/SharedThreadPool.java b/jps/model-api/src/org/jetbrains/jps/service/SharedThreadPool.java index bb26dd49b031..429442cdc2cc 100644 --- a/jps/model-api/src/org/jetbrains/jps/service/SharedThreadPool.java +++ b/jps/model-api/src/org/jetbrains/jps/service/SharedThreadPool.java @@ -15,16 +15,12 @@ */ package org.jetbrains.jps.service; -import java.util.concurrent.Executor; -import java.util.concurrent.Future; - /** * @author nik */ -public abstract class SharedThreadPool implements Executor { +public abstract class SharedThreadPool implements ThreadExecutor { public static SharedThreadPool getInstance() { return JpsServiceManager.getInstance().getService(SharedThreadPool.class); } - public abstract Future executeOnPooledThread(Runnable action); } diff --git a/jps/model-api/src/org/jetbrains/jps/service/ThreadExecutor.java b/jps/model-api/src/org/jetbrains/jps/service/ThreadExecutor.java new file mode 100644 index 000000000000..fba17fa182a1 --- /dev/null +++ b/jps/model-api/src/org/jetbrains/jps/service/ThreadExecutor.java @@ -0,0 +1,23 @@ +/* + * Copyright 2000-2015 JetBrains s.r.o. + * + * Licensed 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. + */ +package org.jetbrains.jps.service; + +import java.util.concurrent.Executor; +import java.util.concurrent.Future; + +public interface ThreadExecutor extends Executor { + Future executeOnPooledThread(Runnable action); +}