Public Git Hosting - EMFCompare2.git/blob - plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/logical/resolver/ThreadedModelResolver.java

1 /*******************************************************************************

4 * are made available under the terms of the Eclipse Public License v1.0

5 * which accompanies this distribution, and is available at

6 * http://www.eclipse.org/legal/epl-v10.html

8 * Contributors:

9 * Obeo - initial API and implementation

10 *******************************************************************************/

package org.eclipse.emf.compare.ide.ui.internal.logical.resolver;

import static com.google.common.collect.Sets.difference;

import static com.google.common.collect.Sets.intersection;

import static org.eclipse.emf.compare.ide.ui.internal.util.PlatformElementUtil.adaptAs;

import static org.eclipse.emf.compare.ide.utils.ResourceUtil.createURIFor;

import static org.eclipse.emf.compare.ide.utils.ResourceUtil.hasModelType;

import com.google.common.base.Function;

import com.google.common.base.Predicate;

import com.google.common.collect.ImmutableSet;

import com.google.common.collect.Iterables;

import com.google.common.collect.Sets;

import com.google.common.util.concurrent.FutureCallback;

import com.google.common.util.concurrent.Futures;

import com.google.common.util.concurrent.ListenableFuture;

import com.google.common.util.concurrent.ListeningExecutorService;

import com.google.common.util.concurrent.MoreExecutors;

import com.google.common.util.concurrent.ThreadFactoryBuilder;

31 import java.util.Collections;

32 import java.util.HashSet;

33 import java.util.LinkedHashSet;

34 import java.util.List;

35 import java.util.Set;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.ThreadFactory;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IResourceChangeEvent;

import org.eclipse.core.resources.IResourceChangeListener;

import org.eclipse.core.resources.IResourceDelta;

import org.eclipse.core.resources.IResourceDeltaVisitor;

import org.eclipse.core.resources.IResourceVisitor;

import org.eclipse.core.resources.IStorage;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.OperationCanceledException;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.SubMonitor;

import org.eclipse.emf.common.util.BasicDiagnostic;

import org.eclipse.emf.common.util.Diagnostic;

import org.eclipse.emf.common.util.URI;

import org.eclipse.emf.compare.ide.ui.internal.EMFCompareIDEUIMessages;

import org.eclipse.emf.compare.ide.ui.internal.EMFCompareIDEUIPlugin;

import org.eclipse.emf.compare.ide.ui.internal.preferences.EMFCompareUIPreferences;

import org.eclipse.emf.compare.ide.ui.internal.util.ThreadSafeProgressMonitor;

import org.eclipse.emf.compare.ide.ui.logical.AbstractModelResolver;

import org.eclipse.emf.compare.ide.ui.logical.IModelResolver;

import org.eclipse.emf.compare.ide.ui.logical.IStorageProviderAccessor;

import org.eclipse.emf.compare.ide.ui.logical.IStorageProviderAccessor.DiffSide;

import org.eclipse.emf.compare.ide.ui.logical.SynchronizationModel;

import org.eclipse.emf.compare.ide.utils.ResourceUtil;

import org.eclipse.emf.compare.ide.utils.StorageTraversal;

import org.eclipse.emf.compare.ide.utils.StorageURIConverter;

import org.eclipse.emf.ecore.resource.Resource;

import org.eclipse.emf.ecore.util.EcoreUtil;

import org.eclipse.jface.preference.IPreferenceStore;

79 /**

80 * This implementation of an {@link IModelResolver} will look up all of the models located in a set container

81 * level of the "starting point" (by default, the containing project) to construct the graph of dependencies

82 * between these models.

83 *

84 * Once this graph is created for the "local" resource, the right and origin (if any) resources will be

85 * inferred from the same traversal of resources, though this time expanded with a "top-down" approach : load

86 * all models of the traversal from the remote side, then resolve their containment tree to check whether

87 * there are other remote resources in the logical model that do not (or "that no longer) exist locally and

88 * thus couldn't be discovered in the first resolution phase.

89 *

90 *

91 * All model loading will happen concurrently. At first, a distinct thread will be launched to resolve every

92 * model discovered in the container we're browsing. Then, each thread can and will launch separate threads to

93 * resolve the set of dependencies discovered "under" the model they are in charge of resolving.

94 *

95 *

96 * No model will be loaded twice, since this will be aware of what models have already been resolved, thus

97 * ignoring duplicate resolving demands.

98 *

99 *

100 * @author <a href="mailto:laurent.goubet@obeo.fr">Laurent Goubet</a>

101 */

102 public class ThreadedModelResolver extends AbstractModelResolver {

103

104 /** This can be used in order to convert an Iterable of IStorages to an Iterable over the storage's URIs. */

        private static final Function<IStorage, URI> AS_URI = new Function<IStorage, URI>() {

106 public URI apply(IStorage input) {

                        if (input != null) {

108 return createURIFor(input);

109 }

110 return null;

111 }

112 };

113

114 /**

115 * Keeps track of the discovered dependency graph for local resources.

116 *

117 * Model resolvers are created from the extension point registry, so we know there will be a single

118 * instance of our resolver for a single run of Eclipse (even across multiple comparisons). We also assume

119 * that this graph won't turn to be a memory hog since we're only keeping track of URIs, and at the worst

120 * no more URIs than there are resources in the user's workspace. We can thus keep this graph around to

121 * avoid multiple crawlings of the same models. Team, as well as the EMFResourceMapping, tend to be

122 * over-enthusiast with the resolution of model traversals. For example, a single

123 * "right-click -> compare with -> commit..." with EGit ends up calling 8 distinct times for the resource

124 * traversal of the selected resource.

125 *

126 */

127 private final Graph<URI> dependencyGraph;

128

129 /**

130 * We'll keep track of what's already been resolved to avoid duplicate jobs.

131 */

132 private Set<URI> resolvedResources;

133

134 /**

135 * Will keep track of any error or warning that can arise during the loading of the resources.

136 */

137 private BasicDiagnostic diagnostic;

138

139 /**

140 * Keeps track of the URIs which we are currently resolving (or which are queued for resolution).

141 *

142 * This along with {@link #resolvedResources} will prevent multiple "duplicate" resolution threads to be

143 * queued. We assume that this will be sufficient to prevent duplicates, and the resolution threads

144 * themselves won't check whether their target has already been resolved before starting.

145 *

146 */

147 private final Set<URI> currentlyResolving;

148

149 /** Thread pool for our resolving threads. */

150 private ListeningExecutorService resolvingPool;

151

152 /** Thread pool for our unloading threads. */

153 private ListeningExecutorService unloadingPool;

154

155 /**

156 * An executor service will be used to shut down the {@link #unloadingPool} and the {@link #resolvingPool}

157 * .

158 */

159 private ListeningExecutorService terminator;

160

161 /** Tracks if shutdown of {@link #unloadingPool} and {@link #resolvingPool} is currently in progress. */

162 private final AtomicBoolean shutdownInProgress;

163

164 /**

165 * This will lock will prevent concurrent modifications of this resolver's fields. Most notably,

166 * {@link #currentlyResolving}, {@link #resolvedResources} and {@link #diagnostic} must not be accessed

167 * concurrently by two threads at once.

168 */

169 private final ReentrantLock lock;

170

171 /**

172 * This resolver will not accept two model resolutions at once.

173 *

174 * Any thread trying to call a model resolution process through either of the three "resolve*" APIs will

175 * have to wait for this condition to be true before starting.

176 *

177 */

178 private final Condition notResolving;

179

180 /** Condition to await for all current {@link ResourceResolver} threads to terminate. */

181 private final Condition resolutionEnd;

182

183 /**

184 * This resolver will keep a resource listener over the workspace in order to keep its dependencies graph

185 * in sync.

186 *

187 * We're building the dependency graph on-demand and keep it around between invocations. This listener

188 * will allow us to update the graph on-demand by keeping track of the removed and changed resources since

189 * we were last called.

190 *

191 */

192 private ModelResourceListener resourceListener;

193

194 /** Default constructor. */

195 public ThreadedModelResolver() {

                this.dependencyGraph = new Graph<URI>();

                this.lock = new ReentrantLock(true);

                this.notResolving = lock.newCondition();

                this.resolutionEnd = lock.newCondition();

                this.currentlyResolving = new HashSet<URI>();

                this.shutdownInProgress = new AtomicBoolean(false);

202 }

203

204 /**

205 * Creates the thread pools of this resolver. We cannot keep pools between resolving call because in case

206 * of cancellation, we have to shutdown the pool to exit early.

207 */

208 private void createThreadPools() {

                final int availableProcessors = Runtime.getRuntime().availableProcessors();

                ThreadFactory resolvingThreadFactory = new ThreadFactoryBuilder().setNameFormat(

211 "EMFCompare-ResolvingThread-%d") //$NON-NLS-1$

212 .build();

                this.resolvingPool = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(

214 availableProcessors, resolvingThreadFactory));

                ThreadFactory unloadingThreadFactory = new ThreadFactoryBuilder().setNameFormat(

216 "EMFCompare-UnloadingThread-%d") //$NON-NLS-1$

217 .build();

                this.unloadingPool = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(

219 availableProcessors, unloadingThreadFactory));

220 }

221

222 /**

223 * {@inheritDoc}

224 */

225 @Override

226 public void initialize() {

                this.resourceListener = new ModelResourceListener();

                ResourcesPlugin.getWorkspace().addResourceChangeListener(resourceListener);

229

                this.terminator = MoreExecutors.listeningDecorator(Executors

                                .newSingleThreadExecutor(new ThreadFactoryBuilder().setNameFormat(

                                                "EMFCompare-ThreadPoolShutdowner-%d").setPriority(Thread.MAX_PRIORITY).build())); //$NON-NLS-1$

233 }

234

235 /** {@inheritDoc} */

236 @Override

237 public void dispose() {

238 terminator.shutdown();

                ResourcesPlugin.getWorkspace().removeResourceChangeListener(resourceListener);

240 super.dispose();

241 }

242

243 /**

244 * Shutdown {@link #resolvingPool} and {@link #unloadingPool} and set these two fields to null.

245 */

246 private void shutdownPools() {

                if (!shutdownAndAwaitTermination(resolvingPool) || !shutdownAndAwaitTermination(unloadingPool)) {

                        EMFCompareIDEUIPlugin.getDefault().log(IStatus.WARNING,

249 "Thread pools have not been properly stopped"); //$NON-NLS-1$

250 }

251 resolvingPool = null;

252 unloadingPool = null;

253 }

254

255 /**

256 * Shuts down an {@link ExecutorService} in two phases, first by calling

257 * {@link ExecutorService#shutdown() shutdown} to reject incoming tasks, and then calling

258 * {@link ExecutorService#shutdownNow() shutdownNow}, if necessary, to cancel any lingering tasks. Returns

259 * true if the pool has been properly shutdown, false otherwise.

260 *

261 * Copy/pasted from {@link ExecutorService} javadoc.

262 *

263 * @param pool

264 * the pool to shutdown

265 * @return true if the pool has been properly shutdown, false otherwise.

266 */

267 private static boolean shutdownAndAwaitTermination(ExecutorService pool) {

268 boolean ret = true;

269 pool.shutdown(); // Disable new tasks from being submitted

270 try {

271 // Wait a while for existing tasks to terminate

                        if (!pool.awaitTermination(5, TimeUnit.SECONDS)) {

273 pool.shutdownNow(); // Cancel currently executing tasks

274 // Wait a while for tasks to respond to being canceled

                                if (!pool.awaitTermination(5, TimeUnit.SECONDS)) {

276 ret = false;

277 }

278 }

279 } catch (InterruptedException ie) {

280 // (Re-)Cancel if current thread also interrupted

281 pool.shutdownNow();

282 // Preserve interrupt status

                        Thread.currentThread().interrupt();

284 ret = false;

285 }

286 return ret;

287 }

288

289 /** {@inheritDoc} */

290 public boolean canResolve(IStorage sourceStorage) {

291 return true;

292 }

293

294 /**

295 * {@inheritDoc}

296 *

297 * Note that no two threads will be able to resolve models at once : all three "resolve*" methods will

298 * lock internally to prevent multiple resolutions at once. Though this shouldn't happen unless the user

299 * calls multiple comparisons one after the other in quick succession, we use this locking to prevent

300 * potential unforeseen interactions.

301 *

302 */

        public StorageTraversal resolveLocalModel(IResource start, IProgressMonitor monitor)

304 throws InterruptedException {

305 if (!(start instanceof IFile)) {

                        return new StorageTraversal(new LinkedHashSet<IStorage>());

307 }

308

309 ThreadSafeProgressMonitor subMonitor = null;

310 lock.lockInterruptibly();

311 try {

                        subMonitor = new ThreadSafeProgressMonitor(SubMonitor.convert(monitor, 100));

                        while (!currentlyResolving.isEmpty()) {

314 notResolving.await();

315 }

316

317 setupResolving();

318

                        if (getResolutionScope() != CrossReferenceResolutionScope.SELF) {

                                final SynchronizedResourceSet resourceSet = new SynchronizedResourceSet();

                                updateDependencies(resourceSet, (IFile)start, subMonitor);

322 updateChangedResources(resourceSet, subMonitor);

323 }

324

                        while (!currentlyResolving.isEmpty()) {

326 resolutionEnd.await();

327 }

328

                        if (subMonitor.isCanceled()) {

330 throw new OperationCanceledException();

331 }

332

                        final Set<IStorage> traversalSet = resolveTraversal((IFile)start, Collections.<URI> emptySet());

                        StorageTraversal traversal = new StorageTraversal(traversalSet, diagnostic);

335

336 return traversal;

337 } finally {

338 try {

339 finalizeResolving();

340

                                if (subMonitor != null) {

                                        subMonitor.setWorkRemaining(0);

343 }

344 } finally {

345 notResolving.signal();

346 lock.unlock();

347 }

348 }

349 }

350

351 /**

352 * {@inheritDoc}

353 *

354 * Note that no two threads will be able to resolve models at once : all three "resolve*" methods will

355 * lock internally to prevent multiple resolutions at once. Though this shouldn't happen unless the user

356 * calls multiple comparisons one after the other in quick succession, we use this locking to prevent

357 * potential unforeseen interactions.

358 *

359 */

        public SynchronizationModel resolveLocalModels(IResource left, IResource right, IResource origin,

361 IProgressMonitor monitor) throws InterruptedException {

362

                ThreadSafeProgressMonitor subMonitor = new ThreadSafeProgressMonitor(SubMonitor.convert(monitor, 100));

364 try {

                        if (!(left instanceof IFile && right instanceof IFile && (origin == null || origin instanceof IFile))) {

                                return resolveNonFileLocalModels(left, right, origin, subMonitor);

367 } else {

                                return resolveFileLocalModel(left, right, origin, subMonitor);

369 }

370 } finally {

                        subMonitor.setWorkRemaining(0);

372 }

373 }

374

        private SynchronizationModel resolveNonFileLocalModels(IResource left, IResource right, IResource origin,

376 ThreadSafeProgressMonitor subMonitor) throws InterruptedException {

377 // Sub-optimal implementation, we'll only try and resolve each side individually

                final StorageTraversal leftTraversal = resolveLocalModel(left, subMonitor);

                final StorageTraversal rightTraversal = resolveLocalModel(right, subMonitor);

380 final StorageTraversal originTraversal;

                if (origin != null) {

                        originTraversal = resolveLocalModel(origin, subMonitor);

383 } else {

                        originTraversal = new StorageTraversal(Sets.<IStorage> newLinkedHashSet());

385 }

386

                return new SynchronizationModel(leftTraversal, rightTraversal, originTraversal);

388 }

389

        private SynchronizationModel resolveFileLocalModel(IResource left, IResource right, IResource origin,

391 ThreadSafeProgressMonitor monitor) throws InterruptedException {

392

393 lock.lockInterruptibly();

394 try {

                        while (!currentlyResolving.isEmpty()) {

396 notResolving.await();

397 }

398

399 setupResolving();

400

                        if (getResolutionScope() != CrossReferenceResolutionScope.SELF) {

                                final SynchronizedResourceSet resourceSet = new SynchronizedResourceSet();

                                updateDependencies(resourceSet, (IFile)left, monitor);

                                updateDependencies(resourceSet, (IFile)right, monitor);

405 if (origin instanceof IFile) {

                                        updateDependencies(resourceSet, (IFile)origin, monitor);

407 }

408 updateChangedResources(resourceSet, monitor);

409 }

410

                        final URI leftURI = createURIFor((IFile)left);

                        final URI rightURI = createURIFor((IFile)right);

413 final URI originURI;

414 final Set<IFile> startingPoints;

415 if (origin instanceof IFile) {

                                startingPoints = ImmutableSet.of((IFile)left, (IFile)right, (IFile)origin);

                                originURI = createURIFor((IFile)origin);

418 } else {

                                startingPoints = ImmutableSet.of((IFile)left, (IFile)right);

420 originURI = null;

421 }

422

                        while (!currentlyResolving.isEmpty()) {

424 resolutionEnd.await();

425 }

426

                        if (monitor.isCanceled()) {

428 throw new OperationCanceledException();

429 }

430

431 final Set<IStorage> leftTraversal;

432 final Set<IStorage> rightTraversal;

433 final Set<IStorage> originTraversal;

434 if (origin instanceof IFile) {

                                leftTraversal = resolveTraversal((IFile)left, ImmutableSet.of(rightURI, originURI));

                                rightTraversal = resolveTraversal((IFile)right, ImmutableSet.of(leftURI, originURI));

                                originTraversal = resolveTraversal((IFile)origin, ImmutableSet.of(leftURI, rightURI));

438 } else {

                                leftTraversal = resolveTraversal((IFile)left, Collections.singleton(rightURI));

                                rightTraversal = resolveTraversal((IFile)right, Collections.singleton(leftURI));

441 originTraversal = Collections.emptySet();

442 }

443

444 /*

445 * If one resource of the logical model was pointing to both (or "all three") of our starting

446 * elements, we'll have way too many things in our traversal. We need to remove the intersection

447 * before going any further.

448 */

                        Set<IStorage> intersection = intersection(leftTraversal, rightTraversal);

                        if (!originTraversal.isEmpty()) {

                                intersection = intersection(intersection, originTraversal);

452 }

                        logCoherenceThreats(Iterables.transform(startingPoints, AS_URI), Iterables.transform(

454 intersection, AS_URI));

455

                        final Set<IStorage> actualLeft = new LinkedHashSet<IStorage>(difference(leftTraversal,

457 intersection));

                        final Set<IStorage> actualRight = new LinkedHashSet<IStorage>(difference(rightTraversal,

459 intersection));

                        final Set<IStorage> actualOrigin = new LinkedHashSet<IStorage>(difference(originTraversal,

461 intersection));

                        final SynchronizationModel synchronizationModel = new SynchronizationModel(new StorageTraversal(

                                        actualLeft), new StorageTraversal(actualRight), new StorageTraversal(actualOrigin),

464 diagnostic);

465

466 return synchronizationModel;

467 } finally {

468 try {

469 finalizeResolving();

470 } finally {

471 notResolving.signal();

472 lock.unlock();

473 }

474 }

475 }

476

477 /**

478 * {@inheritDoc}

479 *

480 * Note that no two threads will be able to resolve models at once : all three "resolve*" methods will

481 * lock internally to prevent multiple resolutions at once. Though this shouldn't happen unless the user

482 * calls multiple comparisons one after the other in quick succession, we use this locking to prevent

483 * potential unforeseen interactions.

484 *

485 */

        public SynchronizationModel resolveModels(IStorageProviderAccessor storageAccessor, IStorage left,

                        IStorage right, IStorage origin, IProgressMonitor monitor) throws InterruptedException {

488

489 ThreadSafeProgressMonitor subMonitor = null;

490 lock.lockInterruptibly();

491 try {

                        subMonitor = new ThreadSafeProgressMonitor(SubMonitor.convert(monitor, 100));

493

                        while (!currentlyResolving.isEmpty()) {

495 notResolving.await();

496 }

497

498 setupResolving();

499

                        final IFile leftFile = adaptAs(left, IFile.class);

501

502 /*

503 * If we have a local side to this comparison, resolve it first, then use this result to infer the

504 * remote sides' traversal. Otherwise, resolve all three side in a simple top-down approach.

505 */

506 final SynchronizationModel synchronizationModel;

                        if (leftFile != null) {

                                synchronizationModel = resolveModelsWithLocal(storageAccessor, leftFile, right, origin,

509 subMonitor);

510 } else {

                                synchronizationModel = resolveRemoteModels(storageAccessor, left, right, origin, subMonitor);

512 }

513

514 return synchronizationModel;

515 } finally {

516 try {

517 finalizeResolving();

518

                                if (subMonitor != null) {

                                        subMonitor.setWorkRemaining(0);

521 }

522 } finally {

523 notResolving.signal();

524 lock.unlock();

525 }

526 }

527 }

528

529 /**

530 * This should be call before starting any model resolution but it must not be call if another resolution

531 * is already running (i.e. it must be call after an {@link #notResolving}.await()).

532 */

533 private void setupResolving() {

534 createThreadPools();

535 resolvedResources = new LinkedHashSet<URI>();

                diagnostic = new BasicDiagnostic(EMFCompareIDEUIPlugin.PLUGIN_ID, 0, null, new Object[0]);

537 }

538

539 /**

540 * This is the counterpart of the {@link #setupResolving()} method. This should be called in a finally

541 * block everywhere {@link #setupResolving()} is called.

542 */

543 private void finalizeResolving() {

                if (!shutdownInProgress.get()) {

545 shutdownPools();

546 }

547

                if (diagnostic.getSeverity() >= Diagnostic.ERROR) {

549 // something bad (or a cancel request) happened during resolution, so we invalidate the

550 // dependency graph to avoid weird behavior next time the resolution is called.

551 dependencyGraph.clear();

552 }

553

554 resolvedResources = null;

555 diagnostic = null;

556 }

557

558 /**

559 * The 'left' model we've been fed is a local file. We'll assume that the whole 'left' side of this

560 * comparison is local and resolve everything for that side as we would for local comparisons : update the

561 * dependency graph according to our resource listener, lookup for cross-references to/from the left

562 * resource according to the {@link #getResolutionScope() resolution scope}... Once we've resolved the

563 * local traversal, we'll use that as a base to infer the two remote sides, then "augment" it with the

564 * outgoing references of the remote variants of these resources.

565 *

566 * @param storageAccessor

567 * The accessor that can be used to retrieve synchronization information between our resources.

568 * @param left

569 * File corresponding to the left side of this comparison.

570 * @param right

571 * "starting point" of the traversal to resolve as the right logical model.

572 * @param origin

573 * "starting point" of the traversal to resolve as the origin logical model (common ancestor of

574 * left and right). Can be <code>null</code>.

575 * @param monitor

576 * Monitor on which to report progress to the user.

577 * @return A traversal corresponding to all resources composing the given file's logical model.

578 * @throws InterruptedException

579 * Thrown if the resolution is cancelled or interrupted one way or another.

580 */

        private SynchronizationModel resolveModelsWithLocal(IStorageProviderAccessor storageAccessor, IFile left,

                        IStorage right, IStorage origin, ThreadSafeProgressMonitor monitor) throws InterruptedException {

583

584 // Update changes and compute dependencies for left

585 // Then load the same set of resources for the remote sides, completing it top-down

586

                if (getResolutionScope() != CrossReferenceResolutionScope.SELF) {

                        final SynchronizedResourceSet resourceSet = new SynchronizedResourceSet();

                        updateDependencies(resourceSet, left, monitor);

590 updateChangedResources(resourceSet, monitor);

591 }

592

                while (!currentlyResolving.isEmpty()) {

594 resolutionEnd.await();

595 }

                if (monitor.isCanceled()) {

597 throw new OperationCanceledException();

598 }

                final Set<IStorage> leftTraversal = resolveTraversal(left, Collections.<URI> emptySet());

600

                final Set<IStorage> rightTraversal = resolveRemoteTraversal(storageAccessor, right, leftTraversal,

602 DiffSide.REMOTE, monitor);

603 final Set<IStorage> originTraversal;

                if (origin != null) {

                        originTraversal = resolveRemoteTraversal(storageAccessor, origin, leftTraversal, DiffSide.ORIGIN,

606 monitor);

607 } else {

608 originTraversal = Collections.emptySet();

609 }

610

                final SynchronizationModel synchronizationModel = new SynchronizationModel(new StorageTraversal(

                                leftTraversal), new StorageTraversal(rightTraversal), new StorageTraversal(originTraversal),

613 diagnostic);

614

615 return synchronizationModel;

616 }

617

618 /**

619 * All three sides we've been fed are remote. We'll resolve all three with a simple a top-down algorithm

620 * (detect only outgoing cross-references).

621 *

622 * @param storageAccessor

623 * The accessor that can be used to retrieve synchronization information between our resources.

624 * @param left

625 * "starting point" of the traversal to resolve as the left logical model.

626 * @param right

627 * "starting point" of the traversal to resolve as the right logical model.

628 * @param origin

629 * "starting point" of the traversal to resolve as the origin logical model (common ancestor of

630 * left and right). Can be <code>null</code>.

631 * @param monitor

632 * Monitor on which to report progress to the user.

633 * @return A traversal corresponding to all resources composing the given file's logical model.

634 * @throws InterruptedException

635 * Thrown if the resolution is cancelled or interrupted one way or another.

636 */

        private SynchronizationModel resolveRemoteModels(IStorageProviderAccessor storageAccessor, IStorage left,

                        IStorage right, IStorage origin, ThreadSafeProgressMonitor monitor) throws InterruptedException {

639

                final Set<IStorage> leftTraversal = resolveRemoteTraversal(storageAccessor, left, Collections

                                .<IStorage> emptySet(), DiffSide.SOURCE, monitor);

                final Set<IStorage> rightTraversal = resolveRemoteTraversal(storageAccessor, right, Collections

                                .<IStorage> emptySet(), DiffSide.REMOTE, monitor);

644 final Set<IStorage> originTraversal;

                if (origin != null) {

                        originTraversal = resolveRemoteTraversal(storageAccessor, origin, Collections

                                        .<IStorage> emptySet(), DiffSide.ORIGIN, monitor);

648 } else {

649 originTraversal = Collections.emptySet();

650 }

                final SynchronizationModel synchronizationModel = new SynchronizationModel(new StorageTraversal(

                                leftTraversal), new StorageTraversal(rightTraversal), new StorageTraversal(originTraversal),

653 diagnostic);

654

655 return synchronizationModel;

656 }

657

658 /**

659 * Checks the current state of our {@link #resourceListener} and updates the dependency graph for all

660 * resources that have been changed since we last checked.

661 *

662 * @param resourceSet

663 * The resource set in which to load our temporary resources.

664 * @param monitor

665 * Monitor on which to report progress to the user.

666 */

        private void updateChangedResources(SynchronizedResourceSet resourceSet, ThreadSafeProgressMonitor monitor) {

                final Set<URI> removedURIs = difference(resourceListener.popRemovedURIs(), resolvedResources);

                final Set<URI> changedURIs = difference(resourceListener.popChangedURIs(), resolvedResources);

670

671 dependencyGraph.removeAll(removedURIs);

672

673 // We need to re-resolve the changed resources, along with their direct parents

                final Set<URI> recompute = new LinkedHashSet<URI>(changedURIs);

675 for (URI changed : changedURIs) {

                        if (dependencyGraph.contains(changed)) {

                                recompute.addAll(dependencyGraph.getDirectParents(changed));

678 }

679 }

680 dependencyGraph.removeAll(recompute);

681

682 for (URI changed : recompute) {

                        demandResolve(resourceSet, changed, monitor);

684 }

685 }

686

687 /**

688 * Update the dependency graph to make sure that it contains the given file.

689 *

690 * If the graph does not yet contain this file, we'll try and find cross-references outgoing from and/or

691 * incoming to the given file, depending on the current {@link #getResolutionScope() resolution scope}.

692 *

693 *

694 * @param resourceSet

695 * The resource set in which to load the temporary resources.

696 * @param file

697 * The file which we need to be present in the dependency graph.

698 * @param monitor

699 * Monitor on which to report progress to the user.

700 */

        private void updateDependencies(SynchronizedResourceSet resourceSet, IFile file,

702 ThreadSafeProgressMonitor monitor) {

                final URI expectedURI = createURIFor(file);

                if (!dependencyGraph.contains(expectedURI)) {

                        final IResource startingPoint = getResolutionStartingPoint(file);

                        final ModelResourceVisitor modelVisitor = new ModelResourceVisitor(resourceSet, monitor);

707 try {

708 startingPoint.accept(modelVisitor);

709 } catch (CoreException e) {

                                safeMergeDiagnostic(BasicDiagnostic.toDiagnostic(e));

711 }

712 }

713 }

714

715 /**

716 * Returns the starting point for the resolution of the given file's logical model according to

717 * {@link #getResolutionScope()}.

718 *

719 * @param file

720 * The file which logical model we need to add to the current {@link #dependencyGraph}.

721 * @return Starting point for this file's logical model resolution.

722 * @see CrossReferenceResolutionScope

723 */

724 private IResource getResolutionStartingPoint(IFile file) {

725 final IResource startingPoint;

726 switch (getResolutionScope()) {

727 case WORKSPACE:

                                startingPoint = ResourcesPlugin.getWorkspace().getRoot();

729 break;

730 case PROJECT:

731 startingPoint = file.getProject();

732 break;

733 case CONTAINER:

734 startingPoint = file.getParent();

735 break;

736 case OUTGOING:

737 // fall through, the difference between SELF and OUTGOING will only come later on

738 case SELF:

739 // fall through

740 default:

741 startingPoint = file;

742 break;

743 }

744 return startingPoint;

745 }

746

747 /**

748 * Tells this resolver how much of the dependency graph should be created at once. Note that this value

749 * may change during a resolution, which sole "visible" effect would be to prevent resolution of further

750 * outgoing references if the new value is "SELF".

751 *

752 * @return The current resolution scope.

753 */

754 private CrossReferenceResolutionScope getResolutionScope() {

                final IPreferenceStore store = EMFCompareIDEUIPlugin.getDefault().getPreferenceStore();

                if (store.getBoolean(EMFCompareUIPreferences.DISABLE_RESOLVERS_PREFERENCE)) {

757 return CrossReferenceResolutionScope.SELF;

758 }

                final String stringValue = store.getString(EMFCompareUIPreferences.RESOLUTION_SCOPE_PREFERENCE);

                return CrossReferenceResolutionScope.valueOf(stringValue);

761 }

762

        private Set<IStorage> resolveTraversal(IFile file, Set<URI> bounds) {

                final Set<IStorage> traversal = new LinkedHashSet<IStorage>();

765

                final Iterable<URI> dependencies = getDependenciesOf(file, bounds);

767 for (URI uri : dependencies) {

                        traversal.add(getFileAt(uri));

769 }

770 return traversal;

771 }

772

        private Set<IStorage> resolveRemoteTraversal(IStorageProviderAccessor storageAccessor, IStorage start,

                        Set<IStorage> localVariants, DiffSide side, ThreadSafeProgressMonitor monitor)

775 throws InterruptedException {

                final SynchronizedResourceSet resourceSet = new SynchronizedResourceSet();

                final StorageURIConverter converter = new RevisionedURIConverter(resourceSet.getURIConverter(),

778 storageAccessor, side);

779 resourceSet.setURIConverter(converter);

780

781 resolvedResources = new LinkedHashSet<URI>();

782

783 for (IStorage local : localVariants) {

784 /*

785 * FIXME check that the IResourceVariantTrees support parallel accesses... or make sure that we do

786 * not use multiple thread to resolve the remote variants. For now, we'll use threads.

787 */

                        final URI expectedURI = ResourceUtil.createURIFor(local);

                        demandRemoteResolve(resourceSet, expectedURI, monitor);

790 }

791

                final URI startURI = ResourceUtil.createURIFor(start);

                demandRemoteResolve(resourceSet, startURI, monitor);

794

                while (!currentlyResolving.isEmpty()) {

796 resolutionEnd.await();

797 }

798

                if (monitor.isCanceled()) {

800 throw new OperationCanceledException();

801 }

802

803 resolvedResources = null;

804

805 return converter.getLoadedRevisions();

806 }

807

        private Iterable<URI> getDependenciesOf(IFile file, Set<URI> bounds) {

                final URI expectedURI = ResourceUtil.createURIFor(file);

810

811 final Iterable<URI> dependencies;

812 switch (getResolutionScope()) {

813 case WORKSPACE:

                                dependencies = dependencyGraph.getSubgraphContaining(expectedURI, bounds);

815 break;

816 case PROJECT:

                                final Set<URI> allDependencies = dependencyGraph.getSubgraphContaining(expectedURI, bounds);

                                final IResource project = file.getProject();

                                dependencies = Iterables.filter(allDependencies, isInContainer(project));

820 break;

821 case CONTAINER:

                                final Set<URI> allDependencies1 = dependencyGraph.getSubgraphContaining(expectedURI, bounds);

                                final IResource container = file.getParent();

                                dependencies = Iterables.filter(allDependencies1, isInContainer(container));

825 break;

826 case OUTGOING:

                                dependencies = dependencyGraph.getTreeFrom(expectedURI, bounds);

828 break;

829 case SELF:

830 // fall through

831 default:

                                dependencies = Collections.singleton(expectedURI);

833 break;

834 }

835 return dependencies;

836 }

837

838 /**

839 * Returns the IFile located at the given URI.

840 *

841 * @param uri

842 * URI we need the file for.

843 * @return The IFile located at the given URI.

844 */

845 private IFile getFileAt(URI uri) {

                final StringBuilder path = new StringBuilder();

                List<String> segments = uri.segmentsList();

                if (uri.isPlatformResource()) {

                        segments = segments.subList(1, segments.size());

850 }

851 for (String segment : segments) {

                        path.append(URI.decode(segment)).append('/');

853 }

                return ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(path.toString()));

855 }

856

857 /**

858 * This predicate can be used to check wether a given URI points to a workspace resource contained in the

859 * given container.

860 *

861 * @param container

862 * The container in which we need the resources to be contained.

863 * @return A ready to use predicate.

864 */

        private Predicate<URI> isInContainer(final IResource container) {

866 return new Predicate<URI>() {

867 public boolean apply(URI input) {

                                if (input != null) {

                                        final IFile pointedFile = getFileAt(input);

                                        if (pointedFile != null) {

                                                return container.getLocation().isPrefixOf(pointedFile.getLocation());

872 }

873 }

874 return false;

875 }

876 };

877 }

878

879 /**

880 * When executing local comparisons, we resolve the full logical model of both (or "all three of") the

881 * compared files.

882 *

883 * If there is one resource in the scope that references all of these starting points, then we'll have

884 * perfectly identical logical models for all comparison sides. Because of that, we need to constrain the

885 * logical model of each starting point to only parts that are not accessible from other starting points.

886 * This might cause coherence issues as merging could thus "break" references from other files to our

887 * compared ones.

888 *

889 *

890 * This method will be used to browse the files that are removed from the logical model, and log a warning

891 * for the files that are removed even though they are "parents" of one of the starting points.

892 *

893 *

894 * @param startingPoints

895 * Starting points of the comparison.

896 * @param removedFromModel

897 * All files that have been removed from the comparison scope.

898 */

        private void logCoherenceThreats(Iterable<URI> startingPoints, Iterable<URI> removedFromModel) {

                final Set<URI> coherenceThreats = new LinkedHashSet<URI>();

901 for (URI start : startingPoints) {

902 for (URI removed : removedFromModel) {

                                if (dependencyGraph.hasChild(removed, start)) {

904 coherenceThreats.add(removed);

905 }

906 }

907 }

908

                if (!coherenceThreats.isEmpty()) {

910 // FIXME: should be added to diagnostic instead

                        final String message = EMFCompareIDEUIMessages.getString("ModelResolver.coherenceWarning"); //$NON-NLS-1$

                        final String details = Iterables.toString(coherenceThreats);

                        EMFCompareIDEUIPlugin.getDefault().getLog().log(

                                        new Status(IStatus.WARNING, EMFCompareIDEUIPlugin.PLUGIN_ID, message + '\n' + details));

915 }

916 }

917

918 /**

919 * Allows callers to launch the loading and resolution of the model pointed at by the given URI.

920 *

921 * This will check whether the given storage isn't already being resolved, then submit a job to the

922 * {@link #resolvingPool} to load and resolve the model in a separate thread.

923 *

924 *

925 * @param resourceSet

926 * The resource set in which to load the resource.

927 * @param uri

928 * The uri we are to try and load as a model.

929 * @param monitor

930 * Monitor on which to report progress to the user.

931 * @see ResourceResolver

932 */

        protected void demandResolve(SynchronizedResourceSet resourceSet, URI uri,

934 final ThreadSafeProgressMonitor monitor) {

                if (isInterruptedOrCanceled(monitor)) {

936 demandResolvingAndUnloadingPoolShutdown();

937 return;

938 }

939

940 lock.lock();

941 try {

                        if (resolvedResources.add(uri) && currentlyResolving.add(uri)) {

943 // Regardless of the amount of progress reported so far, use 0.1% of the space remaining in

944 // the monitor to process the next node.

                                monitor.setWorkRemaining(1000);

                                ListenableFuture<?> future = resolvingPool.submit(new ResourceResolver(resourceSet, uri,

947 monitor));

                                Futures.addCallback(future, new ResolvingFutureCallback(monitor, uri));

949 }

950 } finally {

951 lock.unlock();

952 }

953 }

954

955 /**

956 * Allows callers to launch the loading and resolution of the model pointed at by the given URI, without

957 * updating the {@link #dependencyGraph} along the way.

958 *

959 * This will check whether the given storage isn't already being resolved, then submit a job to the

960 * {@link #resolvingPool} to load and resolve the model in a separate thread.

961 *

962 *

963 * @param resourceSet

964 * The resource set in which to load the resource.

965 * @param uri

966 * The uri we are to try and load as a model.

967 * @param monitor

968 * Monitor on which to report progress to the user.

969 */

        protected void demandRemoteResolve(SynchronizedResourceSet resourceSet, URI uri,

971 final ThreadSafeProgressMonitor monitor) {

                if (isInterruptedOrCanceled(monitor)) {

973 demandResolvingAndUnloadingPoolShutdown();

974 return;

975 }

976

977 lock.lock();

978 try {

                        if (resolvedResources.add(uri) && currentlyResolving.add(uri)) {

980 // Regardless of the amount of progress reported so far, use 0.1% of the space remaining in

981 // the monitor to process the next node.

                                monitor.setWorkRemaining(1000);

                                ListenableFuture<?> future = resolvingPool.submit(new RemoteResourceResolver(resourceSet,

984 uri, monitor));

                                Futures.addCallback(future, new ResolvingFutureCallback(monitor, uri));

986 }

987 } finally {

988 lock.unlock();

989 }

990 }

991

992 /**

993 * Allows callers to launch the unloading of the given resource.

994 *

995 * Do note that even though this is called "unload", we won't actually call {@link Resource#unload()} on

996 * the given resource unless we deem it necessary (we only call if for UML because of the CacheAdapter)

997 * for now. This will only remove the resource from its containing resource set so as to allow it to be

998 * garbage collected.

999 *

1000 *

1001 * @param resourceSet

1002 * The resource set containing the resource to be unloaded.

1003 * @param resource

1004 * The resource to unload.

1005 * @param monitor

1006 * Monitor on which to report progress to the user.

1007 * @see ResourceUnloader

1008 */

        protected void demandUnload(SynchronizedResourceSet resourceSet, Resource resource,

1010 final ThreadSafeProgressMonitor monitor) {

1011

1012 // Regardless of the amount of progress reported so far, use 0.1% of the space remaining in the

1013 // monitor to process the next node.

                monitor.setWorkRemaining(1000);

1015 ListenableFuture<?> future = unloadingPool

                                .submit(new ResourceUnloader(resourceSet, resource, monitor));

                Futures.addCallback(future, new FutureCallback<Object>() {

1018 public void onSuccess(Object result) {

                                if (!isInterruptedOrCanceled(monitor)) {

                                        monitor.worked(1);

1021 }

1022 }

1023

1024 public void onFailure(Throwable t) {

                                if (!isInterruptedOrCanceled(monitor)) {

                                        monitor.worked(1);

                                        safeMergeDiagnostic(BasicDiagnostic.toDiagnostic(t));

1028 }

1029 }

1030 });

1031 }

1032

1033 /**

1034 * Thread safely merge the given diagnostic to the {@link #diagnostic} field.

1035 *

1036 * @param resourceDiagnostic

1037 * the diagnostic to be added to the global diagnostic.

1038 */

1039 private void safeMergeDiagnostic(Diagnostic resourceDiagnostic) {

1040 lock.lock();

1041 try {

1042 diagnostic.merge(resourceDiagnostic);

1043 } finally {

1044 lock.unlock();

1045 }

1046 }

1047

1048 /**

1049 * Checks if the current thread is interrupted or if the given monitor has been canceled.

1050 *

1051 * @param monitor

1052 * the monitor to check

1053 * @return true if the current thread has been canceled, false otherwise.

1054 */

1055 private boolean isInterruptedOrCanceled(IProgressMonitor monitor) {

                return Thread.currentThread().isInterrupted() || monitor.isCanceled();

1057 }

1058

1059 /**

1060 * If {@link #shutdownInProgress shutdown has not been requested before}, it submits a new task to

1061 * {@link #shutdownPools() shut down} {@link #resolvingPool} and {@link #unloadingPool}. Do nothing if

1062 * current thread already is interrupted.

1063 */

1064 private void demandResolvingAndUnloadingPoolShutdown() {

                if (!Thread.currentThread().isInterrupted()) {

                        if (shutdownInProgress.compareAndSet(false, true)) {

1067 Runnable runnable = new Runnable() {

1068 public void run() {

1069 shutdownPools();

1070 }

1071 };

1072

                                ListenableFuture<?> listenableFuture = terminator.submit(runnable);

                                Futures.addCallback(listenableFuture, new FutureCallback<Object>() {

1075 public void onSuccess(Object result) {

                                                shutdownInProgress.set(false);

1077 }

1078

1079 public void onFailure(Throwable t) {

                                                shutdownInProgress.set(false);

                                                EMFCompareIDEUIPlugin.getDefault().log(t);

1082 }

1083 });

1084 }

1085 }

1086 }

1087

1088 /**

1089 * This will remove the given uri from the {@link #currentlyResolving} set and signal to

1090 * {@link #resolutionEnd} if the set is empty afterward. This method must be call by every callback of

1091 * resolving tasks.

1092 *

1093 * @param uri

1094 * the uri to remove.

1095 */

1096 private void finalizeResolvingTask(URI uri) {

1097 lock.lock();

1098 try {

1099 currentlyResolving.remove(uri);

                        if (currentlyResolving.isEmpty()) {

1101 resolutionEnd.signal();

1102 }

1103 } finally {

1104 lock.unlock();

1105 }

1106 }

1107

1108 /**

1109 * The callback for {@link ResourceResolver} and {@link RemoteResourceResolver} tasks. It will report

1110 * progress, log errors and finalize the resolving and as such, possibly signaling the end of the

1111 * resolution.

1112 *

1113 * @author <a href="mailto:mikael.barbero@obeo.fr">Mikael Barbero</a>

1114 */

1115 private final class ResolvingFutureCallback implements FutureCallback<Object> {

1116

1117 /** The monitor to which report progress. */

1118 private final IProgressMonitor monitor;

1119

1120 private final URI uri;

1121

1122 /**

1123 * @param monitor

1124 */

                private ResolvingFutureCallback(IProgressMonitor monitor, URI uri) {

1126 this.monitor = monitor;

1127 this.uri = uri;

1128 }

1129

1130 public void onSuccess(Object result) {

1131 try {

                                if (!isInterruptedOrCanceled(monitor)) {

1133 // do not report progress anymore when the task has been interrupted of canceled. It

1134 // speeds up the cancellation.

                                        monitor.worked(1);

1136 }

1137 } finally {

1138 finalizeResolvingTask(uri);

1139 }

1140 }

1141

1142 public void onFailure(Throwable t) {

1143 try {

                                if (!isInterruptedOrCanceled(monitor)) {

1145 // do not report progress or errors anymore when the task has been interrupted of

1146 // canceled. It speeds up the cancellation.

                                        monitor.worked(1);

                                        safeMergeDiagnostic(BasicDiagnostic.toDiagnostic(t));

1149 }

1150 } finally {

1151 finalizeResolvingTask(uri);

1152 }

1153 }

1154 }

1155

1156 /**

1157 * Implements a runnable that will load the EMF resource pointed at by a given URI, then resolve all of

1158 * its cross-referenced resources and update the dependency graph accordingly.

1159 *

1160 * Once done with the resolution, this thread will spawn an independent job to unload the resource.

1161 *

1162 *

1163 * @author <a href="mailto:laurent.goubet@obeo.fr">Laurent Goubet</a>

1164 */

1165 private class ResourceResolver implements Runnable {

1166 /** The resource set in which to load the resource. */

1167 private final SynchronizedResourceSet resourceSet;

1168

1169 /** URI that needs to be loaded as an EMF model. */

1170 private final URI uri;

1171

1172 /** Monitor on which to report progress to the user. */

1173 private final ThreadSafeProgressMonitor monitor;

1174

1175 /**

1176 * Default constructor.

1177 *

1178 * @param resourceSet

1179 * The resource set in which to load the resource.

1180 * @param uri

1181 * URI that needs to be loaded as an EMF model.

1182 * @param monitor

1183 * Monitor on which to report progress to the user.

1184 */

                public ResourceResolver(SynchronizedResourceSet resourceSet, URI uri,

1186 ThreadSafeProgressMonitor monitor) {

1187 this.resourceSet = resourceSet;

1188 this.uri = uri;

1189 this.monitor = monitor;

1190 }

1191

1192 /** {@inheritDoc} */

1193 public void run() {

                        if (isInterruptedOrCanceled(monitor)) {

1195 demandResolvingAndUnloadingPoolShutdown();

1196 return;

1197 }

1198

                        final Resource resource = resourceSet.loadResource(uri);

                        Diagnostic resourceDiagnostic = EcoreUtil.computeDiagnostic(resource, true);

                        if (resourceDiagnostic.getSeverity() >= Diagnostic.WARNING) {

1202 safeMergeDiagnostic(resourceDiagnostic);

1203 }

1204 dependencyGraph.add(uri);

                        if (getResolutionScope() != CrossReferenceResolutionScope.SELF) {

                                final Set<URI> crossReferencedResources = resourceSet.discoverCrossReferences(resource,

1207 monitor);

                                dependencyGraph.addChildren(uri, crossReferencedResources);

1209 for (URI crossRef : crossReferencedResources) {

                                        if (isInterruptedOrCanceled(monitor)) {

1211 demandResolvingAndUnloadingPoolShutdown();

1212 // do not return, we want to unload what we've already loaded to avoid leaks.

1213 break;

1214 }

                                        demandResolve(resourceSet, crossRef, monitor);

1216 }

1217 }

                        demandUnload(resourceSet, resource, monitor);

1219 }

1220 }

1221

1222 /**

1223 * Implements a runnable that will load the given EMF resource, then launch the resolution of all

1224 * cross-references of this resource in separate threads. This will not update the dependency graph.

1225 *

1226 * @author <a href="mailto:laurent.goubet@obeo.fr">Laurent Goubet</a>

1227 */

1228 private class RemoteResourceResolver implements Runnable {

1229 /** The resource set in which to load the resource. */

1230 private final SynchronizedResourceSet resourceSet;

1231

1232 /** URI that needs to be loaded as an EMF model. */

1233 private final URI uri;

1234

1235 /** Monitor on which to report progress to the user. */

1236 private final ThreadSafeProgressMonitor monitor;

1237

1238 /**

1239 * Constructs a resolver to load a resource from its URI.

1240 *

1241 * @param resourceSet

1242 * The resource set in which to load the resource.

1243 * @param uri

1244 * The URI that needs to be loaded as an EMF model.

1245 * @param monitor

1246 * Monitor on which to report progress to the user.

1247 */

                public RemoteResourceResolver(SynchronizedResourceSet resourceSet, URI uri,

1249 ThreadSafeProgressMonitor monitor) {

1250 this.resourceSet = resourceSet;

1251 this.uri = uri;

1252 this.monitor = monitor;

1253 }

1254

1255 /** {@inheritDoc} */

1256 public void run() {

                        if (isInterruptedOrCanceled(monitor)) {

1258 demandResolvingAndUnloadingPoolShutdown();

1259 return;

1260 }

1261

                        final Resource resource = resourceSet.loadResource(uri);

                        Diagnostic resourceDiagnostic = EcoreUtil.computeDiagnostic(resource, true);

                        if (resourceDiagnostic.getSeverity() >= Diagnostic.WARNING) {

1265 safeMergeDiagnostic(resourceDiagnostic);

1266 }

                        if (getResolutionScope() != CrossReferenceResolutionScope.SELF) {

                                final Set<URI> crossReferencedResources = resourceSet.discoverCrossReferences(resource,

1269 monitor);

1270 for (URI crossRef : crossReferencedResources) {

                                        if (isInterruptedOrCanceled(monitor)) {

1272 demandResolvingAndUnloadingPoolShutdown();

1273 // do not return, we want to unload what we've already loaded to avoid leaks.

1274 break;

1275 }

                                        demandRemoteResolve(resourceSet, crossRef, monitor);

1277 }

1278 }

                        demandUnload(resourceSet, resource, monitor);

1280 }

1281 }

1282

1283 /**

1284 * Implementation of a Runnable that can be used to unload a given resource and make it

1285 * garbage-collectable.

1286 *

1287 * @author <a href="mailto:laurent.goubet@obeo.fr">Laurent Goubet</a>

1288 */

1289 private static class ResourceUnloader implements Runnable {

1290 /** The resource set from which to unload a resource. */

1291 private final SynchronizedResourceSet resourceSet;

1292

1293 /** The resource to unload. */

1294 private final Resource resource;

1295

1296 /** Monitor on which to report progress to the user. */

1297 private final IProgressMonitor monitor;

1298

1299 /**

1300 * Default constructor.

1301 *

1302 * @param resourceSet

1303 * The resource set from which to unload a resource.

1304 * @param resource

1305 * The resource to unload.

1306 * @param monitor

1307 * Monitor on which to report progress to the user.

1308 */

                public ResourceUnloader(SynchronizedResourceSet resourceSet, Resource resource,

1310 IProgressMonitor monitor) {

1311 this.resourceSet = resourceSet;

1312 this.resource = resource;

1313 this.monitor = monitor;

1314 }

1315

1316 /** {@inheritDoc} */

1317 public void run() {

                        resourceSet.unload(resource, monitor);

1319 }

1320 }

1321

1322 /**

1323 * This implementation of a resource visitor will allow us to browse a given hierarchy and resolve the

1324 * models files in contains, as determined by {@link ThreadedModelResolver#MODEL_CONTENT_TYPES}.

1325 *

1326 * @author <a href="mailto:laurent.goubet@obeo.fr">laurent Goubet</a>

1327 * @see ThreadedModelResolver#hasModelType(IFile)

1328 */

1329 private class ModelResourceVisitor implements IResourceVisitor {

1330 /** Resource set in which to load the model files this visitor will find. */

1331 private final SynchronizedResourceSet resourceSet;

1332

1333 /** Monitor on which to report progress to the user. */

1334 private final ThreadSafeProgressMonitor monitor;

1335

1336 /**

1337 * Default constructor.

1338 *

1339 * @param resourceSet

1340 * The resource set in which this visitor will load the model files it finds.

1341 * @param monitor

1342 * Monitor on which to report progress to the user.

1343 */

                public ModelResourceVisitor(SynchronizedResourceSet resourceSet, ThreadSafeProgressMonitor monitor) {

1345 this.resourceSet = resourceSet;

1346 this.monitor = monitor;

1347 }

1348

1349 /** {@inheritDoc} */

                public boolean visit(IResource resource) throws CoreException {

                        if (isInterruptedOrCanceled(monitor)) {

1352 demandResolvingAndUnloadingPoolShutdown();

1353 // cancel the visit

1354 throw new OperationCanceledException();

1355 }

1356

1357 if (resource instanceof IFile) {

1358 final IFile file = (IFile)resource;

                                if (hasModelType(file)) {

                                        final URI expectedURI = ResourceUtil.createURIFor(file);

                                        demandResolve(resourceSet, expectedURI, monitor);

1362 }

1363 return false;

1364 }

1365 return true;

1366 }

1367 }

1368

1369 /**

1370 * This will listen to workspace changes and react to all changes on "model" resources as determined by

1371 * {@link ThreadedModelResolver#MODEL_CONTENT_TYPES}.

1372 *

1373 * @author <a href="mailto:laurent.goubet@obeo.fr">laurent Goubet</a>

1374 * @see ThreadedModelResolver#hasModelType(IFile)

1375 */

1376 private static class ModelResourceListener implements IResourceChangeListener {

1377 /** Keeps track of the URIs that need to be reparsed when next we need the dependencies graph . */

1378 protected final Set<URI> changedURIs;

1379

1380 /** Tracks the files that have been removed. */

1381 protected final Set<URI> removedURIs;

1382

1383 /** Prevents concurrent access to the two internal sets. */

1384 protected final ReentrantLock internalLock;

1385

1386 /** Initializes this listener. */

1387 public ModelResourceListener() {

                        this.changedURIs = new LinkedHashSet<URI>();

                        this.removedURIs = new LinkedHashSet<URI>();

                        this.internalLock = new ReentrantLock();

1391 }

1392

1393 /** {@inheritDoc} */

1394 public void resourceChanged(IResourceChangeEvent event) {

                        final IResourceDelta delta = event.getDelta();

                        if (delta == null) {

1397 return;

1398 }

1399

1400 /*

1401 * We must block any and all threads from using the two internal sets through either

1402 * popChangedURIs or popRemovedURIs while we are parsing a resource delta. This particular locking

1403 * is here to avoid such misuses.

1404 */

1405 internalLock.lock();

1406 try {

                                delta.accept(new ModelResourceDeltaVisitor());

1408 } catch (CoreException e) {

                                EMFCompareIDEUIPlugin.getDefault().log(e);

1410 } finally {

1411 internalLock.unlock();

1412 }

1413 }

1414

1415 /**

1416 * Retrieves the set of all changed URIs since we last updated the dependencies graph, and clears it

1417 * for subsequent calls.

1418 *

1419 * @return The set of all changed URIs since we last updated the dependencies graph.

1420 */

                public Set<URI> popChangedURIs() {

1422 final Set<URI> changed;

1423 internalLock.lock();

1424 try {

                                changed = ImmutableSet.copyOf(changedURIs);

1426 changedURIs.clear();

1427 } finally {

1428 internalLock.unlock();

1429 }

1430 return changed;

1431 }

1432

1433 /**

1434 * Retrieves the set of all removed URIs since we last updated the dependencies graph, and clears it

1435 * for subsequent calls.

1436 *

1437 * @return The set of all removed URIs since we last updated the dependencies graph.

1438 */

                public Set<URI> popRemovedURIs() {

1440 final Set<URI> removed;

1441 internalLock.lock();

1442 try {

                                removed = ImmutableSet.copyOf(removedURIs);

1444 removedURIs.clear();

1445 } finally {

1446 internalLock.unlock();

1447 }

1448 return removed;

1449 }

1450

1451 /**

1452 * Visits a resource delta to collect the changed and removed files' URIs.

1453 *

1454 * @author <a href="mailto:laurent.goubet@obeo.fr">laurent Goubet</a>

1455 */

1456 private class ModelResourceDeltaVisitor implements IResourceDeltaVisitor {

1457 /**

1458 * {@inheritDoc}

1459 *

1460 * @see org.eclipse.core.resources.IResourceDeltaVisitor#visit(org.eclipse.core.resources.IResourceDelta)

1461 */

                        public boolean visit(IResourceDelta delta) throws CoreException {

1463 /*

1464 * Note : the lock (#lock) must be acquired by the current thread _before_ calling #accept()

1465 * on this visitor.

1466 */

                                if (delta.getFlags() == IResourceDelta.MARKERS

                                                || delta.getResource().getType() != IResource.FILE) {

1469 return true;

1470 }

1471

                                final IFile file = (IFile)delta.getResource();

                                final URI fileURI = createURIFor(file);

1474 // We can't check the content type of a removed resource

                                if (delta.getKind() == IResourceDelta.REMOVED) {

1476 removedURIs.add(fileURI);

1477 changedURIs.remove(fileURI);

                                } else if (hasModelType(file)) {

                                        if ((delta.getKind() & IResourceDelta.CHANGED) != 0) {

1480 changedURIs.add(fileURI);

1481 // Probably can't happen, but let's stay on the safe side

1482 removedURIs.remove(fileURI);

                                        } else if ((delta.getKind() & IResourceDelta.ADDED) != 0) {

1484 // If a previously removed resource is changed, we can assume it's been re-added

                                                if (removedURIs.remove(fileURI)) {

1486 changedURIs.add(fileURI);

1487 }

1488 }

1489 }

1490

1491 return true;

1492 }

1493 }

1494 }

1495 }