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 // Event.cpp: declaration of CEvent and CEventQueue 00022 // Events are elements queued and processed by 00023 // StreamManager and Router threads 00024 /////////////////////////////////////////////////////////////////////////////// 00025 00026 #include <iostream> 00027 00028 #include "Event.h" 00029 #include "RioError.h" 00030 00031 using namespace std; 00032 00033 CEventManager::CEventManager() 00034 { 00035 m_VectorRTDataRequest = 0; 00036 // m_FreeRTDataRequest does not need to be initialized 00037 m_VectorNRTDataRequest = 0; 00038 // m_FreeNRTDataRequest does not need to be initialized 00039 m_VectorStorageRequest = 0; 00040 // m_FreeStorageRequest does not need to be initialized 00041 m_VectorStorageReply = 0; 00042 // m_FreeStorageReply does not need to be initialized 00043 m_VectorAddDisk = 0; 00044 // m_FreeAddDisk does not need to be initialized 00045 m_VectorTimeOut = NULL; 00046 // m_FreeTimeOut does not need to be initialized 00047 // Novos eventos para tratar da queda/reinicio dos servidores de 00048 // armazenamento. 00049 m_VectorStorageDown = NULL; 00050 // m_FreeStorageDown does not need to be initialized 00051 m_VectorStorageDown = NULL; 00052 // m_FreeStorageUp does not need to be initialized 00053 m_VectorFinalizeThread = NULL; 00054 // m_FreeFinalizeRouter does not need to be initialized 00055 } 00056 00057 00058 /////////////////////////////////////////////////////////////////////////////// 00059 CEventManager::~CEventManager() 00060 { 00061 if( m_VectorRTDataRequest != 0 ) delete[] m_VectorRTDataRequest; 00062 if( m_VectorNRTDataRequest != 0 ) delete[] m_VectorNRTDataRequest; 00063 if( m_VectorStorageRequest != 0 ) delete[] m_VectorStorageRequest; 00064 if( m_VectorStorageReply != 0 ) delete[] m_VectorStorageReply; 00065 if( m_VectorAddDisk != 0 ) delete[] m_VectorAddDisk; 00066 // Novos eventos para tratar da queda/reinicio dos servidores de 00067 // armazenamento. 00068 if( m_VectorStorageDown != 0 ) delete[] m_VectorStorageDown; 00069 if( m_VectorStorageUp != 0 ) delete[] m_VectorStorageUp; 00070 // Novo evento para finalizar as threads (que usem uma fila). 00071 if( m_VectorFinalizeThread != 0 ) delete[] m_VectorFinalizeThread; 00072 } 00073 00074 /////////////////////////////////////////////////////////////////////////////// 00075 // Initialize: Initialize free list for a given event type with a given 00076 // number of available elements. This must be called at least 00077 // once for each event type, before asking for a new element 00078 // of that type 00079 int CEventManager::Initialize( EventType Type, int n ) 00080 { 00081 int i; 00082 00083 switch( Type ) 00084 { 00085 case EventTypeRTDataRequest: 00086 if( m_VectorRTDataRequest != 0 ) delete[] m_VectorRTDataRequest; 00087 m_VectorRTDataRequest = new EventDataRequest[n]; 00088 if( m_VectorRTDataRequest == 0 ) 00089 { 00090 RioErr << "CEventManager::Initialize(): Failed to allocate space " 00091 << " for EventDataRequest free list (Out of memory)" 00092 << endl; 00093 return (ERROR_EVENT + ERROR_MEMORY); 00094 } 00095 for( i = 0; i < n; i++ ) 00096 { 00097 m_VectorRTDataRequest[i].Header.Type = EventTypeRTDataRequest; 00098 m_FreeRTDataRequest.Put( (Event*) &m_VectorRTDataRequest[i] ); 00099 } 00100 break; 00101 00102 case EventTypeNRTDataRequest: 00103 if( m_VectorNRTDataRequest != 0 ) delete[] m_VectorNRTDataRequest; 00104 m_VectorNRTDataRequest = new EventDataRequest[n]; 00105 if( m_VectorNRTDataRequest == 0 ) 00106 { 00107 RioErr << "CEventManager::Initialize(): Failed to allocate space " 00108 << " for EventDataRequest free list (Out of memory)" 00109 << endl; 00110 return (ERROR_EVENT + ERROR_MEMORY); 00111 } 00112 for( i = 0; i < n; i++ ) 00113 { 00114 m_VectorNRTDataRequest[i].Header.Type = EventTypeNRTDataRequest; 00115 m_FreeNRTDataRequest.Put( (Event*) &m_VectorNRTDataRequest[i] ); 00116 } 00117 break; 00118 00119 case EventTypeStorageRequest: 00120 if( m_VectorStorageRequest != 0 ) delete[] m_VectorStorageRequest; 00121 m_VectorStorageRequest = new EventStorageRequest[n]; 00122 if( m_VectorStorageRequest == 0 ) 00123 { 00124 RioErr << "CEventManager::Initialize(): Failed to allocate space " 00125 << " for EventStorageRequest free list (Out of memory)" 00126 << endl; 00127 return ( ERROR_EVENT + ERROR_MEMORY ); 00128 } 00129 for( i = 0; i < n; i++ ) 00130 { 00131 m_VectorStorageRequest[i].Header.Type = EventTypeStorageRequest; 00132 m_VectorStorageRequest[i].StorageRequest.Header.Type = MSG_RSS_NODEINFO_REQ; 00133 m_VectorStorageRequest[i].StorageRequest.Header.Size = SizeMsgRSSnodeInfoReq; 00134 00135 m_FreeStorageRequest.Put( (Event*) &m_VectorStorageRequest[i] ); 00136 } 00137 break; 00138 00139 case EventTypeStorageReply: 00140 if( m_VectorStorageReply != 0 ) delete[] m_VectorStorageReply; 00141 m_VectorStorageReply = new EventStorageReply[n]; 00142 if( m_VectorStorageReply == 0 ) 00143 { 00144 RioErr << "CEventManager::Initialize(): Failed to allocate space " 00145 << " for EventStorageReply free list (Out of memory)" 00146 << endl; 00147 return ( ERROR_EVENT + ERROR_MEMORY ); 00148 } 00149 for( i = 0; i < n; i++ ) 00150 { 00151 m_VectorStorageReply[i].Header.Type = EventTypeStorageReply; 00152 m_FreeStorageReply.Put( (Event*) &m_VectorStorageReply[i] ); 00153 } 00154 break; 00155 00156 case EventTypeAddDisk: 00157 if( m_VectorAddDisk != 0 ) delete[] m_VectorAddDisk; 00158 m_VectorAddDisk = new EventAddDisk[n]; 00159 if( m_VectorAddDisk == 0 ) 00160 { 00161 RioErr << "CEventManager::Initialize(): Failed to allocate space " 00162 << " for EventAddDisk free list (Out of memory)" << endl; 00163 return ( ERROR_EVENT + ERROR_MEMORY ); 00164 } 00165 for( i = 0; i < n; i++ ) 00166 { 00167 m_VectorAddDisk[i].Header.Type = EventTypeAddDisk; 00168 m_FreeAddDisk.Put( (Event*) &m_VectorAddDisk[i] ); 00169 } 00170 break; 00171 00172 case EventTypeTimeOut: 00173 if( m_VectorTimeOut != 0 ) 00174 delete[] m_VectorTimeOut; 00175 m_VectorTimeOut = new EventTimeOut[n]; 00176 if( m_VectorTimeOut == 0 ) 00177 { 00178 RioErr << "CEventManager::Initialize(): Failed to allocate space " 00179 << " for EventTimeOut free list (Out of memory)" << endl; 00180 return ( ERROR_EVENT + ERROR_MEMORY ); 00181 } 00182 for( i = 0; i < n; i++ ) 00183 { 00184 m_VectorTimeOut[i].Header.Type = EventTypeTimeOut; 00185 m_FreeTimeOut.Put( (Event*) &m_VectorTimeOut[i] ); 00186 } 00187 break; 00188 // Novos eventos para tratar da queda/reinicio dos servidores de 00189 // armazenamento. 00190 // Evento gerado quando detectamos que um servidor de armazenamento 00191 // parou de funcionar. 00192 case EventTypeStorageDown: 00193 if( m_VectorStorageDown != 0 ) 00194 delete[] m_VectorStorageDown; 00195 m_VectorStorageDown = new EventStorageDown[ n ]; 00196 if( m_VectorStorageDown == 0 ) 00197 { 00198 RioErr << "CEventManager::Initialize(): Failed to allocate " 00199 << "space for EventStorageDown free list (Out of memory)" 00200 << endl; 00201 return ( ERROR_EVENT + ERROR_MEMORY ); 00202 } 00203 for( i = 0; i < n; i++ ) 00204 { 00205 m_VectorStorageDown[ i ].Header.Type = EventTypeStorageDown; 00206 m_FreeStorageDown.Put( (Event*) &m_VectorStorageDown[ i ] ); 00207 } 00208 break; 00209 // Evento gerado quando conseguimos restabelecer, com sucesso, uma 00210 // conexao com um servidor de armazenamento que tinha parado de 00211 // funcionar. 00212 case EventTypeStorageUp: 00213 if( m_VectorStorageUp != 0 ) 00214 delete[] m_VectorStorageUp; 00215 m_VectorStorageUp = new EventStorageUp[ n ]; 00216 if( m_VectorStorageUp == 0 ) 00217 { 00218 RioErr << "CEventManager::Initialize(): Failed to allocate " 00219 << "space for EventStorageUp free list (Out of memory)" 00220 << endl; 00221 return ( ERROR_EVENT + ERROR_MEMORY ); 00222 } 00223 for( i = 0; i < n; i++ ) 00224 { 00225 m_VectorStorageUp[ i ].Header.Type = EventTypeStorageUp; 00226 m_FreeStorageUp.Put( (Event*) &m_VectorStorageUp[ i ] ); 00227 } 00228 break; 00229 // Novo evento para finalizar uma thread que use uma fila. 00230 case EventTypeFinalizeThread: 00231 if( m_VectorFinalizeThread != 0 ) 00232 delete[] m_VectorFinalizeThread; 00233 m_VectorFinalizeThread = new EventFinalizeThread[ n ]; 00234 if( m_VectorFinalizeThread == 0 ) 00235 { 00236 RioErr << "CEventManager::Initialize(): Failed to allocate " 00237 << "space for EventFinalizeThread free list (Out of " 00238 << "memory)" << endl; 00239 return ( ERROR_EVENT + ERROR_MEMORY ); 00240 } 00241 for( i = 0; i < n; i++ ) 00242 { 00243 m_VectorFinalizeThread[ i ].Header.Type = 00244 EventTypeFinalizeThread; 00245 m_FreeFinalizeThread.Put( ( Event* ) 00246 &m_VectorFinalizeThread[ i ] ); 00247 } 00248 break; 00249 00250 default: 00251 RioErr << "CEventManager::Initialize(): Invalid Event Type: " 00252 << (unsigned int) Type << endl; 00253 return ( ERROR_EVENT + ERROR_INVALID_PARAM ); 00254 } 00255 00256 return 0; 00257 } 00258 00259 /////////////////////////////////////////////////////////////////////////////// 00260 // New: Get a new event of a given type from the corresponding free list 00261 Event* CEventManager::New( EventType Type ) 00262 { 00263 switch( Type ) 00264 { 00265 case EventTypeRTDataRequest: 00266 return ( m_FreeRTDataRequest.Get() ); 00267 case EventTypeNRTDataRequest: 00268 return ( m_FreeNRTDataRequest.Get() ); 00269 case EventTypeStorageRequest: 00270 return ( m_FreeStorageRequest.Get() ); 00271 case EventTypeStorageReply: 00272 return ( m_FreeStorageReply.Get() ); 00273 case EventTypeAddDisk: 00274 return ( m_FreeAddDisk.Get() ); 00275 case EventTypeTimeOut: 00276 return ( m_FreeTimeOut.Get() ); 00277 // Novos eventos para tratar da queda/reinicio dos servidores de 00278 // armazenamento. 00279 // Evento gerado quando detectamos que um servidor de armazenamento 00280 // parou de funcionar. 00281 case EventTypeStorageDown: 00282 return ( m_FreeStorageDown.Get() ); 00283 // Evento gerado quando conseguimos restabelecer, com sucesso, uma 00284 // conexao com um servidor de armazenamento que tinha parado de 00285 // funcionar. 00286 case EventTypeStorageUp: 00287 return ( m_FreeStorageUp.Get() ); 00288 // Novo evento para finalizar uma thread que use uma fila. 00289 case EventTypeFinalizeThread: 00290 return ( m_FreeFinalizeThread.Get() ); 00291 00292 default: 00293 RioErr << "CEventManager::New(): Invalid Event Type: " 00294 << (unsigned int) Type << endl; 00295 return 0; 00296 } 00297 } 00298 00299 /////////////////////////////////////////////////////////////////////////////// 00300 // New: Return a event element of a given type to the corresponding free list 00301 void CEventManager::Free ( Event *event ) 00302 { 00303 switch( event->Type ) 00304 { 00305 case EventTypeRTDataRequest: 00306 m_FreeRTDataRequest.Put( event ); 00307 break; 00308 case EventTypeNRTDataRequest: 00309 m_FreeNRTDataRequest.Put( event ); 00310 break; 00311 case EventTypeStorageRequest: 00312 m_FreeStorageRequest.Put( event ); 00313 break; 00314 case EventTypeStorageReply: 00315 m_FreeStorageReply.Put( event ); 00316 break; 00317 case EventTypeAddDisk: 00318 m_FreeAddDisk.Put( event ); 00319 break; 00320 case EventTypeTimeOut: 00321 m_FreeAddDisk.Put( event ); 00322 break; 00323 // Novos eventos para tratar da queda/reinicio dos servidores de 00324 // armazenamento. 00325 // Evento gerado quando detectamos que um servidor de armazenamento 00326 // parou de funcionar. 00327 case EventTypeStorageDown: 00328 m_FreeStorageDown.Put( event ); 00329 break; 00330 // Evento gerado quando conseguimos restabelecer, com sucesso, uma 00331 // conexao com um servidor de armazenamento que tinha parado de 00332 // funcionar. 00333 case EventTypeStorageUp: 00334 m_FreeStorageUp.Put( event ); 00335 break; 00336 // Novo evento para finalizar uma thread que use uma fila. 00337 case EventTypeFinalizeThread: 00338 m_FreeFinalizeThread.Put( event ); 00339 break; 00340 00341 default: 00342 RioErr << "CEventManager::Free(): Invalid Event Type: " 00343 << ( unsigned int ) event->Type << endl; 00344 break; 00345 } 00346 } 00347