SECAPIInterface.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: SECAPIInterface.java
 * Description: Interface for call of SEC API (locally as a daemon)
 */

/**
 * @file SECAPIInterface.java
 *
 * @brief Interface for call of SEC API (locally as a daemon)
 */

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 SEC API as external program (deamon)
 * 
 * Note: If SEC API is started locally it will also provide interface on some 
 * port (8082 on default installation but if it is used, 8084 is recommended). 
 * So there is no need to start other instance if we need to provide SEC API 
 * network interface to others. SEC API can also provide services not only 
 * to local Annotation Server but also to other annotation servers which 
 * has acces to appropriate port.
 * 
 * @brief Interface for call of SEC API as external program (deamon)
 * @author Marek Kopecky
 */
public class SECAPIInterface {
  
  /**
   *  Default command for external program
   */
  public static final String SEC_API_COMMAND = "/var/sec/SEC_API/sec_api.py";
  
  /**
   *  Default path for external program
   */
  public static final String SEC_API_PATH = "/var/sec/SEC_API/";
  
  /**
   * Name of setting of command for external program
   */
  public static final String SEC_API_SETTING_NAME = "secCommand";
  
  /**
   * Name of setting of command for external program
   */
  public static final String SEC_API_PATH_SETTING_NAME = "secPath";
  
  /**
   * 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 secApiCommand = SEC_API_COMMAND;
    String nerPath = SEC_API_PATH;
    
    // Load command from DB
    Object[] params = {"name",SEC_API_SETTING_NAME};
    @SuppressWarnings("unchecked")
    List<ServerSetting> settingsList = AppBean.getPersistenceManager().queryDB("ServerSetting.findByName",params);
    if(settingsList != null && !settingsList.isEmpty()){
      secApiCommand = settingsList.get(0).getSettingValue();
    }
    // Load path from DB
    Object[] paramsP = {"name",SEC_API_PATH_SETTING_NAME};
    @SuppressWarnings("unchecked")
    List<ServerSetting> settingsListP = AppBean.getPersistenceManager().queryDB("ServerSetting.findByName",paramsP);
    if(settingsListP != null && !settingsListP.isEmpty()){
      nerPath = settingsListP.get(0).getSettingValue();
    }

    // create process
    try {
      processBuilder = new ProcessBuilder (secApiCommand,"-d");
      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;
  }
  
  /**
   * Returns if SEC API command is empty in database.
   * 
   * @return If SEC API command is empty in database, returns true, false otherwise.
   */
  public static boolean isSecCommandEmpty() {
    // Load command from DB
    Object[] params = {"name",SEC_API_SETTING_NAME};
    @SuppressWarnings("unchecked")
    List<ServerSetting> settingsList = AppBean.getPersistenceManager().queryDB("ServerSetting.findByName",params);
    if(settingsList != null && !settingsList.isEmpty()){
      String secApiCommand = settingsList.get(0).getSettingValue();
      if (secApiCommand.isEmpty()) {
        return true;
      }
    }
    return false;
  }
  
  /**
   * Send message to process and return response.
   * 
   * @param s Message
   * @return Response
   * @throws Exception, when proces was terminated
   */
  public synchronized String makeRequest(String s) throws Exception {
    StringBuilder output = new StringBuilder();
    try {
      brStdIn.write(s);
      brStdIn.flush();
      
      int counter = 0;
      boolean processEnd = false;
      char ch;
      do {
        ch = (char) brStdOut.read();
        output.append(ch);
        try {
          processVar.exitValue();
          // exitValue return a value
          processEnd = true;
        } catch (Exception e) { // process hasn't finished yet
        }
        if (output.length() == 10 
            && (output.substring(0, 9).equalsIgnoreCase("Exception") || output.substring(1, 10).equalsIgnoreCase("Exception"))) {
          Logger.getLogger(NERInterface.class.getName()).log(Level.SEVERE, "SEC API failed. It returned exception.");
          processEnd = true;
        }
        if (processEnd) {
          throw new Exception("Process was terminated");
        }
        if (ch == '{') {
          counter++;
        }
        if (ch == '}') {
          counter--;
        }
      } while (!(ch == '}' && counter <= 0));
    } 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, "SEC API 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.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 SECAPIInterface