org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/reflog/ReflogViewContentProvider.java

   1 /*******************************************************************************
   2  * Copyright (c) 2011, 2017 Chris Aniszczyk <caniszczyk@gmail.com> 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  *   Chris Aniszczyk <caniszczyk@gmail.com> - initial implementation
  12  *   EclipseSource - Filtered Viewer
  13  *   Thomas Wolf <thomas.wolf@paranor.ch> - deferred loading
  14  *******************************************************************************/
  15 package org.eclipse.egit.ui.internal.reflog;
  16
  17 import java.io.File;
  18 import java.io.IOException;
  19 import java.util.Objects;
  20
  21 import org.eclipse.core.runtime.Assert;
  22 import org.eclipse.core.runtime.IProgressMonitor;
  23 import org.eclipse.core.runtime.jobs.IJobChangeEvent;
  24 import org.eclipse.core.runtime.jobs.ISchedulingRule;
  25 import org.eclipse.core.runtime.jobs.JobChangeAdapter;
  26 import org.eclipse.egit.ui.Activator;
  27 import org.eclipse.egit.ui.internal.UIText;
  28 import org.eclipse.jface.viewers.AbstractTreeViewer;
  29 import org.eclipse.jface.viewers.ITreeContentProvider;
  30 import org.eclipse.jface.viewers.Viewer;
  31 import org.eclipse.jgit.api.Git;
  32 import org.eclipse.jgit.lib.Repository;
  33 import org.eclipse.jgit.revwalk.RevWalk;
  34 import org.eclipse.swt.widgets.Control;
  35 import org.eclipse.ui.model.WorkbenchAdapter;
  36 import org.eclipse.ui.progress.DeferredTreeContentManager;
  37 import org.eclipse.ui.progress.IDeferredWorkbenchAdapter;
  38 import org.eclipse.ui.progress.IElementCollector;
  39
  40 /**
  41  * A content provider for reflog entries given a repository and a ref.
  42  */
  43 public class ReflogViewContentProvider implements ITreeContentProvider {
  44
  45         private DeferredTreeContentManager loader;
  46
  47         private Object currentInput;
  48
  49         /**
  50          * Serializes concurrent attempts to load the reflog.
  51          */
  52         private static class ReflogSchedulingRule implements ISchedulingRule {
  53
  54                 private final File gitDir;
  55
  56                 public ReflogSchedulingRule(File gitDir) {
  57                         this.gitDir = gitDir;
  58                 }
  59
  60                 @Override
  61                 public boolean contains(ISchedulingRule rule) {
  62                         if (rule instanceof ReflogSchedulingRule) {
  63                                 return Objects.equals(gitDir,
  64                                                 ((ReflogSchedulingRule) rule).gitDir);
  65                         }
  66                         return false;
  67                 }
  68
  69                 @Override
  70                 public boolean isConflicting(ISchedulingRule rule) {
  71                         return rule instanceof ReflogSchedulingRule;
  72                 }
  73
  74         }
  75
  76         private static final WorkbenchAdapter ERROR_ELEMENT = new WorkbenchAdapter() {
  77
  78                 @Override
  79                 public String getLabel(Object object) {
  80                         return UIText.ReflogView_ErrorOnLoad;
  81                 }
  82         };
  83
  84
  85         /**
  86          * Input class for this content provider.
  87          */
  88         public static class ReflogInput extends WorkbenchAdapter
  89                         implements IDeferredWorkbenchAdapter {
  90
  91                 private final Repository repository;
  92
  93                 private final String ref;
  94
  95                 private final ISchedulingRule rule;
  96
  97                 private ReflogItem[] refLog;
  98
  99                 /**
 100                  * Create input with non-null repository and non-null ref
 101                  *
 102                  * @param repository
 103                  * @param ref
 104                  */
 105                 public ReflogInput(Repository repository, String ref) {
 106                         Assert.isNotNull(repository, "Repository cannot be null"); //$NON-NLS-1$
 107                         Assert.isNotNull(ref, "Ref cannot be null"); //$NON-NLS-1$
 108                         this.repository = repository;
 109                         this.ref = ref;
 110                         this.rule = new ReflogSchedulingRule(repository.getDirectory());
 111                 }
 112
 113                 /**
 114                  * Get repository
 115                  *
 116                  * @return repository
 117                  */
 118                 public Repository getRepository() {
 119                         return repository;
 120                 }
 121
 122                 /**
 123                  * Retrieves the ref.
 124                  *
 125                  * @return the ref
 126                  */
 127                 public String getRef() {
 128                         return ref;
 129                 }
 130
 131                 @Override
 132                 public Object[] getChildren(Object o) {
 133                         if (refLog != null) {
 134                                 return refLog;
 135                         }
 136                         return null;
 137                 }
 138
 139                 @Override
 140                 public void fetchDeferredChildren(Object object,
 141                                 IElementCollector collector, IProgressMonitor monitor) {
 142                         if (refLog != null) {
 143                                 return; // Already loaded.
 144                         }
 145                         try (Git git = new Git(repository);
 146                                         RevWalk walk = new RevWalk(repository)) {
 147                                 refLog = git.reflog().setRef(ref).call().stream()
 148                                                 .map(entry -> {
 149                                                         String commitMessage = null;
 150                                                         try {
 151                                                                 commitMessage = walk
 152                                                                                 .parseCommit(entry.getNewId())
 153                                                                                 .getShortMessage();
 154                                                         } catch (IOException e) {
 155                                                                 // Ignore here
 156                                                         }
 157                                                         return new ReflogItem(ReflogInput.this, entry,
 158                                                                         commitMessage);
 159                                                 })
 160                                                 .toArray(ReflogItem[]::new);
 161                                 collector.add(refLog, monitor);
 162                         } catch (Exception e) {
 163                                 Activator.logError("Error running reflog command", e); //$NON-NLS-1$
 164                                 collector.add(ERROR_ELEMENT, monitor);
 165                         }
 166                 }
 167
 168                 @Override
 169                 public boolean isContainer() {
 170                         return true;
 171                 }
 172
 173                 @Override
 174                 public ISchedulingRule getRule(Object object) {
 175                         return rule;
 176                 }
 177         }
 178
 179         @Override
 180         public Object[] getElements(Object inputElement) {
 181                 return getChildren(inputElement);
 182         }
 183
 184         @Override
 185         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 186                 if (oldInput != null && loader != null) {
 187                         loader.cancel(oldInput);
 188                 }
 189                 currentInput = newInput;
 190                 if (viewer instanceof AbstractTreeViewer && newInput != null) {
 191                         loader = new DeferredBatchLoader((AbstractTreeViewer) viewer);
 192                         loader.addUpdateCompleteListener(new JobChangeAdapter() {
 193
 194                                 @Override
 195                                 public void done(IJobChangeEvent event) {
 196                                         if (event.getResult().isOK()) {
 197                                                 // Force a selection event
 198                                                 viewer.setSelection(viewer.getSelection());
 199                                         }
 200                                 }
 201                         });
 202                 }
 203         }
 204
 205         @Override
 206         public void dispose() {
 207                 if (currentInput != null && loader != null) {
 208                         loader.cancel(currentInput);
 209                 }
 210                 currentInput = null;
 211                 loader = null;
 212         }
 213
 214         @Override
 215         public Object[] getChildren(Object parentElement) {
 216                 if (parentElement instanceof ReflogInput && loader != null) {
 217                         Object[] knownChildren = ((ReflogInput) parentElement)
 218                                         .getChildren(parentElement);
 219                         if (knownChildren != null) {
 220                                 return knownChildren;
 221                         }
 222                         return loader.getChildren(parentElement);
 223                 }
 224                 return new Object[0];
 225         }
 226
 227         @Override
 228         public Object getParent(Object element) {
 229                 return null;
 230         }
 231
 232         @Override
 233         public boolean hasChildren(Object element) {
 234                 return false;
 235         }
 236
 237         /**
 238          * A variant of {@link DeferredTreeContentManager} that doesn't use a
 239          * separate UI job to fill in the tree. With UI jobs, it's simply impossible
 240          * to know what has already been added when there are several loading jobs.
 241          * For our use case (load the whole reflog, then add it to the tree) a
 242          * {@link org.eclipse.swt.widgets.Display#syncExec(Runnable) syncExec()} is
 243          * sufficient.
 244          */
 245         private static class DeferredBatchLoader
 246                         extends DeferredTreeContentManager {
 247
 248                 private AbstractTreeViewer viewer;
 249
 250                 public DeferredBatchLoader(AbstractTreeViewer viewer) {
 251                         super(viewer);
 252                         this.viewer = viewer;
 253                 }
 254
 255                 /**
 256                  * Add child nodes, removing the error element if appropriate. Contrary
 257                  * to the super implementation, this does <em>not</em> use a UI job but
 258                  * a simple {@link org.eclipse.swt.widgets.Display#syncExec(Runnable)
 259                  * syncExec()}.
 260                  *
 261                  * @param parent
 262                  *            to add the {@code children} to
 263                  * @param children
 264                  *            to add to the {@code parent}
 265                  * @param monitor
 266                  *            is ignored
 267                  */
 268                 @Override
 269                 protected void addChildren(Object parent, Object[] children,
 270                                 IProgressMonitor monitor) {
 271                         Control control = viewer.getControl();
 272                         if (control == null || control.isDisposed()) {
 273                                 return;
 274                         }
 275                         control.getDisplay().syncExec(() -> {
 276                                 if (!control.isDisposed()) {
 277                                         try {
 278                                                 control.setRedraw(false);
 279                                                 if (children.length != 1
 280                                                                 || children[0] != ERROR_ELEMENT) {
 281                                                         viewer.remove(ERROR_ELEMENT);
 282                                                 }
 283                                                 viewer.add(parent, children);
 284                                         } finally {
 285                                                 control.setRedraw(true);
 286                                         }
 287                                 }
 288                         });
 289                 }
 290         }
 291 }