| /******************************************************************************* |
| * Copyright (c) 2004, 2015 Tasktop Technologies 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: |
| * Tasktop Technologies - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.mylyn.internal.tasks.core.sync; |
| |
| import java.text.MessageFormat; |
| import java.text.SimpleDateFormat; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.MultiStatus; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.SubProgressMonitor; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.mylyn.commons.core.StatusHandler; |
| import org.eclipse.mylyn.commons.net.Policy; |
| import org.eclipse.mylyn.internal.tasks.core.AbstractTask; |
| import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants; |
| import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants.ObjectSchedulingRule; |
| import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery; |
| import org.eclipse.mylyn.internal.tasks.core.TaskList; |
| import org.eclipse.mylyn.internal.tasks.core.data.TaskDataManager; |
| import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector; |
| import org.eclipse.mylyn.tasks.core.IRepositoryModel; |
| import org.eclipse.mylyn.tasks.core.ITask; |
| import org.eclipse.mylyn.tasks.core.ITask.SynchronizationState; |
| import org.eclipse.mylyn.tasks.core.TaskRepository; |
| import org.eclipse.mylyn.tasks.core.data.TaskData; |
| import org.eclipse.mylyn.tasks.core.data.TaskDataCollector; |
| import org.eclipse.mylyn.tasks.core.data.TaskRelation; |
| import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession; |
| import org.eclipse.mylyn.tasks.core.sync.SynchronizationJob; |
| import org.eclipse.osgi.util.NLS; |
| |
| /** |
| * @author Mik Kersten |
| * @author Rob Elves |
| * @author Steffen Pingel |
| */ |
| public class SynchronizeQueriesJob extends SynchronizationJob { |
| |
| private class TaskCollector extends TaskDataCollector { |
| |
| private final Set<ITask> removedQueryResults; |
| |
| private final RepositoryQuery repositoryQuery; |
| |
| private int resultCount; |
| |
| private final SynchronizationSession session; |
| |
| public TaskCollector(RepositoryQuery repositoryQuery, SynchronizationSession session) { |
| this.repositoryQuery = repositoryQuery; |
| this.session = session; |
| this.removedQueryResults = new HashSet<ITask>(repositoryQuery.getChildren()); |
| } |
| |
| @Override |
| public void accept(TaskData taskData) { |
| ITask task = taskList.getTask(taskData.getRepositoryUrl(), taskData.getTaskId()); |
| if (task == null) { |
| task = tasksModel.createTask(repository, taskData.getTaskId()); |
| ((AbstractTask) task).setSynchronizationState(SynchronizationState.INCOMING_NEW); |
| if (taskData.isPartial() && connector.canSynchronizeTask(repository, task)) { |
| session.markStale(task); |
| } |
| } else { |
| removedQueryResults.remove(task); |
| } |
| taskList.addTask(task, repositoryQuery); |
| try { |
| session.putTaskData(task, taskData); |
| } catch (CoreException e) { |
| StatusHandler.log(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN, "Failed to save task", e)); //$NON-NLS-1$ |
| } |
| resultCount++; |
| } |
| |
| public Set<ITask> getRemovedChildren() { |
| return removedQueryResults; |
| } |
| |
| public int getResultCount() { |
| return resultCount; |
| } |
| |
| @Override |
| public void failed(String taskId, IStatus status) { |
| ITask task = taskList.getTask(repositoryQuery.getRepositoryUrl(), taskId); |
| if (task != null && status != null) { |
| statuses.add(status); |
| ((AbstractTask) task).setStatus(status); |
| if (!isUser()) { |
| ((AbstractTask) task).setSynchronizing(false); |
| } |
| taskList.notifyElementChanged(task); |
| } |
| } |
| |
| } |
| |
| private final AbstractRepositoryConnector connector; |
| |
| private final Set<RepositoryQuery> queries; |
| |
| private final TaskRepository repository; |
| |
| private final TaskDataManager taskDataManager; |
| |
| private final TaskList taskList; |
| |
| private final IRepositoryModel tasksModel; |
| |
| private final List<IStatus> statuses; |
| |
| public SynchronizeQueriesJob(TaskList taskList, TaskDataManager taskDataManager, IRepositoryModel tasksModel, |
| AbstractRepositoryConnector connector, TaskRepository repository, Set<RepositoryQuery> queries) { |
| super(Messages.SynchronizeQueriesJob_Synchronizing_Queries + " (" + repository.getRepositoryLabel() + ")"); //$NON-NLS-1$//$NON-NLS-2$ |
| this.taskList = taskList; |
| this.taskDataManager = taskDataManager; |
| this.tasksModel = tasksModel; |
| this.connector = connector; |
| this.repository = repository; |
| this.queries = queries; |
| this.statuses = new ArrayList<IStatus>(); |
| } |
| |
| @Override |
| public IStatus run(IProgressMonitor jobMonitor) { |
| try { |
| monitor.setCanceled(false); |
| monitor.attach(jobMonitor); |
| try { |
| monitor.beginTask(Messages.SynchronizeQueriesJob_Processing, 20 + queries.size() * 20 + 40 + 10); |
| |
| Set<ITask> allTasks; |
| if (!isFullSynchronization()) { |
| allTasks = new HashSet<ITask>(); |
| for (RepositoryQuery query : queries) { |
| allTasks.addAll(query.getChildren()); |
| } |
| } else { |
| allTasks = taskList.getTasks(repository.getRepositoryUrl()); |
| } |
| |
| ObjectSchedulingRule rule = new ObjectSchedulingRule(repository); |
| try { |
| Job.getJobManager().beginRule(rule, monitor); |
| |
| final Map<String, TaskRelation[]> relationsByTaskId = new HashMap<String, TaskRelation[]>(); |
| SynchronizationSession session = new SynchronizationSession(taskDataManager) { |
| @Override |
| public void putTaskData(ITask task, TaskData taskData) throws CoreException { |
| boolean changed = connector.hasTaskChanged(repository, task, taskData); |
| taskDataManager.putUpdatedTaskData(task, taskData, isUser(), this, monitor); |
| if (taskData.isPartial()) { |
| if (changed && connector.canSynchronizeTask(repository, task)) { |
| markStale(task); |
| } |
| } else { |
| Collection<TaskRelation> relations = connector.getTaskRelations(taskData); |
| if (relations != null) { |
| relationsByTaskId.put(task.getTaskId(), relations.toArray(new TaskRelation[0])); |
| } |
| } |
| } |
| }; |
| session.setTaskRepository(repository); |
| session.setFullSynchronization(isFullSynchronization()); |
| session.setTasks(Collections.unmodifiableSet(allTasks)); |
| session.setNeedsPerformQueries(true); |
| session.setUser(isUser()); |
| |
| updateQueryStatus(null); |
| try { |
| boolean success = preSynchronization(session, new SubProgressMonitor(monitor, 20)); |
| |
| if ((success && session.needsPerformQueries()) || isUser()) { |
| // synchronize queries, tasks changed within query are added to set of tasks to be synchronized |
| synchronizeQueries(monitor, session); |
| } else { |
| monitor.worked(queries.size() * 20); |
| } |
| } finally { |
| for (RepositoryQuery repositoryQuery : queries) { |
| repositoryQuery.setSynchronizing(false); |
| } |
| taskList.notifySynchronizationStateChanged(queries); |
| } |
| |
| Set<ITask> tasksToBeSynchronized = new HashSet<ITask>(); |
| for (ITask task : session.getStaleTasks()) { |
| tasksToBeSynchronized.add(task); |
| ((AbstractTask) task).setSynchronizing(true); |
| } |
| |
| // synchronize tasks that were marked by the connector |
| SynchronizeTasksJob job = new SynchronizeTasksJob(taskList, taskDataManager, tasksModel, connector, |
| repository, tasksToBeSynchronized); |
| job.setFetchSubtasks(getFetchSubtasks()); |
| job.setUser(isUser()); |
| job.setSession(session); |
| if (!tasksToBeSynchronized.isEmpty()) { |
| Policy.checkCanceled(monitor); |
| IStatus result = job.run(new SubProgressMonitor(monitor, 30)); |
| if (result == Status.CANCEL_STATUS) { |
| throw new OperationCanceledException(); |
| } |
| statuses.addAll(job.getStatuses()); |
| } |
| monitor.subTask(Messages.SynchronizeQueriesJob_Receiving_related_tasks); |
| job.synchronizedTaskRelations(monitor, relationsByTaskId); |
| monitor.worked(10); |
| |
| session.setChangedTasks(tasksToBeSynchronized); |
| if (statuses.size() > 0) { |
| Status status = new MultiStatus(ITasksCoreConstants.ID_PLUGIN, 0, |
| statuses.toArray(new IStatus[0]), "Query synchronization failed", null); //$NON-NLS-1$ |
| session.setStatus(status); |
| } |
| |
| // hook into the connector for synchronization time stamp management |
| postSynchronization(session, new SubProgressMonitor(monitor, 10)); |
| } finally { |
| Job.getJobManager().endRule(rule); |
| } |
| } catch (OperationCanceledException e) { |
| return Status.CANCEL_STATUS; |
| } catch (Exception e) { |
| StatusHandler |
| .log(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN, "Synchronization failed", e)); //$NON-NLS-1$ |
| } catch (LinkageError e) { |
| StatusHandler.log(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN, |
| NLS.bind("Synchronization for connector ''{0}'' failed", connector.getConnectorKind()), e)); //$NON-NLS-1$ |
| } finally { |
| monitor.done(); |
| } |
| } finally { |
| monitor.detach(jobMonitor); |
| } |
| return Status.OK_STATUS; |
| } |
| |
| private void synchronizeQueries(IProgressMonitor monitor, SynchronizationSession session) { |
| for (RepositoryQuery repositoryQuery : queries) { |
| Policy.checkCanceled(monitor); |
| monitor.subTask(MessageFormat.format(Messages.SynchronizeQueriesJob_Synchronizing_query_X, |
| repositoryQuery.getSummary())); |
| synchronizeQuery(repositoryQuery, session, new SubProgressMonitor(monitor, 20)); |
| } |
| } |
| |
| private boolean postSynchronization(SynchronizationSession event, IProgressMonitor monitor) { |
| try { |
| Policy.checkCanceled(monitor); |
| monitor.subTask(Messages.SynchronizeQueriesJob_Updating_repository_state); |
| if (!isUser()) { |
| monitor = Policy.backgroundMonitorFor(monitor); |
| } |
| connector.postSynchronization(event, monitor); |
| return true; |
| } catch (CoreException e) { |
| updateQueryStatus(e.getStatus()); |
| return false; |
| } |
| } |
| |
| private boolean preSynchronization(ISynchronizationSession event, IProgressMonitor monitor) { |
| try { |
| Policy.checkCanceled(monitor); |
| monitor.subTask(Messages.SynchronizeQueriesJob_Querying_repository); |
| if (!isUser()) { |
| monitor = Policy.backgroundMonitorFor(monitor); |
| } |
| connector.preSynchronization(event, monitor); |
| return true; |
| } catch (CoreException e) { |
| // synchronization is unlikely to succeed, inform user and exit |
| updateQueryStatus(e.getStatus()); |
| statuses.add(e.getStatus()); |
| return false; |
| } |
| } |
| |
| private void synchronizeQuery(RepositoryQuery repositoryQuery, SynchronizationSession event, |
| IProgressMonitor monitor) { |
| TaskCollector collector = new TaskCollector(repositoryQuery, event); |
| |
| if (!isUser()) { |
| monitor = Policy.backgroundMonitorFor(monitor); |
| } |
| IStatus result = connector.performQuery(repository, repositoryQuery, collector, event, monitor); |
| if (result == null || result.isOK()) { |
| Set<ITask> removedChildren = collector.getRemovedChildren(); |
| if (!removedChildren.isEmpty()) { |
| taskList.removeFromContainer(repositoryQuery, removedChildren); |
| } |
| |
| repositoryQuery.setLastSynchronizedStamp(new SimpleDateFormat("MMM d, H:mm:ss").format(new Date())); //$NON-NLS-1$ |
| } else if (result.getSeverity() == IStatus.CANCEL) { |
| throw new OperationCanceledException(); |
| } else { |
| repositoryQuery.setStatus(result); |
| statuses.add(result); |
| } |
| } |
| |
| private void updateQueryStatus(final IStatus status) { |
| for (RepositoryQuery repositoryQuery : queries) { |
| repositoryQuery.setStatus(status); |
| } |
| taskList.notifySynchronizationStateChanged(queries); |
| } |
| |
| public Collection<IStatus> getStatuses() { |
| return Collections.unmodifiableCollection(statuses); |
| } |
| |
| } |
