plugins/org.eclipse.oomph.setup.sync/src/org/eclipse/oomph/setup/internal/sync/Synchronization.java - oomph/org.eclipse.oomph - Git at Google

 /*
  * Copyright (c) 2015 Eike Stepper (Berlin, Germany) and others.
  * 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:
  *    Eike Stepper - initial API and implementation
  */
 package org.eclipse.oomph.setup.internal.sync;

 import org.eclipse.oomph.base.util.BaseUtil;
 import org.eclipse.oomph.setup.CompoundTask;
 import org.eclipse.oomph.setup.PreferenceTask;
 import org.eclipse.oomph.setup.SetupPackage;
 import org.eclipse.oomph.setup.SetupTask;
 import org.eclipse.oomph.setup.SetupTaskContainer;
 import org.eclipse.oomph.setup.internal.sync.DataProvider.NotCurrentException;
 import org.eclipse.oomph.setup.internal.sync.Snapshot.WorkingCopy;
 import org.eclipse.oomph.setup.sync.RemoteData;
 import org.eclipse.oomph.setup.sync.SyncAction;
 import org.eclipse.oomph.setup.sync.SyncActionType;
 import org.eclipse.oomph.setup.sync.SyncDelta;
 import org.eclipse.oomph.setup.sync.SyncDeltaType;
 import org.eclipse.oomph.setup.sync.SyncFactory;
 import org.eclipse.oomph.setup.sync.SyncPackage;
 import org.eclipse.oomph.setup.sync.SyncPolicy;
 import org.eclipse.oomph.util.IOUtil;
 import org.eclipse.oomph.util.ObjectUtil;
 import org.eclipse.oomph.util.StringUtil;

 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.impl.AdapterImpl;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.common.util.EMap;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.ecore.util.EcoreUtil;

 import java.io.File;
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;

 /**
  * @author Eike Stepper
  */
 public class Synchronization
 {
   public static final EClass USER_TYPE = SetupPackage.Literals.USER;

   public static final EClass REMOTE_DATA_TYPE = SyncPackage.Literals.REMOTE_DATA;

   private final ResourceSet resourceSet = SyncUtil.createResourceSet();

   private final Set<String> ids = new HashSet<String>();

   private final Map<String, String> preferenceIDs = new HashMap<String, String>();

   private final Synchronizer synchronizer;

   private final WorkingCopy localWorkingCopy;

   private final WorkingCopy remoteWorkingCopy;

   private final EMap<String, SyncPolicy> policies;

   private final Map<String, SyncAction> actions;

   private Map<String, SyncAction> unresolvedActions;

   private boolean committed;

   private boolean disposed;

   private int lastID;

   public Synchronization(Synchronizer synchronizer) throws IOException
   {
     this.synchronizer = synchronizer;

     remoteWorkingCopy = createRemoteWorkingCopy();
     localWorkingCopy = createLocalWorkingCopy();

     policies = getPolicies(remoteWorkingCopy);

     // Compute remote deltas first to make sure that new local tasks don't pick remotely existing IDs.
     Map<String, SyncDelta> remoteDeltas = computeRemoteDeltas(remoteWorkingCopy);
     Map<String, SyncDelta> localDeltas = computeLocalDeltas(localWorkingCopy);

     actions = computeSyncActions(localDeltas, remoteDeltas);

     for (Map.Entry<String, SyncAction> entry : actions.entrySet())
     {
       String id = entry.getKey();
       SyncAction action = entry.getValue();
       new ActionAdapter(action, id);
     }

     synchronizer.syncStarted();
   }

   public Synchronizer getSynchronizer()
   {
     return synchronizer;
   }

   public EMap<String, SyncPolicy> getRemotePolicies()
   {
     return policies;
   }

   private WorkingCopy createRemoteWorkingCopy() throws IOException
   {
     Snapshot snapshot = synchronizer.getRemoteSnapshot();
     return createWorkingCopy(snapshot, REMOTE_DATA_TYPE);
   }

   private WorkingCopy createLocalWorkingCopy() throws IOException
   {
     Snapshot snapshot = synchronizer.getLocalSnapshot();
     return createWorkingCopy(snapshot, USER_TYPE);
   }

   private WorkingCopy createWorkingCopy(Snapshot snapshot, EClass eClass) throws IOException
   {
     WorkingCopy workingCopy = snapshot.createWorkingCopy();

     File oldFile = snapshot.getOldFile();
     if (!oldFile.exists())
     {
       SyncUtil.inititalizeFile(oldFile, eClass, resourceSet);
     }

     File tmpFile = workingCopy.getTmpFile();
     if (!tmpFile.exists())
     {
       File newFile = snapshot.getNewFile();
       if (!newFile.exists())
       {
         SyncUtil.inititalizeFile(tmpFile, eClass, resourceSet);
       }
       else
       {
         IOUtil.copyFile(newFile, tmpFile);
       }
     }

     return workingCopy;
   }

   private EMap<String, SyncPolicy> getPolicies(WorkingCopy remoteWorkingCopy)
   {
     File file = remoteWorkingCopy.getTmpFile();
     RemoteData remoteData = loadObject(file, REMOTE_DATA_TYPE);
     return remoteData.getPolicies();
   }

   private boolean isIncluded(String id)
   {
     return SyncPolicy.EXCLUDE != policies.get(id);
   }

   private Map<String, SyncDelta> computeRemoteDeltas(WorkingCopy remoteWorkingCopy)
   {
     return computeDeltas(remoteWorkingCopy, REMOTE_DATA_TYPE);
   }

   private Map<String, SyncDelta> computeLocalDeltas(WorkingCopy localWorkingCopy)
   {
     return computeDeltas(localWorkingCopy, USER_TYPE);
   }

   private Map<String, SyncDelta> computeDeltas(WorkingCopy workingCopy, EClass eClass)
   {
     Snapshot snapshot = workingCopy.getSnapshot();

     File oldFile = snapshot.getOldFile();
     File tmpFile = workingCopy.getTmpFile();

     SetupTaskContainer oldData = loadObject(oldFile, eClass);
     SetupTaskContainer newData = loadObject(tmpFile, eClass);

     return compareTasks(oldData, newData);
   }

   private Map<String, SyncAction> computeSyncActions(Map<String, SyncDelta> localDeltas, Map<String, SyncDelta> remoteDeltas)
   {
     Map<String, SyncAction> actions = new HashMap<String, SyncAction>();

     for (Map.Entry<String, SyncDelta> localEntry : localDeltas.entrySet())
     {
       String id = localEntry.getKey();

       SyncDelta localDelta = localEntry.getValue();
       SyncDelta remoteDelta = remoteDeltas.remove(id);

       SyncAction action = compareDeltas(localDelta, remoteDelta);
       if (action != null)
       {
         actions.put(id, action);
       }
     }

     for (SyncDelta remoteDelta : remoteDeltas.values())
     {
       String id = remoteDelta.getID();
       SyncAction action = compareDeltas(null, remoteDelta);
       actions.put(id, action);
     }

     return actions;
   }

   private SyncAction compareDeltas(SyncDelta localDelta, SyncDelta remoteDelta)
   {
     SyncDeltaType localDeltaType = localDelta == null ? SyncDeltaType.UNCHANGED : localDelta.getType();
     SyncDeltaType remoteDeltaType = remoteDelta == null ? SyncDeltaType.UNCHANGED : remoteDelta.getType();

     SyncActionType actionType = compareDeltaTypes(localDeltaType, remoteDeltaType);
     if (actionType == SyncActionType.NONE)
     {
       PreferenceTask localPreference = (PreferenceTask)localDelta.getNewTask();
       PreferenceTask remotePreference = (PreferenceTask)remoteDelta.getNewTask();

       // The comparison has returned a Changed/Changed delta conflict, so compare the values.
       if (ObjectUtil.equals(localPreference.getValue(), remotePreference.getValue()))
       {
         // Ignore unchanged values.
         actionType = null;
       }
       else
       {
         actionType = SyncActionType.CONFLICT;
       }
     }

     if (actionType != null)
     {
       return SyncFactory.eINSTANCE.createSyncAction(localDelta, remoteDelta, actionType);
     }

     return null;
   }

   private SyncActionType compareDeltaTypes(SyncDeltaType localDeltaType, SyncDeltaType remoteDeltaType)
   {
     switch (localDeltaType)
     {
       case UNCHANGED:
         switch (remoteDeltaType)
         {
           case UNCHANGED:
             return null;

           case CHANGED:
             return SyncActionType.SET_REMOTE;

           case REMOVED:
             return SyncActionType.REMOVE;
         }
         break;

       case CHANGED:
         switch (remoteDeltaType)
         {
           case UNCHANGED:
             return SyncActionType.SET_LOCAL;

           case CHANGED:
             // Will be changed to CONFLICT or null by the caller.
             return SyncActionType.NONE;

           case REMOVED:
             return SyncActionType.CONFLICT;
         }
         break;

       case REMOVED:
         switch (remoteDeltaType)
         {
           case UNCHANGED:
             return SyncActionType.REMOVE;

           case CHANGED:
             return SyncActionType.CONFLICT;

           case REMOVED:
             return null;
         }
         break;
     }

     throw new IllegalArgumentException();
   }

   private Map<String, SyncDelta> compareTasks(SetupTaskContainer oldTaskContainer, SetupTaskContainer newTaskContainer)
   {
     Map<String, SyncDelta> deltas = new HashMap<String, SyncDelta>();

     Map<String, SetupTask> oldTasks = collectTasks(oldTaskContainer);
     Map<String, SetupTask> newTasks = collectTasks(newTaskContainer);

     for (Map.Entry<String, SetupTask> oldEntry : oldTasks.entrySet())
     {
       String id = oldEntry.getKey();
       if (isIncluded(id))
       {
         SetupTask oldTask = oldEntry.getValue();
         SetupTask newTask = newTasks.remove(id);

         SyncDelta delta = compareTasks(id, oldTask, newTask);
         if (delta != null)
         {
           deltas.put(id, delta);
         }
       }
     }

     for (Map.Entry<String, SetupTask> newEntry : newTasks.entrySet())
     {
       String id = newEntry.getKey();
       if (isIncluded(id))
       {
         SetupTask newTask = newEntry.getValue();

         SyncDelta delta = compareTasks(id, null, newTask);
         deltas.put(id, delta);
       }
     }

     return deltas;
   }

   private SyncDelta compareTasks(String id, SetupTask oldTask, SetupTask newTask)
   {
     if (oldTask == null)
     {
       if (newTask == null)
       {
         return null;
       }

       return SyncFactory.eINSTANCE.createSyncDelta(id, oldTask, newTask, SyncDeltaType.CHANGED);
     }

     if (newTask == null)
     {
       return SyncFactory.eINSTANCE.createSyncDelta(id, oldTask, newTask, SyncDeltaType.REMOVED);
     }

     PreferenceTask oldPreference = (PreferenceTask)oldTask;
     PreferenceTask newPreference = (PreferenceTask)newTask;

     if (!ObjectUtil.equals(oldPreference.getKey(), newPreference.getKey()))
     {
       // Ignore changed keys.
       return null;
     }

     if (ObjectUtil.equals(oldPreference.getValue(), newPreference.getValue()))
     {
       // Ignore unchanged values.
       return null;
     }

     return SyncFactory.eINSTANCE.createSyncDelta(id, oldPreference, newPreference, SyncDeltaType.CHANGED);
   }

   private Map<String, SetupTask> collectTasks(SetupTaskContainer taskContainer)
   {
     Map<String, SetupTask> tasks = new HashMap<String, SetupTask>();
     collectTasks(taskContainer.getSetupTasks(), tasks);
     return tasks;
   }

   private void collectTasks(EList<SetupTask> tasks, Map<String, SetupTask> result)
   {
     for (SetupTask task : tasks)
     {
       String id = rememberID(task);

       if (isSychronizable(task))
       {
         if (StringUtil.isEmpty(id))
         {
           id = getPreferenceID(task);

           if (StringUtil.isEmpty(id))
           {
             id = createID();
           }
           else
           {
             ids.add(id);
           }

           task.setID(id);
           rememberPreferenceID(task);
         }

         if (result.put(id, task) != null)
         {
           throw new DuplicateIDException(id);
         }
       }
       else if (task instanceof CompoundTask)
       {
         CompoundTask compoundTask = (CompoundTask)task;
         collectTasks(compoundTask.getSetupTasks(), result);
       }
     }
   }

   private String rememberID(SetupTask task)
   {
     String id = task.getID();
     if (!StringUtil.isEmpty(id))
     {
       // Make sure existing IDs are not reused.
       ids.add(id);

       rememberPreferenceID(task);
     }

     return id;
   }

   private void rememberPreferenceID(SetupTask task)
   {
     String id = task.getID();
     if (!StringUtil.isEmpty(id))
     {
       if (task instanceof PreferenceTask)
       {
         PreferenceTask preferenceTask = (PreferenceTask)task;
         String key = preferenceTask.getKey();

         if (!StringUtil.isEmpty(key))
         {
           preferenceIDs.put(key, id);
         }
       }
     }
   }

   private String getPreferenceID(SetupTask task)
   {
     if (task instanceof PreferenceTask)
     {
       PreferenceTask preferenceTask = (PreferenceTask)task;
       String key = preferenceTask.getKey();

       if (!StringUtil.isEmpty(key))
       {
         return preferenceIDs.get(key);
       }
     }

     return null;
   }

   private <T extends EObject> T loadObject(File file, EClass eClass)
   {
     URI uri = URI.createFileURI(file.getAbsolutePath());
     Resource resource = resourceSet.getResource(uri, true);
     return BaseUtil.getObjectByType(resource.getContents(), eClass);
   }

   private boolean isSychronizable(SetupTask task)
   {
     return task instanceof PreferenceTask;
   }

   private String createID()
   {
     for (int i = lastID + 1; i < Integer.MAX_VALUE; i++)
     {
       String id = "sync" + i;
       if (ids.add(id))
       {
         lastID = i;
         return id;
       }
     }

     throw new IllegalStateException("Too many IDs");
   }

   public String getID(SyncAction action)
   {
     String id = action.getID();
     if (id != null)
     {
       return id;
     }

     ActionAdapter adapter = (ActionAdapter)EcoreUtil.getAdapter(action.eAdapters(), ActionAdapter.class);
     if (adapter != null)
     {
       return adapter.getID();
     }

     return null;
   }

   public Map<String, SyncAction> getActions()
   {
     return actions;
   }

   public Map<String, SyncAction> getUnresolvedActions()
   {
     if (unresolvedActions == null)
     {
       unresolvedActions = new HashMap<String, SyncAction>();

       for (Map.Entry<String, SyncAction> entry : actions.entrySet())
       {
         SyncAction action = entry.getValue();

         if (action.getEffectiveType() == SyncActionType.CONFLICT)
         {
           String id = entry.getKey();
           unresolvedActions.put(id, action);
         }
       }
     }

     return unresolvedActions;
   }

   public Synchronization resolve(String id, SyncActionType resolvedType)
   {
     SyncAction action = actions.get(id);
     if (action != null)
     {
       action.setResolvedType(resolvedType);
     }

     return this;
   }

   public void commit() throws IOException, NotCurrentException
   {
     if (!committed && !disposed)
     {
       committed = true;
       doCommit();
     }
   }

   private void doCommit() throws IOException, NotCurrentException
   {
     synchronizer.commitStarted();

     try
     {
       applyActions(remoteWorkingCopy, REMOTE_DATA_TYPE);
       remoteWorkingCopy.commit();

       applyActions(localWorkingCopy, USER_TYPE);
       localWorkingCopy.commit();

       synchronizer.commitFinished(null);
     }
     catch (IOException ex)
     {
       synchronizer.commitFinished(ex);
       throw ex;
     }
     catch (RuntimeException ex)
     {
       synchronizer.commitFinished(ex);
       throw ex;
     }
     catch (Error ex)
     {
       synchronizer.commitFinished(ex);
       throw ex;
     }
     finally
     {
       doDispose();
     }
   }

   private void applyActions(WorkingCopy workingCopy, EClass eClass)
   {
     File file = workingCopy.getTmpFile();

     SetupTaskContainer taskContainer = loadObject(file, eClass);
     Map<String, SetupTask> tasks = collectTasks(taskContainer);

     for (Map.Entry<String, SyncAction> entry : actions.entrySet())
     {
       String id = entry.getKey();
       SyncAction action = entry.getValue();
       SyncActionType type = action.getEffectiveType();

       switch (type)
       {
         case CONFLICT:
           throw new ConflictException(action);

         case SET_LOCAL:
           include(id);
           applySetAction(taskContainer, tasks, id, action.getLocalDelta());
           break;

         case SET_REMOTE:
           include(id);
           applySetAction(taskContainer, tasks, id, action.getRemoteDelta());
           break;

         case REMOVE:
           include(id);
           applyRemoveAction(taskContainer, tasks, action.getLocalDelta());
           applyRemoveAction(taskContainer, tasks, action.getRemoteDelta());
           break;

         case EXCLUDE:
           exclude(id);
           applyRemoveAction(taskContainer, tasks, action.getRemoteDelta());
           break;

         default:
           // Do nothing.
           break;
       }
     }

     BaseUtil.saveEObject(taskContainer);
   }

   private void applySetAction(SetupTaskContainer taskContainer, Map<String, SetupTask> tasks, String id, SyncDelta delta)
   {
     if (delta != null)
     {
       SetupTask newTask = delta.getNewTask();
       if (newTask != null)
       {
         newTask = EcoreUtil.copy(newTask);
         newTask.setID(id);
         newTask.getRestrictions().clear();
         newTask.getPredecessors().clear();
         newTask.getSuccessors().clear();

         SetupTask oldTask = tasks.get(id);
         if (oldTask != null)
         {
           EcoreUtil.replace(oldTask, newTask);
         }
         else
         {
           taskContainer.getSetupTasks().add(newTask);
         }
       }
     }
   }

   private void applyRemoveAction(SetupTaskContainer taskContainer, Map<String, SetupTask> tasks, SyncDelta delta)
   {
     if (delta != null)
     {
       String id = delta.getID();

       SetupTask oldTask = tasks.get(id);
       if (oldTask != null)
       {
         EcoreUtil.remove(oldTask);
       }
     }
   }

   private void include(String id)
   {
     policies.put(id, SyncPolicy.INCLUDE);
   }

   private void exclude(String id)
   {
     policies.put(id, SyncPolicy.EXCLUDE);
   }

   public void dispose()
   {
     if (!disposed)
     {
       doDispose();
     }
   }

   private void doDispose()
   {
     disposed = true;

     try
     {
       localWorkingCopy.dispose();
     }
     catch (Throwable ex)
     {
       SetupSyncPlugin.INSTANCE.log(ex);
     }

     try
     {
       remoteWorkingCopy.dispose();
     }
     catch (Throwable ex)
     {
       SetupSyncPlugin.INSTANCE.log(ex);
     }

     try
     {
       synchronizer.releaseLock();
     }
     catch (Throwable ex)
     {
       SetupSyncPlugin.INSTANCE.log(ex);
     }
   }

   /**
    * @author Eike Stepper
    */
   private final class ActionAdapter extends AdapterImpl
   {
     private final String id;

     public ActionAdapter(SyncAction action, String id)
     {
       this.id = id;
       action.eAdapters().add(this);
     }

     public String getID()
     {
       return id;
     }

     @Override
     public void notifyChanged(Notification msg)
     {
       if (msg.getFeature() == SyncPackage.Literals.SYNC_ACTION__RESOLVED_TYPE && !msg.isTouch())
       {
         unresolvedActions = null;

         SyncAction action = (SyncAction)getTarget();
         synchronizer.actionResolved(action, id);
       }
     }
   }

   /**
    * @author Eike Stepper
    */
   public static class DuplicateIDException extends SnychronizerException
   {
     private static final long serialVersionUID = 1L;

     public DuplicateIDException(String id)
     {
       super("Duplicate ID: " + id);
     }
   }

   /**
    * @author Eike Stepper
    */
   public static class ConflictException extends SnychronizerException
   {
     private static final long serialVersionUID = 1L;

     public ConflictException(SyncAction action)
     {
       super("Conflict: " + action);
     }
   }
 }
	/*
	* Copyright (c) 2015 Eike Stepper (Berlin, Germany) and others.
	* 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:
	* Eike Stepper - initial API and implementation
	*/
	package org.eclipse.oomph.setup.internal.sync;

	import org.eclipse.oomph.base.util.BaseUtil;
	import org.eclipse.oomph.setup.CompoundTask;
	import org.eclipse.oomph.setup.PreferenceTask;
	import org.eclipse.oomph.setup.SetupPackage;
	import org.eclipse.oomph.setup.SetupTask;
	import org.eclipse.oomph.setup.SetupTaskContainer;
	import org.eclipse.oomph.setup.internal.sync.DataProvider.NotCurrentException;
	import org.eclipse.oomph.setup.internal.sync.Snapshot.WorkingCopy;
	import org.eclipse.oomph.setup.sync.RemoteData;
	import org.eclipse.oomph.setup.sync.SyncAction;
	import org.eclipse.oomph.setup.sync.SyncActionType;
	import org.eclipse.oomph.setup.sync.SyncDelta;
	import org.eclipse.oomph.setup.sync.SyncDeltaType;
	import org.eclipse.oomph.setup.sync.SyncFactory;
	import org.eclipse.oomph.setup.sync.SyncPackage;
	import org.eclipse.oomph.setup.sync.SyncPolicy;
	import org.eclipse.oomph.util.IOUtil;
	import org.eclipse.oomph.util.ObjectUtil;
	import org.eclipse.oomph.util.StringUtil;

	import org.eclipse.emf.common.notify.Notification;
	import org.eclipse.emf.common.notify.impl.AdapterImpl;
	import org.eclipse.emf.common.util.EList;
	import org.eclipse.emf.common.util.EMap;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.EClass;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.ecore.resource.ResourceSet;
	import org.eclipse.emf.ecore.util.EcoreUtil;

	import java.io.File;
	import java.io.IOException;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Map;
	import java.util.Set;

	/**
	* @author Eike Stepper
	*/
	public class Synchronization
	{
	public static final EClass USER_TYPE = SetupPackage.Literals.USER;

	public static final EClass REMOTE_DATA_TYPE = SyncPackage.Literals.REMOTE_DATA;

	private final ResourceSet resourceSet = SyncUtil.createResourceSet();

	private final Set<String> ids = new HashSet<String>();

	private final Map<String, String> preferenceIDs = new HashMap<String, String>();

	private final Synchronizer synchronizer;

	private final WorkingCopy localWorkingCopy;

	private final WorkingCopy remoteWorkingCopy;

	private final EMap<String, SyncPolicy> policies;

	private final Map<String, SyncAction> actions;

	private Map<String, SyncAction> unresolvedActions;

	private boolean committed;

	private boolean disposed;

	private int lastID;

	public Synchronization(Synchronizer synchronizer) throws IOException
	{
	this.synchronizer = synchronizer;

	remoteWorkingCopy = createRemoteWorkingCopy();
	localWorkingCopy = createLocalWorkingCopy();

	policies = getPolicies(remoteWorkingCopy);

	// Compute remote deltas first to make sure that new local tasks don't pick remotely existing IDs.
	Map<String, SyncDelta> remoteDeltas = computeRemoteDeltas(remoteWorkingCopy);
	Map<String, SyncDelta> localDeltas = computeLocalDeltas(localWorkingCopy);

	actions = computeSyncActions(localDeltas, remoteDeltas);

	for (Map.Entry<String, SyncAction> entry : actions.entrySet())
	{
	String id = entry.getKey();
	SyncAction action = entry.getValue();
	new ActionAdapter(action, id);
	}

	synchronizer.syncStarted();
	}

	public Synchronizer getSynchronizer()
	{
	return synchronizer;
	}

	public EMap<String, SyncPolicy> getRemotePolicies()
	{
	return policies;
	}

	private WorkingCopy createRemoteWorkingCopy() throws IOException
	{
	Snapshot snapshot = synchronizer.getRemoteSnapshot();
	return createWorkingCopy(snapshot, REMOTE_DATA_TYPE);
	}

	private WorkingCopy createLocalWorkingCopy() throws IOException
	{
	Snapshot snapshot = synchronizer.getLocalSnapshot();
	return createWorkingCopy(snapshot, USER_TYPE);
	}

	private WorkingCopy createWorkingCopy(Snapshot snapshot, EClass eClass) throws IOException
	{
	WorkingCopy workingCopy = snapshot.createWorkingCopy();

	File oldFile = snapshot.getOldFile();
	if (!oldFile.exists())
	{
	SyncUtil.inititalizeFile(oldFile, eClass, resourceSet);
	}

	File tmpFile = workingCopy.getTmpFile();
	if (!tmpFile.exists())
	{
	File newFile = snapshot.getNewFile();
	if (!newFile.exists())
	{
	SyncUtil.inititalizeFile(tmpFile, eClass, resourceSet);
	}
	else
	{
	IOUtil.copyFile(newFile, tmpFile);
	}
	}

	return workingCopy;
	}

	private EMap<String, SyncPolicy> getPolicies(WorkingCopy remoteWorkingCopy)
	{
	File file = remoteWorkingCopy.getTmpFile();
	RemoteData remoteData = loadObject(file, REMOTE_DATA_TYPE);
	return remoteData.getPolicies();
	}

	private boolean isIncluded(String id)
	{
	return SyncPolicy.EXCLUDE != policies.get(id);
	}

	private Map<String, SyncDelta> computeRemoteDeltas(WorkingCopy remoteWorkingCopy)
	{
	return computeDeltas(remoteWorkingCopy, REMOTE_DATA_TYPE);
	}

	private Map<String, SyncDelta> computeLocalDeltas(WorkingCopy localWorkingCopy)
	{
	return computeDeltas(localWorkingCopy, USER_TYPE);
	}

	private Map<String, SyncDelta> computeDeltas(WorkingCopy workingCopy, EClass eClass)
	{
	Snapshot snapshot = workingCopy.getSnapshot();

	File oldFile = snapshot.getOldFile();
	File tmpFile = workingCopy.getTmpFile();

	SetupTaskContainer oldData = loadObject(oldFile, eClass);
	SetupTaskContainer newData = loadObject(tmpFile, eClass);

	return compareTasks(oldData, newData);
	}

	private Map<String, SyncAction> computeSyncActions(Map<String, SyncDelta> localDeltas, Map<String, SyncDelta> remoteDeltas)
	{
	Map<String, SyncAction> actions = new HashMap<String, SyncAction>();

	for (Map.Entry<String, SyncDelta> localEntry : localDeltas.entrySet())
	{
	String id = localEntry.getKey();

	SyncDelta localDelta = localEntry.getValue();
	SyncDelta remoteDelta = remoteDeltas.remove(id);

	SyncAction action = compareDeltas(localDelta, remoteDelta);
	if (action != null)
	{
	actions.put(id, action);
	}
	}

	for (SyncDelta remoteDelta : remoteDeltas.values())
	{
	String id = remoteDelta.getID();
	SyncAction action = compareDeltas(null, remoteDelta);
	actions.put(id, action);
	}

	return actions;
	}

	private SyncAction compareDeltas(SyncDelta localDelta, SyncDelta remoteDelta)
	{
	SyncDeltaType localDeltaType = localDelta == null ? SyncDeltaType.UNCHANGED : localDelta.getType();
	SyncDeltaType remoteDeltaType = remoteDelta == null ? SyncDeltaType.UNCHANGED : remoteDelta.getType();

	SyncActionType actionType = compareDeltaTypes(localDeltaType, remoteDeltaType);
	if (actionType == SyncActionType.NONE)
	{
	PreferenceTask localPreference = (PreferenceTask)localDelta.getNewTask();
	PreferenceTask remotePreference = (PreferenceTask)remoteDelta.getNewTask();

	// The comparison has returned a Changed/Changed delta conflict, so compare the values.
	if (ObjectUtil.equals(localPreference.getValue(), remotePreference.getValue()))
	{
	// Ignore unchanged values.
	actionType = null;
	}
	else
	{
	actionType = SyncActionType.CONFLICT;
	}
	}

	if (actionType != null)
	{
	return SyncFactory.eINSTANCE.createSyncAction(localDelta, remoteDelta, actionType);
	}

	return null;
	}

	private SyncActionType compareDeltaTypes(SyncDeltaType localDeltaType, SyncDeltaType remoteDeltaType)
	{
	switch (localDeltaType)
	{
	case UNCHANGED:
	switch (remoteDeltaType)
	{
	case UNCHANGED:
	return null;

	case CHANGED:
	return SyncActionType.SET_REMOTE;

	case REMOVED:
	return SyncActionType.REMOVE;
	}
	break;

	case CHANGED:
	switch (remoteDeltaType)
	{
	case UNCHANGED:
	return SyncActionType.SET_LOCAL;

	case CHANGED:
	// Will be changed to CONFLICT or null by the caller.
	return SyncActionType.NONE;

	case REMOVED:
	return SyncActionType.CONFLICT;
	}
	break;

	case REMOVED:
	switch (remoteDeltaType)
	{
	case UNCHANGED:
	return SyncActionType.REMOVE;

	case CHANGED:
	return SyncActionType.CONFLICT;

	case REMOVED:
	return null;
	}
	break;
	}

	throw new IllegalArgumentException();
	}

	private Map<String, SyncDelta> compareTasks(SetupTaskContainer oldTaskContainer, SetupTaskContainer newTaskContainer)
	{
	Map<String, SyncDelta> deltas = new HashMap<String, SyncDelta>();

	Map<String, SetupTask> oldTasks = collectTasks(oldTaskContainer);
	Map<String, SetupTask> newTasks = collectTasks(newTaskContainer);

	for (Map.Entry<String, SetupTask> oldEntry : oldTasks.entrySet())
	{
	String id = oldEntry.getKey();
	if (isIncluded(id))
	{
	SetupTask oldTask = oldEntry.getValue();
	SetupTask newTask = newTasks.remove(id);

	SyncDelta delta = compareTasks(id, oldTask, newTask);
	if (delta != null)
	{
	deltas.put(id, delta);
	}
	}
	}

	for (Map.Entry<String, SetupTask> newEntry : newTasks.entrySet())
	{
	String id = newEntry.getKey();
	if (isIncluded(id))
	{
	SetupTask newTask = newEntry.getValue();

	SyncDelta delta = compareTasks(id, null, newTask);
	deltas.put(id, delta);
	}
	}

	return deltas;
	}

	private SyncDelta compareTasks(String id, SetupTask oldTask, SetupTask newTask)
	{
	if (oldTask == null)
	{
	if (newTask == null)
	{
	return null;
	}

	return SyncFactory.eINSTANCE.createSyncDelta(id, oldTask, newTask, SyncDeltaType.CHANGED);
	}

	if (newTask == null)
	{
	return SyncFactory.eINSTANCE.createSyncDelta(id, oldTask, newTask, SyncDeltaType.REMOVED);
	}

	PreferenceTask oldPreference = (PreferenceTask)oldTask;
	PreferenceTask newPreference = (PreferenceTask)newTask;

	if (!ObjectUtil.equals(oldPreference.getKey(), newPreference.getKey()))
	{
	// Ignore changed keys.
	return null;
	}

	if (ObjectUtil.equals(oldPreference.getValue(), newPreference.getValue()))
	{
	// Ignore unchanged values.
	return null;
	}

	return SyncFactory.eINSTANCE.createSyncDelta(id, oldPreference, newPreference, SyncDeltaType.CHANGED);
	}

	private Map<String, SetupTask> collectTasks(SetupTaskContainer taskContainer)
	{
	Map<String, SetupTask> tasks = new HashMap<String, SetupTask>();
	collectTasks(taskContainer.getSetupTasks(), tasks);
	return tasks;
	}

	private void collectTasks(EList<SetupTask> tasks, Map<String, SetupTask> result)
	{
	for (SetupTask task : tasks)
	{
	String id = rememberID(task);

	if (isSychronizable(task))
	{
	if (StringUtil.isEmpty(id))
	{
	id = getPreferenceID(task);

	if (StringUtil.isEmpty(id))
	{
	id = createID();
	}
	else
	{
	ids.add(id);
	}

	task.setID(id);
	rememberPreferenceID(task);
	}

	if (result.put(id, task) != null)
	{
	throw new DuplicateIDException(id);
	}
	}
	else if (task instanceof CompoundTask)
	{
	CompoundTask compoundTask = (CompoundTask)task;
	collectTasks(compoundTask.getSetupTasks(), result);
	}
	}
	}

	private String rememberID(SetupTask task)
	{
	String id = task.getID();
	if (!StringUtil.isEmpty(id))
	{
	// Make sure existing IDs are not reused.
	ids.add(id);

	rememberPreferenceID(task);
	}

	return id;
	}

	private void rememberPreferenceID(SetupTask task)
	{
	String id = task.getID();
	if (!StringUtil.isEmpty(id))
	{
	if (task instanceof PreferenceTask)
	{
	PreferenceTask preferenceTask = (PreferenceTask)task;
	String key = preferenceTask.getKey();

	if (!StringUtil.isEmpty(key))
	{
	preferenceIDs.put(key, id);
	}
	}
	}
	}

	private String getPreferenceID(SetupTask task)
	{
	if (task instanceof PreferenceTask)
	{
	PreferenceTask preferenceTask = (PreferenceTask)task;
	String key = preferenceTask.getKey();

	if (!StringUtil.isEmpty(key))
	{
	return preferenceIDs.get(key);
	}
	}

	return null;
	}

	private <T extends EObject> T loadObject(File file, EClass eClass)
	{
	URI uri = URI.createFileURI(file.getAbsolutePath());
	Resource resource = resourceSet.getResource(uri, true);
	return BaseUtil.getObjectByType(resource.getContents(), eClass);
	}

	private boolean isSychronizable(SetupTask task)
	{
	return task instanceof PreferenceTask;
	}

	private String createID()
	{
	for (int i = lastID + 1; i < Integer.MAX_VALUE; i++)
	{
	String id = "sync" + i;
	if (ids.add(id))
	{
	lastID = i;
	return id;
	}
	}

	throw new IllegalStateException("Too many IDs");
	}

	public String getID(SyncAction action)
	{
	String id = action.getID();
	if (id != null)
	{
	return id;
	}

	ActionAdapter adapter = (ActionAdapter)EcoreUtil.getAdapter(action.eAdapters(), ActionAdapter.class);
	if (adapter != null)
	{
	return adapter.getID();
	}

	return null;
	}

	public Map<String, SyncAction> getActions()
	{
	return actions;
	}

	public Map<String, SyncAction> getUnresolvedActions()
	{
	if (unresolvedActions == null)
	{
	unresolvedActions = new HashMap<String, SyncAction>();

	for (Map.Entry<String, SyncAction> entry : actions.entrySet())
	{
	SyncAction action = entry.getValue();

	if (action.getEffectiveType() == SyncActionType.CONFLICT)
	{
	String id = entry.getKey();
	unresolvedActions.put(id, action);
	}
	}
	}

	return unresolvedActions;
	}

	public Synchronization resolve(String id, SyncActionType resolvedType)
	{
	SyncAction action = actions.get(id);
	if (action != null)
	{
	action.setResolvedType(resolvedType);
	}

	return this;
	}

	public void commit() throws IOException, NotCurrentException
	{
	if (!committed && !disposed)
	{
	committed = true;
	doCommit();
	}
	}

	private void doCommit() throws IOException, NotCurrentException
	{
	synchronizer.commitStarted();

	try
	{
	applyActions(remoteWorkingCopy, REMOTE_DATA_TYPE);
	remoteWorkingCopy.commit();

	applyActions(localWorkingCopy, USER_TYPE);
	localWorkingCopy.commit();

	synchronizer.commitFinished(null);
	}
	catch (IOException ex)
	{
	synchronizer.commitFinished(ex);
	throw ex;
	}
	catch (RuntimeException ex)
	{
	synchronizer.commitFinished(ex);
	throw ex;
	}
	catch (Error ex)
	{
	synchronizer.commitFinished(ex);
	throw ex;
	}
	finally
	{
	doDispose();
	}
	}

	private void applyActions(WorkingCopy workingCopy, EClass eClass)
	{
	File file = workingCopy.getTmpFile();

	SetupTaskContainer taskContainer = loadObject(file, eClass);
	Map<String, SetupTask> tasks = collectTasks(taskContainer);

	for (Map.Entry<String, SyncAction> entry : actions.entrySet())
	{
	String id = entry.getKey();
	SyncAction action = entry.getValue();
	SyncActionType type = action.getEffectiveType();

	switch (type)
	{
	case CONFLICT:
	throw new ConflictException(action);

	case SET_LOCAL:
	include(id);
	applySetAction(taskContainer, tasks, id, action.getLocalDelta());
	break;

	case SET_REMOTE:
	include(id);
	applySetAction(taskContainer, tasks, id, action.getRemoteDelta());
	break;

	case REMOVE:
	include(id);
	applyRemoveAction(taskContainer, tasks, action.getLocalDelta());
	applyRemoveAction(taskContainer, tasks, action.getRemoteDelta());
	break;

	case EXCLUDE:
	exclude(id);
	applyRemoveAction(taskContainer, tasks, action.getRemoteDelta());
	break;

	default:
	// Do nothing.
	break;
	}
	}

	BaseUtil.saveEObject(taskContainer);
	}

	private void applySetAction(SetupTaskContainer taskContainer, Map<String, SetupTask> tasks, String id, SyncDelta delta)
	{
	if (delta != null)
	{
	SetupTask newTask = delta.getNewTask();
	if (newTask != null)
	{
	newTask = EcoreUtil.copy(newTask);
	newTask.setID(id);
	newTask.getRestrictions().clear();
	newTask.getPredecessors().clear();
	newTask.getSuccessors().clear();

	SetupTask oldTask = tasks.get(id);
	if (oldTask != null)
	{
	EcoreUtil.replace(oldTask, newTask);
	}
	else
	{
	taskContainer.getSetupTasks().add(newTask);
	}
	}
	}
	}

	private void applyRemoveAction(SetupTaskContainer taskContainer, Map<String, SetupTask> tasks, SyncDelta delta)
	{
	if (delta != null)
	{
	String id = delta.getID();

	SetupTask oldTask = tasks.get(id);
	if (oldTask != null)
	{
	EcoreUtil.remove(oldTask);
	}
	}
	}

	private void include(String id)
	{
	policies.put(id, SyncPolicy.INCLUDE);
	}

	private void exclude(String id)
	{
	policies.put(id, SyncPolicy.EXCLUDE);
	}

	public void dispose()
	{
	if (!disposed)
	{
	doDispose();
	}
	}

	private void doDispose()
	{
	disposed = true;

	try
	{
	localWorkingCopy.dispose();
	}
	catch (Throwable ex)
	{
	SetupSyncPlugin.INSTANCE.log(ex);
	}

	try
	{
	remoteWorkingCopy.dispose();
	}
	catch (Throwable ex)
	{
	SetupSyncPlugin.INSTANCE.log(ex);
	}

	try
	{
	synchronizer.releaseLock();
	}
	catch (Throwable ex)
	{
	SetupSyncPlugin.INSTANCE.log(ex);
	}
	}

	/**
	* @author Eike Stepper
	*/
	private final class ActionAdapter extends AdapterImpl
	{
	private final String id;

	public ActionAdapter(SyncAction action, String id)
	{
	this.id = id;
	action.eAdapters().add(this);
	}

	public String getID()
	{
	return id;
	}

	@Override
	public void notifyChanged(Notification msg)
	{
	if (msg.getFeature() == SyncPackage.Literals.SYNC_ACTION__RESOLVED_TYPE && !msg.isTouch())
	{
	unresolvedActions = null;

	SyncAction action = (SyncAction)getTarget();
	synchronizer.actionResolved(action, id);
	}
	}
	}

	/**
	* @author Eike Stepper
	*/
	public static class DuplicateIDException extends SnychronizerException
	{
	private static final long serialVersionUID = 1L;

	public DuplicateIDException(String id)
	{
	super("Duplicate ID: " + id);
	}
	}

	/**
	* @author Eike Stepper
	*/
	public static class ConflictException extends SnychronizerException
	{
	private static final long serialVersionUID = 1L;

	public ConflictException(SyncAction action)
	{
	super("Conflict: " + action);
	}
	}
	}