plugins/maven/src/main/java/org/jetbrains/idea/maven/project/MavenProjectsManager.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.jetbrains.idea.maven.project;
  17
  18 import com.intellij.ide.startup.StartupManagerEx;
  19 import com.intellij.openapi.application.ApplicationManager;
  20 import com.intellij.openapi.application.Result;
  21 import com.intellij.openapi.command.WriteCommandAction;
  22 import com.intellij.openapi.components.PersistentStateComponent;
  23 import com.intellij.openapi.components.SettingsSavingComponent;
  24 import com.intellij.openapi.components.State;
  25 import com.intellij.openapi.components.Storage;
  26 import com.intellij.openapi.fileEditor.FileDocumentManager;
  27 import com.intellij.openapi.module.Module;
  28 import com.intellij.openapi.project.DumbAwareRunnable;
  29 import com.intellij.openapi.project.Project;
  30 import com.intellij.openapi.roots.ModuleRootManager;
  31 import com.intellij.openapi.roots.ProjectRootManager;
  32 import com.intellij.openapi.util.Computable;
  33 import com.intellij.openapi.util.Disposer;
  34 import com.intellij.openapi.util.Pair;
  35 import com.intellij.openapi.util.Ref;
  36 import com.intellij.openapi.util.io.FileUtil;
  37 import com.intellij.openapi.vfs.VirtualFile;
  38 import com.intellij.openapi.vfs.VirtualFileManager;
  39 import com.intellij.psi.PsiFile;
  40 import com.intellij.psi.PsiManager;
  41 import com.intellij.util.EventDispatcher;
  42 import com.intellij.util.containers.ContainerUtil;
  43 import com.intellij.util.ui.update.Update;
  44 import gnu.trove.THashMap;
  45 import gnu.trove.THashSet;
  46 import org.jetbrains.annotations.Nullable;
  47 import org.jetbrains.annotations.TestOnly;
  48 import org.jetbrains.idea.maven.dom.MavenDomUtil;
  49 import org.jetbrains.idea.maven.dom.model.MavenDomDependency;
  50 import org.jetbrains.idea.maven.dom.model.MavenDomProjectModel;
  51 import org.jetbrains.idea.maven.execution.SoutMavenConsole;
  52 import org.jetbrains.idea.maven.importing.MavenDefaultModifiableModelsProvider;
  53 import org.jetbrains.idea.maven.importing.MavenFoldersImporter;
  54 import org.jetbrains.idea.maven.importing.MavenModifiableModelsProvider;
  55 import org.jetbrains.idea.maven.importing.MavenProjectImporter;
  56 import org.jetbrains.idea.maven.utils.*;
  57
  58 import java.io.File;
  59 import java.io.IOException;
  60 import java.util.*;
  61 import java.util.concurrent.atomic.AtomicBoolean;
  62
  63 @State(name = "MavenProjectsManager", storages = {@Storage(id = "default", file = "$PROJECT_FILE$")})
  64 public class MavenProjectsManager extends SimpleProjectComponent implements PersistentStateComponent<MavenProjectsManagerState>,
  65                                                                             SettingsSavingComponent {
  66   private static final int IMPORT_DELAY = 1000;
  67
  68   static final Object SCHEDULE_IMPORT_MESSAGE = "SCHEDULE_IMPORT_MESSAGE";
  69   static final Object FORCE_IMPORT_MESSAGE = "FORCE_IMPORT_MESSAGE";
  70
  71   private final AtomicBoolean isInitialized = new AtomicBoolean();
  72
  73   private MavenProjectsManagerState myState = new MavenProjectsManagerState();
  74
  75   private MavenEmbeddersManager myEmbeddersManager;
  76
  77   private MavenProjectsTree myProjectsTree;
  78   private MavenProjectsManagerWatcher myWatcher;
  79
  80   private MavenProjectsProcessor myReadingProcessor;
  81   private MavenProjectsProcessor myResolvingProcessor;
  82   private MavenProjectsProcessor myPluginsResolvingProcessor;
  83   private MavenProjectsProcessor myFoldersResolvingProcessor;
  84   private MavenProjectsProcessor myArtifactsDownloadingProcessor;
  85   private MavenProjectsProcessor myPostProcessor;
  86
  87   private MavenMergingUpdateQueue myImportingQueue;
  88   private final Object myImportingDataLock = new Object();
  89   private final Map<MavenProject, MavenProjectChanges> myProjectsToImport = new THashMap<MavenProject, MavenProjectChanges>();
  90   private boolean myImportModuleGroupsRequired = false;
  91
  92   private MavenMergingUpdateQueue mySchedulesQueue;
  93
  94   private final EventDispatcher<MavenProjectsTree.Listener> myProjectsTreeDispatcher
  95     = EventDispatcher.create(MavenProjectsTree.Listener.class);
  96   private final List<Listener> myManagerListeners = ContainerUtil.createEmptyCOWList();
  97
  98   public static MavenProjectsManager getInstance(Project p) {
  99     return p.getComponent(MavenProjectsManager.class);
 100   }
 101
 102   public MavenProjectsManager(Project project) {
 103     super(project);
 104   }
 105
 106   public MavenProjectsManagerState getState() {
 107     if (isInitialized()) {
 108       applyTreeToState();
 109     }
 110     return myState;
 111   }
 112
 113   public void loadState(MavenProjectsManagerState state) {
 114     myState = state;
 115     if (isInitialized()) {
 116       applyStateToTree();
 117       scheduleUpdateAllProjects(false);
 118     }
 119   }
 120
 121   public MavenGeneralSettings getGeneralSettings() {
 122     return getWorkspaceSettings().generalSettings;
 123   }
 124
 125   public MavenImportingSettings getImportingSettings() {
 126     return getWorkspaceSettings().importingSettings;
 127   }
 128
 129   private MavenWorkspaceSettings getWorkspaceSettings() {
 130     return MavenWorkspaceSettingsComponent.getInstance(myProject).getState();
 131   }
 132
 133   public File getLocalRepository() {
 134     return getGeneralSettings().getEffectiveLocalRepository();
 135   }
 136
 137   @Override
 138   public void initComponent() {
 139     if (!isNormalProject()) return;
 140
 141     StartupManagerEx.getInstanceEx(myProject).registerStartupActivity(new Runnable() {
 142       public void run() {
 143         boolean wasMavenized = !myState.originalFiles.isEmpty();
 144         if (!wasMavenized) return;
 145         initMavenized();
 146       }
 147     });
 148   }
 149
 150   private void initMavenized() {
 151     doInit(false);
 152   }
 153
 154   private void initNew(List<VirtualFile> files, List<String> explicitProfiles) {
 155     myState.originalFiles = MavenUtil.collectPaths(files);
 156     myState.activeProfiles = explicitProfiles;
 157     doInit(true);
 158   }
 159
 160   @TestOnly
 161   public void initForTests() {
 162     doInit(false);
 163   }
 164
 165   private void doInit(final boolean isNew) {
 166     if (isInitialized.getAndSet(true)) return;
 167
 168     initProjectsTree(!isNew);
 169
 170     initWorkers();
 171     listenForSettingsChanges();
 172     listenForProjectsTreeChanges();
 173
 174     MavenUtil.runWhenInitialized(myProject, new DumbAwareRunnable() {
 175       public void run() {
 176         if (!isUnitTestMode()) {
 177           fireActivated();
 178           listenForExternalChanges();
 179         }
 180         scheduleUpdateAllProjects(isNew);
 181       }
 182     });
 183   }
 184
 185   private void initProjectsTree(boolean tryToLoadExisting) {
 186     if (tryToLoadExisting) {
 187       File file = getProjectsTreeFile();
 188       try {
 189         if (file.exists()) {
 190           myProjectsTree = MavenProjectsTree.read(file);
 191         }
 192       }
 193       catch (IOException e) {
 194         MavenLog.LOG.info(e);
 195       }
 196     }
 197
 198     if (myProjectsTree == null) myProjectsTree = new MavenProjectsTree();
 199     applyStateToTree();
 200     myProjectsTree.addListener(myProjectsTreeDispatcher.getMulticaster());
 201   }
 202
 203   private void applyTreeToState() {
 204     myState.originalFiles = myProjectsTree.getManagedFilesPaths();
 205     myState.activeProfiles = new ArrayList<String>(myProjectsTree.getExplicitProfiles());
 206     myState.ignoredFiles = new THashSet<String>(myProjectsTree.getIgnoredFilesPaths());
 207     myState.ignoredPathMasks = myProjectsTree.getIgnoredFilesPatterns();
 208   }
 209
 210   private void applyStateToTree() {
 211     myProjectsTree.resetManagedFilesPathsAndProfiles(myState.originalFiles, myState.activeProfiles);
 212     myProjectsTree.setIgnoredFilesPaths(new ArrayList<String>(myState.ignoredFiles));
 213     myProjectsTree.setIgnoredFilesPatterns(myState.ignoredPathMasks);
 214   }
 215
 216   public void save() {
 217     if (myProjectsTree != null) {
 218       try {
 219         myProjectsTree.save(getProjectsTreeFile());
 220       }
 221       catch (IOException e) {
 222         MavenLog.LOG.error(e);
 223       }
 224     }
 225   }
 226
 227   private File getProjectsTreeFile() {
 228     File file = new File(getProjectsTreesDir(), myProject.getLocationHash() + "/tree.dat");
 229     file.getParentFile().mkdirs();
 230     return file;
 231   }
 232
 233   private static File getProjectsTreesDir() {
 234     return MavenUtil.getPluginSystemDir("Projects");
 235   }
 236
 237   private void initWorkers() {
 238     myEmbeddersManager = new MavenEmbeddersManager(getGeneralSettings());
 239
 240     myReadingProcessor = new MavenProjectsProcessor(myProject,
 241                                                     ProjectBundle.message("maven.reading"),
 242                                                     false,
 243                                                     myEmbeddersManager);
 244     myResolvingProcessor = new MavenProjectsProcessor(myProject,
 245                                                       ProjectBundle.message("maven.resolving"),
 246                                                       true,
 247                                                       myEmbeddersManager);
 248     myPluginsResolvingProcessor = new MavenProjectsProcessor(myProject,
 249                                                              ProjectBundle.message("maven.downloading.plugins"),
 250                                                              true,
 251                                                              myEmbeddersManager);
 252     myFoldersResolvingProcessor = new MavenProjectsProcessor(myProject,
 253                                                              ProjectBundle.message("maven.updating.folders"),
 254                                                              true,
 255                                                              myEmbeddersManager);
 256     myArtifactsDownloadingProcessor = new MavenProjectsProcessor(myProject,
 257                                                                  ProjectBundle.message("maven.downloading"),
 258                                                                  true,
 259                                                                  myEmbeddersManager);
 260     myPostProcessor = new MavenProjectsProcessor(myProject,
 261                                                  ProjectBundle.message("maven.post.processing"),
 262                                                  true,
 263                                                  myEmbeddersManager);
 264
 265     myWatcher = new MavenProjectsManagerWatcher(myProject, myProjectsTree, getGeneralSettings(), myReadingProcessor, myEmbeddersManager);
 266
 267     myImportingQueue = new MavenMergingUpdateQueue(getComponentName() + ": Importing queue", IMPORT_DELAY, !isUnitTestMode(), myProject);
 268     myImportingQueue.setPassThrough(false);
 269
 270     myImportingQueue.makeUserAware(myProject);
 271     myImportingQueue.makeDumbAware(myProject);
 272     myImportingQueue.makeModalAware(myProject);
 273
 274     mySchedulesQueue = new MavenMergingUpdateQueue(getComponentName() + ": Schedules queue", 500, !isUnitTestMode(), myProject);
 275     mySchedulesQueue.setPassThrough(false);
 276   }
 277
 278   private void listenForSettingsChanges() {
 279     getImportingSettings().addListener(new MavenImportingSettings.Listener() {
 280       public void autoImportChanged() {
 281         scheduleImportSettings();
 282       }
 283
 284       public void createModuleGroupsChanged() {
 285         scheduleImportSettings(true);
 286       }
 287
 288       public void createModuleForAggregatorsChanged() {
 289         scheduleImportSettings();
 290       }
 291     });
 292   }
 293
 294   private void listenForProjectsTreeChanges() {
 295     myProjectsTree.addListener(new MavenProjectsTree.ListenerAdapter() {
 296       @Override
 297       public void projectsIgnoredStateChanged(List<MavenProject> ignored, List<MavenProject> unignored, Object message) {
 298         if (message instanceof MavenProjectImporter) return;
 299         scheduleImport(false);
 300       }
 301
 302       @Override
 303       public void projectsUpdated(List<Pair<MavenProject, MavenProjectChanges>> updated, List<MavenProject> deleted, Object message) {
 304         myEmbeddersManager.clearCaches();
 305
 306         unscheduleAllTasks(deleted);
 307
 308         List<MavenProject> updatedProjects = MavenUtil.collectFirsts(updated);
 309
 310         // import only updated and the dependents (we need to update faced-deps, packaging etc);
 311         List<Pair<MavenProject, MavenProjectChanges>> toImport = new ArrayList<Pair<MavenProject, MavenProjectChanges>>(updated);
 312         for (MavenProject each : updatedProjects) {
 313           for (MavenProject eachDependent : myProjectsTree.getDependentProjects(each)) {
 314             toImport.add(Pair.create(eachDependent, MavenProjectChanges.DEPENDENCIES));
 315           }
 316         }
 317
 318         // resolve updated, theirs dependents, and dependents of deleted
 319         Set<MavenProject> toResolve = new THashSet<MavenProject>(updatedProjects);
 320         for (MavenProject each : ContainerUtil.concat(updatedProjects, deleted)) {
 321           toResolve.addAll(myProjectsTree.getDependentProjects(each));
 322         }
 323
 324         // do not try to resolve projects with syntactic errors
 325         Iterator<MavenProject> it = toResolve.iterator();
 326         while (it.hasNext()) {
 327           MavenProject each = it.next();
 328           if (each.hasReadingProblems()) it.remove();
 329         }
 330
 331         if (haveChanges(toImport) || !deleted.isEmpty()) {
 332           scheduleImport(toImport, message == FORCE_IMPORT_MESSAGE);
 333         }
 334         scheduleResolve(toResolve, message == FORCE_IMPORT_MESSAGE);
 335       }
 336
 337       private boolean haveChanges(List<Pair<MavenProject, MavenProjectChanges>> projectsWithChanges) {
 338         for (MavenProjectChanges each : MavenUtil.collectSeconds(projectsWithChanges)) {
 339           if (each.hasChanges()) return true;
 340         }
 341         return false;
 342       }
 343
 344       @Override
 345       public void projectResolved(Pair<MavenProject, MavenProjectChanges> projectWithChanges,
 346                                   org.apache.maven.project.MavenProject nativeMavenProject,
 347                                   Object message) {
 348         if (shouldScheduleProject(projectWithChanges)) {
 349           if (projectWithChanges.first.hasUnresolvedPlugins()) {
 350             schedulePluginsResolving(projectWithChanges.first, nativeMavenProject);
 351           }
 352           scheduleArtifactsDownloading(Collections.singleton(projectWithChanges.first),
 353                                        getImportingSettings().shouldDownloadSourcesAutomatically(),
 354                                        getImportingSettings().shouldDownloadDocsAutomatically());
 355           scheduleForNextImport(projectWithChanges);
 356         }
 357         processMessage(message);
 358       }
 359
 360       @Override
 361       public void foldersResolved(Pair<MavenProject, MavenProjectChanges> projectWithChanges, Object message) {
 362         if (shouldScheduleProject(projectWithChanges)) {
 363           scheduleForNextImport(projectWithChanges);
 364         }
 365         processMessage(message);
 366       }
 367
 368       private boolean shouldScheduleProject(Pair<MavenProject, MavenProjectChanges> projectWithChanges) {
 369         return !projectWithChanges.first.hasReadingProblems() && projectWithChanges.second.hasChanges();
 370       }
 371
 372       private void processMessage(Object message) {
 373         if (getScheduledProjectsCount() == 0) return;
 374
 375         if (message == SCHEDULE_IMPORT_MESSAGE) {
 376           scheduleImport(false);
 377         }
 378         else if (message == FORCE_IMPORT_MESSAGE) {
 379           scheduleImport(true);
 380         }
 381       }
 382     });
 383   }
 384
 385   public void listenForExternalChanges() {
 386     myWatcher.start();
 387   }
 388
 389   @Override
 390   public void projectClosed() {
 391     if (!isInitialized.getAndSet(false)) return;
 392
 393     Disposer.dispose(mySchedulesQueue);
 394     Disposer.dispose(myImportingQueue);
 395
 396     myWatcher.stop();
 397
 398     myReadingProcessor.stop();
 399     myResolvingProcessor.stop();
 400     myPluginsResolvingProcessor.stop();
 401     myFoldersResolvingProcessor.stop();
 402     myArtifactsDownloadingProcessor.stop();
 403     myPostProcessor.stop();
 404
 405     myEmbeddersManager.release();
 406
 407     if (isUnitTestMode()) {
 408       FileUtil.delete(getProjectsTreesDir());
 409     }
 410   }
 411
 412   @TestOnly
 413   public MavenEmbeddersManager getEmbeddersManagerInTests() {
 414     return myEmbeddersManager;
 415   }
 416
 417   private boolean isInitialized() {
 418     return isInitialized.get();
 419   }
 420
 421   public boolean isMavenizedProject() {
 422     return isInitialized();
 423   }
 424
 425   public boolean isMavenizedModule(final Module m) {
 426     return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
 427       public Boolean compute() {
 428         return "true".equals(m.getOptionValue(getMavenizedModuleOptionName()));
 429       }
 430     });
 431   }
 432
 433   public void setMavenizedModules(Collection<Module> modules, boolean mavenized) {
 434     ApplicationManager.getApplication().assertWriteAccessAllowed();
 435     for (Module m : modules) {
 436       if (mavenized) {
 437         m.setOption(getMavenizedModuleOptionName(), "true");
 438       }
 439       else {
 440         m.clearOption(getMavenizedModuleOptionName());
 441       }
 442     }
 443   }
 444
 445   private String getMavenizedModuleOptionName() {
 446     return getComponentName() + ".isMavenModule";
 447   }
 448
 449   @TestOnly
 450   public void resetManagedFilesAndProfilesInTests(List<VirtualFile> files, List<String> profiles) {
 451     myWatcher.resetManagedFilesAndProfilesInTests(files, profiles);
 452   }
 453
 454   public void addManagedFilesWithProfiles(List<VirtualFile> files, List<String> profiles) {
 455     if (!isInitialized()) {
 456       initNew(files, profiles);
 457     }
 458     else {
 459       myWatcher.addManagedFilesWithProfiles(files, profiles);
 460     }
 461   }
 462
 463   public void addManagedFiles(List<VirtualFile> files) {
 464     addManagedFilesWithProfiles(files, Collections.<String>emptyList());
 465   }
 466
 467   public void removeManagedFiles(List<VirtualFile> files) {
 468     myWatcher.removeManagedFiles(files);
 469   }
 470
 471   public boolean isManagedFile(VirtualFile f) {
 472     if (!isInitialized()) return false;
 473     return myProjectsTree.isManagedFile(f);
 474   }
 475
 476   public Collection<String> getExplicitProfiles() {
 477     if (!isInitialized()) return Collections.emptyList();
 478     return myProjectsTree.getExplicitProfiles();
 479   }
 480
 481   public void setExplicitProfiles(Collection<String> profiles) {
 482     myWatcher.setExplicitProfiles(profiles);
 483   }
 484
 485   public Collection<String> getAvailableProfiles() {
 486     if (!isInitialized()) return Collections.emptyList();
 487     return myProjectsTree.getAvailableProfiles();
 488   }
 489
 490   public Collection<Pair<String, MavenProfileState>> getProfilesWithStates() {
 491     if (!isInitialized()) return Collections.emptyList();
 492     return myProjectsTree.getProfilesWithStates();
 493   }
 494
 495   public boolean hasProjects() {
 496     if (!isInitialized()) return false;
 497     return myProjectsTree.hasProjects();
 498   }
 499
 500   public List<MavenProject> getProjects() {
 501     if (!isInitialized()) return Collections.emptyList();
 502     return myProjectsTree.getProjects();
 503   }
 504
 505   public List<MavenProject> getNonIgnoredProjects() {
 506     if (!isInitialized()) return Collections.emptyList();
 507     return myProjectsTree.getNonIgnoredProjects();
 508   }
 509
 510   public List<VirtualFile> getProjectsFiles() {
 511     if (!isInitialized()) return Collections.emptyList();
 512     return myProjectsTree.getProjectsFiles();
 513   }
 514
 515   public MavenProject findProject(VirtualFile f) {
 516     if (!isInitialized()) return null;
 517     return myProjectsTree.findProject(f);
 518   }
 519
 520   public MavenProject findProject(MavenId id) {
 521     if (!isInitialized()) return null;
 522     return myProjectsTree.findProject(id);
 523   }
 524
 525   public MavenProject findProject(MavenArtifact artifact) {
 526     if (!isInitialized()) return null;
 527     return myProjectsTree.findProject(artifact);
 528   }
 529
 530   public MavenProject findProject(Module module) {
 531     VirtualFile f = findPomFile(module, new MavenModelsProvider() {
 532       public Module[] getModules() {
 533         throw new UnsupportedOperationException();
 534       }
 535
 536       public VirtualFile[] getContentRoots(Module module) {
 537         return ModuleRootManager.getInstance(module).getContentRoots();
 538       }
 539     });
 540     return f == null ? null : findProject(f);
 541   }
 542
 543   @Nullable
 544   public Module findModule(MavenProject project) {
 545     if (!isInitialized()) return null;
 546     return ProjectRootManager.getInstance(myProject).getFileIndex().getModuleForFile(project.getFile());
 547   }
 548
 549   public MavenProject findContainingProject(VirtualFile file) {
 550     if (!isInitialized()) return null;
 551     Module module = ProjectRootManager.getInstance(myProject).getFileIndex().getModuleForFile(file);
 552     return module == null ? null : findProject(module);
 553   }
 554
 555   private static VirtualFile findPomFile(Module module, MavenModelsProvider modelsProvider) {
 556     for (VirtualFile root : modelsProvider.getContentRoots(module)) {
 557       final VirtualFile virtualFile = root.findChild(MavenConstants.POM_XML);
 558       if (virtualFile != null) {
 559         return virtualFile;
 560       }
 561     }
 562     return null;
 563   }
 564
 565   public MavenProject findAggregator(MavenProject module) {
 566     if (!isInitialized()) return null;
 567     return myProjectsTree.findAggregator(module);
 568   }
 569
 570   public List<MavenProject> getModules(MavenProject aggregator) {
 571     if (!isInitialized()) return Collections.emptyList();
 572     return myProjectsTree.getModules(aggregator);
 573   }
 574
 575   public List<String> getIgnoredFilesPaths() {
 576     if (!isInitialized()) return Collections.emptyList();
 577     return myProjectsTree.getIgnoredFilesPaths();
 578   }
 579
 580   public void setIgnoredFilesPaths(List<String> paths) {
 581     if (!isInitialized()) return;
 582     myProjectsTree.setIgnoredFilesPaths(paths);
 583   }
 584
 585   public boolean getIgnoredState(MavenProject project) {
 586     if (!isInitialized()) return false;
 587     return myProjectsTree.getIgnoredState(project);
 588   }
 589
 590   public void setIgnoredState(List<MavenProject> projects, boolean ignored) {
 591     if (!isInitialized()) return;
 592     myProjectsTree.setIgnoredState(projects, ignored);
 593   }
 594
 595   public List<String> getIgnoredFilesPatterns() {
 596     if (!isInitialized()) return Collections.emptyList();
 597     return myProjectsTree.getIgnoredFilesPatterns();
 598   }
 599
 600   public void setIgnoredFilesPatterns(List<String> patterns) {
 601     if (!isInitialized()) return;
 602     myProjectsTree.setIgnoredFilesPatterns(patterns);
 603   }
 604
 605   public boolean isIgnored(MavenProject project) {
 606     if (!isInitialized()) return false;
 607     return myProjectsTree.isIgnored(project);
 608   }
 609
 610   public Set<MavenRemoteRepository> getRemoteRepositories() {
 611     Set<MavenRemoteRepository> result = new THashSet<MavenRemoteRepository>();
 612     for (MavenProject each : getProjects()) {
 613       for (MavenRemoteRepository eachRepository : each.getRemoteRepositories()) {
 614         result.add(eachRepository);
 615       }
 616     }
 617     return result;
 618   }
 619
 620   @TestOnly
 621   public MavenProjectsTree getProjectsTreeForTests() {
 622     return myProjectsTree;
 623   }
 624
 625   private void scheduleUpdateAllProjects(boolean forceImport) {
 626     doScheduleUpdateProjects(null, false, forceImport);
 627   }
 628
 629   public void forceUpdateProjects(Collection<MavenProject> projects) {
 630     doScheduleUpdateProjects(projects, true, true);
 631   }
 632
 633   public void forceUpdateAllProjectsOrFindAllAvailablePomFiles() {
 634     if (!isMavenizedProject()) {
 635       addManagedFiles(collectAllAvailablePomFiles());
 636     }
 637     doScheduleUpdateProjects(null, true, true);
 638   }
 639
 640   private void doScheduleUpdateProjects(final Collection<MavenProject> projects, final boolean force, final boolean forceImport) {
 641     // read when postStartupActivitias start
 642     MavenUtil.runWhenInitialized(myProject, new DumbAwareRunnable() {
 643       public void run() {
 644         if (projects == null) {
 645           myWatcher.scheduleUpdateAll(force, forceImport);
 646         }
 647         else {
 648           myWatcher.scheduleUpdate(MavenUtil.collectFiles(projects), Collections.EMPTY_LIST, force, forceImport);
 649         }
 650       }
 651     });
 652   }
 653
 654   private void scheduleResolve(final Collection<MavenProject> projects, final boolean forceImport) {
 655     runWhenFullyOpen(new Runnable() {
 656       public void run() {
 657         Iterator<MavenProject> it = projects.iterator();
 658         while (it.hasNext()) {
 659           MavenProject each = it.next();
 660           Object message = it.hasNext() ? null : (forceImport ? FORCE_IMPORT_MESSAGE : SCHEDULE_IMPORT_MESSAGE);
 661           myResolvingProcessor.scheduleTask(new MavenProjectsProcessorResolvingTask(each,
 662                                                                                     myProjectsTree,
 663                                                                                     getGeneralSettings(),
 664                                                                                     message));
 665         }
 666       }
 667     });
 668   }
 669
 670   @TestOnly
 671   public void scheduleResolveInTests(Collection<MavenProject> projects) {
 672     scheduleResolve(projects, false);
 673   }
 674
 675   @TestOnly
 676   public void scheduleResolveAllInTests() {
 677     scheduleResolve(getProjects(), false);
 678   }
 679
 680   public void scheduleFoldersResolving(final Collection<MavenProject> projects) {
 681     runWhenFullyOpen(new Runnable() {
 682       public void run() {
 683         Iterator<MavenProject> it = projects.iterator();
 684         while (it.hasNext()) {
 685           MavenProject each = it.next();
 686           Object message = it.hasNext() ? null : FORCE_IMPORT_MESSAGE;
 687           myFoldersResolvingProcessor.scheduleTask(new MavenProjectsProcessorFoldersResolvingTask(each,
 688                                                                                                   getGeneralSettings(),
 689                                                                                                   getImportingSettings(),
 690                                                                                                   myProjectsTree,
 691                                                                                                   message));
 692         }
 693       }
 694     });
 695   }
 696
 697   public void scheduleFoldersResolvingForAllProjects() {
 698     scheduleFoldersResolving(getProjects());
 699   }
 700
 701   private void schedulePluginsResolving(final MavenProject project, final org.apache.maven.project.MavenProject nativeMavenProject) {
 702     runWhenFullyOpen(new Runnable() {
 703       public void run() {
 704         myPluginsResolvingProcessor.scheduleTask(new MavenProjectsProcessorPluginsResolvingTask(project,
 705                                                                                                 nativeMavenProject,
 706                                                                                                 myProjectsTree));
 707       }
 708     });
 709   }
 710
 711   public void scheduleArtifactsDownloading(final Collection<MavenProject> projects, final boolean sources, final boolean docs) {
 712     if (!sources && !docs) return;
 713
 714     runWhenFullyOpen(new Runnable() {
 715       public void run() {
 716         for (MavenProject each : projects) {
 717           myArtifactsDownloadingProcessor.scheduleTask(
 718             new MavenProjectsProcessorArtifactsDownloadingTask(each, myProjectsTree, sources, docs));
 719         }
 720       }
 721     });
 722   }
 723
 724   public void scheduleArtifactsDownloading(final Collection<MavenProject> projects) {
 725     scheduleArtifactsDownloading(projects, true, true);
 726   }
 727
 728   public void scheduleArtifactsDownloadingForAllProjects() {
 729     scheduleArtifactsDownloading(getProjects());
 730   }
 731
 732   private void scheduleImport(List<Pair<MavenProject, MavenProjectChanges>> projectsWithChanges, boolean forceImport) {
 733     scheduleForNextImport(projectsWithChanges);
 734     scheduleImport(forceImport);
 735   }
 736
 737   private void scheduleImportSettings() {
 738     scheduleImportSettings(false);
 739   }
 740
 741   private void scheduleImportSettings(boolean importModuleGroupsRequired) {
 742     synchronized (myImportingDataLock) {
 743       myImportModuleGroupsRequired = importModuleGroupsRequired;
 744     }
 745     scheduleImport(false);
 746   }
 747
 748   private void scheduleImport(final boolean forceImport) {
 749     runWhenFullyOpen(new Runnable() {
 750       public void run() {
 751         final boolean autoImport = getImportingSettings().isImportAutomatically();
 752         // postpone activation to prevent import from being called from events poster
 753         mySchedulesQueue.queue(new Update(new Object()) {
 754           public void run() {
 755             if (autoImport || forceImport) {
 756               myImportingQueue.activate();
 757             }
 758             else {
 759               myImportingQueue.deactivate();
 760             }
 761           }
 762         });
 763         myImportingQueue.queue(new Update(MavenProjectsManager.this) {
 764           public void run() {
 765             importProjects();
 766             if (!autoImport) myImportingQueue.deactivate();
 767           }
 768         });
 769         if (!forceImport) fireScheduledImportsChanged();
 770       }
 771     });
 772   }
 773
 774   @TestOnly
 775   public void scheduleImportInTests(List<VirtualFile> projectFiles) {
 776     List<Pair<MavenProject, MavenProjectChanges>> toImport = new ArrayList<Pair<MavenProject, MavenProjectChanges>>();
 777     for (VirtualFile each : projectFiles) {
 778       MavenProject project = findProject(each);
 779       if (project != null) {
 780         toImport.add(Pair.create(project, MavenProjectChanges.ALL));
 781       }
 782     }
 783     scheduleImport(toImport, false);
 784   }
 785
 786   private void scheduleForNextImport(Pair<MavenProject, MavenProjectChanges> projectWithChanges) {
 787     scheduleForNextImport(Collections.singletonList(projectWithChanges));
 788   }
 789
 790   private void scheduleForNextImport(List<Pair<MavenProject, MavenProjectChanges>> projectsWithChanges) {
 791     synchronized (myImportingDataLock) {
 792       for (Pair<MavenProject, MavenProjectChanges> each : projectsWithChanges) {
 793         MavenProjectChanges changes = each.second.mergedWith(myProjectsToImport.get(each.first));
 794         myProjectsToImport.put(each.first, changes);
 795       }
 796     }
 797   }
 798
 799   public boolean hasScheduledImports() {
 800     if (!isInitialized()) return false;
 801     return !myImportingQueue.isEmpty();
 802   }
 803
 804   public int getScheduledProjectsCount() {
 805     if (!isInitialized()) return 0;
 806     synchronized (myImportingDataLock) {
 807       return myProjectsToImport.size();
 808     }
 809   }
 810
 811   public void performScheduledImport() {
 812     performScheduledImport(true);
 813   }
 814
 815   public void performScheduledImport(final boolean force) {
 816     if (!isInitialized()) return;
 817     runWhenFullyOpen(new Runnable() {
 818       public void run() {
 819         // ensure all pending schedules are processed
 820         mySchedulesQueue.flush(false);
 821         if (!force && !myImportingQueue.isActive()) return;
 822         myImportingQueue.flush(false);
 823       }
 824     });
 825   }
 826
 827   private void runWhenFullyOpen(final Runnable runnable) {
 828     if (!isInitialized()) return; // may be called from scheduleImport after project started closing and before it is closed.
 829
 830     if (isNoBackgroundMode()) {
 831       runnable.run();
 832       return;
 833     }
 834
 835     final Ref<Runnable> wrapper = new Ref<Runnable>();
 836     wrapper.set(new Runnable() {
 837       public void run() {
 838         if (!StartupManagerEx.getInstanceEx(myProject).postStartupActivityPassed()) {
 839           mySchedulesQueue.queue(new Update(runnable) { // should not remove previously schedules tasks
 840
 841             public void run() {
 842               wrapper.get().run();
 843             }
 844           });
 845           return;
 846         }
 847         runnable.run();
 848       }
 849     });
 850     MavenUtil.runWhenInitialized(myProject, wrapper.get());
 851   }
 852
 853   private void schedulePostImportTasts(List<MavenProjectsProcessorTask> postTasks) {
 854     for (MavenProjectsProcessorTask each : postTasks) {
 855       myPostProcessor.scheduleTask(each);
 856     }
 857   }
 858
 859   private void unscheduleAllTasks(List<MavenProject> projects) {
 860     for (MavenProject each : projects) {
 861       MavenProjectsProcessorEmptyTask dummyTask = new MavenProjectsProcessorEmptyTask(each);
 862
 863       synchronized (myImportingDataLock) {
 864         myProjectsToImport.remove(each);
 865       }
 866
 867       myResolvingProcessor.removeTask(dummyTask);
 868       myPluginsResolvingProcessor.removeTask(dummyTask);
 869       myFoldersResolvingProcessor.removeTask(dummyTask);
 870       myArtifactsDownloadingProcessor.removeTask(dummyTask);
 871       myPostProcessor.removeTask(dummyTask);
 872     }
 873   }
 874
 875   @TestOnly
 876   public void unscheduleAllTasksInTests() {
 877     unscheduleAllTasks(getProjects());
 878   }
 879
 880   public void waitForReadingCompletion() {
 881     waitForTasksCompletion(Collections.<MavenProjectsProcessor>emptyList());
 882   }
 883
 884   public void waitForResolvingCompletion() {
 885     waitForTasksCompletion(myResolvingProcessor);
 886   }
 887
 888   public void waitForFoldersResolvingCompletion() {
 889     waitForTasksCompletion(myFoldersResolvingProcessor);
 890   }
 891
 892   public void waitForPluginsResolvingCompletion() {
 893     waitForTasksCompletion(myPluginsResolvingProcessor);
 894   }
 895
 896   public void waitForArtifactsDownloadingCompletion() {
 897     waitForTasksCompletion(Arrays.asList(myResolvingProcessor, myArtifactsDownloadingProcessor));
 898   }
 899
 900   public void waitForPostImportTasksCompletion() {
 901     myPostProcessor.waitForCompletion();
 902   }
 903
 904   private void waitForTasksCompletion(MavenProjectsProcessor processor) {
 905     waitForTasksCompletion(Collections.singletonList(processor));
 906   }
 907
 908   private void waitForTasksCompletion(List<MavenProjectsProcessor> processors) {
 909     FileDocumentManager.getInstance().saveAllDocuments();
 910
 911     myReadingProcessor.waitForCompletion();
 912     for (MavenProjectsProcessor each : processors) {
 913       each.waitForCompletion();
 914     }
 915   }
 916
 917   public void updateProjectTargetFolders() {
 918     updateProjectFolders(true);
 919   }
 920
 921   private void updateProjectFolders(final boolean targetFoldersOnly) {
 922     MavenUtil.invokeLater(myProject, new Runnable() {
 923       public void run() {
 924         MavenFoldersImporter.updateProjectFolders(myProject, targetFoldersOnly);
 925         VirtualFileManager.getInstance().refresh(false);
 926       }
 927     });
 928   }
 929
 930   public List<Module> importProjects() {
 931     return importProjects(new MavenDefaultModifiableModelsProvider(myProject));
 932   }
 933
 934   public List<Module> importProjects(final MavenModifiableModelsProvider modelsProvider) {
 935     final Map<MavenProject, MavenProjectChanges> projectsToImportWithChanges;
 936     final boolean importModuleGroupsRequired;
 937     synchronized (myImportingDataLock) {
 938       projectsToImportWithChanges = new THashMap<MavenProject, MavenProjectChanges>(myProjectsToImport);
 939       myProjectsToImport.clear();
 940       importModuleGroupsRequired = myImportModuleGroupsRequired;
 941     }
 942     fireScheduledImportsChanged();
 943
 944     final Ref<MavenProjectImporter> importer = new Ref<MavenProjectImporter>();
 945     final Ref<List<MavenProjectsProcessorTask>> postTasks = new Ref<List<MavenProjectsProcessorTask>>();
 946
 947     final Runnable r = new Runnable() {
 948       public void run() {
 949         importer.set(new MavenProjectImporter(myProject,
 950                                               myProjectsTree,
 951                                               getFileToModuleMapping(modelsProvider),
 952                                               projectsToImportWithChanges,
 953                                               importModuleGroupsRequired,
 954                                               modelsProvider,
 955                                               getImportingSettings()));
 956         postTasks.set(importer.get().importProject());
 957       }
 958     };
 959
 960     // called from wizard or ui
 961     if (ApplicationManager.getApplication().isDispatchThread()) {
 962       r.run();
 963     }
 964     else {
 965       MavenUtil.runInBackground(myProject, ProjectBundle.message("maven.project.importing"), false, new MavenTask() {
 966         public void run(MavenProgressIndicator indicator) throws MavenProcessCanceledException {
 967           r.run();
 968         }
 969       }).waitFor();
 970     }
 971
 972
 973     VirtualFileManager.getInstance().refresh(isNormalProject());
 974     schedulePostImportTasts(postTasks.get());
 975
 976     // do not block user too often
 977     myImportingQueue.restartTimer();
 978
 979     return importer.get().getCreatedModules();
 980   }
 981
 982   private Map<VirtualFile, Module> getFileToModuleMapping(MavenModelsProvider modelsProvider) {
 983     Map<VirtualFile, Module> result = new THashMap<VirtualFile, Module>();
 984     for (Module each : modelsProvider.getModules()) {
 985       VirtualFile f = findPomFile(each, modelsProvider);
 986       if (f != null) result.put(f, each);
 987     }
 988     return result;
 989   }
 990
 991   private List<VirtualFile> collectAllAvailablePomFiles() {
 992     List<VirtualFile> result = new ArrayList<VirtualFile>(getFileToModuleMapping(new MavenDefaultModelsProvider(myProject)).keySet());
 993
 994     VirtualFile pom = myProject.getBaseDir().findChild(MavenConstants.POM_XML);
 995     if (pom != null) result.add(pom);
 996
 997     return result;
 998   }
 999
1000   public MavenDomDependency addDependency(final MavenProject mavenProject, final MavenId id) {
1001     final MavenArtifact[] artifact = new MavenArtifact[1];
1002
1003     try {
1004       MavenUtil.run(myProject, "Downloading dependency...", new MavenTask() {
1005         public void run(MavenProgressIndicator indicator) throws MavenProcessCanceledException {
1006           artifact[0] = myProjectsTree.downloadArtifact(mavenProject, id, myEmbeddersManager, new SoutMavenConsole(), indicator);
1007         }
1008       });
1009     }
1010     catch (MavenProcessCanceledException ignore) {
1011       return null;
1012     }
1013
1014     VirtualFile file = mavenProject.getFile();
1015     PsiFile psiFile = PsiManager.getInstance(myProject).findFile(file);
1016
1017     MavenDomDependency result = new WriteCommandAction<MavenDomDependency>(myProject, "Add Maven Dependency", psiFile) {
1018       protected void run(Result<MavenDomDependency> result) throws Throwable {
1019         MavenDomProjectModel model = MavenDomUtil.getMavenDomProjectModel(myProject, mavenProject.getFile());
1020         MavenDomDependency domDependency = model.getDependencies().addDependency();
1021         domDependency.getGroupId().setStringValue(artifact[0].getGroupId());
1022         domDependency.getArtifactId().setStringValue(artifact[0].getArtifactId());
1023         domDependency.getVersion().setStringValue(artifact[0].getVersion());
1024
1025         mavenProject.addDependency(artifact[0]);
1026         result.setResult(domDependency);
1027       }
1028     }.execute().getResultObject();
1029
1030     scheduleImport(Collections.singletonList(Pair.create(mavenProject, MavenProjectChanges.DEPENDENCIES)), true);
1031
1032     return result;
1033   }
1034
1035   public void addManagerListener(Listener listener) {
1036     myManagerListeners.add(listener);
1037   }
1038
1039   public void addProjectsTreeListener(MavenProjectsTree.Listener listener) {
1040     myProjectsTreeDispatcher.addListener(listener);
1041   }
1042
1043   @TestOnly
1044   public void fireActivatedInTests() {
1045     fireActivated();
1046   }
1047
1048   private void fireActivated() {
1049     for (Listener each : myManagerListeners) {
1050       each.activated();
1051     }
1052   }
1053
1054   private void fireScheduledImportsChanged() {
1055     for (Listener each : myManagerListeners) {
1056       each.scheduledImportsChanged();
1057     }
1058   }
1059
1060   public interface Listener {
1061     void activated();
1062
1063     void scheduledImportsChanged();
1064   }
1065 }