Uses of Interface
org.opennms.bb.common.components.PCQueue

Packages that use PCQueue
org.opennms.bb.common.components   
org.opennms.bb.dp.actiond   
org.opennms.bb.dp.actiond.components   
org.opennms.bb.dp.capsd   
org.opennms.bb.dp.capsd.components   
org.opennms.bb.dp.common.components   
org.opennms.bb.dp.discovery   
org.opennms.bb.dp.discovery.components   
org.opennms.bb.dp.eventd   
org.opennms.bb.dp.poller.scheduler   
org.opennms.bb.dp.poller.scheduler.utils   
 

Uses of PCQueue in org.opennms.bb.common.components
 

Classes in org.opennms.bb.common.components that implement PCQueue
 class PCQueueFixedArray
          The fixed array queue is a definitively sized array of elements that follow producer/consumer rules.
 class PCQueueLinkedList
          The Linked list queue is a potentially infinite sized list of elements that follow producer/consumer rules.
 

Uses of PCQueue in org.opennms.bb.dp.actiond
 

Fields in org.opennms.bb.dp.actiond declared as PCQueue
private  PCQueue Actiond.m_actionQ
          the queue between the ActiondEventListener and the execManager
 

Uses of PCQueue in org.opennms.bb.dp.actiond.components
 

Fields in org.opennms.bb.dp.actiond.components declared as PCQueue
private  PCQueue ActionLaunchManager.m_actionQ
          The queue to which the actions that are to be executed are added.
private  PCQueue ActiondEventReceiver.m_listenerQ
          queue to which the incoming event stream is to be added
private  PCQueue ActionLauncher.m_actionQ
          The queue to which completed reader objects are added.
private  PCQueue ActiondEventListener.m_listenerQ
          The queue to which the incoming events are added.
private  PCQueue ActiondEventListener.m_actionQ
          The queue to which completed reader objects are sent for further processing.
 

Constructors in org.opennms.bb.dp.actiond.components with parameters of type PCQueue
ActionLaunchManager(PCQueue actionQ)
          Constructs the ActionLaunchManager - creates the 'ActionLauncher' thread pool and starts the INIT_NUM_LAUNCHERS number of the threads The maximum number of threads in the pool can be configured via the PROP_MAX_ACTION_LAUNCHER_THREADS property - the maximum number defaults to 10 The command timeout is the number of milliseconds that the launcher should wait for a launched command to complete.
ActiondEventReceiver(ActiondEventListener eListener, PCQueue listenerQ)
          Creates a ActiondEventReceiver for actiond
ActionLauncher(ActionLaunchManager launchMgr, PCQueue actionQ, long timeout)
          Constructs the ActionLauncher thread.
ActiondEventListener(PCQueue actionQ)
          Creates the ActiondEventListener thread of actiond that listens for events via JSDT from eventd
 

Uses of PCQueue in org.opennms.bb.dp.capsd
 

Fields in org.opennms.bb.dp.capsd declared as PCQueue
(package private)  PCQueue Capsd.m_capsReadQ
          Queue to which nodes received from discovery are added
(package private)  PCQueue Capsd.m_databaseQ
          Queue between the capability read and the the database writer
 

Uses of PCQueue in org.opennms.bb.dp.capsd.components
 

Fields in org.opennms.bb.dp.capsd.components declared as PCQueue
private  PCQueue CapsdReadManager.m_discRecvQ
          The queue to which the newly discovered nodes from discovery are received.
private  PCQueue CapsdReadManager.m_capsPropReadQ
          Input queue to the RunnableConsumerThreads.
private  PCQueue CapsdReadManager.m_databaseQ
          The backside queue for the RunnableConsumerThread instances.
private  PCQueue CapsdDiscReceiver.m_discRecvQ
          The discovery queue is the link between the capabilites daemon and the discovery system.
private  PCQueue CapsdWriteManager.m_mgrInputQ
          Queue to which CapsReader objects that have results of the SNMP, service queries are added by the CapsdReadManager.
private  PCQueue CapsdWriteManager.m_capsWriterQ
          Queue to which this adds CapsWriter objects which then run and all the data collected to the database.
 

Constructors in org.opennms.bb.dp.capsd.components with parameters of type PCQueue
CapsdReadManager(PCQueue discRecvQ, PCQueue databaseQ, List servicePlugins, Set dupNodes)
          Creates a new CapsdReadManager that creates a RunnableConsumerThread thread pool.
CapsdDiscReceiver(PCQueue Q, Set dupNodes)
          The class' constructor is used to create an instance of the capsd/discovery address exchange channel.
CapsdWriteManager(PCQueue Q)
          Constructs a new CapsdWriteManager object that maintains a DBRunnableConsumerThread thread pool to handle the serilization of data to persistant storage (the database).
 

Uses of PCQueue in org.opennms.bb.dp.common.components
 

Fields in org.opennms.bb.dp.common.components declared as PCQueue
private  PCQueue DBRunnableConsumerThread.m_input
          The Producer/Consumer Queue where Runnable Objects are dequeued and run by the run() method.
private  PCQueue DBRunnableConsumerThread.m_output
          The Producer/Consumer Queue where the Runnable objects from the input queue are placed when their run() method returns.
private  PCQueue RunnableConsumerThread.m_input
          The Producer/Consumer Queue where Runnable Objects are dequeued and run by the run() method.
private  PCQueue RunnableConsumerThread.m_output
          The Producer/Consumer Queue where the Runnable objects from the input queue are placed when their run() method returns.
 

Constructors in org.opennms.bb.dp.common.components with parameters of type PCQueue
DBRunnableConsumerThread(PCQueue input, String dbDriver, String url, String user, String passwd)
          Constructs a thread consumer of objects that implement the DBRunnable interface.
DBRunnableConsumerThread(PCQueue input, Connection dbconn)
          Constructs a thread consumer of objects that implement the DBRunnable interface.
DBRunnableConsumerThread(PCQueue input, PCQueue output, String dbDriver, String url, String user, String passwd)
          Constructs a consumer of objects that implement the DBRunnable interface.
DBRunnableConsumerThread(PCQueue input, PCQueue output, Connection dbconn)
          Constructs a consumer of objects that implement the DBRunnable interface.
DBRunnableConsumerThread(String name, PCQueue input, String dbDriver, String url, String user, String passwd)
          Constructs a thread consumer of objects that implement the DBRunnable interface.
DBRunnableConsumerThread(String name, PCQueue input, Connection dbconn)
          Constructs a thread consumer of objects that implement the DBRunnable interface.
DBRunnableConsumerThread(String name, PCQueue input, PCQueue output, String dbDriver, String url, String user, String passwd)
          Constructs a consumer of objects that implement the DBRunnable interface.
DBRunnableConsumerThread(String name, PCQueue input, PCQueue output, Connection dbconn)
          Constructs a consumer of objects that implement the DBRunnable interface.
DBRunnableConsumerThread(ThreadGroup grp, String name, PCQueue input, String dbDriver, String url, String user, String passwd)
          Constructs a thread consumer of objects that implement the Runnable interface.
DBRunnableConsumerThread(ThreadGroup grp, String name, PCQueue input, Connection dbconn)
          Constructs a thread consumer of objects that implement the Runnable interface.
DBRunnableConsumerThread(ThreadGroup grp, String name, PCQueue input, PCQueue output, String dbDriver, String url, String user, String passwd)
          Constructs a threadconsumer of objects that implement the Runnable interface.
DBRunnableConsumerThread(ThreadGroup grp, String name, PCQueue input, PCQueue output, Connection dbconn)
          Constructs a threadconsumer of objects that implement the Runnable interface.
RunnableConsumerThread(PCQueue input)
          Constructs a thread consumer of objects that implement the Runnable interface.
RunnableConsumerThread(PCQueue input, PCQueue output)
          Constructs a consumer of objects that implement the Runnable interface.
RunnableConsumerThread(String name, PCQueue input)
          Constructs a thread consumer of objects that implement the Runnable interface.
RunnableConsumerThread(String name, PCQueue input, PCQueue output)
          Constructs a consumer of objects that implement the Runnable interface.
RunnableConsumerThread(ThreadGroup grp, String name, PCQueue input)
          Constructs a thread consumer of objects that implement the Runnable interface.
RunnableConsumerThread(ThreadGroup grp, String name, PCQueue input, PCQueue output)
          Constructs a threadconsumer of objects that implement the Runnable interface.
 

Uses of PCQueue in org.opennms.bb.dp.discovery
 

Fields in org.opennms.bb.dp.discovery declared as PCQueue
private  PCQueue Discovery.m_pingRequestQ
          The producer/cosumer queue that is the sink for the IPGenerator and the source for the numerous discovery ping threads.
private  PCQueue Discovery.m_monitorRequestQ
          The producer/cosumer queue that is the sink for the MonitorRequestReceiver and the source for the numerous monitor ping threads.
 

Uses of PCQueue in org.opennms.bb.dp.discovery.components
 

Fields in org.opennms.bb.dp.discovery.components declared as PCQueue
private  PCQueue IPGenerator.m_generatedQ
          The output queue for placing generated addresses
private  PCQueue MonitorPinger.m_monitorRequestQ
          The monitor request queue is the link between the discovery system and the ICMP service monitor.
private  PCQueue DiscPinger.m_requestQ
           
private  PCQueue MonitorRequestReceiver.m_monitorRequestQ
          The monitor request queue is the link between the discovery system and the ICMP service monitor.
private  PCQueue DiscPingReplyReceiver.m_replyQ
          The queue to write the received replies
private  PCQueue DiscPingManager.m_requestQ
          queue to which IPGenerator adds the next address to ping
private  PCQueue DiscPingManager.m_monitorRequestQ
          queue to which MonitorRequestReceiver adds the next address to ping
private  PCQueue DiscPingManager.m_replyQ
          queue to which DiscReplyReceiver adds the address whose ping reply was received
 

Constructors in org.opennms.bb.dp.discovery.components with parameters of type PCQueue
IPGenerator(List ranges, List specifics, Set knownNodes, PCQueue Q)
          Constructs a generator object that iterates through the list of specific addresses.
MonitorPinger(DiscPingManager pingMgr, long lThreadID, PCQueue requestQ, DaemonConnection portal, short pingFilterID)
          Creates a new monitor ping thread that will attempt to poll addresses as they are added to the request queue.
DiscPinger(long lThreadID, PCQueue requestQ, DaemonConnection portal, short pingFilterID, QuantumSemaphore pktLimiter)
          Creates a new discovery ping thread that will attempt to poll addresses as they are set by the manager.
MonitorRequestReceiver(PCQueue Q, Object pingMgr)
          The class' constructor is used to create an instance of the discovery/ICMP service monitor request exchange channel.
DiscPingReplyReceiver(DaemonConnection dc, PCQueue pingReplyQ, Object informer)
          Constructs a ping reciever thread that reads the messages from the connection and stores them in the queue.
DiscPingManager(int port, long nThreads, long nPktsPerSec, PCQueue requestQ, int maxMonitorThreads, PCQueue monitorRequestQ)
          The ping manager's constructor is used to initialize the connection to the icmpd, open the jsdt connections, and startup the pinger thread pool.
 

Uses of PCQueue in org.opennms.bb.dp.eventd
 

Classes in org.opennms.bb.dp.eventd that implement PCQueue
private  class EventListener.CheckQueue
          This class is designed to specifically override the add behaviour of the base class.
private  class EventPersistd.CheckQueue
          This class is designed to specifically override the add behaviour of the base class.
 

Fields in org.opennms.bb.dp.eventd declared as PCQueue
private  PCQueue JSDTHandler.m_readerQ
          queue to which the incoming event stream is to be added
private  PCQueue EventListener.m_readerQ
          The queue to which the incoming events are added
private  PCQueue EventListener.m_destQ
          The queue to were completed reader objects are sent.
private  PCQueue UDPHandler.m_readerQ
          queue to the eventExpander
private  PCQueue UDPHandler.m_udpQ
          queue between the inner class that accepts new datagram packets and the main thread
private  PCQueue UDPHandler.DatagramPacketHandler.m_dest
          The datagram destination
private  PCQueue TCPHandler.m_readerQ
          queue of the EventsReaders
private  PCQueue TCPHandler.m_tcpQ
          queue between the inner class that accepts new connections and the main thread
private  PCQueue TCPHandler.ConnectionHandler.m_dest
          The destination of the accepted clients.
private  PCQueue Eventd.m_bridgeQ
          The queue of EventReaders from the TCP/UDP/JSDT receivers.
private  PCQueue EventPersistd.m_readersQ
          The queue from which EventReaders are received from
private  PCQueue EventPersistd.m_eventWriterQ
          Queue to which this adds EventWriter objects which then run and add all the data collected to the database
private  PCQueue EventPersistd.m_eventWriterReplyQ
          The queue to which EventWriters add events that have been added to the database - these are then grouped 10 at a time and sent out
 

Constructors in org.opennms.bb.dp.eventd with parameters of type PCQueue
JSDTHandler(PCQueue readerQ)
          Creates a JSDTHandler for eventd
EventListener(PCQueue destQ)
          Creates the Listener thread of eventd that listens for events sent via TCP, UDP or JSDT
UDPHandler(int port, PCQueue readerQ)
          Constructs a handler listening at the port 'port'
UDPHandler.DatagramPacketHandler(DatagramSocket sock, PCQueue dest)
          Create the datagram packet handler object
TCPHandler(int port, PCQueue readerQ)
          Instantiate the TCPHandler at the said port with the default name
TCPHandler(String name, int port, PCQueue readerQ)
          Instantiate the TCPHandler at the said port with the specified name
TCPHandler.ConnectionHandler(ServerSocket sock, PCQueue dest)
          Create the connection handler object
EventPersistd(PCQueue readersQ)
          Constructs the EventPeristd thread of the Eventd
 

Uses of PCQueue in org.opennms.bb.dp.poller.scheduler
 

Fields in org.opennms.bb.dp.poller.scheduler declared as PCQueue
private  PCQueue PollerScheduler.m_inQueue
          Queue holding NetworkInterface runnables that have been scheduled
private  PCQueue PollerScheduler.m_outQueue
          Queue holding NetworkInterfaces that have completeted polling
 

Uses of PCQueue in org.opennms.bb.dp.poller.scheduler.utils
 

Fields in org.opennms.bb.dp.poller.scheduler.utils declared as PCQueue
private  PCQueue IntervalScheduler.m_readyQ
           
 

Constructors in org.opennms.bb.dp.poller.scheduler.utils with parameters of type PCQueue
IntervalScheduler(int aSchedulePeriod, PCQueue aReadyQ)