MigrationWorker.java

package jetbrains.mps.build.migration;

/*Generated by MPS */

import jetbrains.mps.tool.builder.MpsWorker;
import jetbrains.mps.core.tool.environment.classloading.UrlClassLoader;
import jetbrains.mps.tool.common.Script;
import jetbrains.mps.tool.environment.Environment;
import jetbrains.mps.tool.environment.EnvironmentConfig;
import org.apache.log4j.Logger;
import java.util.Map;
import java.io.File;
import java.util.List;
import jetbrains.mps.project.Project;
import jetbrains.mps.make.MPSCompilationResult;
import jetbrains.mps.smodel.ModelAccess;
import jetbrains.mps.util.Computable;
import jetbrains.mps.make.ModuleMaker;
import jetbrains.mps.util.IterableUtil;
import jetbrains.mps.progress.EmptyProgressMonitor;
import jetbrains.mps.classloading.ClassLoaderManager;
import javax.swing.SwingUtilities;
import com.intellij.ide.plugins.PluginManager;
import com.intellij.openapi.extensions.PluginId;
import java.lang.reflect.Method;
import com.intellij.openapi.project.ProjectManager;
import com.intellij.ide.impl.ProjectUtil;
import java.lang.reflect.InvocationTargetException;
import jetbrains.mps.tool.environment.IdeaEnvironment;
import org.jetbrains.annotations.NotNull;
import java.util.Set;
import jetbrains.mps.internal.collections.runtime.SetSequence;
import java.util.LinkedHashSet;
import jetbrains.mps.util.PathManager;
import jetbrains.mps.internal.collections.runtime.Sequence;
import jetbrains.mps.internal.collections.runtime.ISelector;
import java.net.URL;
import java.net.MalformedURLException;
import jetbrains.mps.internal.collections.runtime.IWhereFilter;
import jetbrains.mps.library.LibraryInitializer;

public class MigrationWorker extends MpsWorker {
  private static final String MIGRATION_PLUGIN = "jetbrains.mps.ide.migration.assistant";
  private static final String TASK_EXEC_CLASS = "jetbrains.mps.ide.migration.AntTaskExecutionUtil";

  private final UrlClassLoader myClassLoader;

  public MigrationWorker(Script whatToDo, MpsWorker.AntLogger logger) {
    super(whatToDo, logger);
    myClassLoader = createClassloader();
  }

  @Override
  protected Environment createEnvironment() {
    EnvironmentConfig cfg = MpsWorker.createEnvConfig(myWhatToDo);
    cfg.addPlugin("migrationAssistant", MigrationWorker.MIGRATION_PLUGIN);

    Environment environment = new MigrationWorker.MyEnvironment(cfg);
    environment.init();

    Logger.getRootLogger().setLevel(myWhatToDo.getLogLevel());

    return environment;
  }

  @Override
  public void work() {
    setupEnvironment();

    Map<File, List<String>> mpsProjects = myWhatToDo.getMPSProjectFiles();
    for (File file : mpsProjects.keySet()) {
      final Project p = myEnvironment.openProject(file);
      info("Loaded project " + p);
      myEnvironment.flushAllEvents();

      final MPSCompilationResult mpsCompilationResult = ModelAccess.instance().runReadAction(new Computable<MPSCompilationResult>() {
        public MPSCompilationResult compute() {
          return new ModuleMaker().make(IterableUtil.asCollection(p.getProjectModulesWithGenerators()), new EmptyProgressMonitor(), myJavaCompilerOptions);
        }
      });
      if (mpsCompilationResult.isReloadingNeeded()) {
        ModelAccess.instance().runWriteAction(new Runnable() {
          public void run() {
            ClassLoaderManager.getInstance().reloadModules(mpsCompilationResult.getChangedModules());
          }
        });
      }
      myEnvironment.flushAllEvents();

      try {
        SwingUtilities.invokeAndWait(new Runnable() {
          public void run() {
            try {
              Class<?> euClass = PluginManager.getPlugin(PluginId.getId(MIGRATION_PLUGIN)).getPluginClassLoader().loadClass(TASK_EXEC_CLASS);
              Method method = euClass.getMethod("migrate", Project.class);
              Object result = method.invoke(null, p);
              if (!(((Boolean) result))) {
                info("Nothing to migrate");
              }
              com.intellij.openapi.project.Project[] projects = ProjectManager.getInstance().getOpenProjects();
              assert projects.length == 1 : "more than one project opened: " + projects.length;
              ProjectUtil.closeAndDispose(projects[0]);
            } catch (Exception e) {
              error(e.getMessage());
            }
          }
        });
      } catch (InterruptedException e) {
        error(e.getMessage());
      } catch (InvocationTargetException e) {
        error(e.getMessage());
      }
      p.dispose();
      myEnvironment.flushAllEvents();
    }

    dispose();
  }

  public static void main(String[] args) {
    MigrationWorker mpsWorker = new MigrationWorker(Script.fromDumpInFile(new File(args[0])), new MpsWorker.SystemOutLogger());
    mpsWorker.workFromMain();
  }

  protected void executeTask(Project project, MpsWorker.ObjectsToProcess go) {
  }

  protected void showStatistic() {
  }

  protected class MyEnvironment extends IdeaEnvironment {
    public MyEnvironment(@NotNull EnvironmentConfig config) {
      super(config);
    }

    @Override
    protected ClassLoader rootClassLoader() {
      return myClassLoader;
    }
  }

  private UrlClassLoader createClassloader() {
    Set<File> pluginsClasspath = SetSequence.fromSet(new LinkedHashSet<File>());
    File pluginDir = new File(PathManager.getPreInstalledPluginsPath());
    for (File pluginFolder : pluginDir.listFiles()) {
      if (pluginFolder.isFile()) {
        SetSequence.fromSet(pluginsClasspath).addElement(pluginFolder);
      } else {
        File lib = new File(pluginFolder + File.separator + "lib");
        if (lib.exists() && lib.isDirectory()) {
          SetSequence.fromSet(pluginsClasspath).addSequence(Sequence.fromIterable(Sequence.fromArray(lib.listFiles(PathManager.JAR_FILE_FILTER))));
        }
      }
    }

    return new UrlClassLoader(SetSequence.fromSet(pluginsClasspath).select(new ISelector<File, URL>() {
      public URL select(File it) {
        try {
          return it.toURI().toURL();
        } catch (MalformedURLException e) {
          return null;
        }
      }
    }).where(new IWhereFilter<URL>() {
      public boolean accept(URL it) {
        return it != null;
      }
    }).toGenericArray(URL.class), LibraryInitializer.class.getClassLoader());
  }

}