org.spearce.egit.core/src/org/spearce/egit/core/internal/UpdateJob.java

   1 /*
   2  *  Copyrighy (C) 2007  Robin Rosenberg
   3  *
   4  *  This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Lesser General Public
   6  *  License, version 2.1, as published by the Free Software Foundation.
   7  *
   8  *  This library is distributed in the hope that it will be useful,
   9  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  *  Lesser General Public License for more details.
  12  *
  13  *  You should have received a copy of the GNU Lesser General Public
  14  *  License along with this library; if not, write to the Free Software
  15  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  16  */
  17 package org.spearce.egit.core.internal;
  18
  19 import java.io.File;
  20 import java.io.IOException;
  21 import java.util.Collection;
  22 import java.util.IdentityHashMap;
  23 import java.util.Iterator;
  24
  25 import org.eclipse.core.resources.IContainer;
  26 import org.eclipse.core.resources.IProject;
  27 import org.eclipse.core.resources.IResource;
  28 import org.eclipse.core.resources.IResourceProxy;
  29 import org.eclipse.core.resources.IResourceProxyVisitor;
  30 import org.eclipse.core.resources.IResourceVisitor;
  31 import org.eclipse.core.runtime.CoreException;
  32 import org.eclipse.core.runtime.IProgressMonitor;
  33 import org.eclipse.core.runtime.IStatus;
  34 import org.eclipse.core.runtime.NullProgressMonitor;
  35 import org.eclipse.core.runtime.Status;
  36 import org.eclipse.core.runtime.jobs.Job;
  37 import org.spearce.egit.core.Activator;
  38 import org.spearce.egit.core.CoreText;
  39 import org.spearce.egit.core.project.GitProjectData;
  40 import org.spearce.egit.core.project.RepositoryMapping;
  41 import org.spearce.jgit.lib.GitIndex;
  42 import org.spearce.jgit.lib.GitIndex.Entry;
  43
  44 public class UpdateJob extends Job {
  45
  46         private final Collection rsrcList;
  47
  48         public UpdateJob(Collection rsrcList) {
  49                 super("Update index");
  50                 this.rsrcList = rsrcList;
  51                 setPriority(Job.LONG);
  52         }
  53
  54         protected IStatus run(IProgressMonitor m) {
  55                 if (m == null) {
  56                         m = new NullProgressMonitor();
  57                 }
  58
  59                 trace("running");
  60                 try {
  61                         final IdentityHashMap<RepositoryMapping, Boolean> tomerge = new IdentityHashMap<RepositoryMapping, Boolean>();
  62                         try {
  63                                 final int[] count=new int[1];
  64                                 long t0=System.currentTimeMillis();
  65                                 for (Object obj : rsrcList) {
  66                                         if (obj instanceof IContainer) {
  67                                                 ((IContainer)obj).accept(new IResourceProxyVisitor() {
  68                                                         public boolean visit(IResourceProxy rp) throws CoreException {
  69                                                                 if (rp.getType() == IResource.FILE) {
  70                                                                         count[0]++;
  71                                                                 }
  72                                                                 return true;
  73                                                         }
  74                                                 }, IContainer.EXCLUDE_DERIVED);
  75                                         } else if (obj instanceof IResource) {
  76                                                         count[0]++;
  77                                         }
  78                                 }
  79                                 long t1=System.currentTimeMillis();
  80                                 System.out.println("Counted "+count[0]+" items to update in "+(t1-t0)/1000.0+"s");
  81                                 m.beginTask(CoreText.UpdateOperation_updating, count[0]);
  82                                 final IProgressMonitor fm = m;
  83                                 for (Object obj : rsrcList) {
  84                                         if (obj instanceof IResource) {
  85                                                 final IResource r = (IResource)obj;
  86                                                 final IProject p = r.getProject();
  87                                                 final GitProjectData pd = GitProjectData.get(r.getProject());
  88                                                 final RepositoryMapping rm = pd.getRepositoryMapping(p);
  89                                                 final GitIndex index = rm.getRepository().getIndex();
  90                                                 tomerge.put(rm, Boolean.TRUE);
  91                                                 String prefix = rm.getSubset();
  92                                                 if (prefix == null)
  93                                                         prefix = "";
  94                                                 else
  95                                                         prefix = prefix + "/";
  96                                                 final String fprefix = prefix;
  97                                                 if (r instanceof IContainer) {
  98                                                         ((IContainer)r).accept(new IResourceVisitor() {
  99                                                                 public boolean visit(IResource resource) throws CoreException {
 100                                                                         try {
 101                                                                                 if (resource.getType() == IResource.FILE) {
 102                                                                                         String path = fprefix + resource.getProjectRelativePath();
 103                                                                                         Entry entry = index.getEntry(path);
 104                                                                                         if (entry != null) {
 105                                                                                                 entry.update(new File(rm.getWorkDir(),path), rm.getRepository());
 106                                                                                         }
 107                                                                                         fm.worked(1);
 108                                                                                 }
 109                                                                         } catch (IOException e) {
 110                                                                                 e.printStackTrace();
 111                                                                                 throw Activator.error(CoreText.UpdateOperation_failed, e);
 112                                                                         }
 113                                                                         return true;
 114                                                                 }
 115                                                         },IResource.DEPTH_INFINITE, IContainer.EXCLUDE_DERIVED);
 116                                                 } else {
 117                                                         String path = fprefix + r.getProjectRelativePath();
 118                                                         Entry entry = index.getEntry(path);
 119                                                         if (entry != null) {
 120                                                                 entry.update(new File(rm.getWorkDir(),path), rm.getRepository());
 121                                                         }
 122                                                         m.worked(1);
 123                                                 }
 124                                         }
 125                                 }
 126                                 for (RepositoryMapping rm : tomerge.keySet()) {
 127                                         m.setTaskName("Writing index for "+rm.getRepository().getDirectory());
 128                                         rm.getRepository().getIndex().write();
 129                                 }
 130                         } catch (RuntimeException e) {
 131                                 e.printStackTrace();
 132                                 return Activator.error(CoreText.UpdateOperation_failed, e).getStatus();
 133                         } catch (IOException e) {
 134                                 e.printStackTrace();
 135                                 return Activator.error(CoreText.UpdateOperation_failed, e).getStatus();
 136                         } catch (CoreException e) {
 137                                 e.printStackTrace();
 138                                 return Activator.error(CoreText.UpdateOperation_failed, e).getStatus();
 139                         } finally {
 140                                 try {
 141                                         final Iterator i = tomerge.keySet().iterator();
 142                                         while (i.hasNext()) {
 143                                                 final RepositoryMapping r = (RepositoryMapping) i.next();
 144                                                 r.getRepository().getIndex().read();
 145                                                 r.recomputeMerge();
 146                                         }
 147                                 } catch (IOException e) {
 148                                         e.printStackTrace();
 149                                 } finally {
 150                                         m.done();
 151                                 }
 152                         }
 153                 } finally {
 154                         trace("done");
 155                         m.done();
 156                 }
 157
 158                 return Status.OK_STATUS;
 159         }
 160
 161         private void trace(final String m) {
 162                 Activator.trace("(UpdateJob)"+m);
 163         }
 164
 165 }