protected void runSootDirectly(String mainClass) {
int length = getSootCommandList().getList().size();
String temp[] = new String[length];
getSootCommandList().getList().toArray(temp);
sendSootOutputEvent(mainClass);
sendSootOutputEvent(" ");
final String[] cmdAsArray = temp;
for (int i = 0; i < temp.length; i++) {
sendSootOutputEvent(temp[i]);
sendSootOutputEvent(" ");
}
sendSootOutputEvent("\n");
IRunnableWithProgress op;
try {
newProcessStarting();
op = new SootRunner(temp, Display.getCurrent(), mainClass);
((SootRunner) op).setParent(this);
ModalContext.run(op, true, new NullProgressMonitor(), Display.getCurrent());
} catch (InvocationTargetException e1) {
// handle exception
System.out.println("InvocationTargetException: " + e1.getMessage());
System.out.println("InvocationTargetException: " + e1.getTargetException());
System.out.println(e1.getStackTrace());
} catch (InterruptedException e2) {
// handle cancelation
System.out.println("InterruptedException: " + e2.getMessage());
}
}
/* (non-Javadoc)
* Method declared on IRunnableContext
*/
public void run(boolean fork, boolean cancelable, IRunnableWithProgress runnable)
throws InvocationTargetException, InterruptedException {
if (fProgressMonitorPart == null) {
ModalContext.run(runnable, false, new NullProgressMonitor(), getShell().getDisplay());
} else {
Object state = null;
if (fActiveRunningOperations == 0) state = aboutToStart(fork && cancelable);
fActiveRunningOperations++;
try {
ModalContext.run(runnable, fork, fProgressMonitorPart, getShell().getDisplay());
} finally {
fActiveRunningOperations--;
// Stop if this is the last one
if (state != null) stopped(state);
}
}
}
@Override
public void run(boolean fork, boolean cancelable, IRunnableWithProgress runnable)
throws InvocationTargetException, InterruptedException {
ModalContext.run(runnable, fork, monitor, getDisplay());
}
// ------------------------------------------------------------------------
// Operation(s)
// ------------------------------------------------------------------------
@Override
public void run(IProgressMonitor monitor) {
try {
monitor.worked(1);
String root = null;
List<TracePackageElement> resultElementList = new ArrayList<>();
SubMonitor subMonitor = SubMonitor.convert(monitor, fProfile.getChildren().length * 2);
List<RemoteImportConnectionNodeElement> connectionNodes =
fProfile.getConnectionNodeElements();
for (RemoteImportConnectionNodeElement connectionNode : connectionNodes) {
RemoteSystemProxy proxy = connectionNode.getRemoteSystemProxy();
// create new element to decouple from input element
RemoteImportConnectionNodeElement outputConnectionNode =
new RemoteImportConnectionNodeElement(
null, connectionNode.getName(), connectionNode.getURI());
resultElementList.add(outputConnectionNode);
for (TracePackageElement element : connectionNode.getChildren()) {
if (element instanceof RemoteImportTraceGroupElement) {
ModalContext.checkCanceled(monitor);
RemoteImportTraceGroupElement traceGroup = (RemoteImportTraceGroupElement) element;
root = traceGroup.getRootImportPath();
TracePackageElement[] traceElements = traceGroup.getChildren();
fTemplatePatternsToTraceElements = generatePatterns(traceElements);
IRemoteFileService fs =
proxy.getRemoteConnection().getService(IRemoteFileService.class);
if (fs == null) {
continue;
}
final IFileStore remoteFolder = fs.getResource(root);
// make sure that remote directory is read and not cached
int recursionLevel = 0;
// create new element to decouple from input element
RemoteImportTraceGroupElement outputTraceGroup =
new RemoteImportTraceGroupElement(
outputConnectionNode, traceGroup.getRootImportPath());
outputTraceGroup.setRecursive(traceGroup.isRecursive());
generateElementsFromArchive(
outputTraceGroup,
outputTraceGroup,
remoteFolder,
recursionLevel,
subMonitor.newChild(1));
filterElements(outputTraceGroup);
}
}
}
setResultElements(resultElementList.toArray(new TracePackageElement[0]));
setStatus(Status.OK_STATUS);
} catch (InterruptedException e) {
setStatus(Status.CANCEL_STATUS);
} catch (Exception e) {
setStatus(
new Status(
IStatus.ERROR,
Activator.PLUGIN_ID,
NLS.bind(
RemoteMessages.RemoteGenerateManifest_GenerateProfileManifestError,
fProfile.getText()),
e));
}
}
/**
* Scan traceFolder for files that match the patterns specified in the template file. When there
* is a match, the trace package element is used to determine the trace name and trace type.
*
* @param traceGroup The parent trace group element
* @param parentElement The immediate parent trace group or folder element
* @param traceFolder The folder to scan
* @param recursionLevel The recursion level (needed to find directory traces under the
* traceFolder
* @param monitor The progress monitor
* @throws CoreException Thrown by the file system implementation
* @throws InterruptedException Thrown if operation was cancelled
*/
private void generateElementsFromArchive(
final RemoteImportTraceGroupElement traceGroup,
final TracePackageElement parentElement,
final IFileStore traceFolder,
final int recursionLevel,
IProgressMonitor monitor)
throws CoreException, InterruptedException {
int localRecursionLevel = recursionLevel + 1;
IFileStore[] sources = traceFolder.childStores(EFS.NONE, monitor);
for (int i = 0; i < sources.length; i++) {
ModalContext.checkCanceled(monitor);
SubMonitor subMonitor = SubMonitor.convert(monitor, sources.length);
IFileStore fileStore = sources[i];
IPath fullArchivePath = TmfTraceCoreUtils.newSafePath(fileStore.toURI().getPath());
IFileInfo sourceInfo = fileStore.fetchInfo();
if (!sourceInfo.isDirectory()) {
String rootPathString = traceGroup.getRootImportPath();
IPath rootPath = TmfTraceCoreUtils.newSafePath(rootPathString);
IPath relativeTracePath = Path.EMPTY;
if (rootPath.isPrefixOf(fullArchivePath)) {
relativeTracePath = fullArchivePath.makeRelativeTo(rootPath);
}
Entry<Pattern, TracePackageTraceElement> matchingTemplateEntry =
getMatchingTemplateElement(relativeTracePath);
if (matchingTemplateEntry != null) {
TracePackageTraceElement matchingTemplateElement = matchingTemplateEntry.getValue();
String traceType = matchingTemplateElement.getTraceType();
// If a single file is part of a directory trace, use the parent directory instead
TracePackageElement parent = parentElement;
if (matchesDirectoryTrace(relativeTracePath, matchingTemplateEntry)) {
fullArchivePath = fullArchivePath.removeLastSegments(1);
fDirectoryTraces.add(fullArchivePath);
fileStore = fileStore.getParent();
parent = parentElement.getParent();
// Let the auto-detection choose the best trace type
traceType = null;
} else if ((localRecursionLevel > 1) && (!traceGroup.isRecursive())) {
// Don't consider file traces on level 2 if it's not recursive
continue;
}
String traceName = fullArchivePath.lastSegment();
String fileName = fileStore.getName();
// create new elements to decouple from input elements
TracePackageTraceElement traceElement =
new TracePackageTraceElement(parent, traceName, traceType);
RemoteImportTraceFilesElement tracePackageFilesElement =
new RemoteImportTraceFilesElement(traceElement, fileName, fileStore);
tracePackageFilesElement.setVisible(false);
}
} else {
if (traceGroup.isRecursive() || localRecursionLevel < 2) {
RemoteImportFolderElement folder =
new RemoteImportFolderElement(parentElement, fileStore.getName());
generateElementsFromArchive(
traceGroup, folder, fileStore, localRecursionLevel, subMonitor);
}
}
}
}
private boolean login(boolean test) {
final String username = usernameText.getText();
final String password = passwordText.getText();
if (StringUtil.isEmpty(username)) {
if (test) {
MessageDialog.openError(
main.getShell(),
Messages.JiraPreferencePageProvider_ERR_InvalidInput_Title,
Messages.JiraPreferencePageProvider_ERR_EmptyUsername);
return false;
}
return true;
}
if (StringUtil.isEmpty(password)) {
if (test) {
MessageDialog.openError(
main.getShell(),
Messages.JiraPreferencePageProvider_ERR_InvalidInput_Title,
Messages.JiraPreferencePageProvider_ERR_EmptyPassword);
return false;
}
return true;
}
setUILocked(true);
firePreValidationStartEvent();
try {
ModalContext.run(
new IRunnableWithProgress() {
public void run(IProgressMonitor monitor)
throws InvocationTargetException, InterruptedException {
monitor.beginTask(
Messages.JiraPreferencePageProvider_ValidateCredentials,
IProgressMonitor.UNKNOWN);
try {
IStatus status = getJiraManager().login(username, password);
if (status.isOK()) {
// successful; now re-layout to show the logout components
UIUtils.getDisplay()
.asyncExec(
new Runnable() {
public void run() {
updateUserText();
layout();
}
});
} else {
throw new InvocationTargetException(new CoreException(status));
}
} finally {
if (!monitor.isCanceled()) {
monitor.done();
}
}
}
},
true,
getProgressMonitor(),
UIUtils.getDisplay());
} catch (InvocationTargetException e) {
if (main != null && !main.isDisposed()) {
MessageDialog.openError(
main.getShell(),
Messages.JiraPreferencePageProvider_ERR_LoginFailed_Title,
e.getTargetException().getMessage());
}
return false;
} catch (Exception e) {
IdeLog.logError(JiraUIPlugin.getDefault(), e);
} finally {
setUILocked(false);
firePostValidationEndEvent();
}
return true;
}