CServerUserLogs Class Reference

#include <UserLogs.h>

Public Member Functions
	CServerUserLogs (server_rec *Server)
	Construtor da classe, usado ao criar um objeto da classe.
virtual	~CServerUserLogs ()
	Destrutor da classe, usado ao remover um objeto da classe.
virtual RioResult	Initialize (char *LogsFilePrefixPath, unsigned int MaxLogFileSize, unsigned long long int MaxCombinedLogFilesSize, int LogsPort)
	Funcao usada para inicializar um objeto da classe CUserLogs.
void	JoinThread ()
	Funcao para bloquear o processo ate a thread que recebe os logs termine de executar.
Private Member Functions
RioResult	ReceiveLogLine (char *LogLine, int *LogLinePort)
	Funcao usada para receber uma string com um log pelo socket UDP.
RioResult	SendResult (int Port, int Result)
	Funcao para enviar o resultado dado como parametro para o socket UDP cuja porta tambem e dada como parametro.
bool	ServerUserLogsThread ()
	Funcao executada pela thread da classe.
Static Private Member Functions
static void *	ServerUserLogsThreadEp (void *Param)
	Funcao que chama a funcao executada pela thread da classe, usada quando a thread e criada.
Private Attributes
bool	m_Initialized
	Variavel booleana que indica se a classe foi inicializada.
pthread_t	m_ServerUserLogsThread
	Identificador da thread que recebe os dados a serem colocados no log.
server_rec *	m_Server
	Ponteiro para a estrutura com as informacoes do servidor.
CLogRotation *	m_LogRotation
	Ponteiro para o objeto da classe de gerenciamento de logs usada por esta classe.
int	m_Socket
	Socket usado para enviar dados para a thread da classe, usando a funcao estatica SendLogLine da classe.
struct sockaddr_in	m_SocketAddr
	Armazena o endereco do socket usado para gerar os logs.
int	m_LogsServerPort
	Armazena a porta usada pela thread que envia os logs.

---

Detailed Description

Definition at line 54 of file UserLogs.h.

---

Constructor & Destructor Documentation

CServerUserLogs::CServerUserLogs

(

server_rec *

Server

)

Construtor da classe, usado ao criar um objeto da classe.

Parameters:

Server

ponteiro para a requisicao associada a conexao http com o servidor.

Definition at line 41 of file UserLogs.cpp.

{
    // Inicializa as variaveis da classe.
    m_Initialized = false;
    m_ServerUserLogsThread = 0;
    m_LogRotation = NULL;
    m_Socket = 0;
    memset( &m_SocketAddr, 0, sizeof( m_SocketAddr ) );
    m_Server = Server;
    m_LogsServerPort = 0;
}

CServerUserLogs::~CServerUserLogs

(

)

[virtual]

Destrutor da classe, usado ao remover um objeto da classe.

Definition at line 54 of file UserLogs.cpp.

{
    // Cria uma string temporaria, toda preenchida com 0, para ser enviada pelo
    // socket e ser recebida como uma string vazia.
    char NullStr[ MAXLOGLINESIZE ];

    // Armazena uma copia do identificador da thread.
    pthread_t ServerUserLogsThread;

    // Envia a mensagem de finalizacao (um dado com tamanho igual a 0) pelo 
    // socket UDP, para finalizar a thread, se a thread ainda estiver
    // executando.
    if( m_ServerUserLogsThread != 0 )
    {
        // Salva o ID da thread para ser usado nos comandos a seguir.
        ServerUserLogsThread = m_ServerUserLogsThread;
        // Inicializa a string temporaria com 0, para que ela seja vazia.
        memset( NullStr, 0, MAXLOGLINESIZE );

        // Envia a mensagem com somente um byte, para destravar o poll.
        if( sendto( m_Socket, NullStr, MAXLOGLINESIZE, UDP_FLAGS_SENDDATA,
                    ( struct sockaddr * ) &m_SocketAddr,
                    sizeof( m_SocketAddr ) ) < 0 )
        {
            // Ocorreu um erro ao enviarmos a mensagem, Entao vamos cancelar a
            // thread.
            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Error %u (%s) "
                          "when finalizing object! killing the thread!", errno,
            strerror( errno ) );
            pthread_cancel( ServerUserLogsThread );
        }
        else
        {
            #ifdef RIO_DEBUG2
            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Esperando a "
                          "thread que recebe os logs terminar de executar!" );
            #endif
            // Espera a thread terminar a sua execucao.
            pthread_join( ServerUserLogsThread, NULL );
        }
    }

    // Deleta o objeto que gerencia os logs.
    if( m_LogRotation != NULL )
        delete m_LogRotation;

    // Fecha o socket do servidor.
    if( m_Socket != 0 )
    {
        shutdown( m_Socket, SHUT_RDWR );
        close( m_Socket );
    }
}

---

Member Function Documentation

int CServerUserLogs::Initialize	(	char *	LogsFilePrefixPath,
		unsigned int	MaxLogFileSize,
		unsigned long long int	MaxCombinedLogFilesSize,
		int	LogsPort
	)			[virtual]

Funcao usada para inicializar um objeto da classe CUserLogs.

O objeto deve estar inicializado para podermos usar a funcao NewLogLine (caso o objeto nao esteja inicializado, e retornado o erro ERROR_SERVERUSERLOGS + ERROR_NOT_INITIALIZED).

Parameters:

	LogsFilePrefixPath	nome do caminho do prefixo para os arquivos de log. Este caminho deve incluir, alem do prefixo, o nome do diretorio onde os logs serao armazenados. Por exemplo, o parametro "/home/xandao/TesteLogs" indica que os logs serao armazenados no diretorio "/home/xandao", com nomes com o prefixo de "TesteLogs".
	MaxLogFileSize	tamanho maximo que o arquivo de log deve ter. Quando o tamanho passar do tamanho maximo, o arquivo de log sera compactado e um novo arquivo de log (com o prefixo dado) sera criado.
	MaxCombinedLogFilesSize	valor maximo para o tamanho combinado dos arquivos com os logs.
	LogsPort	Porta UDP a ser usada (sem ser na ordem de rede).

Returns:

S_OK se a inicializacao foi feita com sucesso, e um valor diferente de S_OK em caso contrario.

Definition at line 512 of file UserLogs.cpp.

{
    // Atributos da thread de gerenciamento das conexoes TCP.
    pthread_attr_t attribServerUserLogsThread;
    // Armazena o endereco do socket UDP.
    struct sockaddr_in TempAddr;
    // Armazena o tamanho do endereco do socket usado para desbloquear o select.
    socklen_t AddrSize;
    // Armazena o resultado das execucoes das funcoes da classe e do objeto do
    // RIO.
    RioResult RioStatus;

    // Verifica se o objeto da classe ja esta inicializado.
    if( m_Initialized )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                      "Objeto ja foi inicializado!" );
        #endif

        return ERROR_SERVERUSERLOGS + ERROR_INITIALIZED;
    }

    // Cria o socket UDP do objeto, usado para receber linhas de log.
    m_Socket = socket( AF_INET, SOCK_DGRAM, 0 );
    if( m_Socket < 0 )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Erro %u (%s) ao "
                      "criaro socket UDP usado pelo objeto!", errno,
                      strerror( errno ) );
        #endif

        return ERROR_SERVERUSERLOGS + ERROR_SOCKET_CREATE;
    }

    // Faz com que o socket seja exclusivo do processo, e nao seja passado
    // para um outro processo criado pelo processo que abriu o socket.
    //
    // Obs: Sera que isso e necessario?
    //
    if( fcntl( m_Socket, F_SETFD, FD_CLOEXEC ) < 0 )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Erro %u (%s) ao "
                      "fazer o socket UDP recem criado ser exclusivo ao "
                      "processo!", errno, strerror( errno ) );
        #endif

        return ERROR_SERVERUSERLOGS + ERROR_SOCKET_OPTIONS;
    }

    // Inicializa a porta do servidor.
    m_LogsServerPort = LogsPort;

    // Limpa a estrutura TempAddr.
    memset( &TempAddr, 0, sizeof( TempAddr ) );
    // associa o socket UDP usado para desbloquear o poll ao IP do servidor e
    // a uma porta escolhida aleatoriamente (isso esta bom, ou devemos usar a
    // porta do UDP mais 1 - para nao colidir com a porta UDP da RioNeti?).
    TempAddr.sin_family = AF_INET;
    TempAddr.sin_addr.s_addr = INADDR_ANY; // Faz o sistema definir o IP. A
                                           // estrutura server tinha diversos
                                           // IPs, mas eu nao sabia qual deles
                                           // deveria ser usado.
    TempAddr.sin_addr.s_addr = USERLOGS_UDP_IP; // Usando o IP 127.0.0.1
    TempAddr.sin_port = htons( m_LogsServerPort );

    if( bind( m_Socket, ( struct sockaddr * ) &TempAddr,
              sizeof( TempAddr ) ) < 0 )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Erro %u (%s) ao "
                      "ligar o socket UDP a uma porta %u!", errno,
                      strerror( errno ), m_LogsServerPort );
        #endif

        return ERROR_SERVERUSERLOGS + ERROR_SOCKET_BIND;
    }

    AddrSize = sizeof( m_SocketAddr );
    if( getsockname( m_Socket, ( struct sockaddr * ) &m_SocketAddr,
                     &AddrSize ) != 0 )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Erro %u (%s) ao "
                      "obter as informacoes do socket UDP!", errno,
                      strerror( errno ) );
        #endif

        return ERROR_SERVERUSERLOGS + ERROR_SOCKET_OPTIONS;
    }


    // Tenta criar um novo objeto da classe CLogRotation;
    try
    {
        m_LogRotation = new CLogRotation( false );
    }
    catch( bad_alloc &ba )
    {
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Memory error ("
                      "bad_alloc, error = %s) when allocating log rotation "
                      "object!", ba.what() );

        m_LogRotation = NULL;

        // Fecha o socket UDP criado.
        shutdown( m_Socket, SHUT_RDWR );
        close( m_Socket );

        return ERROR_SERVERUSERLOGS + ERROR_MEMORY;
    }

    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Tentando inicializar o "
                  "objeto de gerenciamento de logs!" );
    #endif

    // Tenta inicializar o objeto da classe CLogRotation criado.
    RioStatus = m_LogRotation->Initialize( LogsFilePrefixPath, MaxLogFileSize,
                                           MaxCombinedLogFilesSize );
    if( FAILED( RioStatus ) )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Erro %8x (%s) ao "
                      "inicializar o objeto de gerenciamento dos logs!",
                      RioStatus, GetErrorDescription( RioStatus ).c_str() );
        #endif

        return RioStatus;
    }
    #ifdef RIO_DEBUG2
    else
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Objeto de "
                      "gerenciamento de logs inicializado com sucesso! Tentando "
                      "criar a thread!" );
    #endif

    // Agora tentamos criar a thread do objeto da classe CUserLogs, responsavel
    // por receber as mensagens que serao salvas no log.
    // Inicializa os atributos da thread usada para gerenciar as transferencias
    // de dados.
    pthread_attr_init( &attribServerUserLogsThread );
    // Inicializa a pilha da thread usada para gerenciar as transferencias de
    // dados.
    pthread_attr_setstacksize( &attribServerUserLogsThread,
                               2 * PTHREAD_STACK_MIN );

    // Cria a thread usada para gerenciar as transferencias de dados.
    if( pthread_create( &m_ServerUserLogsThread, &attribServerUserLogsThread,
                        ServerUserLogsThreadEp, ( void * ) this ) != 0 )
    {
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Erro %u (%s) ao "
                      "criar a thread que recebe as mensagens via UDP!",
                      errno, strerror( errno ) );

        return ERROR_TCPCONNECTION + ERROR_CREATE_THREAD;
    }
    #ifdef RIO_DEBUG2
    else
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Thread criada com "
                      "sucesso! O ID da thread e igual a %u",
                      ( unsigned int ) m_ServerUserLogsThread );
    #endif

    // Informa que a classe foi inicializada com sucesso.
    m_Initialized = true;

    return S_OK;
}

void CServerUserLogs::JoinThread

(

)

Funcao para bloquear o processo ate a thread que recebe os logs termine de executar.

Definition at line 689 of file UserLogs.cpp.

{
    pthread_join( m_ServerUserLogsThread, NULL );
}

RioResult CServerUserLogs::ReceiveLogLine	(	char *	LogLine,
		int *	LogLinePort
	)			[private]

Funcao usada para receber uma string com um log pelo socket UDP.

Parameters:

	Log	ponteiro a string que armazenara a linha de log recebida. Se algum erro ocorrer, sera retornada uma string vazia, com tamanho 0. Em caso contrario sera retornada a string recebida, que pode ser vazia quando uma mensagem de termino de conexao for recebida.
	Port	ponteiro para armazenar a porta da qual se originou a mensagem com a linha do log.

Returns:

S_OK se o log foi recebido pelo socket UDP com sucesso, ou o codigo de erro se algum erro ocorrer durante o recebimento do log.

Definition at line 109 of file UserLogs.cpp.

{
    // Armazena a quantidade de bytes recebidos.
    ssize_t BytesReceived;
    // Armazena o endereco de origem da linha de log redebida. Somente vamos
    // aceitar dados (com supostas linhas para o log) enviadas pela propria
    // maquina em que o modulo esta executando.
    struct sockaddr_in SourceAddr;
    // Armazena o tamanho da estrutura SourceAddr
    socklen_t SourceAddrSize;

    // Inicializa o buffer que recebera a linha dos logs. Note que estamos
    // supondo que ele possui pelo menos espaco para MAXLOGLINESIZE + 1 bytes.
    memset( LogLine, 0, MAXLOGLINESIZE + 1 );

    // Tenta receber a linha de log pelo socket UDP.
    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Tentando receber a "
                  "linha com %u bytes pelo socket UDP!", MAXLOGLINESIZE );
    #endif

    SourceAddrSize = sizeof( SourceAddr );
    BytesReceived = recvfrom( m_Socket, LogLine, MAXLOGLINESIZE,
                              UDP_FLAGS_RECEIVE,
                              ( struct sockaddr * ) &SourceAddr,
                              &SourceAddrSize );
    // Copia a porta do socket UDP do qual a conexao se originou.
    *Port = SourceAddr.sin_port;

    if( BytesReceived < 0 )
    {
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Error %d (%s) "
                      "receiving log line from UDP socket!", errno,
                      strerror( errno ) );

        return ERROR_SERVERUSERLOGS + ERROR_SOCKET_RECEIVE;
    }
    else if( SourceAddr.sin_addr.s_addr != m_SocketAddr.sin_addr.s_addr )
    {
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Log Line "
                      "received from invalid address ip %s and port %u, "
                      "different from ip %s and port %u!",
                      inet_ntoa( SourceAddr.sin_addr ),
                      ntohs( SourceAddr.sin_port ),
                      inet_ntoa( m_SocketAddr.sin_addr ),
                      ntohs( m_SocketAddr.sin_port ) );

        return ERROR_SERVERUSERLOGS + ERROR_INVALID_HOST;

    }
    else if( ( unsigned int ) BytesReceived != MAXLOGLINESIZE )
    {
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Error receiving "
                      "log line from UDP socket! Only %u bytes of %u has "
                      "received!", BytesReceived, MAXLOGLINESIZE );

        return ERROR_SERVERUSERLOGS + ERROR_SOCKET_RECEIVE;
     }

    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Linha de log %s "
                  "recebida com sucesso pela conexao UDP pela porta %u!",
                  LogLine, ntohs( *Port ) );
    #endif

    return S_OK;
}

RioResult CServerUserLogs::SendResult	(	int	Port,
		int	Result
	)			[private]

Funcao para enviar o resultado dado como parametro para o socket UDP cuja porta tambem e dada como parametro.

Parameters:

	Port	porta UDP para a qual o resultado deve ser enviado.
	RioResult	Resultado (codigo de erro) a ser enviado.

Returns:

S_OK se o resultado foi enviado pelo socket UDP com sucesso, ou o codigo de erro se algum erro ocorrer durante o envio do resultado.

Definition at line 179 of file UserLogs.cpp.

{
    // Armazena o endereco do socket UDP para o qual desejamos enviar os dados.
    struct sockaddr_in DestAddr;
    // Armazena a quantidade de bytes enviados.
    ssize_t BytesSent;

    // Limpa a estrutura TempAddr.
    memset( &DestAddr, 0, sizeof( DestAddr ) );
    // Inicializa a estrutura temporaria do endereco com o IP local e a porta
    // passada como parametro.
    DestAddr.sin_family = AF_INET;
    DestAddr.sin_addr.s_addr = m_SocketAddr.sin_addr.s_addr;
    DestAddr.sin_port = Port;

    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Tentando enviar o "
                  "resultado %08X pelo socket UDP para o IP %s e a porta %u, a "
                  "partir do IP %s e da porta %u!", Result,
                  inet_ntoa( DestAddr.sin_addr ), ntohs( DestAddr.sin_port ),
                  inet_ntoa( m_SocketAddr.sin_addr ),
                  ntohs( m_SocketAddr.sin_port ) );
    #endif

    // Tenta enviar o Resultado para o socket UDP.
    BytesSent = sendto( m_Socket, &Result, sizeof( Result ),
                        UDP_FLAGS_SENDDATA, ( struct sockaddr * ) &DestAddr,
                        sizeof( DestAddr ) );
    if( BytesSent < 0 )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Error %d (%s) "
                      "sending result value %08X to UDP socket!", errno,
                       strerror( errno ), Result );
        #endif

        return ERROR_SERVERUSERLOGS + ERROR_SOCKET_SEND;
    }
    else if( BytesSent != sizeof( Result ) )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Error sending "
                      "result value %08X to UDP socket! Only %u bytes of "
                      "%u has sent!", Result, BytesSent, sizeof( Result ) );
        #endif

        return ERROR_SERVERUSERLOGS + ERROR_SOCKET_SEND;
    }

    #ifdef RIO_DEBUG2
    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Erro %u enviado com "
                  "sucesso a porta %u!", Result, ntohs( Port ) );
    #endif

    // Como enviamos corretamente o resultado, retornamos S_OK.
    return S_OK;
}

bool CServerUserLogs::ServerUserLogsThread

(

)

[private]

Funcao executada pela thread da classe.

Returns:

true se o objeto deve ser removido antes de a thread ser finalizada (quando a thread for finalizada por uma mensagem especial enviada por um objeto da classe cliente) ou false em caso contrario (quando a thread for finalizada pelo destrutor do objeto).

Definition at line 238 of file UserLogs.cpp.

{
    // Armazena o resultado das execucoes das funcoes da classe e do objeto do
    // RIO.
    RioResult RioStatus, RioStatus2;
    // Armazena o resultado da execucao das funcoes da biblioteca do C.
    int SystemStatus;
    // Variavel usada para indicar se devemos continuar
    bool ExecuteThread;
    // Variavel para armazenar se, ao retornarmos da thread, deveremos ou nao
    // deletar o objeto (se a mensagem for recebida da mesma porta da classe,
    // indicando que o destrutor foi chamado, nao devemos remover o objeto).
    bool RemoveObject;
    // Variavel para armazenar uma linha de log recebida pela conexao UDP.
    char LogLine[ MAXLOGLINESIZE + 1 ];
    // Vetor de sockes usado pelo comando poll
    struct pollfd SoketsInfo[ USERLOGSSOCKETSNUMBER ];
    // Armazena a porta do socket UDP do qual recebemos uma linha de log.
    int LogLinePort;

    #ifdef RIO_DEBUG2
    RioErr << "SERVERUSERLOGSTHREADID " << syscall( SYS_gettid ) << endl;
    #endif

    // Inicializa a variavel usada para indicar que a thread esta em execucao.
    // Esta variavel se tornara false quando recebermos uma linha de log com
    // tamanho igual a 0.
    ExecuteThread = true;

    // Inicializa a variavel usada para indicar se o objeto deve ou nao ser
    // removido ao retornarmos da funcao (por default, nao fazemos isso, pois
    // precisamos enviar uma mensagem de resposta se removermos o objeto pela
    // mensagem especial (uma linha de log com tamanho nulo).
    RemoveObject = false;

    // Inicializa o vetor usado pelo comando poll.
    SoketsInfo[ USERLOGSSOCKETUDP ].fd = m_Socket;
    SoketsInfo[ USERLOGSSOCKETUDP ].events = POLLIN;

    while( ExecuteThread )
    {
        #ifdef RIO_DEBUG2
        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Antes de executar "
                      "a funcao poll, com o socket %u!", m_Socket );
        #endif

        // Espera por mensagens (linhas de log) pelo socket UDP, usando o
        // comando poll. O valor negativo no tempo do comando indica que nao
        // existe um timeout.
        SystemStatus = poll( SoketsInfo, USERLOGSSOCKETSNUMBER, -1 );
        if( SystemStatus < 0 )
        {
            // Se ocorrer algum erro ao executar o poll, reporta este erro no
            // log e tenta executar novamente o comando.
            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Error %d (%s) "
                          "when executing poll function. Trying again!", errno,
                          strerror( errno ) );

        }
        else
        {
            #ifdef RIO_DEBUG2
            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Sucesso ao "
                          "executar a funcao poll!" );
            #endif
            // Nao ocorreu um erro ao executar o poll. Devemos agora entao ver
            // se recebemos dados pelo socket que sera, caso tenha vindo da
            // maquina local, uma linha para ser salva no log.
            if( ( SoketsInfo[ USERLOGSSOCKETUDP ].revents & POLLIN ) != 0 )
            {
                #ifdef RIO_DEBUG2
                ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Existem "
                              "mensagens a serem recebidas!" );
                #endif
                // Existem dados no socket UDP. Tentamos entao receber uma
                // mensagem que, se correta, contera uma linha a ser salva no
                // log.
                RioStatus = ReceiveLogLine( LogLine, &LogLinePort );
                if( FAILED( RioStatus ) )
                {
                    // Neste caso, ocorreu um erro ao tentarmos receber uma
                    // linha de log. Simplesmente mostramos uma mensagem e
                    // executamos novamente a funcao poll.
                    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server, "Error "
                                  "%8x (%s) when executing "
                                  "ReceiveLogLinefunction!", RioStatus,
                                  GetErrorDescription( RioStatus ).c_str() );
                }
                else if( strlen( LogLine ) == 0 )
                {
                    #ifdef RIO_DEBUG2
                    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                                  "Recebida uma mensagem para finalizar a "
                                  "classe! Mensagem recebida %s! Finalizando a "
                                  "thread!",
                                  ( LogLinePort != ntohs( m_LogsServerPort ) ) ?
                                  "de um cliente" : "do destrutor" );
                    #endif
                    // Recebemos uma mensagem indicando para terminarmos a
                    // conexao. Simplesmente fazermos ExecuteThread ser false.
                    ExecuteThread = false;
                    // Deleta o objeto da classe CLogRotation
                    delete m_LogRotation;
                    m_LogRotation = NULL;

                    // Envia uma mensagem de estado, se Port for diferente de
                    // m_LogsServerPort.
                    if( LogLinePort != ntohs( m_LogsServerPort ) )
                    {
                        // Como a mensagem foi recebida de um objeto associado a
                        // um cliente, definimos entao que o objeto deve ser
                        // removido.
                        RemoveObject = true;

                        // Envia a mensagem de estado ao cliente, informando que
                        // a delecao esta sendo processada e que a classe de
                        // logs ja foi finalizada.
                        RioStatus = SendResult( S_OK, LogLinePort );
                        if( FAILED( RioStatus ) )
                        {
                            // Ocorreu um erro ao tentarmos salvar uma linha no log.
                            // Neste caso, tambem ignoramos o erro e tentamos
                            // receber outras linhas de log.
                            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                                          "Error %8x (%s) when executing "
                                          "SendResult to send result S_OK!",
                                          RioStatus,
                                          GetErrorDescription( RioStatus ).
                                                                      c_str() );
                        }
                        #ifdef RIO_DEBUG2
                        else
                            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                                          "Resposta S_OK a mensagem de "
                                          "finalizacao enviada com sucesso ao "
                                          "objeto cliente!"
                                        );
                        #endif
                    }
                }
                else
                {
                    #ifdef RIO_DEBUG2
                    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                                  "Recebida a linha %s para o log da porta %u. "
                                  "Tentando repassa-la ao objeto que gerencia "
                                  "os logs!", LogLine, ntohs( LogLinePort ) );
                    #endif

                    // Recebemos uma linha de log pela conexao UDP. Vamos agora
                    // tentar inseri-la no log.
                    RioStatus = m_LogRotation->NewLogLine( time( NULL ),
                                                           LogLine );
                    if( FAILED( RioStatus ) )
                    {
                        // Ocorreu um erro ao tentarmos salvar uma linha no log.
                        // Neste caso, tambem ignoramos o erro e tentamos
                        // receber outras linhas de log.
                        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                                      "Error %8x (%s) when executing "
                                      "NewLogLine to insert log line %s!",
                                      RioStatus,
                                      GetErrorDescription( RioStatus ).c_str(),
                                      LogLine );
                    }
                    #ifdef RIO_DEBUG2
                    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                                  "Linha %s recebida da porta UDP %u passada "
                                  "com sucesso para o objeto de gerenciamento "
                                  "dos logs!", LogLine, ntohs( LogLinePort ) );
                    #endif

                    #ifdef RIO_DEBUG2
                    ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                                  "Linha de log removida com sucesso!" );
                    #endif

                    // Envia uma mensagem de estado, se Port for diferente de
                    // m_LogsServerPort.
                    if( LogLinePort != ntohs( m_LogsServerPort ) )
                    {
                        RioStatus2 = SendResult( RioStatus, LogLinePort );
                        if( FAILED( RioStatus2 ) )
                        {
                            // Ocorreu um erro ao tentarmos salvar uma linha no log.
                            // Neste caso, tambem ignoramos o erro e tentamos
                            // receber outras linhas de log.
                            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                                          "Error %8x (%s) when executing "
                                          "SendResult to send result %8X (%s)!",
                                          RioStatus2,
                                          GetErrorDescription( RioStatus2 ).
                                                                      c_str(),
                                          RioStatus,
                                          GetErrorDescription( RioStatus2 ).
                                                                      c_str() );
                        }
                        #ifdef RIO_DEBUG2
                        else
                            ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                                          "Resposta %u (%s) ao envio de uma "
                                          "linha de log enviada com sucesso "
                                          "ao objeto cliente!", RioStatus,
                                        GetErrorDescription( RioStatus ).c_str()
                                        );
                        #endif
                    }
                    #ifdef RIO_DEBUG2
                    else
                        ap_log_error( APLOG_MARK, APLOG_ERR, 0, m_Server,
                                      "Erro! Linha de log recebida da porta "
                                      "%u somente usada para finalizar a "
                                      "thread! Mensagem ignorada!",
                                      m_LogsServerPort );
                    #endif
                }
            }
        }
    }

    // Fecha o socket do servidor.
    shutdown( m_Socket, SHUT_RDWR );
    close( m_Socket );
    m_Socket = 0;

    // Altera o indicador da ID da thread, para informar que a thread ja foi
    // finalizada (para evitar que o destrutor envie uma mensagem de termino).
    m_ServerUserLogsThread = 0;

    // Retorna da thread informando se devemos ou nao remover o objeto.
    return RemoveObject;
}

void * CServerUserLogs::ServerUserLogsThreadEp

(

void *

Param

)

[static, private]

Funcao que chama a funcao executada pela thread da classe, usada quando a thread e criada.

Parameters:

Param

ponteiro para o parametro da thread (no caso, um ponteiro para um objeto da classe), passado ao criar a thread.

Definition at line 473 of file UserLogs.cpp.

{
    CServerUserLogs *ServerUserLogs;

    // Converte o ponteito para um objeto da classe.
    ServerUserLogs = ( CServerUserLogs * ) Param;

    #ifdef RIO_DEBUG2
    RioErr << "CServerUserLogs::ServerUserLogsThreadEp chamando a funcao "
           << "ServerUserLogsThread do objeto que executa a thread!" << endl;
    #endif

    // Chama a funcao da classe, removendo o objeto somente se o retorno da
    // funcao for true (se for false, a thread foi finalizada pelo destrutor do
    // objeto e, neste caso, a remocao nao e necessaria).
    if( ServerUserLogs->ServerUserLogsThread() )
    {
        #ifdef RIO_DEBUG2
        RioErr << "CServerUserLogs::ServerUserLogsThreadEp a funcao retornou "
               << "true! Deletando o objeto!" << endl;
        #endif

        // Como a funcao retornou true (termino por uma mensagem com tamanho 0),
        // deveremos deletar o objeto.
        delete ServerUserLogs;
    }

    #ifdef RIO_DEBUG2
    RioErr << "CServerUserLogs::ServerUserLogsThreadEp depois de executar a "
           << "funcao ServerUserLogsThread!" << endl;
    #endif

    return NULL;
}

---

Field Documentation

bool CServerUserLogs::m_Initialized [private]

Variavel booleana que indica se a classe foi inicializada.

Definition at line 58 of file UserLogs.h.

CLogRotation* CServerUserLogs::m_LogRotation [private]

Ponteiro para o objeto da classe de gerenciamento de logs usada por esta classe.

Definition at line 66 of file UserLogs.h.

int CServerUserLogs::m_LogsServerPort [private]

Armazena a porta usada pela thread que envia os logs.

Definition at line 73 of file UserLogs.h.

server_rec* CServerUserLogs::m_Server [private]

Ponteiro para a estrutura com as informacoes do servidor.

Definition at line 63 of file UserLogs.h.

pthread_t CServerUserLogs::m_ServerUserLogsThread [private]

Identificador da thread que recebe os dados a serem colocados no log.

Definition at line 61 of file UserLogs.h.

int CServerUserLogs::m_Socket [private]

Socket usado para enviar dados para a thread da classe, usando a funcao estatica SendLogLine da classe.

Definition at line 69 of file UserLogs.h.

struct sockaddr_in CServerUserLogs::m_SocketAddr [private]

Armazena o endereco do socket usado para gerar os logs.

Definition at line 71 of file UserLogs.h.

---

The documentation for this class was generated from the following files:

• UserLogs.h
• UserLogs.cpp