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 */ 00017 00018 /////////////////////////////////////////////////////////////////////////////// 00019 // PLSessionManager.h: Declaration of the PLSessionManager 00020 /////////////////////////////////////////////////////////////////////////////// 00021 00022 #ifndef __PLSESSIONMANAGER_H_ 00023 #define __PLSESSIONMANAGER_H_ 00024 00025 #include <fstream> 00026 using namespace std; 00027 00028 #include <sys/time.h> 00029 #include <sys/types.h> 00030 #include <string.h> 00031 #include <arpa/inet.h> 00032 #include <netinet/in.h> 00033 #include <stdio.h> 00034 #include <string.h> 00035 #include <errno.h> 00036 #include <pthread.h> 00037 #include <sys/socket.h> 00038 #include <signal.h> 00039 #include <stdlib.h> 00040 #include <math.h> 00041 #include <unistd.h> 00042 00043 #include "CommMulticastStream.h" 00044 #include "RioError.h" 00045 #include "RioProxy.h" 00046 #include "RioTCP.h" 00047 #include "RioTCPTypes.h" 00048 #include "RioInterface.h" 00049 #include "DataConversion.h" 00050 #include "td4types.h" 00051 #include "NetMgr.h" 00052 #include "PLStreamManager.h" 00053 #include "PLObjectManager.h" 00054 #include "token.h" 00055 00056 class PLSessionManager; 00057 00058 #define PL_CLIENT_STAT_LEADER_ENABLED 0x1 00059 #define PL_CLIENT_STAT_LEADER_DISABLED 0x0 00060 00061 #define PL_OK 0 00062 #define PL_ERROR 1 00063 #define PL_ERROR_TIMEOUT PL_ERROR - 0x002 00064 00065 // Size of a unsigned integer 2^32 00066 #define MAX_GROUPID (unsigned)300 00067 00068 // Serve para o PI n�o ficar bloqueado quando um bloco n�o chega 00069 // One second (us) 00070 #define BLOCK_TIMEOUT 1000000 00071 00072 class ClientThreadParameter 00073 { 00074 public: 00075 SOCKET Socket; 00076 PLSessionManager *SessionManager; 00077 SOCKADDR_IN RemoteAddress; 00078 00079 ClientThreadParameter() 00080 { 00081 memset( &Socket, 0, sizeof(SOCKET) ); 00082 SessionManager = NULL; 00083 memset( &RemoteAddress, 0, sizeof(SOCKADDR_IN)); 00084 } 00085 }; 00086 00087 class InfoClient 00088 { 00089 public: 00090 InfoClient() 00091 { 00092 NextMember = NULL; 00093 NextGroup = NULL; 00094 PrevMember = NULL; 00095 PrevGroup = NULL; 00096 isPatching = false; 00097 memset( video_name, 0, sizeof(video_name) ); 00098 videoTotalBlocks = 0; 00099 memset( multicast_ip, 0, sizeof(multicast_ip) ); 00100 multicast_port = 0; 00101 PIDClientThread = 0; 00102 mode = UNAVAILABLE; 00103 CurrentBlock = -1; 00104 target = -1; 00105 }; 00106 00107 InfoClient *NextMember; 00108 InfoClient *NextGroup; 00109 InfoClient *PrevMember; 00110 InfoClient *PrevGroup; 00111 bool isPatching; 00112 char video_name[ 1024 + 1 ]; //nome do v�deo que o cliente assiste 00113 unsigned int videoTotalBlocks; 00114 char multicast_ip[ 1024 + 1 ]; 00115 int multicast_port; //Identifica o grupo do cliente 00116 pid_t PIDClientThread; // Identifier 00117 00118 ClientMode mode; // Indica qual o papel do cliente no sistema, a saber, 00119 //op��es: PASSIVE, LEADER, SUBLEADER, INACTIVE ou 00120 //UNAVAILABLE. 00121 00122 int CurrentBlock; // CurrentBlock s� � usada pelo l�der. Indica o 00123 //bloco que est� sendo pedido para o grupo. Os 00124 //demais clientes (n�o lideres) devem ter esta 00125 //vari�vel setada para zero. 00126 int target; //target s� � usado pelo subl�der. Indica qual o 00127 //bloco que este subl�der deve alcan�ar para que 00128 //seu subgrupo termine o processo de merging com o 00129 //grupo principal. 00130 }; 00131 00132 struct LogRequest 00133 { 00134 char *IPClient; 00135 int Port; 00136 double Time; 00137 char *Stream; // Video Name 00138 int Block; 00139 char *Operation; // play, pause, stop ... 00140 char *RIOServer; 00141 }; 00142 00143 /////////////////////////////////////////////////////////////////////////////// 00144 // PLSessionManager 00145 /////////////////////////////////////////////////////////////////////////////// 00146 class PLSessionManager 00147 { 00148 public: 00149 PLSessionManager(); 00150 ~PLSessionManager(); 00151 00152 pthread_mutex_t InfoClientMutex; 00153 pthread_mutex_t MoveMutex; 00154 pthread_mutex_t MulticastPortInfoMutex; 00155 00156 unsigned int BlockSize; 00157 char *RIOServer; 00158 00159 static InfoClient *m_InfoClient; //m_InfoClient � o primeiro 00160 //cliente do primeiro grupo 00161 00162 static InfoClient *m_InactiveClient; //m_InactiveClient � o 00163 //primeiro cliente do 00164 //grupo de inativos 00165 00166 PLStreamManager *StreamManager; 00167 PLObjectManager *ObjectManager; 00168 static CommunicationStream *CommMulticastStream; 00169 00170 // Nova variavel que contera o diretorio onde o arquivo de 00171 // configuracao do RIOPL (RIOPLsystem.cfg) sera lido (usado 00172 // pela funcao ReadConfiguration). 00173 char *m_ConfigsDirectory; 00174 00175 // Nova variavel que contera o diretorio onde os logs do RIOPL 00176 // (gerados pelas diversas classes que o compoe) serao gerados. 00177 char *m_LogsDirectory; 00178 00179 // Foi adicionado um parametro à função Initializa para permitir ler o 00180 // arquivo de configuracao e salvar os arquivos de log em um 00181 // diretorio diferente de onde o codigo da RIOPL esta. O parametro 00182 // da o nome de um diretorio, onde, no subdiretorio etc, estara o 00183 // arquivo de configuracao e, no subdiretorio var, os arquivos de log. 00184 int Initialize( char *PrefixDirectory ); 00185 00186 /*** 00187 * FindClient procura o cliente cujo PID � PIDClientThread nos grupos ativos e, 00188 * caso n�o encontre, procura no grupo de inativos. Retorna NULL caso o cliente 00189 * n�o exista em nenhum dos grupos. 00190 * Obs: FindClient n�o usa mutex pra impedir concorr�ncia pois assume que isto � 00191 * feito por quem o invoca. Como algumas a��es �s vezes s�o necess�rias ap�s a 00192 * FindClient, convencionou-se que o lock e unlock no mutex deve ser 00193 * administrado pelo m�todo que chama a FindClient de acordo com a necessidade. 00194 * @param PIDClientThread pid do cliente que se que localizar na tabela de 00195 * membros ativos e inativos do sistema. 00196 * @return retorna um ponteiro para o cliente de pid PIDClientThread. 00197 */ 00198 InfoClient *FindClient( pid_t PIDClientThread ); 00199 00200 void PrintLogRequest( LogRequest *PrintLogRequest ); 00201 00202 /*** 00203 * SetMode altera o membro mode do cliente client para o novo modo fornecido 00204 * pelo par�metro mode. 00205 * @param client cliente ao qual se deseja setar o membro mode. 00206 * @param mode � o valor que ser� atribu�do ao membro mode do cliente client. 00207 * @return retorna PL_OK em caso de sucesso e PL_ERROR em caso de falha ou 00208 * erro. 00209 */ 00210 int SetMode( InfoClient *client, ClientMode mode ); 00211 00212 /*** 00213 * CreateNewMember cria um novo membro e o insere na lista de inativos. Este 00214 * novo membro permanecer� nesta lista at� que, por uma a��o, seja alocado em 00215 * algum grupo atrav�s do m�todo AllocClient. 00216 * Este m�todo s� � executado pela PL. 00217 * @param ObjectName � o nome do v�deo que o cliente a ser criado pretende 00218 * assistir. 00219 * @param ObjectSize � o tamanho do v�deo que o cliente deseja assitir em 00220 * n�mero de blocos. 00221 * @return retorna um ponteiro para o novo membro criado. 00222 */ 00223 InfoClient *CreateNewMember( char *ObjectName, 00224 unsigned int ObjectSize ); 00225 /** 00226 * AllocClient trata as interacoes do cliente e o aloca em um dos grupos 00227 * existentes ou cria um novo grupo se necessario de acordo com a movimentacao 00228 * do cliente. Se block < 0, entao o cliente deve ser removido do grupo a 00229 * que pertence e ser inserido na lista de inativos. 00230 * new_block por default � igual a zero. 00231 * @param clientPID pid do cliente que interagiu 00232 * @param moveData corpo da mensagem enviada pelo cliente que se moveu 00233 * @return retorna PL_OK em caso de sucesso e PL_ERROR em caso de falha ou 00234 * erro. 00235 */ 00236 int AllocClient( int pid, msgMove *moveData ); 00237 00238 /*** 00239 * CreateNewGroup cria um novo grupo no final da lista encadeada de forma que 00240 * member seja o l�der do mesmo. Neste ponto, uma nova porta multicast e um 00241 * novo ID de grupo s�o gerados e armazenados nos atributos de member. O bloco 00242 * inicial para este grupo � fornecido pelo par�metro block. 00243 * @param member cliente que ser� o l�der do novo grupo. Este cliente informa 00244 * qual o bloco inicial bem como outros atributos do novo grupo a ser criado. 00245 * @param block bloco inicial do grupo a ser setado em meber->CurrentBlock. 00246 * @return retorna PL_OK em caso de sucesso e PL_ERROR em caso de falha ou 00247 * erro. 00248 */ 00249 int CreateNewGroup( InfoClient *member, int block ); 00250 00251 /*** 00252 * FindGroup percorre os grupos ativos procurando um que melhor se adeque a 00253 * posi��o do cliente current_client. Se n�o houver um grupo em que 00254 * current_client possa ser admitido, FindGroup retorna NULL (neste caso, fica 00255 * a cargo de quem chamou FindGroup criar um novo grupo para este cliente). 00256 * Caso FindGroup encontre um grupo adequado, retorna um ponteiro para o atual 00257 * l�der do respectivo grupo. 00258 * O par�metro new_block � usado para indicar ao cliente se ele deve alterar o 00259 * pr�ximo bloco a ser tocado. Isto acontece quando o cliente encontra um grupo 00260 * que est� um pouco atr�s dele. Neste caso, para se unir a este grupo o 00261 * cliente recua de sua posi��o atual. 00262 * @param current_client � o cliente para o qual se procura um grupo adequado. 00263 * @param block � o bloco que o cliente que se moveu requisitou � PL. 00264 * @param new_block informa ao cliente se ele deve(retorno > -1) ou n�o 00265 * (retorno == -1) alterar seu pr�ximo bloco a ser tocado antes de prosseguir. 00266 * @return retorna um ponteiro para o l�der do grupo escolhido para o cliente. 00267 */ 00268 InfoClient *FindGroup( InfoClient *current_client, int block, 00269 int *new_block = 0 ); 00270 00271 /*** 00272 * FindMergeGroup percorre os grupos ativos procurando por um grupo que esteja 00273 * o mais pr�ximo poss�vel do grupo group desde que esteja a uma dist�ncia 00274 * m�xima de m_DeltaAfter do mesmo para que estes grupos passem compartilhar o 00275 * fluxo de group e venham a se unire em um s�. Se n�o houver um grupo nessas 00276 * condi��es, FindMergeGroup retorna NULL. 00277 * @param group grupo que ser� tomado como base na busca por outro grupo que 00278 * possa se unir a este. 00279 * @return retorna um ponteiro para o l�der do grupo escolhido para se unir ao 00280 * grupo group. 00281 */ 00282 InfoClient *FindMergeGroup( InfoClient *group ); 00283 00284 /*** 00285 * isMergeableGroup analisa se o grupo fornecido pelo par�metro group � 00286 * est�vel e apto para ser unido a outro grupo, isto �, (nenhum membro 00287 * est� fazendo patching e o grupo n�o est� em processo de uni�o com outro 00288 * grupo.) 00289 * @param group � o grupo que est� sendo analisado quando � disponibilidade para 00290 * fus�o com outro grupo. 00291 * @return retorna true ou false caso o grupo group esteja apto ou n�o a ser 00292 * unido a outro grupo. 00293 */ 00294 bool isMergeableGroup( InfoClient *group ); 00295 00296 /*** 00297 * InsertMemberInActiveGroup insere o cliente client na �ltima posi��o do 00298 * grupo group (caso n�o exista um subl�der no grupo), ou imediatamente 00299 * antes do subl�der do grupo (se houver um), setando corretamente os 00300 * atributos de client conforme os atributos de group. 00301 * @param client cliente que ser� inserido no grupo indicado pelo par�metor 00302 * group. 00303 * @param group grupo ao qual o cliente do par�metro client ser� inserido. 00304 * @param isPatching informa se o cliente que est� sendo inserido no grupo 00305 * entrar� fazendo patching (isPatching = true) ou n�o (isPatching = false). 00306 * @return retorna PL_OK em caso de sucesso e PL_ERROR em caso de falha ou 00307 * erro. 00308 */ 00309 int InsertMemberInActiveGroup( InfoClient *client, 00310 InfoClient *group, 00311 bool isPatching ); 00312 00313 /*** 00314 * InsertMemberInInactiveGroup insere o cliente client na primeira posi��o da 00315 * lista de clientes inativos, setando corretamente os atributos de client/ 00316 * conforme os atributos dos membros inativos. 00317 * @param client cliente que ser� inserido no grupo de inativos. 00318 * @return retorna PL_OK em caso de sucesso e PL_ERROR em caso de falha ou 00319 * erro. 00320 */ 00321 int InsertMemberInInactiveGroup( InfoClient *client ); 00322 00323 /*** 00324 * SwitchToLeader torna new_leader o novo l�der do grupo a que pertence. 00325 * O lider antigo perde a lideran�a e passa a ser simplesmente membro do grupo. 00326 * @param new_leader � o cliente que assumir� a lideran�a de seu grupo. 00327 * @return retorna PL_OK em caso de sucesso e PL_ERROR em caso de falha ou 00328 * erro. 00329 */ 00330 int SwitchToLeader( InfoClient *new_leader ); 00331 00332 /*** 00333 * SwitchToLeader torna new_subleader o novo subl�der do grupo a que pertence. 00334 * O sublider antigo perde a sublideran�a e passa a ser simplesmente membro 00335 * do grupo mas � inserido ap�s o subl�der na lista encadeada. 00336 * @param new_subleader � o cliente que assumir� a sublideran�a de seu grupo. 00337 * @return retorna PL_OK em caso de sucesso e PL_ERROR em caso de falha ou 00338 * erro. 00339 */ 00340 int SwitchToSubLeader( InfoClient *new_subleader ); 00341 00342 /*** 00343 * MergeGroups une os grupos masterGroup e slaveGroup em um s� inserindo os 00344 * membros de slaveGroup no grupo de masterGroup. O membro slaveGroup, antes 00345 * l�der, passa a ser subl�der do grupo masterGroup. 00346 * @param slaveGroup � o grupo que ser� acoplado ao final do grupo master. 00347 * @param masterGroup � o grupo que recebe os integrantes do grupo slave. 00348 * @return retorna PL_OK em caso de sucesso e PL_ERROR em caso de falha ou 00349 * erro. 00350 */ 00351 int MergeGroups( InfoClient *slaveGroup, 00352 InfoClient *masterGroup ); 00353 00354 /*** 00355 * SwitchToPassiveUser altera o papel do cliente client no sistema de forma que 00356 * ele passe a ser um cliente PASSIVE no grupo que faz parte. Se ele for um 00357 * LEADER ou SUBLEADER, o pr�ximo na lista ser� atribu�do como LEADER ou 00358 * SUBLEADER, respectivamente. Se cliente for submembro, ser� realocado na lista 00359 * de forma a ficar entre o subl�der e o l�der do grupo. 00360 * @param member cliente a ter seu modo alterado para PASSIVE. 00361 */ 00362 int SwitchToPassiveUser( InfoClient *new_leader ); 00363 00364 // int SwitchToUser( InfoClient *new_leader ); 00365 /*** 00366 * RemoveMember remove o cliente do grupo a que pertence, seja do grupo de 00367 * ativos ou do de inativos, ajustando os ponteiros de seus vizinhos da lista 00368 * encadeada, caso existam, coerentemente. Se member for l�der/subl�der, o 00369 * pr�ximo membro na lista herda a lideran�a/sublideran�a. O vetor 00370 * MulticastPortInfo � atualizado conforme as mudan�as exigirem que isto seja 00371 * feito. 00372 * Este m�todo n�o usa mutex para proteger as vari�veis e membros da classe 00373 * pois assume que isto j� � feito pelos m�todos/fun��es que o invocam. 00374 * Nota: A struct InfoClient member � removida dos grupos mas ainda 00375 * continua existindo; para elimin�-la h� que se usar o delete. 00376 * Ap�s removido de seu grupo, member fica com mode setado para UNAVAILABLE, 00377 * todos os ponteiros para outros mebros e grupos vizinhos s�o setados para 00378 * NULL, CurrentBlock � setado para -1 e target para INT_MAX. Caso member a ser 00379 * removido seja um subl�der, o pr�ximo na lista, se houver, ter� seu valor 00380 * "isPatching" setado para true e seu valor "target" para o atual "target" de 00381 * member. Os demais valores permanecem inalterados. 00382 * @param member � o membro que ser� removido do grupo que estiver presente, 00383 * seja ele de ativos ou de inativos. 00384 * @return retorna PL_OK em caso de sucesso e PL_ERROR em caso de falha ou 00385 * erro. 00386 */ 00387 int RemoveMember( InfoClient *member ); 00388 00389 /*** 00390 * InsertMemberBefore insere o membro member antes de o_member na lista 00391 * encadeada do grupo a que o_member pertence. Caso o_member seja lider deste 00392 * grupo, member assume a lideran�a no lugar de o_member. Caso o_member seja 00393 * subl�der, permanecer� subl�der. 00394 * Obs: Necessariamente, member n�o pode pertencer a nenhum grupo, pois este 00395 * m�todo N�O REMOVE o membro member de grupo algum! 00396 * @param member membro que ser� inserido na lista. 00397 * @param o_member membro que serve como refer�ncia para a inser��o do novo 00398 * membro. 00399 * @return retorna PL_OK em caso de sucesso e PL_ERROR em caso de falha ou 00400 * erro. 00401 */ 00402 int InsertMemberBefore( InfoClient *member, 00403 InfoClient *o_member ); 00404 00405 /*** 00406 * InsertMemberAfter insere o membro member depois de o_member na lista 00407 * encadeada do grupo a que o_member pertence. 00408 * Obs: Necessariamente, member n�o pode pertencer a nenhum grupo, pois este 00409 * m�todo N�O REMOVE o membro member de grupo algum! 00410 * @param member membro que ser� inserido na lista. 00411 * @param o_member membro que serve como refer�ncia para a inser��o do novo 00412 * membro. 00413 * @return retorna PL_OK em caso de sucesso e PL_ERROR em caso de falha ou 00414 * erro. 00415 */ 00416 int InsertMemberAfter( InfoClient *member, 00417 InfoClient *o_member ); 00418 00419 /*** 00420 * GetGroupLeader percorre o grupo a que member pertence em busca de 00421 * seu primeiro membro (que fica no in�cio da lista encadeada). Por defini��o, 00422 * o primeiro membro de um grupo � o l�der do mesmo. Antigamente este m�todo se 00423 * chamava GetFirstInGroup, mas optou-se por trocar o nome para GetGroupLeader 00424 * por ser mais intuitivo. 00425 * Nota: Se, ao ter passado pelo loop, GetGroupLeader retornar member_result 00426 * como NULL, significa que o grupo de member n�o tem l�der, isto �, � um 00427 * grupo em dissolu��o ou � a lista de clientes inativos. 00428 * @param member � um membro qualquer do grupo que se deseja obter o l�der. 00429 * @return retorna um ponteiro para o l�der do grupo de member ou NULL caso 00430 * member fa�a parte de um grupo sem l�der (em dissolu��o) ou esteja na lista 00431 * de inativos. 00432 */ 00433 InfoClient *GetGroupLeader( InfoClient *member ); 00434 00435 /*** 00436 * GetGroupLeader percorre o grupo a que member pertence em busca de 00437 * um subl�der, caso o mesmo exista. De in�cio a busca � feita do membro 00438 * member para frente e, caso o subl�der n�o seja encontrado, a busca � feita 00439 * de member para tr�s. Em ambos os casos, a busca para quando se ultrapassa �s 00440 * extremidades da lista encadeada do grupo de member. Caso n�o exista um 00441 * subl�der, este m�todo retorna NULL. 00442 * @param member � um membro qualquer do grupo que se deseja obter o subl�der. 00443 * @return retorna um ponteiro para o subl�der do grupo de member ou NULL caso 00444 * member fa�a parte de um grupo sem subl�der ou esteja na lista de inativos. 00445 */ 00446 InfoClient *GetGroupSubLeader( InfoClient *member ); 00447 00448 /*** 00449 * GetFirstInGroup retorna o primeiro membro do grupo que member faz parte. 00450 * @param member � um membro qualquer do grupo a ser pesquisado. 00451 * @param member � um membro qualquer do grupo que se deseja obter o primeiro 00452 * membro (na primeira posi��o da lista). 00453 * @return retorna um ponteiro para o primeiro membro do grupo de member ou 00454 * NULL em caso de erro. 00455 */ 00456 InfoClient *GetFirstInGroup( InfoClient *member ); 00457 00458 /*** 00459 * GetLastInGroup retorna o �ltimo membro do grupo que member faz parte. 00460 * Nota: o membro retornado pode ser um submembro pois GetLastInGroup() varre a 00461 * lista de membros at� a �ltima posi��o poss�vel. 00462 * @param member � um membro qualquer do grupo que se deseja obter o �ltimo 00463 * elemento. 00464 * @return retorna um ponteiro para o �ltimo membro do grupo de member ou NULL 00465 * em caso de erro. 00466 */ 00467 InfoClient *GetLastInGroup( InfoClient *member ); 00468 00469 /*** 00470 * isSubMember verifica se o cliente member � subMembro do grupo que faz parte, 00471 * isto �, se ele est� escutando o fluxo do subl�der do grupo. Isto significa, a 00472 * n�vel de implementa��o, que o cliente est� a partir do subl�der (inclusive) 00473 * na lista de membros de seu grupo. 00474 * @param member � o mebro do grupo que se quer descobrir se � ou n�o submembro. 00475 * @param subLeaderBlock ser� preenchido com o valor do membro CurrentBlock do 00476 * subl�der do grupo, caso exista. 00477 * @return Retorna true se member for submembro do grupo e false caso contr�rio. 00478 */ 00479 bool isSubMember( InfoClient *member, int *subLeaderBlock ); 00480 00481 void PrintLogFile(); 00482 00483 //Mutex handlers 00484 /*** 00485 * InfoClientMutexLock trava o mutex InfoClientMutex. 00486 * @param msg � usado apenas no modo RIO_DEBUG2 para facilitar depura��es de 00487 * clientes travados em mutex's. 00488 */ 00489 void InfoClientMutexLock( string msg = "" ); 00490 00491 /*** 00492 * InfoClientMutexUnlock destrava o mutex InfoClientMutex. 00493 * @param msg � usado apenas no modo RIO_DEBUG2 para facilitar depura��es de 00494 * clientes travados em mutex's. 00495 */ 00496 void InfoClientMutexUnlock( string msg = "" ); 00497 00498 /*** 00499 * MoveMutexLock trava o mutex MoveMutex. 00500 * @param msg � usado apenas no modo RIO_DEBUG2 para facilitar depura��es de 00501 * clientes travados em mutex's. 00502 */ 00503 void MoveMutexLock( string msg = "" ); 00504 00505 /*** 00506 * MoveMutexUnlock destrava o mutex MoveMutex. 00507 * @param msg � usado apenas no modo RIO_DEBUG2 para facilitar depura��es de 00508 * clientes travados em mutex's. 00509 */ 00510 void MoveMutexUnlock( string msg = "" ); 00511 00512 /*** 00513 * MulticastPortInfoMutexLock trava o mutex MulticastPortInfoMutex. 00514 * @param msg � usado apenas no modo RIO_DEBUG2 para facilitar depura��es de 00515 * clientes travados em mutex's. 00516 */ 00517 void MulticastPortInfoMutexLock( string msg = "" ); 00518 00519 /*** 00520 * MulticastPortInfoMutexUnlock destrava o mutex MulticastPortInfoMutex. 00521 * @param msg � usado apenas no modo RIO_DEBUG2 para facilitar depura��es de 00522 * clientes travados em mutex's. 00523 */ 00524 void MulticastPortInfoMutexUnlock( string msg = "" ); 00525 00526 private: 00527 CRioObject *ObjectRioServer; 00528 RioRequest *RequestRioServer; 00529 00530 unsigned next_group;/* Vector with data requests to RioServer*/ 00531 CRioTCP *m_TCPconnection; 00532 bool m_initialized; 00533 ofstream m_log; 00534 ofstream m_requestlog; 00535 pthread_t m_ConnectionThreadId; 00536 int m_DeltaAfter; 00537 int m_DeltaBefore; 00538 int m_inicial_multicast_port; 00539 int m_num_ports; 00540 char *m_MulticastIP; 00541 00542 #if defined(RIO_DEBUG2) || defined(RIO_EMUL) 00543 struct timeval time_list; 00544 struct timeval initial_time; 00545 struct timeval final_time; 00546 ofstream m_log_timer; 00547 #endif 00548 00549 int CleanUp(); 00550 static void *ConnectionThread( void * param ); 00551 static void *ClientThread( void * param ); 00552 int ReadConfiguration(); 00553 int CheckConfiguration(); 00554 void InitializeMulticastPortInfo(); 00555 00556 #if defined(RIO_DEBUG2) || defined(RIO_EMUL) 00557 void PrintClientInfo( InfoClient *Client ); 00558 void PrintClientTable(); 00559 #endif 00560 00561 /*** 00562 * ChangePIDPort atualiza o vetor de portas multicast. Cada porta armazena o 00563 * pid da thread (pid_t) do l�der da respectiva porta. Sempre que h� uma troca 00564 * de lideran�a/sublideran�a, este vetor deve ser atualizado. ChangePIDPort 00565 * varre o referido vetor at� encontrar o pid_t de actualLeader_pid e o 00566 * subsitui pelo pid_t de newLeader_pid. 00567 * @param actualLeader_pid pid do l�der atual. 00568 * @param newLeader_pid pid do novo l�der. 00569 */ 00570 void ChangePIDPort( pid_t actualleader_pid, 00571 pid_t newleader_pid ); 00572 /*** 00573 * ChooseMulticastPort varre MulticastPortInfo atr�s de uma posi��o livre para 00574 * aloc�-la para o cliente cujo pid foi fornecido como par�metro. Cada posi��o 00575 * livre deste vetor � uma porta multicast dispon�vel para novos grupos. 00576 * @param pid pid do cliente que ser� l�der deste novo grupo. 00577 * @return retorna a porta alocada para o grupo do cliente fornecido no 00578 * par�metro pid. 00579 */ 00580 int ChooseMulticastPort( pid_t pid ); 00581 00582 /*** 00583 * DischargeMulticastPort limpa a posi��o do vetor MulticastPortInfo ocupada 00584 * pelo cliente de pid_t pid (fornecido no par�metro). 00585 * Nota: V�rios clientes podem estar escutando a mesma porta, mas sempre haver� 00586 * um �nico respons�vel por cada porta (um l�der ou subl�der). 00587 */ 00588 void DischargeMulticastPort( pid_t pid ); 00589 00590 int ExecuteSessionManager( unsigned int Method, 00591 char* Parameter, 00592 unsigned int ParameterSize, 00593 char* Result, 00594 unsigned int *ResultSize, 00595 CRioSession *SessionRioServer, 00596 CRioStream *StreamRioServer, 00597 RioRequest* RequestRioServer); 00598 00599 int ExecuteStreamManager( unsigned int Method, 00600 char* Parameter, 00601 unsigned int ParameterSize, 00602 char* Result, 00603 unsigned int *ResultSize, 00604 CRioStream *StreamRioServer, 00605 CRioObject *ObjectRioServer, 00606 RioRequest *RequestRioServer, 00607 SOCKADDR_IN remoteaddress ); 00608 00609 int ExecuteRouter( unsigned int Method, char* Parameter, 00610 unsigned int ParameterSize, char* Result, 00611 unsigned int *ResultSize, 00612 CRioObject *ObjectRioServer, 00613 RioRequest* RequestRioServer, 00614 CRioSession* SessionRioServer, 00615 SOCKADDR_IN remoteAddress ); 00616 00617 int ExecuteObjectManager( unsigned int Method, 00618 char* Parameter, 00619 unsigned int ParameterSize, 00620 char* Result, 00621 unsigned int* ResultSize, 00622 CRioObject *ObjectRioServer ); 00623 00624 int ExecuteCall( unsigned int Class, unsigned int Method, 00625 char* Parameter, unsigned int ParameterSize, 00626 char* Result, unsigned int *ResultSize, 00627 CRioSession *SessionRioServer, 00628 CRioStream *StreamRioServer, 00629 CRioObject *ObjectRioServer, 00630 RioRequest* RequestRioServer, 00631 SOCKADDR_IN remoteAddress ); 00632 00633 void KillClientThread( CRioSession *SessionRioServer, 00634 CRioStream *StreamRioServer, 00635 CRioObject *ObjectRioServer, 00636 RioRequest *RequestRioServer ); 00637 00638 HRESULT OpenSessionRioServer( char *Server, char *UserName, 00639 char *Password, 00640 CRioSession *SessionRioServer, 00641 RioRequest* RequestRioServer); 00642 00643 HRESULT CloseSessionRioServer( CRioSession *SessionRioServer, 00644 unsigned int *ResultSize ); 00645 00646 int DeleteClient( pid_t PIDClientThread ); 00647 }; 00648 #endif //__PLSESSIONMANAGER_H_