plugins/gradle/src/org/jetbrains/plugins/gradle/service/project/data/ExternalProjectDataService.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2014 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.plugins.gradle.service.project.data;

 import com.intellij.CommonBundle;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.externalSystem.model.*;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
 import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskNotificationListener;
 import com.intellij.openapi.externalSystem.service.internal.ExternalSystemResolveProjectTask;
 import com.intellij.openapi.externalSystem.service.notification.ExternalSystemNotificationManager;
 import com.intellij.openapi.externalSystem.service.notification.NotificationSource;
 import com.intellij.openapi.externalSystem.service.project.manage.ProjectDataManager;
 import com.intellij.openapi.externalSystem.service.project.manage.ProjectDataService;
 import com.intellij.openapi.externalSystem.settings.ExternalProjectSettings;
 import com.intellij.openapi.externalSystem.util.*;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.progress.Task;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ex.ProjectRootManagerEx;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.Function;
 import com.intellij.util.containers.ConcurrentFactoryMap;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.ui.UIUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import java.io.File;
 import java.util.Collection;
 import java.util.Map;

 /**
  * @author Vladislav.Soroka
  * @since 7/17/2014
  */
 @Order(ExternalSystemConstants.BUILTIN_SERVICE_ORDER)
 public class ExternalProjectDataService implements ProjectDataService<ExternalProject, Project> {
   private static final Logger LOG = Logger.getInstance(ExternalProjectDataService.class);

   @NotNull public static final Key<ExternalProject> KEY = Key.create(ExternalProject.class, ProjectKeys.TASK.getProcessingWeight() + 1);

   @NotNull private final Map<Pair<ProjectSystemId, File>, ExternalProject> myExternalRootProjects;

   @NotNull private ProjectDataManager myProjectDataManager;

   public ExternalProjectDataService(@NotNull ProjectDataManager projectDataManager) {
     myProjectDataManager = projectDataManager;
     myExternalRootProjects = new ConcurrentFactoryMap<Pair<ProjectSystemId, File>, ExternalProject>() {
       @Nullable
       @Override
       protected ExternalProject create(Pair<ProjectSystemId, File> key) {
         return new ExternalProjectSerializer().load(key.first, key.second);
       }

       @Override
       public ExternalProject put(Pair<ProjectSystemId, File> key, ExternalProject value) {
         new ExternalProjectSerializer().save(value);
         return super.put(key, value);
       }
     };
   }

   @NotNull
   @Override
   public Key<ExternalProject> getTargetDataKey() {
     return KEY;
   }

   public void importData(@NotNull final Collection<DataNode<ExternalProject>> toImport,
                          @NotNull final Project project,
                          final boolean synchronous) {
     if (toImport.size() != 1) {
       throw new IllegalArgumentException(
         String.format("Expected to get a single external project but got %d: %s", toImport.size(), toImport));
     }
     saveExternalProject(toImport.iterator().next().getData());
   }

   @Override
   public void removeData(@NotNull final Collection<? extends Project> modules, @NotNull Project project, boolean synchronous) {
   }

   @Nullable
   public ExternalProject getOrImportRootExternalProject(@NotNull Project project,
                                                         @NotNull ProjectSystemId systemId,
                                                         @NotNull File projectRootDir) {
     final ExternalProject externalProject = getRootExternalProject(systemId, projectRootDir);
     return externalProject != null ? externalProject : importExternalProject(project, systemId, projectRootDir);
   }

   @Nullable
   private ExternalProject importExternalProject(@NotNull final Project project,
                                                 @NotNull final ProjectSystemId projectSystemId,
                                                 @NotNull final File projectRootDir) {
     final Boolean result = UIUtil.invokeAndWaitIfNeeded(new Computable<Boolean>() {
       @Override
       public Boolean compute() {
         final Ref<Boolean> result = new Ref<Boolean>(false);
         if (project.isDisposed()) return false;

         final String linkedProjectPath = FileUtil.toCanonicalPath(projectRootDir.getPath());
         final ExternalProjectSettings projectSettings =
           ExternalSystemApiUtil.getSettings(project, projectSystemId).getLinkedProjectSettings(linkedProjectPath);
         if (projectSettings == null) {
           LOG.warn("Unable to get project settings for project path: " + linkedProjectPath);
           if (LOG.isDebugEnabled()) {
             LOG.debug("Available projects paths: " + ContainerUtil.map(
               ExternalSystemApiUtil.getSettings(project, projectSystemId).getLinkedProjectsSettings(),
               new Function<ExternalProjectSettings, String>() {
                 @Override
                 public String fun(ExternalProjectSettings settings) {
                   return settings.getExternalProjectPath();
                 }
               }));
           }
           return false;
         }

         final File projectFile = new File(linkedProjectPath);
         final String projectName;
         if (projectFile.isFile()) {
           projectName = projectFile.getParentFile().getName();
         }
         else {
           projectName = projectFile.getName();
         }

         // ask a user for the project import if auto-import is disabled
         if (!projectSettings.isUseAutoImport()) {
           String message = String.format("Project '%s' require synchronization with %s configuration. \nImport the project?",
                                          projectName, projectSystemId.getReadableName());
           int returnValue = Messages.showOkCancelDialog(
             message, "Import Project", CommonBundle.getOkButtonText(), CommonBundle.getCancelButtonText(), Messages.getQuestionIcon()
           );
           if (returnValue != Messages.OK) return false;
         }

         final String title = ExternalSystemBundle.message("progress.import.text", linkedProjectPath, projectSystemId.getReadableName());
         new Task.Modal(project, title, false) {
           @Override
           public void run(@NotNull ProgressIndicator indicator) {
             if (project.isDisposed()) return;

             ExternalSystemNotificationManager.getInstance(project)
               .clearNotifications(null, NotificationSource.PROJECT_SYNC, projectSystemId);
             ExternalSystemResolveProjectTask task =
               new ExternalSystemResolveProjectTask(projectSystemId, project, linkedProjectPath, false);
             task.execute(indicator, ExternalSystemTaskNotificationListener.EP_NAME.getExtensions());
             if (project.isDisposed()) return;

             final Throwable error = task.getError();
             if (error != null) {
               ExternalSystemNotificationManager.getInstance(project)
                 .processExternalProjectRefreshError(error, projectName, projectSystemId);
               return;
             }
             final DataNode<ProjectData> projectDataDataNode = task.getExternalProject();
             if (projectDataDataNode == null) return;

             final Collection<DataNode<ExternalProject>> nodes = ExternalSystemApiUtil.findAll(projectDataDataNode, KEY);
             if (nodes.size() != 1) {
               throw new IllegalArgumentException(
                 String.format("Expected to get a single external project but got %d: %s", nodes.size(), nodes));
             }

             ProjectRootManagerEx.getInstanceEx(myProject).mergeRootsChangesDuring(new Runnable() {
               @Override
               public void run() {
                 myProjectDataManager.importData(KEY, nodes, project, true);
               }
             });

             result.set(true);
           }
         }.queue();

         return result.get();
       }
     });

     return result ? getRootExternalProject(projectSystemId, projectRootDir) : null;
   }

   @Nullable
   public ExternalProject getRootExternalProject(@NotNull ProjectSystemId systemId, @NotNull File projectRootDir) {
     return myExternalRootProjects.get(Pair.create(systemId, projectRootDir));
   }

   public void saveExternalProject(@NotNull ExternalProject externalProject) {
     myExternalRootProjects.put(
       Pair.create(new ProjectSystemId(externalProject.getExternalSystemId()), externalProject.getProjectDir()),
       new DefaultExternalProject(externalProject)
     );
   }

   @Nullable
   public ExternalProject findExternalProject(@NotNull ExternalProject parentProject, @NotNull Module module) {
     String externalProjectId = ExternalSystemApiUtil.getExternalProjectId(module);
     return externalProjectId != null ? findExternalProject(parentProject, externalProjectId) : null;
   }

   @Nullable
   private static ExternalProject findExternalProject(@NotNull ExternalProject parentProject, @NotNull String externalProjectId) {
     if (parentProject.getQName().equals(externalProjectId)) return parentProject;
     if (parentProject.getChildProjects().containsKey(externalProjectId)) {
       return parentProject.getChildProjects().get(externalProjectId);
     }
     for (ExternalProject externalProject : parentProject.getChildProjects().values()) {
       final ExternalProject project = findExternalProject(externalProject, externalProjectId);
       if (project != null) return project;
     }
     return null;
   }
 }
	/*
	* Copyright 2000-2014 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.plugins.gradle.service.project.data;

	import com.intellij.CommonBundle;
	import com.intellij.openapi.diagnostic.Logger;
	import com.intellij.openapi.externalSystem.model.*;
	import com.intellij.openapi.externalSystem.model.project.ProjectData;
	import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskNotificationListener;
	import com.intellij.openapi.externalSystem.service.internal.ExternalSystemResolveProjectTask;
	import com.intellij.openapi.externalSystem.service.notification.ExternalSystemNotificationManager;
	import com.intellij.openapi.externalSystem.service.notification.NotificationSource;
	import com.intellij.openapi.externalSystem.service.project.manage.ProjectDataManager;
	import com.intellij.openapi.externalSystem.service.project.manage.ProjectDataService;
	import com.intellij.openapi.externalSystem.settings.ExternalProjectSettings;
	import com.intellij.openapi.externalSystem.util.*;
	import com.intellij.openapi.module.Module;
	import com.intellij.openapi.progress.ProgressIndicator;
	import com.intellij.openapi.progress.Task;
	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.roots.ex.ProjectRootManagerEx;
	import com.intellij.openapi.ui.Messages;
	import com.intellij.openapi.util.Computable;
	import com.intellij.openapi.util.Pair;
	import com.intellij.openapi.util.Ref;
	import com.intellij.openapi.util.io.FileUtil;
	import com.intellij.util.Function;
	import com.intellij.util.containers.ConcurrentFactoryMap;
	import com.intellij.util.containers.ContainerUtil;
	import com.intellij.util.ui.UIUtil;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;

	import java.io.File;
	import java.util.Collection;
	import java.util.Map;

	/**
	* @author Vladislav.Soroka
	* @since 7/17/2014
	*/
	@Order(ExternalSystemConstants.BUILTIN_SERVICE_ORDER)
	public class ExternalProjectDataService implements ProjectDataService<ExternalProject, Project> {
	private static final Logger LOG = Logger.getInstance(ExternalProjectDataService.class);

	@NotNull public static final Key<ExternalProject> KEY = Key.create(ExternalProject.class, ProjectKeys.TASK.getProcessingWeight() + 1);

	@NotNull private final Map<Pair<ProjectSystemId, File>, ExternalProject> myExternalRootProjects;

	@NotNull private ProjectDataManager myProjectDataManager;

	public ExternalProjectDataService(@NotNull ProjectDataManager projectDataManager) {
	myProjectDataManager = projectDataManager;
	myExternalRootProjects = new ConcurrentFactoryMap<Pair<ProjectSystemId, File>, ExternalProject>() {
	@Nullable
	@Override
	protected ExternalProject create(Pair<ProjectSystemId, File> key) {
	return new ExternalProjectSerializer().load(key.first, key.second);
	}

	@Override
	public ExternalProject put(Pair<ProjectSystemId, File> key, ExternalProject value) {
	new ExternalProjectSerializer().save(value);
	return super.put(key, value);
	}
	};
	}

	@NotNull
	@Override
	public Key<ExternalProject> getTargetDataKey() {
	return KEY;
	}

	public void importData(@NotNull final Collection<DataNode<ExternalProject>> toImport,
	@NotNull final Project project,
	final boolean synchronous) {
	if (toImport.size() != 1) {
	throw new IllegalArgumentException(
	String.format("Expected to get a single external project but got %d: %s", toImport.size(), toImport));
	}
	saveExternalProject(toImport.iterator().next().getData());
	}

	@Override
	public void removeData(@NotNull final Collection<? extends Project> modules, @NotNull Project project, boolean synchronous) {
	}

	@Nullable
	public ExternalProject getOrImportRootExternalProject(@NotNull Project project,
	@NotNull ProjectSystemId systemId,
	@NotNull File projectRootDir) {
	final ExternalProject externalProject = getRootExternalProject(systemId, projectRootDir);
	return externalProject != null ? externalProject : importExternalProject(project, systemId, projectRootDir);
	}

	@Nullable
	private ExternalProject importExternalProject(@NotNull final Project project,
	@NotNull final ProjectSystemId projectSystemId,
	@NotNull final File projectRootDir) {
	final Boolean result = UIUtil.invokeAndWaitIfNeeded(new Computable<Boolean>() {
	@Override
	public Boolean compute() {
	final Ref<Boolean> result = new Ref<Boolean>(false);
	if (project.isDisposed()) return false;

	final String linkedProjectPath = FileUtil.toCanonicalPath(projectRootDir.getPath());
	final ExternalProjectSettings projectSettings =
	ExternalSystemApiUtil.getSettings(project, projectSystemId).getLinkedProjectSettings(linkedProjectPath);
	if (projectSettings == null) {
	LOG.warn("Unable to get project settings for project path: " + linkedProjectPath);
	if (LOG.isDebugEnabled()) {
	LOG.debug("Available projects paths: " + ContainerUtil.map(
	ExternalSystemApiUtil.getSettings(project, projectSystemId).getLinkedProjectsSettings(),
	new Function<ExternalProjectSettings, String>() {
	@Override
	public String fun(ExternalProjectSettings settings) {
	return settings.getExternalProjectPath();
	}
	}));
	}
	return false;
	}

	final File projectFile = new File(linkedProjectPath);
	final String projectName;
	if (projectFile.isFile()) {
	projectName = projectFile.getParentFile().getName();
	}
	else {
	projectName = projectFile.getName();
	}

	// ask a user for the project import if auto-import is disabled
	if (!projectSettings.isUseAutoImport()) {
	String message = String.format("Project '%s' require synchronization with %s configuration. \nImport the project?",
	projectName, projectSystemId.getReadableName());
	int returnValue = Messages.showOkCancelDialog(
	message, "Import Project", CommonBundle.getOkButtonText(), CommonBundle.getCancelButtonText(), Messages.getQuestionIcon()
	);
	if (returnValue != Messages.OK) return false;
	}

	final String title = ExternalSystemBundle.message("progress.import.text", linkedProjectPath, projectSystemId.getReadableName());
	new Task.Modal(project, title, false) {
	@Override
	public void run(@NotNull ProgressIndicator indicator) {
	if (project.isDisposed()) return;

	ExternalSystemNotificationManager.getInstance(project)
	.clearNotifications(null, NotificationSource.PROJECT_SYNC, projectSystemId);
	ExternalSystemResolveProjectTask task =
	new ExternalSystemResolveProjectTask(projectSystemId, project, linkedProjectPath, false);
	task.execute(indicator, ExternalSystemTaskNotificationListener.EP_NAME.getExtensions());
	if (project.isDisposed()) return;

	final Throwable error = task.getError();
	if (error != null) {
	ExternalSystemNotificationManager.getInstance(project)
	.processExternalProjectRefreshError(error, projectName, projectSystemId);
	return;
	}
	final DataNode<ProjectData> projectDataDataNode = task.getExternalProject();
	if (projectDataDataNode == null) return;

	final Collection<DataNode<ExternalProject>> nodes = ExternalSystemApiUtil.findAll(projectDataDataNode, KEY);
	if (nodes.size() != 1) {
	throw new IllegalArgumentException(
	String.format("Expected to get a single external project but got %d: %s", nodes.size(), nodes));
	}

	ProjectRootManagerEx.getInstanceEx(myProject).mergeRootsChangesDuring(new Runnable() {
	@Override
	public void run() {
	myProjectDataManager.importData(KEY, nodes, project, true);
	}
	});

	result.set(true);
	}
	}.queue();

	return result.get();
	}
	});

	return result ? getRootExternalProject(projectSystemId, projectRootDir) : null;
	}

	@Nullable
	public ExternalProject getRootExternalProject(@NotNull ProjectSystemId systemId, @NotNull File projectRootDir) {
	return myExternalRootProjects.get(Pair.create(systemId, projectRootDir));
	}

	public void saveExternalProject(@NotNull ExternalProject externalProject) {
	myExternalRootProjects.put(
	Pair.create(new ProjectSystemId(externalProject.getExternalSystemId()), externalProject.getProjectDir()),
	new DefaultExternalProject(externalProject)
	);
	}

	@Nullable
	public ExternalProject findExternalProject(@NotNull ExternalProject parentProject, @NotNull Module module) {
	String externalProjectId = ExternalSystemApiUtil.getExternalProjectId(module);
	return externalProjectId != null ? findExternalProject(parentProject, externalProjectId) : null;
	}

	@Nullable
	private static ExternalProject findExternalProject(@NotNull ExternalProject parentProject, @NotNull String externalProjectId) {
	if (parentProject.getQName().equals(externalProjectId)) return parentProject;
	if (parentProject.getChildProjects().containsKey(externalProjectId)) {
	return parentProject.getChildProjects().get(externalProjectId);
	}
	for (ExternalProject externalProject : parentProject.getChildProjects().values()) {
	final ExternalProject project = findExternalProject(externalProject, externalProjectId);
	if (project != null) return project;
	}
	return null;
	}
	}