org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/clone/GitImportWizard.java

   1 /*******************************************************************************
   2  * Copyright (c) 2010-2013 SAP AG and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License 2.0
   5  * which accompanies this distribution, and is available at
   6  * https://www.eclipse.org/legal/epl-2.0/
   7  *
   8  * SPDX-License-Identifier: EPL-2.0
   9  *
  10  * Contributors:
  11  *    Mathias Kinzler (SAP AG) - initial implementation
  12  *    Stefan Lay (SAP AG) - improvements
  13  *******************************************************************************/
  14 package org.eclipse.egit.ui.internal.clone;
  15
  16 import java.io.File;
  17 import java.io.IOException;
  18 import java.lang.reflect.InvocationTargetException;
  19 import java.net.URISyntaxException;
  20 import java.util.ArrayList;
  21 import java.util.Arrays;
  22 import java.util.HashSet;
  23 import java.util.List;
  24 import java.util.Set;
  25
  26 import org.eclipse.core.resources.IProject;
  27 import org.eclipse.core.resources.IProjectDescription;
  28 import org.eclipse.core.resources.IResource;
  29 import org.eclipse.core.resources.IWorkspaceRunnable;
  30 import org.eclipse.core.resources.ResourcesPlugin;
  31 import org.eclipse.core.runtime.CoreException;
  32 import org.eclipse.core.runtime.IProgressMonitor;
  33 import org.eclipse.core.runtime.Path;
  34 import org.eclipse.core.runtime.SubMonitor;
  35 import org.eclipse.egit.core.op.ConnectProviderOperation;
  36 import org.eclipse.egit.ui.Activator;
  37 import org.eclipse.egit.ui.internal.UIIcons;
  38 import org.eclipse.egit.ui.internal.UIText;
  39 import org.eclipse.egit.ui.internal.clone.GitCloneSourceProviderExtension.CloneSourceProvider;
  40 import org.eclipse.egit.ui.internal.provisional.wizards.GitRepositoryInfo;
  41 import org.eclipse.egit.ui.internal.provisional.wizards.IRepositorySearchResult;
  42 import org.eclipse.egit.ui.internal.provisional.wizards.NoRepositoryInfoException;
  43 import org.eclipse.jface.dialogs.IDialogSettings;
  44 import org.eclipse.jface.operation.IRunnableWithProgress;
  45 import org.eclipse.jface.viewers.IStructuredSelection;
  46 import org.eclipse.jface.wizard.IWizardPage;
  47 import org.eclipse.jgit.lib.Constants;
  48 import org.eclipse.jgit.lib.Repository;
  49 import org.eclipse.ui.IImportWizard;
  50 import org.eclipse.ui.IWorkbench;
  51 import org.eclipse.ui.IWorkingSet;
  52 import org.eclipse.ui.PlatformUI;
  53 import org.eclipse.ui.actions.NewProjectAction;
  54
  55 /**
  56  * A wizard which allows to optionally clone a repository and to import projects from a repository.
  57  */
  58 public class GitImportWizard extends AbstractGitCloneWizard implements IImportWizard {
  59         private static final String GIT_IMPORT_SECTION = "GitImportWizard"; //$NON-NLS-1$
  60
  61         private GitSelectRepositoryPage selectRepoPage = new GitSelectRepositoryPage(
  62                         false);
  63
  64         private GitSelectWizardPage importWithDirectoriesPage = new GitSelectWizardPage(){
  65                 @Override
  66                 public void setVisible(boolean visible) {
  67                         if (existingRepo == null && visible && (cloneDestination.cloneSettingsChanged())) {
  68                                 setCallerRunsCloneOperation(true);
  69                                 try {
  70                                         final GitRepositoryInfo repositoryInfo = currentSearchResult.getGitRepositoryInfo();
  71                                         performClone(repositoryInfo);
  72                                         importWithDirectoriesPage.getControl().getDisplay().asyncExec(new Runnable() {
  73
  74                                                 @Override
  75                                                 public void run() {
  76                                                         runCloneOperation(getContainer(), repositoryInfo);
  77                                                         cloneDestination.saveSettingsForClonedRepo();
  78                                                 }});
  79                                 } catch (URISyntaxException e) {
  80                                         Activator.error(UIText.GitImportWizard_errorParsingURI, e);
  81                                 } catch (NoRepositoryInfoException e) {
  82                                         Activator.error(UIText.GitImportWizard_noRepositoryInfo, e);
  83                                 } catch (Exception e) {
  84                                         Activator.error(e.getMessage(), e);
  85                                 }
  86                         }
  87                         super.setVisible(visible);
  88                 }
  89         };
  90
  91         private GitProjectsImportPage projectsImportPage = new GitProjectsImportPage() {
  92                 @Override
  93                 public void setVisible(boolean visible) {
  94                         if (visible)
  95                                 setProjectsList(importWithDirectoriesPage.getPath());
  96                         super.setVisible(visible);
  97                 }
  98         };
  99
 100         private GitCreateGeneralProjectPage createGeneralProjectPage = new GitCreateGeneralProjectPage() {
 101                 @Override
 102                 public void setVisible(boolean visible) {
 103                         if (visible)
 104                                 setPath(importWithDirectoriesPage.getPath());
 105                         super.setVisible(visible);
 106                 }
 107         };
 108
 109         private Repository existingRepo;
 110
 111         /**
 112          * The default constructor
 113          */
 114         public GitImportWizard() {
 115                 this(null);
 116         }
 117
 118         /**
 119          * Construct the import wizard based on given repository search result. The
 120          * wizard skips the repository location page in this case.
 121          *
 122          * @param searchResult
 123          *            the search result to initialize the import wizard with.
 124          */
 125         public GitImportWizard(IRepositorySearchResult searchResult) {
 126                 super(searchResult);
 127                 setWindowTitle(UIText.GitImportWizard_WizardTitle);
 128                 setDefaultPageImageDescriptor(UIIcons.WIZBAN_IMPORT_REPO);
 129                 setDialogSettings(getImportWizardDialogSettings());
 130         }
 131
 132         @Override
 133         protected void addPreClonePages() {
 134                 if (!hasSearchResult())
 135                         addPage(selectRepoPage);
 136         }
 137
 138         @Override
 139         protected void addPostClonePages() {
 140                 addPage(importWithDirectoriesPage);
 141                 addPage(projectsImportPage);
 142                 addPage(createGeneralProjectPage);
 143         }
 144
 145         @Override
 146         protected List<CloneSourceProvider> getCloneSourceProviders() {
 147                 List<CloneSourceProvider> cloneSourceProvider = super.getCloneSourceProviders();
 148                 cloneSourceProvider.add(0, CloneSourceProvider.LOCAL);
 149                 return cloneSourceProvider;
 150         }
 151
 152         @Override
 153         public void init(IWorkbench workbench, IStructuredSelection selection) {
 154                 // nothing to do
 155         }
 156
 157         @Override
 158         public IWizardPage getNextPage(IWizardPage page) {
 159                 if (page == selectRepoPage) {
 160                         existingRepo = selectRepoPage.getRepository();
 161                         importWithDirectoriesPage.setRepository(selectRepoPage
 162                                         .getRepository());
 163                         return importWithDirectoriesPage;
 164                 } else if (page == cloneDestination) {
 165                         existingRepo = null;
 166                         importWithDirectoriesPage.setRepository(getTargetRepository());
 167                         return importWithDirectoriesPage;
 168                 } else if (page == importWithDirectoriesPage)
 169                         switch (importWithDirectoriesPage.getWizardSelection()) {
 170                         case GitSelectWizardPage.EXISTING_PROJECTS_WIZARD:
 171                                 return projectsImportPage;
 172                         case GitSelectWizardPage.NEW_WIZARD:
 173                                 return null;
 174                         case GitSelectWizardPage.GENERAL_WIZARD:
 175                                 return createGeneralProjectPage;
 176                         }
 177                 else if (page == createGeneralProjectPage
 178                                 || page == projectsImportPage)
 179                         return null;
 180                 return super.getNextPage(page);
 181         }
 182
 183         private Repository getTargetRepository() {
 184                 if (existingRepo != null)
 185                         return existingRepo;
 186                 else
 187                         try {
 188                                 return org.eclipse.egit.core.Activator
 189                                                 .getDefault()
 190                                                 .getRepositoryCache()
 191                                                 .lookupRepository(
 192                                                                 new File(cloneDestination.getDestinationFile(),
 193                                                                                 Constants.DOT_GIT));
 194                         } catch (IOException e) {
 195                                 Activator
 196                                                 .error("Error looking up repository at " + cloneDestination.getDestinationFile(), e); //$NON-NLS-1$
 197                                 return null;
 198                         }
 199         }
 200
 201         @Override
 202         public boolean performFinish() {
 203                 try {
 204                         getContainer().run(true, true, new IRunnableWithProgress() {
 205                                 @Override
 206                                 public void run(IProgressMonitor monitor)
 207                                                 throws InvocationTargetException, InterruptedException {
 208                                         importProjects(monitor);
 209                                 }
 210                         });
 211                 } catch (InvocationTargetException e) {
 212                         Activator
 213                                         .handleError(e.getCause().getMessage(), e.getCause(), true);
 214                         return false;
 215                 } catch (InterruptedException e) {
 216                         Activator.handleError(
 217                                         UIText.GitCreateProjectViaWizardWizard_AbortedMessage, e,
 218                                         true);
 219                         return false;
 220                 }
 221                 return true;
 222         }
 223
 224         @Override
 225         public boolean canFinish() {
 226                 switch (importWithDirectoriesPage.getWizardSelection()) {
 227                 case GitSelectWizardPage.EXISTING_PROJECTS_WIZARD:
 228                         return projectsImportPage.isPageComplete();
 229                 case GitSelectWizardPage.NEW_WIZARD:
 230                         return true;
 231                 case GitSelectWizardPage.GENERAL_WIZARD:
 232                         return createGeneralProjectPage.isPageComplete();
 233                 }
 234                 return super.canFinish();
 235
 236         }
 237
 238         private void importProjects(IProgressMonitor monitor)
 239                         throws InvocationTargetException, InterruptedException {
 240                 switch (importWithDirectoriesPage.getWizardSelection()) {
 241                 case GitSelectWizardPage.EXISTING_PROJECTS_WIZARD: {
 242                         final Set<ProjectRecord> projectsToCreate = new HashSet<>();
 243                         final List<IWorkingSet> workingSets = new ArrayList<>();
 244                         // get the data from the pages in the UI thread
 245                         PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
 246                                 @Override
 247                                 public void run() {
 248                                         projectsToCreate.addAll(projectsImportPage
 249                                                         .getCheckedProjects());
 250                                         IWorkingSet[] workingSetArray = projectsImportPage
 251                                                         .getSelectedWorkingSets();
 252                                         workingSets.addAll(Arrays.asList(workingSetArray));
 253                                         projectsImportPage.saveWidgetValues();
 254                                 }
 255                         });
 256                         ProjectUtils.createProjects(projectsToCreate,
 257                                         workingSets.toArray(new IWorkingSet[0]),
 258                                         monitor);
 259                         break;
 260                 }
 261                 case GitSelectWizardPage.NEW_WIZARD: {
 262                         final File[] repoDir = new File[1];
 263                         PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
 264                                 @Override
 265                                 public void run() {
 266                                         repoDir[0] = getTargetRepository().getDirectory();
 267                                 }
 268                         });
 269                         final List<IProject> previousProjects = Arrays
 270                                         .asList(ResourcesPlugin.getWorkspace().getRoot()
 271                                                         .getProjects());
 272                         PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
 273                                 @Override
 274                                 public void run() {
 275                                         new NewProjectAction(PlatformUI.getWorkbench()
 276                                                         .getActiveWorkbenchWindow()).run();
 277                                 }
 278                         });
 279                         IWorkspaceRunnable wsr = new IWorkspaceRunnable() {
 280                                 @Override
 281                                 public void run(IProgressMonitor actMonitor)
 282                                                 throws CoreException {
 283                                         IProject[] currentProjects = ResourcesPlugin.getWorkspace()
 284                                                         .getRoot().getProjects();
 285                                         SubMonitor progress = SubMonitor.convert(actMonitor,
 286                                                         currentProjects.length);
 287                                         for (IProject current : currentProjects)
 288                                                 if (!previousProjects.contains(current)) {
 289                                                         ConnectProviderOperation cpo = new ConnectProviderOperation(
 290                                                                         current, repoDir[0]);
 291                                                         cpo.execute(progress.newChild(1));
 292                                                 } else {
 293                                                         progress.worked(1);
 294                                                 }
 295                                 }
 296                         };
 297                         try {
 298                                 ResourcesPlugin.getWorkspace().run(wsr, monitor);
 299                         } catch (CoreException e) {
 300                                 throw new InvocationTargetException(e);
 301                         }
 302                         break;
 303                 }
 304                 case GitSelectWizardPage.GENERAL_WIZARD: {
 305                         final String[] projectName = new String[1];
 306                         final boolean[] defaultLocation = new boolean[1];
 307                         final String[] path = new String[1];
 308                         final File[] repoDir = new File[1];
 309                         // get the data from the page in the UI thread
 310                         PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
 311                                 @Override
 312                                 public void run() {
 313                                         projectName[0] = createGeneralProjectPage.getProjectName();
 314                                         defaultLocation[0] = createGeneralProjectPage
 315                                                         .isDefaultLocation();
 316                                         path[0] = importWithDirectoriesPage.getPath();
 317                                         repoDir[0] = getTargetRepository().getDirectory();
 318                                 }
 319                         });
 320                         try {
 321                                 IWorkspaceRunnable wsr = new IWorkspaceRunnable() {
 322                                         @Override
 323                                         public void run(IProgressMonitor actMonitor)
 324                                                         throws CoreException {
 325                                                 final IProjectDescription desc = ResourcesPlugin
 326                                                                 .getWorkspace().newProjectDescription(
 327                                                                                 projectName[0]);
 328                                                 desc.setLocation(new Path(path[0]));
 329                                                 SubMonitor progress = SubMonitor.convert(actMonitor, 4);
 330                                                 IProject prj = ResourcesPlugin.getWorkspace().getRoot()
 331                                                                 .getProject(desc.getName());
 332                                                 prj.create(desc, progress.newChild(1));
 333                                                 prj.open(progress.newChild(1));
 334                                                 ConnectProviderOperation cpo = new ConnectProviderOperation(
 335                                                                 prj, repoDir[0]);
 336                                                 cpo.execute(progress.newChild(1));
 337
 338                                                 ResourcesPlugin.getWorkspace().getRoot().refreshLocal(
 339                                                                 IResource.DEPTH_ONE, progress.newChild(1));
 340                                         }
 341                                 };
 342                                 ResourcesPlugin.getWorkspace().run(wsr, monitor);
 343                         } catch (CoreException e) {
 344                                 throw new InvocationTargetException(e);
 345                         }
 346                         break;
 347                 }
 348                 }
 349         }
 350
 351         static IDialogSettings getImportWizardDialogSettings() {
 352                 IDialogSettings settings = Activator.getDefault().getDialogSettings();
 353
 354                 IDialogSettings wizardSettings = settings
 355                                 .getSection(GitImportWizard.GIT_IMPORT_SECTION);
 356                 if (wizardSettings == null) {
 357                         wizardSettings = settings
 358                                         .addNewSection(GitImportWizard.GIT_IMPORT_SECTION);
 359                 }
 360                 return wizardSettings;
 361         }
 362 }