#include <RemoteQueueHolder.h>

Collaboration diagram for CPN::RemoteQueueHolder:

Public Types
typedef std::map< Key_t, shared_ptr< RemoteQueueBase > >	QueueMap

typedef std::vector < shared_ptr< RemoteQueueBase > >	QueueList

Public Member Functions
void	AddQueue (shared_ptr< RemoteQueueBase > queue)

void	CleanupQueue (Key_t key)

void	Cleanup ()

void	Shutdown ()

WakeupHandle *	GetWakeup ()

Private Member Functions
void	PrintState ()

Private Attributes
QueueMap	queuemap

QueueList	queuelist

PthreadMutex	lock

PthreadCondition	cond

WakeupHandle	wakeup

Detailed Description

RemoteQueueHolder takes responsibility of holding references to the remote queues so that they can exist after the node has terminated. This is required because a node can terminate and the RemoteQueue has not finished sending all its data to the other side. This class also allows us to signal to the remote queues to shut down. Note that because closing a socket while selecting on that socket is a race condition and the only other good way of breaking out of the select is to also select on some other file, this holder provides a FileHandle that will cause select to return when shutting down.

Definition at line 47 of file RemoteQueueHolder.h.

Member Typedef Documentation

typedef std::vector<shared_ptr<RemoteQueueBase> > CPN::RemoteQueueHolder::QueueList

Definition at line 50 of file RemoteQueueHolder.h.

typedef std::map<Key_t, shared_ptr<RemoteQueueBase> > CPN::RemoteQueueHolder::QueueMap

Definition at line 49 of file RemoteQueueHolder.h.

Member Function Documentation

void CPN::RemoteQueueHolder::AddQueue ( shared_ptr< RemoteQueueBase > queue )

Add a queue.

Parameters

queue the queue to add

Definition at line 29 of file RemoteQueueHolder.cc.

References lock, and queuemap.

                                                                       {
         AutoLock<PthreadMutex> al(lock);
         queuemap.insert(std::make_pair(queue->GetKey(), queue));
     }

void CPN::RemoteQueueHolder::Cleanup ( )

Called by the kernel periodically to clean up queues that are done.

Definition at line 44 of file RemoteQueueHolder.cc.

References lock, queuelist, and AutoLock< Lockable >::Unlock().

                                     {
         AutoLock<PthreadMutex> al(lock);
         QueueList tmp;
         tmp.swap(queuelist);
         al.Unlock();
         tmp.clear();
     }

Here is the call graph for this function:

void CPN::RemoteQueueHolder::CleanupQueue ( Key_t key )

Called by the RemoteQueue it self to say it has completed.

Parameters

key	the endpoint key for the queue

Definition at line 34 of file RemoteQueueHolder.cc.

References cond, lock, queuelist, queuemap, and PthreadCondition::Signal().

Referenced by CPN::RemoteQueue::FileThreadEntryPoint().

                                                   {
         AutoLock<PthreadMutex> al(lock);
         QueueMap::iterator entry = queuemap.find(key);
         if (entry != queuemap.end()) {
             queuelist.push_back(entry->second);
             queuemap.erase(entry);
         }
         cond.Signal();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

WakeupHandle* CPN::RemoteQueueHolder::GetWakeup ( )

inline

The WakeupHandle is used by all the RemoteQueues to break out of select when shutting down.

Returns: A WakeupHandle pointer.

Definition at line 76 of file RemoteQueueHolder.h.

References wakeup.

Referenced by CPN::RemoteQueue::FileThreadEntryPoint().

76 { return &wakeup; }

CPN::RemoteQueueHolder::wakeup

WakeupHandle wakeup

Definition: RemoteQueueHolder.h:83

Here is the caller graph for this function:

void CPN::RemoteQueueHolder::PrintState ( )

private

Definition at line 66 of file RemoteQueueHolder.cc.

References queuelist, and queuemap.

                                        {
         QueueMap::iterator q = queuemap.begin();
         while (q != queuemap.end()) {
             q->second->LogState();
             ++q;
         }
         QueueList::iterator itr = queuelist.begin();
         while (itr != queuelist.end()) {
             itr->get()->LogState();
             ++itr;
         }
     }

void CPN::RemoteQueueHolder::Shutdown ( )

Call shutdown on each queue and cause the WakeupHandle to make select return.

Definition at line 52 of file RemoteQueueHolder.cc.

References cond, lock, queuelist, queuemap, WakeupHandle::SendWakeup(), PthreadCondition::Wait(), and wakeup.

                                      {
         AutoLock<PthreadMutex> al(lock);
         QueueMap::iterator q = queuemap.begin();
         while (q != queuemap.end()) {
             q->second->Shutdown();
             ++q;
         }
         wakeup.SendWakeup();
         while (!queuemap.empty()) {
             cond.Wait(lock);
         }
         queuelist.clear();
     }