| /******************************************************************************* |
| * Copyright (c) 2008-2011 Chair for Applied Software Engineering, |
| * Technische Universitaet Muenchen. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Otto von Wesendonk, Edgar Mueller, Maximilian Koegel - initial API and implementation |
| * Johannes Faltermeier - adaptions for independent storage |
| ******************************************************************************/ |
| package org.eclipse.emf.emfstore.internal.client.model.impl; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Date; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.LinkedHashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.ListIterator; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.Callable; |
| |
| import org.apache.commons.io.FileUtils; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EStructuralFeature.Setting; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl; |
| import org.eclipse.emf.ecore.util.ECrossReferenceAdapter; |
| import org.eclipse.emf.ecore.util.EcoreUtil.UsageCrossReferencer; |
| import org.eclipse.emf.ecore.xmi.XMIResource; |
| import org.eclipse.emf.emfstore.client.ESUsersession; |
| import org.eclipse.emf.emfstore.client.callbacks.ESCommitCallback; |
| import org.eclipse.emf.emfstore.client.callbacks.ESUpdateCallback; |
| import org.eclipse.emf.emfstore.client.changetracking.ESCommandStack; |
| import org.eclipse.emf.emfstore.client.handler.ESRunnableContext; |
| import org.eclipse.emf.emfstore.client.observer.ESLoginObserver; |
| import org.eclipse.emf.emfstore.client.observer.ESMergeObserver; |
| import org.eclipse.emf.emfstore.client.util.ESClientURIUtil; |
| import org.eclipse.emf.emfstore.client.util.ESVoidCallable; |
| import org.eclipse.emf.emfstore.client.util.RunESCommand; |
| import org.eclipse.emf.emfstore.common.extensionpoint.ESExtensionElement; |
| import org.eclipse.emf.emfstore.common.extensionpoint.ESExtensionPoint; |
| import org.eclipse.emf.emfstore.internal.client.importexport.impl.ExportChangesController; |
| import org.eclipse.emf.emfstore.internal.client.importexport.impl.ExportProjectController; |
| import org.eclipse.emf.emfstore.internal.client.model.CompositeOperationHandle; |
| import org.eclipse.emf.emfstore.internal.client.model.Configuration; |
| import org.eclipse.emf.emfstore.internal.client.model.ESWorkspaceProviderImpl; |
| import org.eclipse.emf.emfstore.internal.client.model.ProjectSpace; |
| import org.eclipse.emf.emfstore.internal.client.model.Usersession; |
| import org.eclipse.emf.emfstore.internal.client.model.changeTracking.merging.ConflictResolver; |
| import org.eclipse.emf.emfstore.internal.client.model.changeTracking.notification.recording.NotificationRecorder; |
| import org.eclipse.emf.emfstore.internal.client.model.connectionmanager.ConnectionManager; |
| import org.eclipse.emf.emfstore.internal.client.model.connectionmanager.ServerCall; |
| import org.eclipse.emf.emfstore.internal.client.model.controller.CommitController; |
| import org.eclipse.emf.emfstore.internal.client.model.controller.ShareController; |
| import org.eclipse.emf.emfstore.internal.client.model.controller.UpdateController; |
| import org.eclipse.emf.emfstore.internal.client.model.exceptions.ChangeConflictException; |
| import org.eclipse.emf.emfstore.internal.client.model.exceptions.IllegalProjectSpaceStateException; |
| import org.eclipse.emf.emfstore.internal.client.model.exceptions.MEUrlResolutionException; |
| import org.eclipse.emf.emfstore.internal.client.model.exceptions.PropertyNotFoundException; |
| import org.eclipse.emf.emfstore.internal.client.model.filetransfer.FileDownloadStatus; |
| import org.eclipse.emf.emfstore.internal.client.model.filetransfer.FileInformation; |
| import org.eclipse.emf.emfstore.internal.client.model.filetransfer.FileTransferManager; |
| import org.eclipse.emf.emfstore.internal.client.model.impl.api.ESLocalProjectImpl; |
| import org.eclipse.emf.emfstore.internal.client.model.util.WorkspaceUtil; |
| import org.eclipse.emf.emfstore.internal.client.observers.DeleteProjectSpaceObserver; |
| import org.eclipse.emf.emfstore.internal.client.properties.PropertyManager; |
| import org.eclipse.emf.emfstore.internal.common.ESDisposable; |
| import org.eclipse.emf.emfstore.internal.common.ExtensionRegistry; |
| import org.eclipse.emf.emfstore.internal.common.model.ModelElementId; |
| import org.eclipse.emf.emfstore.internal.common.model.Project; |
| import org.eclipse.emf.emfstore.internal.common.model.impl.IdentifiableElementImpl; |
| import org.eclipse.emf.emfstore.internal.common.model.impl.ProjectImpl; |
| import org.eclipse.emf.emfstore.internal.common.model.util.ModelUtil; |
| import org.eclipse.emf.emfstore.internal.common.model.util.SerializationException; |
| import org.eclipse.emf.emfstore.internal.server.conflictDetection.ChangeConflictSet; |
| import org.eclipse.emf.emfstore.internal.server.conflictDetection.ConflictBucket; |
| import org.eclipse.emf.emfstore.internal.server.conflictDetection.ConflictDetector; |
| import org.eclipse.emf.emfstore.internal.server.exceptions.FileTransferException; |
| import org.eclipse.emf.emfstore.internal.server.exceptions.InvalidVersionSpecException; |
| import org.eclipse.emf.emfstore.internal.server.model.FileIdentifier; |
| import org.eclipse.emf.emfstore.internal.server.model.ProjectInfo; |
| import org.eclipse.emf.emfstore.internal.server.model.accesscontrol.ACUser; |
| import org.eclipse.emf.emfstore.internal.server.model.accesscontrol.OrgUnitProperty; |
| import org.eclipse.emf.emfstore.internal.server.model.url.ModelElementUrlFragment; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.AbstractChangePackage; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.BranchInfo; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.BranchVersionSpec; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.ChangePackage; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.FileBasedChangePackage; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.LogMessage; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.PrimaryVersionSpec; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.TagVersionSpec; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.VersionSpec; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.VersioningFactory; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.Versions; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.impl.FileBasedChangePackageImpl; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.impl.persistent.ChangePackageContainer; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.AbstractOperation; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.CreateDeleteOperation; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.util.ChangePackageUtil; |
| import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.util.OperationUtil; |
| import org.eclipse.emf.emfstore.server.ESCloseableIterable; |
| import org.eclipse.emf.emfstore.server.exceptions.ESException; |
| import org.eclipse.emf.emfstore.server.model.ESChangePackage; |
| |
| /** |
| * Project space base class that contains custom user methods. |
| * |
| * @author koegel |
| * @author wesendon |
| * @author emueller |
| * @author jfaltermeier |
| * |
| */ |
| public abstract class ProjectSpaceBase extends IdentifiableElementImpl |
| implements ProjectSpace, ESLoginObserver, ESDisposable, ChangePackageContainer { |
| |
| private ESLocalProjectImpl esLocalProjectImpl; |
| |
| private boolean initCompleted; |
| private boolean isTransient; |
| private boolean disposed; |
| |
| private FileTransferManager fileTransferManager; |
| private OperationManager operationManager; |
| |
| private PropertyManager propertyManager; |
| private final Map<String, OrgUnitProperty> propertyMap; |
| |
| private ResourceSet resourceSet; |
| private ResourcePersister resourcePersister; |
| |
| private ECrossReferenceAdapter crossReferenceAdapter; |
| private ESRunnableContext runnableContext; |
| |
| /** |
| * Constructor. |
| */ |
| public ProjectSpaceBase() { |
| propertyMap = new LinkedHashMap<String, OrgUnitProperty>(); |
| initRunnableContext(); |
| } |
| |
| /** |
| * <p> |
| * Provides a context in which a {@link Runnable} is executed. |
| * </p> |
| * <p> |
| * This may be used to provide a context while applying operations on a |
| * {@link org.eclipse.emf.emfstore.client.ESLocalProject}. |
| * </p> |
| * |
| * @param runnableContext |
| * the runnable context to be set |
| */ |
| public void setRunnableContext(ESRunnableContext runnableContext) { |
| this.runnableContext = runnableContext; |
| } |
| |
| private void initRunnableContext() { |
| runnableContext = ExtensionRegistry.INSTANCE.get( |
| RUNNABLE_CONTEXT_ID, |
| ESRunnableContext.class, |
| new DefaultRunnableContext(), true); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#addFile(java.io.File) |
| */ |
| public FileIdentifier addFile(File file) throws FileTransferException { |
| return fileTransferManager.addFile(file); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#addFile(java.io.File, java.lang.String) |
| */ |
| public FileIdentifier addFile(File file, String fileIdentifier) throws FileTransferException { |
| return fileTransferManager.addFile(file, fileIdentifier); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#addOperations(java.util.List) |
| */ |
| public void addOperations(List<? extends AbstractOperation> operations) { |
| |
| final List<AbstractOperation> ops = new ArrayList<AbstractOperation>(); |
| for (final AbstractOperation operation : operations) { |
| ops.add(operation); |
| } |
| |
| getLocalChangePackage().addAll(ops); |
| |
| updateDirtyState(); |
| |
| for (final AbstractOperation op : operations) { |
| operationManager.notifyOperationExecuted(op); |
| } |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#addTag(org.eclipse.emf.emfstore.internal.server.model.versioning.PrimaryVersionSpec, |
| * org.eclipse.emf.emfstore.internal.server.model.versioning.TagVersionSpec) |
| */ |
| public void addTag(PrimaryVersionSpec versionSpec, TagVersionSpec tag) throws ESException { |
| final ConnectionManager cm = ESWorkspaceProviderImpl.getInstance().getConnectionManager(); |
| cm.addTag(getUsersession().getSessionId(), getProjectId(), versionSpec, tag); |
| } |
| |
| /** |
| * Helper method which applies merged changes on the ProjectSpace. This |
| * method is used by merge mechanisms in update as well as branch merging. |
| * |
| * @param baseSpec |
| * new base version |
| * @param incomingChangePackages |
| * changes from the current branch |
| * @param myChanges |
| * merged changes |
| * @param progressMonitor |
| * an {@link IProgressMonitor} to inform about the progress of the UpdateCallback in case it is called |
| * @param runChecksumCheckOnBaseSpec |
| * whether the checksum check is performed while applying the changes |
| * |
| * @throws ESException in case the checksum comparison failed and the activated IChecksumErrorHandler |
| * also failed |
| */ |
| public void applyChanges(PrimaryVersionSpec baseSpec, List<AbstractChangePackage> incomingChangePackages, |
| AbstractChangePackage myChanges, IProgressMonitor progressMonitor, boolean runChecksumCheckOnBaseSpec) |
| throws ESException { |
| |
| // revert local changes |
| notifyPreRevertMyChanges(getLocalChangePackage()); |
| revert(); |
| notifyPostRevertMyChanges(); |
| |
| // apply changes from repo. incoming (aka theirs) |
| applyChangePackages(incomingChangePackages, false); |
| if (runChecksumCheckOnBaseSpec) { |
| runChecksumTests(baseSpec, incomingChangePackages, progressMonitor); |
| } |
| notifyPostApplyTheirChanges(incomingChangePackages); |
| |
| reapplyLocalChanges(myChanges); |
| notifyPostApplyMergedChanges(myChanges); |
| |
| setBaseVersion(baseSpec); |
| save(); |
| } |
| |
| private void reapplyLocalChanges(AbstractChangePackage myChangePackage) { |
| final ESCloseableIterable<AbstractOperation> operations = myChangePackage.operations(); |
| try { |
| if (Configuration.getClientBehavior().isRerecordingActivated()) { |
| applyOperationsWithRerecording(operations.iterable()); |
| } else { |
| applyOperations(operations.iterable(), true); |
| } |
| } finally { |
| operations.close(); |
| } |
| } |
| |
| private void runChecksumTests(PrimaryVersionSpec baseSpec, List<AbstractChangePackage> incomingChangePackages, |
| IProgressMonitor progressMonitor) |
| throws ESException { |
| |
| progressMonitor.subTask(Messages.ProjectSpaceBase_Computing_Checksum); |
| |
| if (!performChecksumCheck(baseSpec, getProject())) { |
| progressMonitor.subTask(Messages.ProjectSpaceBase_Activate_ChecksumErrorHandler_Invalid_Chekcum); |
| final boolean errorHandled = Configuration.getClientBehavior() |
| .getChecksumErrorHandler() |
| .execute(toAPI(), baseSpec.toAPI(), progressMonitor); |
| |
| if (!errorHandled) { |
| // rollback |
| for (int i = incomingChangePackages.size() - 1; i >= 0; i--) { |
| final ESCloseableIterable<AbstractOperation> reversedOperations = incomingChangePackages.get(i) |
| .reversedOperations(); |
| try { |
| applyChangePackage(reversedOperations.iterable(), false); |
| } finally { |
| reversedOperations.close(); |
| } |
| } |
| // TODO |
| // applyChangePackage(getLocalChangePackage2().iterator(), true); |
| |
| throw new ESException(Messages.ProjectSpaceBase_Update_Cancelled_Invalid_Checksum); |
| } |
| } |
| } |
| |
| // FIXME: rename |
| private void applyChangePackage(Iterable<AbstractOperation> operations, boolean addOperations) { |
| applyOperations(operations, addOperations); |
| } |
| |
| private void applyChangePackages(Iterable<AbstractChangePackage> changePackages, boolean addOperations) { |
| for (final AbstractChangePackage changePackage : changePackages) { |
| final ESCloseableIterable<AbstractOperation> operations = changePackage.operations(); |
| try { |
| applyChangePackage(operations.iterable(), addOperations); |
| } finally { |
| operations.close(); |
| } |
| } |
| } |
| |
| private boolean performChecksumCheck(PrimaryVersionSpec baseVersion, Project project) { |
| |
| if (Configuration.getClientBehavior().isChecksumCheckActive()) { |
| final long expectedChecksum = baseVersion.getProjectStateChecksum(); |
| try { |
| final long computedChecksum = ModelUtil.computeChecksum(project); |
| return expectedChecksum == computedChecksum; |
| } catch (final SerializationException e) { |
| WorkspaceUtil.logWarning(Messages.ProjectSpaceBase_Cannot_Compute_Checksum, e); |
| } |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Applies a list of operations to the project. The change tracking will be |
| * stopped meanwhile. |
| * |
| * |
| * @param operations |
| * the list of operations to be applied upon the project space |
| * @param addOperations |
| * whether the operations should be saved in project space |
| * |
| */ |
| public void applyOperations(Iterable<AbstractOperation> operations, boolean addOperations) { |
| executeRunnable(new ApplyOperationsRunnable(this, operations, addOperations)); |
| } |
| |
| /** |
| * Applies a list of operations to the project. The change tracking will be |
| * stopped meanwhile. |
| * |
| * |
| * @param operations |
| * the list of operations to be applied upon the project space |
| * |
| */ |
| public void applyOperationsWithRerecording(Iterable<AbstractOperation> operations) { |
| executeRunnable(new ApplyOperationsAndRecordRunnable(this, operations)); |
| } |
| |
| /** |
| * Executes a given {@link Runnable} in the context of this {@link ProjectSpace}.<br> |
| * The {@link Runnable} usually modifies the Project contained in the {@link ProjectSpace}. |
| * |
| * @param runnable |
| * the {@link Runnable} to be executed in the context of this {@link ProjectSpace} |
| */ |
| public void executeRunnable(Runnable runnable) { |
| getRunnableContext().executeRunnable(runnable); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#beginCompositeOperation() |
| */ |
| public CompositeOperationHandle beginCompositeOperation() { |
| return operationManager.beginCompositeOperation(); |
| } |
| |
| /** |
| * Removes the elements that are marked as cutted from the project. |
| */ |
| public void cleanCutElements() { |
| final List<EObject> cutElements = new ArrayList<EObject>(getProject().getCutElements()); |
| for (final EObject cutElement : cutElements) { |
| getProject().deleteModelElement(cutElement); |
| } |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#commit(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public PrimaryVersionSpec commit(IProgressMonitor monitor) throws ESException { |
| return new CommitController(this, null, null, monitor).execute(); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#commit(java.lang.String, |
| * org.eclipse.emf.emfstore.client.callbacks.ESCommitCallback, org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public PrimaryVersionSpec commit(String logMessage, ESCommitCallback callback, IProgressMonitor monitor) |
| throws ESException { |
| return new CommitController(this, logMessage, callback, monitor).execute(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public PrimaryVersionSpec commitToBranch(BranchVersionSpec branch, String logMessage, |
| ESCommitCallback callback, |
| IProgressMonitor monitor) throws ESException { |
| return new CommitController(this, branch, logMessage, callback, monitor).execute(); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#exportLocalChanges(java.io.File, |
| * org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public void exportLocalChanges(File file, IProgressMonitor progressMonitor) throws IOException { |
| new ExportChangesController(this).execute(file, progressMonitor); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#exportLocalChanges(java.io.File) |
| */ |
| public void exportLocalChanges(File file) throws IOException { |
| new ExportChangesController(this).execute(file, new NullProgressMonitor()); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#exportProject(java.io.File, |
| * org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public void exportProject(File file, IProgressMonitor progressMonitor) throws IOException { |
| new ExportProjectController(this).execute(file, progressMonitor); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#exportProject(java.io.File) |
| */ |
| public void exportProject(File file) throws IOException { |
| new ExportProjectController(this).execute(file, new NullProgressMonitor()); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#getChanges(org.eclipse.emf.emfstore.internal.server.model.versioning.VersionSpec, |
| * org.eclipse.emf.emfstore.internal.server.model.versioning.VersionSpec) |
| */ |
| public List<AbstractChangePackage> getChanges(VersionSpec sourceVersion, VersionSpec targetVersion) |
| throws InvalidVersionSpecException, ESException { |
| // TODO: is this a server call? |
| final ConnectionManager connectionManager = ESWorkspaceProviderImpl.getInstance().getConnectionManager(); |
| final List<AbstractChangePackage> changes = connectionManager.getChanges(getUsersession().getSessionId(), |
| getProjectId(), |
| sourceVersion, targetVersion); |
| return changes; |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#getFile(org.eclipse.emf.emfstore.internal.server.model.FileIdentifier) |
| */ |
| public FileDownloadStatus getFile(FileIdentifier fileIdentifier) throws FileTransferException { |
| return fileTransferManager.getFile(fileIdentifier, false); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#getFileInfo(org.eclipse.emf.emfstore.internal.server.model.FileIdentifier) |
| */ |
| public FileInformation getFileInfo(FileIdentifier fileIdentifier) { |
| return fileTransferManager.getFileInfo(fileIdentifier); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#getLocalChangePackage(boolean) |
| */ |
| public AbstractChangePackage getLocalChangePackage(boolean canonize) { |
| final AbstractChangePackage changePackage = ChangePackageUtil.createChangePackage( |
| Configuration.getClientBehavior().useInMemoryChangePackage()); |
| |
| // copy operations from ProjectSpace |
| final ESCloseableIterable<AbstractOperation> operations = getLocalChangePackage().operations(); |
| try { |
| for (final AbstractOperation operation : operations.iterable()) { |
| final AbstractOperation clonedOperation = ModelUtil.clone(operation); |
| changePackage.add(clonedOperation); |
| } |
| } finally { |
| operations.close(); |
| } |
| final LogMessage logMessage = VersioningFactory.eINSTANCE.createLogMessage(); |
| if (getUsersession() != null) { |
| logMessage.setAuthor(getUsersession().getUsername()); |
| } else { |
| logMessage.setAuthor(Messages.ProjectSpaceBase_Unknown_Author); |
| } |
| logMessage.setClientDate(new Date()); |
| changePackage.setLogMessage(logMessage); |
| return changePackage; |
| } |
| |
| /** |
| * Get the current notification recorder. |
| * |
| * @return the recorder |
| */ |
| public NotificationRecorder getNotificationRecorder() { |
| return operationManager.getNotificationRecorder(); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#getOperationManager() |
| */ |
| public OperationManager getOperationManager() { |
| return operationManager; |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#getProjectInfo() |
| */ |
| public ProjectInfo getProjectInfo() { |
| final ProjectInfo projectInfo = org.eclipse.emf.emfstore.internal.server.model.ModelFactory.eINSTANCE |
| .createProjectInfo(); |
| projectInfo.setProjectId(ModelUtil.clone(getProjectId())); |
| projectInfo.setName(getProjectName()); |
| projectInfo.setDescription(getProjectDescription()); |
| projectInfo.setVersion(ModelUtil.clone(getBaseVersion())); |
| return projectInfo; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#getPropertyManager() |
| */ |
| public PropertyManager getPropertyManager() { |
| if (propertyManager == null) { |
| propertyManager = new PropertyManager(this); |
| } |
| |
| return propertyManager; |
| } |
| |
| /** |
| * getter for a string argument - see {@link #setProperty(OrgUnitProperty)}. |
| */ |
| private OrgUnitProperty getProperty(String name) throws PropertyNotFoundException { |
| // sanity checks |
| if (getUsersession() != null && getUsersession().getACUser() != null) { |
| final OrgUnitProperty orgUnitProperty = propertyMap.get(name); |
| if (orgUnitProperty != null) { |
| return orgUnitProperty; |
| } |
| } |
| throw new PropertyNotFoundException(MessageFormat.format( |
| Messages.ProjectSpaceBase_Property_Not_Found, name)); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#importLocalChanges(java.lang.String) |
| */ |
| public void importLocalChanges(String fileName) throws IOException { |
| |
| final ResourceSetImpl resourceSet = new ResourceSetImpl(); |
| final Resource resource = resourceSet.getResource(URI.createFileURI(fileName), true); |
| final EList<EObject> directContents = resource.getContents(); |
| // sanity check |
| |
| if (directContents.size() != 1 && !(directContents.get(0) instanceof ChangePackage)) { |
| throw new IOException(Messages.ProjectSpaceBase_Corrupt_File); |
| } |
| |
| final AbstractChangePackage changePackage = (AbstractChangePackage) directContents.get(0); |
| |
| if (!initCompleted) { |
| init(); |
| } |
| |
| final ESCloseableIterable<AbstractOperation> operations = changePackage.operations(); |
| try { |
| applyOperations(operations.iterable(), true); |
| } finally { |
| operations.close(); |
| } |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#init() |
| */ |
| public void init() { |
| initCrossReferenceAdapter(); |
| |
| final ESCommandStack commandStack = (ESCommandStack) ESWorkspaceProviderImpl.getInstance().getEditingDomain() |
| .getCommandStack(); |
| |
| fileTransferManager = new FileTransferManager(this); |
| operationManager = new OperationManager(this); |
| |
| // initialization order is important! |
| |
| initPropertyMap(); |
| |
| final URI localChangePackageUri = ESClientURIUtil.createOperationsURI(this); |
| final AbstractChangePackage localChangePackage = getLocalChangePackage(); |
| |
| if (localChangePackage == null) { |
| setChangePackage(createChangePackage(localChangePackageUri, true)); |
| } else if (localChangePackage.eIsProxy()) { |
| setChangePackage(createChangePackage(localChangePackageUri, false)); |
| } else { |
| if (!Configuration.getClientBehavior().useInMemoryChangePackage()) { |
| final FileBasedChangePackage changePackage = (FileBasedChangePackage) getLocalChangePackage(); |
| if (changePackage.eResource() == eResource()) { |
| migrateFileBasedChangePackageIntoDedicatedResource(localChangePackageUri, changePackage); |
| } else { |
| // TODO: move to FileBasedChangePackage |
| try { |
| FileUtils.copyFile( |
| new File(changePackage.getFilePath()), |
| new File(changePackage.getTempFilePath())); |
| } catch (final IOException ex) { |
| WorkspaceUtil.logException(ex.getMessage(), ex); |
| } |
| } |
| } |
| } |
| |
| initResourcePersister(); |
| // TODO: use ObserverBug to register observers |
| commandStack.addCommandStackObserver(resourcePersister); |
| commandStack.addCommandStackObserver(operationManager); |
| |
| getProject().addIdEObjectCollectionChangeObserver(operationManager); |
| getProject().addIdEObjectCollectionChangeObserver(resourcePersister); |
| |
| if (getProject() instanceof ProjectImpl) { |
| ((ProjectImpl) getProject()).setUndetachable(operationManager); |
| ((ProjectImpl) getProject()).setUndetachable(resourcePersister); |
| } |
| |
| initCompleted = true; |
| |
| startChangeRecording(); |
| cleanCutElements(); |
| } |
| |
| private AbstractChangePackage createChangePackage(URI localChangePackageUri, boolean initialize) { |
| |
| AbstractChangePackage localChangePackage; |
| |
| if (Configuration.getClientBehavior().useInMemoryChangePackage()) { |
| localChangePackage = VersioningFactory.eINSTANCE.createChangePackage(); |
| final Resource resource = getResourceSet().createResource(localChangePackageUri); |
| resource.getContents().add(localChangePackage); |
| } else { |
| final URI normalizedUri = getResourceSet().getURIConverter().normalize(localChangePackageUri); |
| final String filePath = normalizedUri.toFileString(); |
| localChangePackage = VersioningFactory.eINSTANCE.createFileBasedChangePackage(); |
| |
| if (initialize) { |
| ((FileBasedChangePackage) localChangePackage) |
| .initialize(filePath + FileBasedChangePackageImpl.FILE_OP_INDEX); |
| } else { |
| ((FileBasedChangePackage) localChangePackage).setFilePath( |
| filePath + FileBasedChangePackageImpl.FILE_OP_INDEX); |
| } |
| |
| final Resource resource = getResourceSet().createResource(localChangePackageUri); |
| resource.getContents().add(localChangePackage); |
| try { |
| resource.save(ModelUtil.getResourceSaveOptions()); |
| } catch (final IOException ex) { |
| WorkspaceUtil.logException(ex.getMessage(), ex); |
| } |
| } |
| |
| return localChangePackage; |
| } |
| |
| private void migrateFileBasedChangePackageIntoDedicatedResource(final URI localChangePackageUri, |
| final FileBasedChangePackage changePackage) { |
| |
| final URI normalizedUri = getResourceSet().getURIConverter().normalize(localChangePackageUri); |
| final String filePath = normalizedUri.toFileString(); |
| |
| final String tempPath = changePackage.getTempFilePath(); |
| final String path = changePackage.getFilePath(); |
| |
| RunESCommand.run(new ESVoidCallable() { |
| @Override |
| public void run() { |
| changePackage.setFilePath(filePath + ".1"); //$NON-NLS-1$ |
| } |
| }); |
| |
| if (path != null) { |
| // temp file depends on path |
| try { |
| FileUtils.moveFile(new File(tempPath), new File(changePackage.getTempFilePath())); |
| FileUtils.moveFile(new File(path), new File(changePackage.getFilePath())); |
| } catch (final IOException ex) { |
| WorkspaceUtil.logException(ex.getMessage(), ex); |
| } |
| } |
| |
| Resource resource = getResourceSet().getResource(localChangePackageUri, true); |
| if (resource == null) { |
| resource = getResourceSet().createResource(localChangePackageUri); |
| } |
| |
| final Resource r = resource; |
| // move change package into its own resource |
| RunESCommand.run(new ESVoidCallable() { |
| @Override |
| public void run() { |
| r.getContents().add(changePackage); |
| setChangePackage(changePackage); |
| } |
| }); |
| try { |
| eResource().save(ModelUtil.getResourceSaveOptions()); |
| resource.save(ModelUtil.getResourceSaveOptions()); |
| } catch (final IOException ex) { |
| WorkspaceUtil.logException(ex.getMessage(), ex); |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| private void initPropertyMap() { |
| // TODO: deprecated, OrgUnitPropertiy will be removed soon |
| if (getUsersession() != null) { |
| ESWorkspaceProviderImpl.getObserverBus().register(this, ESLoginObserver.class); |
| final ACUser acUser = getUsersession().getACUser(); |
| if (acUser != null) { |
| for (final OrgUnitProperty p : acUser.getProperties()) { |
| if (p.getProject() != null && p.getProject().equals(getProjectId())) { |
| propertyMap.put(p.getName(), p); |
| } |
| } |
| } |
| } |
| } |
| |
| private void initCrossReferenceAdapter() { |
| |
| // default |
| boolean useCrossReferenceAdapter = true; |
| |
| for (final ESExtensionElement element : new ESExtensionPoint( |
| "org.eclipse.emf.emfstore.client.inverseCrossReferenceCache") //$NON-NLS-1$ |
| .getExtensionElements()) { |
| useCrossReferenceAdapter &= element.getBoolean("activated"); //$NON-NLS-1$ |
| } |
| |
| if (useCrossReferenceAdapter) { |
| crossReferenceAdapter = new ECrossReferenceAdapter(); |
| getProject().eAdapters().add(crossReferenceAdapter); |
| } |
| } |
| |
| private void initResourcePersister() { |
| |
| resourcePersister = new ResourcePersister(toAPI()); |
| |
| if (!isTransient) { |
| resourcePersister.addResource(eResource()); |
| resourcePersister.addResource(getLocalChangePackage().eResource()); |
| resourcePersister.addResource(getProject().eResource()); |
| resourcePersister.addDirtyStateChangeLister(new ESLocalProjectSaveStateNotifier(toAPI())); |
| ESWorkspaceProviderImpl.getObserverBus().register(resourcePersister); |
| } |
| } |
| |
| /** |
| * Returns the file transfer manager. |
| * |
| * @return the file transfer manager |
| */ |
| public FileTransferManager getFileTransferManager() { |
| return fileTransferManager; |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#initResources(org.eclipse.emf.ecore.resource.ResourceSet) |
| */ |
| public void initResources(ResourceSet resourceSet) { |
| this.resourceSet = resourceSet; |
| initCompleted = true; |
| |
| final URI projectSpaceURI = ESClientURIUtil.createProjectSpaceURI(this); |
| final URI operationsURI = ESClientURIUtil.createOperationsURI(this); |
| final URI projectURI = ESClientURIUtil.createProjectURI(this); |
| |
| setResourceCount(0); |
| |
| final List<Resource> resources = new ArrayList<Resource>(); |
| final Resource resource = resourceSet.createResource(projectURI); |
| // if resource splitting fails, we need a reference to the old resource |
| resource.getContents().add(getProject()); |
| resources.add(resource); |
| setResourceCount(getResourceCount() + 1); |
| |
| for (final EObject modelElement : getProject().getAllModelElements()) { |
| ((XMIResource) resource).setID(modelElement, getProject().getModelElementId(modelElement).getId()); |
| } |
| |
| final Resource localChangePackageResource = resourceSet.createResource(operationsURI); |
| |
| // TODO: LCP |
| resources.add(localChangePackageResource); |
| |
| final Resource projectSpaceResource = resourceSet.createResource(projectSpaceURI); |
| projectSpaceResource.getContents().add(this); |
| resources.add(projectSpaceResource); |
| |
| // save all resources that have been created |
| for (final Resource currentResource : resources) { |
| try { |
| ModelUtil.saveResource(currentResource, WorkspaceUtil.getResourceLogger()); |
| } catch (final IOException e) { |
| WorkspaceUtil.logException(Messages.ProjectSpaceBase_Resource_Init_Failed, e); |
| } |
| } |
| |
| init(); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#delete(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public void delete(IProgressMonitor monitor) throws IOException { |
| |
| ESWorkspaceProviderImpl.getObserverBus().notify(DeleteProjectSpaceObserver.class).projectSpaceDeleted(this); |
| |
| // delete project to notify listeners |
| getProject().delete(); |
| |
| // remove resources from resource set and delete them |
| deleteResource(getProject().eResource()); |
| deleteResource(eResource()); |
| |
| if (FileBasedChangePackage.class.isInstance(getLocalChangePackage())) { |
| FileBasedChangePackageImpl.class.cast(getLocalChangePackage()).delete(); |
| } else { |
| // LCP - no change package in memory anymore, hence no resource available |
| final URI localChangePackageUri = ESClientURIUtil.createOperationsURI(this); |
| final URI normalizedUri = getResourceSet().getURIConverter().normalize(localChangePackageUri); |
| final String fileString = normalizedUri.toFileString(); |
| final File operationsFile = new File(fileString); |
| |
| operationsFile.delete(); |
| |
| boolean isDeleted = !operationsFile.exists(); |
| int retries = 0; |
| while (!isDeleted && retries < 3) { |
| operationsFile.delete(); |
| isDeleted = !operationsFile.exists(); |
| retries++; |
| } |
| } |
| |
| // TODO: remove project space from workspace, this is not the case if delete |
| // is performed via Workspace#deleteProjectSpace |
| ESWorkspaceProviderImpl.getInstance().getInternalWorkspace().getProjectSpaces().remove(this); |
| |
| dispose(); |
| } |
| |
| private void deleteResource(Resource resource) throws IOException { |
| if (resource != null) { |
| resource.delete(null); |
| } |
| } |
| |
| /** |
| * Returns the {@link ECrossReferenceAdapter}, if available. |
| * |
| * @param modelElement |
| * the model element for which to find inverse cross references |
| * |
| * @return the {@link ECrossReferenceAdapter} |
| */ |
| public Collection<Setting> findInverseCrossReferences(EObject modelElement) { |
| if (crossReferenceAdapter != null) { |
| return crossReferenceAdapter.getInverseReferences(modelElement); |
| } |
| |
| return UsageCrossReferencer.find(modelElement, resourceSet); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#getResourceSet() |
| */ |
| public ResourceSet getResourceSet() { |
| return resourceSet; |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#setResourceSet(org.eclipse.emf.ecore.resource.ResourceSet) |
| */ |
| public void setResourceSet(ResourceSet resourceSet) { |
| this.resourceSet = resourceSet; |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#isTransient() |
| */ |
| public boolean isTransient() { |
| return isTransient; |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#isUpdated() |
| */ |
| public boolean isUpdated() throws ESException { |
| final PrimaryVersionSpec headVersion = resolveVersionSpec(Versions.createHEAD(getBaseVersion()), |
| new NullProgressMonitor()); |
| return getBaseVersion().equals(headVersion); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void loginCompleted(ESUsersession session) { |
| // TODO Implement possibility in observerbus to register only for |
| // certain notifier |
| if (getUsersession() == null || !getUsersession().toAPI().equals(session)) { |
| return; |
| } |
| try { |
| transmitProperties(); |
| // BEGIN SUPRESS CATCH EXCEPTION |
| } catch (final RuntimeException e) { |
| // END SUPRESS CATCH EXCEPTION |
| WorkspaceUtil.logException(Messages.ProjectSpaceBase_Transmit_Properties_Failed, e); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#makeTransient() |
| */ |
| public void makeTransient() { |
| if (initCompleted) { |
| throw new IllegalAccessError(Messages.ProjectSpaceBase_Make_Transient_Error); |
| } |
| isTransient = true; |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void mergeBranch(final PrimaryVersionSpec branchSpec, final ConflictResolver conflictResolver, |
| final IProgressMonitor monitor) |
| throws ESException { |
| |
| if (branchSpec == null || conflictResolver == null) { |
| throw new IllegalArgumentException(Messages.ProjectSpaceBase_Arguments_Must_Not_Be_Null); |
| } |
| |
| if (Versions.isSameBranch(getBaseVersion(), branchSpec)) { |
| throw new InvalidVersionSpecException(Messages.ProjectSpaceBase_Cannot_Merge_Branch_With_Itself); |
| } |
| |
| final PrimaryVersionSpec commonAncestor = new ServerCall<PrimaryVersionSpec>(this) { |
| @Override |
| protected PrimaryVersionSpec run() throws ESException { |
| return resolveVersionSpec(Versions.createANCESTOR(getBaseVersion(), |
| branchSpec), monitor); |
| } |
| }.execute(); |
| |
| final List<AbstractChangePackage> baseChanges = getChanges(commonAncestor, getBaseVersion()); |
| final List<AbstractChangePackage> branchChanges = getChanges(commonAncestor, branchSpec); |
| |
| final ChangeConflictSet conflictSet = new ConflictDetector().calculateConflicts(branchChanges, |
| baseChanges, getProject()); |
| |
| if (conflictResolver.resolveConflicts(getProject(), conflictSet)) { |
| final AbstractChangePackage copyOfResolvedConflicts = mergeResolvedConflicts(conflictSet, branchChanges, |
| baseChanges); |
| RunESCommand.WithException.run(ESException.class, new Callable<Void>() { |
| public Void call() throws Exception { |
| applyChanges(getBaseVersion(), baseChanges, copyOfResolvedConflicts, monitor, false); |
| setMergedVersion(ModelUtil.clone(branchSpec)); |
| return null; |
| } |
| }); |
| } |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#mergeResolvedConflicts(org.eclipse.emf.emfstore.internal.server.conflictDetection.ChangeConflictSet, |
| * java.util.List, java.util.List) |
| */ |
| public AbstractChangePackage mergeResolvedConflicts(ChangeConflictSet conflictSet, |
| List<AbstractChangePackage> myChangePackages, List<AbstractChangePackage> theirChangePackages) |
| throws ChangeConflictException { |
| |
| final Set<AbstractOperation> accceptedMineSet = new LinkedHashSet<AbstractOperation>(); |
| final Set<AbstractOperation> rejectedTheirsSet = new LinkedHashSet<AbstractOperation>(); |
| |
| for (final ConflictBucket conflict : conflictSet.getConflictBuckets()) { |
| if (!conflict.isResolved()) { |
| throw new ChangeConflictException( |
| Messages.ProjectSpaceBase_Conflict_During_Update_No_Resolution, |
| conflictSet); |
| } |
| accceptedMineSet.addAll(conflict.getAcceptedLocalOperations()); |
| rejectedTheirsSet.addAll(conflict.getRejectedRemoteOperations()); |
| } |
| |
| final List<AbstractOperation> acceptedMineList = new LinkedList<AbstractOperation>(); |
| for (final AbstractChangePackage locChangePackage : myChangePackages) { |
| final ESCloseableIterable<AbstractOperation> operations = locChangePackage.operations(); |
| try { |
| for (final AbstractOperation myOperation : operations.iterable()) { |
| final Set<AbstractOperation> notInvolvedInConflict = conflictSet.getNotInvolvedInConflict(); |
| final List<AbstractOperation> ops = new ArrayList<AbstractOperation>(notInvolvedInConflict); |
| |
| if (containsOp(ops, myOperation)) { |
| acceptedMineList.add(myOperation); |
| } else if (containsOp(accceptedMineSet, myOperation)) { |
| acceptedMineList.add(myOperation); |
| } |
| final Iterator<AbstractOperation> iterator = accceptedMineSet.iterator(); |
| while (iterator.hasNext()) { |
| final AbstractOperation operation = iterator.next(); |
| if (operation.getIdentifier().equals(myOperation.getIdentifier())) { |
| iterator.remove(); |
| break; |
| } |
| } |
| |
| } |
| } finally { |
| operations.close(); |
| } |
| } |
| // add all remaining operations in acceptedMineSet (they have been generated during merge) |
| acceptedMineList.addAll(accceptedMineSet); |
| |
| final List<AbstractOperation> rejectedTheirsList = new LinkedList<AbstractOperation>(); |
| for (final AbstractChangePackage theirCP : theirChangePackages) { |
| final ESCloseableIterable<AbstractOperation> operations = theirCP.operations(); |
| try { |
| for (final AbstractOperation theirOperation : operations.iterable()) { |
| |
| if (containsOp(rejectedTheirsSet, theirOperation)) { |
| rejectedTheirsList.add(theirOperation); |
| } |
| } |
| } finally { |
| operations.close(); |
| } |
| } |
| |
| final List<AbstractOperation> mergeResult = new ArrayList<AbstractOperation>(rejectedTheirsList.size() |
| + acceptedMineList.size()); |
| for (final AbstractOperation operationToReverse : rejectedTheirsList) { |
| mergeResult.add(0, operationToReverse.reverse()); |
| } |
| |
| mergeResult.addAll(acceptedMineList); |
| final AbstractChangePackage result = ChangePackageUtil.createChangePackage( |
| Configuration.getClientBehavior().useInMemoryChangePackage()); |
| |
| // dup op in mergeResult |
| result.addAll(mergeResult); |
| |
| return result; |
| } |
| |
| // TODO LCP: do we elsewhere compare operations? |
| private static boolean containsOp(Collection<AbstractOperation> ops, AbstractOperation op) { |
| for (final AbstractOperation abstractOperation : ops) { |
| if (OperationUtil.isCreateDelete(abstractOperation) && |
| OperationUtil.isCreateDelete(op)) { |
| |
| final CreateDeleteOperation createDeleteOperation = CreateDeleteOperation.class.cast(abstractOperation); |
| final CreateDeleteOperation otherCreateDeleteOperation = CreateDeleteOperation.class.cast(op); |
| |
| if (createDeleteOperation.getOperationId().equals(otherCreateDeleteOperation.getOperationId()) |
| && createDeleteOperation.getModelElementId() |
| .equals(otherCreateDeleteOperation.getModelElementId())) { |
| return true; |
| } |
| |
| } else if (abstractOperation.getOperationId().equals(op.getOperationId())) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#getBranches() |
| */ |
| public List<BranchInfo> getBranches() throws ESException { |
| return new ServerCall<List<BranchInfo>>(this) { |
| @Override |
| protected List<BranchInfo> run() throws ESException { |
| final ConnectionManager cm = ESWorkspaceProviderImpl.getInstance().getConnectionManager(); |
| return cm.getBranches(getSessionId(), getProjectId()); |
| } |
| }.execute(); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#removeTag(org.eclipse.emf.emfstore.internal.server.model.versioning.PrimaryVersionSpec, |
| * org.eclipse.emf.emfstore.internal.server.model.versioning.TagVersionSpec) |
| */ |
| public void removeTag(PrimaryVersionSpec versionSpec, TagVersionSpec tag) throws ESException { |
| final ConnectionManager cm = ESWorkspaceProviderImpl.getInstance().getConnectionManager(); |
| cm.removeTag(getUsersession().getSessionId(), getProjectId(), versionSpec, tag); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#resolve(org.eclipse.emf.emfstore.internal.server.model.url.ModelElementUrlFragment) |
| */ |
| public EObject resolve(ModelElementUrlFragment modelElementUrlFragment) throws MEUrlResolutionException { |
| final ModelElementId modelElementId = modelElementUrlFragment.getModelElementId(); |
| final EObject modelElement = getProject().getModelElement(modelElementId); |
| if (modelElement == null) { |
| throw new MEUrlResolutionException(); |
| } |
| return modelElement; |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#resolveVersionSpec(org.eclipse.emf.emfstore.internal.server.model.versioning.VersionSpec, |
| * org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public PrimaryVersionSpec resolveVersionSpec(final VersionSpec versionSpec, IProgressMonitor monitor) |
| throws InvalidVersionSpecException, ESException { |
| return new ServerCall<PrimaryVersionSpec>(this, monitor) { |
| @Override |
| protected PrimaryVersionSpec run() throws ESException { |
| return getConnectionManager().resolveVersionSpec( |
| getSessionId(), |
| getProjectId(), |
| versionSpec); |
| } |
| }.execute(); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#revert() |
| */ |
| public void revert() { |
| while (!getLocalChangePackage().isEmpty()) { |
| undoLastOperation(); |
| } |
| updateDirtyState(); |
| } |
| |
| /** |
| * Saves the project space itself only, no containment children. |
| */ |
| public void saveProjectSpaceOnly() { |
| saveResource(eResource()); |
| } |
| |
| /** |
| * Saves the project space. |
| */ |
| public void save() { |
| saveProjectSpaceOnly(); |
| saveChangePackage(); |
| resourcePersister.saveDirtyResources(true); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#hasUnsavedChanges() |
| */ |
| public boolean hasUnsavedChanges() { |
| |
| if (resourcePersister != null) { |
| return resourcePersister.isDirty(); |
| } |
| |
| // in case the project space has not been initialized yet |
| return false; |
| } |
| |
| private void saveChangePackage() { |
| try { |
| getLocalChangePackage().save(); |
| } catch (final IOException e) { |
| WorkspaceUtil.logException(Messages.ProjectSpaceBase_Error_During_Save |
| + Messages.ProjectSpaceBase_Delete_Project_And_Checkout_Again, e); |
| } |
| } |
| |
| /** |
| * Save the given resource that is part of the project space resource set. |
| * |
| * @param resource |
| * the resource |
| */ |
| public void saveResource(Resource resource) { |
| try { |
| if (resource == null) { |
| if (!isTransient) { |
| WorkspaceUtil.logException(Messages.ProjectSpaceBase_Resource_Not_Initialized, |
| new IllegalProjectSpaceStateException(Messages.ProjectSpaceBase_Resource_Is_Null)); |
| } |
| return; |
| } |
| ModelUtil.saveResource(resource, WorkspaceUtil.getResourceLogger()); |
| } catch (final IOException e) { |
| WorkspaceUtil.logException(Messages.ProjectSpaceBase_Error_During_Save |
| + Messages.ProjectSpaceBase_Delete_Project_And_Checkout_Again, e); |
| } |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#setProperty(org.eclipse.emf.emfstore.internal.server.model.accesscontrol.OrgUnitProperty) |
| */ |
| public void setProperty(OrgUnitProperty property) { |
| // sanity checks |
| if (getUsersession() != null && getUsersession().getACUser() != null) { |
| try { |
| if (property.getProject() == null) { |
| property.setProject(ModelUtil.clone(getProjectId())); |
| } else if (!property.getProject().equals(getProjectId())) { |
| return; |
| } |
| final OrgUnitProperty prop = getProperty(property.getName()); |
| prop.setValue(property.getValue()); |
| } catch (final PropertyNotFoundException e) { |
| getUsersession().getACUser().getProperties().add(property); |
| propertyMap.put(property.getName(), property); |
| } |
| // the properties that have been altered are retained in a separate |
| // list |
| for (final OrgUnitProperty changedProperty : getUsersession().getChangedProperties()) { |
| if (changedProperty.getName().equals(property.getName()) |
| && changedProperty.getProject().equals(getProjectId())) { |
| changedProperty.setValue(property.getValue()); |
| ESWorkspaceProviderImpl.getInstance().getWorkspace().toInternalAPI().save(); |
| return; |
| } |
| } |
| getUsersession().getChangedProperties().add(property); |
| ESWorkspaceProviderImpl.getInstance().getWorkspace().toInternalAPI().save(); |
| } |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#shareProject(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public ProjectInfo shareProject(IProgressMonitor monitor) throws ESException { |
| return shareProject(null, monitor); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#shareProject(org.eclipse.emf.emfstore.internal.client.model.Usersession, |
| * org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public ProjectInfo shareProject(Usersession session, IProgressMonitor monitor) throws ESException { |
| return new ShareController(this, session, monitor).execute(); |
| } |
| |
| /** |
| * Starts change recording on this workspace, resumes previous recordings if |
| * there are any. |
| */ |
| public void startChangeRecording() { |
| operationManager.startChangeRecording(); |
| updateDirtyState(); |
| } |
| |
| /** |
| * Stops current recording of changes and adds recorded changes to this |
| * project spaces changes. |
| */ |
| public void stopChangeRecording() { |
| if (operationManager != null) { |
| operationManager.stopChangeRecording(); |
| } |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#transmitProperties() |
| */ |
| public void transmitProperties() { |
| final List<OrgUnitProperty> temp = new ArrayList<OrgUnitProperty>(); |
| for (final OrgUnitProperty changedProperty : getUsersession().getChangedProperties()) { |
| if (changedProperty.getProject() != null && changedProperty.getProject().equals(getProjectId())) { |
| temp.add(changedProperty); |
| } |
| } |
| final ListIterator<OrgUnitProperty> iterator = temp.listIterator(); |
| while (iterator.hasNext()) { |
| try { |
| ESWorkspaceProviderImpl |
| .getInstance() |
| .getConnectionManager() |
| .transmitProperty(getUsersession().getSessionId(), iterator.next(), getUsersession().getACUser(), |
| getProjectId()); |
| iterator.remove(); |
| } catch (final ESException e) { |
| WorkspaceUtil.logException(Messages.ProjectSpaceBase_Transmission_Of_Properties_Failed, e); |
| } |
| } |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#undoLastOperation() |
| */ |
| public void undoLastOperation() { |
| undoLastOperations(1); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#undoLastOperation() |
| */ |
| public void undoLastOperations(int numberOfOperations) { |
| |
| if (numberOfOperations <= 0) { |
| return; |
| } |
| |
| if (!getLocalChangePackage().isEmpty()) { |
| final List<AbstractOperation> operations = getLocalChangePackage().removeAtEnd(1); |
| final AbstractOperation lastOperation = operations.get(0); |
| final AbstractOperation reversedOperation = lastOperation.reverse(); |
| |
| final Iterable<AbstractOperation> iterable = Collections.singletonList(reversedOperation); |
| |
| applyOperations(iterable, false); |
| operationManager.notifyOperationUndone(lastOperation); |
| |
| undoLastOperations(--numberOfOperations); |
| } |
| updateDirtyState(); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#update(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public PrimaryVersionSpec update(IProgressMonitor monitor) throws ESException { |
| return update(Versions.createHEAD(getBaseVersion()), null, monitor); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#update(org.eclipse.emf.emfstore.internal.server.model.versioning.VersionSpec) |
| */ |
| public PrimaryVersionSpec update(final VersionSpec version) throws ESException { |
| return update(version, null, null); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#update(org.eclipse.emf.emfstore.internal.server.model.versioning.VersionSpec, |
| * org.eclipse.emf.emfstore.client.callbacks.ESUpdateCallback, org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public PrimaryVersionSpec update(VersionSpec version, ESUpdateCallback callback, IProgressMonitor progress) |
| throws ESException { |
| return new UpdateController(this, version, callback, progress).execute(); |
| } |
| |
| /** |
| * Updates the dirty state of the project space. |
| */ |
| public void updateDirtyState() { |
| boolean isEmpty = true; |
| final AbstractChangePackage localChangePackage = getLocalChangePackage(); |
| if (localChangePackage == null) { |
| return; |
| } |
| isEmpty = localChangePackage.isEmpty(); |
| if (isDirty() == !isEmpty) { |
| return; |
| } |
| setDirty(!isEmpty); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.common.ESDisposable#dispose() |
| */ |
| @SuppressWarnings("unchecked") |
| public void dispose() { |
| |
| if (disposed) { |
| return; |
| } |
| |
| stopChangeRecording(); |
| |
| if (crossReferenceAdapter != null) { |
| getProject().eAdapters().remove(crossReferenceAdapter); |
| } |
| |
| final ESCommandStack commandStack = (ESCommandStack) ESWorkspaceProviderImpl.getInstance().getEditingDomain() |
| .getCommandStack(); |
| commandStack.removeCommandStackObserver(operationManager); |
| commandStack.removeCommandStackObserver(resourcePersister); |
| |
| getProject().removeIdEObjectCollectionChangeObserver(operationManager); |
| getProject().removeIdEObjectCollectionChangeObserver(resourcePersister); |
| |
| ESWorkspaceProviderImpl.getObserverBus().unregister(resourcePersister); |
| ESWorkspaceProviderImpl.getObserverBus().unregister(this, ESLoginObserver.class); |
| ESWorkspaceProviderImpl.getObserverBus().unregister(this); |
| |
| operationManager.dispose(); |
| resourcePersister.dispose(); |
| disposed = true; |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.client.model.ProjectSpace#isShared() |
| */ |
| public boolean isShared() { |
| return getUsersession() != null && getBaseVersion() != null; |
| } |
| |
| private void notifyPreRevertMyChanges(final AbstractChangePackage changePackage) { |
| ESWorkspaceProviderImpl.getObserverBus().notify(ESMergeObserver.class) |
| .preRevertMyChanges(toAPI(), changePackage.toAPI()); |
| } |
| |
| private void notifyPostRevertMyChanges() { |
| ESWorkspaceProviderImpl.getObserverBus().notify(ESMergeObserver.class).postRevertMyChanges(toAPI()); |
| } |
| |
| private void notifyPostApplyTheirChanges(List<AbstractChangePackage> theirChangePackages) { |
| |
| final List<ESChangePackage> changePackages = new ArrayList<ESChangePackage>(); |
| for (final AbstractChangePackage theirChangePackage : theirChangePackages) { |
| changePackages.add(theirChangePackage.toAPI()); |
| } |
| |
| // TODO ASYNC review this cancel |
| ESWorkspaceProviderImpl.getObserverBus().notify(ESMergeObserver.class) |
| .postApplyTheirChanges(toAPI(), changePackages); |
| } |
| |
| private void notifyPostApplyMergedChanges(AbstractChangePackage changePackage) { |
| ESWorkspaceProviderImpl.getObserverBus().notify(ESMergeObserver.class) |
| .postApplyMergedChanges( |
| toAPI(), changePackage.toAPI()); |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.common.api.APIDelegate#toAPI() |
| */ |
| public ESLocalProjectImpl toAPI() { |
| if (esLocalProjectImpl == null) { |
| esLocalProjectImpl = createAPI(); |
| } |
| return esLocalProjectImpl; |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.emfstore.internal.common.api.APIDelegate#createAPI() |
| */ |
| public ESLocalProjectImpl createAPI() { |
| return new ESLocalProjectImpl(this); |
| } |
| |
| /** |
| * Returns the {@link ESRunnableContext} operations are applied in. |
| * |
| * @return the runnable context operations are executed in |
| */ |
| public ESRunnableContext getRunnableContext() { |
| return runnableContext; |
| } |
| } |
