00001 /* 00002 * Copyright (C) 2009, Edmundo Albuquerque de Souza e Silva. 00003 * 00004 * This file may be distributed under the terms of the Q Public License 00005 * as defined by Trolltech AS of Norway and appearing in the file 00006 * LICENSE.QPL included in the packaging of this file. 00007 * 00008 * THIS FILE IS PROVIDED AS IS WITH NO WARRANTY OF ANY KIND, INCLUDING 00009 * THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR 00010 * PURPOSE. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, 00011 * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING 00012 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, 00013 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 00014 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 00015 * 00016 * Thanks: Jose Renato Santos 00017 * 00018 */ 00019 00020 /////////////////////////////////////////////////////////////////////////////// 00021 // SessionManager.h: Declaration of the CSessionManager 00022 /////////////////////////////////////////////////////////////////////////////// 00023 00024 #ifndef __SESSIONMANAGER_H_ 00025 #define __SESSIONMANAGER_H_ 00026 00027 #include <fstream> 00028 00029 #include "MonitorTable.h" 00030 #include "SessionManagerTypes.h" 00031 00032 #include "RioMutex.h" 00033 #include "RioTCP.h" 00034 #include "LogRotation.h" 00035 #include "SearchLogs.h" 00036 00037 #include "StreamManager.h" 00038 #include "ObjectManager.h" 00039 #include "UserManager.h" 00040 #include "NetMgr.h" 00041 #include "NetInterface.h" 00042 00043 class CSessionManager; 00044 class RioSession; 00045 00046 class ClientThreadParameter 00047 { 00048 public: 00049 SOCKET Socket; 00050 CSessionManager* SessionManager; 00051 SOCKADDR_IN RemoteAddress; 00052 00053 ClientThreadParameter() 00054 { 00055 memset( &Socket, 0, sizeof(SOCKET)); 00056 SessionManager = NULL; 00057 memset( &RemoteAddress, 0, sizeof(SOCKADDR_IN)); 00058 } 00059 00060 }; 00061 00062 class SessionEntry 00063 { 00064 public: 00065 RioSessionId Session; 00066 RioSession *s_ptr; 00067 00068 SessionEntry() 00069 { 00070 memset( &Session, 0, sizeof(RioSessionId)); 00071 s_ptr = NULL; 00072 } 00073 }; 00074 00075 enum idtype 00076 { 00077 idt_invalid=0, 00078 idt_stream, 00079 idt_object, 00080 idt_directory, 00081 idt_streamobj 00082 }; 00083 00084 struct identry 00085 { 00086 idtype id_type; 00087 void *id_object; 00088 }; 00089 00090 /////////////////////////////////////////////////////////////////////////////// 00091 // only used inside of SessionManager 00092 class RioSession 00093 { 00094 private: 00095 CSessionManager *s_mgr; 00096 RioUser *s_user; 00097 int s_id; 00098 // id table: index by id (usually supplied to/from client) 00099 static const unsigned int s_idmax = 50; //100; 00100 identry s_idtable[s_idmax]; 00101 char s_CurrentDir[MaxPathSize+100]; 00102 bool m_alreadyClosed; 00103 SOCKADDR_IN s_remoteAddress;//to correct client ip 00104 NATData s_ServerNat; // endereco do cliente, no servidor de 00105 // gerenciamento, associado ao envio de 00106 // mensagens de estado e os dados das 00107 // buscas nos logs. 00108 00109 RioSession( CSessionManager *mgr ); 00110 RioSession( CSessionManager *mgr, SOCKADDR_IN remoteAddress ); 00111 ~RioSession(); 00112 00113 // internal functions to session 00114 void *checkid( int id, idtype type ); 00115 void **newid( int *id, idtype type ); 00116 int ObjectToPath( char* ObjectName, char* RioPath, int PathSize ); 00117 00118 // have session 00119 int Open( char *Username, char *Password ); 00120 int ChangeDir( char *Dir ); 00121 int GetCurrentDir( int size, char *Dir ); 00122 int Close(); 00123 00124 // have session (work on objects but don't leave them open) 00125 int CreateObject( char *ObjectName, short Type ); 00126 00127 int DeleteObject( char *ObjectName ); 00128 int RenameObject( char *CurrentName, char *NewName ); 00129 int GetObjectInfo( char *ObjectName, ObjectInfo *ObjectInfo ); 00130 int GetBlockSize( unsigned int *BlockSize ); 00131 int GetRemoteAddress( SOCKADDR_IN *Address ); 00132 00133 int GetNumberOfDisks( unsigned int *NumberOfDisks ); 00134 int GetNumberOfStorageNodes( unsigned int *NumberOfStorageNodes ); 00135 int GetStorageNodeInfo( unsigned int StorageNodeIndex, 00136 RioStorageNodeInfo* StorageNodeInfo ); 00137 int GetNumberOfActiveAndMaxSessions( 00138 unsigned int *NumberOfActiveSessions, 00139 unsigned int *NumberOfMaxSessions ); 00140 int RemoveIdEntryFromTable( int ObjectId, idtype type ); 00141 int SaveMeasures(); 00142 int GetMonitorTable( vector<ClientData> &clientTable, 00143 vector<StorageData> &storageTable ); 00144 // -------------------------------------------------------------------- 00145 00146 // open directory (RioDirectory *) 00147 int FirstObject( char *DirectoryName, int *dirid, 00148 int *IsDirectory, int BufferSize, char *ObjectName ); 00149 00150 // open Stream (RioStream *) 00151 int OpenStream( RioStreamTraffic *Traffic, int *StreamId ); 00152 00153 // requires stream 00154 int StreamOpenObject( int StreamId, char *ObjectName, RioAccess Access, 00155 int *StreamObjId ); 00156 int StreamOpenObject( int StreamId, char *ObjectName, 00157 struct timeval RTT_average, 00158 int BufferSize, RioAccess Access, 00159 int *StreamObjId ); 00160 int ClientCanStart( int StreamId ); 00161 // -------------------------------------------------------------------- 00162 int CloseStream( int StreamId ); 00163 int StreamMaxRequests( int StreamId ); 00164 00165 // require directory 00166 int NextObject( int DirectoryId, int *IsDirectory, int BufferSize, 00167 char *ObjectName ); 00168 00169 // require streamobj 00170 int GetSize( int ObjectId, RioObjectSize *ObjectSize ); 00171 // O novo parametro e um vetor de bits que indica quais servidores de 00172 // armazenamento nao podem ser usados (cada bit esta associado a um 00173 // servidor e um valor 1 neste bit indica que o servidor nao pode ser 00174 // usado). 00175 int SetSize( int ObjectId, RioObjectSize ObjectSize, char* md5sum, 00176 unsigned long long int ExcludeStorages ); 00177 00178 int GetType( int ObjectId, short *Type ); 00179 int GetnBlocks( int ObjectId, RioBlock *nBlocks ); 00180 00181 /** 00182 * Funcao CloseObject: fecha um objeto que foi anteriormente aberto pelo 00183 * cliente conectado nesta sessao do Servidor RIO dada pela classe. 00184 * @param ObjectId Valor identificando o objeto dentre todos os objetos 00185 * abertos na sessao. 00186 * @return Erro se o valor for diferente de S_OK. 00187 */ 00188 int CloseObject( int ObjectId ); 00189 00190 int DataRequest( u32 reqid, u32 ipaddr, u32 objid, u32 block, 00191 u32 repbits, u16 port, u16 operation ); 00192 00193 int ExecuteCall( unsigned int Class, unsigned int Method, 00194 char* Parameter, 00195 unsigned int ParameterSize, 00196 char** Result, 00197 unsigned int* ResultSize ); 00198 00199 int ExecuteSessionManager( unsigned int Method, 00200 char* Parameter, 00201 unsigned int ParameterSize, 00202 char** Result, 00203 unsigned int* ResultSize ); 00204 00205 int ExecuteStreamManager( unsigned int Method, 00206 char* Parameter, 00207 unsigned int ParameterSize, 00208 char** Result, 00209 unsigned int* ResultSize ); 00210 00211 int ExecuteObjectManager( unsigned int Method, 00212 char* Parameter, 00213 unsigned int ParameterSize, 00214 char** Result, 00215 unsigned int* ResultSize ); 00216 00217 int ExecuteRouter( unsigned int Method, 00218 char* Parameter, 00219 unsigned int ParameterSize, 00220 char** Result, 00221 unsigned int* ResultSize ); 00222 00223 // Nova funcao para executar as chamadas remotas para a UserManager. 00224 int ExecuteUserManager( unsigned int Method, 00225 char* Parameter, 00226 unsigned int ParameterSize, 00227 char** Result, 00228 unsigned int* ResultSize ); 00229 00230 // Novas funcoes usadas pela implementacao do controle de fluxo. 00231 00232 /** 00233 * GetVideoRate funcao usada pela implementacao controle de fluxo para 00234 * obter a taxa de transmissao do video (esta funcao sera usada pelo 00235 * novo metodo remoto da Object Manager, que sera usado pelo riosh para 00236 * ler a taxa de transmissao do video). 00237 * @param ObjectId identificador do objeto. 00238 * @param VideoRate ponteiro para o inteiro nao sinalizado que 00239 * armazenara a taxa de transmissao do video. 00240 * @return diferente de S_OK se algum erro ocorreu ao obter a taxa. 00241 */ 00242 00243 int GetVideoRate( int ObjectId, unsigned int *VideoRate ); 00244 /** 00245 * SetVideoRate funcao usada pela implementacao controle de fluxo para 00246 * alterar a taxa de transmissao do video (esta funcao sera usada pelo 00247 * novo metodo remoto da Object Manager, que sera usado pelo riosh para 00248 * alterar a taxa de transmissao do video). 00249 * @param ObjectId identificador do objeto. 00250 * @param VideoRate inteiro nao sinalizado com a nova taxa de 00251 * transmissao do video. 00252 * @return diferente de S_OK se algum erro ocorreu ao alterar a taxa. 00253 */ 00254 int SetVideoRate( int ObjectId, unsigned int VideoRate ); 00255 00256 // Nova funcao usada pela implementacao que permite o reinicio dos 00257 // servidores. 00258 00259 /** 00260 * Funcao usada para realocar os blocos fisicos associados ao bloco 00261 * logico de um objeto. 00262 * @param ObjectId identificador do objeto. 00263 * @param Block bloco logico do objeto para o qual desejamos realocar 00264 * os blocos fisicos. 00265 * @param ExcludeStorages vetor de bits que indica quais servidores de 00266 * armazenamento nao podem ser usados (cada bit esta associado a um 00267 * servidor e um valor 1 neste bit indica que o servidor nao pode ser 00268 * usado) ao alocarmos os blocos. 00269 * @return diferente de S_OK se algum erro ocorreu ao realocar os 00270 * blocos. 00271 */ 00272 int ReallocBlocks( int ObjectId, unsigned int Block, 00273 unsigned long long int ExcludeStorages ); 00274 00275 // Novas funcoes usadas pela implementacao do gerenciamento de logs. 00276 00277 /** 00278 * Funcao usada para armazenar uma linha no log do servidor de despacho. 00279 * A linha a ser impressa contera, nesta ordem, o tempo atual (colocado 00280 * pela classe CLogRotation), StrInfo, ObjectName, o IP do cliente e a 00281 * porta do cliente. 00282 * @param StrInfo cadeia com a informacao especifica a ser colocada no 00283 * log. 00284 * @param ObjectName nome do objeto (o caminho completo do arquivo do 00285 * sistema de arquivos do RIO) a ser colocado no log. 00286 * @return S_OK se a linha foi inserida no log com sucesso, ou um valor 00287 * diferente de S_OK se algum erro ocorreu. 00288 */ 00289 int SaveLogLine( const char *StrInfo, const char *ObjectName ); 00290 /** 00291 * Nova funcao para solicitar uma busca em um conjunto de logs de um 00292 * dos servidores. 00293 * @param searchtype tipo da busca, que por enquanto, pode ser 00294 * SEARCHINTRAFFICLOGS para fazer busca nos logs com os trafegos de um 00295 * dos servidores de armazenamento, ou SEARCHINCLIENTSLOGS para fazer 00296 * uma busca nos logs com os comportamentos dos clientes do servidor de 00297 * despacho. 00298 * @param starttime Tempo inicial da busca (baseado no mesmo principio 00299 * da funcao time da biblioteca do C, isto e, o tempo em segundos desde 00300 * a Epoch (00:00:00 UTC, Janeiro 1 de 1970). 00301 * @param endtime Tempo Final da busca (o mesmo princio do tempo 00302 * inicial dado acima). 00303 * @param serveripaddr endereco IP do servidor. 00304 * @param serverport porta (a UDP) usada por este servidor. 00305 * @param clientipaddr endereco IP do cliente que fez a busca. 00306 * @param clientport porta (a UDP) usada por este cliente. 00307 * @param reqid identificador que deve ser usado pelo servidor ao 00308 * enviar o resultado da busca. 00309 * @return S_OK se a solicitacao de busca foi inicializada com sucesso, 00310 * ou um valor diferente de S_OK se a solicitacao nao foi iniciada com 00311 * sucesso. No caso do fracasso, se o erro e ERROR_INVALID_METHOD, isso 00312 * naoindicara um erro e sim, que o servidor nao possui suporte para 00313 * fazer as buscas. 00314 */ 00315 int SearchLogsRequest( u32 searchtype, time_t starttime, time_t endtime, 00316 u32 serveripaddr, u16 serverport, 00317 u32 clientipaddr, u16 clientport, u32 reqid ); 00318 /** 00319 * Nova funcao para ler um bloco do arquivo com os resultados da busca. 00320 * @param serveripaddr endereco IP do servidor. 00321 * @param serverport porta (a UDP) usada por este servidor. 00322 * @param clientipaddr endereco IP do cliente que fez a busca. 00323 * @param clientport porta (a UDP) usada por este cliente. 00324 * @param resultfileid valor usado para identificar o arquivo com o 00325 * resultado da busca no servidor, retornado quando recebemos a 00326 * informacao de que a busca foi feita com sucesso. 00327 * @param block numero do bloco que desejamos obter. 00328 * @param reqid identificador que deve ser usado pelo servidor ao 00329 * enviar o bloco do arquivo ao cliente. 00330 * @return S_OK se o pedido do bloco foi feito com sucesso, ou um valor 00331 * diferente de S_OK se o pedido nao foi feito com sucesso. 00332 */ 00333 int SearchResultDataRequest( u32 serveripaddr, u16 serverport, 00334 u32 clientipaddr, u16 clientport, 00335 u64 resultfileid, u32 block, u32 reqid ); 00336 00337 /** 00338 * Nova funcao para informar ao servidor que o arquivo com o resultado 00339 * da busca pode ser removido. 00340 * @param serveripaddr endereco IP do servidor. 00341 * @param serverport porta (a UDP) usada por este servidor. 00342 * @param resultfileid valor usado para identificar o arquivo com o 00343 * resultado da busca no servidor, retornado quando recebemos a 00344 * informacao de que a busca foi feita com sucesso. 00345 * @return S_OK se o pedido de remocao do arquivo foi feito com 00346 * sucesso, ou um valor diferente de S_OK se algum erro ocorreu. 00347 */ 00348 int RemoveSearchResultFile( u32 serveripaddr, u16 serverport, 00349 u64 resultfileid ); 00350 00351 // Novas funcoes para executar as chamadas remotas para a UserManager. 00352 00353 /** 00354 * Nova funcao para criar um novo usuario. 00355 * @param UserName ponteiro para o nome do usuario. 00356 * @param Password pontrito para a senha do usuario. 00357 * @return S_OK se o usuario foi criado com sucesso ou o codigo de erro 00358 * caso o usuario nao tenha sido criado com sucesso. 00359 */ 00360 int CreateUser( char *UserName, char *Password ); 00361 00362 /** 00363 * Nova funcao para remover um dos usuarios do RIO. 00364 * @param UserName ponteiro para o nome do usuario. 00365 * @return S_OK se o usuario foi removido com sucesso ou o codigo de 00366 * erro caso nao tenha sido possivel remover o usuario. 00367 */ 00368 int RemoveUser( char *UserName ); 00369 00370 /** 00371 * Nova funcao para alterar a senha de um dos usuarios do RIO. 00372 * @param UserName ponteiro para o nome do usuario. 00373 * @param Password pontrito para a senha do usuario. 00374 * @return S_OK se o a senha fou alterada com sucesso ou o codigo de 00375 * erro caso nao tenha sido possivel alterar a senha do usuario. 00376 */ 00377 int ChangePassword( char *UserName, char *Password ); 00378 00379 /** 00380 * Nova funcao para obter a lista com todos os usuarios 00381 * @param USerList vetor de strings (STL) no qual a lista de usuarios 00382 * sera armazenada. 00383 * @return S_OK caso a lista tenha sido gerada com sucesso ou o codigo 00384 * de erro caso nao tenha sido possivel gerar a lista. 00385 */ 00386 int GetUserList( vector< string > &UserList ); 00387 00388 friend class CSessionManager; 00389 }; 00390 00391 /////////////////////////////////////////////////////////////////////////////// 00392 // CSessionManager 00393 class CSessionManager 00394 { 00395 private: 00396 unsigned int m_BlockSize; 00397 00398 // added to support df command ----------------------------- 00399 unsigned int m_NumberOfDisks; 00400 unsigned int m_NumberOfStorageNodes; 00401 DiskMgr *m_DiskMgr; 00402 // -------------------------------------------------------------------- 00403 00404 char *m_FileRoot; 00405 // -------------------------------------------------------------------- 00406 00407 int m_MaxSessions; 00408 00409 CSystemManager *m_SystemManager; 00410 CStreamManager *m_StreamManager; 00411 CObjectManager *m_ObjectManager; 00412 CUserManager *m_UserManager; 00413 CRouter *m_Router; 00414 CRioTCP *m_TCPconnection; 00415 NetMgr *m_NetMgr; 00416 CNetInterface *m_NetInterface; 00417 00418 int m_used; 00419 SessionEntry *m_SessionTable; 00420 pthread_mutex_t m_mutex; 00421 bool m_initialized; 00422 ofstream m_log; 00423 00424 pthread_t m_ConnectionThreadId; 00425 bool m_threadStopEvent; 00426 SOCKADDR_IN *m_ServerAddress; // Vetor com os enderecos (IP, porta) 00427 // das maquinas para as quais 00428 // precisamos enviar periodicamente 00429 // pacotes Fake, isto e, do Servidor 00430 // RIO e dos Storage Servers. 00431 unsigned int m_ServerAddressSize; // Numero de maquinas no vetor 00432 // m_ServerAddress. 00433 // Novo parametro usado para indicar o tempo maximo que o servidor 00434 // espera por uma requisicao de um cliente antes de fechar a conexao com 00435 // a suposicao de que ela caiu. 00436 int m_ClientsTimeOut; 00437 00438 // Ponteiro para o objeto do tipo CLogRotation, que sera usado para 00439 // armazenar os logs de acesso dos clientes. 00440 CLogRotation *m_LogRotation; 00441 00442 // Nova variavel que contera o diretorio onde os logs do servidor 00443 // (gerados pelas diversas classes que o compoe) serao gerados. 00444 char *m_LogsDirectory; 00445 00446 // Ponteiro para o objeto do tipo CSearchLogs, que sera usado para 00447 // buscar nos logs de acesso dos clientes. 00448 CSearchLogs *m_SearchLogs; 00449 00450 int CleanUp(); 00451 void PostITEvent( MonitorEvent *event ); 00452 void GetMonitorTable( vector<ClientData> &, vector<StorageData> & ); 00453 static void *ConnectionThread( void * param ); 00454 static void *ClientThread( void * param ); 00455 void KillConnectionThread(); 00456 /** 00457 * SetNATMapping informa ao Router o mapeamento NAT de um cliente com 00458 * um storage. Sao enviados o mapeamento NAT do cliente com o servidor, 00459 * o id do storage e o mapeamento NAT do cliente com o storage 00460 * considerado. 00461 * @param server_map estrutura identificando o mapeamento do servidor 00462 * de gerenciamento. 00463 * @param stor_id identificador do servidor de armazenamento. 00464 * @param stor_map estrutura identificando o mapeamento do servidor 00465 * de armazenamento com o identificador stor_id. 00466 */ 00467 void SetNATMapping( NATData server_map, int stor_id, NATData stor_map ); 00468 00469 /** 00470 * Le do arquivo cactimes que contem o tempo para tocar cada bloco do 00471 * video. Este arquivo (cactimes) deve estar no mesmo diretorio do 00472 * video, porem copiado pelo sistema de arquivos do linux e nao do RIO. 00473 * Nao esta sendo utilizado atualmente mas sera mantido pois pode ser 00474 * util no futuro. 00475 */ 00476 int GetVideoDuration( char *VideoName ); 00477 00478 friend class RioSession; 00479 00480 public: 00481 CSessionManager(); 00482 ~CSessionManager(); 00483 00484 int SaveMeasures(); 00485 // Agora o metodo Initialize da classe CSessionManager possuira somente 00486 // um parametro, pois o parametro GenerateLogs esta agora na estrutura 00487 // StreamManagerConfig. 00488 int Initialize( SessionManagerConfig *Config ); 00489 /** 00490 * Funcao para invalidar todos os mapeamentos dos clientes conectados 00491 * para um servidor de armazenamento identificado pela ID passada como 00492 * parametro. 00493 * @param StorageId Identificador do servidor de armazenamento. 00494 */ 00495 void InvalidateStorageNatMappings( int StorageId ); 00496 /** 00497 * Funcao para alterar o valor do numero de discos do servidor. Ela foi 00498 * necessaria porque, quando os servidores de armazenamento inicializam 00499 * apos o servidor. 00500 * @param NumberOfDisks novo numero de discos. 00501 */ 00502 void SetNumberOfDisks( unsigned int NumberOfDisks ); 00503 }; 00504 00505 #endif //__SESSIONMANAGER_H_