| Home >> All >> org >> jboss >> [ mq Javadoc ] |
| • | org.jboss.mq.il.* (98) | • | org.jboss.mq.pm.* (17) | • | org.jboss.mq.referenceable.* (3) |
| • | org.jboss.mq.security.* (5) | • | org.jboss.mq.selectors.* (7) | • | org.jboss.mq.server.* (35) |
| • | org.jboss.mq.sm.* (7) | • | org.jboss.mq.test.* (2) | • | org.jboss.mq.threadpool.* (2) |
| • | org.jboss.mq.xml.* (5) |
• org.jboss.mq: Javadoc index of package org.jboss.mq.
Package Samples:
• org.jboss.mq.il.ha
• org.jboss.mq.il
• org.jboss.mq.il.jvm
• org.jboss.mq.il.oil
• org.jboss.mq.il.oil2
• org.jboss.mq.il.rmi
• org.jboss.mq.il.uil.multiplexor
• org.jboss.mq.il.uil
• org.jboss.mq.pm
• org.jboss.mq.pm.file
• org.jboss.mq.pm.jdbc
• org.jboss.mq.pm.jdbc2
• org.jboss.mq.pm.rollinglogged
• org.jboss.mq.referenceable
• org.jboss.mq.security
• org.jboss.mq.selectors
• org.jboss.mq.server
• org.jboss.mq.server.jmx
• org.jboss.mq.sm
• org.jboss.mq.sm.file
Classes:
• HTTPClient: Utility class that provides HTTP functionality. This class is modeled after Scott's Util class in org.jboss.invocation.http.interfaces.Util, however, that class deals with Invocation object, while this handles HTTPILRequest objects. Other then that, it is a pretty close reproduction. Concerning SSL, like Scott's Util class, a check is performed at run time to determine if the connection is the JSSE 1.0.2 package (i.e. the connection is an instance of com.sun.net.ssl.HttpsURLConnection). If so, the system properties are queried to see if the org.jboss.security.ignoreHttpsHost value is set to true. ...
• XElement: XElement provides an interface to an XML element. An XElement represents an XML element which contains: Name (required) Attributes (optional) character data (optional) other elements (optional) It is important to understand the diffrence between an "field" XElement and a non "field" XElement. If an XElement does not contain any sub elements, it is considered a "field" XElement. The getField(String) and getValue() functions will throw an XElementException if they are used on non "attribute" objects. This give you a little bit type checking (You'll get an exception if you try to access the character ...
• Connection: This class implements javax.jms.Connection. It is also the gateway through wich all calls to the JMS server is done. To do its work it needs a ServerIL to invoke (@see org.jboss.mq.server.ServerIL). The (new from february 2002) logic for clientID is the following: if logging in with a user and passwork a preconfigured clientID may be automatically delivered from the server. If the client wants to set it's own clientID it must do so on a connection wich does not have a prefonfigured clientID and it must do so before it calls any other methods on the connection (even getClientID()). It is not allowable ...
• HTTPClientILService: The HTTP/S implementation of the ClientILService object. One of these exists for each Connection object. Normally, this would be where you would boot up a client-side listener for the server to invoke. However in this case, we poll the server instead. In short, the ClientIL that we provide, once serialized and shipped to the server, simply places requests the server makes to it in a server-side storage mechanism. Then, when we send an HTTP request to the server, the servlet looks for queued requests waiting for us, batches them up and returns them in the response. Since we place ALL requests delivered ...
• DynamicStateManager: A state manager that allowed durable subscriptions to be dynamically created if configured to support it. Otherwise backward compatible with the old StateManager. Backed by an XML file. Example file format: john needle DurableSubscriberExample john needle myDurableSub TestTopic...
• XElementProducer: XElementProducer parses and provides an XElementConsumer XElement data. An XElementProducer is a SAX based XML parser. This class provides a hybrid of the Event Based and DOM based XML parsing models. This is done by telling the XElementProducer which elements signal the start of a record, and when to generat an XElement. As the "record" XML elements are encountered, XElements are produced. These XElements create an in memory DOM tree of the element and all sub elements. After the "record" element has be fully read in through the use of SAX events, the "record" element, now in the form of an XElement, ...
• HTTPServerILServlet: This Servlet acts as a proxy to the JMS Server for the HTTP IL clients. It receives posts from the HTTPServerIL in the form of HTTPILRequests, invokes the approprate method on the server, and returns a HTTPILResponse. This also acts as a delegate for the HTTPClientILService, by receiving POSTS, looking in HTTPILStorageQueue, retrieving HTTPRequests bound for the client, packaging them in a HTTPILResponse. These requests are generally long lived to simulate asynch messaging. When the HTTPClientILService POSTS a HTTPILRequest the payload of the request includes timeout value which represents the ...
• BaseMsg: The base msg class for all msgs used by the UIL2 invoker. Msgs consist of a msg type, id and exception and can operate as two way items that are sent with the request content and received with the reply content for the request. Such round-trip behavior is based on matching the request msgID with the reply msgID. The msgID parameter is segmented into value 1 to 2147483647 for client originated msgs and -1 to -2147483647 for server originated msgs. The message is a Runnable to avoid constructing a Runnable object when asynchronously handling the message from the ReadTask.
• BasicQueue: This class represents a queue which provides it's messages exclusively to one consumer at a time. Notes about synchronization: Much of the work is synchronized on the receivers or messages depending on the work performed. However, anything to do with unacknowledged messages and removed subscriptions must be done synchronized on both (receivers first). This is because there are multiple entry points with the possibility that a message acknowledgement (or NACK) is being processed at the same time as a network failure removes the subscription.
• MessageReference: This class holds a reference to an actual Message. Where it is actually at may vary. The reference it holds may be a: Hard Reference - The message is consider recently used and should not be paged out Soft Reference - The message is consider old and CAN be removed from memory by the GC No Reference - The message was removed from memory by the GC, but we can load it from a file.
• MessageCache: This class implements a Message cache so that larger amounts of messages can be processed without running out of memory. When memory starts getting tight it starts moving messages out of memory and into a file so that they can be recovered later. The locks should be obtained in the following order: mr, the relevent message we are working with lruCache, when maintaining the usage order
• StateManager: Interface for StateManager. A StateManager is a manager that manages states that has to do with clients/ users and durable subscription. A state manager most know how to persist information regarding durable subscriptions. It should also hold all current clientID's that are connected to the server. It may also support basic autentication, which is what the old default StateManager did.
• HTTPServerIL: Client proxy to the server. For each request, an HTTP or HTTPS request is created, and posted to the given URL. The URL is supplied in the HTTPServerILService MBean configuration, or automatically generated by as localhost here, but can be overridden on the client side by specifying a property name for the URL value, which will be resolved to a system property on the client side.
• ClientReconnectInterceptor: The JMS spec does not let a second client with the same clientID connect to the server. The second client gets an InvalidClientIDException exception. This interceptor modifies the server so that the first client gets disconnected and then the second client can connect successfully. Currently it only works if the client id is set by the client using the setClient method call.
• MultiplexorTest: This class is a unit tester of the StreamMux and StreamDemux classes. Starts 3 concurent readers and 3 concurent writers using 3 fully buffered object streams multiplexed over a single Pipe(Input/Output)Stream. The writers send a 10K message with a timestamp. Readers display how long the message took to arrive.
• SpyTopicPublisher: This class implements javax.jms.TopicPublisher A publisher created with a null Topic will now be interpreted as created as an unidentifyed publisher and follows the spec in throwing UnsupportedOperationException at the correct places.
• SocketMultiplexor: Used to multiplex a socket's streams. With this this interface you can access the multiplexed streams of the socket. The multiplexed streams are identifed a stream id. Stream id 0 is reserved for internal use of the multiplexor.
• SpyQueueSender: This class implements javax.jms.QueueSender A sender created with a null Queue will now be interpreted as created as an unidentifyed sender and follows the spec in throwing UnsupportedOperationException at the correct places.
• SimpleTimer: Much like the java.util.Timer class, except a separate thread is launched only when a new task appears. Another useful feature is that all pending tasks may be canceled without invalidating the whole timer.
• Work: This is the interface of work that the thread pool can do. Users of the thread pool enqueue an object implementing this interface to have one of the threads in the thread pool call back the method declared here.
• AbstractStateManager: An abstract baseclass to make it a little bit easier to implement new StateManagers. Apart from one methods in StateManager subclasses implement the protected abstract callback methods to do its work.
• JMSServerInterceptor: Interceptor interface for clients IL accessing the JMSServer. Using an iterface for this layer makes it possible to put in logic without having to modify the server objet. And also makes this pluggable.
• UILClientILService: The UILClientILService runs on the client side of a JMS server connection and acts as a factory for the UILClientIL passed to the server. It also handles the callbacks from the client side SocketManager.
• SpyConnectionFactoryObjectFactory: This class is used to create instances of of: SpyTopicConnectionFactory SpyQueueConnectionFactory SpyXATopicConnectionFactory SpyXAQueueConnectionFactory classes from a javax.naming.Reference instance.
| Home | Contact Us | Privacy Policy | Terms of Service |