CSearchLogs Class Reference

Classe que permite executar e enviar buscas executadas em um objeto do tipo CLogRotation. More...

#include <SearchLogs.h>

Public Member Functions

 CSearchLogs ()
 Construtor da classe, usado para ao criarmos um novo objeto do tipo CSearchLogs usado para gerenciar as buscas.
virtual ~CSearchLogs ()
 Destrutor da classe, usado quando o objeto for removido.
virtual int Initialize (CLogRotation *MyLogRotation, NetMgr *MyNetMgr, const char *LogsDirectory, const char *SearchResultPrefix, unsigned int BlockSize, CNetInterface *NetInterface=NULL)
 Funcao usada para inicializar o objeto da classe CSearchLogs criado (somente poderemos usar as outras funcoes apos inicializar a classe, pois em caso, contrario, todas retornarao o erro ERROR_SEARCHLOGS + ERROR_NOT_INITIALIZED.
virtual int SearchLogsRequest (time_t StartTime, time_t EndTime, u32 ClientIPAddr, u16 ClientPort, u32 ReqId)
 Nova funcao para solicitar uma busca em um conjunto de logs de um dos servidores.
virtual int SearchResultDataRequest (u32 ClientIPAddr, u16 ClientPort, u64 ResultFileId, u32 Block, u32 ReqId)
 Nova funcao para ler um bloco do arquivo com os resultados da busca.
virtual int RemoveSearchResultFile (u64 ResultFileId)
 Nova funcao para informar ao servidor que o arquivo com o resultado da busca pode ser removido.
virtual void SearchLogsRequestSendError (time_t StartTime, time_t EndTime, u32 ClientIPAddr, u16 ClientPort, u32 ReqId)
 Funcao similar a SearchLogsRequest mas, ao inves de retornar o codigo de erro, o envia ao cliente, usando a ReqId passada como parametro, a partir de um comando especial (onde o tamanho do arquivo e 0 e o identificador do arquivo e o codigo de erro).
virtual void SearchResultDataRequestSendError (u32 ClientIPAddr, u16 ClientPort, u64 ResultFileId, u32 Block, u32 ReqId)
 Funcao similar a SearchResultDataRequest mas, ao inves de retornar o codigo de erro, o envia ao cliente, usando a ReqId passada como parametro.

Private Member Functions

bool GetSearchFileName (unsigned long long int SearchFileId, char *SearchFileName)
 Funcao usada para retornar o nome do arquivo (com o caminho completo), a partir do identificador passado como parametro).

Static Private Member Functions

static void SearchResutCallback (char *SearchFileName, time_t StartTime, time_t EndTime, int SearchResult, void *callbackparam)
 Nova funcao de callback chamada quando uma solicitacao de busca e completada.
static void SearchCmdCallback (void *callbackparam, int result)
 Nova funcao de callback chamada quando o comando enviado pelo servidor ao cliente termina a sua execucao.
static void SearchCmdResultCallback (void *callbackparam, int result)
 Nova funcao de callback chamada quando a resposta do comando enviado pelo servidor ao cliente termina a sua execucao.
static void SearchBlockCallback (void *callbackparam, int result)
 Nova funcao de callback chamada quando o bloco enviado pelo servidor ao cliente (do arquivo com o resultado da busca) e completamente enviado -com ou sem sucesso-).

Private Attributes

bool m_Initialized
 Variavel booleana que indica se a classe foi inicializada.
CLogRotation * m_LogRotation
 Classe usada para fazermos as buscas nos logs do servidor.
NetMgr * m_NetMgr
 Classe usada para enviar o arquivo de log ao cliente.
CNetInterface * m_NetInterface
 Nova classe usada para enviar o arquivo de log ao cliente (com a nova implementacao do TCP.
const char * m_LogsDirectory
 Diretorio em que os logs da busca serao armazenados.
const char * m_SearchResultPrefix
 Prefixo usado para os arquivos de busca.
unsigned int m_BlockSize
 Tamanho do bloco no sistema de arquivos do servidor.

Detailed Description

Classe que permite executar e enviar buscas executadas em um objeto do tipo CLogRotation.

Usada pelos servidores (de gerenciamento e os de armazenamento) para enviar os logs aos clientes.

Definition at line 42 of file SearchLogs.h.

Constructor & Destructor Documentation

CSearchLogs::CSearchLogs (  ) 

Construtor da classe, usado para ao criarmos um novo objeto do tipo CSearchLogs usado para gerenciar as buscas.

Definition at line 20 of file SearchLogs.cpp.

00021 {
00022     // Inicializa as variaveis da classe.
00023     m_Initialized = false;
00024     m_LogRotation = NULL;
00025     m_NetMgr = NULL;
00026     m_LogsDirectory = NULL;
00027     m_SearchResultPrefix = NULL;
00028     m_BlockSize = 0;
00029     m_NetInterface = NULL;
00030 }

CSearchLogs::~CSearchLogs (  )  [virtual]

Destrutor da classe, usado quando o objeto for removido.

Definition at line 33 of file SearchLogs.cpp.

00034 {
00035 }

Member Function Documentation

bool CSearchLogs::GetSearchFileName ( unsigned long long int  SearchFileId,
char *  SearchFileName 
) [private]

Funcao usada para retornar o nome do arquivo (com o caminho completo), a partir do identificador passado como parametro).

Parameters:
SearchFileId identificador associado ao nome do arquivo.
SearchFileName Nome do arquivo associado ao identificador.
Returns:
true se o nome foi obtido com sucesso ou false se algum erro ocorreu.

Definition at line 65 of file SearchLogs.cpp.

00067 {
00068     // Armazena o retorno da funcao IdRandomName.
00069     bool status; 
00070     // String para armazenar a parte aleatoria do nome do arquivo, obtida a 
00071     // partir da identificacao do arquivo.
00072     char RandomName[ 11 ]; // 10 caracteres para a parte aleatoria do nome
00073                            // mais 1 para o terminador.
00074     status = IdRandomName( SearchFileId, RandomName, 10 );
00075     if( status )
00076     {
00077         strcpy( SearchFileName, m_LogsDirectory );
00078         strcat( SearchFileName, SEARCHRESULTDIRECTORY );
00079         strcat( SearchFileName, m_SearchResultPrefix );
00080         strcat( SearchFileName, RandomName );
00081     }
00082     return status;
00083 }

int CSearchLogs::Initialize ( CLogRotation *  MyLogRotation,
NetMgr *  MyNetMgr,
const char *  LogsDirectory,
const char *  SearchResultPrefix,
unsigned int  BlockSize,
CNetInterface *  NetInterface = NULL 
) [virtual]

Funcao usada para inicializar o objeto da classe CSearchLogs criado (somente poderemos usar as outras funcoes apos inicializar a classe, pois em caso, contrario, todas retornarao o erro ERROR_SEARCHLOGS + ERROR_NOT_INITIALIZED.

Parameters:
MyLogRotation ponteiro para o objeto do tipo CLogRotation em que as buscas serao executadas.
MyNetMgr ponteiro para o objeto do tipo NetMgr usado para enviar os resultados das buscas aos clientes.
SearchResultDirectory diretorio em que os logs do servidor sao armazenados (os resultados da busca serao armazenados no subdiretorio SEARCHRESULTDIRECTORY).
SearchResultPrefix prefixo usado nos arquivos com os resultados da busca (isso e para diferenciar os arquivos do servidor de gerenciamento e de armazenamento, caso estejam em uma mesma maquina).
BlockSize tamanho do bloco no sistema de arquivos do servidor.
NetInterface novo parametro (opcional, para caso alguem tenha usado a implementacao anterior da classe e nao tenha mudado o codigo) com o ponteiro para o objeto do tipo NetInterface que implementa a nova copia do TCP.
Returns:
S_OK se nenhum erro ocorreu ou diferente de S_OK se algum erro ocorreu (no momento, o unico erro e o de chamar Initialize apois ja termos inicializado o objeto).

Definition at line 38 of file SearchLogs.cpp.

00043 {
00044     // Primeiramente verifica se a classe ja foi inicializada.
00045     if( m_Initialized )
00046     {
00047         #ifdef RIO_DEBUG2
00048         RioErr << "CSearchLogs::Initialize o objeto ja foi inicializado" 
00049                << endl;
00050         #endif
00051         return ERROR_SEARCHLOGS + ERROR_INITIALIZED;
00052     }
00053     m_LogRotation = MyLogRotation;
00054     m_NetMgr = MyNetMgr;
00055     m_LogsDirectory = LogsDirectory;
00056     m_SearchResultPrefix = SearchResultPrefix;
00057     m_BlockSize = BlockSize;
00058     m_NetInterface = NetInterface;
00059     m_Initialized = true;
00060     return S_OK;
00061 }

int CSearchLogs::RemoveSearchResultFile ( u64  ResultFileId  )  [virtual]

Nova funcao para informar ao servidor que o arquivo com o resultado da busca pode ser removido.

Parameters:
ResultFileId valor usado para identificar o arquivo com o resultado da busca no servidor, retornado quando recebemos a informacao de que a busca foi feita com sucesso.
Returns:
S_OK se o pedido de remocao do arquivo foi feito com sucesso, ou um valor diferente de S_OK se algum erro ocorreu.

Definition at line 493 of file SearchLogs.cpp.

00494 {
00495     
00496     // Armazena o nome do arquivo.
00497     char SearchResultFileName[ MaxPathSize ];
00498 
00499     // Primeiramente verifica se a classe foi inicializada.
00500     if( !m_Initialized )
00501     {
00502         #ifdef RIO_DEBUG2
00503         RioErr << "CSearchLogs::RemoveSearchResultFile o objeto nao foi "
00504                << "inicializado" << endl;
00505         #endif
00506         return ERROR_SEARCHLOGS + ERROR_NOT_INITIALIZED;
00507     }
00508 
00509     #ifdef RIO_DEBUG2
00510     RioErr << "CSearchLogs::RemoveSearchResultFile Pedido de remocao do "  
00511            << " do arquivo com o identificador " << ResultFileId << endl;  
00512     #endif
00513     // Obtem o nome do arquivo associado ao identificador e o tenta remover.
00514     if( GetSearchFileName( ResultFileId, SearchResultFileName  ) )
00515     {
00516         #ifdef RIO_DEBUG2
00517         RioErr << "CSearchLogs::RemoveSearchResultFile Removendo o arquivo "  
00518                << SearchResultFileName << " associado ao identificador " 
00519                << ResultFileId << endl;  
00520         #endif
00521         if( remove( SearchResultFileName ) < 0 )
00522         {
00523             #ifdef RIO_DEBUG2
00524             RioErr << "CSearchLogs::RemoveSearchResultFile Nao consegui "
00525                    << "remover o arquivo "<< SearchResultFileName 
00526                    << ": " << errno << "(" << strerror( errno ) << ")" 
00527                    << endl;  
00528             #endif
00529             return ERROR_SEARCHLOGS + ERROR_REMOVE_SEARCHRESULT_FILE;
00530         }
00531         else
00532             return S_OK;
00533     }
00534     else
00535         return ERROR_SEARCHLOGS + ERROR_INVALID_SEARCHRESULT_IDENTIFICATION;
00536 }

void CSearchLogs::SearchBlockCallback ( void *  callbackparam,
int  result 
) [static, private]

Nova funcao de callback chamada quando o bloco enviado pelo servidor ao cliente (do arquivo com o resultado da busca) e completamente enviado -com ou sem sucesso-).

Parameters:
callbackparam ponteiro para quem executou o envio do bloco (no caso, um ponteiro para o buffer com o bloco, pois precisamos remover este buffer).
result resultado do envio do bloco. Qualquer valor diferente de S_OK indica um erro ao executar o comando.

Definition at line 260 of file SearchLogs.cpp.

00261 {
00262     // Informacoes sobre o cliente (usada pela funcao que envia o comando).
00263     char *BlockBuffer;
00264     
00265     #ifdef RIO_DEBUG2
00266     if( result != S_OK )
00267         RioErr << "CSearchLogs::SearchBlockCallback erro " << result 
00268                << " ao enviar um bloco do arquivo de busca ao cliente" << endl;
00269     else           
00270         RioErr << "CSearchLogs::SearchBlockCallback bloco do arquivo de busca "
00271                << "enviado com sucesso ao cliente" << endl;
00272     #endif
00273 
00274     // Inicializa uma variavel local com o buffer, passado pelo parametro 
00275     // callbackparam.
00276     BlockBuffer = ( char * ) callbackparam;
00277 
00278     // Remove o buffer com o bloco;
00279     delete[] BlockBuffer;    
00280 }

void CSearchLogs::SearchCmdCallback ( void *  callbackparam,
int  result 
) [static, private]

Nova funcao de callback chamada quando o comando enviado pelo servidor ao cliente termina a sua execucao.

Parameters:
callbackparam ponteiro para quem executou o comando (no caso, um ponteiro para a estrutura SearchCallbackData com as informacoes do cliente relacionado ao comando).
result resultado da execucao do comando. Qualquer valor diferente de S_OK indica um erro ao executar o comando.

Definition at line 172 of file SearchLogs.cpp.

00173 {
00174     // Informacoes sobre o cliente (usada pela funcao que envia o comando).
00175     SearchCallbackData *ClientData;
00176 
00177     // Inicializa uma variavel local com as informacoes do cliente, passadas
00178     // pelo parametro callbackparam.
00179     ClientData = ( SearchCallbackData * ) callbackparam;
00180 
00181     #ifdef RIO_DEBUG2
00182     in_addr ip;
00183     ip.s_addr = ClientData->ClientIP;
00184     RioErr << "CSearchLogs::SearchCmdCallback Comando enviado para o cliente "
00185            << "com o IP " << inet_ntoa( ip ) << " e porta " 
00186            << ntohs( ClientData->ClientPort ) << ", usando a id = " 
00187            << ClientData->ReqId << ", e a id do arquivo = " 
00188            << ClientData->ResultFileId << " terminou com o status " 
00189            << result << endl;
00190     #endif            
00191     
00192     if( result == S_OK )
00193     {
00194         #ifdef RIO_DEBUG2
00195         RioErr << "CSearchLogs::SearchCmdCallback comando de uma solicitacao " 
00196                << "de busca enviado com sucesso. Enviando a resposta ao "
00197                << "comando" << endl;
00198         #endif
00199         // Envia o resultado do comando(TYPE_RESULT) ao cliente de acordo com o 
00200         // resultado da busca.
00201         if( ( ClientData->SearchLogs->m_NetInterface != NULL ) && 
00202             ( ClientData->SearchLogs->m_NetInterface->FindIPAndPort( 
00203               ClientData->ClientIP, ClientData->ClientPort ) ) )
00204             ClientData->SearchLogs->m_NetInterface->SendResult( 
00205                                                            ClientData->ClientIP, 
00206                                                          ClientData->ClientPort,
00207                                                       ClientData->ReqId, S_OK );
00208         else
00209             ClientData->SearchLogs->m_NetMgr->SendResult( ClientData->ClientIP, 
00210                                                          ClientData->ClientPort,
00211                                                       ClientData->ReqId, S_OK );
00212 
00213     }
00214     else 
00215     {
00216         #ifdef RIO_DEBUG2
00217         RioErr << "CSearchLogs::SearchCmdCallback erro " << result 
00218                << " ao enviar o comando de uma solicitacao de busca." << endl;
00219         #endif
00220         
00221         // Remove a estrutura com os dados do cliente.
00222         delete ClientData;    
00223     }
00224 
00225 }

void CSearchLogs::SearchCmdResultCallback ( void *  callbackparam,
int  result 
) [static, private]

Nova funcao de callback chamada quando a resposta do comando enviado pelo servidor ao cliente termina a sua execucao.

Parameters:
callbackparam ponteiro para quem executou o comando (no caso, um ponteiro para a estrutura SearchCallbackData com as informacoes do cliente relacionado ao comando).
result resultado da execucao do comando. Qualquer valor diferente de S_OK indica um erro ao executar o comando.

Definition at line 228 of file SearchLogs.cpp.

00229 {
00230     // Informacoes sobre o cliente (usada pela funcao que envia o comando).
00231     SearchCallbackData *ClientData;
00232 
00233     // Inicializa uma variavel local com as informacoes do cliente, passadas
00234     // pelo parametro callbackparam.
00235     ClientData = ( SearchCallbackData * ) callbackparam;
00236 
00237     #ifdef RIO_DEBUG2
00238     in_addr ip;
00239     ip.s_addr = ClientData->ClientIP;
00240     RioErr << "CSearchLogs::SearchCmdCallback Resposta enviada para o cliente "
00241            << "com o IP "<< inet_ntoa( ip ) << " e porta " 
00242            << ntohs( ClientData->ClientPort ) << ", usando a id = " 
00243            << ClientData->ReqId << ", e a id do arquivo = " 
00244            << ClientData->ResultFileId << " terminou com o status " 
00245            << result << endl;
00246 
00247     if( result != S_OK )
00248         RioErr << "CSearchLogs::SearchCmdResultCallback erro " << result 
00249                << " ao enviar a resposta de um comando de uma solicitacao de "
00250                << "busca." << endl;
00251     #endif            
00252 
00253     // Remove a estrutura com os dados do cliente.
00254     delete ClientData;    
00255 
00256 }

int CSearchLogs::SearchLogsRequest ( time_t  StartTime,
time_t  EndTime,
u32  ClientIPAddr,
u16  ClientPort,
u32  ReqId 
) [virtual]

Nova funcao para solicitar uma busca em um conjunto de logs de um dos servidores.

Parameters:
StartTime Tempo inicial da busca (baseado no mesmo principio da funcao time da biblioteca do C, isto e, o tempo em segundos desde a Epoch (00:00:00 UTC, Janeiro 1 de 1970).
EndTime Tempo Final da busca (o mesmo princio do tempo inicial dado acima).
ClientIPAddr endereco IP do cliente que fez a busca.
ClientPort porta (a UDP) usada por este cliente.
ReqId identificador que deve ser usado pelo servidor ao enviar o resultado da busca.
Returns:
S_OK se a solicitacao de busca foi inicializada com sucesso, ou um valor diferente de S_OK se a solicitacao nao foi iniciada com sucesso. No caso do fracasso, se o erro e ERROR_INVALID_METHOD, isso naoindicara um erro e sim, que o servidor nao possui suporte para fazer as buscas.

Definition at line 284 of file SearchLogs.cpp.

00287 {
00288     // Armazena o nome do arquivo.
00289     char SearchResultFileName[ MaxPathSize ];
00290     // Estrutura passada a callback da busca.
00291     SearchCallbackData *SearchData;    
00292 
00293     // Primeiramente verifica se a classe foi inicializada.
00294     if( !m_Initialized )
00295     {
00296         #ifdef RIO_DEBUG2
00297         RioErr << "CSearchLogs::SearchLogsRequest o objeto nao foi "
00298                << "inicializado" << endl;
00299         #endif
00300         return ERROR_SEARCHLOGS + ERROR_NOT_INITIALIZED;
00301     }
00302     
00303     // Verifica se o intervalo de tempo dado e valido.
00304     if( ( StartTime < 0 ) || ( EndTime < 0 ) || ( EndTime < StartTime ) )
00305         return ERROR_SEARCHLOGS + ERROR_SEARCHLOGS_TIME_INTERVAL;
00306  
00307     // Aloca a estrutura com os dados passados a callback a ser chamada quando 
00308     // a busca terminar.
00309     SearchData = new SearchCallbackData;
00310     if( SearchData == NULL )
00311        return ERROR_SEARCHLOGS + ERROR_MEMORY;
00312             
00313     // Inicializa os campos de SearchData, com excecao da identificacao do
00314     // arquivo, que precisamos avaliar para que seja unica.
00315     SearchData->SearchLogs = this;
00316     SearchData->ClientIP = ClientIPAddr;
00317     SearchData->ClientPort = ClientPort;
00318     SearchData->ReqId = ReqId;   
00319 
00320     // Agora vamos iniciar a busca. Primeiramente precisamos criar um nome
00321     // para o arquivo com o resultado da busca (com o caminho completo).
00322     // Vamos fazer isso usando a funcao RIOmktemp.
00323     strcpy( SearchResultFileName, m_LogsDirectory );
00324     strcat( SearchResultFileName, SEARCHRESULTDIRECTORY );
00325     strcat( SearchResultFileName, m_SearchResultPrefix );
00326     strcat( SearchResultFileName, "XXXXXXXXXX" );
00327         
00328     // Usa a funcao RIOmktemp para criar um arquivo com nome aleatorio.
00329     if( !RIOmktempAndID( SearchResultFileName, &SearchData->ResultFileId ) )
00330     {
00331         // Se a funcao retornar false, ocorreu algum erro ao tentarmos criar
00332         // o arquivo temporario.
00333         return ERROR_SEARCHLOGS + ERROR_CREATE_SEARCHRESULT_FILENAME;
00334     }
00335         
00336     // Agora que temos um nome do arquivo, iniciamos a requisicao de busca
00337     if( m_LogRotation->SearchLogFiles( SearchResultFileName, StartTime, EndTime, 
00338                                        &SearchResutCallback,
00339                                        ( void * ) SearchData ) != S_OK )
00340         return ERROR_SEARCHLOGS + ERROR_LOGROTATION_SEARCH_FAILED; 
00341     else
00342     {
00343         #ifdef RIO_DEBUG2
00344         in_addr ip;    
00345         ip.s_addr = ClientIPAddr;
00346         RioErr << "CSearchLogs::SearchLogsRequest Busca inicializada para o "
00347                << "cliente com o IP " << inet_ntoa( ip ) << " e porta "
00348                << ntohs( ClientPort ) << ": tempo inicial = "
00349                << StartTime << ", tempo final = " << EndTime 
00350                << ", usando a id = " << ReqId << endl;  
00351         #endif
00352                       
00353         return S_OK;   
00354     }   
00355 }

void CSearchLogs::SearchLogsRequestSendError ( time_t  StartTime,
time_t  EndTime,
u32  ClientIPAddr,
u16  ClientPort,
u32  ReqId 
) [virtual]

Funcao similar a SearchLogsRequest mas, ao inves de retornar o codigo de erro, o envia ao cliente, usando a ReqId passada como parametro, a partir de um comando especial (onde o tamanho do arquivo e 0 e o identificador do arquivo e o codigo de erro).

Parameters:
StartTime Tempo inicial da busca (baseado no mesmo principio da funcao time da biblioteca do C, isto e, o tempo em segundos desde a Epoch (00:00:00 UTC, Janeiro 1 de 1970).
EndTime Tempo Final da busca (o mesmo princio do tempo inicial dado acima).
ClientIPAddr endereco IP do cliente que fez a busca.
ClientPort porta (a UDP) usada por este cliente.
ReqId identificador que deve ser usado pelo servidor ao enviar o resultado da busca.

Definition at line 540 of file SearchLogs.cpp.

00543 {
00544     int Status;
00545 
00546     Status = SearchLogsRequest( StartTime, EndTime, ClientIPAddr, ClientPort,
00547                                 ReqId );
00548     if( Status != S_OK )
00549     {
00550         #ifdef RIO_DEBUG2
00551         RioErr << "SearchLogsRequestSendError ocorreu um erro ao executar a "
00552                << "funcao SearchLogsRequest. Enviando o codigo de erro usando "
00553                << "um comando especial a partir da funcao SendCmd da classe "
00554                << "NetMgr" << endl;
00555         #endif
00556         if( ( m_NetInterface != NULL ) && 
00557             ( m_NetInterface->FindIPAndPort( ClientIPAddr, ClientPort ) ) )
00558             m_NetInterface->SendRst( ClientIPAddr, ClientPort, ReqId, Status );
00559         else
00560             m_NetMgr->SendRst( ClientIPAddr, ClientPort, ReqId, Status );
00561     }
00562 }

int CSearchLogs::SearchResultDataRequest ( u32  ClientIPAddr,
u16  ClientPort,
u64  ResultFileId,
u32  Block,
u32  ReqId 
) [virtual]

Nova funcao para ler um bloco do arquivo com os resultados da busca.

Parameters:
ClientIPAddr endereco IP do cliente que fez a busca.
ClientPort porta (a UDP) usada por este cliente.
ResultFileId valor usado para identificar o arquivo com o resultado da busca no servidor, retornado quando recebemos a informacao de que a busca foi feita com sucesso.
Block numero do bloco que desejamos obter.
ReqId identificador que deve ser usado pelo servidor ao enviar o bloco do arquivo ao cliente.
Returns:
S_OK se o pedido do bloco foi feito com sucesso, ou um valor diferente de S_OK se o pedido nao foi feito com sucesso.

Definition at line 359 of file SearchLogs.cpp.

00362 {
00363     // Armazena o nome do arquivo.
00364     char SearchResultFileName[ MaxPathSize ];
00365     // Armazena o numero de blocos do arquivo (TotalBlocks).
00366     unsigned int TotalBlocks;
00367     // Tamanho do bloco a ser lido (somente o ultimo pode ser menor do que
00368     // m_BlockSize.
00369     unsigned int ReadSize;
00370     // Estrutura para obtermos o tamanho do arquivo com o resultado da busca.
00371     struct stat FileInfo;
00372     // Buffer em que armazenaremos o bloco lido do arquivo.
00373     char *BlockBuffer;
00374     // Identificador para o arquivo de busca aberto (de onde vamos ler um dos
00375     // blocos).
00376     FILE *ResultFile;
00377 
00378     // Primeiramente verifica se a classe foi inicializada.
00379     if( !m_Initialized )
00380     {
00381         #ifdef RIO_DEBUG2
00382         RioErr << "CSearchLogs::SearchResultDataRequest o objeto nao foi "
00383                << "inicializado" << endl;
00384         #endif
00385         return ERROR_SEARCHLOGS + ERROR_NOT_INITIALIZED;
00386     }
00387     
00388     #ifdef RIO_DEBUG2
00389     in_addr ip;    
00390     ip.s_addr = ClientIPAddr;
00391     RioErr << "CSearchLogs::SearchResultDataRequest Pedido do bloco " << Block 
00392            << " do arquivo com o identificador " << ResultFileId 
00393            << " a partir do cliente com o IP " << inet_ntoa( ip ) 
00394            << " e porta " << ntohs( ClientPort ) << ", usando a id "
00395            << ReqId << endl;  
00396     #endif
00397     // Tenta alocar o buffer a ser usado.
00398     BlockBuffer = new char[ m_BlockSize ];
00399     if( BlockBuffer == NULL )
00400         return ERROR_SEARCHLOGS + ERROR_MEMORY;
00401         
00402     // Descobre o nome do arquivo associado a resultfileid.
00403     if( !GetSearchFileName( ResultFileId, SearchResultFileName  ) )
00404     {
00405         delete [] BlockBuffer;
00406         return ERROR_SEARCHLOGS + ERROR_INVALID_SEARCHRESULT_IDENTIFICATION;
00407     }
00408 
00409     #ifdef RIO_DEBUG2
00410     RioErr << "CSearchLogs::SearchResultDataRequest Arquivo com o nome "
00411            << SearchResultFileName << " esta associado ao identificador "
00412            << ResultFileId << endl;      
00413     #endif      
00414 
00415     // Descobre o tamanho do arquivo com o resultado da busca. 
00416     if( lstat( SearchResultFileName, &FileInfo ) < 0 )
00417     { 
00418         delete [] BlockBuffer;
00419         return ERROR_SEARCHLOGS + ERROR_OPEN_SEARCHRESULT_FILE;
00420     }
00421     // Descobre o numero de blocos do arquivo, para podermos verificar se o 
00422     // bloco passado como parametro e valido.
00423     TotalBlocks = ( FileInfo.st_size + m_BlockSize - 1 ) / m_BlockSize;
00424     #ifdef RIO_DEBUG2
00425     RioErr << "CSearchLogs::SearchResultDataRequest tamanho do arquivo de "
00426            << "busca " << FileInfo.st_size << " bytes (ou " << TotalBlocks 
00427            << " blocos)" << endl;
00428     #endif
00429 
00430     // Verifica se o bloco passado e valido.
00431     if( Block >= TotalBlocks )
00432     {
00433         delete [] BlockBuffer;
00434         return ERROR_SEARCHLOGS + ERROR_INVALID_BLOCK;
00435     }
00436            
00437     // Abre o arquivo com o resultado da busca.
00438     ResultFile = fopen( SearchResultFileName, "r" );
00439     if( ResultFile == NULL )
00440     {
00441         delete [] BlockBuffer;
00442         return ERROR_SEARCHLOGS + ERROR_OPEN_SEARCHRESULT_FILE;
00443     }
00444         
00445     // Posiciona o ponteiro do arquivo no inicio do bloco (o valor do seek
00446     // sera exatamente de block * m_BlockSize bytes).
00447     if( fseek( ResultFile, Block * m_BlockSize, SEEK_SET ) )
00448     {
00449         fclose( ResultFile );
00450         delete [] BlockBuffer;
00451         return ERROR_SEARCHLOGS + ERROR_READ_SEARCHRESULT_FILE;
00452     }
00453     // Determina o tamanho do bloco a ser lido.
00454     if( Block < TotalBlocks - 1 )
00455         ReadSize = m_BlockSize;
00456     else
00457         ReadSize = FileInfo.st_size - m_BlockSize * ( TotalBlocks - 1 );
00458                    
00459     // Limpa o buffer com o bloco.
00460     memset( BlockBuffer, 0, sizeof( BlockBuffer ) );
00461                      
00462     // Le o bloco do arquivo de busca.
00463     if( fread( BlockBuffer, sizeof( char ), ReadSize,  ResultFile ) != 
00464         ReadSize )
00465     {
00466         fclose( ResultFile );
00467         delete [] BlockBuffer;
00468         return ERROR_SEARCHLOGS + ERROR_READ_SEARCHRESULT_FILE;
00469     }
00470         
00471     // Fecha o arquivo de busca.
00472     fclose( ResultFile );
00473         
00474     // Inicializa o envio do bloco para o cliente (sera que podemos fazer
00475     // isso, ou devemos deixar isso pendente em alguma pilha? Neste caso,
00476     // provavelmente precisariamos criar uma thread).
00477     if( ( m_NetInterface != NULL ) && 
00478         ( m_NetInterface->FindIPAndPort( ClientIPAddr, ClientPort ) ) )
00479         m_NetInterface->SendBlock( ClientIPAddr, ClientPort, ReqId, BlockBuffer, 
00480                                    m_BlockSize, &SearchBlockCallback,
00481                                   ( void * ) BlockBuffer );
00482     else
00483         m_NetMgr->SendBlock( ClientIPAddr, ClientPort, ReqId, BlockBuffer, 
00484                              m_BlockSize, &SearchBlockCallback,
00485                              ( void * ) BlockBuffer, RIO_TRAFFIC_NRT );
00486                                     
00487     return S_OK;                            
00488         
00489 }

void CSearchLogs::SearchResultDataRequestSendError ( u32  ClientIPAddr,
u16  ClientPort,
u64  ResultFileId,
u32  Block,
u32  ReqId 
) [virtual]

Funcao similar a SearchResultDataRequest mas, ao inves de retornar o codigo de erro, o envia ao cliente, usando a ReqId passada como parametro.

Parameters:
ClientIPAddr endereco IP do cliente que fez a busca.
ClientPort porta (a UDP) usada por este cliente.
ResultFileId valor usado para identificar o arquivo com o resultado da busca no servidor, retornado quando recebemos a informacao de que a busca foi feita com sucesso.
Block numero do bloco que desejamos obter.
ReqId identificador que deve ser usado pelo servidor ao enviar o bloco do arquivo ao cliente.

Definition at line 566 of file SearchLogs.cpp.

00570 {
00571     int Status;
00572     
00573     Status = SearchResultDataRequest( ClientIPAddr, ClientPort, ResultFileId,
00574                                       Block, ReqId );
00575     if( Status != S_OK )
00576     {
00577         #ifdef RIO_DEBUG2
00578         RioErr << "SearchResultDataRequestSendError ocorreu um erro ao "
00579                << "executar a funcao SearchResultDataRequest. Enviando o "
00580                << "codigo de erro usando a funcao SendRst da classe NetMgr" 
00581                << endl;
00582         #endif
00583         if( ( m_NetInterface != NULL ) && 
00584             ( m_NetInterface->FindIPAndPort( ClientIPAddr, ClientPort ) ) )
00585             m_NetInterface->SendRst( ClientIPAddr, ClientPort, ReqId, Status );
00586         else
00587             m_NetMgr->SendRst( ClientIPAddr, ClientPort, ReqId, Status );
00588     }
00589 }

void CSearchLogs::SearchResutCallback ( char *  SearchFileName,
time_t  StartTime,
time_t  EndTime,
int  SearchResult,
void *  callbackparam 
) [static, private]

Nova funcao de callback chamada quando uma solicitacao de busca e completada.

Parameters:
SearchFileName Nome do arquivo com o resultado da busca (se a busca tiver sucesso).
StartTime Tempo inicial da busca (baseado no mesmo principio da funcao time da biblioteca do C, isto e, o tempo em segundos desde a Epoch (00:00:00 UTC, Janeiro 1 de 1970).
EndTime Tempo final da busca (usando o mesmo principio de StartTime).
SearchResult resultado da busca: se igual a SEARCH_OK, a busca teve sucesso, isto e, existem logs dentro da faixa de tempo dada pelo intervalo [StartTime, EndTime]. Se for igual a SEARCH_FAILED, entao nao existem logs no intervalo [StartTime, EndTime].
callbackparam parametro dependende da implementacao passado a callback. Para esta classe, e um ponteiro para uma estrutura do tipo SearchCallbackData).

Definition at line 86 of file SearchLogs.cpp.

00089 { 
00090     // Informacoes sobre o cliente (usada pela funcao que envia o comando).
00091     SearchCallbackData *ClientData;
00092     // Estrutura para obtermos o tamanho do arquivo com o resultado da busca.
00093     struct stat FileInfo;
00094     // Buffer temporario para armazenar os dados a serem enviados para o 
00095     // cliente: espaco para 1 inteiro de 32 bits sinalizado com o tamanho,
00096     // e 1 inteiro de 64 bits nao-sinalizaco com o identificador do arquivo com
00097     // o resultado da busca.
00098     char SearchInfo[ sizeof( int ) + sizeof( unsigned long long int ) ]; 
00099     
00100     // Inicializa uma variavel local com as informacoes do cliente, passadas
00101     // pelo parametro callbackparam.
00102     ClientData = ( SearchCallbackData * ) callbackparam;
00103     
00104     // Inicializa o buffer com 0 (indicando uma busca sem sucesso).
00105     memset( ( void * ) SearchInfo, 0, sizeof( SearchInfo ) );
00106     
00107     // Copia o tamanho e a ID do arquivo com o resultado da busca se a busca 
00108     // teve sucesso.
00109     if( SearchResult == SEARCH_OK )
00110     {
00111         // Descobre o tamanho do arquivo com o resultado da busca. 
00112         if( lstat( SearchFileName, &FileInfo ) == 0 ) 
00113         {
00114             // Copia o tamanho do arquivo em SearchInfo.
00115             memcpy( ( void * ) SearchInfo, ( void * ) &( FileInfo.st_size ), 
00116                     sizeof( int ) );
00117             // Copia o identificador do arquivo em SearchInfo.
00118             memcpy( ( void * ) &SearchInfo[ sizeof( int ) ], 
00119                     ( void * ) &( ClientData->ResultFileId ), 
00120                     sizeof( unsigned long long int ) );
00121         } 
00122         else 
00123         {
00124             remove( SearchFileName );
00125         }
00126     }
00127 
00128     #ifdef RIO_DEBUG2
00129     in_addr ip;
00130     ip.s_addr = ClientData->ClientIP;
00131     RioErr << "CSearchLogs::SearchResutCallback Busca terminada para o cliente "
00132            << "com o IP " << inet_ntoa( ip ) << " e porta " 
00133            << ntohs( ClientData->ClientPort ) << ": tempo inicial = " 
00134            << StartTime << ", tempo final = " << EndTime << ", usando a id = " 
00135            << ClientData->ReqId << ", a id do arquivo = " 
00136            << ClientData->ResultFileId << ", e o nome de arquivo "
00137            << SearchFileName << endl; 
00138     // Imprime o conteudo do comando
00139     RioErr << "CSearchLogs::ProcessSearchCmd SearchInfo = ";
00140     char Hex[ 3 ]; // 2 bytes para o chare hexa  + 1 para o terminador.
00141     for( unsigned int i = 0; i < sizeof( int ) + sizeof( unsigned long long int ); 
00142          i++ )
00143     {
00144         sprintf( Hex, "%02X", ( unsigned char ) SearchInfo[ i ] );
00145          RioErr << Hex << " ";
00146     }
00147     RioErr << ", sizeof( SearchInfo ) = " << sizeof( SearchInfo ) << endl;
00148     #endif            
00149 
00150     // Envia uma mensagem (um comando - TYPE_CMD) ao cliente de acordo com o 
00151     // resultado da busca.
00152     if( ( ClientData->SearchLogs->m_NetInterface != NULL ) && 
00153         ( ClientData->SearchLogs->m_NetInterface->FindIPAndPort( 
00154           ClientData->ClientIP, ClientData->ClientPort ) ) )
00155         ClientData->SearchLogs->m_NetInterface->SendCmd( ClientData->ClientIP, 
00156                                                          ClientData->ClientPort, 
00157                                                   ClientData->ReqId, SearchInfo, 
00158                                                          sizeof( SearchInfo ), 
00159                                                          &SearchCmdCallback,
00160                                                         ( void * ) ClientData );  
00161     else 
00162         ClientData->SearchLogs->m_NetMgr->SendCmd( ClientData->ClientIP, 
00163                                                    ClientData->ClientPort, 
00164                                                   ClientData->ReqId, SearchInfo, 
00165                                                    sizeof( SearchInfo ), 
00166                                                    &SearchCmdCallback,
00167                                                    ( void * ) ClientData );  
00168 }

Field Documentation

unsigned int CSearchLogs::m_BlockSize [private]

Tamanho do bloco no sistema de arquivos do servidor.

Definition at line 59 of file SearchLogs.h.

bool CSearchLogs::m_Initialized [private]

Variavel booleana que indica se a classe foi inicializada.

Definition at line 46 of file SearchLogs.h.

CLogRotation* CSearchLogs::m_LogRotation [private]

Classe usada para fazermos as buscas nos logs do servidor.

Definition at line 48 of file SearchLogs.h.

const char* CSearchLogs::m_LogsDirectory [private]

Diretorio em que os logs da busca serao armazenados.

Definition at line 55 of file SearchLogs.h.

CNetInterface* CSearchLogs::m_NetInterface [private]

Nova classe usada para enviar o arquivo de log ao cliente (com a nova implementacao do TCP.

Definition at line 53 of file SearchLogs.h.

NetMgr* CSearchLogs::m_NetMgr [private]

Classe usada para enviar o arquivo de log ao cliente.

Definition at line 50 of file SearchLogs.h.

const char* CSearchLogs::m_SearchResultPrefix [private]

Prefixo usado para os arquivos de busca.

Definition at line 57 of file SearchLogs.h.

The documentation for this class was generated from the following files:
Generated on Wed Jul 4 16:03:33 2012 for RIO by  doxygen 1.6.3