コード例 #1
0
ファイル: MessageQueue.cpp プロジェクト: ncultra/Pegasus-2.5
MessageQueue* MessageQueue::lookup(Uint32 queueId)
{

    MessageQueue* queue = 0;
    AutoMutex autoMut(q_table_mut);

    if (_queueTable.lookup(queueId, queue))
    {
        return queue;
    }

    // Not found!

    Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3,
        "MessageQueue::lookup failure queueId = %u", queueId);

    return 0;
}
コード例 #2
0
ファイル: MessageQueue.cpp プロジェクト: ncultra/Pegasus-2.5
void MessageQueue::remove(Message* message)
{
    PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE,"MessageQueue::remove()");

    if (!message)
    {
        PEG_METHOD_EXIT();
        throw NullPointer();
    }

    if (message->_owner != this)
    {
        PEG_METHOD_EXIT();
        throw NoSuchMessageOnQueue();
    }

    {
    AutoMutex autoMut(_mut);

    if (message->_next)
        message->_next->_prev = message->_prev;
    else
        _back = message->_prev;

    if (message->_prev)
        message->_prev->_next = message->_next;
    else
        _front = message->_next;

    _count--;
    Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL4,
       "MessageQueue::remove _count = %d", _count);

    } // mutex unlocks here

    message->_prev = 0;
    message->_next = 0;
    message->_owner = 0;

    PEG_METHOD_EXIT();
}
コード例 #3
0
void * ModuleController::callback_handle::operator new(size_t size)
{
   if( size != sizeof(callback_handle))
      return ::operator new(size);
   AutoMutex autoMut(_alloc_mut);
   callback_handle *node = _head;
   if(node)
      _head = reinterpret_cast<callback_handle *>(node->_parm);
   else
   {
      callback_handle *block =
	 reinterpret_cast<callback_handle *>(::operator new(BLOCK_SIZE * sizeof(callback_handle)));
      int i;
      for(i = 1; i < BLOCK_SIZE - 1; ++i)
	 block[i]._parm = & block[i + 1];
      block[BLOCK_SIZE - 1]._parm = NULL;
      node = block;
      _head = &block[1];
   }
   return node;
}
コード例 #4
0
ファイル: MessageQueue.cpp プロジェクト: deleisha/neopegasus
MessageQueue* MessageQueue::lookup(const char *name)
{

    if (name == NULL)
        throw NullPointer();

    AutoMutex autoMut(q_table_mut);
    for (QueueTable::Iterator i = _queueTable.start(); i; i++)
    {
        // ATTN: Need to decide how many characters to compare in queue names
        if (!strcmp(((MessageQueue *)i.value())->getQueueName(), name))
        {
            return (MessageQueue *)i.value();
        }
    }

    PEG_TRACE((TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL1,
        "MessageQueue::lookup failure - name = %s", name));

    return 0;
}
コード例 #5
0
ファイル: MessageQueue.cpp プロジェクト: deleisha/neopegasus
MessageQueue::~MessageQueue()
{
    // ATTN-A: thread safety!
    PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE,"MessageQueue::~MessageQueue()");
    PEG_TRACE((TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3,
        "MessageQueue::~MessageQueue queueId = %i, name = %s",
        _queueId,
        _name));

    {
        AutoMutex autoMut(q_table_mut);
        _queueTable.remove(_queueId);
    } // mutex unlocks here

    // Free the name:

    delete [] _name;

    // Return the queue id.

    putQueueId(_queueId);

    PEG_METHOD_EXIT();
}
コード例 #6
0
// Creates a SNMP session
void snmpDeliverTrap_netsnmp::_createSession(
    const String& targetHost,
    Uint16 targetHostFormat,
    Uint32 portNumber,
    const String& securityName,
    void*& sessionHandle,
    snmp_session*& sessionPtr)
{
    PEG_METHOD_ENTER(TRC_IND_HANDLER,
        "snmpDeliverTrap_netsnmp::_createSession");

    Sint32 libErr, sysErr;
    char* errStr;
    String exceptionStr;

    struct snmp_session snmpSession;

    {
        AutoMutex autoMut(_sessionInitMutex);
        snmp_sess_init(&snmpSession);

        CString targetHostCStr = targetHost.getCString();

        // peername has format: targetHost:portNumber
        snmpSession.peername =
            (char*)malloc((size_t)(strlen(targetHostCStr) + 1 + 32));

        if (targetHostFormat == _IPV6_ADDRESS)
        {
            sprintf(snmpSession.peername, "udp6:[%s]:%u",
                (const char*)targetHostCStr,
                portNumber);
        }
        else
        {
            sprintf(snmpSession.peername, "%s:%u",
                (const char*)targetHostCStr,
                portNumber);
        }

        sessionHandle = snmp_sess_open(&snmpSession);
    }

    if (sessionHandle == NULL)
    {
        exceptionStr = _MSG_SESSION_OPEN_FAILED;

        // Get library, system errno
        snmp_error(&snmpSession, &libErr, &sysErr, &errStr);

        exceptionStr.append(errStr);

        free(errStr);

        free(snmpSession.peername);

        PEG_METHOD_EXIT();

        throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
            MessageLoaderParms(_MSG_SESSION_OPEN_FAILED_KEY, exceptionStr));
    }

    try
    {
        // get the snmp_session pointer
        sessionPtr = snmp_sess_session(sessionHandle);
        if (sessionPtr == NULL)
        {
            exceptionStr = _MSG_GET_SESSION_POINT_FAILED;

            // Get library, system errno
            snmp_sess_error(&snmpSession, &libErr, &sysErr, &errStr);

            exceptionStr.append(errStr);

            free(errStr);

            free(snmpSession.peername);

            throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
                _MSG_GET_SESSION_POINTER_FAILED_KEY,
                exceptionStr));
        }

        // Community Name, default is public
        String communityName;
        if (securityName.size() == 0)
        {
            communityName.assign("public");
        }
        else
        {
            communityName = securityName;
        }

        free(snmpSession.peername);

        free(sessionPtr->community);

        CString communityNameCStr = communityName.getCString();
        size_t communityNameLen = strlen(communityNameCStr);

        sessionPtr->community = (u_char*)malloc(communityNameLen);

        memcpy(sessionPtr->community, (const char*)communityNameCStr,
               communityNameLen);
        sessionPtr->community_len = communityNameLen;
    }
    catch (...)
    {
        _destroySession(sessionHandle);

        PEG_METHOD_EXIT();
        throw;
    }

    PEG_METHOD_EXIT();
}
コード例 #7
0
void HTTPAcceptor::_acceptConnection()
{
    // This function cannot be called on an invalid socket!

    PEGASUS_ASSERT(_rep != 0);

    // Accept the connection (populate the address):

    struct sockaddr* accept_address;
    SocketLength address_size;

    if (_connectionType == LOCAL_CONNECTION)
    {
#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
        accept_address =
            reinterpret_cast<struct sockaddr*>(new struct sockaddr_un);
        address_size = sizeof(struct sockaddr_un);
#else
        PEGASUS_ASSERT(false);
#endif
    }
    else
    {
#ifdef PEGASUS_ENABLE_IPV6
        accept_address =
           reinterpret_cast<struct sockaddr*>
           (new struct sockaddr_storage);
        address_size = sizeof(struct sockaddr_storage);
#else
        accept_address =
            reinterpret_cast<struct sockaddr*>(new struct sockaddr_in);
        address_size = sizeof(struct sockaddr_in);
#endif
    }

    // It is not necessary to handle EINTR errors from this accept() call.
    // An EINTR error should not occur on a non-blocking socket.  If the
    // listen socket is blocking and EINTR occurs, the new socket connection
    // is not accepted here.

    // EAGAIN errors are also not handled here.  An EAGAIN error should not
    // occur after select() indicates that the listen socket is available for
    // reading.  If the accept() fails with an EAGAIN error code, a new
    // connection is not accepted here.

    SocketHandle socket = accept(_rep->socket, accept_address, &address_size);

    if (socket == PEGASUS_SOCKET_ERROR)
    {
        // the remote connection is invalid, destroy client address.
        delete accept_address;

        // TCPIP is down reconnect this acceptor
        if (getSocketError() == PEGASUS_NETWORK_TCPIP_STOPPED)
        {
            PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                "Socket has an IO error. TCP/IP down. Try to reconnect.");

            reconnectConnectionSocket();

            return;
        }
        PEG_TRACE((
            TRC_DISCARDED_DATA,
            Tracer::LEVEL1,
            "HTTPAcceptor: accept() failed.  errno: %u",
            errno));
        return;
    }

    // Use an AutoPtr to ensure the socket handle is closed on exception
    AutoPtr<SocketHandle, CloseSocketHandle> socketPtr(&socket);

#ifndef PEGASUS_OS_TYPE_WINDOWS
    // We need to ensure that the socket number is not higher than
    // what fits into FD_SETSIZE, because we else won't be able to select on it
    // and won't ever communicate correct on that socket.
    if (socket >= FD_SETSIZE)
    {
        // the remote connection is invalid, destroy client address.
        delete accept_address;

        PEG_TRACE(
            (TRC_DISCARDED_DATA,
             Tracer::LEVEL1,
             "HTTPAcceptor out of available sockets."
                 "accept() returned too large socket number %u."
                 "Closing connection to the new client.",
             socket));

        return;
    }
#endif

    String ipAddress;

    if (_connectionType == LOCAL_CONNECTION)
    {
        ipAddress = "localhost";
    }
    else
    {
#ifdef PEGASUS_ENABLE_IPV6
        char ipBuffer[PEGASUS_INET6_ADDRSTR_LEN];
        int rc;
        if ((rc = System::getNameInfo(accept_address,
                address_size,
                ipBuffer,
                PEGASUS_INET6_ADDRSTR_LEN,
                0,
                0,
                NI_NUMERICHOST)))
        {
            PEG_TRACE((
                TRC_DISCARDED_DATA,
                Tracer::LEVEL1,
                "HTTPAcceptor: getnameinfo() failed.  rc: %d",
                rc));
            delete accept_address;
            return;
        }
        ipAddress = ipBuffer;
#else
        unsigned char* sa = reinterpret_cast<unsigned char*>(
            &reinterpret_cast<struct sockaddr_in*>(
                accept_address)->sin_addr.s_addr);
        char ipBuffer[32];
        sprintf(ipBuffer, "%u.%u.%u.%u", sa[0], sa[1], sa[2], sa[3]);
        ipAddress = ipBuffer;
#endif
    }

    delete accept_address;

// set the close on exec flag
#if !defined(PEGASUS_OS_TYPE_WINDOWS) && !defined(PEGASUS_OS_VMS)
    int sock_flags;
    if ((sock_flags = fcntl(socket, F_GETFD, 0)) < 0)
    {
        PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
            "HTTPAcceptor: fcntl(F_GETFD) failed");
    }
    else
    {
        sock_flags |= FD_CLOEXEC;
        if (fcntl(socket, F_SETFD, sock_flags) < 0)
        {
            PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                "HTTPAcceptor: fcntl(F_SETFD) failed");
        }
    }
#endif


    PEG_TRACE((
        TRC_HTTP,
        Tracer::LEVEL3,
        "HTTPAcceptor - accept() success.  Socket: %u",
        socket));

    SharedPtr<MP_Socket> mp_socket(new MP_Socket(
        socket, _sslcontext, _sslContextObjectLock, ipAddress));
    // mp_socket now has responsibility for closing the socket handle
    socketPtr.release();

    mp_socket->disableBlocking();

    {
#ifndef PEGASUS_INTEGERS_BOUNDARY_ALIGNED
        AutoMutex lock(_socketWriteTimeoutMutex);
#endif
        mp_socket->setSocketWriteTimeout(_socketWriteTimeout);
    }

    // Perform the SSL handshake, if applicable.

    Sint32 socketAcceptStatus = mp_socket->accept();

    if (socketAcceptStatus < 0)
    {
        PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
            "HTTPAcceptor: SSL_accept() failed");
        return;
    }

    // Create a new connection and add it to the connection list:

    AutoPtr<HTTPConnection> connection(new HTTPConnection(
        _monitor,
        mp_socket,
        ipAddress,
        this,
        _outputMessageQueue));

    if (HTTPConnection::getIdleConnectionTimeout())
    {
        Time::gettimeofday(&connection->_idleStartTime);
    }

    if (socketAcceptStatus == 0)
    {
        PEG_TRACE_CSTRING(TRC_HTTP, Tracer::LEVEL1,
            "HTTPAcceptor: SSL_accept() pending");
        connection->_acceptPending = true;
        Time::gettimeofday(&connection->_acceptPendingStartTime);
    }

    // Solicit events on this new connection's socket:
    int index;

    if (-1 ==  (index = _monitor->solicitSocketMessages(
            connection->getSocket(),
            SocketMessage::READ | SocketMessage::EXCEPTION,
            connection->getQueueId(), MonitorEntry::TYPE_CONNECTION)) )
    {
        PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
            "HTTPAcceptor::_acceptConnection: Attempt to allocate entry in "
                "_entries table failed.");
        return;
    }

    connection->_entry_index = index;
    AutoMutex autoMut(_rep->_connection_mut);
    _rep->connections.append(connection.get());
    connection.release();
}
コード例 #8
0
void IndicationOperationAggregate::appendRequest(
    CIMRequestMessage* request)
{
    AutoMutex autoMut(_appendRequestMutex);
    _requestList.append(request);
}
コード例 #9
0
ファイル: LocalAuthFile.cpp プロジェクト: brunolauze/pegasus
//
// create a file and make a random token data entry to it.
// send the file name back to caller
//
String LocalAuthFile::create()
{
    PEG_METHOD_ENTER(TRC_AUTHENTICATION, "LocalAuthFile::create()");

    Uint32 secs, milliSecs;
    Uint32 mySequenceNumber;

    System::getCurrentTime(secs, milliSecs);

    //
    // extension size is username plus the sequence count
    //
    {
        AutoMutex autoMut(sequenceCountLock);
        mySequenceNumber = sequenceCount++;
    } // mutex unlocks here

    char extension[2*INT_BUFFER_SIZE];
    sprintf(extension,"_%u_%u", mySequenceNumber, milliSecs);
    extension[strlen(extension)] = 0;

    String filePath;

    // Check to see whether a domain was specified. If so, strip the domain
    // from the local auth file name, since the backslash and '@' are invalid
    // filename characters.  Store this in another variable, since we need to
    // keep the domain around for the rest of the operations.
    String fileUserName = _userName;
    Uint32 index = _userName.find('\\');
    if (index != PEG_NOT_FOUND)
    {
        fileUserName = _userName.subString(index + 1);
    }
    else
    {
        index = _userName.find('@');
        if (index != PEG_NOT_FOUND)
        {
            fileUserName = _userName.subString(0, index);
        }
    }

    filePath.append(_authFilePath);
    filePath.append(fileUserName);//_userName);
    filePath.append(extension);
    CString filePathCString = filePath.getCString();

    //
    // 1. Create a file name for authentication.
    //
    ofstream outfs(filePathCString);

    if (!outfs)
    {
        // unable to create file
        Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            MessageLoaderParms(
                "Security.Authentication.LocalAuthFile.NO_CREATE",
                "Creation of the local authentication security file"
                    " $0 failed: $1",
                filePath, strerror(errno)));
        PEG_METHOD_EXIT();
        throw CannotOpenFile (filePath);
    }
    outfs.clear();

    //
    // 2. Set file permission to read/write by the owner only.
    //

#if defined(PEGASUS_OS_TYPE_WINDOWS)
    Boolean success =
        FileSystem::changeFilePermissions(filePath, _S_IREAD | _S_IWRITE);
#else
    Boolean success =
        FileSystem::changeFilePermissions(filePath, S_IRUSR | S_IWUSR);
#endif

    if (!success)
    {
        // Unable to change the local auth file permissions, remove the file
        // and throw CannotOpenFile error.
        Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            MessageLoaderParms(
                "Security.Authentication.LocalAuthFile.NO_CHMOD",
                "Changing permissions of the local authentication security "
                    "file $0 failed: $1",
                filePath, strerror(errno)));

        if (filePath.size())
        {
            if (FileSystem::exists(filePath))
            {
                FileSystem::removeFile(filePath);
            }
        }

        PEG_METHOD_EXIT();
        throw CannotOpenFile (filePath);
    }

    //
    // 3. Generate random token and write the token to the file.
    //
    String randomToken = _generateRandomTokenString();
    outfs << randomToken;

    // test if the write was successful
    if (outfs.fail())
    {
        Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            MessageLoaderParms(
                "Security.Authentication.LocalAuthFile.NO_WRITE",
                "Cannot write security token to the local authentication "
                    "security file $0.",
                filePath));

        if (filePath.size())
        {
            if (FileSystem::exists(filePath))
            {
                FileSystem::removeFile(filePath);
            }
        }

        PEG_METHOD_EXIT();
        throw CannotOpenFile (filePath);

    }

    outfs.close();

    //
    // 4. Set file permission to read only by the owner.
    //
#if defined(PEGASUS_OS_TYPE_WINDOWS)
    success = FileSystem::changeFilePermissions(filePath, _S_IREAD);
#else
    success = FileSystem::changeFilePermissions(filePath, S_IRUSR);
#endif

    if (!success)
    {
        // Unable to change the local auth file permissions, remove the file
        // and throw CannotOpenFile error.
        Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            MessageLoaderParms(
                "Security.Authentication.LocalAuthFile.NO_CHMOD",
                "Changing permissions of the local authentication security "
                    "file $0 failed: $1",
                filePath, strerror(errno)));

        if (filePath.size())
        {
            if (FileSystem::exists(filePath))
            {
                FileSystem::removeFile(filePath);
            }
        }

        PEG_METHOD_EXIT();
        throw CannotOpenFile (filePath);
    }

    //
    // 5. Change the file owner to the requesting user.
    //

    if (!FileSystem::changeFileOwner(filePath,_userName))
    {
        // Unable to change owner on local auth file, remove the file
        // and throw CannotOpenFile error.

        Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            MessageLoaderParms(
                "Security.Authentication.LocalAuthFile.NO_CHOWN_REQUSER",
                "Changing ownership of the local authentication "
                    "security file $0 to the requesting user failed: $1",
                filePath, strerror(errno)));

        if (filePath.size())
        {
            if (FileSystem::exists(filePath))
            {
                FileSystem::removeFile(filePath);
            }
        }

        PEG_METHOD_EXIT();
        throw CannotOpenFile (filePath);
    }

    _secret = randomToken;

    _filePathName = filePath;

    PEG_METHOD_EXIT();

    return _filePathName;
}
コード例 #10
0
void StatisticalData::addToValue(Sint64 value,
    MessageType msgType,
    StatDataType t)
{
    // Map MessageType to statistic type. Requires multiple tests because
    // mapping request and responses to the request types.
    Uint16 type;

    if ((msgType) >= CIM_OPEN_ENUMERATE_INSTANCES_REQUEST_MESSAGE)
    {
        type = msgType - CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE;
    }
    else if (msgType >= CIM_GET_CLASS_RESPONSE_MESSAGE)
    {
        type = msgType - CIM_GET_CLASS_RESPONSE_MESSAGE;
    }
    else
    {
        type = msgType - 1;
    }

    // Test if valid statistic type
    if (type >= NUMBER_OF_TYPES)
    {
         PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL2,
             "StatData: Statistical Data Discarded.  "
                 "Invalid Request Type =  %u", type));
         return;
    }
    //// Diagnostic to confirm message type conversion. Normally commented
    //// out
//  PEG_TRACE((TRC_STATISTICAL_DATA, Tracer::LEVEL4,
//   "StatisticalData::addToValue msgType %s %u. stat type %u %s",
//             MessageTypeToString(msgType),
//             msgType, type, (const char*)requestName[type].getCString() ));

    if (copyGSD)
    {
        AutoMutex autoMut(_mutex);
        switch (t)
        {
            case PEGASUS_STATDATA_SERVER:
                numCalls[type] += 1;
                cimomTime[type] += value;
                PEG_TRACE((TRC_STATISTICAL_DATA, Tracer::LEVEL4,
                    "StatData: SERVER: %s(%d): count = %"
                        PEGASUS_64BIT_CONVERSION_WIDTH "d; value = %"
                        PEGASUS_64BIT_CONVERSION_WIDTH "d; total = %"
                        PEGASUS_64BIT_CONVERSION_WIDTH "d",
                    (const char *)requestName[type].getCString(), type,
                    numCalls[type], value, cimomTime[type]));
                break;
            case PEGASUS_STATDATA_PROVIDER:
                providerTime[type] += value;
                PEG_TRACE((TRC_STATISTICAL_DATA, Tracer::LEVEL4,
                    "StatData: PROVIDER: %s(%d): count = %"
                        PEGASUS_64BIT_CONVERSION_WIDTH "d; value = %"
                        PEGASUS_64BIT_CONVERSION_WIDTH "d; total = %"
                        PEGASUS_64BIT_CONVERSION_WIDTH "d",
                    (const char *)requestName[type].getCString(), type,
                    numCalls[type], value, providerTime[type]));
                break;
        case PEGASUS_STATDATA_BYTES_SENT:
                responseSize[type] += value;
                PEG_TRACE((TRC_STATISTICAL_DATA, Tracer::LEVEL4,
                    "StatData: BYTES_SENT: %s(%d): count = %"
                        PEGASUS_64BIT_CONVERSION_WIDTH "d; value = %"
                        PEGASUS_64BIT_CONVERSION_WIDTH "d; total = %"
                        PEGASUS_64BIT_CONVERSION_WIDTH "d",
                    (const char *)requestName[type].getCString(), type,
                    numCalls[type], value, responseSize[type]));
                break;
        case PEGASUS_STATDATA_BYTES_READ:
                requestSize[type] += value;
                PEG_TRACE((TRC_STATISTICAL_DATA, Tracer::LEVEL4,
                    "StatData: BYTES_READ: %s(%d): count = %"
                        PEGASUS_64BIT_CONVERSION_WIDTH "d; value = %"
                        PEGASUS_64BIT_CONVERSION_WIDTH "d; total = %"
                        PEGASUS_64BIT_CONVERSION_WIDTH "d",
                    (const char *)requestName[type].getCString(), type,
                    numCalls[type], value, requestSize[type]));
                break;
        }
    }
}
コード例 #11
0
void pegasus_module::module_rep::_send_async_callback(Uint32 msg_handle, Message *msg, void *parm)
{
   AutoMutex autoMut(_thread_safety);
   _async_callback(msg_handle, msg, parm);
}
コード例 #12
0
MessageQueueService::~MessageQueueService()
{
   _die = 1;

   // The polling_routine locks the _polling_list while
   // processing the incoming messages for services on the 
   // list.  Deleting the service from the _polling_list
   // prior to processing, avoids synchronization issues
   // with the _polling_routine.

   _polling_list.remove(this);

   // ATTN: The code for closing the _incoming queue
   // is not working correctly. In OpenPegasus 2.5,
   // execution of the following code is very timing
   // dependent. This needs to be fix.
   // See Bug 4079 for details. 
   if (_incoming_queue_shutdown.value() == 0)
   {
       _shutdown_incoming_queue();
   }

   // Wait until all threads processing the messages
   // for this service have completed.

   while (_threads.value() > 0)
   {
      pegasus_yield();
   }

   {
     AutoMutex autoMut(_meta_dispatcher_mutex);
     _service_count--;
     if (_service_count.value() == 0)
     {

      _stop_polling++;
      _polling_sem.signal();
      if (_polling_thread) {
          _polling_thread->join();
          delete _polling_thread;
          _polling_thread = 0;
      }
      _meta_dispatcher->_shutdown_routed_queue();
      delete _meta_dispatcher;
      _meta_dispatcher = 0;

      delete _thread_pool;
      _thread_pool = 0;
     }
   } // mutex unlocks here
   // Clean up in case there are extra stuff on the queue.
  while (_incoming.count())
  {
    try { 
      delete _incoming.remove_first();
    } catch (const ListClosed &e)
    {
      // If the list is closed, there is nothing we can do. 
      break;
    }
  }
}
コード例 #13
0
MessageQueueService::MessageQueueService(
   const char *name,
   Uint32 queueID,
   Uint32 capabilities,
   Uint32 mask)
   : Base(name, true,  queueID),
     _mask(mask),
     _die(0),
     _threads(0),
     _incoming(true, 0),
     _incoming_queue_shutdown(0)
{

   _capabilities = (capabilities | module_capabilities::async);

   _default_op_timeout.tv_sec = 30;
   _default_op_timeout.tv_usec = 100;

   max_threads_per_svc_queue = MAX_THREADS_PER_SVC_QUEUE;

   // if requested threads gt MAX_THREADS_PER_SVC_QUEUE_LIMIT
   // then set to MAX_THREADS_PER_SVC_QUEUE_LIMIT

   if (max_threads_per_svc_queue > MAX_THREADS_PER_SVC_QUEUE_LIMIT)
     {
       max_threads_per_svc_queue = MAX_THREADS_PER_SVC_QUEUE_LIMIT;
     }

   // if requested threads eq 0 (unlimited) 
   // then set to MAX_THREADS_PER_SVC_QUEUE_LIMIT

   if (max_threads_per_svc_queue == 0)
     {
       max_threads_per_svc_queue = MAX_THREADS_PER_SVC_QUEUE_DEFAULT;
     }

   // cout << "MAX_THREADS_PER_SVC_QUEUE = " << MAX_THREADS_PER_SVC_QUEUE << endl;
   // cout << "max_threads_per_svc_queue set to = " << max_threads_per_svc_queue << endl;
   

   AutoMutex autoMut(_meta_dispatcher_mutex);

   if (_meta_dispatcher == 0)
   {
      _stop_polling = 0;
      PEGASUS_ASSERT(_service_count.value() == 0);
      _meta_dispatcher = new cimom();
      if (_meta_dispatcher == NULL)
      {
         throw NullPointer();
      }
      //  _thread_pool = new ThreadPool(initial_cnt, "MessageQueueService",
      //   minimum_cnt, maximum_cnt, deallocateWait); 
      //
      _thread_pool =
          new ThreadPool(0, "MessageQueueService", 0, 0, deallocateWait);
   }
   _service_count++;

   if (false == register_service(name, _capabilities, _mask))
   {
      //l10n
      //throw BindFailedException("MessageQueueService Base Unable to register with  Meta Dispatcher");
      MessageLoaderParms parms("Common.MessageQueueService.UNABLE_TO_REGISTER",
         "MessageQueueService Base Unable to register with  Meta Dispatcher");

      throw BindFailedException(parms);
   }

   _polling_list.insert_last(this);

}
コード例 #14
0
ファイル: MessageQueue.cpp プロジェクト: ncultra/Pegasus-2.5
void MessageQueue::remove_myself(Uint32 qid)
{
    AutoMutex autoMut(q_table_mut);
    _queueTable.remove(qid);
}