main.cpp File Reference

#include <extern.h>
#include <iostream>
#include <string.h>
#include <signal.h>
#include <execinfo.h>
#include <stdlib.h>
#include <unistd.h>
#include <netinet/in.h>
#include <getopt.h>
#include <vsisemaphore.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/syscall.h>
#include "../interface/RioError.h"
#include "../interface/RioTypes.h"
#include "token.h"

Go to the source code of this file.

Data Structures
struct	StorageServerConfig
Functions
void	usage (char *progname)
void	show_stackframe ()
	Handles the SEGFAULT.
void	segfaultHandler (int sig)
void	signalHandler (int sig)
void	PrintConfiguration (StorageServerConfig *Config)
int	CheckConfiguration (StorageServerConfig *Config)
int	ReadConfiguration (char *ConfigsDirectory, StorageServerConfig *Config)
int	main (int argc, char *argv[])
Variables
static char	Usage []
static char	Usage2 []
const char *const	CONFIGSSUBDIR = "etc/RIO/"
const char *const	LOGSSUBDIR = "var/log/RIO/"
const char *const	CONFIGNAME = "RIOstorage.cfg"
CvsiSemaphore	Finish (0)

---

Function Documentation

int CheckConfiguration

(

StorageServerConfig *

Config

)

Definition at line 194 of file storage/main.cpp.

{

    if( Config->Buffers <= 0 )
    {
       // Number of buffers =
       //                   (number of buffers to each client (max 20???) + 1)
       //                    * max number of clients (100???) + extra
       Config->Buffers = ( ( 20 + 1 ) * 100 + 10 ) * 1;
    }

    if( ( strcasecmp( Config->CollectMeasures, "on" ) != 0 ) &&
       ( strcasecmp( Config->CollectMeasures, "off" ) != 0 ))
    {
        RioErr << "ERROR: CheckConfiguration "
               << "CollectMeasures: " << Config->CollectMeasures
               << " invalid (must be 'on' or 'off')" << endl;
        return ( 1 );
    }

    if( ( Config->EstimatedParameter < 0 ) || 
        ( Config->EstimatedParameter > 1 ) )
    {
        RioErr << "ERROR: CheckConfiguration Invalid EstimatedParameter: " 
               << Config->EstimatedParameter << endl;
        return ( 1 );
    }

    if( ( Config->SendFlag != 1 ) && (  Config->SendFlag != 0 ) )
    {
        Config->SendFlag = 1;
    }

    if( Config->MaxClientsCredits <= 0 )
    {
        RioErr << "ERROR: CheckConfiguration Invalid number of client credits: " 
               << Config->MaxClientsCredits << endl;
        return ( 1 );
    }

    if( Config->MaxNetworkCredits <= 0 )
    {
        RioErr << "ERROR: CheckConfiguration Invalid number of network "
               << "credits: " << Config->MaxNetworkCredits << endl;
        return ( 1 );
    }

    if( ( Config->RouterPort <= 0) || ( Config->RouterPort > 0xffff ) )
    {
        RioErr << "ERROR: CheckConfiguration Invalid port number: " 
               << Config->RouterPort << endl;
        return( 1 );
    }

    if( Config->NetworkRate <= 0 )
    {
        RioErr << "ERROR: CheckConfiguration Invalid number of network "
               << "rate: " << Config->NetworkRate << endl;
        return ( 1 );
    }

    if( Config->DiskThreads <= 0 )
    {
        RioErr << "ERROR: CheckConfiguration Invalid number of disk threads: " 
               << Config->DiskThreads << endl;
        return ( 1 );
    }

    // Novas opcoes usadas pelo gerenciamento dos logs para limitar o tamanho
    // do arquivo de log nao compactado e o tamanho total combinado de todos
    // os logs (compactados ou nao).
    
    if( Config->MaxLogFileSize <= 0 )
    {
        RioErr << "ERROR: CheckConfiguration Invalid maximum uncompacted log "
               << "size: " << Config->MaxLogFileSize << endl;
        return ( 1 );
    }

    if( Config->MaxCombinedLogFilesSize <= 0 )
    {
        RioErr << "ERROR: CheckConfiguration Invalid total maximum combined "
               << "logs sizes: " << Config->MaxCombinedLogFilesSize << endl;
        return ( 1 );
    }

    // Nova opcao para definir se os logs devem ou nao ser salvos, ou seja, se 
    // devemos ou nao somente executar buscas nestes logs.
    if( ( Config->SaveLogs != NULL ) && 
        ( strcasecmp( Config->SaveLogs, "on" ) != 0 ) &&
        ( strcasecmp( Config->SaveLogs, "off" ) != 0 ) )
    {
        RioErr << "ERROR: CheckConfiguration LogRotation value" 
               << Config->SaveLogs << " invalid (must be 'on' or 'off')" 
               << endl;
        return ( 1 );
    }

    // Nova opcao usada para definir o tempo maximo de inatividade das conexoes
    // TCP de cada cliente com o servidor de armazenamento.
    if( Config->ClientsTimeOut <= 0 )
    {
        RioErr << "ERROR: CheckConfiguration Invalid connection timeout: "
               << Config->ClientsTimeOut << endl;
        return ( 1 );
    }

    // Imprime as configuracoes
    PrintConfiguration( Config );
    
    return 0;
}

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 460 of file storage/main.cpp.

{
    unsigned int i;
    struct in_addr storageip;
    int port;
    char c;
    int stat;
    StorageServerConfig StorageConfig;
    int ind = -1;
    // A opcao -l, que definia o diretorio dos logs, foi removida (junto com 
    // as outras opcoes que estao agora no arquivo de configuracao), e foi
    // substituida pela opcao -p, que define agora o prefixo onde os logs 
    // serao salvos (em prefixo/var/log/RIO) e de onde leremos o arquivo de
    // configuracao (de prefixo/etc/RIO).
    static char opts_short[] = "hn:p:v";
    static struct option opts_int[] =
    {
       {"help"             ,0,0,'h'},
       {"logsdirectory"    ,1,0,'l'},
       {"ndisks"           ,1,0,'n'},
       // Nova opcao para permitir que o arquivo de configuracao e os logs 
       // estejam em um diretorio diferente do que esta o servidor. Os arquivos 
       // de configuracao estarao em no subdiretorio etc/RIO e os arquivos de 
       // log no subdiretorio var/log/RIO.
       {"prefixdirectory"  ,1,0,'p'},
       {"version"          ,0,0,'v'},
       {0,0,0,0}
    };
    
    // default parameters
    int nDisks = 1;
    bool CollectMeasures = false;
    // Variavel usada para armazenar se devemos ou nao salvar os logs.
    bool SaveLogs = true;
    // Armazena o estado da execucao da NetInterface.
    RioResult RioStatus;
    
    // Parametros originais do servidor de armazenamento.
    StorageConfig.Buffers = 0;
    StorageConfig.RouterPort = 5101;
    StorageConfig.SendFlag = 1;
    StorageConfig.DiskThreads = 1;
    StorageConfig.EstimatedParameter = 0;
    StorageConfig.CollectMeasures = NULL;
    StorageConfig.ClientsTimeOut = 18000;
    // Por default, vamos supor que os logs devem ser salvos.
    StorageConfig.SaveLogs = NULL;
    // Prefixo do diretorio com o arquivo de configuracao e com os logs. O 
    // arquivo de configuracao sera lido de Prefixo/etc/RIO, e os logs serao
    // salvos em Prefixo/var/log/RIO. Default: NULL, indicando que os logs 
    // devem ser armazenados no diretorio onde esta o codigo do servidor de
    // armazenamento, e o arquivo de configuracao do servidor.
    char *PrefixDirectory = NULL;
    // Diretorio com o arquivo de configuracao do storage.
    char *ConfigsDirectory = NULL;
    // Diretorio onde os arquivos de logs serao salvos.
    char *LogsDirectory = NULL;
    // Taxa de transmissao de dados em Mbps [default = 100 -> 100Mbps].
    StorageConfig.NetworkRate = 100;
    // Numero maximo de creditos da rede (usado ao enviarmos os fragmentos)
    // [default = 1].
    StorageConfig.MaxNetworkCredits = 1; 
    // Numero maximo de creditos dos clientes (usado ao enviarmos os 
    // fragmentos) [default = 1].
    StorageConfig.MaxClientsCredits = 1; 
    // Tamanho maximo do arquivo de log nao compactado (log rotation)
    StorageConfig.MaxLogFileSize = MAXLOGFILESIZE;
    // Tamanho maximo combinado de todos os arquivos com os logs (log rotation)
    StorageConfig.MaxCombinedLogFilesSize = MAXCOMBINEDLOGSFILESIZE;
    // ------------------------------------------------------------------------

    RioErr << "MAINTHREADID " << syscall( SYS_gettid ) << endl;

    char *ProgName = argv[ 0 ];

    signal( SIGSEGV, segfaultHandler );
    signal( SIGTERM, signalHandler );

    while( (c = getopt_long( argc, argv, opts_short, opts_int, &ind )) != -1 )
    {
        switch( c )
        {
            case 'n':
                nDisks = atoi(optarg);
                break;
            case 'h':
                usage(ProgName);
                return (0);
            case 'v':
                cout << "RIOStorage version: " << VERSION << endl;
                exit( 0 );
            // Nova opcao para ler o diretorio onde os logs do storage server
            // serao armazenados
            case 'p':
                PrefixDirectory = optarg;
                break;
            // Nova opcao para ler o numero maximo de creditos ao enviarmos
            // fragmentos para os clientes.
            default:
                usage( ProgName );
                return( 1 );
        }
    }

    if( ( argc - optind ) < nDisks )
    {
        RioErr << "ERROR: Missing device names" << endl;
        usage( ProgName );
        return( 1 );
    }
    
    // Inicializa as variaveis com o diretorio onde os arquivos de
    // configuracao do servidor e os arquivos com as senhas, e com o 
    // diretorio onde os logs serao armazenados.
    if( PrefixDirectory == NULL )
    {
        // Se um prefixo nao foi passado, entao inicializamos os dois
        // diretorios com uma string vazia, para que os arquivos sejam
        // lidos e salvos no diretorio em que o codigo binario do servidor
        // esta armazenado.
        ConfigsDirectory = new char[ 1 ];
        if( ConfigsDirectory == NULL )
        {
            RioErr << "ERROR: Erro ao alocar a memoria" << endl;
            return ( 1 );
        }
        LogsDirectory = new char[ 1 ];
        if( LogsDirectory == NULL )
        {
            RioErr << "ERROR: Erro ao alocar a memoria" << endl;
            delete[] ConfigsDirectory;
            return ( 1 );
        }
        ConfigsDirectory[ 0 ] = 0;
        LogsDirectory[ 0 ] = 0;
    }
    else
    {
        // Devemos agora verificar se o prefixo do nome do diretorio passado
        // como parametro possui, no final, uma "/".
        unsigned int PrefixDirectorySize, ConfigsDirectorySize, 
                     LogsDirectorySize;
        PrefixDirectorySize = strlen( PrefixDirectory );
        ConfigsDirectorySize = PrefixDirectorySize + strlen( CONFIGSSUBDIR ) +
                               1;
        LogsDirectorySize = PrefixDirectorySize + strlen( LOGSSUBDIR ) + 1;
        // Verifica se o prefixo do diretorio termina ou nao com uma '/'.
        if( PrefixDirectory[ PrefixDirectorySize - 1 ] != '/' ) 
        {
            // Como nao temos uma "/" deveremos coloca-la e, com isso, o 
            // tamanho de ambos os nomes de diretorio aumentarao em uma
            // unidade.
            ConfigsDirectorySize++;
            LogsDirectorySize++;
        } 
        ConfigsDirectory = new char[ ConfigsDirectorySize ];
        if( ConfigsDirectory == NULL )
        {
            RioErr << "ERROR: Erro ao alocar a memoria" << endl;
            return ( 1 );
        }
        LogsDirectory = new char[ LogsDirectorySize ];
        if( LogsDirectory == NULL )
        {
            RioErr << "ERROR: Erro ao alocar a memoria" << endl;
            delete[] ConfigsDirectory;
            return ( 1 );
        }
        strcpy( ConfigsDirectory, PrefixDirectory );
        strcpy( LogsDirectory, PrefixDirectory );
        if( PrefixDirectory[ PrefixDirectorySize - 1 ] != '/' )
        {
            // Como nao temos uma '/' deveremos coloca-la em ambos os nomes
            // de diretorio.
            strcat( ConfigsDirectory, "/" );
            strcat( LogsDirectory, "/" );
        }
        strcat( ConfigsDirectory, CONFIGSSUBDIR );
        strcat( LogsDirectory, LOGSSUBDIR );
    }
    
    if( ( nDisks <= 0 ) || ( nDisks > MAXSTORAGEDISKSARRAY ) )
    {
        RioErr << "ERROR: Invalid number of disks: " << nDisks << endl;
        return(1);
    }

    // Le as configuracoes do arquivo de configuracao do storage.
    
    stat = ReadConfiguration( ConfigsDirectory, &StorageConfig );

    if( stat ) 
    {
        RioErr << "ERROR: ReadConfiguration failed" << endl;
        RioErr << "Storage not running. Check error messages!" << endl;
        delete ConfigsDirectory;
        delete LogsDirectory;
        if( StorageConfig.CollectMeasures != NULL )
            delete StorageConfig.CollectMeasures;
        return (1);
    } 
    
    // Inicializa o valor de CollectMeasures.
    if( StorageConfig.CollectMeasures != NULL )
        CollectMeasures = ( strcasecmp( StorageConfig.CollectMeasures, "on" ) 
                        == 0 );

    // Inicializa o valor de SaveLogs, usado para definir se devemos ou nao
    // salvar os logs.
    if( StorageConfig.SaveLogs != NULL )
        SaveLogs = ( strcasecmp( StorageConfig.SaveLogs, "on" ) == 0 );

    // Remove a string com o diretorio do arquivo de configuracao e a string
    // StorageConfig.CollectMeasures.
    // Obs: o que devemos fazer com as strings LogsDirectory e 
    // StorageConfig.InterfaceName? Elas nao podem ser removidas aqui porque
    // sao usadas pelas threads do servidor de armazanemento, e a thread 
    // principal parece acabar depois de que as outras threads iniciam com
    // sucesso.
    
    delete ConfigsDirectory;
    if( StorageConfig.CollectMeasures != NULL )
        delete StorageConfig.CollectMeasures;
    
    RioErr << "CollectMeasures: \t"    << CollectMeasures << endl;
    RioErr << "EstimatedParameter: \t" << StorageConfig.EstimatedParameter 
           << endl << endl;
    // ------------------------------------------------------------------------

    Config.nDisks     = (u32) nDisks;
    //Config.FragSize   = (u32) StorageConfig.BufferSize;
    Config.BufferSize = (u32) StorageConfig.Buffers;
    Config.MaxReqSize = 1;
    Config.MaxReq     = (u32) StorageConfig.Buffers;
    Config.RouterPort = (u16) StorageConfig.RouterPort;
    Config.Disk       = new DiskConfig[Config.nDisks];

    // Get Device names
    for(i=0; i < Config.nDisks; i++)
    {
        Config.Disk[i].Name = argv[i+optind];
    }

    Device = new CStorageDevice[Config.nDisks];
    if(Device == 0)
    {
        RioErr << "Error when creating device class: Not enough memory" << endl;
        return (1);
    }

    RioErr << "Number of devices: "<< Config.nDisks << " (array created). "
           << endl;

    // A porta foi fixada para STORAGESERVERUDPPORT para podermos dar suporte
    // aos clientes atras de NAT.
    // Mais tres parametros foram adicionados, para passar o numero maximo
    // de creditos dos clientes, o numero maximo de creditos da rede, e a taxa 
    // de transferencia dos fragmentos.
    #ifdef RIO_DEBUG_FILE
    // Compoe o nome do arquivo com o log gerado pela RioNeti.
    // Inicializa o nome com o diretorio com os logs.
    char tmpName[  MaxPathSize ];
    char tmpDomain[  MaxPathSize ];
    char LogFileName[  MaxPathSize ];
    strcpy( LogFileName, LogsDirectory );
    // Obtem o nome da maquina em que o servidor de armazenamento esta 
    // executando.
    gethostname( tmpName,  MaxPathSize - 1 ); 
    // Obtem o dominio da maquina em que o servidor de armazenamento esta 
    // executando.
    getdomainname( tmpDomain,  MaxPathSize - 1 );
    // Adiciona o nome que identifica o log da RioNeti com o log do servidor de
    // armazenamento.
    strcat( LogFileName, "RIOStorageEmul_" );
    strcat( LogFileName, tmpName );
    // Verifica se o dominio esta no nome da maquina e o adiciona ao log caso 
    // nao esteja.
    if( strstr( tmpName, tmpDomain ) == NULL ) 
    {
        strcat( LogFileName, "." );
        strcat( LogFileName, tmpDomain );
    }
    strcat( LogFileName, ".log" );

    // Inicializa a classe antiga de transferencia de dados.
    NetManager.Start( htons( STORAGESERVERUDPPORT ), 128 * 1024, FRAGMENTSIZE, 
                      LogFileName, StorageConfig.MaxClientsCredits, 
                      StorageConfig.MaxNetworkCredits, 
                      StorageConfig.NetworkRate );
          
    // Inicializa a nova classe de transferencia de dados (nao devemos verificar
    // se algum erro ocorreu? Ou seja, descartar o retorno da funcao Start acima
    // e o correto a ser feito?
    // 
    // Obs1: Verificar o que fazer com os timeouts do send e do receive (que
    // serao 0 porque usamos os valores default).
    // Obs2: Usei 18000 segundos = 5 horas para o timeout porque este e o 
    // timeout da conexao principal do TCP do cliente com o servidor de 
    // despacho. Precisamos definir vamos obter este valor e depois 
    // inicializa-lo, porque ele e definido no arquivo de configuracao do 
    // servidor de despacho. Vamos precisar criar uma nova funcao para poder 
    // alterar o valor do timeou (e talvez o do envio e o do recebimento) caso 
    // a informacao seja passa do servidor de despacho ao servidor de 
    // armazenamento durante a sua inicializacao.
    //     
    RioStatus = NetInterface.Start( htons( STORAGESERVERUDPPORT ), 
                                    StorageConfig.ClientsTimeOut, 
                                    NETTCPTIMEOUTSECONDS, NETTCPTIMEOUTSECONDS, 
                                    NULL, true, LogFileName ); 
    
    #else
    
    // Inicializa a classe antiga de transferencia de dados.
    NetManager.Start( htons( STORAGESERVERUDPPORT ), 128 * 1024, FRAGMENTSIZE, 
                      StorageConfig.MaxClientsCredits,
                      StorageConfig.MaxNetworkCredits, 
                      StorageConfig.NetworkRate );

    // Inicializa a nova classe de transferencia de dados (nao devemos verificar
    // se algum erro ocorreu? Ou seja, descartar o retorno da funcao Start acima
    // e o correto a ser feito?
    // 
    // Obs1: Verificar o que fazer com os timeouts do send e do receive (que
    // serao 0 porque usamos os valores default).
    // Obs2: Usei 18000 segundos = 5 horas para o timeout porque este e o 
    // timeout da conexao principal do TCP do cliente com o servidor de 
    // despacho. Precisamos definir vamos obter este valor e depois 
    // inicializa-lo, porque ele e definido no arquivo de configuracao do 
    // servidor de despacho. Vamos precisar criar uma nova funcao para poder 
    // alterar o valor do timeou (e talvez o do envio e o do recebimento) caso 
    // a informacao seja passa do servidor de despacho ao servidor de 
    // armazenamento durante a sua inicializacao.
    //    
    RioStatus = NetInterface.Start( htons( STORAGESERVERUDPPORT ), 
                                    StorageConfig.ClientsTimeOut,
                                    NETTCPTIMEOUTSECONDS, 
                                    NETTCPTIMEOUTSECONDS );  
    
    #endif
    
    // Verifica se ocorreu algum erro ao inicializar a NetInterface.
    if( FAILED( RioStatus ) )
    {
        #ifdef RIO_DEBUG2
        RioErr << "main: erro 0x" << hex << RioStatus << dec << " ("
               << GetErrorDescription( RioStatus ) << ") ao criar o objeto "
               << "da classe CNetIneface associado a nova conexao TCP." 
               << endl;
        #endif

        RioErr << "Error when initializing TCP" << endl;
        return (1);
    }       

    // Agora a nova classe de gerenciamento de rede e que definira o IP e a 
    // porta do servidor de armazenamento (estes valores deveriam ser os mesmos.
    // Se isso nao ocorrer entao existe algum erro de implementacao na nova
    // classe).
    //NetManager.getmyaddrport( (int*) &(storageip.s_addr), &port);
    NetInterface.getmyaddrport( (int*) &(storageip.s_addr), &port);

    // Cria a classe usada para armazenar os pacotes enviados pelo servidor de
    // armazenamento.
    // Define o nome para os prefixo dos logs.
    char LogFileNamePrefix[  MaxPathSize ];
    strcpy( LogFileNamePrefix, LogsDirectory );
    strcat( LogFileNamePrefix, "StorageLog_" );
    // Adiciona o IP do storage (a porta nao sera necessaria, pois dois storages
    // nao podem executar na mesma maquina).
    strcat( LogFileNamePrefix, inet_ntoa( storageip ) ); 
    if( SentPackagesLog.Initialize( LogFileNamePrefix, 
                                    StorageConfig.MaxLogFileSize, 
                                    StorageConfig.MaxCombinedLogFilesSize,
                                    SaveLogs ) != S_OK )
    {           
        // Devemos ou nao parar o servidor de armazenamento neste caso?
        RioErr << "main: erro ao inicializar a classe com os logs." << endl;
        return (1);
    }

    // Define a classe de gerenciamento dos logs de envio para a implementacao
    // antiga de rede.
    NetManager.setLogRotation( &SentPackagesLog );
    // Define a classe de gerenciamento dos logs de envio para a nova 
    // implementacao de rede.
    NetInterface.setLogRotation( &SentPackagesLog );

    // Initialize devices
    for(i=0; i<Config.nDisks; i++)
    {
        // A funcao initialize da CStorageDevice possui agora mais um parametro:
        // o nome do diretorio onde os logs devem ser salvos.
        stat = Device[i].Initialize(Config.Disk[i].Name,
                                    inet_ntoa( storageip ),
                                    StorageConfig.DiskThreads,
                                    StorageConfig.EstimatedParameter,
                                    CollectMeasures, LogsDirectory );
        // --------------------------------------------------------------------
        if(stat < 0)
        {
            RioErr << "Error when initializing Device " << Config.Disk[i].Name
                   << ": " << stat << endl;
            return (1);
        }
    }

    // Get Device parameters
    for(i=0; i< Config.nDisks; i++)
    {
        Config.Disk[i].Size = Device[i].Size();
        Config.Disk[i].SectorSize = Device[i].SectorSize();
    }

    stat = Client.Initialize( StorageConfig.SendFlag, 
                              StorageConfig.EstimatedParameter );
    if(stat < 0)
    {
        RioErr << "Error when initializing Client Interface: " << stat << endl;
        return (1);
    }

    stat = MsgManager.Initialize( Config.MaxReq + 10 );
    if(stat < 0)
    {
        RioErr << "Error when initializing Msg Manager: " << stat << endl;
        return (1);
    }

    RioErr << "Msg Manager started. Max number of msg : "<< Config.MaxReq + 10
           << " (array created). "<< endl;

    // O novo parametro, com o diretorio com os logs, e usado ao inicializarmos
    // a classe de busca nos logs.
    stat = Router.Initialize( htons( Config.RouterPort ), LogsDirectory );
    if(stat < 0)
    {
        RioErr << "Error when initializing Router Interface: " << stat << endl;
        return (1);
    }


    RioErr << "TCP/IP address (control messages): "
           << inet_ntoa( storageip ) << ":"<< StorageConfig.RouterPort << endl;

    if(!Finish.IsOpen())
    {
        RioErr << "ERROR: Semaphore could not be created" << endl;
        return (1);
    }

    // Wait until semaphore is signaled to end program
    Finish.P();

    return (0);
}

void PrintConfiguration

(

StorageServerConfig *

Config

)

Definition at line 159 of file storage/main.cpp.

{
    cout << "---------------------------------------------------" << endl;
    cout << "             RIO Storage Configuration             " << endl;
    cout << "---------------------------------------------------" << endl;
    cout << "Buffers\t\t\t" << Config->Buffers << endl; 
    cout << "CollectMeasures\t\t" << Config->CollectMeasures << endl;
    cout << "EstimatedTime\t\t" << Config->EstimatedParameter << endl;
    cout << "SendBlocksFlag\t\t" << Config->SendFlag << endl;
    cout << "MaxClientsCredits\t" << Config->MaxClientsCredits << endl;
    cout << "MaxNetworkCredits\t" << Config->MaxNetworkCredits << endl;
    cout << "RouterPort\t\t" << Config->RouterPort << endl;
    cout << "NetworkRate\t\t" << Config->NetworkRate << endl;
    cout << "DiskThreads\t\t" << Config->DiskThreads << endl;  
    // Novas opcoes usadas pelo gerenciamento dos logs para limitar o tamanho
    // do arquivo de log nao compactado e o tamanho total combinado de todos
    // os logs (compactados ou nao).
    cout << "MaxLogFileSize\t\t" << Config->MaxLogFileSize / 1024 << " Kbytes" 
         << endl;
    cout << "MaxCombinedLogFilesSize\t" << Config->MaxCombinedLogFilesSize / 1024
         << " Kbytes" << endl;
    // Nova opcao para definir se os logs devem ou nao ser salvos, ou seja, se 
    // devemos ou nao somente executar buscas nestes logs.
    if( Config->SaveLogs != NULL )
        cout << "LogRotation \t\t" << Config->SaveLogs << endl;
    else
        cout << "LogRotation \t\tOn" << endl;
    // Nova opcao usada para definir o tempo maximo de inatividade das conexoes
    // TCP de cada cliente com o servidor de armazenamento.
    cout << "ClientsTimeOut\t\t" << Config->ClientsTimeOut << " seconds." 
         << endl;
    cout << "---------------------------------------------------" << endl;
}

int ReadConfiguration	(	char *	ConfigsDirectory,
		StorageServerConfig *	Config
	)

Definition at line 309 of file storage/main.cpp.

{
    // Variavel usada para compor o nome do arquivo com a configuracao do
    // servidor RIO.
    char ConfigFileName[ MaxPathSize ];

    // Palavras-chave usadas pelo arquivo de configuracao do servidor de
    // armazenamento.
    enum keys
    {
        Buffers = 1, CollectMeasures, EstimatedTime, SendBlocksFlag, 
        MaxClientsCredits, MaxNetworkCredits, RouterPort,
        NetworkRate, DiskThreads, MaxLogFileSize, MaxCombinedLogFilesSize,
        LogRotation, ClientsTimeOut
    };

    static struct token_kw mykeys[] = {
        {"Buffers", Buffers}, 
        {"CollectMeasures", CollectMeasures},
        {"EstimatedTime", EstimatedTime},
        {"SendBlocksFlag", SendBlocksFlag},
        // Define o numero maximo de creditos usados para o envio dos fragmentos 
        // ao cliente.
        {"MaxClientsCredits", MaxClientsCredits},
        // Define o numero maximo de creditos usados para o envio dos fragmentos
        // pela rede (ou seja para todos os clientes).
        {"MaxNetworkCredits", MaxNetworkCredits},
        {"RouterPort", RouterPort},
        // Define a taxa maxima de transferencia dos dados.
        {"NetworkRate", NetworkRate},
        {"DiskThreads", DiskThreads},
        // Novas opcoes usadas pelo gerenciamento dos logs para limitar o 
        // tamanho do arquivo de log nao compactado e o tamanho total combinado 
        // de todos os logs (compactados ou nao).
        {"MaxLogFileSize", MaxLogFileSize},
        {"MaxCombinedLogFilesSize", MaxCombinedLogFilesSize}, 
        // Nova opcao para definir se os logs devem ou nao ser salvos, ou seja,
        // se devemos ou nao somente executar buscas nestes logs.
        {"LogRotation", LogRotation},
        // Nova opcao usada para definir o tempo maximo de inatividade das 
        // conexoes TCP de cada cliente com o servidor de armazenamento.
        {"ClientsTimeOut", ClientsTimeOut},
        {NULL, 0}
    };

    cout << endl;
    token tok;
    //tok.setcerr(&cout);

    // Alteracao para ler o arquivo de configuracao de um diretorio qualquer,
    // diferente de onde o servidor esta. Por default, o arquivo e lido do
    // diretorio em que esta o binario do servidor.
    // Compoe o nome do arquivo com a configuracao do servidor.

    strcpy( ConfigFileName, ConfigsDirectory );
    strcat( ConfigFileName, CONFIGNAME );

    if( tok.openfile( ConfigFileName ) )
        return 1;

    int word;
    int number;

    while( ( word = tok.parseline( mykeys )) != END_TOKEN )
    {
        switch( word )
        {
            case Buffers:
                tok.getnumber( &Config->Buffers );
                break;

            case CollectMeasures:
                tok.getstrnew( &Config->CollectMeasures );
                break;

            case EstimatedTime:
                tok.getdouble( &Config->EstimatedParameter );
                break;

            case SendBlocksFlag:
                tok.getnumber( &Config->SendFlag );
                break;

            case MaxClientsCredits:
                tok.getnumber( &Config->MaxClientsCredits );
                break;

            case MaxNetworkCredits:
                tok.getnumber( &Config->MaxNetworkCredits );
                break;

            case RouterPort:
                tok.getnumber( &Config->RouterPort );
                break;

            case NetworkRate:
                tok.getnumber( &Config->NetworkRate );
                break;

            case DiskThreads:
                tok.getnumber( &Config->DiskThreads );
                break;

            // Novas opcoes usadas pelo gerenciamento dos logs para limitar o 
            // tamanho do arquivo de log nao compactado e o tamanho total 
            // combinado de todos os logs (compactados ou nao).
            case MaxLogFileSize:
                tok.getnumber( &number );
                // Tamanho do log nao compactado e dado em KB.
                Config->MaxLogFileSize = number * 1024;
                break;
                
            case MaxCombinedLogFilesSize:
                tok.getnumber( &number );
                // Tamanho combinado dos logs e dado em KB.
                Config->MaxCombinedLogFilesSize = ( ( unsigned long long int ) 
                                                    number ) * 1024;
                break;
            // Nova opcao para definir se os logs devem ou nao ser salvos, ou 
            // seja, se devemos ou nao somente executar buscas nestes logs.
            case LogRotation:
                tok.getstrnew( &Config->SaveLogs );
                break;
            // Nova opcao usada para definir o tempo maximo de inatividade das 
            // conexoes TCP de cada cliente com o servidor de armazenamento.
            case ClientsTimeOut:
                tok.getnumber( &number );
                Config->ClientsTimeOut = ( unsigned int ) number;
                break;

            // Valor para uma opcao invalida.
            case ERROR_TOKEN:
                char *Aux;
                tok.getstrnew( &Aux );
                RioErr << "warning: invalid keyword " << Aux << " ignored!"
                       << endl;
                delete[] Aux;
                break;

            // Chave invalida.
            default:
                RioErr << "word " << word << endl;
                tok.emsg("{default} invalid word");
                continue;
        }
        tok.ckend();
    }
    tok.closefile();
    return CheckConfiguration( Config );
}

void segfaultHandler

(

int

sig

)

Definition at line 133 of file storage/main.cpp.

{
    RioErr << "[Storage-main] SEGMENTATION FAULT!" << endl;
    show_stackframe();

    _exit( 1 );
}

void show_stackframe

(

)

Handles the SEGFAULT.

Definition at line 119 of file storage/main.cpp.

{
    void *trace[16];
    char **messages = (char **)NULL;
    int i, trace_size = 0;

    trace_size = backtrace( trace, 16 );
    messages = backtrace_symbols( trace, trace_size );
    RioErr << "[bt] Execution path:" << endl;
    for( i = 0; i < trace_size; ++i )
        RioErr << "[bt(" << i << "/" << trace_size << ")] " << messages[i]
               << endl;
}

void signalHandler

(

int

sig

)

Definition at line 142 of file storage/main.cpp.

{
    RioErr << "[Storage] CAUGHT SIGTERM SIGNAL!" << endl;
    // Desassocia a classe SentPackagesLog da classe RioNeti.
    NetManager.setLogRotation( NULL );
    // Desbloqueia a thread principal.
    Finish.V();
    // Nova funcao para tratar o sigterm (futuramente podemos finalizar as
    // estruturas aqui nesta funcao.
    exit( 2 );
}

void usage

(

char *

progname

)

Definition at line 107 of file storage/main.cpp.

{
    RioErr << "Usage: " << endl;
    RioErr << "  " << progname << " " << Usage;
    RioErr << Usage2 << endl;
}

---

Variable Documentation

const char* const CONFIGNAME = "RIOstorage.cfg"

Definition at line 105 of file storage/main.cpp.

const char* const CONFIGSSUBDIR = "etc/RIO/"

Definition at line 100 of file storage/main.cpp.

CvsiSemaphore Finish(0)

const char* const LOGSSUBDIR = "var/log/RIO/"

Definition at line 103 of file storage/main.cpp.

char Usage[] [static]

Initial value:

     "[-h] "
     "[-n disks] "
     "[-p prefix directory] "
     "[-v]"
     "<devices> \n"

Definition at line 49 of file storage/main.cpp.

char Usage2[] [static]

Initial value:

    "  -h|--help\n"
    "    Prints this message and exit\n"
    "  -n|--ndisks <number_of_disks>\n"
    "    Number of disks to use. Default: 1\n"
    "  -p|--prefixdirectory <prefix directory>\n"
    "    Set the prefix directory of config files and logs.\n"
    "  -v|--version\n"
    "    Show version number and exit\n"
    "  <disk_devices>\n"
    "    List of disk devices (or file) names\n"

Definition at line 56 of file storage/main.cpp.