/*
 * sga-daemon.idl
 *
 * $Author: isabella $
 * $Revision: 145926 $ - $Date: 2013-10-18 17:34:25 -0300 (Fri, 18 Oct 2013) $
 */

#ifndef _SGA_DAEMON_IDL
#define _SGA_DAEMON_IDL

#include "sga-manager.idl"

/**
 * Interfaces entre SGA e SSI (SGA Manager) para gerência da execução remota
 * de algoritmos.
 */
module sgaidl {
   /**
    * Valores retornados pelo método execNetBench
    */
   enum SGANetCapacity {
     ALL,
     NO,
     CALC
   };

   /**
    * Estados de um processo.
    */
   enum ProcessState {
     RUNNING,
     SLEEPING,
     WAITING,
     FINISHED
   };

   /**
    * Informações para monitoração de um processo.
    * As informações sobre um processo em execução na máquina hospedeira
    * são tipicamente obtidas através da execução do comando 'ps'.
    */
   struct ProcessInfo {
      long pid;
      long ppid;
      string command;
      string execHost;
      ProcessState state;
      long processorId;
      double memoryRamSizeMb;
      double memorySwapSizeMb;
      double CPUPerc;
      double CPUTimeSec; 
      long wallTimeSec; 
      double userTimeSec;
      double systemTimeSec;
      double virtualMemorySizeMB;
      double bytesInKB;
      double bytesOutKB;
      double diskBytesReadKB;
      double diskBytesWriteKB;
   };

   /** 
    * Informações específicas sobre a execução do comando.
    */
   struct ExecutionInfo {
     string key;
     string value;
   };

   /**
    * Informações para monitoração de um comando.
    * A execução de um comando pode gerar um ou mais processos, portanto são 
    * fornecidas as informações de todos os processos que compõem o comando.
    */
   struct RunningCommandInfo {
     sequence<ProcessInfo> processData;
     sequence<ExecutionInfo> executionData;
   };
   
   /**      
    * Representa um endereço de rede.  
    * É composto por um nome (hostname) e uma porta.
    */
   struct Address {
     string host;
     long port;
   };

   /** Estrutura que representa um path em um SGA. */
   struct SGAPath {
     string path;
     double sizeKB;
     boolean isDir;
     boolean isSymbolicLink;
     string linkPath;
     boolean readable;
     boolean writable;
     boolean executable;
     boolean exists;
   };

   typedef sequence<string> NodeNamesInfo;
   
   typedef sequence<string> SandboxPaths;

   typedef sequence<SGAPath> SGAPaths;
   
   interface SGAServer;

   /**
    * Interface do gerenciador de um comando.
    * Para cada comando executado pelo SGA é criado um gerenciador de
    * comando.
    */
   interface SGACommand {
      /**
       * Identificação do processo principal.
       * @return identificação (pid) do processo principal do comando
       */
      long    getPid();

      /**
       * Indica se o comando ainda está ativo (em execução).
       * @return true se o comando está em execução
       */
      boolean isRunning();

      /**
       * Fornece as informações de monitoração de um comando.
       * @return informações de monitoração de todos os processos 
       * que compõem o comando.
       */
      RunningCommandInfo getRunningCommandInfo();

      /**
       * Fornece a referência para o SGA.
       * @return referência para o SGA responsável pela execução do comando
       */
      SGAServer getSGAServer();

      /**
       * Termina a execução do comando.
       */
      oneway void kill();
   };

   /**
    * Interface do SGA daemon.
    */
   interface SGAServer {
      
      /**
       * Verifica se o SGA representa um cluster
       * @return true
       */
      boolean isCluster();

      /**
       * Verifica se o SGA está ativo
       * @return true
       */
      boolean isAlive();

      /**
       * Verifica se o SGA possui um determinado requisito externo
       * que o habilite para execução de um comando.
       * @return true se o SGA possui tal requisito.
       */
      boolean meetsRequirement(in string requirement);

	  /**
	   * Verifica se o SGA deve executar o benchmark de rede durante a
	   * escolha de servidores (com CSFS e com benchmark de rede) ou
	   * se a taxa de transferência entre o servidor e esse SGA deve ser
	   * configurada para ilimitada (sem CSFS) ou limitada (com CSFS e
	   * sem benchmark de rede)
       * @return SGANetCapacity.CALC se o SGA deve calcular a 
       *         capacidade de transferência.
       *         SGANetCapacity.ALL se o SGA apresenta grande 
       *         capacidade de transferência.
       *         SGANetCapacity.NO se o SGA apresenta pequena 
       *         capacidade de transferência.
       */
      SGANetCapacity execNetBench();

      /**
       * Verifica se o SGA está apto a receber comandos.
       * @return true se o SGA pode receber requisições de execução
       */
      boolean isEnabled();

      /**
       * Obtém os nomes das máquinas gerenciadas pelo SGA.
       * @remark Este método deve ser utilizado somente quando
       * tem-se a configuração de cluster.
       * @return uma seqüência com os nomes dos nós (na mesma ordem
       * das seqüências de memória, monitoração e CPU).
       */
      NodeNamesInfo getNodeNames();

      /**
       * Obtém a identificação da máquina hospedeira
       * @return nome (hostname) da máquina hospedeira do SGA
       */
      string getHostName();

      /**
       * Obtém a identificação da máquina que deve ser contactada
       * para transferências via CSFS.
       * @return endereço composto de nome (hostname) e porta da 
       * máquina para transferências via CSFS
       */
      Address getCSFSAddress();

      /**
       * Obtém o diretório raíz usado para transferências via CSFS.
       * @return diretório
       */
      string getCSFSRootDir();

      /**
       * Requisição de execução de um comando.
       * @param command comando a ser executado
       * @param cmdid identificador do comando a ser executado
       * @param host maquina que ira executar o comando (para clusters)
       * @param execpath diretorio de execucao do comando.
       * @param outputpath diretorio de output do comando.
       * @param sandboxpath diretorio de sandbox do comando.
       * @return referência para o comando
       */
      SGACommand executeCommand( in string command, in string cmdid,
        in string hostName, in string execpath, in string outputpath, 
        in SandboxPaths sandboxes);
      
      /**
       * Solicita a finalização do daemon
       */
      oneway void kill(in long status);

      /** Retorna a informação de um arquivo ou diretório dado seu path. */
      SGAPath getPath(in string path);

      /** Retorna uma lista de paths filhos de um path. */
      SGAPaths getPaths(in string root);
   };

}; 

#endif
