All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
| Class |
Description |
| AckCollector |
Collects acks from a number of nodes, waits for all acks.
|
| Address |
Address identifies cluster member.
|
| AddressedDNSResolver |
|
| AddressGenerator |
Callback to provide custom addresses.
|
| AgeOutCache<K> |
Cache which removes its elements after a certain time
|
| AgeOutCache.Handler<K> |
|
| AlternatingBundler |
Bundler implementation which sends message batches (or single messages) as soon as the target destination changes
(or max_bundler_size would be exceeded).
Messages are removed from the main queue one by one and processed as follows:
A B B C C A causes the following sends: A -> {CC} -> {BB} -> A
Note that null is also a valid destination (send-to-all).
JIRA: https://issues.redhat.com/browse/JGRP-2171
|
| ArrayIterator<T> |
Iterator over an array of elements of type T.
|
| AsciiString |
Simple string implemented as a byte[] array.
|
| ASYM_ENCRYPT |
Encrypts and decrypts communication in JGroups by using a secret key distributed to all cluster members by the
key server (coordinator) using asymmetric (public/private key) encryption.
The secret key is identical for all cluster members and is used to encrypt messages when sending and decrypt them
when receiving messages.
|
| ASYM_ENCRYPT.Processing |
|
| AsyncCounter |
An asynchronous counter interface.
|
| AsyncNoBundler |
Simple and stupid async version of NoBundler.
|
| AttributeType |
|
| AUTH |
The AUTH protocol adds a layer of authentication to JGroups.
|
| AuthHeader |
AuthHeader is a holder object for the token that is passed from the joiner to the coordinator
|
| AuthToken |
Abstract AuthToken class used by implementations of AUTH, e.g.
|
| Average |
Maintains an approximation of an average of values.
|
| AverageMinMax |
Measures min and max in addition to average
|
| AwaitInfo |
|
| BARRIER |
All messages up the stack have to go through a barrier (read lock, RL).
|
| Base64 |
Encodes and decodes to and from Base64 notation.
|
| Base64.InputStream |
A Base64.InputStream will read data from another
java.io.InputStream, given in the constructor,
and encode/decode to/from Base64 notation on the fly. |
| Base64.OutputStream |
A Base64.OutputStream will write data to another
java.io.OutputStream, given in the constructor,
and encode/decode to/from Base64 notation on the fly. |
| BaseBundler |
Implements storing of messages in a hashmap and sending of single messages and message batches.
|
| BaseDataOutputStream |
Implements DataOutput in a generic manner, so that subclasses can implement specific behavior.
|
| BaseMessage |
A common superclass for all Message implementations. |
| BaseServer |
Abstract class for a server handling sending, receiving and connection management.
|
| BasicTCP |
Shared base class for TCP protocols
|
| BATCH |
Batches messages near the top of the stack.
|
| BATCH.BatchHeader |
|
| BATCH2 |
Batches messages near the top of the stack.
|
| BATCH2.Batch2Header |
|
| BatchBundler |
|
| BatchMessage |
A message that contains a batch of messages for use with BATCH protocol.
|
| Bits |
Class (similar to (and partly copied from) java.nio.Bits) containing helper methods to encode variables
(e.g.
|
| BlockingInputStream |
Bounded input stream.
|
| BoundedHashMap<K,V> |
Bounded linked hashmap; used by SEQUENCER
|
| BoundedList<T> |
A bounded subclass of LinkedList, oldest elements are removed once max capacity is exceeded.
|
| BPING |
Broadcast PING.
|
| Buffers |
Class to do scattering reads or gathering writes on a sequence of ByteBuffer instances.
|
| Bundler |
Pluggable way to collect messages and send them as batches
|
| ByteArray |
Byte array with an offset and length.
Note that the underlying byte array must not be changed as long as this instance is in use !
|
| ByteArrayDataInputStream |
Implements DataInput over a byte[] buffer.
|
| ByteArrayDataOutputStream |
Implements DataOutput over a byte[] buffer.
|
| ByteBufferInputStream |
Class using ByteBuffer and implementing DataInput.
|
| ByteBufferOutputStream |
Class using ByteBuffer and implementing DataOutput.
|
| BytesMessage |
A Message containing a byte array as payload. |
| Cache<K,V> |
Simple cache which maintains keys and value.
|
| Cache.ChangeListener |
|
| Cache.Value<V> |
|
| CENTRAL_LOCK |
Deprecated.
|
| CENTRAL_LOCK2 |
Deprecated.
|
| CertficateCNMatcher |
|
| ChannelListener |
Allows a listener to be notified when an important channel lifecycle event occurs.
|
| Chat |
|
| CheckGaps |
Reads a sequence of numbers from stdin and verifies that they are in order
|
| CheckMonotonicallyIncreasingNumbers |
Checks whether numbers in a stream are monotonically increasing, e.g.
|
| ClassConfigurator |
Maintains a mapping between magic IDs and classes (defined in jg-magic-map.xml), and between protocol IDs and
protocol classes (defined in jg-protocol-ids.xml).
|
| CLEAR_FLAGS |
Protocol which clears the given flags in the down direction for all messages
|
| Client |
Defines common operations for clients (TCP or NIO)
|
| ClientGmsImpl |
Client part of GMS.
|
| CompletableFutures |
Utility class with CompletableFuture and CompletionStage useful methods.
|
| Component |
Tags components inside of protocols.
|
| CompositeMessage |
A message composed of multiple messages.
|
| COMPRESS |
Compresses the payload of a message.
|
| COMPRESS.CompressHeader |
|
| ConcurrentLinkedBlockingQueue<T> |
Attempt at writing a fast transfer queue, which is bounded.
|
| ConcurrentLinkedBlockingQueue2<T> |
Attempt at writing a fast transfer queue, which is bounded.
|
| CondVar |
A condition variable with methods for (timed) waiting and signalling
|
| Configurator |
The task if this class is to setup and configure the protocol stack.
|
| Configurator.InetAddressInfo |
|
| ConfiguratorFactory |
The ConfigurationFactory is a factory that returns a protocol stack configurator.
|
| Connection |
Represents a connection to a peer
|
| ConnectionListener |
|
| Constructable<T> |
Interface returning a supplier which can be called to create an instance
|
| CoordGmsImpl |
Coordinator role of the Group MemberShip (GMS) protocol.
|
| Counter |
Deprecated.
|
| COUNTER |
Protocol which is used by CounterService to provide a distributed atomic counter |
| COUNTER.AddAndGetRequest |
|
| COUNTER.CompareAndSetRequest |
|
| COUNTER.CounterHeader |
|
| COUNTER.CounterViewImpl |
|
| COUNTER.DeleteRequest |
|
| COUNTER.ExceptionResponse |
|
| COUNTER.GetOrCreateRequest |
|
| COUNTER.ReconcileRequest |
|
| COUNTER.ReconcileResponse |
|
| COUNTER.Request |
|
| COUNTER.RequestCompletableFuture<T> |
|
| COUNTER.RequestType |
|
| COUNTER.ResendPendingRequests |
|
| COUNTER.Response<T> |
|
| COUNTER.ResponseData<T> |
|
| COUNTER.ResponseType |
|
| COUNTER.SetRequest |
|
| COUNTER.SimpleRequest |
|
| COUNTER.SyncCounterImpl |
|
| COUNTER.UpdateFunctionRequest<T extends Streamable> |
|
| COUNTER.UpdateFunctionResponse<T extends Streamable> |
|
| COUNTER.UpdateRequest |
|
| COUNTER.UpdateResult<T extends Streamable> |
|
| COUNTER.ValueResponse |
|
| COUNTER.VersionedValue |
|
| CounterFunction<T extends Streamable> |
|
| CounterService |
Provides a distributed counter (similar to AtomicLong) which can be atomically updated across a cluster.
|
| CounterServiceDemo |
|
| CounterView |
A view representing the counter's state.
|
| Credit |
Maintains credits for a unicast destination.
|
| CreditMap |
Maintains credits for senders, when credits fall below 0, a sender blocks until new credits have been received.
|
| CustomLogFactory |
An extension interface allowing to plug in a custom log provider.
|
| CustomRejectionPolicy |
// TODO: Document this
|
| DAISYCHAIN |
Implementation of daisy chaining.
|
| DAISYCHAIN.DaisyHeader |
|
| DefaultDNSResolver |
|
| DefaultMessageFactory |
|
| DefaultSocketFactory |
Default implementation, ignores service names
|
| DefaultThreadFactory |
Thread factory mainly responsible for naming of threads.
|
| DELAY |
Delays incoming/outgoing messages by a random number of milliseconds (range between 0 and n
where n is determined by the user) and nanoseconds (constant amount).
|
| DeltaView |
Subclass of View with a null members field. |
| DETECT_LOOPBACKS |
Detects unicast loopbacks: messages where dest == local address
|
| DH_KEY_EXCHANGE |
Key exchange based on Diffie-Hellman-Merkle (https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange).
Diffie-Hellman is used between a member and a key server (the coordinator) to obtain a session key
(only known to the key server and the joiner) which is used by the key server to encrypt the shared secret symmetric
(group) key and by the requester to decrypt the group key it gets in the response of the key server.
|
| DH_KEY_EXCHANGE.DhHeader |
|
| DH_KEY_EXCHANGE.Type |
|
| DiagnosticsHandler |
|
| DiagnosticsHandler.ProbeHandler |
|
| Digest |
A message digest containing - for each member - the highest seqno delivered (hd) and the highest seqno received (hr).
|
| Digest.Entry |
Keeps track of one members plus its highest delivered and received seqnos
|
| DirectExecutor |
|
| DISCARD |
Discards up or down messages based on a percentage; e.g., setting property 'up' to 0.1 causes 10%
of all up messages to be discarded.
|
| DISCARD_PAYLOAD |
Discards a message whose sequence number (in the payload, as a Long) matches seqno 2 times,
before passing it down.
|
| DISCARD.MyCheckBox |
|
| Discovery |
The Discovery protocol retrieves the initial membership (used by GMS and MERGE3) by sending discovery requests.
|
| DiscoveryPacket |
|
| DiscoveryRequest |
|
| DiscoveryResponse |
|
| DNS_PING |
|
| DNSResolver |
|
| DNSResolver.DNSRecordType |
|
| Draw |
Shared whiteboard, each new instance joins the same group.
|
| DrawCommand |
Encapsulates information about a draw command.
|
| DROP |
Protocol which drops up or down messages according to user-defined filters
|
| DUPL |
Duplicates outgoing or incoming messages by copying them
|
| DUPL.Direction |
|
| EchoServer |
Simple TCP server replying back to client with connection information (peer address etc)
|
| EmptyMessage |
A Message without a payload; optimized for sending only headers (e.g. |
| Encrypt<E extends java.security.KeyStore.Entry> |
|
| EncryptHeader |
|
| Event |
Event is a JGroups internal class used for inter-stack and intra-stack communication.
|
| EXAMPLE |
Example of a protocol layer.
|
| EXAMPLE.ExampleHeader |
|
| Experimental |
Elements annotated with this annotation are experimental and may get removed from the distribution at any time
|
| ExpiryCache<K> |
Cache which maintains timestamps for keys, and methods to remove/replace expired keys.
|
| ExtendedUUID |
Subclass of UUID accommodating additional data such as a flag and a small hashmap. |
| FailureDetection |
|
| FailureDetection.HeartbeatHeader |
|
| FastArray<T> |
Simple
|
| FcHeader |
Header used by various flow control protocols
|
| FD_ALL |
Failure detection based on simple heartbeat protocol.
|
| FD_ALL2 |
Failure detection based on simple heartbeat protocol.
|
| FD_ALL3 |
Failure detection based on simple heartbeat protocol.
|
| FD_ALL3.Bitmap |
|
| FD_HOST |
Failure detection protocol which detects the crash or hanging of entire hosts and suspects all cluster members
on those hosts.
|
| FD_HOST.CommandExecutor2 |
|
| FD_HOST.ExternalPingCommand |
|
| FD_HOST.IsReachablePingCommand |
|
| FD_HOST.PingCommand |
Command used to check whether a given host is alive, periodically called
|
| FD_SOCK |
Failure detection protocol based on sockets.
|
| FD_SOCK.ClientConnectionHandler |
Handles a client connection; multiple client can connect at the same time
|
| FD_SOCK.FdHeader |
|
| FD_SOCK2 |
Failure detection protocol based on TCP connections, successor to FD_SOCK. |
| FD_SOCK2.FdHeader |
|
| FD_SOCK2.PingDest |
|
| FD_SOCK2.Request |
|
| FD_SOCK2.Request.Type |
|
| FD_SOCK2.State |
|
| FILE_PING |
Simple discovery protocol which uses a file on shared storage such as an SMB share, NFS mount or S3.
|
| FixedMembershipToken |
The FixedMemberShipToken object predefines a list of IP addresses and ports that can join the group.
|
| FixedSizeBitSet |
Class copied from BitSet.
|
| FlagsUUID |
Subclass of UUID accommodating additional data such as a flag. |
| FlowControl |
Simple flow control protocol based on a credit system.
|
| FlowControlTest |
Interactive test for MFC and UFC
|
| FLUSH |
Flush, as it name implies, forces group members to flush their pending messages while blocking
them to send any additional messages.
|
| FLUSH.FlushHeader |
|
| FLUSH.FlushStartResult |
|
| FORK |
The FORK protocol; multiplexes messages to different forks in a stack (https://issues.redhat.com/browse/JGRP-1613).
|
| FORK.ForkHeader |
|
| ForkChannel |
Implementation of a ForkChannel, which is a light-weight channel.
|
| ForkConfig |
Parses the fork-stacks.xsd schema.
|
| ForkProtocol |
Acts as bottom protocol of a fork-stack.
|
| ForkProtocolStack |
Protocol stack which maintains the mapping between fork-channel IDs and ForkChannels
|
| FRAG |
Fragmentation layer.
|
| FRAG.FragmentationList |
A fragmentation list keeps a list of fragmentation tables
sorted by an Address ( the sender ).
|
| FRAG.FragmentationTable |
Keeps track of the fragments that are received.
|
| FRAG.FragmentationTable.FragEntry |
inner class represents an entry for a message
each entry holds an array of byte arrays sorted
once all the byte buffer entries have been filled
the fragmentation is considered complete.
|
| FRAG2 |
Fragmentation layer.
|
| FRAG2.FragEntry |
Class represents an entry for a message.
|
| FRAG3 |
Fragmentation protocol which uses less memory to store fragments than FRAG2.
When a message is fragmented, all fragments carry the size of the original message, their offset and
length with respect to the original message and a fragment ID (to identify the fragment).
When the first fragment is received, the full message is created and each fragment copies its data into the full
message at its offset and length. |
| Frag3Header |
|
| FRAG4 |
Fragmentation layer.
|
| FragHeader |
|
| Fragmentation |
Base class for all fragmentation protocols.
|
| FragmentedMessage |
|
| GenerateGettersAndSetters |
Given a class, generates code for getters and setters for all attributes and writes it to stdout
|
| GetNetworkInterfaces |
Lists all network interfaces on a system
|
| Global |
Global is a JGroups internal class defining global variables.
|
| GMS |
Group membership protocol.
|
| GMS.DefaultMembershipPolicy |
|
| GMS.GmsHeader |
|
| GmsImpl |
|
| GmsImpl.Request |
|
| GossipData |
Encapsulates data sent between GossipRouter and RouterStub (TCPGOSSIP and TUNNEL)
|
| GossipRouter |
Router for TCP based group comunication (using layer TCP instead of UDP).
|
| GossipRouter.DumpMessages |
|
| GossipRouter.Entry |
|
| GossipRouter.TLSClientAuth |
|
| GossipType |
Types of requests and responses exchanged between GossipRouter and RouterStubs
|
| GridFile |
Subclass of File to iterate through directories and files in a grid
|
| GridFile.Metadata |
|
| GridFilesystem |
Entry point for GridFile and GridInputStream / GridOutputStream
|
| GridFilesystemTest |
|
| GridFilesystemTest.cd |
|
| GridFilesystemTest.Command |
|
| GridFilesystemTest.down |
|
| GridFilesystemTest.ls |
|
| GridFilesystemTest.mkdir |
|
| GridFilesystemTest.pwd |
|
| GridFilesystemTest.rm |
|
| GridFilesystemTest.up |
|
| GridInputStream |
|
| GridOutputStream |
|
| GroupRequest<T> |
Sends a message to all members of the group and waits for all responses (or timeout).
|
| GuardedBy |
Copyright (c) 2005 Brian Goetz and Tim Peierls
Released under the Creative Commons Attribution License
(http://creativecommons.org/licenses/by/2.5)
Official home: http://www.jcip.net
Adopted from Java Concurrency in Practice.
|
| HDRS |
Prints the headers of all sent or received messages
|
| Header |
Header is a JGroups internal base class for all JGroups headers.
|
| Headers |
|
| HexToBinary |
|
| Immutable |
Copyright (c) 2005 Brian Goetz and Tim Peierls
Released under the Creative Commons Attribution License
(http://creativecommons.org/licenses/by/2.5)
Official home: http://www.jcip.net
Adopted from Java Concurrency in Practice.
|
| InfinispanStackMerge3Test |
This test runs number of merge events with a similar stack configuration that current Infinispan and WildFly is using to
showcase speed of merges after partitioning.
|
| INJECT_VIEW |
Simple protocol to inject an arbitrary view on one or more cluster nodes.
|
| InputStreamAdapter |
|
| IntHashMap<T> |
A hashmap where keys have to be ints.
|
| IpAddress |
Network-dependent address (Internet).
|
| JChannel |
A channel represents a group communication endpoint (like a socket).
|
| JChannel.State |
|
| JChannelProbeHandler |
|
| JChannelProbeHandler.ThreadEntry |
|
| JDBC_PING |
Discovery protocol using a JDBC connection to a shared database.
|
| JDKLogImpl |
Logger that delivers messages to a JDK logger
|
| JGroupsTransport |
|
| JmxConfigurator |
|
| JmxDemo |
Shows how annotations can be used to expose attributes and operations
|
| JmxDemo.MyNotification |
|
| JoinRsp |
Result of a JOIN request (sent by the GMS client).
|
| JPerf |
Tool to measure TCP throughput, similar to iperf
|
| JPerf.Stats |
|
| KeyExchange |
Base class for protocols implementing key exchange: a secret key to be used for encryption is exchanged between
2 parties (usually the key server and a new cluster member) securely; ie.
|
| KeyStoreGenerator |
Generates a keystore file that has a SecretKey in it.
|
| Krb5Token |
JGroups AuthToken Class to for Kerberos v5 authentication.
|
| Krb5TokenUtils |
Support class that implements all the low level Kerberos security calls
|
| Krb5TokenUtils.LoginCallbackHandler |
|
| LargeState |
Tests transfer of large states.
|
| LargestWinningPolicy |
Policy which picks the new coordinator in a merge from the largest subview.
|
| LazyRemovalCache<K,V> |
Cache which doesn't remove elements on remove(), removeAll() or retainAll(), but only removes elements when a
configurable size limit has been exceeded.
|
| LazyRemovalCache.Entry<V> |
|
| LazyRemovalCache.Printable<K,V> |
|
| LazyThreadFactory |
Lazily names threads: whenever the address or cluster name is changed, all threads are renamed
|
| Leaver |
Handles the leaving of a member from a group.
|
| Lifecycle |
Interface that defines lifecycle methods.
|
| LOCAL_PING |
Discovery protocol for finding members in the local process only.
|
| LocalAddress |
This is an assertion, checked at startup time.
|
| LocalTransport |
A local transport is used for sending messages only to single (or all) members of the same host.
|
| LockInfo |
|
| Locking |
Deprecated.
|
| Locking.LockInfoResponse |
|
| Locking.LockingHeader |
|
| Locking.Request |
|
| Locking.Response |
A response to a request, to be sent back to the requester as a message
|
| Locking.Type |
|
| LockNotification |
|
| LockService |
Deprecated.
|
| LockServiceDemo |
Demos the LockService
|
| Log |
Simple logging wrapper for log4j or JDK logging.
|
| Log4J2LogImpl |
Logger that delivers messages to a Log4J2 logger
|
| LogFactory |
Factory that creates Log instances. |
| LongMessage |
Message with a long as payload.
|
| LongSizeStreamable |
Utility class that implements SizeStreamable and LongSupplier to store a long value. |
| LongTuple<V> |
A tuple with a long (primitive) first value
|
| MAKE_BATCH |
Intercepts individual up messages and creates batches from them, passing the batches up.
|
| MakeUnique |
Replaces words that start with args passed to the program with A, B, C and so on.
|
| ManagedAttribute |
Indicates that a public method or a field (any visibility) in
an MBean class defines an MBean attribute.
|
| ManagedOperation |
Indicates that a method in an MBean class defines an MBean
operation.
|
| MaxOneThreadPerSender |
MessageProcessingPolicy which processes regular messages and message batches by
assigning a max of 1 thread per message from the same sender. |
| MBean |
Optional annotation that exposes all public methods in the class hierarchy (excluding Object) as MBean operations.
|
| mcast |
Tests IP multicast.
|
| McastDiscovery |
Discovers all neighbors in an IP multicast environment by using expanding ring multicasts (increasing TTL).
|
| McastReceiverTest |
Tests IP multicast.
|
| McastReceiverTest.Receiver |
|
| McastSenderTest |
Same as McastSenderTest, but uses all available interfaces (including loopback) to send the packets
|
| McastSenderTest.AckReceiver |
|
| Membership |
Represents a membership of a cluster group.
|
| MembershipChangePolicy |
Policy used to determine the new membership after a membership change (join, leave) or a merge.
|
| MERGE3 |
Protocol to discover subgroups; e.g., existing due to a network partition (that healed).
|
| MERGE3.MergeHeader |
|
| MERGE3.MergeHeader.Type |
|
| MergeData |
Encapsulates data sent with a MERGE_RSP (handleMergeResponse()) and INSTALL_MERGE_VIEW (handleMergeView()).
|
| MergeId |
ID to uniquely identify a merge
|
| Merger |
Handles merging.
|
| MergeView |
A view that is sent as a result of a cluster merge.
|
| Message |
A Message is used to send data to members of a group.
|
| Message.Flag |
|
| Message.TransientFlag |
|
| MessageBatch |
Represents a message batch; multiple messages from the same sender to the same receiver(s).
|
| MessageBatch.Mode |
|
| MessageDispatcher |
Provides synchronous and asynchronous message sending with request-response
correlation; i.e., matching responses with the original request.
|
| MessageDispatcherSpeedTest |
|
| MessageFactory |
|
| MessageProcessingPolicy |
Policy which decides how to process a received message or message batch.
|
| MessageSendTest |
Tests sending different types of Message implementations over a given protocol stack |
| MessageSendTest.MyData |
|
| MessageSendTest.MyHeader |
|
| MessageSendTest.MySizeData |
|
| MessageSendTest.Person |
|
| MethodCall |
A method call is the JGroups representation of a remote method.
|
| MethodInvoker |
|
| MethodLookup |
|
| MFC |
Simple flow control protocol based on a credit system.
|
| MFC_NB |
Non-blocking alternative to MFC.
JIRA: JIRA: https://issues.redhat.com/browse/JGRP-2172 |
| MockSocketChannel |
A mock SocketChannel for testing
|
| ModClusterAdvertizeListener |
Listens on 224.0.1.105:23364 for mod-cluster advertizements from httpd daemons and prints them to stdout
|
| MPerf |
Dynamic tool to measure multicast performance of JGroups; every member sends N messages and we measure how long it
takes for all receivers to receive them.
|
| MPerf.ConfigChange |
|
| MPerf.Configuration |
|
| MPerf.MessageCounter |
|
| MPerf.MPerfHeader |
|
| MPerf.Result |
|
| MPerfRpc |
Dynamic tool to measure multicast RPC performance of JGroups; every member invokes N RPCs and we measure how long it
takes for all receivers to receive them.
|
| MPerfRpc.ConfigChange |
|
| MPerfRpc.Configuration |
|
| MPerfRpc.Result |
|
| MPING |
Uses its own IP multicast socket to send and receive discovery requests/responses.
|
| MsgStats |
Class which has all the stats about received/sent messages etc (in TP)
|
| MulticastTest |
Tests MulticastSocket.joinGroup(InetAddress) and MulticastChannel.join(InetAddress, NetworkInterface).
|
| MulticastTest2 |
Tests 2 MulticastSockets joining the same multicast address and port (this should be possible).
|
| MutableDigest |
A mutable version of Digest.
|
| MyCanvas |
|
| MyReceiver<T> |
Generic receiver for a JChannel
|
| NAKACK2 |
Negative AcKnowledgement layer (NAKs).
|
| NakAckHeader2 |
|
| NameCache |
Maintains the mappings between addresses and logical names (moved out of UUID.cache into a separate class)
|
| NioBaseServer |
|
| NioClient |
|
| NioClientTest |
NIO based client for measuring heap-based vs direct byte buffers.
|
| NioConnection |
|
| NioConnection.State |
|
| NioMessage |
A Message with a (heap-based or direct) ByteBuffer as payload.
Note that the payload of an NioMessage must not be modified after sending it (ie. |
| NioServer |
Server for sending and receiving messages via NIO channels.
|
| NioServerPerfTest |
NIO based server for measuring heap-based vs direct byte buffers.
|
| NioTransport |
|
| NoBundler |
Bundler which doesn't bundle :-) Can be used to measure the diff between bundling and non-bundling (e.g.
|
| NonBlockingCredit |
Non-blocking credit for a unicast destination.
Instead of blocking when insufficient credits are available for sending a message, this class queues the
message and sends it at a later time when enough credits have been received to send it.
JIRA: https://issues.redhat.com/browse/JGRP-2172
|
| NonBlockingCreditMap |
|
| NonReflectiveProbeHandler |
|
| NoProgressException |
Exception raised when a threadpool rejects jobs but shows no progress.
|
| NullAddress |
|
| ObjectInputStreamWithClassloader |
Override ObjectInputStream.resolveClass(java.io.ObjectStreamClass) using the passed-in
classloader
|
| ObjectMessage |
A Message with an object as payload. |
| ObjectWrapper |
Wraps an object and its serialized form.
|
| OneTimeAddressGenerator |
Implementation of AddressGenerator which is configured with an initial value, and
after that random values are generated. |
| OutputStreamAdapter |
|
| Owner |
Represents an 'owner', which is an address and thread ID
|
| PaddedAtomicBoolean |
|
| PaddedAtomicInteger |
|
| PaddedAtomicLong |
Copied from http://mechanical-sympathy.blogspot.ch/2011/08/false-sharing-java-7.html.
|
| ParseMessages |
Parses messages out of a captured file and writes them to stdout
|
| ParseMessages.BinaryToAsciiInputStream |
|
| ParseMessages.InnerParseMessages |
|
| ParseMessagesFields |
While investigating network errors, we would like to look for timestamp and JGroups data.
|
| ParseMessagesFields.BinaryToAsciiWithFieldsInputStream |
|
| ParsePacketDissections |
If you use `tshark ...
|
| PartialOutputStream |
Decorates an output stream (DataOutput) and writes only a subset [start..end] (both indices
inclusive) of the original data to the underlying output stream.
Example:
|
| ParticipantGmsImpl |
|
| PDC |
Persistent Discovery Cache.
|
| PDC.Mapping |
|
| PERF |
Protocol measuring latency between stacks.
|
| PERF.PerfHeader |
|
| PerfUtil |
Misc stuff for performance tests
|
| PerfUtil.Config |
|
| PerfUtil.CustomCall |
Abstract class which uses IDs for methods.
|
| PerfUtil.GetCall |
|
| PerfUtil.PutCall |
|
| PerfUtil.Results |
|
| PhysicalAddress |
Represents a physical (as opposed to logical) address
|
| PING |
The PING protocol retrieves the initial membership by mcasting a discovery request (via the multicast capable
transport) to all current cluster members
|
| PingData |
Encapsulates information about a cluster node, e.g.
|
| PingHeader |
Used to send discovery requests and responses
|
| PingPong |
Simple protocol to test round trip times.
|
| PingPongDatagram |
Simple protocol to test round trip times.
|
| Probe |
Discovers all UDP-based members running on a certain mcast address
|
| ProcessingQueue<T> |
A queue with many producers and consumers.
|
| ProcessingQueue.Handler<T> |
|
| ProgrammaticChat |
|
| ProgrammaticUPerf |
Tests the UNICAST by invoking unicast RPCs between a sender and a receiver.
|
| ProgrammaticUPerf2 |
Tests the UNICAST by invoking unicast RPCs between a sender and a receiver.
|
| ProgressCheckRejectionPolicy |
Detects
|
| Promise<T> |
Allows a thread to submit an asynchronous request and to wait for the result.
|
| PropertiesToAsciidoc |
Iterates over all concrete Protocol classes and creates tables with Protocol's properties.
|
| Property |
Represents a Protocol property assigned from corresponding field in JGroups
properties file.
|
| PropertyConverter |
Represents a property converter that takes an input from corresponding field
in JGroups properties file as a String and converts it to a matching Java
type.
|
| PropertyConverters |
Groups a set of standard PropertyConverter(s) supplied by JGroups.
|
| PropertyConverters.BindInterface |
|
| PropertyConverters.Default |
|
| PropertyConverters.InitialHosts |
|
| PropertyConverters.InitialHosts2 |
|
| PropertyConverters.NetworkInterfaceList |
|
| PropertyHelper |
|
| Protocol |
The Protocol class provides a set of common services for protocol layers.
|
| ProtocolConfiguration |
Parses and encapsulates the specification for 1 protocol of the protocol stack, e.g.
|
| ProtocolHook |
Provides hook(s) that are called when a protocol has been created
|
| ProtocolStack |
A ProtocolStack manages a number of protocols layered above each other.
|
| ProtocolStack.Position |
|
| ProtocolStackConfigurator |
|
| PubClient |
Demo of a client which connects to a server ( PubServer) and sends it messages which are forwarded to all
connected clients |
| PubServer |
Demo which starts an NioServer that accepts messages from clients ( PubClient) and forwards them to
all connected clients |
| RACKSPACE_PING |
Discovery protocol based on Rackspace Cloud Files storage solution
|
| RACKSPACE_PING.RackspaceClient |
A thread safe Rackspace ReST client
|
| Range |
|
| RATE_LIMITER |
Protocol which sends at most max_bytes in time_period milliseconds.
|
| Receiver |
Receiver interface to be used with BaseServer instances |
| Receiver |
Defines the callbacks that are invoked when messages, views etc are received
|
| ReceiverAdapter |
|
| RecommendedForUpgrade |
Protocols annotated with this annotation should upgrade to a newer version (e.g.
|
| RED |
Implementation of Random Early Drop: messages are discarded when the bundler's queue in the transport nears exhaustion.
|
| Ref<T> |
Keeps a reference to another object
|
| Refcountable<T> |
Provides ref-counting for messages (https://issues.redhat.com/browse/JGRP-2417).
|
| RefcountedBytesMessage |
Ref-counted message implementation.
Note that this class is experimental and may get removed without notice.
|
| RefcountedNioMessage |
Ref-counted message implementation.
Note that this class is experimental and may get removed without notice.
|
| RefcountImpl<T> |
Ref-counted implementation; can be used by message implementations.
Note that this class is experimental and may get removed without notice.
|
| ReflectUtils |
Methods to get/set attributes and invoke operations of a given instance.
|
| RegexMembership |
Matches the IP address or logical name of a joiner against a regular expression and accepts or rejects based on
pattern matching
|
| RELAY2 |
Design: ./doc/design/RELAY2.txt and at https://github.com/belaban/JGroups/blob/master/doc/design/RELAY2.txt.
|
| RELAY2.Relay2Header |
|
| RelayConfig |
Parses and maintains the RELAY2 configuration (in memory)
|
| RelayConfig.BridgeConfig |
|
| RelayConfig.ForwardConfig |
|
| RelayConfig.ProgrammaticBridgeConfig |
|
| RelayConfig.PropertiesBridgeConfig |
|
| RelayConfig.SiteConfig |
|
| RelayDemo |
Demos RELAY.
|
| RelayDemoRpc |
Demos RELAY.
|
| Relayer |
Maintains bridges and routing table.
|
| RemoveQueueBundler |
Bundler implementation which sends message batches (or single messages) as soon as the remove queue is full
(or max_bundler_size would be exceeded).
Messages are removed from the main queue and processed as follows (assuming they all fit into the remove queue):
A B B C C A causes the following sends: {AA} -> {CC} -> {BB}
Note that null is also a valid destination (send-to-all).
Contrary to TransferQueueBundler, this bundler uses a RingBuffer rather than an ArrayBlockingQueue
and the size of the remove queue is fixed. |
| ReplCache<K,V> |
Cache which allows for replication factors per data items; the factor determines how many replicas
of a key/value we create across the cluster.
See doc/design/ReplCache.txt for details.
|
| ReplCache.ChangeListener |
|
| ReplCache.ConsistentHashFunction<K> |
|
| ReplCache.HashFunction<K> |
|
| ReplCache.HashFunctionFactory<K> |
|
| ReplCache.Value<V> |
|
| ReplCacheDemo |
GUI demo of ReplCache
|
| ReplCacheDemo.MyFocusListener |
|
| ReplCacheDemo.MyTable |
|
| ReplicatedHashMap<K,V> |
Implementation of a ConcurrentMap with replication of the contents across a cluster.
|
| ReplicatedHashMap.Notification<K,V> |
|
| ReplicatedHashMap.SynchronizedReplicatedMap<K,V> |
|
| ReplicatedHashMapDemo |
Uses the ReplicatedHashMap building block, which subclasses java.util.HashMap and overrides
the methods that modify the hashmap (e.g.
|
| ReplicatedMap<K,V> |
|
| ReplicatedTree |
A tree-like structure that is replicated across several members.
|
| ReplicatedTree.MyListener |
|
| ReplicatedTree.Node |
|
| ReplicatedTree.ReplicatedTreeListener |
|
| ReplicatedTree.Request |
Class used to multicast add(), remove() and set() methods to all members.
|
| ReplicatedTree.StringHolder |
|
| Request<T> |
Abstract class for a unicast or multicast request
|
| RequestCorrelator |
Framework to send requests and receive matching responses (on request ID).
|
| RequestCorrelator.Header |
The header for RequestCorrelator messages
|
| RequestCorrelator.MultiDestinationHeader |
|
| RequestHandler |
|
| RequestOptions |
Class which captures a bunch of options relevant to remote method invocation or message sending
|
| RequestTable<T> |
Table for storing requests associated with monotonically increasing sequence numbers (seqnos).
|
| RequestTable.Visitor<T> |
|
| ResourceDMBean |
A DynamicMBean wrapping an annotated object instance and exposing attributes annotated with @ManagedAttribute and
operations annotated with @ManagedOperation.
|
| ResourceDMBean.Accessor |
|
| ResourceDMBean.AttributeEntry |
|
| ResourceDMBean.FieldAccessor |
|
| ResourceDMBean.MethodAccessor |
|
| ResourceDMBean.NoopAccessor |
|
| ResourceManager |
Manages resources such as multicast addresses and multicast ports, and TCP
ports.
|
| ResourceManager.IpAddressRep |
|
| ResourceManager.IPv4AddressRep |
Representation of an IPv4 address
|
| ResourceManager.IPv6AddressRep |
Representation of an IPv6 address
|
| Response |
|
| ResponseCollector<T> |
Similar to AckCollector, but collects responses from cluster members, not just acks.
|
| ResponseCollectorTask<T> |
Task which is seeded with an initial membership.
|
| ResponseMode |
Enum capturing the various response modes for RPCs
|
| Responses |
Manages responses for the discovery protocol.
|
| Responses.PingDataIterator |
|
| Result |
|
| REVERSE |
Reverses the next N messages that are received.
|
| RingBuffer<T> |
Ring buffer of fixed capacity designed for multiple writers but only a single reader.
|
| RingBufferBundler |
|
| RingBufferBundlerLockless |
Bundler which doesn't use locks but relies on CAS.
|
| RingBufferBundlerLockless2 |
Lockless bundler using a reader thread which is unparked by (exactly one) writer thread.
|
| RingBufferSeqno<T> |
Ring buffer, implemented with a circular array.
|
| RingBufferSeqnoLockless<T> |
Ring buffer, implemented with a circular array.
|
| RoundTrip |
Class that measure RTT for multicast messages between 2 cluster members.
|
| RoundTripRpc |
Class that measure RTT for multicast messages between 2 cluster members.
|
| Route |
Class which maintains the destination address for sending messages to a given site, and the bridge channel to do so.
|
| RouterStub |
Client stub that talks to a remote GossipRouter via blocking or non-blocking TCP
|
| RouterStub.CloseListener |
|
| RouterStub.MembersNotification |
|
| RouterStub.StubReceiver |
|
| RouterStubGet |
|
| RouterStubManager |
Manages a list of RouterStubs (e.g.
|
| RouteStatusListener |
Gets notified when a site comes up or goes down
|
| RpcDispatcher |
This class allows a programmer to invoke remote methods in all (or single) group members and optionally wait for
the return value(s).
|
| RpcDispatcherBlocking |
Tests synchronous group RPCs.
|
| RpcDispatcherSpeedTest |
Test for measuring performance of RPCs.
|
| RpcStats |
Keeps track of stats for sync and async unicasts and multicasts
|
| RpcStats.Result |
|
| RpcStats.RTTStat |
|
| RpcStats.Type |
|
| Rsp<T> |
Class that represents a response from a communication
|
| RspFilter |
Interface defining when a group request is done.
|
| RspList<T> |
Contains responses from all members.
|
| RSVP |
Protocol which implements synchronous messages (https://issues.redhat.com/browse/JGRP-1389).
|
| RSVP.Entry |
|
| RSVP.RsvpHeader |
|
| RtReceiver |
|
| RTTHeader |
Header to measure round-trip times (in nanoseconds) for sync RPCs (https://issues.redhat.com/browse/JGRP-2604)
|
| RtTransport |
|
| Runner |
Runs a given function in a loop (in a separate thread) until it is stopped
|
| SecurityActions |
Privileged actions for the package
Do not move.
|
| SecurityActions.SysProps |
|
| SenderSendsBundler |
|
| SeqnoList |
A bitset of missing messages with a fixed size.
|
| SEQUENCER |
Implementation of total order protocol using a sequencer.
|
| SEQUENCER.SequencerHeader |
|
| SEQUENCER2 |
Implementation of total order protocol using a sequencer_uum.
|
| SEQUENCER2.SequencerHeader |
|
| SERIALIZE |
Serializes the entire message (including payload, headers, flags and destination and src) into the payload of
another message that's then sent.
|
| ServerGmsImpl |
Common super class for CoordGmsImpl and ParticipantGmsImpl
|
| ServerTransport |
|
| SHARED_LOOPBACK |
Loopback transport shared by all channels within the same VM.
|
| SHARED_LOOPBACK_PING |
|
| ShmTest |
Tests the speed of message sending/receiving via shared memory.
|
| SHUFFLE |
Reorders messages by buffering them and shuffling the result after TIMEOUT ms.
|
| ShutdownRejectedExecutionHandler |
ShutdownRejectedExecutionHandler is a decorator RejectedExecutionHandler used
in all JGroups ThreadPoolExecutor(s).
|
| SimpleTCP |
Bare-bones thread-per-connection TCP-based transport.
|
| SimplifiedTransferQueueBundler |
This bundler uses the same logic as TransferQueueBundler but does not allocate
memory except for the buffer itself and does not use complex data structures. |
| SiteAddress |
Address with a site suffix
|
| SiteMaster |
Special address with the UUID part being 0: identifies the current (relay) coordinator of a given site.
|
| SiteMasterPicker |
Allows an implementation to pick a SiteMaster or a Route from a list (if multiple site masters are
enabled). |
| SiteUUID |
Implementation of SiteAddress
|
| SIZE |
Protocol which prints out the real size of a message.
|
| SizeBoundedQueue<T> |
Blocking FIFO queue bounded by the max number of bytes of all elements.
|
| SizeBoundedQueue.El<T> |
|
| SizeStreamable |
Interface implementing Streamable and returning the size of the marshalled object.
|
| Slf4jLogImpl |
Logger that delivers messages to a SLF4J logger
|
| SNIFF |
Protocol trying to print message payloads as strings
|
| SocketFactory |
Factory to create various types of sockets.
|
| SOS |
Periodically fetches some attributes and writes them to a file (https://issues.redhat.com/browse/JGRP-2402)
|
| SSL_KEY_EXCHANGE |
Key exchange based on SSL sockets.
|
| SSL_KEY_EXCHANGE.SessionVerifier |
|
| SSL_KEY_EXCHANGE.Type |
|
| SslContextFactory |
SslContextFactory.
|
| STABLE |
Computes the broadcast messages that are stable; i.e., have been delivered by all members.
|
| STABLE.StableHeader |
|
| StackType |
|
| STATE |
STATE streams the state (written to an OutputStream) to the state requester in chunks (defined by
chunk_size).
|
| STATE_SOCK |
STATE_SOCK has the state provider create a server socket to which the state
requester connects and from which the latter reads the state.
|
| STATE_TRANSFER |
STATE_TRANSFER protocol based on byte array transfer.
|
| STATE_TRANSFER.StateHeader |
Wraps data for a state request/response.
|
| StateTransferException |
StateTransferException is thrown to indicate a failure of a state transfer between
cluster members.
|
| StateTransferInfo |
Contains parameters for state transfer.
|
| StateTransferResult |
Encapsulates the result of a state transfer.
|
| STATS |
Provides various stats
|
| STOMP |
Protocol which provides STOMP (http://stomp.codehaus.org/) support.
|
| STOMP.ClientVerb |
|
| STOMP.Frame |
|
| STOMP.ServerVerb |
|
| STOMP.StompHeader |
|
| STOMP.StompHeader.Type |
|
| StompChat |
Chat client using STOMP to talk to other clients
|
| StompConnection |
STOMP client to access the STOMP [1] protocol.
|
| StompConnection.ConnectionCallback |
|
| StompConnection.Listener |
|
| StompDraw |
Simple STOMP demo client.
|
| Streamable |
Implementations of Streamable can add their state directly to the output stream, enabling them to bypass costly
serialization
|
| StreamingStateTransfer |
Base class for state transfer protocols which use streaming (or chunking) to transfer state between two members.
|
| StreamingStateTransfer.StateHeader |
|
| SubmitToThreadPool |
Default message processing policy.
|
| SuppressCache<T> |
Cache which keeps a timestamp and counter for every key.
|
| SuppressCache.Value |
|
| SuppressLog<T> |
Log (using SuppressCache) which suppresses (certain) messages from the same member for a given time |
| SuppressLog.Level |
|
| SuspectedException |
Thrown if a message is sent to a suspected member.
|
| SWIFT_PING |
Discovery protocol based on Openstack Swift (object storage).
|
| SWIFT_PING.AUTH_TYPE |
Supported Swift authentication providers
|
| SWIFT_PING.Authenticator |
Contract for Swift authentication providers
|
| SWIFT_PING.ConnBuilder |
Build HttpURLConnections with adequate headers and method
|
| SWIFT_PING.Credentials |
Result of a successfully authenticated session
|
| SWIFT_PING.HttpHeaders |
|
| SWIFT_PING.HttpResponse |
Response for a Swift API call
|
| SWIFT_PING.Keystone_V_2_0_Auth |
Openstack Keytsone v2.0 authentication provider.
|
| SWIFT_PING.SwiftClient |
A thread safe Swift client
|
| SWIFT_PING.Utils |
|
| SYM_ENCRYPT |
Encrypts and decrypts communication in JGroups by using a secret key shared by all cluster members.
|
| SyncCounter |
A synchronous counter interface
|
| Table<T> |
A store for elements (typically messages) to be retransmitted or delivered.
|
| Table.Visitor<T> |
|
| TCP |
TCP based protocol.
|
| TCP_NIO2 |
Protocol using TCP/IP to send and receive messages.
|
| TcpBaseServer |
Common base class for TCP based clients and servers
|
| TcpClient |
|
| TcpConnection |
Blocking IO (BIO) connection.
|
| TCPGOSSIP |
The TCPGOSSIP protocol layer retrieves the initial membership (used by GMS when started by sending event
FIND_INITIAL_MBRS down the stack).
|
| TCPPING |
The TCPPING protocol defines a static cluster membership.
|
| TcpServer |
Class that manages allows to send and receive messages via TCP sockets.
|
| TcpTransport |
|
| ThreadCreator |
|
| ThreadFactory |
|
| ThreadPool |
Thread pool based on ThreadPoolExecutor
|
| TIME |
Protocol measuring delivery times.
|
| TimeScheduler |
Timer-like interface which allows for execution of tasks.
|
| TimeScheduler.Task |
|
| TimeScheduler3 |
|
| TimeScheduler3.Task |
|
| TimeScheduler3.TaskType |
|
| TimeService |
Provides a coarse grained time service.
|
| Topology |
Demonstrates the membership service.
|
| TotalOrder |
Originally written to be a demo for TOTAL order (code to be written by a student).
|
| TotalOrder.EventHandler |
|
| TotOrderRequest |
|
| TP |
Generic transport - specific implementations should extend this abstract class.
|
| TpHeader |
Generic transport header, used by TP.
|
| TRACE |
|
| TransferQueueBundler |
This bundler adds all (unicast or multicast) messages to a queue until max size has been exceeded, but does send
messages immediately when no other messages are available.
|
| TransferQueueBundler2 |
This bundler adds all (unicast or multicast) messages to a queue until max size has been exceeded, but does send
messages immediately when no other messages are available.
|
| TransferQueueBundler2.Buffer |
|
| Triple<V1,V2,V3> |
Holds 3 values, useful when we have a map with a key, but more than 1 value and we don't want to create a separate
holder object for the values, and don't want to pass the values as a list or array.
|
| TUNNEL |
Replacement for UDP.
|
| TUNNEL.TUNNELPolicy |
|
| Tuple<V1,V2> |
Holds 2 values, useful when we have a map with a key, but more than 1 value and we don't want to create a separate
holder object for the values, and don't want to pass the values as a list or array.
|
| UDP |
IP multicast transport based on UDP.
|
| UdpPerf |
Dynamic tool to measure multicast performance of JGroups; every member sends N messages and we measure how long it
takes for all receivers to receive them.
|
| UdpTransport |
Transport based on UDP datagrams.
|
| UFC |
Simple flow control protocol based on a credit system.
|
| UFC_NB |
Non-blocking alternative to UFC.
JIRA: https://issues.redhat.com/browse/JGRP-2172 |
| UNICAST3 |
Reliable unicast protocol using a combination of positive and negative acks.
|
| UNICAST3.State |
|
| UnicastHeader3 |
Moved out of UNICAST3 into separate class. |
| UnicastRequest<T> |
Sends a request to a single target destination
|
| UnicastTest |
Perf tests the UNICAST protocol by sending unicast messages between a sender and a receiver
|
| UnicastTestRpc |
Tests performance of unicast RPCs between a caller and a recipient
|
| UnicastTestTcp |
Same as UnicastTest, but uses pure TCP instead of JGroups
|
| UnicastTestTcpRpc |
Tests the UNICAST by invoking unicast RPCs between a sender and a receiver
|
| UnicastTestTcpSlow |
Same as UnicastTest, but uses pure TCP instead of JGroups
|
| UnknownForkHandler |
Allows a user of fork to define the handling of a message for which no fork stack or fork channel exists.
|
| UnreachableException |
Thrown if member in different site cannot be contacted; used by RELAY2
|
| Unsupported |
Elements annotated with this annotation are unsupported and may get removed from the distribution at any time
|
| UPerf |
Tests the UNICAST by invoking unicast RPCs between a sender and a receiver.
|
| UpHandler |
Provides a hook to hijack all events received by a certain channel which has installed this UpHandler.
|
| Util |
Collection of various utility routines that can not be assigned to other classes.
|
| Util.AddressScope |
|
| UUID |
Logical address which is unique over space and time.
|
| VERIFY_SUSPECT |
Catches SUSPECT events traveling up the stack.
|
| VERIFY_SUSPECT.Entry |
|
| VERIFY_SUSPECT.VerifyHeader |
|
| VERIFY_SUSPECT2 |
Double-checks that a suspected member is really dead.
Details: https://issues.redhat.com/browse/JGRP-2558
Design: https://github.com/belaban/JGroups/blob/master/doc/design/VERIFY_SUSPECT2.txt
|
| VERIFY_SUSPECT2.Entry |
|
| VERIFY_SUSPECT2.VerifyHeader |
|
| Version |
We're using the scheme described at http://www.jboss.com/index.html?module=bb&op=viewtopic&t=77231
for major, minor and micro version numbers.
|
| View |
A view is a local representation of the current membership of a group.
|
| ViewHandler<R> |
Responsible for dispatching JOIN/LEAVE/MERGE requests to the GMS protocol.
|
| ViewId |
ViewIds are used for ordering views (each view has a ViewId and a list of members).
|
| WriteVersionTo |
Extracts version and codename from pom.xml and writes them to ./classes/JGROUPS_VERSION.properties
|
| X509Token |
This is an example of using a preshared token that is encrypted using an X509 certificate for
authentication purposes.
|
| XmlAttribute |
|
| XmlConfigurator |
Uses XML to configure a protocol stack
|
| XmlConfigurator.ElementType |
|
| XmlElement |
|
| XmlInclude |
|
| XmlInclude.Type |
|
| XmlNode |
A simple replacement for a W3C DOM node.
|
| XMLSchemaGenerator |
Iterates over all concrete Protocol classes and creates XML schema used for validation of configuration files.
|
| XMLSchemaGenerator.DelayingElementWriter |
|