(file) Return to Monitor.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Monitor.cpp between version 1.72.2.2 and 1.82

version 1.72.2.2, 2004/08/07 21:01:29 version 1.82, 2004/12/15 14:12:42
Line 1 
Line 1 
 //%2003////////////////////////////////////////////////////////////////////////  //%2004////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
 // IBM Corp.; EMC Corporation, The Open Group. // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 27 
Line 29 
 // //
 // Modified By: Mike Day (monitor_2) mdday@us.ibm.com // Modified By: Mike Day (monitor_2) mdday@us.ibm.com
 //              Amit K Arora (Bug#1153) amita@in.ibm.com //              Amit K Arora (Bug#1153) amita@in.ibm.com
   //              Alagaraja Ramasubramanian (alags_raj@in.ibm.com) for Bug#1090
   //              Sushma Fernandes (sushma@hp.com) for Bug#2057
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 102 
Line 106 
      _async(false),      _async(false),
      _stopConnections(0),      _stopConnections(0),
      _stopConnectionsSem(0),      _stopConnectionsSem(0),
      _solicitSocketCount(0)       _solicitSocketCount(0),
        _tickle_client_socket(-1),
        _tickle_server_socket(-1),
        _tickle_peer_socket(-1)
 { {
     int numberOfMonitorEntriesToAllocate = MAX_NUMBER_OF_MONITOR_ENTRIES;     int numberOfMonitorEntriesToAllocate = MAX_NUMBER_OF_MONITOR_ENTRIES;
     Socket::initializeInterface();     Socket::initializeInterface();
Line 128 
Line 135 
      _async(async),      _async(async),
      _stopConnections(0),      _stopConnections(0),
      _stopConnectionsSem(0),      _stopConnectionsSem(0),
      _solicitSocketCount(0)       _solicitSocketCount(0),
        _tickle_client_socket(-1),
        _tickle_server_socket(-1),
        _tickle_peer_socket(-1)
 { {
     int numberOfMonitorEntriesToAllocate = MAX_NUMBER_OF_MONITOR_ENTRIES;     int numberOfMonitorEntriesToAllocate = MAX_NUMBER_OF_MONITOR_ENTRIES;
     Socket::initializeInterface();     Socket::initializeInterface();
Line 162 
Line 172 
     Tracer::trace(TRC_HTTP, Tracer::LEVEL4, "deleting rep");     Tracer::trace(TRC_HTTP, Tracer::LEVEL4, "deleting rep");
  
     Tracer::trace(TRC_HTTP, Tracer::LEVEL4, "uninitializing interface");     Tracer::trace(TRC_HTTP, Tracer::LEVEL4, "uninitializing interface");
   
       try{
           if(_tickle_peer_socket >= 0)
           {
               Socket::close(_tickle_peer_socket);
           }
           if(_tickle_client_socket >= 0)
           {
               Socket::close(_tickle_client_socket);
           }
           if(_tickle_server_socket >= 0)
           {
               Socket::close(_tickle_server_socket);
           }
       }
       catch(...)
       {
           Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
                     "Failed to close tickle sockets");
       }
   
     Socket::uninitializeInterface();     Socket::uninitializeInterface();
     Tracer::trace(TRC_HTTP, Tracer::LEVEL4,     Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
                   "returning from monitor destructor");                   "returning from monitor destructor");
Line 179 
Line 210 
     // get a socket for the server side     // get a socket for the server side
     if((_tickle_server_socket = ::socket(PF_INET, SOCK_STREAM, 0)) < 0){     if((_tickle_server_socket = ::socket(PF_INET, SOCK_STREAM, 0)) < 0){
         //handle error         //handle error
         throw Exception("Monitor::initializeTickler(), create socket failed on tickle server.");          MessageLoaderParms parms("Common.Monitor.TICKLE_CREATE",
                                    "Received error number $0 while creating the internal socket.",
   #if !defined(PEGASUS_OS_TYPE_WINDOWS)
                                    errno);
   #else
                                    WSAGetLastError());
   #endif
           throw Exception(parms);
     }     }
  
     // initialize the address     // initialize the address
Line 201 
Line 239 
     PEGASUS_SOCKLEN_SIZE _addr_size = sizeof(_tickle_server_addr);     PEGASUS_SOCKLEN_SIZE _addr_size = sizeof(_tickle_server_addr);
  
     // bind server side to socket     // bind server side to socket
     if((::bind(_tickle_server_socket,(struct sockaddr *)&_tickle_server_addr, sizeof(_tickle_server_addr))) < 0){      if((::bind(_tickle_server_socket,
                  (struct sockaddr *)&_tickle_server_addr,
                  sizeof(_tickle_server_addr))) < 0){
         // handle error         // handle error
         throw Exception("Monitor::initializeTickler(), bind failed on tickle server socket.");          MessageLoaderParms parms("Common.Monitor.TICKLE_BIND",
                                    "Received error number $0 while binding the internal socket.",
   #if !defined(PEGASUS_OS_TYPE_WINDOWS)
                                    errno);
   #else
                                    WSAGetLastError());
   #endif
           throw Exception(parms);
     }     }
  
     // tell the kernel we are a server     // tell the kernel we are a server
     if((::listen(_tickle_server_socket,3)) < 0){     if((::listen(_tickle_server_socket,3)) < 0){
         // handle error         // handle error
         throw Exception("Monitor::initializeTickler(), listen failed on tickle server socket");          MessageLoaderParms parms("Common.Monitor.TICKLE_LISTEN",
                            "Received error number $0 while listening to the internal socket.",
   #if !defined(PEGASUS_OS_TYPE_WINDOWS)
                                    errno);
   #else
                                    WSAGetLastError());
   #endif
           throw Exception(parms);
     }     }
  
     // make sure we have the correct socket for our server     // make sure we have the correct socket for our server
     int sock = ::getsockname(_tickle_server_socket,(struct sockaddr*)&_tickle_server_addr, &_addr_size);      int sock = ::getsockname(_tickle_server_socket,
                                (struct sockaddr*)&_tickle_server_addr,
                                &_addr_size);
     if(sock < 0){     if(sock < 0){
         // handle error         // handle error
         throw Exception("Monitor::initializeTickler(), getsockname failed on tickle server socket");          MessageLoaderParms parms("Common.Monitor.TICKLE_SOCKNAME",
                            "Received error number $0 while getting the internal socket name.",
   #if !defined(PEGASUS_OS_TYPE_WINDOWS)
                                    errno);
   #else
                                    WSAGetLastError());
   #endif
           throw Exception(parms);
     }     }
  
     /* set up the tickle client/connector */     /* set up the tickle client/connector */
Line 224 
Line 287 
     // get a socket for our tickle client     // get a socket for our tickle client
     if((_tickle_client_socket = ::socket(PF_INET, SOCK_STREAM, 0)) < 0){     if((_tickle_client_socket = ::socket(PF_INET, SOCK_STREAM, 0)) < 0){
         // handle error         // handle error
         throw Exception("Monitor::initializeTickler(), create socket failed on tickle client.");          MessageLoaderParms parms("Common.Monitor.TICKLE_CLIENT_CREATE",
                            "Received error number $0 while creating the internal client socket.",
   #if !defined(PEGASUS_OS_TYPE_WINDOWS)
                                    errno);
   #else
                                    WSAGetLastError());
   #endif
           throw Exception(parms);
     }     }
  
     // setup the address of the client     // setup the address of the client
Line 244 
Line 314 
     _tickle_client_addr.sin_port = 0;     _tickle_client_addr.sin_port = 0;
  
     // bind socket to client side     // bind socket to client side
     if((::bind(_tickle_client_socket,(struct sockaddr*)&_tickle_client_addr, sizeof(_tickle_client_addr))) < 0){      if((::bind(_tickle_client_socket,
                  (struct sockaddr*)&_tickle_client_addr,
                  sizeof(_tickle_client_addr))) < 0){
         // handle error         // handle error
         throw Exception("Monitor::initializeTickler(), bind failed on tickle client socket.");          MessageLoaderParms parms("Common.Monitor.TICKLE_CLIENT_BIND",
                            "Received error number $0 while binding the internal client socket.",
   #if !defined(PEGASUS_OS_TYPE_WINDOWS)
                                    errno);
   #else
                                    WSAGetLastError());
   #endif
           throw Exception(parms);
     }     }
  
     // connect to server side     // connect to server side
     if((::connect(_tickle_client_socket,(struct sockaddr*)&_tickle_server_addr, sizeof(_tickle_server_addr))) < 0){      if((::connect(_tickle_client_socket,
                     (struct sockaddr*)&_tickle_server_addr,
                     sizeof(_tickle_server_addr))) < 0){
         // handle error         // handle error
         throw Exception("Monitor::initializeTickler(), connect failed between tickle client and tickle server.");          MessageLoaderParms parms("Common.Monitor.TICKLE_CLIENT_CONNECT",
                            "Received error number $0 while connecting the internal client socket.",
   #if !defined(PEGASUS_OS_TYPE_WINDOWS)
                                    errno);
   #else
                                    WSAGetLastError());
   #endif
           throw Exception(parms);
     }     }
  
     /* set up the slave connection */     /* set up the slave connection */
Line 261 
Line 349 
     pegasus_sleep(1);     pegasus_sleep(1);
  
     // this call may fail, we will try a max of 20 times to establish this peer connection     // this call may fail, we will try a max of 20 times to establish this peer connection
     if((_tickle_peer_socket = ::accept(_tickle_server_socket,(struct sockaddr*)&_tickle_peer_addr, &peer_size)) < 0){      if((_tickle_peer_socket = ::accept(_tickle_server_socket,
                                          (struct sockaddr*)&_tickle_peer_addr,
                                          &peer_size)) < 0){
   #if !defined(PEGASUS_OS_TYPE_WINDOWS)
           // Only retry on non-windows platforms.
         if(_tickle_peer_socket == -1 && errno == EAGAIN)         if(_tickle_peer_socket == -1 && errno == EAGAIN)
         {         {
           int retries = 0;           int retries = 0;
           do           do
           {           {
             pegasus_sleep(1);             pegasus_sleep(1);
             _tickle_peer_socket = ::accept(_tickle_server_socket,(struct sockaddr*)&_tickle_peer_addr, &peer_size);              _tickle_peer_socket = ::accept(_tickle_server_socket,
                                              (struct sockaddr*)&_tickle_peer_addr,
                                              &peer_size);
             retries++;             retries++;
           } while(_tickle_peer_socket == -1 && errno == EAGAIN && retries < 20);           } while(_tickle_peer_socket == -1 && errno == EAGAIN && retries < 20);
         }         }
   #endif
     }     }
     if(_tickle_peer_socket == -1){     if(_tickle_peer_socket == -1){
         // handle error         // handle error
         throw Exception("Monitor::initializeTickler(), accept failed, peer socket connection not established.");          MessageLoaderParms parms("Common.Monitor.TICKLE_ACCEPT",
                            "Received error number $0 while accepting the internal socket connection.",
   #if !defined(PEGASUS_OS_TYPE_WINDOWS)
                                    errno);
   #else
                                    WSAGetLastError());
   #endif
           throw Exception(parms);
     }     }
     // add the tickler to the list of entries to be monitored and set to IDLE because Monitor only     // add the tickler to the list of entries to be monitored and set to IDLE because Monitor only
     // checks entries with IDLE state for events     // checks entries with IDLE state for events
Line 291 
Line 393 
       '0','0'       '0','0'
     };     };
  
       AutoMutex autoMutex(_tickle_mutex);
   Socket::disableBlocking(_tickle_client_socket);   Socket::disableBlocking(_tickle_client_socket);
   Socket::write(_tickle_client_socket,&_buffer, 2);   Socket::write(_tickle_client_socket,&_buffer, 2);
   Socket::enableBlocking(_tickle_client_socket);   Socket::enableBlocking(_tickle_client_socket);
 } }
  
   void Monitor::setState( Uint32 index, _MonitorEntry::entry_status status )
   {
       // Set the state to requested state
       _entries[index]._status = status;
   }
   
 Boolean Monitor::run(Uint32 milliseconds) Boolean Monitor::run(Uint32 milliseconds)
 { {
  
     Boolean handled_events = false;     Boolean handled_events = false;
      int i = 0;      int i = 0;
    // #if defined(PEGASUS_OS_OS400) || defined(PEGASUS_OS_HPUX)  
     struct timeval tv = {milliseconds/1000, milliseconds%1000*1000};     struct timeval tv = {milliseconds/1000, milliseconds%1000*1000};
 //#else  
   //  struct timeval tv = {0, 1};  
 //#endif  
     fd_set fdread;     fd_set fdread;
     FD_ZERO(&fdread);     FD_ZERO(&fdread);
   
     _entry_mut.lock(pegasus_thread_self());     _entry_mut.lock(pegasus_thread_self());
  
     // Check the stopConnections flag.  If set, clear the Acceptor monitor entries     // Check the stopConnections flag.  If set, clear the Acceptor monitor entries
Line 339 
Line 447 
  
     for( int indx = 0; indx < (int)_entries.size(); indx++)     for( int indx = 0; indx < (int)_entries.size(); indx++)
     {     {
        if ((_entries[indx]._status.value() == _MonitorEntry::DYING) &&                           const _MonitorEntry &entry = _entries[indx];
                 (_entries[indx]._type == Monitor::CONNECTION))         if ((entry._status.value() == _MonitorEntry::DYING) &&
                                            (entry._type == Monitor::CONNECTION))
        {        {
           MessageQueue *q = MessageQueue::lookup(_entries[indx].queueId);            MessageQueue *q = MessageQueue::lookup(entry.queueId);
           PEGASUS_ASSERT(q != 0);           PEGASUS_ASSERT(q != 0);
           MessageQueue & o = static_cast<HTTPConnection *>(q)->get_owner();            HTTPConnection &h = *static_cast<HTTPConnection *>(q);
           Message* message= new CloseConnectionMessage(_entries[indx].socket);  
                                           if (h._connectionClosePending == false)
                                                   continue;
   
                                           // NOTE: do not attempt to delete while there are pending responses
                                           // coming thru. The last response to come thru after a
                                           // _connectionClosePending will reset _responsePending to false
                                           // and then cause the monitor to rerun this code and clean up.
                                           // (see HTTPConnection.cpp)
   
                                           if (h._responsePending == true)
                                           {
                                                   Tracer::trace(TRC_HTTP, Tracer::LEVEL4, "Monitor::run - "
                                                                                                           "Ignoring connection delete request because "
                                                                                                           "responses are still pending. "
                                                                                                           "connection=0x%p, socket=%d\n",
                                                                                                           (void *)&h, h.getSocket());
                                                   continue;
                                           }
                                           h._connectionClosePending = false;
             MessageQueue &o = h.get_owner();
             Message* message= new CloseConnectionMessage(entry.socket);
           message->dest = o.getQueueId();           message->dest = o.getQueueId();
  
           // HTTPAcceptor is responsible for closing the connection.           // HTTPAcceptor is responsible for closing the connection.
Line 393 
Line 523 
     */     */
     maxSocketCurrentPass++;     maxSocketCurrentPass++;
  
     // Fixed in monitor_2 but added because Monitor is still the default monitor.  
     // When _idleEntries is 0 don't immediately return, otherwise this loops out of control  
     // kicking off kill idle thread threads.  E.g. There is nothing to select on when the cimserver  
     // is shutting down.  
     /*if( _idleEntries == 0 )  
     {  
         Thread::sleep( milliseconds );  
         _entry_mut.unlock();  
         return false;  
     }*/  
   
     _entry_mut.unlock();     _entry_mut.unlock();
     //int events = select(FD_SETSIZE, &fdread, NULL, NULL, &tv);  
     int events = select(maxSocketCurrentPass, &fdread, NULL, NULL, &tv);     int events = select(maxSocketCurrentPass, &fdread, NULL, NULL, &tv);
    _entry_mut.lock(pegasus_thread_self());    _entry_mut.lock(pegasus_thread_self());
  
Line 449 
Line 567 
                    Tracer::trace(TRC_HTTP, Tracer::LEVEL4,                    Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
                      "_entries[indx].type for indx = %d is Monitor::CONNECTION", indx);                      "_entries[indx].type for indx = %d is Monitor::CONNECTION", indx);
                    static_cast<HTTPConnection *>(q)->_entry_index = indx;                    static_cast<HTTPConnection *>(q)->_entry_index = indx;
                    _entries[indx]._status = _MonitorEntry::BUSY;  
                      // Do not update the entry just yet. The entry gets updated once
                      // the request has been read.
                      //_entries[indx]._status = _MonitorEntry::BUSY;
   
                    // If allocate_and_awaken failure, retry on next iteration                    // If allocate_and_awaken failure, retry on next iteration
 /*  /* Removed for PEP 183.
                    if (!MessageQueueService::get_thread_pool()->allocate_and_awaken(                    if (!MessageQueueService::get_thread_pool()->allocate_and_awaken(
                            (void *)q, _dispatch))                            (void *)q, _dispatch))
                    {                    {
Line 462 
Line 584 
                       return true;                       return true;
                    }                    }
 */ */
 // begin hack  // Added for PEP 183
                    HTTPConnection *dst = reinterpret_cast<HTTPConnection *>(q);                    HTTPConnection *dst = reinterpret_cast<HTTPConnection *>(q);
                          Tracer::trace(TRC_HTTP, Tracer::LEVEL4,                          Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
                          "Monitor::_dispatch: entering run() for indx  = %d, queueId = %d, q = %p",                          "Monitor::_dispatch: entering run() for indx  = %d, queueId = %d, q = %p",
Line 479 
Line 601 
                    Tracer::trace(TRC_HTTP, Tracer::LEVEL4,                    Tracer::trace(TRC_HTTP, Tracer::LEVEL4,
                    "Monitor::_dispatch: exited run() for index %d", dst->_entry_index);                    "Monitor::_dispatch: exited run() for index %d", dst->_entry_index);
  
                    PEGASUS_ASSERT(dst->_monitor->_entries[dst->_entry_index]._status.value() == _MonitorEntry::BUSY);                     // It is possible the entry status may not be set to busy.
                      // The following will fail in that case.
                      // PEGASUS_ASSERT(dst->_monitor->_entries[dst->_entry_index]._status.value() == _MonitorEntry::BUSY);
    // Once the HTTPConnection thread has set the status value to either    // Once the HTTPConnection thread has set the status value to either
    // Monitor::DYING or Monitor::IDLE, it has returned control of the connection    // Monitor::DYING or Monitor::IDLE, it has returned control of the connection
    // to the Monitor.  It is no longer permissible to access the connection    // to the Monitor.  It is no longer permissible to access the connection
    // or the entry in the _entries table.    // or the entry in the _entries table.
                 if (dst->_connectionClosePending)  
                 {  
                         dst->_monitor->_entries[dst->_entry_index]._status = _MonitorEntry::DYING;  
                 }  
                 else  
                 {  
                         dst->_monitor->_entries[dst->_entry_index]._status = _MonitorEntry::IDLE;  
                 }  
  
 // end hack                     // The following is not relevant as the worker thread or the
                      // reader thread will update the status of the entry.
                      //if (dst->_connectionClosePending)
                      //{
                      //  dst->_monitor->_entries[dst->_entry_index]._status = _MonitorEntry::DYING;
                      //}
                      //else
                      //{
                      //  dst->_monitor->_entries[dst->_entry_index]._status = _MonitorEntry::IDLE;
                      //}
   // end Added for PEP 183
                 }                 }
                 else if( _entries[indx]._type == Monitor::INTERNAL){                 else if( _entries[indx]._type == Monitor::INTERNAL){
                         // set ourself to BUSY,                         // set ourself to BUSY,
Line 534 
Line 659 
     return(handled_events);     return(handled_events);
 } }
  
 void Monitor::stopListeningForConnections()  void Monitor::stopListeningForConnections(Boolean wait)
 { {
     PEG_METHOD_ENTER(TRC_HTTP, "Monitor::stopListeningForConnections()");     PEG_METHOD_ENTER(TRC_HTTP, "Monitor::stopListeningForConnections()");
     // set boolean then tickle the server to recognize _stopConnections     // set boolean then tickle the server to recognize _stopConnections
     _stopConnections = 1;     _stopConnections = 1;
     tickle();     tickle();
  
       if (wait)
       {
     // Wait for the monitor to notice _stopConnections.  Otherwise the     // Wait for the monitor to notice _stopConnections.  Otherwise the
     // caller of this function may unbind the ports while the monitor     // caller of this function may unbind the ports while the monitor
     // is still accepting connections on them.     // is still accepting connections on them.
Line 553 
Line 680 
       // The monitor is probably busy processng a very long request, and is       // The monitor is probably busy processng a very long request, and is
       // not accepting connections.  Let the caller unbind the ports.       // not accepting connections.  Let the caller unbind the ports.
     }     }
       }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
Line 565 
Line 693 
     int type)     int type)
 { {
      PEG_METHOD_ENTER(TRC_HTTP, "Monitor::solicitSocketMessages");      PEG_METHOD_ENTER(TRC_HTTP, "Monitor::solicitSocketMessages");
      AutoMutex autoMut(_entry_mut);
    _entry_mut.lock(pegasus_thread_self());  
    // Check to see if we need to dynamically grow the _entries array    // Check to see if we need to dynamically grow the _entries array
    // We always want the _entries array to 2 bigger than the    // We always want the _entries array to 2 bigger than the
    // current connections requested    // current connections requested
Line 590 
Line 717 
             _entries[index].queueId  = queueId;             _entries[index].queueId  = queueId;
             _entries[index]._type = type;             _entries[index]._type = type;
             _entries[index]._status = _MonitorEntry::IDLE;             _entries[index]._status = _MonitorEntry::IDLE;
             _entry_mut.unlock();  
  
             return index;             return index;
          }          }
Line 598 
Line 724 
       catch(...)       catch(...)
       {       {
       }       }
   
    }    }
    _solicitSocketCount--;  // decrease the count, if we are here we didnt do anything meaningful    _solicitSocketCount--;  // decrease the count, if we are here we didnt do anything meaningful
    _entry_mut.unlock();  
    PEG_METHOD_EXIT();    PEG_METHOD_EXIT();
    return -1;    return -1;
  
Line 611 
Line 735 
 { {
  
     PEG_METHOD_ENTER(TRC_HTTP, "Monitor::unsolicitSocketMessages");     PEG_METHOD_ENTER(TRC_HTTP, "Monitor::unsolicitSocketMessages");
     _entry_mut.lock(pegasus_thread_self());      AutoMutex autoMut(_entry_mut);
  
     /*     /*
         Start at index = 1 because _entries[0] is the tickle entry which never needs         Start at index = 1 because _entries[0] is the tickle entry which never needs
Line 642 
Line 766 
         index--;         index--;
     }     }
  
     _entry_mut.unlock();  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
   // Note: this is no longer called with PEP 183.
 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL Monitor::_dispatch(void *parm) PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL Monitor::_dispatch(void *parm)
 { {
    HTTPConnection *dst = reinterpret_cast<HTTPConnection *>(parm);    HTTPConnection *dst = reinterpret_cast<HTTPConnection *>(parm);
Line 1112 
Line 1236 
  
    PEG_METHOD_ENTER(TRC_HTTP, "monitor_2::solicitSocketMessages");    PEG_METHOD_ENTER(TRC_HTTP, "monitor_2::solicitSocketMessages");
  
    _entry_mut.lock(pegasus_thread_self());     AutoMutex autoMut(_entry_mut);
  
    for(int index = 0; index < (int)_entries.size(); index++)    for(int index = 0; index < (int)_entries.size(); index++)
    {    {
Line 1124 
Line 1248 
             //_entries[index].queueId  = queueId;             //_entries[index].queueId  = queueId;
             //_entries[index]._type = type;             //_entries[index]._type = type;
             _entries[index]._status = IDLE;             _entries[index]._status = IDLE;
             _entry_mut.unlock();  
  
             return index;             return index;
          }          }
Line 1134 
Line 1257 
       }       }
  
    }    }
    _entry_mut.unlock();  
    PEG_METHOD_EXIT();    PEG_METHOD_EXIT();
    return -1;    return -1;
 } }
Line 1144 
Line 1266 
 { {
  
     PEG_METHOD_ENTER(TRC_HTTP, "monitor_2::unsolicitSocketMessages");     PEG_METHOD_ENTER(TRC_HTTP, "monitor_2::unsolicitSocketMessages");
     _entry2_mut.lock(pegasus_thread_self());      AutoMutex autoMut(_entry2_mut);
  
     for(int index = 0; index < (int)_entries2.size(); index++)     for(int index = 0; index < (int)_entries2.size(); index++)
     {     {
Line 1155 
Line 1277 
           break;           break;
        }        }
     }     }
     _entry2_mut.unlock();  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  

Legend:
Removed from v.1.72.2.2  
changed lines
  Added in v.1.82
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2