MonitorTable Class Reference

#include <MonitorTable.h>

Public Member Functions
	MonitorTable ()
void	getData (vector< ClientData > &clientTable, vector< StorageData > &storageTable)
void	putMonitorEvent (MonitorEvent *event)
void	Monitor ()
void	Stop ()
	Nova funcao para parar a thread de monitoramento.
Private Attributes
vector< ClientData >	client_data
vector< StorageData >	storage_data
queue< MonitorEvent * >	event_queue
pthread_mutex_t	table_access
sem_t	event_queue_semaphore
bool	stopThread

---

Detailed Description

Definition at line 136 of file MonitorTable.h.

---

Constructor & Destructor Documentation

MonitorTable::MonitorTable

(

)

Definition at line 204 of file MonitorTable.cpp.

{
    pthread_mutex_init( &table_access, NULL );
    sem_init( &event_queue_semaphore, 0, 0 );
    // Inicializa a variavel que informa se a thread de monitoramento deve ser
    // finalizada.
    stopThread = false;
}

---

Member Function Documentation

void MonitorTable::getData	(	vector< ClientData > &	clientTable,
		vector< StorageData > &	storageTable
	)

Definition at line 213 of file MonitorTable.cpp.

{
    pthread_mutex_lock( &table_access );
    clientTable.insert( clientTable.begin(), client_data.begin(), client_data.end() );
    storageTable.insert( storageTable.begin(), storage_data.begin(), storage_data.end() );
    pthread_mutex_unlock( &table_access );
}

void MonitorTable::Monitor

(

)

Definition at line 230 of file MonitorTable.cpp.

{

    RioErr << "MONITORTHREADID " << syscall( SYS_gettid ) << endl;
    
    while( true )
    {
        sem_wait( &event_queue_semaphore );
        pthread_mutex_lock( &table_access );

        // Verifica se devemos terminar a thread.
        if( stopThread )
        {
            RioErr << "MonitorTable::Monitor thread terminada!" << endl;
            pthread_mutex_unlock( &table_access );
            pthread_exit( NULL );
            
        }
        if( event_queue.empty() )
        {
            pthread_mutex_unlock( &table_access );
            continue;
        }
        
        MonitorEvent *event = event_queue.front();
        switch( event->getType() )
        {
            case CLIENT_LIST_EVENT + CONNECT_EVENT:
            {
                ConnectEvent *c_event = (ConnectEvent *)event;
                ClientData data;
                data.m_ip = c_event->getIP();
                data.m_port = c_event->getPort();
                data.m_video = c_event->getVideo();
                time( &(data.m_time) );
                data.m_queue = 0;
                client_data.push_back( data );
                break;
            }
            case CLIENT_LIST_EVENT + UPDATE_QUEUE_EVENT:
            {
                UpdateQueueEvent *uq_event = (UpdateQueueEvent *)event;
                vector<ClientData>::iterator it;
                for( it = client_data.begin(); it != client_data.end(); it++ )
                {
                    if( (*it).m_ip != uq_event->getIP() )
                        continue;
                    if( (*it).m_port != uq_event->getPort() )
                        continue;
                    (*it).m_queue = uq_event->getQueue();
                }
                break;
            }
            case CLIENT_LIST_EVENT + DISCONNECT_EVENT:
            {
                DisconnectEvent *d_event = (DisconnectEvent *)event;
                vector<ClientData>::iterator it;
                for( it = client_data.begin(); it != client_data.end(); it++ )
                {
                    if( (*it).m_ip != d_event->getIP() )
                        continue;
                    if( (*it).m_port != d_event->getPort() )
                        continue;
                    if( (*it).m_video != d_event->getVideo() )
                        continue;
                    client_data.erase( it );
                    it--;
                    break;
                }
                break;
            }
            case STORAGE_LIST_EVENT + ADD_NODE_EVENT:
            {
                AddNodeEvent *an_event = (AddNodeEvent *)event;
                StorageData data;
                data.m_hostname = an_event->getHostName();
                data.m_ip = an_event->getIP();
                data.m_diskname = ALL_DISKS;
                data.m_queue = 0;
                storage_data.push_back( data );
                break;
            }
            case STORAGE_LIST_EVENT + ADD_DISK_EVENT:
            {
                AddDiskEvent *ad_event = (AddDiskEvent *)event;
                vector<StorageData>::iterator it;
                for( it = storage_data.begin(); it != storage_data.end(); it++ )
                {
                    if( (*it).m_hostname == ad_event->getHostName() )
                    {
                        StorageData data;
                        data.m_ip = "";
                        data.m_hostname = ad_event->getHostName();
                        data.m_diskname = ad_event->getDiskName();
                        data.m_queue = 0;

                        it++;
                        storage_data.insert( it, data );
                        break;
                    }
                }
                break;
            }
            case STORAGE_LIST_EVENT + UPDATE_DISK_QUEUE_EVENT:
            {
                UpdateDiskQueueEvent *udq_event = (UpdateDiskQueueEvent *)event;
                vector<StorageData>::iterator it, disk_it;
                for( it = storage_data.begin(); it != storage_data.end(); it++ )
                {
                    if( (*it).m_hostname == udq_event->getHostName() )
                        break;
                }
                (*it).m_queue = 0;
                for( disk_it = it + 1; disk_it != storage_data.end(); disk_it++ )
                {
                    if( (*disk_it).m_hostname != udq_event->getHostName() )
                        break;

                    if( (*disk_it).m_diskname == udq_event->getDiskName() )
                        (*disk_it).m_queue = udq_event->getQueue();

                    (*it).m_queue += (*disk_it).m_queue;
                }
                break;
            }
        }
        event_queue.pop();
        delete event;
        pthread_mutex_unlock( &table_access );  
    }
}

void MonitorTable::putMonitorEvent

(

MonitorEvent *

event

)

Definition at line 222 of file MonitorTable.cpp.

{
    pthread_mutex_lock( &table_access );
    event_queue.push( event );
    sem_post( &event_queue_semaphore );
    pthread_mutex_unlock( &table_access );
}

void MonitorTable::Stop

(

void

)

Nova funcao para parar a thread de monitoramento.

Definition at line 363 of file MonitorTable.cpp.

{
    pthread_mutex_lock( &table_access );
    // Informa que a thread deve ser finalizada.
    stopThread = true;
    // Desbloquea a thread caso ela esteja bloqueada no semaforo.
    sem_post( &event_queue_semaphore );
    pthread_mutex_unlock( &table_access );
}

---

Field Documentation

vector<ClientData> MonitorTable::client_data [private]

Definition at line 138 of file MonitorTable.h.

queue<MonitorEvent *> MonitorTable::event_queue [private]

Definition at line 140 of file MonitorTable.h.

sem_t MonitorTable::event_queue_semaphore [private]

Definition at line 143 of file MonitorTable.h.

bool MonitorTable::stopThread [private]

Definition at line 145 of file MonitorTable.h.

vector<StorageData> MonitorTable::storage_data [private]

Definition at line 139 of file MonitorTable.h.

pthread_mutex_t MonitorTable::table_access [private]

Definition at line 142 of file MonitorTable.h.

---

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

• MonitorTable.h
• MonitorTable.cpp