NERInterface.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: NERInterface.java
 * Description: Interface for call of external program (deamon)
 */

/**
 * @file NERInterface.java
 *
 * @brief Interface for call of external program (deamon) with NER
 */

package cz.vutbr.fit.knot.annotations.modules.suggestionManager;

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.entity.ServerSetting;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Interface for call of external program (deamon) with NER
 * 
 * @brief Interface for call of external program (deamon)
 * @author Marek Kopecky
 */
public class NERInterface {
  
  /**
   *  Default command for external program
   */
  public static final String NER_COMMAND = "/var/sec/NER/ner.py";
  
  /**
   *  Default path for external program
   */
  public static final String NER_PATH = "/var/sec/NER/";
  
  /**
   *  Default KB path for external program
   */
  public static final String NER_KB_PATH = "/var/sec/NER/KBstatsMetrics.all";
  
  /**
   * Name of setting of command for external program
   */
  public static final String NER_SETTING_NAME = "nerCommand";
  
  /**
   * Name of setting of command for external program
   */
  public static final String NER_PATH_SETTING_NAME = "nerPath";
  
  /**
   * Name of setting of KB for external program
   */
  public static final String NER_KB_SETTING_NAME = "nerKB";
  
  /**
   * Input / output separator
   */
  public static final String IO_SEPARATOR = "\nNER_NEW_FILE\n";
  /**
   * Input / output separator
   */
  public static final String IO_SEPARATOR_EMPTY = "NER_NEW_FILE\n";
  /**
   * Clean input / output separator
   */
  public static final String CLEANED_IO_SEPARATOR = "NER_NEW_FILE";
  /**
   * Command for closing of NER
   */
  public static final String ENDING_COMMAND = "\nNER_END\n";
  
  /**
   * Standard input of external program
   */
  OutputStream stdin = null;
  
  /**
   * Standard error output of external program
   */
  InputStream stderr = null;
  
  /**
   * Standard output of external program
   */
  InputStream stdout = null;
  
  /**
   * Process builder information
   */
  ProcessBuilder processBuilder;
  
  /**
   * Process information
   */
  Process processVar;
  
  /**
   * Buffered writer for stdin
   */
  BufferedWriter brStdIn;
  
  /**
   * Buffered reader for stdout
   */
  BufferedReader brStdOut;
  
  /**
   * Buffered reader for stderr
   */
  BufferedReader brStdErrOut;
  
  /**
   * true - proces was initialized, false proces was not initialized
   */
  boolean wasInitialized = false;
  
  /**
   * Initialize process
   * 
   * @return true - process was created, false - process was not created
   */
  public synchronized boolean init() {
    if (wasInitialized) {
      return false;
    }
    
    String nerCommand = NER_COMMAND;
    String nerPath = NER_PATH;
    String nerKBPath = NER_KB_PATH;
    
    // Load command from DB
    Object[] params = {"name",NER_SETTING_NAME};
    @SuppressWarnings("unchecked")
    List<ServerSetting> settingsList = AppBean.getPersistenceManager().queryDB("ServerSetting.findByName",params);
    if(settingsList != null && !settingsList.isEmpty()){
      nerCommand = settingsList.get(0).getSettingValue();
    }
    // Load path from DB
    Object[] paramsP = {"name",NER_PATH_SETTING_NAME};
    @SuppressWarnings("unchecked")
    List<ServerSetting> settingsListP = AppBean.getPersistenceManager().queryDB("ServerSetting.findByName",paramsP);
    if(settingsListP != null && !settingsListP.isEmpty()){
      nerPath = settingsListP.get(0).getSettingValue();
    }
    // Load KB path from DB
    Object[] paramsK = {"name",NER_KB_SETTING_NAME};
    @SuppressWarnings("unchecked")
    List<ServerSetting> settingsListK = AppBean.getPersistenceManager().queryDB("ServerSetting.findByName",paramsK);
    if(settingsListK != null && !settingsListK.isEmpty()){
      nerKBPath = settingsListK.get(0).getSettingValue();
    }

    // create process
    try {
      processBuilder = new ProcessBuilder (nerCommand,"-d","-k",nerKBPath);
      processBuilder.directory(new File(nerPath));
      processBuilder.redirectErrorStream(true);
      processVar = processBuilder.start();
    } catch (IOException e) {
      return false;
    }
    
    stdin = processVar.getOutputStream ();
    stderr = processVar.getErrorStream ();
    stdout = processVar.getInputStream ();
    brStdIn = new BufferedWriter(new OutputStreamWriter(stdin));
    brStdOut = new BufferedReader(new InputStreamReader(stdout));
    brStdErrOut = new BufferedReader(new InputStreamReader(stdout));
    
    wasInitialized = true;
    return true;
  }
  
  /**
   * Send message to process and return response.
   * 
   * @param s Message
   * @return Response
   * @throws Exception, when proces was terminated
   */
  public synchronized String process(String s) throws Exception {
    StringBuilder output = new StringBuilder();
    try {
      brStdIn.write(s + IO_SEPARATOR);
      brStdIn.flush();
      
      int counter = 0;
      boolean processEnd = false;
      int possibleSeparatorLength = 1000;
      do {
        output.append((char) brStdOut.read());
        if (counter > possibleSeparatorLength) {
          try {
            processVar.exitValue();
            // exitValue return a value
            processEnd = true;
          } catch (Exception e) { // process hasn't finished yet
          }
          if (processEnd) {
            throw new Exception("Process was terminated");
          }
          counter = 0;
        }
        counter++;
        possibleSeparatorLength = output.length() - IO_SEPARATOR_EMPTY.length();
      } while ((possibleSeparatorLength >= 0) ? (!output.substring(possibleSeparatorLength).equals(IO_SEPARATOR) &&
              !output.substring(possibleSeparatorLength).equals(IO_SEPARATOR_EMPTY)) : true);
    } catch (IOException e) {
      try {
        StringBuilder erStr = new StringBuilder("");
        String row = brStdErrOut.readLine();
        while (row != null) {
          erStr.append(row);
          row = brStdErrOut.readLine();
        }
        Logger.getLogger(NERInterface.class.getName()).log(Level.SEVERE, "NER terminated! Error stream: " + erStr.toString());
      } catch (Exception exc) {
      }
      throw new Exception("Process was terminated");
    }
    return output.toString();
  }
  
  /**
   * Destroy process and close streams
   */
  public void close() {
    try {
      wasInitialized = false;
      try {
        stdin.write((ENDING_COMMAND).getBytes());
        stdin.flush();
      } catch (Exception exception) {
      }
      stdin.close();
      brStdOut.close();
      // clean up if any output in stderr
      BufferedReader brCleanUp = new BufferedReader(new InputStreamReader(stderr));
      while (brCleanUp.readLine() != null) {
      }
      brCleanUp.close();
      stdout.close();
      stderr.close();
      processVar.destroy();
    } catch (IOException e) {}
  }
}  // public class NERInterface