plugins/maven/src/main/java/org/jetbrains/idea/maven/server/MavenServerManager.java - platform/tools/idea - Git at Google

 /*
  * 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.idea.maven.server;

 import com.intellij.execution.DefaultExecutionResult;
 import com.intellij.execution.ExecutionException;
 import com.intellij.execution.ExecutionResult;
 import com.intellij.execution.Executor;
 import com.intellij.execution.configurations.*;
 import com.intellij.execution.process.OSProcessHandler;
 import com.intellij.execution.process.ProcessHandler;
 import com.intellij.execution.rmi.RemoteProcessSupport;
 import com.intellij.execution.runners.ProgramRunner;
 import com.intellij.openapi.actionSystem.AnAction;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.components.*;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.projectRoots.*;
 import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl;
 import com.intellij.openapi.roots.ProjectRootManager;
 import com.intellij.openapi.util.ShutDownTracker;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.Alarm;
 import com.intellij.util.PathUtil;
 import com.intellij.util.containers.ContainerUtil;
 import gnu.trove.THashMap;
 import org.apache.lucene.search.Query;
 import org.jdom.Element;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.idea.maven.execution.MavenRunnerSettings;
 import org.jetbrains.idea.maven.model.MavenExplicitProfiles;
 import org.jetbrains.idea.maven.model.MavenId;
 import org.jetbrains.idea.maven.model.MavenModel;
 import org.jetbrains.idea.maven.project.MavenConsole;
 import org.jetbrains.idea.maven.project.MavenGeneralSettings;
 import org.jetbrains.idea.maven.project.MavenProjectsManager;
 import org.jetbrains.idea.maven.utils.MavenLog;
 import org.jetbrains.idea.maven.utils.MavenProgressIndicator;
 import org.jetbrains.idea.maven.utils.MavenUtil;

 import java.io.File;
 import java.rmi.RemoteException;
 import java.rmi.server.UnicastRemoteObject;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;

 @State(
   name = "MavenVersion",
   storages = {@Storage(
     file = StoragePathMacros.APP_CONFIG + "/mavenVersion.xml")})
 public class MavenServerManager extends RemoteObjectWrapper<MavenServer> implements PersistentStateComponent<Element> {
   @NonNls private static final String MAIN_CLASS = "org.jetbrains.idea.maven.server.RemoteMavenServer";

   private static final String DEFAULT_VM_OPTIONS = "-Xmx512m";

   private final RemoteProcessSupport<Object, MavenServer, Object> mySupport;

   private final RemoteMavenServerLogger myLogger = new RemoteMavenServerLogger();
   private final RemoteMavenServerDownloadListener myDownloadListener = new RemoteMavenServerDownloadListener();
   private boolean myLoggerExported;
   private boolean myDownloadListenerExported;

   private final Alarm myShutdownAlarm = new Alarm(Alarm.ThreadToUse.SHARED_THREAD);

   private boolean useMaven2 = false;
   private String mavenEmbedderVMOptions = DEFAULT_VM_OPTIONS;
   private String embedderJdk = MavenRunnerSettings.USE_INTERNAL_JAVA;

   public static MavenServerManager getInstance() {
     return ServiceManager.getService(MavenServerManager.class);
   }

   public MavenServerManager() {
     super(null);

     mySupport = new RemoteProcessSupport<Object, MavenServer, Object>(MavenServer.class) {
       @Override
       protected void fireModificationCountChanged() {
       }

       @Override
       protected String getName(Object file) {
         return MavenServerManager.class.getSimpleName();
       }

       @Override
       protected RunProfileState getRunProfileState(Object target, Object configuration, Executor executor) throws ExecutionException {
         return createRunProfileState();
       }
     };

     ShutDownTracker.getInstance().registerShutdownTask(new Runnable() {
       public void run() {
         shutdown(false);
       }
     });
   }

   @NotNull
   protected synchronized MavenServer create() throws RemoteException {
     MavenServer result;
     try {
       result = mySupport.acquire(this, "");
     }
     catch (Exception e) {
       throw new RemoteException("Cannot start maven service", e);
     }

     myLoggerExported = UnicastRemoteObject.exportObject(myLogger, 0) != null;
     if (!myLoggerExported) throw new RemoteException("Cannot export logger object");

     myDownloadListenerExported = UnicastRemoteObject.exportObject(myDownloadListener, 0) != null;
     if (!myDownloadListenerExported) throw new RemoteException("Cannot export download listener object");

     result.set(myLogger, myDownloadListener);

     return result;
   }

   public synchronized void shutdown(boolean wait) {
     mySupport.stopAll(wait);
     cleanup();
   }

   protected synchronized void cleanup() {
     super.cleanup();

     if (myLoggerExported) {
       try {
         UnicastRemoteObject.unexportObject(myLogger, true);
       }
       catch (RemoteException e) {
         MavenLog.LOG.error(e);
       }
       myLoggerExported = false;
     }
     if (myDownloadListenerExported) {
       try {
         UnicastRemoteObject.unexportObject(myDownloadListener, true);
       }
       catch (RemoteException e) {
         MavenLog.LOG.error(e);
       }
       myDownloadListenerExported = false;
     }

     myShutdownAlarm.cancelAllRequests();
   }

   @NotNull
   private Sdk getJdk() {
     if (embedderJdk.equals(MavenRunnerSettings.USE_JAVA_HOME)) {
       final String javaHome = System.getenv("JAVA_HOME");
       if (!StringUtil.isEmptyOrSpaces(javaHome)) {
         Sdk jdk = JavaSdk.getInstance().createJdk("", javaHome);
         if (jdk != null) {
           return jdk;
         }
       }
     }

     for (Sdk projectJdk : ProjectJdkTable.getInstance().getAllJdks()) {
       if (projectJdk.getName().equals(embedderJdk)) {
         return projectJdk;
       }
     }

     // By default use internal jdk
     return JavaAwareProjectJdkTableImpl.getInstanceEx().getInternalJdk();
   }

   private RunProfileState createRunProfileState() {
     return new CommandLineState(null) {
       private SimpleJavaParameters createJavaParameters() throws ExecutionException {
         final SimpleJavaParameters params = new SimpleJavaParameters();

         params.setJdk(getJdk());

         params.setWorkingDirectory(PathManager.getBinPath());
         final List<String> classPath = new ArrayList<String>();
         classPath.addAll(PathManager.getUtilClassPath());
         ContainerUtil.addIfNotNull(PathUtil.getJarPathForClass(Query.class), classPath);
         params.getClassPath().add(PathManager.getResourceRoot(getClass(), "/messages/CommonBundle.properties"));
         params.getClassPath().addAll(classPath);
         params.getClassPath().addAllFiles(collectClassPathAndLibsFolder());

         params.setMainClass(MAIN_CLASS);

         Map<String, String> defs = new THashMap<String, String>();
         defs.putAll(MavenUtil.getPropertiesFromMavenOpts());

         // pass ssl-related options
         for (Map.Entry<Object, Object> each : System.getProperties().entrySet()) {
           Object key = each.getKey();
           Object value = each.getValue();
           if (key instanceof String && value instanceof String && ((String)key).startsWith("javax.net.ssl")) {
             defs.put((String)key, (String)value);
           }
         }

         if (SystemInfo.isMac) {
           String arch = System.getProperty("sun.arch.data.model");
           if (arch != null) {
             params.getVMParametersList().addParametersString("-d" + arch);
           }
         }

         defs.put("java.awt.headless", "true");
         for (Map.Entry<String, String> each : defs.entrySet()) {
           params.getVMParametersList().defineProperty(each.getKey(), each.getValue());
         }

         params.getVMParametersList().addProperty("idea.version=", MavenUtil.getIdeaVersionToPassToMavenProcess());

         boolean xmxSet = false;

         if (mavenEmbedderVMOptions != null) {
           ParametersList mavenOptsList = new ParametersList();
           mavenOptsList.addParametersString(mavenEmbedderVMOptions);

           for (String param : mavenOptsList.getParameters()) {
             if (param.startsWith("-Xmx")) {
               xmxSet = true;
             }

             params.getVMParametersList().add(param);
           }
         }

         String embedderXmx = System.getProperty("idea.maven.embedder.xmx");
         if (embedderXmx != null) {
           params.getVMParametersList().add("-Xmx" + embedderXmx);
         }
         else {
           if (!xmxSet) {
             params.getVMParametersList().add("-Xmx512m");
           }
         }

         String mavenEmbedderDebugPort = System.getProperty("idea.maven.embedder.debug.port");
         if (mavenEmbedderDebugPort != null) {
           params.getVMParametersList().addParametersString("-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=" + mavenEmbedderDebugPort);
         }

         String mavenEmbedderParameters = System.getProperty("idea.maven.embedder.parameters");
         if (mavenEmbedderParameters != null) {
           params.getProgramParametersList().addParametersString(mavenEmbedderParameters);
         }

         return params;
       }

       @Override
       public ExecutionResult execute(@NotNull Executor executor, @NotNull ProgramRunner runner) throws ExecutionException {
         ProcessHandler processHandler = startProcess();
         return new DefaultExecutionResult(null, processHandler, AnAction.EMPTY_ARRAY);
       }

       @NotNull
       protected OSProcessHandler startProcess() throws ExecutionException {
         SimpleJavaParameters params = createJavaParameters();
         Sdk sdk = params.getJdk();

         GeneralCommandLine commandLine =
           JdkUtil.setupJVMCommandLine(((JavaSdkType)sdk.getSdkType()).getVMExecutablePath(sdk), params, false);

         OSProcessHandler processHandler =
           new OSProcessHandler(commandLine.createProcess(), commandLine.getCommandLineString(), commandLine.getCharset());

         processHandler.setShouldDestroyProcessRecursively(false);

         return processHandler;
       }
     };
   }

   public static File getMavenLibDirectory() {
     File pluginFileOrDir = new File(PathUtil.getJarPathForClass(MavenServerManager.class));
     if (pluginFileOrDir.isDirectory()) {
       File luceneLib = new File(PathUtil.getJarPathForClass(Query.class));
       return new File(luceneLib.getParentFile().getParentFile().getParentFile(), "maven3-server-impl/lib/maven3/lib");
     }

     return new File(pluginFileOrDir.getParentFile(), "maven3");
   }

   public List<File> collectClassPathAndLibsFolder() {
     File pluginFileOrDir = new File(PathUtil.getJarPathForClass(MavenServerManager.class));

     List<File> classpath = new ArrayList<File>();

     String root = pluginFileOrDir.getParent();

     boolean useMaven2 = this.useMaven2;
     if (ApplicationManager.getApplication().isUnitTestMode()) {
       useMaven2 = true;
     }

     if (pluginFileOrDir.isDirectory()) {
       classpath.add(new File(root, "maven-server-api"));

       File luceneLib = new File(PathUtil.getJarPathForClass(Query.class));

       if (useMaven2) {
         classpath.add(new File(root, "maven2-server-impl"));
         addDir(classpath, new File(luceneLib.getParentFile().getParentFile().getParentFile(), "maven2-server-impl/lib"));
       }
       else {
         classpath.add(new File(root, "maven3-server-impl"));

         File maven3Module_Lib = new File(luceneLib.getParentFile().getParentFile().getParentFile(), "maven3-server-impl/lib");
         addDir(classpath, maven3Module_Lib);

         File maven3Home = new File(maven3Module_Lib, "maven3");

         addDir(classpath, new File(maven3Home, "lib"));

         classpath.add(new File(maven3Home, "boot/plexus-classworlds-2.4.jar"));
       }
     }
     else {
       classpath.add(new File(root, "maven-server-api.jar"));

       if (useMaven2) {
         classpath.add(new File(root, "maven2-server-impl.jar"));

         addDir(classpath, new File(root, "maven2"));
       }
       else {
         classpath.add(new File(root, "maven3-server-impl.jar"));
         addDir(classpath, new File(root, "maven3"));
       }
     }

     return classpath;
   }

   private static void addDir(List<File> classpath, File dir) {
     for (File jar : dir.listFiles()) {
       if (jar.isFile() && jar.getName().endsWith(".jar")) {
         classpath.add(jar);
       }
     }
   }

   public MavenEmbedderWrapper createEmbedder(final Project project, final boolean alwaysOnline) {
     return new MavenEmbedderWrapper(this) {
       @NotNull
       @Override
       protected MavenServerEmbedder create() throws RemoteException {
         MavenServerSettings settings = convertSettings(MavenProjectsManager.getInstance(project).getGeneralSettings());
         if (alwaysOnline && settings.isOffline()) {
           settings = settings.clone();
           settings.setOffline(false);
         }

         settings.setProjectJdk(MavenUtil.getSdkPath(ProjectRootManager.getInstance(project).getProjectSdk()));

         return MavenServerManager.this.getOrCreateWrappee().createEmbedder(settings);
       }
     };
   }

   public MavenIndexerWrapper createIndexer() {
     return new MavenIndexerWrapper(this) {
       @NotNull
       @Override
       protected MavenServerIndexer create() throws RemoteException {
         return MavenServerManager.this.getOrCreateWrappee().createIndexer();
       }
     };
   }

   public MavenModel interpolateAndAlignModel(final MavenModel model, final File basedir) {
     return perform(new Retriable<MavenModel>() {
       @Override
       public MavenModel execute() throws RemoteException {
         return getOrCreateWrappee().interpolateAndAlignModel(model, basedir);
       }
     });
   }

   public MavenModel assembleInheritance(final MavenModel model, final MavenModel parentModel) {
     return perform(new Retriable<MavenModel>() {
       @Override
       public MavenModel execute() throws RemoteException {
         return getOrCreateWrappee().assembleInheritance(model, parentModel);
       }
     });
   }

   public ProfileApplicationResult applyProfiles(final MavenModel model,
                                                 final File basedir,
                                                 final MavenExplicitProfiles explicitProfiles,
                                                 final Collection<String> alwaysOnProfiles) {
     return perform(new Retriable<ProfileApplicationResult>() {
       @Override
       public ProfileApplicationResult execute() throws RemoteException {
         return getOrCreateWrappee().applyProfiles(model, basedir, explicitProfiles, alwaysOnProfiles);
       }
     });
   }

   public void addDownloadListener(MavenServerDownloadListener listener) {
     myDownloadListener.myListeners.add(listener);
   }

   public void removeDownloadListener(MavenServerDownloadListener listener) {
     myDownloadListener.myListeners.remove(listener);
   }

   public static MavenServerSettings convertSettings(MavenGeneralSettings settings) {
     MavenServerSettings result = new MavenServerSettings();
     result.setLoggingLevel(settings.getOutputLevel().getLevel());
     result.setOffline(settings.isWorkOffline());
     result.setMavenHome(settings.getEffectiveMavenHome());
     result.setUserSettingsFile(settings.getEffectiveUserSettingsIoFile());
     result.setGlobalSettingsFile(settings.getEffectiveGlobalSettingsIoFile());
     result.setLocalRepository(settings.getEffectiveLocalRepository());
     result.setPluginUpdatePolicy(settings.getPluginUpdatePolicy().getServerPolicy());
     result.setSnapshotUpdatePolicy(settings.isAlwaysUpdateSnapshots() ? MavenServerSettings.UpdatePolicy.ALWAYS_UPDATE : MavenServerSettings.UpdatePolicy.DO_NOT_UPDATE);
     return result;
   }

   public static MavenServerConsole wrapAndExport(final MavenConsole console) {
     try {
       RemoteMavenServerConsole result = new RemoteMavenServerConsole(console);
       UnicastRemoteObject.exportObject(result, 0);
       return result;
     }
     catch (RemoteException e) {
       throw new RuntimeException(e);
     }
   }

   public static MavenServerProgressIndicator wrapAndExport(final MavenProgressIndicator process) {
     try {
       RemoteMavenServerProgressIndicator result = new RemoteMavenServerProgressIndicator(process);
       UnicastRemoteObject.exportObject(result, 0);
       return result;
     }
     catch (RemoteException e) {
       throw new RuntimeException(e);
     }
   }

   public static MavenServerIndicesProcessor wrapAndExport(final MavenIndicesProcessor processor) {
     try {
       RemoteMavenServerIndicesProcessor result = new RemoteMavenServerIndicesProcessor(processor);
       UnicastRemoteObject.exportObject(result, 0);
       return result;
     }
     catch (RemoteException e) {
       throw new RuntimeException(e);
     }
   }

   public boolean isUseMaven2() {
     return useMaven2;
   }

   public void setUseMaven2(boolean useMaven2) {
     if (this.useMaven2 != useMaven2) {
       this.useMaven2 = useMaven2;
       shutdown(false);
     }
   }

   @NotNull
   public String getMavenEmbedderVMOptions() {
     return mavenEmbedderVMOptions;
   }

   public void setMavenEmbedderVMOptions(@NotNull String mavenEmbedderVMOptions) {
     if (!mavenEmbedderVMOptions.trim().equals(this.mavenEmbedderVMOptions.trim())) {
       this.mavenEmbedderVMOptions = mavenEmbedderVMOptions;
       shutdown(false);
     }
   }

   @NotNull
   public String getEmbedderJdk() {
     return embedderJdk;
   }

   public void setEmbedderJdk(@NotNull String embedderJdk) {
     if (!this.embedderJdk.equals(embedderJdk)) {
       this.embedderJdk = embedderJdk;
       shutdown(false);
     }
   }

   @Nullable
   @Override
   public Element getState() {
     final Element element = new Element("maven-version");
     element.setAttribute("version", useMaven2 ? "2.x" : "3.x");
     element.setAttribute("vmOptions", mavenEmbedderVMOptions);
     element.setAttribute("embedderJdk", embedderJdk);
     return element;
   }

   @Override
   public void loadState(Element state) {
     String version = state.getAttributeValue("version");
     useMaven2 = "2.x".equals(version);

     String vmOptions = state.getAttributeValue("vmOptions");
     mavenEmbedderVMOptions = vmOptions == null ? DEFAULT_VM_OPTIONS : vmOptions;

     String embedderJdk = state.getAttributeValue("embedderJdk");
     this.embedderJdk = embedderJdk == null ? MavenRunnerSettings.USE_INTERNAL_JAVA : embedderJdk;
   }

   private static class RemoteMavenServerLogger extends MavenRemoteObject implements MavenServerLogger {
     public void info(Throwable e) {
       MavenLog.LOG.info(e);
     }

     public void warn(Throwable e) {
       MavenLog.LOG.warn(e);
     }

     public void error(Throwable e) {
       MavenLog.LOG.error(e);
     }

     public void print(String s) {
       //noinspection UseOfSystemOutOrSystemErr
       System.out.println(s);
     }
   }

   private static class RemoteMavenServerDownloadListener extends MavenRemoteObject implements MavenServerDownloadListener {
     private final List<MavenServerDownloadListener> myListeners = ContainerUtil.createLockFreeCopyOnWriteList();

     public void artifactDownloaded(File file, String relativePath) throws RemoteException {
       for (MavenServerDownloadListener each : myListeners) {
         each.artifactDownloaded(file, relativePath);
       }
     }
   }

   private static class RemoteMavenServerProgressIndicator extends MavenRemoteObject implements MavenServerProgressIndicator {
     private final MavenProgressIndicator myProcess;

     public RemoteMavenServerProgressIndicator(MavenProgressIndicator process) {
       myProcess = process;
     }

     public void setText(String text) {
       myProcess.setText(text);
     }

     public void setText2(String text) {
       myProcess.setText2(text);
     }

     public boolean isCanceled() {
       return myProcess.isCanceled();
     }

     public void setIndeterminate(boolean value) {
       myProcess.getIndicator().setIndeterminate(value);
     }

     public void setFraction(double fraction) {
       myProcess.setFraction(fraction);
     }
   }

   private static class RemoteMavenServerConsole extends MavenRemoteObject implements MavenServerConsole {
     private final MavenConsole myConsole;

     public RemoteMavenServerConsole(MavenConsole console) {
       myConsole = console;
     }

     public void printMessage(int level, String message, Throwable throwable) {
       myConsole.printMessage(level, message, throwable);
     }
   }

   private static class RemoteMavenServerIndicesProcessor extends MavenRemoteObject implements MavenServerIndicesProcessor {
     private final MavenIndicesProcessor myProcessor;

     private RemoteMavenServerIndicesProcessor(MavenIndicesProcessor processor) {
       myProcessor = processor;
     }

     @Override
     public void processArtifacts(Collection<MavenId> artifacts) {
       myProcessor.processArtifacts(artifacts);
     }
   }
 }
	/*
	* 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.idea.maven.server;

	import com.intellij.execution.DefaultExecutionResult;
	import com.intellij.execution.ExecutionException;
	import com.intellij.execution.ExecutionResult;
	import com.intellij.execution.Executor;
	import com.intellij.execution.configurations.*;
	import com.intellij.execution.process.OSProcessHandler;
	import com.intellij.execution.process.ProcessHandler;
	import com.intellij.execution.rmi.RemoteProcessSupport;
	import com.intellij.execution.runners.ProgramRunner;
	import com.intellij.openapi.actionSystem.AnAction;
	import com.intellij.openapi.application.ApplicationManager;
	import com.intellij.openapi.application.PathManager;
	import com.intellij.openapi.components.*;
	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.projectRoots.*;
	import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl;
	import com.intellij.openapi.roots.ProjectRootManager;
	import com.intellij.openapi.util.ShutDownTracker;
	import com.intellij.openapi.util.SystemInfo;
	import com.intellij.openapi.util.text.StringUtil;
	import com.intellij.util.Alarm;
	import com.intellij.util.PathUtil;
	import com.intellij.util.containers.ContainerUtil;
	import gnu.trove.THashMap;
	import org.apache.lucene.search.Query;
	import org.jdom.Element;
	import org.jetbrains.annotations.NonNls;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;
	import org.jetbrains.idea.maven.execution.MavenRunnerSettings;
	import org.jetbrains.idea.maven.model.MavenExplicitProfiles;
	import org.jetbrains.idea.maven.model.MavenId;
	import org.jetbrains.idea.maven.model.MavenModel;
	import org.jetbrains.idea.maven.project.MavenConsole;
	import org.jetbrains.idea.maven.project.MavenGeneralSettings;
	import org.jetbrains.idea.maven.project.MavenProjectsManager;
	import org.jetbrains.idea.maven.utils.MavenLog;
	import org.jetbrains.idea.maven.utils.MavenProgressIndicator;
	import org.jetbrains.idea.maven.utils.MavenUtil;

	import java.io.File;
	import java.rmi.RemoteException;
	import java.rmi.server.UnicastRemoteObject;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;
	import java.util.Map;

	@State(
	name = "MavenVersion",
	storages = {@Storage(
	file = StoragePathMacros.APP_CONFIG + "/mavenVersion.xml")})
	public class MavenServerManager extends RemoteObjectWrapper<MavenServer> implements PersistentStateComponent<Element> {
	@NonNls private static final String MAIN_CLASS = "org.jetbrains.idea.maven.server.RemoteMavenServer";

	private static final String DEFAULT_VM_OPTIONS = "-Xmx512m";

	private final RemoteProcessSupport<Object, MavenServer, Object> mySupport;

	private final RemoteMavenServerLogger myLogger = new RemoteMavenServerLogger();
	private final RemoteMavenServerDownloadListener myDownloadListener = new RemoteMavenServerDownloadListener();
	private boolean myLoggerExported;
	private boolean myDownloadListenerExported;

	private final Alarm myShutdownAlarm = new Alarm(Alarm.ThreadToUse.SHARED_THREAD);

	private boolean useMaven2 = false;
	private String mavenEmbedderVMOptions = DEFAULT_VM_OPTIONS;
	private String embedderJdk = MavenRunnerSettings.USE_INTERNAL_JAVA;

	public static MavenServerManager getInstance() {
	return ServiceManager.getService(MavenServerManager.class);
	}

	public MavenServerManager() {
	super(null);

	mySupport = new RemoteProcessSupport<Object, MavenServer, Object>(MavenServer.class) {
	@Override
	protected void fireModificationCountChanged() {
	}

	@Override
	protected String getName(Object file) {
	return MavenServerManager.class.getSimpleName();
	}

	@Override
	protected RunProfileState getRunProfileState(Object target, Object configuration, Executor executor) throws ExecutionException {
	return createRunProfileState();
	}
	};

	ShutDownTracker.getInstance().registerShutdownTask(new Runnable() {
	public void run() {
	shutdown(false);
	}
	});
	}

	@NotNull
	protected synchronized MavenServer create() throws RemoteException {
	MavenServer result;
	try {
	result = mySupport.acquire(this, "");
	}
	catch (Exception e) {
	throw new RemoteException("Cannot start maven service", e);
	}

	myLoggerExported = UnicastRemoteObject.exportObject(myLogger, 0) != null;
	if (!myLoggerExported) throw new RemoteException("Cannot export logger object");

	myDownloadListenerExported = UnicastRemoteObject.exportObject(myDownloadListener, 0) != null;
	if (!myDownloadListenerExported) throw new RemoteException("Cannot export download listener object");

	result.set(myLogger, myDownloadListener);

	return result;
	}

	public synchronized void shutdown(boolean wait) {
	mySupport.stopAll(wait);
	cleanup();
	}

	protected synchronized void cleanup() {
	super.cleanup();

	if (myLoggerExported) {
	try {
	UnicastRemoteObject.unexportObject(myLogger, true);
	}
	catch (RemoteException e) {
	MavenLog.LOG.error(e);
	}
	myLoggerExported = false;
	}
	if (myDownloadListenerExported) {
	try {
	UnicastRemoteObject.unexportObject(myDownloadListener, true);
	}
	catch (RemoteException e) {
	MavenLog.LOG.error(e);
	}
	myDownloadListenerExported = false;
	}

	myShutdownAlarm.cancelAllRequests();
	}

	@NotNull
	private Sdk getJdk() {
	if (embedderJdk.equals(MavenRunnerSettings.USE_JAVA_HOME)) {
	final String javaHome = System.getenv("JAVA_HOME");
	if (!StringUtil.isEmptyOrSpaces(javaHome)) {
	Sdk jdk = JavaSdk.getInstance().createJdk("", javaHome);
	if (jdk != null) {
	return jdk;
	}
	}
	}

	for (Sdk projectJdk : ProjectJdkTable.getInstance().getAllJdks()) {
	if (projectJdk.getName().equals(embedderJdk)) {
	return projectJdk;
	}
	}

	// By default use internal jdk
	return JavaAwareProjectJdkTableImpl.getInstanceEx().getInternalJdk();
	}

	private RunProfileState createRunProfileState() {
	return new CommandLineState(null) {
	private SimpleJavaParameters createJavaParameters() throws ExecutionException {
	final SimpleJavaParameters params = new SimpleJavaParameters();

	params.setJdk(getJdk());

	params.setWorkingDirectory(PathManager.getBinPath());
	final List<String> classPath = new ArrayList<String>();
	classPath.addAll(PathManager.getUtilClassPath());
	ContainerUtil.addIfNotNull(PathUtil.getJarPathForClass(Query.class), classPath);
	params.getClassPath().add(PathManager.getResourceRoot(getClass(), "/messages/CommonBundle.properties"));
	params.getClassPath().addAll(classPath);
	params.getClassPath().addAllFiles(collectClassPathAndLibsFolder());

	params.setMainClass(MAIN_CLASS);

	Map<String, String> defs = new THashMap<String, String>();
	defs.putAll(MavenUtil.getPropertiesFromMavenOpts());

	// pass ssl-related options
	for (Map.Entry<Object, Object> each : System.getProperties().entrySet()) {
	Object key = each.getKey();
	Object value = each.getValue();
	if (key instanceof String && value instanceof String && ((String)key).startsWith("javax.net.ssl")) {
	defs.put((String)key, (String)value);
	}
	}

	if (SystemInfo.isMac) {
	String arch = System.getProperty("sun.arch.data.model");
	if (arch != null) {
	params.getVMParametersList().addParametersString("-d" + arch);
	}
	}

	defs.put("java.awt.headless", "true");
	for (Map.Entry<String, String> each : defs.entrySet()) {
	params.getVMParametersList().defineProperty(each.getKey(), each.getValue());
	}

	params.getVMParametersList().addProperty("idea.version=", MavenUtil.getIdeaVersionToPassToMavenProcess());

	boolean xmxSet = false;

	if (mavenEmbedderVMOptions != null) {
	ParametersList mavenOptsList = new ParametersList();
	mavenOptsList.addParametersString(mavenEmbedderVMOptions);

	for (String param : mavenOptsList.getParameters()) {
	if (param.startsWith("-Xmx")) {
	xmxSet = true;
	}

	params.getVMParametersList().add(param);
	}
	}

	String embedderXmx = System.getProperty("idea.maven.embedder.xmx");
	if (embedderXmx != null) {
	params.getVMParametersList().add("-Xmx" + embedderXmx);
	}
	else {
	if (!xmxSet) {
	params.getVMParametersList().add("-Xmx512m");
	}
	}

	String mavenEmbedderDebugPort = System.getProperty("idea.maven.embedder.debug.port");
	if (mavenEmbedderDebugPort != null) {
	params.getVMParametersList().addParametersString("-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=" + mavenEmbedderDebugPort);
	}

	String mavenEmbedderParameters = System.getProperty("idea.maven.embedder.parameters");
	if (mavenEmbedderParameters != null) {
	params.getProgramParametersList().addParametersString(mavenEmbedderParameters);
	}

	return params;
	}

	@Override
	public ExecutionResult execute(@NotNull Executor executor, @NotNull ProgramRunner runner) throws ExecutionException {
	ProcessHandler processHandler = startProcess();
	return new DefaultExecutionResult(null, processHandler, AnAction.EMPTY_ARRAY);
	}

	@NotNull
	protected OSProcessHandler startProcess() throws ExecutionException {
	SimpleJavaParameters params = createJavaParameters();
	Sdk sdk = params.getJdk();

	GeneralCommandLine commandLine =
	JdkUtil.setupJVMCommandLine(((JavaSdkType)sdk.getSdkType()).getVMExecutablePath(sdk), params, false);

	OSProcessHandler processHandler =
	new OSProcessHandler(commandLine.createProcess(), commandLine.getCommandLineString(), commandLine.getCharset());

	processHandler.setShouldDestroyProcessRecursively(false);

	return processHandler;
	}
	};
	}

	public static File getMavenLibDirectory() {
	File pluginFileOrDir = new File(PathUtil.getJarPathForClass(MavenServerManager.class));
	if (pluginFileOrDir.isDirectory()) {
	File luceneLib = new File(PathUtil.getJarPathForClass(Query.class));
	return new File(luceneLib.getParentFile().getParentFile().getParentFile(), "maven3-server-impl/lib/maven3/lib");
	}

	return new File(pluginFileOrDir.getParentFile(), "maven3");
	}

	public List<File> collectClassPathAndLibsFolder() {
	File pluginFileOrDir = new File(PathUtil.getJarPathForClass(MavenServerManager.class));

	List<File> classpath = new ArrayList<File>();

	String root = pluginFileOrDir.getParent();

	boolean useMaven2 = this.useMaven2;
	if (ApplicationManager.getApplication().isUnitTestMode()) {
	useMaven2 = true;
	}

	if (pluginFileOrDir.isDirectory()) {
	classpath.add(new File(root, "maven-server-api"));

	File luceneLib = new File(PathUtil.getJarPathForClass(Query.class));

	if (useMaven2) {
	classpath.add(new File(root, "maven2-server-impl"));
	addDir(classpath, new File(luceneLib.getParentFile().getParentFile().getParentFile(), "maven2-server-impl/lib"));
	}
	else {
	classpath.add(new File(root, "maven3-server-impl"));

	File maven3Module_Lib = new File(luceneLib.getParentFile().getParentFile().getParentFile(), "maven3-server-impl/lib");
	addDir(classpath, maven3Module_Lib);

	File maven3Home = new File(maven3Module_Lib, "maven3");

	addDir(classpath, new File(maven3Home, "lib"));

	classpath.add(new File(maven3Home, "boot/plexus-classworlds-2.4.jar"));
	}
	}
	else {
	classpath.add(new File(root, "maven-server-api.jar"));

	if (useMaven2) {
	classpath.add(new File(root, "maven2-server-impl.jar"));

	addDir(classpath, new File(root, "maven2"));
	}
	else {
	classpath.add(new File(root, "maven3-server-impl.jar"));
	addDir(classpath, new File(root, "maven3"));
	}
	}

	return classpath;
	}

	private static void addDir(List<File> classpath, File dir) {
	for (File jar : dir.listFiles()) {
	if (jar.isFile() && jar.getName().endsWith(".jar")) {
	classpath.add(jar);
	}
	}
	}

	public MavenEmbedderWrapper createEmbedder(final Project project, final boolean alwaysOnline) {
	return new MavenEmbedderWrapper(this) {
	@NotNull
	@Override
	protected MavenServerEmbedder create() throws RemoteException {
	MavenServerSettings settings = convertSettings(MavenProjectsManager.getInstance(project).getGeneralSettings());
	if (alwaysOnline && settings.isOffline()) {
	settings = settings.clone();
	settings.setOffline(false);
	}

	settings.setProjectJdk(MavenUtil.getSdkPath(ProjectRootManager.getInstance(project).getProjectSdk()));

	return MavenServerManager.this.getOrCreateWrappee().createEmbedder(settings);
	}
	};
	}

	public MavenIndexerWrapper createIndexer() {
	return new MavenIndexerWrapper(this) {
	@NotNull
	@Override
	protected MavenServerIndexer create() throws RemoteException {
	return MavenServerManager.this.getOrCreateWrappee().createIndexer();
	}
	};
	}

	public MavenModel interpolateAndAlignModel(final MavenModel model, final File basedir) {
	return perform(new Retriable<MavenModel>() {
	@Override
	public MavenModel execute() throws RemoteException {
	return getOrCreateWrappee().interpolateAndAlignModel(model, basedir);
	}
	});
	}

	public MavenModel assembleInheritance(final MavenModel model, final MavenModel parentModel) {
	return perform(new Retriable<MavenModel>() {
	@Override
	public MavenModel execute() throws RemoteException {
	return getOrCreateWrappee().assembleInheritance(model, parentModel);
	}
	});
	}

	public ProfileApplicationResult applyProfiles(final MavenModel model,
	final File basedir,
	final MavenExplicitProfiles explicitProfiles,
	final Collection<String> alwaysOnProfiles) {
	return perform(new Retriable<ProfileApplicationResult>() {
	@Override
	public ProfileApplicationResult execute() throws RemoteException {
	return getOrCreateWrappee().applyProfiles(model, basedir, explicitProfiles, alwaysOnProfiles);
	}
	});
	}

	public void addDownloadListener(MavenServerDownloadListener listener) {
	myDownloadListener.myListeners.add(listener);
	}

	public void removeDownloadListener(MavenServerDownloadListener listener) {
	myDownloadListener.myListeners.remove(listener);
	}

	public static MavenServerSettings convertSettings(MavenGeneralSettings settings) {
	MavenServerSettings result = new MavenServerSettings();
	result.setLoggingLevel(settings.getOutputLevel().getLevel());
	result.setOffline(settings.isWorkOffline());
	result.setMavenHome(settings.getEffectiveMavenHome());
	result.setUserSettingsFile(settings.getEffectiveUserSettingsIoFile());
	result.setGlobalSettingsFile(settings.getEffectiveGlobalSettingsIoFile());
	result.setLocalRepository(settings.getEffectiveLocalRepository());
	result.setPluginUpdatePolicy(settings.getPluginUpdatePolicy().getServerPolicy());
	result.setSnapshotUpdatePolicy(settings.isAlwaysUpdateSnapshots() ? MavenServerSettings.UpdatePolicy.ALWAYS_UPDATE : MavenServerSettings.UpdatePolicy.DO_NOT_UPDATE);
	return result;
	}

	public static MavenServerConsole wrapAndExport(final MavenConsole console) {
	try {
	RemoteMavenServerConsole result = new RemoteMavenServerConsole(console);
	UnicastRemoteObject.exportObject(result, 0);
	return result;
	}
	catch (RemoteException e) {
	throw new RuntimeException(e);
	}
	}

	public static MavenServerProgressIndicator wrapAndExport(final MavenProgressIndicator process) {
	try {
	RemoteMavenServerProgressIndicator result = new RemoteMavenServerProgressIndicator(process);
	UnicastRemoteObject.exportObject(result, 0);
	return result;
	}
	catch (RemoteException e) {
	throw new RuntimeException(e);
	}
	}

	public static MavenServerIndicesProcessor wrapAndExport(final MavenIndicesProcessor processor) {
	try {
	RemoteMavenServerIndicesProcessor result = new RemoteMavenServerIndicesProcessor(processor);
	UnicastRemoteObject.exportObject(result, 0);
	return result;
	}
	catch (RemoteException e) {
	throw new RuntimeException(e);
	}
	}

	public boolean isUseMaven2() {
	return useMaven2;
	}

	public void setUseMaven2(boolean useMaven2) {
	if (this.useMaven2 != useMaven2) {
	this.useMaven2 = useMaven2;
	shutdown(false);
	}
	}

	@NotNull
	public String getMavenEmbedderVMOptions() {
	return mavenEmbedderVMOptions;
	}

	public void setMavenEmbedderVMOptions(@NotNull String mavenEmbedderVMOptions) {
	if (!mavenEmbedderVMOptions.trim().equals(this.mavenEmbedderVMOptions.trim())) {
	this.mavenEmbedderVMOptions = mavenEmbedderVMOptions;
	shutdown(false);
	}
	}

	@NotNull
	public String getEmbedderJdk() {
	return embedderJdk;
	}

	public void setEmbedderJdk(@NotNull String embedderJdk) {
	if (!this.embedderJdk.equals(embedderJdk)) {
	this.embedderJdk = embedderJdk;
	shutdown(false);
	}
	}

	@Nullable
	@Override
	public Element getState() {
	final Element element = new Element("maven-version");
	element.setAttribute("version", useMaven2 ? "2.x" : "3.x");
	element.setAttribute("vmOptions", mavenEmbedderVMOptions);
	element.setAttribute("embedderJdk", embedderJdk);
	return element;
	}

	@Override
	public void loadState(Element state) {
	String version = state.getAttributeValue("version");
	useMaven2 = "2.x".equals(version);

	String vmOptions = state.getAttributeValue("vmOptions");
	mavenEmbedderVMOptions = vmOptions == null ? DEFAULT_VM_OPTIONS : vmOptions;

	String embedderJdk = state.getAttributeValue("embedderJdk");
	this.embedderJdk = embedderJdk == null ? MavenRunnerSettings.USE_INTERNAL_JAVA : embedderJdk;
	}

	private static class RemoteMavenServerLogger extends MavenRemoteObject implements MavenServerLogger {
	public void info(Throwable e) {
	MavenLog.LOG.info(e);
	}

	public void warn(Throwable e) {
	MavenLog.LOG.warn(e);
	}

	public void error(Throwable e) {
	MavenLog.LOG.error(e);
	}

	public void print(String s) {
	//noinspection UseOfSystemOutOrSystemErr
	System.out.println(s);
	}
	}

	private static class RemoteMavenServerDownloadListener extends MavenRemoteObject implements MavenServerDownloadListener {
	private final List<MavenServerDownloadListener> myListeners = ContainerUtil.createLockFreeCopyOnWriteList();

	public void artifactDownloaded(File file, String relativePath) throws RemoteException {
	for (MavenServerDownloadListener each : myListeners) {
	each.artifactDownloaded(file, relativePath);
	}
	}
	}

	private static class RemoteMavenServerProgressIndicator extends MavenRemoteObject implements MavenServerProgressIndicator {
	private final MavenProgressIndicator myProcess;

	public RemoteMavenServerProgressIndicator(MavenProgressIndicator process) {
	myProcess = process;
	}

	public void setText(String text) {
	myProcess.setText(text);
	}

	public void setText2(String text) {
	myProcess.setText2(text);
	}

	public boolean isCanceled() {
	return myProcess.isCanceled();
	}

	public void setIndeterminate(boolean value) {
	myProcess.getIndicator().setIndeterminate(value);
	}

	public void setFraction(double fraction) {
	myProcess.setFraction(fraction);
	}
	}

	private static class RemoteMavenServerConsole extends MavenRemoteObject implements MavenServerConsole {
	private final MavenConsole myConsole;

	public RemoteMavenServerConsole(MavenConsole console) {
	myConsole = console;
	}

	public void printMessage(int level, String message, Throwable throwable) {
	myConsole.printMessage(level, message, throwable);
	}
	}

	private static class RemoteMavenServerIndicesProcessor extends MavenRemoteObject implements MavenServerIndicesProcessor {
	private final MavenIndicesProcessor myProcessor;

	private RemoteMavenServerIndicesProcessor(MavenIndicesProcessor processor) {
	myProcessor = processor;
	}

	@Override
	public void processArtifacts(Collection<MavenId> artifacts) {
	myProcessor.processArtifacts(artifacts);
	}
	}
	}