/**
* Propagates the markers of the given source file, to the corresponding file at the features
* folder.
*
* @param sourceFile The composed file
*/
public void addFile(IFile sourceFile) {
String fileExtension = sourceFile.getFileExtension();
if (fileExtension == null) {
return;
}
if ("java".equals(fileExtension) || "c".equals(fileExtension) || "h".equals(fileExtension)) {
if (!composedFiles.contains(sourceFile)) {
addComposedFile(sourceFile);
}
if (job == null) {
job =
new Job("Propagate problem markers") {
@Override
public IStatus run(IProgressMonitor monitor) {
propagateMarkers();
return Status.OK_STATUS;
}
};
job.setPriority(Job.SHORT);
job.schedule();
}
if (job.getState() == Job.NONE) {
job.schedule();
}
}
}
/** Execution of the start ZAP job. */
@Override
protected IStatus run(IProgressMonitor monitor) {
// Signal that the ZAP start action is starting.
Job signalZAPStartJob =
new SignalZAPEventJob(
display, "Signal ZAP Start...", ZAPEventType.SERVER_STARTED, eventHandler);
signalZAPStartJob.setPriority(Job.INTERACTIVE);
signalZAPStartJob.schedule();
// Run the start ZAP job.
Job startZAPJob = new StartZAPJob("Running ZAP Start Job...");
startZAPJob.setPriority(Job.LONG);
startZAPJob.schedule();
while (startZAPJob.getResult() == null) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
ConsolePlugin.log(e);
}
}
// Signal that the ZAp start action is complete.
Job signalZAPStartCompleteJob =
new SignalZAPEventJob(
display, "ZAP Start Complete", ZAPEventType.SERVER_STARTUP_COMPLETE, eventHandler);
signalZAPStartCompleteJob.setPriority(Job.INTERACTIVE);
signalZAPStartCompleteJob.schedule();
return Status.OK_STATUS;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ptp.rtsystem.IMonitoringSystem#startEvents()
*/
public void startEvents() throws CoreException {
DebugUtil.trace(
DebugUtil.RTS_TRACING,
"RTS {0}: start events",
getResourceManager().getConfiguration().getName()); // $NON-NLS-1$
/*
* Create monitor jobs, if they do not already exist. They may exist but
* be suspended. If the job is not applicable, then no job will be
* created, according to capabilities for the RM.
*/
if (periodicMonitorJob == null) {
periodicMonitorJob = createPeriodicMonitorJob();
}
if (continousMonitorJob == null) {
continousMonitorJob = createContinuousMonitorJob();
}
/*
* Only schedule the job if they are available. If the job does not
* exists, then it was not created because the capability is not defined
* in the RM.
*/
if (periodicMonitorJob != null) {
periodicMonitorJob.schedule();
}
if (continousMonitorJob != null) {
continousMonitorJob.schedule();
}
doStartEvents();
}
@Override
public void run() {
Job j =
new Job(getToolTipText()) {
@Override
protected IStatus run(IProgressMonitor monitor) {
try {
PrologConsole c = getConsole();
ConsoleModel model = c.getModel();
model.setLineBuffer(" ");
model.commitLineBuffer();
model.setLineBuffer(getQuery());
model.commitLineBuffer();
} catch (Throwable e) {
Debug.report(e);
return Status.CANCEL_STATUS;
} finally {
monitor.done();
}
return Status.OK_STATUS;
}
private PrologConsole getConsole() {
return PrologConsoleView.this;
}
};
j.schedule();
}
private void disableGlobalCDTIndexer() {
// The Job code is borrowed from CCoreInternals ...
final Job job =
new Job("Disable CDT Indexer") {
@Override
protected IStatus run(final IProgressMonitor monitor) {
try {
final Properties props = new Properties();
props.setProperty(IndexerPreferences.KEY_INDEXER_ID, IPDOMManager.ID_NO_INDEXER);
IndexerPreferences.setProperties(null, IndexerPreferences.SCOPE_INSTANCE, props);
InstanceScope.INSTANCE.getNode(CCorePlugin.PLUGIN_ID).flush();
} catch (final BackingStoreException e) {
CCorePlugin.log(e);
}
return Status.OK_STATUS;
}
};
job.setSystem(true);
job.schedule();
try {
job.join();
} catch (final InterruptedException e) {
System.out.println("Exception waiting for indexer disable: " + e.getMessage());
}
// Join any auto builds currently running (should be none)
try {
Job.getJobManager().join(ResourcesPlugin.FAMILY_AUTO_BUILD, null);
} catch (final Exception e1) {
// PASS
}
}
public static List<INamespaceDefinition> getNamespaceDefinitions(
final IProject project, final INamespaceDefinitionTemplate definitionTemplate) {
if (definitionTemplate != null) {
Job namespaceDefinitionJob =
new Job(
(project != null
? String.format("Loading namespaces for project '%s'", project.getName())
: "Loading namespaces")) {
@Override
protected IStatus run(IProgressMonitor monitor) {
List<INamespaceDefinition> namespaceDefinitions = getNamespaceDefinitions(project);
definitionTemplate.doWithNamespaceDefinitions(
(INamespaceDefinition[])
namespaceDefinitions.toArray(
new INamespaceDefinition[namespaceDefinitions.size()]),
project);
return Status.OK_STATUS;
}
};
namespaceDefinitionJob.setPriority(Job.INTERACTIVE);
namespaceDefinitionJob.schedule();
return Collections.emptyList();
}
return getNamespaceDefinitions(project);
}
private void retrieveNewProjectMetadata() {
String templateUrl =
Activator.getDefault().getPreferenceStore().getString(PreferenceConstants.P_TEMPLATES_URL);
this.retriever = new NewProjectMetadataRetriever(templateUrl);
Job job = new Job("Retrieving new project metadata") { // $NON-NLS-1$
@Override
protected IStatus run(IProgressMonitor monitor) {
try {
retriever.retrieveMetadata();
return Status.OK_STATUS;
} catch (Exception e) {
return new Status(
IStatus.ERROR, Activator.PLUGIN_ID, "Cannot retrieve new project metadata", e);
}
}
};
job.addJobChangeListener(
new JobChangeAdapter() {
@Override
public void done(IJobChangeEvent event) {
generalPage.updateControls(retriever.getProjectTypes());
providerPage.updateControls(retriever.getProviders());
themePage.updateControls(retriever.getThemes());
}
});
job.setPriority(Job.LONG);
job.schedule();
}
private void copyFiles(
final IFileStore[] sources, final IFileStore destination, IJobChangeListener listener) {
Job job =
new Job("Copying files") {
@Override
protected IStatus run(IProgressMonitor monitor) {
monitor.beginTask("Copying files", sources.length);
IStatus status = copyFiles(sources, destination, monitor);
monitor.done();
return status;
}
public boolean belongsTo(Object family) {
if ("Copying files".equals(family)) {
return true;
}
return super.belongsTo(family);
}
};
if (listener != null) {
job.addJobChangeListener(listener);
}
job.schedule();
}
/** This method is used for later initialization. This trick should release plug-in start-up. */
void initializeAfterStart() {
Job job = new Job("") { // $NON-NLS-1$
protected IStatus run(IProgressMonitor monitor) {
// start the include path manager
IncludePathManager.getInstance();
// start the library folder manager
LibraryFolderManager.getInstance();
// register the listener in charge of converting the projects -
// applies for projects being opened during work
ResourcesPlugin.getWorkspace()
.addResourceChangeListener(projectConvertListener, IResourceChangeEvent.PRE_BUILD);
ResourcesPlugin.getWorkspace()
.addResourceChangeListener(
reindexOperationListener, IResourceChangeEvent.PRE_BUILD);
// run the conversion over all the projects in the workspace -
// all open projects will be converted
try {
convertProjects(monitor);
} catch (CoreException e) {
log(e);
}
rebuildProjects();
return Status.OK_STATUS;
}
};
job.schedule(Job.LONG);
}
/** {@inheritDoc} */
@Override
protected void runModelAction() throws Exception {
if (!MessageDialog.openConfirm(shell, Messages.RemoveScan, Messages.RemoveSelectedScan)) return;
// Job because removal of many scans and data in log can be slow
final ScanClient client = model.getScanClient();
final Job job =
new Job(Messages.RemoveScan) {
@Override
protected IStatus run(final IProgressMonitor monitor) {
try {
for (ScanInfo info : infos) client.removeScan(info.getId());
} catch (final Exception ex) {
shell
.getDisplay()
.asyncExec(
new Runnable() {
@Override
public void run() {
ExceptionDetailsErrorDialog.openError(shell, Messages.Error, ex);
}
});
}
return Status.OK_STATUS;
}
};
job.setUser(true);
job.schedule();
}
private void refreshAll(final boolean updateSelection) {
queue.clear();
// We use a job for this as the file list can be large
final Job refresh =
new Job("Refresh Image Monitor") {
@Override
protected IStatus run(IProgressMonitor monitor) {
Display.getDefault()
.asyncExec(
new Runnable() {
@Override
public void run() {
galleryGroup.clearAll();
galleryGroup.setItemCount(info.getSize());
galleryGroup.setExpanded(true);
galleryGroup.setText(info.getName());
gallery.update();
gallery.getParent().layout(new Control[] {gallery});
GalleryItem item = galleryGroup.getItem(galleryGroup.getItemCount() - 1);
gallery.setSelection(new GalleryItem[] {item});
}
});
return Status.OK_STATUS;
}
};
refresh.setPriority(Job.INTERACTIVE);
refresh.schedule();
}
/*
* Refreshes the external folders referenced on the buildpath of the given
* source project
*/
public void refreshReferences(IProject source, IProgressMonitor monitor) {
IProject externalProject = getExternalFoldersProject();
if (source.equals(externalProject)) return;
if (!ScriptProject.hasScriptNature(source)) return;
try {
HashSet externalFolders =
getExternalFolders(((ScriptProject) DLTKCore.create(source)).getResolvedBuildpath());
if (externalFolders == null) return;
final Iterator iterator = externalFolders.iterator();
Job refreshJob =
new Job(Messages.refreshing_external_folders) {
public boolean belongsTo(Object family) {
return family == ResourcesPlugin.FAMILY_MANUAL_REFRESH;
}
protected IStatus run(IProgressMonitor pm) {
try {
while (iterator.hasNext()) {
IPath externalPath = (IPath) iterator.next();
IFolder folder = getFolder(externalPath);
if (folder != null) folder.refreshLocal(IResource.DEPTH_INFINITE, pm);
}
} catch (CoreException e) {
return e.getStatus();
}
return Status.OK_STATUS;
}
};
refreshJob.schedule();
} catch (CoreException e) {
Util.log(e, "Exception while refreshing external project"); // $NON-NLS-1$
}
return;
}
/*
* (non-Javadoc)
* @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
*/
public void start(BundleContext context) throws Exception {
super.start(context);
plugin = this;
Job job = new CSSMetadataLoader();
job.schedule();
}
/**
* Schedule (or postpone) the job to execute after a given delay. Any previous pending job is
* canceled.
*/
public final void reschedule(int delay) {
final Job newJob =
new Job(actualJob.getName() + " (Delayed)") {
protected IStatus run(IProgressMonitor monitor) {
synchronized (jobLock) {
if (job == this) {
actualJob.schedule();
return Status.OK_STATUS;
} else {
return Status.CANCEL_STATUS;
}
}
}
};
newJob.setPriority(Job.INTERACTIVE);
// System jobs are not visible in the GUI. I leave it for now, it's quite
// interesting to see auto update tasks in the jobs panel.
//
// newJob.setSystem(true);
synchronized (jobLock) {
/*
* Cancel previous job, but start the new one regardless of the previous job's
* running state.
*/
if (job != null && job.getState() == Job.SLEEPING) {
job.cancel();
}
job = newJob;
job.schedule(delay);
}
}
/** This method starts the job that populates the list of events. */
synchronized void startContentJob() {
if (contentJob != null) return;
contentJob =
new Job("Generate Usage Data Upload Preview") { // $NON-NLS-1$
@Override
protected IStatus run(IProgressMonitor monitor) {
setTableCursor(busyCursor);
processFiles(monitor);
setTableCursor(null);
if (monitor.isCanceled()) return Status.CANCEL_STATUS;
return Status.OK_STATUS;
}
private void setTableCursor(final Cursor cursor) {
if (isDisposed()) return;
getDisplay()
.syncExec(
new Runnable() {
public void run() {
if (isDisposed()) return;
viewer.getTable().setCursor(cursor);
}
});
}
};
contentJob.setPriority(Job.LONG);
contentJob.schedule();
}
/**
* Notify registered {@link RepositoryChangeListener}s of a change.
*
* @param which the repository which has had changes occur within it.
*/
static void fireRepositoryChanged(final RepositoryMapping which) {
Job job =
new Job(CoreText.GitProjectData_repositoryChangedJobName) {
@Override
protected IStatus run(IProgressMonitor monitor) {
RepositoryChangeListener[] listeners = getRepositoryChangeListeners();
monitor.beginTask(CoreText.GitProjectData_repositoryChangedTaskName, listeners.length);
for (RepositoryChangeListener listener : listeners) {
listener.repositoryChanged(which);
monitor.worked(1);
}
monitor.done();
return Status.OK_STATUS;
}
@Override
public boolean belongsTo(Object family) {
if (JobFamilies.REPOSITORY_CHANGED.equals(family)) return true;
return super.belongsTo(family);
}
};
job.schedule();
}
private void runWorkbenchCommands(final List<WorkbenchCommand> commands) {
// TODO: provide a specialized job name...
Job job =
new Job("Executing Workbench Commands...") {
protected IStatus run(IProgressMonitor monitor) {
monitor.beginTask("Executing workbench commands ...", commands.size());
int steps = 0;
for (WorkbenchCommand workbenchCommand : commands) {
workbenchCommand.execute(CMakeWorkbench.this);
steps++;
monitor.worked(steps);
}
return Status.OK_STATUS;
}
};
String info = createInfoStringFromCommands(commands);
Shell shell = PlatformUI.getWorkbench().getDisplay().getActiveShell();
ScrollableInfoMessage dialog = new ScrollableInfoMessage(shell, "CMakeWorkbench Changes", info);
boolean confirmed = (dialog.open() == 0);
if (confirmed) {
job.setPriority(Job.LONG);
job.schedule(); // start as soon as possible
}
}
/** Run the "pub get" command against every pubspec in the workspace. */
private void runPubNow() {
final String pubCmd = RunPubJob.INSTALL_COMMAND;
Job firstJob = null;
Job previousJob = null;
for (Project proj : DartCore.getProjectManager().getProjects()) {
for (final PubFolder pubFolder : proj.getPubFolders()) {
final RunPubJob job = new RunPubJob(pubFolder.getResource(), pubCmd, true);
if (firstJob == null) {
firstJob = job;
} else {
previousJob.addJobChangeListener(
new JobChangeAdapter() {
@Override
public void done(IJobChangeEvent event) {
//
// When one job completes, schedule the next unless the user cancels
//
if (event.getResult().getSeverity() != IStatus.CANCEL) {
job.schedule();
}
}
});
}
previousJob = job;
}
}
firstJob.schedule();
}
public void runAsUserJob(String name, final Object jobFamiliy) {
Job buildJob =
new Job(name) {
/* (non-Javadoc)
* @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
*/
protected IStatus run(IProgressMonitor monitor) {
try {
WorkbenchRunnableAdapter.this.run(monitor);
} catch (InvocationTargetException e) {
Throwable cause = e.getCause();
if (cause instanceof CoreException) {
return ((CoreException) cause).getStatus();
} else {
return RubyUIStatus.createError(IStatus.ERROR, cause);
}
} catch (InterruptedException e) {
return Status.CANCEL_STATUS;
} finally {
monitor.done();
}
return Status.OK_STATUS;
}
public boolean belongsTo(Object family) {
return jobFamiliy == family;
}
};
buildJob.setRule(fRule);
buildJob.setUser(true);
buildJob.schedule();
// TODO: should block until user pressed 'to background'
}
private void validate() {
setErrorMessage(null);
setValid(false);
final Display display = getShell().getDisplay();
Job validator =
new Job("JSHint preferences validation") {
@Override
protected IStatus run(IProgressMonitor monitor) {
try {
monitor.beginTask("checking preferences", 1);
validatePrefs();
display.asyncExec(
new Runnable() {
public void run() {
setValid(true);
}
});
} catch (final IllegalArgumentException exception) {
display.asyncExec(
new Runnable() {
public void run() {
setErrorMessage(exception.getMessage());
}
});
} finally {
monitor.done();
}
return Status.OK_STATUS;
}
};
validator.schedule();
}
public void start(long delay) {
if (runBackup != null) {
stop();
}
runBackup =
new Job("Task Data Snapshot") { // $NON-NLS-1$
@Override
protected IStatus run(IProgressMonitor monitor) {
try {
if (TasksUiPlugin.getTaskList().getAllTasks().size() > 0) {
backupNow(false, monitor);
}
return Status.OK_STATUS;
} finally {
schedule(STANDARD_DELAY);
}
}
};
runBackup.setPriority(Job.BUILD);
runBackup.setSystem(true);
runBackup.schedule(delay);
}
protected void launchJob(IWorkbenchPage page, Integer lineNumber, String filePath) {
Job job = new OpenInEditorJob(page, lineNumber, filePath);
job.addJobChangeListener(
new CompletionPopupJobChangeListener(
"ORG CheatSheet Helpers Notification", "Opening file in editor:\n"));
job.schedule();
}
public void run() {
Job job = createJob();
job.setUser(true);
job.setProperty(
IProgressConstants.ICON_PROPERTY, PDEPluginImages.DESC_PSEARCH_OBJ.createImage());
job.schedule();
}
@Override
public void notifyChanged(final Notification msg) {
switch (msg.getFeatureID(SdrPackage.class)) {
case SdrPackage.SDR_ROOT__LOAD_STATUS:
// The value is the changed load status which will go to null during loading
// once loading is finished the status will change to reflect that of the SDRROOT.
if (msg.getNewValue() != null) {
Job refreshExternalSettingProviderJob =
new Job("Refresh External Settings Providers") {
@Override
protected IStatus run(IProgressMonitor monitor) {
CoreModel.getDefault()
.getProjectDescriptionManager()
.updateExternalSettingsProviders(
new String[] {ExternalSettingProvider.ID}, monitor);
return Status.OK_STATUS;
}
};
refreshExternalSettingProviderJob.setSystem(true); // hide from progress monitor
refreshExternalSettingProviderJob.setUser(false);
refreshExternalSettingProviderJob.schedule(1000);
}
break;
default:
break;
}
}
public void handleDebugEvents(DebugEvent[] events) {
if (events != null && project != null) {
int size = events.length;
for (int i = 0; i < size; i++) {
for (IProcess process : processes) {
if (process != null
&& process.equals(events[i].getSource())
&& events[i].getKind() == DebugEvent.TERMINATE) {
DebugPlugin.getDefault().removeDebugEventListener(this);
terminateForked();
Job job =
new Job("refresh project") {
@Override
protected IStatus run(IProgressMonitor monitor) {
try {
project.refreshLocal(IResource.DEPTH_INFINITE, monitor);
} catch (CoreException e) {
}
GrailsCoreActivator.getDefault().notifyCommandFinish(project);
return Status.OK_STATUS;
}
};
job.setSystem(true);
job.setRule(ResourcesPlugin.getWorkspace().getRuleFactory().buildRule());
job.setPriority(Job.INTERACTIVE);
job.schedule();
}
}
}
}
}
@DsfServiceEventHandler
public void eventDispatched(IExitedDMEvent event) {
// If a memory context is exiting, save expressions and clean its used resources
if (event.getDMContext() instanceof IMemoryDMContext) {
IMemoryDMContext memDmc = (IMemoryDMContext) event.getDMContext();
// Remove entry if it exists
final IMemoryBlockRetrieval retrieval = fMapMemDMCToBlockRetrieval.remove(memDmc);
if (retrieval != null) {
if (retrieval instanceof DsfMemoryBlockRetrieval) {
((DsfMemoryBlockRetrieval) retrieval).saveMemoryBlocks();
}
// Fire a terminate event for the memory retrieval object so
// that the hosting memory views can clean up. See 255120 and
// 283586
DebugPlugin.getDefault()
.fireDebugEventSet(new DebugEvent[] {new DebugEvent(retrieval, DebugEvent.TERMINATE)});
Job removeJob = new Job("Removing memory blocks") { // $NON-NLS-1$
@Override
protected IStatus run(IProgressMonitor monitor) {
IMemoryBlockManager mbm = DebugPlugin.getDefault().getMemoryBlockManager();
IMemoryBlock[] deletedMemoryBlocks = mbm.getMemoryBlocks(retrieval);
mbm.removeMemoryBlocks(deletedMemoryBlocks);
return Status.OK_STATUS;
}
};
removeJob.schedule();
}
}
}
public static void migrateToClasspathAttributes() {
final Map<IPath, String> oldLocations = loadOldForCompatibility();
if (oldLocations.isEmpty()) {
IPreferenceStore preferenceStore = PreferenceConstants.getPreferenceStore();
preferenceStore.setValue(PREF_JAVADOCLOCATIONS, ""); // $NON-NLS-1$
preferenceStore.setValue(PREF_JAVADOCLOCATIONS_MIGRATED, true);
return;
}
Job job =
new Job(CorextMessages.JavaDocLocations_migratejob_name) {
@Override
protected IStatus run(IProgressMonitor monitor) {
try {
IWorkspaceRunnable runnable =
new IWorkspaceRunnable() {
@Override
public void run(IProgressMonitor pm) throws CoreException {
updateClasspathEntries(oldLocations, pm);
IPreferenceStore preferenceStore = PreferenceConstants.getPreferenceStore();
preferenceStore.setValue(PREF_JAVADOCLOCATIONS, ""); // $NON-NLS-1$
preferenceStore.setValue(PREF_JAVADOCLOCATIONS_MIGRATED, true);
}
};
new WorkbenchRunnableAdapter(runnable).run(monitor);
} catch (InvocationTargetException e) {
JavaPlugin.log(e);
} catch (InterruptedException e) {
// should not happen, cannot cancel
}
return Status.OK_STATUS;
}
};
job.schedule();
}
private void doDownloadUpdate(Revision revision) {
// ensure jobs don't stack
if (updateJob != null) {
return;
}
updateJob = new DownloadUpdatesJob(revision);
updateJob.addJobChangeListener(
new JobChangeAdapter() {
@Override
public void done(IJobChangeEvent event) {
updateJob = null;
IStatus result = event.getResult();
if (result.isOK()) {
model.enterState(State.DOWNLOADED);
} else {
UpdateCore.logWarning("Download cancelled [" + result.getMessage() + "]");
model.enterState(State.DOWNLOAD_CANCELLED);
}
}
@Override
public void running(IJobChangeEvent event) {
model.enterState(State.DOWNLOADING);
}
});
updateJob.schedule();
}
private void initialize() {
Job job =
new Job("Comparing IUs") {
@Override
protected IStatus run(IProgressMonitor monitor) {
final TreeElement<Object> root = new TreeElement<Object>();
IMetadataRepository repo = AnalysisHelper.getMetadataRepository();
IQueryResult<IInstallableUnit> ius =
repo.query(QueryUtil.createIUQuery(getIU().getId(), getIU().getVersion()), monitor);
int iuCount = 0;
for (IInstallableUnit iu : ius.toSet()) {
TreeElement<TreeElement<String>> child = AnalysisHelper.diff(getIU(), iu);
if (child != null) root.addChild(child);
iuCount++;
}
if (root.getChildren().length == 0)
root.addChild("No differences found between profile and source installable unit(s)");
else if (iuCount == 0) root.addChild("No source for IU located");
Display.getDefault()
.asyncExec(
new Runnable() {
public void run() {
tree.setInput(root);
}
});
return Status.OK_STATUS;
}
};
job.schedule();
}
private void refresh(final Object element) {
Job job =
new Job("Loading OpenShift information...") {
@Override
protected IStatus run(IProgressMonitor monitor) {
try {
monitor.beginTask("Loading OpenShift information...", IProgressMonitor.UNKNOWN);
if (element instanceof Connection) {
((Connection) element).refresh();
} else if (element instanceof IOpenShiftResource) {
((IOpenShiftResource) element).refresh();
}
// List<IApplication> applications = user.getApplications();
RefreshViewerJob.refresh(viewer);
} catch (OpenShiftException e) {
Logger.error("Failed to refresh element", e);
} finally {
monitor.done();
}
return Status.OK_STATUS;
}
};
job.setPriority(Job.LONG);
job.schedule();
}