Best way to process/handle Error stream messages

Question

I need to process different Error/Exception messages generated compile/run time.

I execute a Java program an read the stream thus generated :

final Process p2 = builder.start();
BufferedReader in = new BufferedReader(new                                                 
        InputStreamReader(p2.getInputStream()));

For each success , the output is generated and shown. No problem there. But I need to show custom message for every Error message.

EG:

Error: Main method not found in class dummy.helloParse10.hello, please define the main method as:
public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application

May be customized as : Error: Main method not found

My current approach is very ugly and limited . I am looking if "Exception" string is present in error stream and then taking out the sub- strings.Something like :

if(tError.contains("Exception"))            
      tError=tError.substring(tError.indexOf("main\"")+5,tError.indexOf("at"))
        + "( At Line: "+tError.substring(tError.indexOf(".java")+6);

But it do not customize my approach in a broad way.

What is the best thing I could do?

Edit :

I think my question is unclear. Basically I am executing a Java program via ProcessBuilder.

    //Compile the program 
  Process p = Runtime.getRuntime().exec("javac filename ");

    // Now get the error stream if available :
  BufferedReader in = new BufferedReader(new            
                    InputStreamReader(p.getOutputStream()));

 String line = null;
 while ((line = in.readLine()) != null) {

       //process error in compilation.
       }
    ...
    ...
  // ProcessBuilder to execute the program.java
  //Read the output or runtime Exception  

No the output of the process can be the result of te java program or an exception/error which is taken from the process steam an is in String form.Need to manipulate those Errors.

Update :

I can now solve the compile time errors via Java Compiler API as suggested by @Miserable Variable .How can I deal with Runtime Exceptions similarly ?

EDIT : In actual it is not possible to modify the program to be run in a new process.They are user specific.

Answer 1

The way I understand it is,

Problem statement:

Write a Java program which should be able to
1. Take an input as Java program file
2. Compile it and produce errors if can't compile
3. Run the class file generated in previous step
4. Produce the run time exceptions generated by the invocation if any

Assumptions:
1. Class would contain a "main" method else it can't be run using "java" program

Given above problem statement I have produced a solution. Before code I think it's a good idea to explain what it does, in the order it does it.

Solution steps:

1. Compile the Java code using the compiler API (using ToolProvider.getSystemJavaCompiler())
2. Use DiagnosticCollector to collect for any compilation errors that might have ocurred.
3. If compilation is successful then load the generated class in byte array.
4. Use ClassLoader.defineClass() to load class file from byte array into JVM runtime.
5. Once class is loaded, use reflection to find the main method, if not present throw main not found related exceptions.
6. Run main method, and report back any runtime exceptions produced.

Note: If needed Standard input and output streams can be redirected for 
      the new program and original objects can be saved as originals for 
      main program. I haven't done it, but it's trivial to do.

Working code:

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.tools.Diagnostic;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

public class JreMain {
    private static final String PATH_TO_JAVA_FILE = "src/main/java/MyProgram.java";

    public static void main(String[] args) {
        JreMain main = new JreMain();
        System.out.println("Running a java program");

        String filePath = PATH_TO_JAVA_FILE;


        File javaFile = new File(filePath);
        /*compiling the file */
        List<String> errorList = main.compile(Arrays.asList(javaFile));

        if(errorList.size() != 0) {
            System.out.println("file could not be compiled, check below for errors");

            for(String error : errorList) {
                System.err.println("Error : " + error);
            }
        } else {
            main.runJavaClass(filePath, new String[] {});
        }
    }

    @SuppressWarnings({"rawtypes", "unchecked"})
    private void runJavaClass(String filePath, String[] mainArguments) {

        System.out.println("Running " + filePath);

        ClassLoader classLoader = getClass().getClassLoader();
        Class klass = null;
        String fileNameWithoutExtension = filePath.substring(0, filePath.length() - ".java".length());
        String className = getClassName(fileNameWithoutExtension);
        /* loading defineClass method in Classloader through reflection, since it's 'protected' */
        try {
            /* signature of defineClass method: protected final Class<?> defineClass(String name, byte[] b, int off, int len)*/

            Method defineClassMethod = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, Integer.TYPE, Integer.TYPE);
            defineClassMethod.setAccessible(true);

            /* attempting to load our class in JVM via byte array */

            byte[] classBytes = getClassBytes(fileNameWithoutExtension + ".class");
            klass = (Class)defineClassMethod.invoke(classLoader, className, classBytes, 0, classBytes.length);

        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        /* checking if main method exists, in the loaded class, and running main if exists*/

        if(klass != null) {
            try {
                Method mainMethod = klass.getMethod("main", String[].class);
                Class returnType = mainMethod.getReturnType();

                /*Checking for main method modifiers and return type*/

                if( !Modifier.isStatic(mainMethod.getModifiers()) || !Modifier.isPublic(mainMethod.getModifiers()) || !(returnType.equals(Void.TYPE) || returnType.equals(Void.class))) {
                    throw new RuntimeException("Main method signature incorrect, expected : \"public static void main(String[] args)\",");
                }

                /* finally invoking the main method **/
                mainMethod.invoke(null, new Object[]{mainArguments});

            } catch (NoSuchMethodException e) {
                throw new RuntimeException("Class " + klass.getCanonicalName() + " does not declare main method");
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                /*e.printStackTrace();*/
                System.err.println("Exception in main :");
                throw new RuntimeException(e.getCause());
            }
        }
    }

    private String getClassName(String fileNameWithoutExtension) {
        String className = null;
        int lastIndex = -1;
        if( ( lastIndex = fileNameWithoutExtension.lastIndexOf(File.separator)) != -1) {
            className = fileNameWithoutExtension.substring(lastIndex + 1);
        } if( ( lastIndex = fileNameWithoutExtension.lastIndexOf("\\")) != -1) {
            className = fileNameWithoutExtension.substring(lastIndex + 1);
        } else if( ( lastIndex = fileNameWithoutExtension.lastIndexOf("/")) != -1) {
            className = fileNameWithoutExtension.substring(lastIndex + 1);
        }
        return className;
    }

    private byte[] getClassBytes(String classFilePath) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        File classFile = new File(classFilePath);
        if(!classFile.exists()) {
            throw new RuntimeException("Class file does not exist : " + classFile.getAbsolutePath());
        }

        byte[] buffer = new byte[2048];
        int readLen = -1;
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(classFile);
            while( (readLen = fis.read(buffer)) != -1) {
                baos.write(buffer, 0, readLen);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return baos.toByteArray();
    }

    @SuppressWarnings("restriction")
    public List<String> compile (List<File> javaFileList) {
        System.out.println("Started compilation");
        List<String> errorList = new ArrayList<String>();
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

        DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(
                diagnostics, null, null);

        Iterable<? extends JavaFileObject> compilationUnits = fileManager
                .getJavaFileObjectsFromFiles(javaFileList);
        compiler.getTask(null, fileManager, diagnostics, null, null, compilationUnits)
                .call();

        for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics
                .getDiagnostics()) {
            String diagnosticMessage = String.format("Error on line %d in %s%n",
                    diagnostic.getLineNumber(), diagnostic.getSource().toUri() + " : \n\t" + diagnostic.getMessage(null));

            /*Following gives out of box good message, but I used above to show the custom use of diagnostic
             * String diagnosticMessage = diagnostic.toString();*/

            errorList.add(diagnosticMessage);
        }
        try {
            fileManager.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return errorList;
    }
}

Thanks to @Miserable Variable, I was almost set to create a process for the javac program, but your answer saved me some ugly code.

** *Edited **

Command line arguments

For compilation:

//in the JreMain.compile()    
List<String> compilerOptionsList = Arrays.asList("-classpath", "jar/slf4j-api-1.7.10.jar", "-verbose");
JavaCompiler.CompilationTask compilationTask = compiler.getTask(null,
            fileManager, diagnostics, compilerOptionsList, null,
            compilationUnits);

For Java runtime arguments:

They will have to be passed to our JareMain program itself.
java -classpath "jar/slf4j-api-1.7.10.jar;" -verbose JreMain

For main method of new program:

//second argument here is going to main method
 main.runJavaClass(filePath, new String[] {});

Answer 2

For Runtime exceptions ,you could look into ProcessBuilder and streaming the error exceptions and then checking for the same.Here are some examples that can help you:

http://examples.javacodegeeks.com/core-java/lang/processbuilder/java-lang-processbuilder-example/

Answer 3

It would be much easier IMO if your program relies on a logging framework to log its errors in a certain log format. You can benefit from this by using a log parser. It should be simple to write your own and maybe you can define a dictionary of common errors patterns that are assigned to your specific program.

If your program does not follow a well-defined log pattern and you want a scalable approach, then one possible way is to implement a Grok-based solution. Grok is used in powerful tools like Logstash. See this post for how to do this in Java.

Answer 4

For identifying errors in compilation, instead of running javac using ProcessBuilder a better alternative might be to use Java Compiler API.

I have never used it myself but it seems pretty straightforward.