Update run/rerun SWAN action to use new program arguments implementation

Author: oshando

swan_assist/build.gradle

@@ -14,8 +14,10 @@ repositories {
 
 dependencies {
     compile group: 'com.googlecode.json-simple', name: 'json-simple', version: '1.1'
-    compile group:'de.upb.cs.swt', name: 'swan_core', version: '1.0.0'
+    compile group:'de.upb.cs.swt', name: 'swan_core', version: '1.3.0'
     compile group: 'ca.mcgill.sable', name: 'soot', version: '3.3.0'
+    compile group: 'org.slf4j', name: 'slf4j-api', version: '1.7.5'
+    compile group: 'org.slf4j', name: 'slf4j-simple', version: '1.7.5'
     testCompile group: 'junit', name: 'junit', version: '4.12'
 }
 

swan_assist/src/main/java/de/fraunhofer/iem/swan/assist/actions/LaunchSwanAction.java

@@ -20,20 +20,20 @@
 import de.fraunhofer.iem.swan.assist.data.MethodWrapper;
 import de.fraunhofer.iem.swan.assist.ui.dialog.SwanLauncherDialog;
 import de.fraunhofer.iem.swan.assist.util.Constants;
+import de.fraunhofer.iem.swan.data.Method;
 
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Objects;
-import java.util.Properties;
+import java.io.InputStreamReader;
+import java.util.*;
 
 /**
  * Action opens dialog for user to set parameters for running SWAN. After which thread is created to run SWAN.
  */
 public class LaunchSwanAction extends AnAction {
 
+    protected Set<Method> methods = new HashSet<Method>();
     /**
      * Obtains application parameters from user, exports updated JSON file and starts thread to run SWAN.
      * @param anActionEvent source event
@@ -70,27 +70,35 @@ public void actionPerformed(AnActionEvent anActionEvent) {
 
             HashMap<String, String> swanParameters = dialog.getParameters();
 
-            //Merge current list with training methods
-            HashMap<String, MethodWrapper> methods = JSONFileLoader.getAllMethods();
+            if(JSONFileLoader.isFileSelected()) {
+                //Merge current list with training methods
+                HashMap<String, MethodWrapper> methods = JSONFileLoader.getAllMethods();
 
-            //Load training methods
-            String trainingFile = Objects.requireNonNull(getClass().getClassLoader().getResource(config.getProperty("train_config_file"))).getPath() ;
-            JSONFileParser fileParser = new JSONFileParser(trainingFile);
-            HashMap<String, MethodWrapper> trainingMethods = fileParser.parseJSONFileMap();
+                InputStream stream = getClass().getClassLoader().getResourceAsStream(config.getProperty("train_config_file"));
+                HashMap<String, MethodWrapper> trainingMethods = new HashMap<>();
 
-            HashMap<String, MethodWrapper> mergedMethods = new HashMap<>(methods);
-            mergedMethods.putAll(trainingMethods);
+                if (stream != null) {
 
-            //Export changes to configuration files
-            JSONWriter exportFile = new JSONWriter();
-            String newConfigFile = swanParameters.get(Constants.SWAN_OUTPUT_DIR) + File.separator + config.getProperty("input_json_suffix");
-            try {
-                exportFile.writeToJsonFile(new ArrayList<>(mergedMethods.values()), newConfigFile);
-            } catch (IOException e) {
-                e.printStackTrace();
-            }
+                    JSONFileParser fileParser = new JSONFileParser();
+                    trainingMethods = fileParser.parseJSONFileStream(new InputStreamReader(stream));
+                }
+
+                HashMap<String, MethodWrapper> mergedMethods = new HashMap<>(methods);
+                mergedMethods.putAll(trainingMethods);
 
-            swanParameters.put(Constants.SWAN_CONFIG_FILE, newConfigFile);
+                //Export changes to configuration files
+                JSONWriter exportFile = new JSONWriter();
+                String newConfigFile = swanParameters.get(Constants.SWAN_OUTPUT_DIR) + File.separator + config.getProperty("input_json_suffix");
+                try {
+                    exportFile.writeToJsonFile(new ArrayList<>(mergedMethods.values()), newConfigFile);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                swanParameters.put(Constants.SWAN_CONFIG_FILE, newConfigFile);
+            }
+            else{
+                swanParameters.put(Constants.SWAN_CONFIG_FILE, config.getProperty("swan_default_param_value"));
+            }
 
             SwanProcessBuilder processBuilder = new SwanProcessBuilder(project, dialog.getParameters());
             processBuilder.start();
@@ -108,7 +116,7 @@ public void actionPerformed(AnActionEvent anActionEvent) {
     public void update(AnActionEvent event) {
 
         //Disable/Enable action button
-        if (JSONFileLoader.isReloading() || !JSONFileLoader.isFileSelected())
+        if (JSONFileLoader.isReloading())
             event.getPresentation().setEnabled(false);
         else
             event.getPresentation().setEnabled(true);

swan_assist/src/main/java/de/fraunhofer/iem/swan/assist/actions/SwanProcessBuilder.java

@@ -9,11 +9,11 @@
 
 import com.intellij.openapi.project.Project;
 import com.intellij.util.messages.MessageBus;
+import de.fraunhofer.iem.swan.Main;
 import de.fraunhofer.iem.swan.assist.comm.SwanNotifier;
 import de.fraunhofer.iem.swan.assist.util.Constants;
 
-import java.io.File;
-import java.io.IOException;
+import java.io.*;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.HashMap;
@@ -46,51 +46,36 @@ public void run() {
 
         ResourceBundle resource = ResourceBundle.getBundle("dialog_messages");
 
-        String currentTimestamp = getCurrentTimestamp("yyyy-MM-dd-HHmmss");
+        String currentTimestamp = getCurrentTimestamp();
 
         File outputFolder = new File(parameters.get(Constants.SWAN_OUTPUT_DIR));
-        outputFolder.mkdirs();
+
+        if(!outputFolder.exists())
+            outputFolder.mkdir();
 
         File logFile = new File(outputFolder, currentTimestamp + parameters.get(Constants.SWAN_OUTPUT_LOG));
         try {
             logFile.createNewFile();
             parameters.replace(Constants.SWAN_OUTPUT_LOG, logFile.getPath());
 
+            FileOutputStream fileOutputStream = new FileOutputStream(logFile.getAbsolutePath());
+
+            System.setOut(new PrintStream(fileOutputStream));
+
         } catch (IOException e) {
             e.printStackTrace();
         }
 
-        ProcessBuilder processBuilder = new ProcessBuilder("java", "-jar",
-                parameters.get(Constants.SWAN_JAR_DIR),
-                parameters.get(Constants.SWAN_SOURCE_DIR),
+        Main.main(new String[]{parameters.get(Constants.SWAN_SOURCE_DIR),
                 parameters.get(Constants.SWAN_TRAIN_DIR),
                 parameters.get(Constants.SWAN_CONFIG_FILE),
-                parameters.get(Constants.SWAN_OUTPUT_DIR));
+                parameters.get(Constants.SWAN_OUTPUT_DIR)});
 
-        processBuilder.redirectErrorStream(true);
-        processBuilder.redirectOutput(ProcessBuilder.Redirect.appendTo(logFile));
-
-        String message;
-
-        try {
-            Process swanProcess = processBuilder.start();
-            int result = swanProcess.waitFor();
-
-            if (result == 0)
-                message = resource.getString("Messages.Notification.Success");
-            else
-                message = resource.getString("Messages.Notification.Failure");
-
-        } catch (IOException | InterruptedException e) {
-
-            e.printStackTrace();
-            message = resource.getString("Messages.Notification.Failure");
-        }
+        System.setOut(System.out);
 
         HashMap<String, String> results = new HashMap<String, String>();
         results.put(Constants.SWAN_OUTPUT_FILE, parameters.get(Constants.SWAN_OUTPUT_FILE));
         results.put(Constants.SWAN_OUTPUT_LOG, parameters.get(Constants.SWAN_OUTPUT_LOG));
-        results.put(Constants.SWAN_OUTPUT_MESSAGE, message);
 
         MessageBus messageBus = project.getMessageBus();
         SwanNotifier publisher = messageBus.syncPublisher(SwanNotifier.END_SWAN_PROCESS_TOPIC);
@@ -99,12 +84,11 @@ public void run() {
 
     /**
      * Get the timestamp in a specified format.
-     * @param dateFormat Date format that should be used.
      * @return Formatted date
      */
-    private String getCurrentTimestamp(String dateFormat) {
+    private String getCurrentTimestamp() {
 
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(dateFormat);
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd-HHmmss");
         return LocalDateTime.now().format(formatter);
     }
 }

swan_assist/src/main/java/de/fraunhofer/iem/swan/assist/ui/MethodListTree.java

@@ -40,11 +40,13 @@
 import de.fraunhofer.iem.swan.assist.comm.*;
 import de.fraunhofer.iem.swan.assist.data.JSONFileLoader;
 import de.fraunhofer.iem.swan.assist.data.MethodWrapper;
+import de.fraunhofer.iem.swan.assist.ui.dialog.MethodDialog;
 import de.fraunhofer.iem.swan.assist.ui.dialog.SwanResultsDialog;
 import de.fraunhofer.iem.swan.assist.util.Constants;
 import de.fraunhofer.iem.swan.assist.util.Formatter;
 import de.fraunhofer.iem.swan.assist.util.PsiTraversal;
 import de.fraunhofer.iem.swan.data.Category;
+import de.fraunhofer.iem.swan.data.Method;
 import javafx.util.Pair;
 import org.jetbrains.annotations.NotNull;
 
@@ -70,6 +72,7 @@ public class MethodListTree extends Tree {
 
     /**
      * Initialises method list tree
+     *
      * @param project Active project in IDE
      */
     public MethodListTree(Project project) {
@@ -98,55 +101,62 @@ public void mouseClicked(MouseEvent e) {
                 if ((SwingUtilities.isRightMouseButton(e) || (e.isControlDown()) && !isEmpty())) {
 
                     DefaultMutableTreeNode node = (DefaultMutableTreeNode) getLastSelectedPathComponent();
-                    Object object = node.getUserObject();
 
-                    if (object instanceof MethodWrapper) {
+                    if (node != null) {
+
+                        Object object = node.getUserObject();
+
+                        if (object instanceof MethodWrapper) {
 
-                        MethodWrapper method = (MethodWrapper) object;
+                            MethodWrapper method = (MethodWrapper) object;
 
-                        RESTORE_METHOD = method.getUpdateOperation().equals(Constants.METHOD_DELETED);
+                            RESTORE_METHOD = method.getUpdateOperation().equals(Constants.METHOD_DELETED);
 
-                        ActionPopupMenu actionPopupMenu = ActionManager.getInstance().createActionPopupMenu("Method", new MethodActionGroup(method));
-                        actionPopupMenu.getComponent().show(e.getComponent(), e.getX(), e.getY());
+                            ActionPopupMenu actionPopupMenu = ActionManager.getInstance().createActionPopupMenu("Method", new MethodActionGroup(method));
+                            actionPopupMenu.getComponent().show(e.getComponent(), e.getX(), e.getY());
+                        }
                     }
 
                 } else if (e.getClickCount() == 2) {
 
                     DefaultMutableTreeNode node = (DefaultMutableTreeNode) getLastSelectedPathComponent();
-                    Object object = node.getUserObject();
+                    if (node != null) {
+                        Object object = node.getUserObject();
 
-                    if (object instanceof MethodWrapper) {
+                        if (object instanceof MethodWrapper) {
 
-                        MethodWrapper method = (MethodWrapper) object;
+                            MethodWrapper method = (MethodWrapper) object;
 
-                        //Get PSI element location
-                        PsiFile[] files = FilenameIndex.getFilesByName(project, method.getFileName(), GlobalSearchScope.allScope(project));
+                            //Get PSI element location
+                            PsiFile[] files = FilenameIndex.getFilesByName(project, method.getFileName(), GlobalSearchScope.allScope(project));
 
-                        boolean methodFound = false;
+                            boolean methodFound = false;
 
-                        for (PsiFile file : files) {
+                            for (PsiFile file : files) {
 
-                            PsiJavaFile psiJavaFile = (PsiJavaFile) file;
+                                PsiJavaFile psiJavaFile = (PsiJavaFile) file;
 
-                            for (PsiClass psiClass : psiJavaFile.getClasses()) {
-                                for (PsiMethod psiMethod : psiClass.getMethods()) {
+                                for (PsiClass psiClass : psiJavaFile.getClasses()) {
+                                    for (PsiMethod psiMethod : psiClass.getMethods()) {
 
-                                    if (Objects.equals(PsiTraversal.getMethodSignature(psiMethod), method.getSignature(true))) {
+                                        if (Objects.equals(PsiTraversal.getMethodSignature(psiMethod), method.getSignature(true))) {
 
-                                        methodFound = true;
-                                        FileEditorManager.getInstance(project).openFile(psiJavaFile.getVirtualFile(), true, true);
-                                        FileEditorManager.getInstance(project).getSelectedTextEditor().getCaretModel().moveToOffset(psiMethod.getTextOffset());
+                                            methodFound = true;
+                                            FileEditorManager.getInstance(project).openFile(psiJavaFile.getVirtualFile(), true, true);
+                                            FileEditorManager.getInstance(project).getSelectedTextEditor().getCaretModel().moveToOffset(psiMethod.getTextOffset());
+                                        }
                                     }
                                 }
                             }
-                        }
 
-                        if (!methodFound) {
-                            JBPopupFactory.getInstance().createHtmlTextBalloonBuilder(resource.getString("Messages.Error.MethodNotFound"), MessageType.ERROR, null)
-                                    .createBalloon()
-                                    .show(JBPopupFactory.getInstance().guessBestPopupLocation((JComponent) e.getComponent()), Balloon.Position.below);
+                            if (!methodFound) {
+                                JBPopupFactory.getInstance().createHtmlTextBalloonBuilder(resource.getString("Messages.Error.MethodNotFound"), MessageType.ERROR, null)
+                                        .createBalloon()
+                                        .show(JBPopupFactory.getInstance().guessBestPopupLocation((JComponent) e.getComponent()), Balloon.Position.below);
+                            }
                         }
                     }
+
                 }
             }
         });
@@ -279,12 +289,11 @@ public void launchSwan(HashMap<String, String> values) {
                 JSONFileLoader.setReloading(false);
                 NotificationType notificationType = NotificationType.INFORMATION;
 
-                if (!values.get(Constants.SWAN_OUTPUT_MESSAGE).equals(resource.getString("Messages.Notification.Success"))) {
-                    notificationType = NotificationType.ERROR;
-                }
+                String message = "<html>"
+                        + resource.getString("Messages.Notification.Completed")
+                        + "<br><a href='logs'>View Logs</a> or <a href='load'>Load Changes</a></html>";
 
-                String message = "<html>" + values.get(Constants.SWAN_OUTPUT_MESSAGE) + "<br><a href='logs'>View Logs</a> or <a href='load'>Load Changes</a></html>";
-                Notifications.Bus.notify(new Notification(Constants.PLUGIN_GROUP_DISPLAY_ID, "Completed", message, notificationType, new NotificationListener() {
+                Notifications.Bus.notify(new Notification(Constants.PLUGIN_GROUP_DISPLAY_ID, resource.getString("Messages.Notification.Title.Completed"), message, notificationType, new NotificationListener() {
                     @Override
                     public void hyperlinkUpdate(@NotNull Notification notification, @NotNull HyperlinkEvent hyperlinkEvent) {
 
@@ -305,6 +314,52 @@ public void hyperlinkUpdate(@NotNull Notification notification, @NotNull Hyperli
             }
         });
 
+
+        //Update Tool Window to notify user that SWAN is running
+        bus.connect().subscribe(SuggestNotifier.START_SUGGEST_TOPIC, new SuggestNotifier() {
+            @Override
+            public void setStartSuggestTopic() {
+                JSONFileLoader.setReloading(true);
+                Notifications.Bus.notify(new Notification(Constants.PLUGIN_GROUP_DISPLAY_ID, resource.getString("Messages.Title.SuggestStarted"), resource.getString("Messages.Notification.SuggestStarted"), NotificationType.INFORMATION));
+
+            }
+
+            @Override
+            public void setEndSuggestTopic(Set<Method> values) {
+                JSONFileLoader.setReloading(false);
+
+                NotificationType notificationType = NotificationType.INFORMATION;
+
+                String message = "<html>" + resource.getString("Messages.Notification.Suggest.Successful") + "<br><a href='methods'>View methods</a></html>";
+                Notifications.Bus.notify(new Notification(Constants.PLUGIN_GROUP_DISPLAY_ID, "Completed", message, notificationType, new NotificationListener() {
+                    @Override
+                    public void hyperlinkUpdate(@NotNull Notification notification, @NotNull HyperlinkEvent hyperlinkEvent) {
+
+                        if (hyperlinkEvent.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
+
+                            if (hyperlinkEvent.getDescription().equals("methods")) {
+
+                                HashMap<String,MethodWrapper> suggestedMethods = new HashMap<>();
+
+                                for(Method m: values){
+
+                                   MethodWrapper methodWrapper = new MethodWrapper(m);
+                                   methodWrapper.setStatus(MethodWrapper.MethodStatus.SUGGESTED);
+
+                                   suggestedMethods.put(methodWrapper.getSignature(true), methodWrapper);
+                                }
+
+                                MethodDialog dialog  = new MethodDialog(suggestedMethods, (String)suggestedMethods.keySet().toArray()[0], project, JSONFileLoader.getCategories());
+                                dialog.show();
+
+
+                            }
+                        }
+                    }
+                }));
+            }
+        });
+
         //Connect to project bus and obtain filter for Method Tree
         bus.connect().subscribe(FilterNotifier.FILTER_SELECTED_TOPIC, new FilterNotifier() {
             @Override
@@ -379,6 +434,7 @@ private DefaultMutableTreeNode searchNode(DefaultMutableTreeNode root, String me
 
     /**
      * Add new node to tree
+     *
      * @param method New method to be added
      */
     private void addNode(MethodWrapper method) {
@@ -390,6 +446,7 @@ private void addNode(MethodWrapper method) {
 
     /**
      * Extracts categories from method and adds them to the DefaultMutableTreeNode node.
+     *
      * @param method the method that is being added to the tree
      * @return the node object with the categories as children
      */
@@ -399,6 +456,7 @@ private DefaultMutableTreeNode addCategoriesToNode(MethodWrapper method) {
 
     /**
      * Extracts categories from method and adds them to the DefaultMutableTreeNode node.
+     *
      * @param node   method to be added to tree
      * @param method the method that is being added to the tree
      * @return the node object with the categories as children