/** @return a tuple with the process created and a string representation of the cmdarray. */
public Tuple<Process, String> run(
String[] cmdarray, File workingDir, IPythonNature nature, IProgressMonitor monitor) {
if (monitor == null) {
monitor = new NullProgressMonitor();
}
String executionString = getArgumentsAsStr(cmdarray);
monitor.setTaskName("Executing: " + executionString);
monitor.worked(5);
Process process = null;
try {
monitor.setTaskName("Making pythonpath environment..." + executionString);
String[] envp = null;
if (nature != null) {
envp =
getEnvironment(
nature,
nature.getProjectInterpreter(),
nature.getRelatedInterpreterManager()); // Don't remove as it *should* be updated
// based on the nature)
}
// Otherwise, use default (used when configuring the interpreter for instance).
monitor.setTaskName("Making exec..." + executionString);
if (workingDir != null) {
if (!workingDir.isDirectory()) {
throw new RuntimeException(
org.python.pydev.shared_core.string.StringUtils.format(
"Working dir must be an existing directory (received: %s)", workingDir));
}
}
process = createProcess(cmdarray, envp, workingDir);
} catch (Exception e) {
throw new RuntimeException(e);
}
return new Tuple<Process, String>(process, executionString);
}
@Override
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
try {
result = CommandResult.SUCCESS;
if (m_scope == null && m_variables == null) {
monitor.setTaskName("Clearing all variables and scopes");
ISharedDataService svc = (ISharedDataService) ServiceManager.get(ISharedDataService.class);
for (String scope : svc.getSharedScopes()) {
svc.removeSharedScope(scope);
}
svc.getSharedScope(ISharedDataService.GLOBAL_SCOPE).clear();
} else if (m_variables != null) {
monitor.beginTask(
"Clearing variables in scope " + m_scope.getScopeName(), m_variables.size());
for (SharedVariable var : m_variables) {
monitor.subTask("Removing variable " + var.name);
m_scope.clear(var.name);
monitor.worked(1);
if (monitor.isCanceled()) return;
}
} else {
monitor.setTaskName("Clearing variables in scope " + m_scope.getScopeName());
m_scope.clear();
}
monitor.done();
} catch (Exception ex) {
ex.printStackTrace();
message = ex.getLocalizedMessage();
result = CommandResult.FAILED;
}
}
public void setTask(int template, String task[]) {
if (m_monitor != null) {
switch (template) {
case TASK_CONNECT:
m_monitor.setTaskName("Connecting to SFTP Site");
break;
case TASK_SCANNING:
m_monitor.setTaskName("Scanning directories");
break;
case TASK_TRANSFER:
if (task.length == 2) {
m_monitor.setTaskName(task[0] + ":\t" + task[1]);
}
break;
case TASK_COMPLETE:
m_monitor.setTaskName("Transfer completed");
break;
case TASK_ERROR:
if (task.length >= 1) {
m_monitor.setTaskName("ERROR: " + task[0]);
for (int a = 0; a < task.length; a++) {
m_output.append(task[a] + "\n");
System.out.println(task[a]);
}
}
break;
}
}
}
/**
* @param process process from where the output should be gotten
* @param executionString string to execute (only for errors)
* @param monitor monitor for giving progress
* @return a tuple with the output of stdout and stderr
*/
public static Tuple<String, String> getProcessOutput(
Process process, String executionString, IProgressMonitor monitor, String encoding) {
if (monitor == null) {
monitor = new NullProgressMonitor();
}
if (process != null) {
try {
process.getOutputStream().close(); // we won't write to it...
} catch (IOException e2) {
}
monitor.setTaskName("Reading output...");
monitor.worked(5);
// No need to synchronize as we'll waitFor() the process before getting the contents.
ThreadStreamReader std = new ThreadStreamReader(process.getInputStream(), false, encoding);
ThreadStreamReader err = new ThreadStreamReader(process.getErrorStream(), false, encoding);
std.start();
err.start();
boolean interrupted = true;
while (interrupted) {
interrupted = false;
try {
monitor.setTaskName("Waiting for process to finish.");
monitor.worked(5);
process.waitFor(); // wait until the process completion.
} catch (InterruptedException e1) {
interrupted = true;
}
}
try {
// just to see if we get something after the process finishes (and let the other threads
// run).
Object sync = new Object();
synchronized (sync) {
sync.wait(50);
}
} catch (Exception e) {
// ignore
}
return new Tuple<String, String>(std.getContents(), err.getContents());
} else {
try {
throw new CoreException(
PydevPlugin.makeStatus(
IStatus.ERROR,
"Error creating process - got null process(" + executionString + ")",
new Exception("Error creating process - got null process.")));
} catch (CoreException e) {
Log.log(IStatus.ERROR, e.getMessage(), e);
}
}
return new Tuple<String, String>(
"", "Error creating process - got null process(" + executionString + ")"); // no output
}
protected RefactoringStatus doCheckFinalConditions(
IProgressMonitor pm, CheckConditionsContext context) throws CoreException {
try {
pm.beginTask("", 18); // $NON-NLS-1$
pm.setTaskName(RefactoringCoreMessages.RenameFieldRefactoring_checking);
RefactoringStatus result = new RefactoringStatus();
result.merge(Checks.checkIfCuBroken(fField));
if (result.hasFatalError()) return result;
result.merge(checkNewElementName(getNewElementName()));
pm.worked(1);
result.merge(checkEnclosingHierarchy());
pm.worked(1);
result.merge(checkNestedHierarchy(fField.getDeclaringType()));
pm.worked(1);
if (fUpdateReferences) {
pm.setTaskName(RefactoringCoreMessages.RenameFieldRefactoring_searching);
fReferences = getReferences(new SubProgressMonitor(pm, 3), result);
pm.setTaskName(RefactoringCoreMessages.RenameFieldRefactoring_checking);
} else {
fReferences = new SearchResultGroup[0];
pm.worked(3);
}
if (fUpdateReferences) result.merge(analyzeAffectedCompilationUnits());
else Checks.checkCompileErrorsInAffectedFile(result, fField.getResource());
if (getGetter() != null && fRenameGetter) {
result.merge(checkAccessor(new SubProgressMonitor(pm, 1), getGetter(), getNewGetterName()));
result.merge(
Checks.checkIfConstructorName(
getGetter(), getNewGetterName(), fField.getDeclaringType().getElementName()));
} else {
pm.worked(1);
}
if (getSetter() != null && fRenameSetter) {
result.merge(checkAccessor(new SubProgressMonitor(pm, 1), getSetter(), getNewSetterName()));
result.merge(
Checks.checkIfConstructorName(
getSetter(), getNewSetterName(), fField.getDeclaringType().getElementName()));
} else {
pm.worked(1);
}
result.merge(createChanges(new SubProgressMonitor(pm, 10)));
if (result.hasFatalError()) return result;
return result;
} finally {
pm.done();
}
}
@Override
public ArtifactKey identify(File file, IProgressMonitor monitor) throws CoreException {
if (monitor == null) {
monitor = new NullProgressMonitor();
}
IndexManager indexManager = MavenPlugin.getIndexManager();
IIndex index = indexManager.getAllIndexes();
IndexedArtifactFile info = null;
try {
if (monitor.isCanceled()) {
return null;
}
monitor.setTaskName("Checking global m2e Nexus index for " + file.getName());
info = index.identify(file);
} catch (Exception e) {
// ignore
}
ArtifactKey artifact = null;
if (info != null) {
artifact = info.getArtifactKey();
if (artifact != null) {
return artifact;
}
}
if (indexManager instanceof NexusIndexManager) {
NexusIndexManager nexusIndexManager = (NexusIndexManager) indexManager;
for (IRepository repository : globalRepositories) {
NexusIndex nexusIndex = nexusIndexManager.getIndex(repository);
if (nexusIndex != null) {
try {
if (monitor.isCanceled()) {
return null;
}
monitor.setTaskName(
"Checking Nexus index of '"
+ repository.getId()
+ "' repository for "
+ file.getName());
info = nexusIndex.identify(file);
} catch (Exception t) {
// ignore
}
if (info != null) {
artifact = info.getArtifactKey();
if (artifact != null) {
return artifact;
}
}
}
}
}
return artifact;
}
/**
* Set the progress monitor done.
*
* @param progress The progress monitor or <code>null</code>.
*/
public static final void done(IProgressMonitor progress) {
if (progress != null) {
progress.setTaskName(""); // $NON-NLS-1$
progress.subTask(""); // $NON-NLS-1$
progress.done();
}
}
/** {@inheritDoc} */
@Override
protected IStatus run(IProgressMonitor pMonitor) {
progressMonitor = pMonitor;
progressMonitor.setTaskName("Waiting...");
try {
final Display display = Activator.getDefault().getWorkbench().getDisplay();
display.syncExec(
new Runnable() {
public void run() {
MessageBox turnOn = new MessageBox(new Shell(display), SWT.ICON_INFORMATION);
if (serviceMode) {
turnOn.setMessage("Turn On connected device in service mode and press OK.");
} else {
turnOn.setMessage("Turn On connected device in normal mode and press OK.");
}
if (turnOn.open() == SWT.OK) {
result = "OK";
} else {
result = "CANCEL";
}
}
});
return new Status(IStatus.OK, Activator.PLUGIN_ID, result);
} catch (Exception e) {
return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Command failed", e);
} finally {
progressMonitor.done();
}
// return null;
}
@Override
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
try {
monitor.setTaskName("Retrieving LOG file for procedure " + m_proc.getProcName());
IFileManager fileMgr = (IFileManager) ServiceManager.get(IFileManager.class);
String path =
fileMgr.getServerFilePath(m_proc.getProcId(), ServerFileType.EXECUTOR_LOG, monitor);
Logger.debug("LOG file path: '" + path + "'", Level.PROC, this);
logFile = (LogFile) fileMgr.getServerFile(path, ServerFileType.EXECUTOR_LOG, null, monitor);
List<IServerFileLine> lines = logFile.getLines();
monitor.beginTask("Exporting log data", lines.size());
PrintWriter writer =
new PrintWriter(new OutputStreamWriter(new FileOutputStream(m_destinationFileName)));
for (IServerFileLine line : lines) {
writer.println(line.toString());
monitor.worked(1);
if (monitor.isCanceled()) break;
}
writer.close();
monitor.done();
result = CommandResult.SUCCESS;
} catch (Exception e) {
Logger.error("Could retrieve LOG:" + e.getLocalizedMessage(), Level.PROC, this);
}
monitor.done();
}
protected IStatus run(IProgressMonitor monitor) {
ArrayList<IFile> files = new ArrayList<IFile>(10);
for (IResource resource : resources) {
getFilesFromResouce(resource, files);
}
int count = files.size();
monitor.beginTask("Validating ...", count);
int completed = 0;
for (IFile file : files.toArray(new IFile[0])) {
monitor.setTaskName(
"Validating "
+ file.getProjectRelativePath().toString()
+ " ("
+ (completed + 1)
+ "/"
+ count
+ ")");
validateFile(file, monitor);
monitor.worked(++completed);
if (monitor.isCanceled()) return Status.CANCEL_STATUS;
}
return Status.OK_STATUS;
}
void doDebug(IProgressMonitor monitor) throws InterruptedException {
monitor.setTaskName(
"Connecting debugger "
+ session.getName()
+ " to "
+ session.getHost()
+ ":"
+ session.getJdb());
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("hostname", session.getHost());
parameters.put("port", session.getJdb() + "");
parameters.put("timeout", session.getTimeout() + "");
IVMConnector connector = JavaRuntime.getDefaultVMConnector();
while (!monitor.isCanceled()) {
try {
connector.connect(parameters, monitor, launch);
break;
} catch (Exception e) {
Thread.sleep(500);
}
}
}
public static IStatus assignPort(
IShellProvider shellProvider, IProgressMonitor monitor, BTTargetPhone phone) {
try {
monitor.beginTask("Scanning BT device for OBEX service", 1);
monitor.setTaskName("Scanning BT device for OBEX service");
int port = ServiceSearch.search(phone.getAddress());
if (port != -1) {
phone.assignPort(port);
} else {
return new Status(
IStatus.ERROR,
TargetPhonePlugin.PLUGIN_ID,
"The device connected to has no OBEX service");
}
return Status.OK_STATUS;
} catch (Exception e) {
return new Status(
IStatus.ERROR,
TargetPhonePlugin.PLUGIN_ID,
"The device connected to has no OBEX service",
e);
} finally {
monitor.worked(1);
}
}
private void createBranch(final String textForBranch, RevCommit commit, IProgressMonitor monitor)
throws CoreException, GitAPIException {
monitor.setTaskName(UIText.FetchGerritChangePage_CreatingBranchTaskName);
CreateLocalBranchOperation bop =
new CreateLocalBranchOperation(repository, textForBranch, commit);
bop.execute(monitor);
CheckoutCommand co = new Git(repository).checkout();
try {
co.setName(textForBranch).call();
} catch (CheckoutConflictException e) {
final CheckoutResult result = co.getResult();
if (result.getStatus() == Status.CONFLICTS) {
final Shell shell = getWizard().getContainer().getShell();
shell
.getDisplay()
.asyncExec(
new Runnable() {
public void run() {
new CheckoutConflictDialog(shell, repository, result.getConflictList()).open();
}
});
}
}
monitor.worked(1);
}
protected IResource[] checkOverwriteOfDirtyResources(
IResource[] resources, IProgressMonitor monitor) throws CVSException, InterruptedException {
List dirtyResources = new ArrayList();
IResource[] selectedResources = getSelectedResources();
try {
monitor = Policy.monitorFor(monitor);
monitor.beginTask(null, selectedResources.length * 100);
monitor.setTaskName(CVSUIMessages.ReplaceWithAction_calculatingDirtyResources);
for (int i = 0; i < selectedResources.length; i++) {
IResource resource = selectedResources[i];
ICVSResource cvsResource = getCVSResourceFor(resource);
if (cvsResource.isModified(Policy.subMonitorFor(monitor, 100))) {
dirtyResources.add(resource);
}
}
} finally {
monitor.done();
}
PromptingDialog dialog =
new PromptingDialog(
getShell(),
selectedResources,
getPromptCondition(
(IResource[]) dirtyResources.toArray(new IResource[dirtyResources.size()])),
CVSUIMessages.ReplaceWithAction_confirmOverwrite);
return dialog.promptForMultiple();
}
/**
* Used to make the work communication (also checks to see if it has been cancelled)
*
* @param desc Some string to be shown in the progress
*/
public synchronized void communicateWork(String desc) throws OperationCanceledException {
IProgressMonitor monitor = getMonitor();
if (monitor != null) {
monitor.setTaskName(desc);
monitor.worked(1);
checkCancelled();
}
}
/**
* Set task name.
*
* @see IProgressMonitor#setTaskName(String)
* @since 2.0
*/
public void setTaskName(String name) {
this.taskString = name;
this.subTaskString = ""; // $NON-NLS-1$
this.showDetails = false;
this.totalCopyCount = 0;
monitor.subTask(""); // $NON-NLS-1$
monitor.setTaskName(name);
}
protected void fullBuild(final IProgressMonitor monitor)
throws CoreException, IOException, ParseException {
monitor.setTaskName("Checking architecture");
monitor.subTask("loading dependencies");
final Architecture architecture = ArchitectureUtils.initializeArchitecture(getProject());
monitor.beginTask("Checking architecture", architecture.getProjectClasses().size());
getProject().accept(new FullBuildVisitor(architecture, monitor, true));
}
/**
* Allows a given set or subset of runtime detectors the ability to search through a folder
*
* @param directory
* @param runtimeCollector
* @param depth
* @param runtimeDetectors
* @param monitor
*/
public void searchDirectory(
File directory,
List<RuntimeDefinition> runtimeCollector,
int depth,
Set<IRuntimeDetector> runtimeDetectors,
IProgressMonitor monitor) {
if (depth == 0 || monitor.isCanceled() || directory == null || !directory.isDirectory()) {
return;
}
int workSize = (1000 + (10 * runtimeDetectors.size()));
monitor.beginTask(
Messages.JBossRuntimeLocator_Searching + directory.getAbsolutePath(), workSize);
monitor.setTaskName(Messages.JBossRuntimeLocator_Searching + directory.getAbsolutePath());
for (IRuntimeDetector detector : runtimeDetectors) {
if (monitor.isCanceled()) {
return;
}
if (!detector.isEnabled()) {
monitor.worked(10);
continue;
}
RuntimeDefinition runtimeDefinition =
detector.getRuntimeDefinition(directory, new SubProgressMonitor(monitor, 10));
if (runtimeDefinition != null) {
runtimeCollector.add(runtimeDefinition);
monitor.done();
return;
}
}
File[] files =
directory.listFiles(
new FileFilter() {
public boolean accept(File file) {
return file.isDirectory();
}
});
SubProgressMonitor childrenMonitor = new SubProgressMonitor(monitor, 1000);
childrenMonitor.beginTask("", 100 * files.length);
if (files != null) {
int size = files.length;
for (int i = 0; i < size; i++) {
if (monitor.isCanceled()) return;
searchDirectory(
files[i],
runtimeCollector,
depth - 1,
runtimeDetectors,
new SubProgressMonitor(childrenMonitor, 100));
}
}
childrenMonitor.done();
}
private void checkOverridden(RefactoringStatus status, IProgressMonitor pm)
throws JavaModelException {
pm.beginTask("", 9); // $NON-NLS-1$
pm.setTaskName(RefactoringCoreMessages.InlineMethodRefactoring_checking_overridden);
MethodDeclaration decl = fSourceProvider.getDeclaration();
IMethod method = (IMethod) decl.resolveBinding().getJavaElement();
if (method == null || Flags.isPrivate(method.getFlags())) {
pm.worked(8);
return;
}
IType type = method.getDeclaringType();
ITypeHierarchy hierarchy = type.newTypeHierarchy(new SubProgressMonitor(pm, 6));
checkSubTypes(status, method, hierarchy.getAllSubtypes(type), new SubProgressMonitor(pm, 1));
checkSuperClasses(
status, method, hierarchy.getAllSuperclasses(type), new SubProgressMonitor(pm, 1));
checkSuperInterfaces(
status, method, hierarchy.getAllSuperInterfaces(type), new SubProgressMonitor(pm, 1));
pm.setTaskName(""); // $NON-NLS-1$
}
/* (non-Javadoc)
* @see org.eclipse.egit.core.op.IEGitOperation#execute(org.eclipse.core.runtime.IProgressMonitor)
*/
public void execute(IProgressMonitor m) throws CoreException {
if (m == null) {
m = new NullProgressMonitor();
}
m.beginTask(CoreText.ConnectProviderOperation_connecting, 100 * projects.size());
try {
for (Iterator iterator = projects.keySet().iterator(); iterator.hasNext(); ) {
IProject project = (IProject) iterator.next();
m.setTaskName(
NLS.bind(CoreText.ConnectProviderOperation_ConnectingProject, project.getName()));
// TODO is this the right location?
if (GitTraceLocation.CORE.isActive())
GitTraceLocation.getTrace()
.trace(
GitTraceLocation.CORE.getLocation(),
"Locating repository for " + project); // $NON-NLS-1$
Collection<RepositoryMapping> repos =
new RepositoryFinder(project).find(new SubProgressMonitor(m, 40));
File suggestedRepo = projects.get(project);
RepositoryMapping actualMapping = findActualRepository(repos, suggestedRepo);
if (actualMapping != null) {
GitProjectData projectData = new GitProjectData(project);
try {
projectData.setRepositoryMappings(Arrays.asList(actualMapping));
projectData.store();
} catch (CoreException ce) {
GitProjectData.delete(project);
throw ce;
} catch (RuntimeException ce) {
GitProjectData.delete(project);
throw ce;
}
RepositoryProvider.map(project, GitProvider.class.getName());
projectData = GitProjectData.get(project);
project.refreshLocal(IResource.DEPTH_INFINITE, new SubProgressMonitor(m, 50));
m.worked(10);
} else {
// TODO is this the right location?
if (GitTraceLocation.CORE.isActive())
GitTraceLocation.getTrace()
.trace(
GitTraceLocation.CORE.getLocation(),
"Attempted to share project without repository ignored :" //$NON-NLS-1$
+ project);
m.worked(60);
}
}
} finally {
m.done();
}
}
private String[] runChildTest(
int depth, TestProgressMonitor root, IProgressMonitor child, int ticks) {
ArrayList results = new ArrayList();
child.beginTask("beginTask" + depth, ticks);
results.add(root.getTaskName());
child.subTask("subTask" + depth);
results.add(root.getSubTaskName());
child.setTaskName("setTaskName" + depth);
results.add(root.getTaskName());
return (String[]) results.toArray(new String[results.size()]);
}
@Override
protected boolean executeAnalysis(final IProgressMonitor monitor) throws TmfAnalysisException {
/* Get the graph */
TmfGraphBuilderModule graphModule = getGraph();
if (graphModule == null) {
Activator.getInstance()
.logWarning("No graph was found to execute the critical path on"); // $NON-NLS-1$
return true;
}
graphModule.schedule();
monitor.setTaskName(
NLS.bind(Messages.CriticalPathModule_waitingForGraph, graphModule.getName()));
if (!graphModule.waitForCompletion(monitor)) {
Activator.getInstance()
.logInfo(
"Critical path execution: graph building was cancelled. Results may not be accurate."); //$NON-NLS-1$
return false;
}
TmfGraph graph = graphModule.getGraph();
if (graph == null) {
throw new TmfAnalysisException(
"Critical Path analysis: graph "
+ graphModule.getName()
+ " is null"); //$NON-NLS-1$//$NON-NLS-2$
}
/* Get the worker id */
Object workerObj = getParameter(PARAM_WORKER);
if (workerObj == null) {
return false;
}
if (!(workerObj instanceof IGraphWorker)) {
throw new IllegalStateException("Worker parameter must be an IGraphWorker"); // $NON-NLS-1$
}
IGraphWorker worker = (IGraphWorker) workerObj;
TmfVertex head = graph.getHead(worker);
if (head == null) {
/* Nothing happens with this worker, return an empty graph */
fCriticalPath = new TmfGraph();
return true;
}
ICriticalPathAlgorithm cp = getAlgorithm(graph);
try {
fCriticalPath = cp.compute(head, null);
return true;
} catch (CriticalPathAlgorithmException e) {
Activator.getInstance().logError(NonNullUtils.nullToEmptyString(e.getMessage()), e);
}
return false;
}
public static void buildKeysForRegularEntries(
IProgressMonitor monitor,
ModulesFoundStructure modulesFound,
PyPublicTreeMap<ModulesKey, ModulesKey> keys,
boolean includeOnlySourceModules) {
String[] dottedValidSourceFiles = FileTypesPreferencesPage.getDottedValidSourceFiles();
int j = 0;
FastStringBuffer buffer = new FastStringBuffer();
// now, create in memory modules for all the loaded files (empty modules).
for (Iterator<Map.Entry<File, String>> iterator =
modulesFound.regularModules.entrySet().iterator();
iterator.hasNext() && monitor.isCanceled() == false;
j++) {
Map.Entry<File, String> entry = iterator.next();
String m = entry.getValue();
if (m != null) {
if (j % 20 == 0) {
// no need to report all the time (that's pretty fast now)
buffer.clear();
monitor.setTaskName(buffer.append("Module resolved: ").append(m).toString());
monitor.worked(1);
}
// we don't load them at this time.
File f = entry.getKey();
if (includeOnlySourceModules) {
// check if we should include only source modules
if (!PythonPathHelper.isValidSourceFile(f.getName())) {
continue;
}
}
ModulesKey modulesKey = new ModulesKey(m, f);
// no conflict (easy)
if (!keys.containsKey(modulesKey)) {
keys.put(modulesKey, modulesKey);
} else {
// we have a conflict, so, let's resolve which one to keep (the old one or this one)
if (PythonPathHelper.isValidSourceFile(f.getName(), dottedValidSourceFiles)) {
// source files have priority over other modules (dlls) -- if both are source, there is
// no real way to resolve
// this priority, so, let's just add it over.
keys.put(modulesKey, modulesKey);
}
}
}
}
}
/** Run the collector. */
@Override
public void run() {
clearCollector(this);
if (taskName != null) {
monitor.setTaskName(taskName);
}
if (subTask != null) {
monitor.subTask(subTask);
}
if (worked > 0) {
monitor.internalWorked(worked);
}
}
private void createTag(
final RefSpec spec, final String textForTag, RevCommit commit, IProgressMonitor monitor)
throws CoreException {
monitor.setTaskName(UIText.FetchGerritChangePage_CreatingTagTaskName);
final TagBuilder tag = new TagBuilder();
PersonIdent personIdent = new PersonIdent(repository);
tag.setTag(textForTag);
tag.setTagger(personIdent);
tag.setMessage(NLS.bind(UIText.FetchGerritChangePage_GeneratedTagMessage, spec.getSource()));
tag.setObjectId(commit);
new TagOperation(repository, tag, false).execute(monitor);
monitor.worked(1);
}
/** {@inheritDoc} */
public void run(IProgressMonitor monitor) {
progressMonitor = monitor;
IProjectPO project = GeneralStorage.getInstance().getProject();
progressMonitor.setTaskName(Messages.PreparingConvertProjectTaskName);
String basePath =
genPath
+ StringConstants.SLASH
+ genPackage.replace(StringConstants.DOT, StringConstants.SLASH);
uuidToNodeInfoMap = new HashMap<String, NodeInfo>();
NodeInfo.setUuidToNodeInfoMap(uuidToNodeInfoMap);
projects = new HashSet<IProjectPO>();
workUnits = 0;
if (project != null) {
defaultToolkit = determineDefaultToolkit(project);
addProjectsToConvert(project);
try {
for (IProjectPO p : projects) {
determineClassNamesForProject(p, basePath);
}
progressMonitor.beginTask(Messages.PreparingConvertProjectTaskName, workUnits);
for (IProjectPO p : projects) {
progressMonitor.setTaskName(NLS.bind(Messages.ConvertProjectTaskName, p.getName()));
handleProject(p, basePath);
}
} catch (StopConversionException e) {
progressMonitor.setCanceled(true);
if (!e.wasManuallyTriggered()) {
ErrorHandlingUtil.createMessageDialog(
new JBException(e.getMessage(), e, MessageIDs.E_CONVERSION_ABORTED_ERROR));
}
return;
}
}
progressMonitor.done();
}
@Override
public void run(IProgressMonitor monitor) throws CoreException {
if (monitor == null) monitor = new NullProgressMonitor();
try {
monitor.beginTask("", 1); // $NON-NLS-1$
monitor.setTaskName(CodeGenerationMessages.GenerateToStringOperation_description);
AbstractTypeDeclaration declaration =
(AbstractTypeDeclaration)
ASTNodes.findDeclaration(fContext.getTypeBinding(), fRewrite.getRoot());
ListRewrite rewriter =
fRewrite
.getASTRewrite()
.getListRewrite(declaration, declaration.getBodyDeclarationsProperty());
if (fContext.getTypeBinding() != null && rewriter != null) {
MethodDeclaration toStringMethod = fGenerator.generateToStringMethod();
List<BodyDeclaration> list = declaration.bodyDeclarations();
BodyDeclaration replace = findMethodToReplace(list, toStringMethod);
if (replace == null
|| ((Boolean)
toStringMethod.getProperty(AbstractToStringGenerator.OVERWRITE_METHOD_PROPERTY))
.booleanValue()) insertMethod(toStringMethod, rewriter, replace);
List<MethodDeclaration> helperMethods = fGenerator.generateHelperMethods();
for (Iterator<MethodDeclaration> iterator = helperMethods.iterator();
iterator.hasNext(); ) {
MethodDeclaration method = iterator.next();
replace = findMethodToReplace(list, method);
if (replace == null
|| ((Boolean) method.getProperty(AbstractToStringGenerator.OVERWRITE_METHOD_PROPERTY))
.booleanValue()) {
insertMethod(method, rewriter, replace);
}
}
JavaModelUtil.applyEdit(
(ICompilationUnit) fUnit.getJavaElement(),
fRewrite.createChange(true).getEdit(),
false,
monitor);
}
} finally {
monitor.done();
}
}
@Override
public IStatus run(final IProgressMonitor monitor) {
monitor.beginTask(Messages.LifecycleDeployHandler_Task_Starting, this.resources.length);
for (final IResource resource : this.resources) {
final IProject project = resource.getProject();
monitor.setTaskName(Messages.LifecycleDeployHandler_Task_RunFor + project.getName());
final IMavenJobData jobData =
new IMavenJobData() {
@Override
public void manipulateRequest(final MavenExecutionRequest request) {
// empty
}
@Override
public IProject getProject() {
return project;
}
@Override
public String[] getMavenCommands() {
return new String[] {"deploy"}; // $NON-NLS-1$
}
@Override
public boolean canProcessRequest(
final MavenExecutionRequest request, final IMavenProjectFacade projectFacade) {
return true;
}
};
final MavenJob job = new MavenJob(jobData);
final SubProgressMonitor subMonitor =
new SubProgressMonitor(monitor, 1, SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK);
final IStatus mavenResult = job.execute(subMonitor);
subMonitor.done();
if (!mavenResult.isOK()) {
monitor.done();
this.done(mavenResult);
return mavenResult;
}
}
monitor.done();
this.done(Status.OK_STATUS);
return Status.OK_STATUS;
}
/** Performs the import. */
public void performImport(final IProgressMonitor monitor) {
// need to disable the workspace refreshing
boolean refresh = RefreshJob.getInstance().isEnabled();
if (refresh) {
// disable resource refreshing during import
//
RefreshJob.getInstance().setEnabled(false);
}
try {
if (monitor != null) {
monitor.setTaskName(ImportResources.ConfigurationImportService_MSG3);
}
if (isSpecsOnly()) {
specsMgr.doImport(data.specs);
} else {
LibraryImportManager importingMgr = new LibraryImportManager(diffMgr, data.importList);
importingMgr.doMerge(data.replaceExisting, monitor);
}
// refresh library files in workspace
//
MethodLibrary lib = LibraryService.getInstance().getCurrentMethodLibrary();
ResourceUtil.refreshResources(lib, monitor);
} catch (Exception e) {
ImportPlugin.getDefault().getLogger().logError(e);
} finally {
if (refresh) {
// re-enable resource refreshing
//
RefreshJob.getInstance().setEnabled(true);
}
if (upGradeInfo != null) {
upGradeInfo.removeCopiedLibrary();
upGradeInfo = null;
}
}
try {
postImportOperation(monitor);
} catch (Exception e) {
ImportPlugin.getDefault().getLogger().logError(e);
}
}
public void run() throws Exception {
try {
monitor.setTaskName("scanning Compilation Units");
onPreRun();
if (monitor.isCanceled()) {
throw new OperationCanceledException();
}
// *** the biggy ***
monitor.beginTask("treating files", compilationUnits.size());
// Step 1 / 4: handle prepare compilation units
for (ICompilationUnit unit : compilationUnits) {
// monitor.setTaskName(unit.getElementName());
if (isAcceptCompilationUnit(unit)) {
countCompilationUnit++;
IProgressMonitor subProgress = new NullProgressMonitor();
// new SubProgressMonitor(monitor, 100); ///??? does not work... blink on screen, display
// last level?
IProgressMonitor oldMonitor = monitor;
monitor = subProgress; // HACK...
try {
handleCompilationUnit(unit);
} finally {
monitor = oldMonitor; // RESTORE from HACK...
}
}
if (monitor.isCanceled()) {
throw new OperationCanceledException();
}
monitor.worked(1);
}
} catch (Exception ex) {
addErrorMsg("Failed :" + ex.toString());
} finally {
onFinishRun();
}
}
