This is an automated email from the ASF dual-hosted git repository.
markt pushed a commit to branch 9.0.x
in repository https://gitbox.apache.org/repos/asf/tomcat.git
commit 3ae984c224e38ad8eae28ba6e3ffd53da95c2a35
Author: Mark Thomas <ma...@apache.org>
AuthorDate: Wed Oct 2 10:57:22 2024 +0100
Updates prior to applying automated code formatting
---
java/org/apache/catalina/tribes/ByteMessage.java | 14 +-
java/org/apache/catalina/tribes/Channel.java | 194 ++++++++++++---------
.../apache/catalina/tribes/ChannelException.java | 3 +-
.../apache/catalina/tribes/ChannelInterceptor.java | 59 ++++---
.../apache/catalina/tribes/ChannelListener.java | 4 +-
.../org/apache/catalina/tribes/ChannelMessage.java | 4 +-
.../apache/catalina/tribes/ChannelReceiver.java | 3 +-
java/org/apache/catalina/tribes/ChannelSender.java | 5 +-
.../org/apache/catalina/tribes/ManagedChannel.java | 1 -
java/org/apache/catalina/tribes/Member.java | 19 +-
.../apache/catalina/tribes/MembershipProvider.java | 20 ++-
.../apache/catalina/tribes/MembershipService.java | 3 +-
.../catalina/tribes/RemoteProcessException.java | 2 +-
13 files changed, 189 insertions(+), 142 deletions(-)
diff --git a/java/org/apache/catalina/tribes/ByteMessage.java
b/java/org/apache/catalina/tribes/ByteMessage.java
index e6f4b5736b..bf3c4269a3 100644
--- a/java/org/apache/catalina/tribes/ByteMessage.java
+++ b/java/org/apache/catalina/tribes/ByteMessage.java
@@ -23,15 +23,17 @@ import java.io.ObjectOutput;
/**
* A byte message is not serialized and deserialized by the channel
- * instead it is sent as a byte array<br>
+ * instead it is sent as a byte array.
+ * <p>
* By default Tribes uses java serialization when it receives an object
* to be sent over the wire. Java serialization is not the most
* efficient of serializing data, and Tribes might not even
* have access to the correct class loaders to deserialize the object properly.
- * <br>
+ * <p>
* The ByteMessage class is a class where the channel when it receives it will
* not attempt to perform serialization, instead it will simply stream the
<code>getMessage()</code>
- * bytes.<br>
+ * bytes.
+ * <p>
* If you are using multiple applications on top of Tribes you should add some
sort of header
* so that you can decide with the <code>ChannelListener.accept()</code>
whether this message was intended
* for you.
@@ -44,8 +46,9 @@ public class ByteMessage implements Externalizable {
/**
- * Creates an empty byte message
- * Constructor also for deserialization
+ * Creates an empty byte message.
+ * <p>
+ * Constructor also for deserialization.
*/
public ByteMessage() {
}
@@ -88,5 +91,4 @@ public class ByteMessage implements Externalizable {
out.write(message,0,message.length);
}
}
-
}
diff --git a/java/org/apache/catalina/tribes/Channel.java
b/java/org/apache/catalina/tribes/Channel.java
index 73534d22b2..52d4c398db 100644
--- a/java/org/apache/catalina/tribes/Channel.java
+++ b/java/org/apache/catalina/tribes/Channel.java
@@ -25,23 +25,26 @@ import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
/**
- * Channel interface<br>
* A channel is a representation of a group of nodes all participating in some
sort of
- * communication with each other.<br>
+ * communication with each other.
+ * <p>
* The channel is the main API class for Tribes, this is essentially the only
class
- * that an application needs to be aware of. Through the channel the
application can:<br>
- * 1. send messages<br>
- * 2. receive message (by registering a <code>ChannelListener</code><br>
- * 3. get all members of the group <code>getMembers()</code><br>
- * 4. receive notifications of members added and members disappeared by
- * registering a <code>MembershipListener</code><br>
- * <br>
- * The channel has 5 major components:<br>
- * 1. Data receiver, with a built in thread pool to receive messages from
other peers<br>
- * 2. Data sender, an implementation for sending data using NIO or java.io<br>
- * 3. Membership listener,listens for membership broadcasts<br>
- * 4. Membership broadcaster, broadcasts membership pings.<br>
- * 5. Channel interceptors, the ability to manipulate messages as they are
sent or arrive<br><br>
+ * that an application needs to be aware of. Through the channel the
application can:
+ * <ul>
+ * <li>send messages</li>
+ * <li>receive message (by registering a <code>ChannelListener</code></li>
+ * <li>get all members of the group <code>getMembers()</code></li>
+ * <li>receive notifications of members added and members disappeared by
+ * registering a <code>MembershipListener</code></li>
+ * </ul>
+ * The channel has 5 major components:
+ * <ul>
+ * <li>Data receiver, with a built in thread pool to receive messages from
other peers</li>
+ * <li>Data sender, an implementation for sending data using NIO or
java.io</li>
+ * <li>Membership listener,listens for membership broadcasts</li>
+ * <li>Membership broadcaster, broadcasts membership pings.</li>
+ * <li>Channel interceptors, the ability to manipulate messages as they are
sent or arrive</li>
+ * </ul>
* The channel layout is:
* <pre><code>
* ChannelListener_1..ChannelListener_N
MembershipListener_1..MembershipListener_N [Application Layer]
@@ -75,8 +78,9 @@ import org.apache.juli.logging.LogFactory;
public interface Channel {
/**
- * Start and stop sequences can be controlled by these constants
- * This allows you to start separate components of the channel <br>
+ * Start and stop sequences can be controlled by these constants.
+ * This allows you to start separate components of the channel.
+ * <p>
* DEFAULT - starts or stops all components in the channel
* @see #start(int)
* @see #stop(int)
@@ -84,8 +88,9 @@ public interface Channel {
int DEFAULT = 15;
/**
- * Start and stop sequences can be controlled by these constants
- * This allows you to start separate components of the channel <br>
+ * Start and stop sequences can be controlled by these constants.
+ * This allows you to start separate components of the channel.
+ * <p>
* SND_RX_SEQ - starts or stops the data receiver. Start means opening a
server socket
* in case of a TCP implementation
* @see #start(int)
@@ -94,8 +99,9 @@ public interface Channel {
int SND_RX_SEQ = 1;
/**
- * Start and stop sequences can be controlled by these constants
- * This allows you to start separate components of the channel <br>
+ * Start and stop sequences can be controlled by these constants.
+ * This allows you to start separate components of the channel.
+ * <p>
* SND_TX_SEQ - starts or stops the data sender. This should not open any
sockets,
* as sockets are opened on demand when a message is being sent
* @see #start(int)
@@ -104,8 +110,9 @@ public interface Channel {
int SND_TX_SEQ = 2;
/**
- * Start and stop sequences can be controlled by these constants
- * This allows you to start separate components of the channel <br>
+ * Start and stop sequences can be controlled by these constants.
+ * This allows you to start separate components of the channel.
+ * <p>
* MBR_RX_SEQ - starts or stops the membership listener. In a multicast
implementation
* this will open a datagram socket and join a group and listen for
membership messages
* members joining
@@ -115,8 +122,9 @@ public interface Channel {
int MBR_RX_SEQ = 4;
/**
- * Start and stop sequences can be controlled by these constants
- * This allows you to start separate components of the channel <br>
+ * Start and stop sequences can be controlled by these constants.
+ * This allows you to start separate components of the channel.
+ * <p>
* MBR_TX_SEQ - starts or stops the membership broadcaster. In a multicast
implementation
* this will open a datagram socket and join a group and broadcast the
local member information
* @see #start(int)
@@ -127,10 +135,12 @@ public interface Channel {
/**
* Send options, when a message is sent, it can have an option flag
* to trigger certain behavior. Most flags are used to trigger channel
interceptors
- * as the message passes through the channel stack. <br>
- * However, there are five default flags that every channel implementation
must implement<br>
+ * as the message passes through the channel stack.
+ * <p>
+ * However, there are five default flags that every channel implementation
must implement.
+ * <p>
* SEND_OPTIONS_BYTE_MESSAGE - The message is a pure byte message and no
marshaling or unmarshaling will
- * be performed.<br>
+ * be performed.
*
* @see #send(Member[], Serializable , int)
* @see #send(Member[], Serializable, int, ErrorHandler)
@@ -140,10 +150,12 @@ public interface Channel {
/**
* Send options, when a message is sent, it can have an option flag
* to trigger certain behavior. Most flags are used to trigger channel
interceptors
- * as the message passes through the channel stack. <br>
- * However, there are five default flags that every channel implementation
must implement<br>
- * SEND_OPTIONS_USE_ACK - Message is sent and an ACK is received when the
message has been received by the recipient<br>
- * If no ack is received, the message is not considered successful<br>
+ * as the message passes through the channel stack.
+ * <p>
+ * However, there are five default flags that every channel implementation
must implement
+ * <p>
+ * SEND_OPTIONS_USE_ACK - Message is sent and an ACK is received when the
message has been received by the recipient.
+ * If no ack is received, the message is not considered successful.
* @see #send(Member[], Serializable , int)
* @see #send(Member[], Serializable, int, ErrorHandler)
*/
@@ -152,11 +164,13 @@ public interface Channel {
/**
* Send options, when a message is sent, it can have an option flag
* to trigger certain behavior. Most flags are used to trigger channel
interceptors
- * as the message passes through the channel stack. <br>
- * However, there are five default flags that every channel implementation
must implement<br>
+ * as the message passes through the channel stack.
+ * <p>
+ * However, there are five default flags that every channel implementation
must implement
+ * <p>
* SEND_OPTIONS_SYNCHRONIZED_ACK - Message is sent and an ACK is received
when the message has been received and
- * processed by the recipient<br>
- * If no ack is received, the message is not considered successful<br>
+ * processed by the recipient.
+ * If no ack is received, the message is not considered successful
* @see #send(Member[], Serializable , int)
* @see #send(Member[], Serializable, int, ErrorHandler)
*/
@@ -165,9 +179,11 @@ public interface Channel {
/**
* Send options, when a message is sent, it can have an option flag
* to trigger certain behavior. Most flags are used to trigger channel
interceptors
- * as the message passes through the channel stack. <br>
- * However, there are five default flags that every channel implementation
must implement<br>
- * SEND_OPTIONS_ASYNCHRONOUS - Message will be placed on a queue and sent
by a separate thread<br>
+ * as the message passes through the channel stack.
+ * <p>
+ * However, there are five default flags that every channel implementation
must implement
+ * <p>
+ * SEND_OPTIONS_ASYNCHRONOUS - Message will be placed on a queue and sent
by a separate thread.
* If the queue is full, behaviour depends on {@link
MessageDispatchInterceptor#isAlwaysSend()}
* @see #send(Member[], Serializable , int)
* @see #send(Member[], Serializable, int, ErrorHandler)
@@ -177,9 +193,11 @@ public interface Channel {
/**
* Send options, when a message is sent, it can have an option flag
* to trigger certain behavior. Most flags are used to trigger channel
interceptors
- * as the message passes through the channel stack. <br>
- * However, there are five default flags that every channel implementation
must implement<br>
- * SEND_OPTIONS_SECURE - Message is sent over an encrypted channel<br>
+ * as the message passes through the channel stack.
+ * <p>
+ * However, there are five default flags that every channel implementation
must implement
+ * <p>
+ * SEND_OPTIONS_SECURE - Message is sent over an encrypted channel
* @see #send(Member[], Serializable , int)
* @see #send(Member[], Serializable, int, ErrorHandler)
*/
@@ -187,7 +205,7 @@ public interface Channel {
/**
* Send options. When a message is sent with this flag on
- * the system sends the message using UDP instead of TCP
+ * the system sends the message using UDP instead of TCP.
* @see #send(Member[], Serializable , int)
* @see #send(Member[], Serializable, int, ErrorHandler)
*/
@@ -195,7 +213,7 @@ public interface Channel {
/**
* Send options. When a message is sent with this flag on
- * the system sends a UDP message on the Multicast address instead of UDP
or TCP to individual addresses
+ * the system sends a UDP message on the Multicast address instead of UDP
or TCP to individual addresses.
* @see #send(Member[], Serializable , int)
* @see #send(Member[], Serializable, int, ErrorHandler)
*/
@@ -204,10 +222,12 @@ public interface Channel {
/**
* Send options, when a message is sent, it can have an option flag
* to trigger certain behavior. Most flags are used to trigger channel
interceptors
- * as the message passes through the channel stack. <br>
- * However, there are five default flags that every channel implementation
must implement<br>
- * SEND_OPTIONS_DEFAULT - the default sending options, just a helper
variable. <br>
- * The default is <code>int SEND_OPTIONS_DEFAULT =
SEND_OPTIONS_USE_ACK;</code><br>
+ * as the message passes through the channel stack.
+ * <p>
+ * However, there are five default flags that every channel implementation
must implement
+ * <p>
+ * SEND_OPTIONS_DEFAULT - the default sending options, just a helper
variable.
+ * The default is <code>SEND_OPTIONS_USE_ACK</code>
* @see #SEND_OPTIONS_USE_ACK
* @see #send(Member[], Serializable , int)
* @see #send(Member[], Serializable, int, ErrorHandler)
@@ -216,28 +236,33 @@ public interface Channel {
/**
- * Adds an interceptor to the stack for message processing<br>
- * Interceptors are ordered in the way they are added.<br>
- * <code>channel.addInterceptor(A);</code><br>
- * <code>channel.addInterceptor(C);</code><br>
- * <code>channel.addInterceptor(B);</code><br>
- * Will result in an interceptor stack like this:<br>
- * <code>A -> C -> B</code><br>
- * The complete stack will look like this:<br>
- * <code>Channel -> A -> C -> B ->
ChannelCoordinator</code><br>
+ * Adds an interceptor to the stack for message processing.
+ * Interceptors are ordered in the way they are added.
+ * <pre><code>
+ * channel.addInterceptor(A);
+ * channel.addInterceptor(C);
+ * channel.addInterceptor(B);
+ * </code></pre>
+ * Will result in an interceptor stack like this:
+ * <code>A -> C -> B</code>
+ * <p>
+ * The complete stack will look like this:
+ * <code>Channel -> A -> C -> B -> ChannelCoordinator</code>
* @param interceptor ChannelInterceptorBase
*/
void addInterceptor(ChannelInterceptor interceptor);
/**
* Starts up the channel. This can be called multiple times for individual
services to start
- * The svc parameter can be the logical or value of any constants
- * @param svc int value of <BR>
- * DEFAULT - will start all services <BR>
- * MBR_RX_SEQ - starts the membership receiver <BR>
- * MBR_TX_SEQ - starts the membership broadcaster <BR>
- * SND_TX_SEQ - starts the replication transmitter<BR>
- * SND_RX_SEQ - starts the replication receiver<BR>
+ * The svc parameter can be the logical or value of any constants.
+ * @param svc one of:
+ * <ul>
+ * <li>DEFAULT - will start all services</li>
+ * <li>MBR_RX_SEQ - starts the membership receiver</li>
+ * <li>MBR_TX_SEQ - starts the membership broadcaster</li>
+ * <li>SND_TX_SEQ - starts the replication transmitter</li>
+ * <li>SND_RX_SEQ - starts the replication receiver</li>
+ * </ul>
* <b>Note:</b> In order for the membership broadcaster to
* transmit the correct information, it has to be started after the
replication receiver.
* @throws ChannelException if a startup error occurs or the service is
already started or an error occurs.
@@ -247,12 +272,14 @@ public interface Channel {
/**
* Shuts down the channel. This can be called multiple times for
individual services to shutdown
* The svc parameter can be the logical or value of any constants
- * @param svc int value of <BR>
- * DEFAULT - will shutdown all services <BR>
- * MBR_RX_SEQ - stops the membership receiver <BR>
- * MBR_TX_SEQ - stops the membership broadcaster <BR>
- * SND_TX_SEQ - stops the replication transmitter<BR>
- * SND_RX_SEQ - stops the replication receiver<BR>
+ * @param svc one of:
+ * <ul>
+ * <li>DEFAULT - will shutdown all services</li>
+ * <li>MBR_RX_SEQ - stops the membership receiver</li>
+ * <li>MBR_TX_SEQ - stops the membership broadcaster</li>
+ * <li>SND_TX_SEQ - stops the replication transmitter</li>
+ * <li>SND_RX_SEQ - stops the replication receiver</li>
+ * </ul>
* @throws ChannelException if a startup error occurs or the service is
already stopped or an error occurs.
*/
void stop(int svc) throws ChannelException;
@@ -286,9 +313,10 @@ public interface Channel {
UniqueId send(Member[] destination, Serializable msg, int options,
ErrorHandler handler) throws ChannelException;
/**
- * Sends a heart beat through the interceptor stacks
+ * Sends a heart beat through the interceptor stacks.
* Use this method to alert interceptors and other components to
- * clean up garbage, timed out messages etc.<br>
+ * clean up garbage, timed out messages etc.
+ * <p>
* If you application has a background thread, then you can save one
thread,
* by configuring your channel to not use an internal heartbeat thread
* and invoking this method.
@@ -304,8 +332,9 @@ public interface Channel {
void setHeartbeat(boolean enable);
/**
- * Add a membership listener, will get notified when a new member joins,
leaves or crashes
- * <br>If the membership listener implements the Heartbeat interface
+ * Add a membership listener, will get notified when a new member joins,
leaves or crashes.
+ * <p>
+ * If the membership listener implements the Heartbeat interface
* the <code>heartbeat()</code> method will be invoked when the heartbeat
runs on the channel
* @param listener MembershipListener
* @see MembershipListener
@@ -313,8 +342,9 @@ public interface Channel {
void addMembershipListener(MembershipListener listener);
/**
- * Add a channel listener, this is a callback object when messages are
received
- * <br>If the channel listener implements the Heartbeat interface
+ * Add a channel listener, this is a callback object when messages are
received.
+ * <p>
+ * If the channel listener implements the Heartbeat interface
* the <code>heartbeat()</code> method will be invoked when the heartbeat
runs on the channel
* @param listener ChannelListener
* @see ChannelListener
@@ -323,21 +353,23 @@ public interface Channel {
void addChannelListener(ChannelListener listener);
/**
- * remove a membership listener, listeners are removed based on
Object.hashCode and Object.equals
+ * Remove a membership listener, listeners are removed based on {@link
Object#hashCode()} and
+ * {@link Object#equals(Object)}.
* @param listener MembershipListener
* @see MembershipListener
*/
void removeMembershipListener(MembershipListener listener);
/**
- * remove a channel listener, listeners are removed based on
Object.hashCode and Object.equals
+ * Remove a channel listener, listeners are removed based on {@link
Object#hashCode()} and
+ * {@link Object#equals(Object)}.
* @param listener ChannelListener
* @see ChannelListener
*/
void removeChannelListener(ChannelListener listener);
/**
- * Returns true if there are any members in the group,
- * this call is the same as <code>getMembers().length > 0</code>
+ * Returns true if there are any members in the group.
+ * This call is the same as <code>getMembers().length > 0</code>
* @return boolean - true if there are any members automatically discovered
*/
boolean hasMembers() ;
@@ -363,7 +395,7 @@ public interface Channel {
* membership information along with a message, and instead of sending
* complete membership details, only send the primary identifier for the
member
* but not the payload or other information. When such message is received
- * the application can retrieve the cached member through this call.<br>
+ * the application can retrieve the cached member through this call.
* In most cases, this is not necessary.
* @param mbr Member
* @return Member
diff --git a/java/org/apache/catalina/tribes/ChannelException.java
b/java/org/apache/catalina/tribes/ChannelException.java
index 5279c35b40..789a9338c0 100644
--- a/java/org/apache/catalina/tribes/ChannelException.java
+++ b/java/org/apache/catalina/tribes/ChannelException.java
@@ -22,7 +22,8 @@ import java.util.ArrayList;
* A channel exception is thrown when an internal error happens
* somewhere in the channel.
* <p>
- * When a global error happens, the cause can be retrieved using
<code>getCause()</code><br><br>
+ * When a global error happens, the cause can be retrieved using
<code>getCause()</code>.
+ * <p>
* If an application is sending a message and some of the recipients fail to
receive it,
* the application can retrieve what recipients failed by using the
<code>getFaultyMembers()</code>
* method. This way, an application will always know if a message was
delivered successfully or not.
diff --git a/java/org/apache/catalina/tribes/ChannelInterceptor.java
b/java/org/apache/catalina/tribes/ChannelInterceptor.java
index f7e41903ed..3152016f0b 100644
--- a/java/org/apache/catalina/tribes/ChannelInterceptor.java
+++ b/java/org/apache/catalina/tribes/ChannelInterceptor.java
@@ -22,7 +22,8 @@ import org.apache.catalina.tribes.group.InterceptorPayload;
* A ChannelInterceptor is an interceptor that intercepts
* messages and membership messages in the channel stack.
* This allows interceptors to modify the message or perform
- * other actions when a message is sent or received.<br>
+ * other actions when a message is sent or received.
+ * <p>
* Interceptors are tied together in a linked list.
* @see org.apache.catalina.tribes.group.ChannelInterceptorBase
*/
@@ -30,13 +31,16 @@ public interface ChannelInterceptor extends
MembershipListener, Heartbeat {
/**
* An interceptor can react to a message based on a set bit on the
- * message options. <br>
+ * message options.
* When a message is sent, the options can be retrieved from
ChannelMessage.getOptions()
- * and if the bit is set, this interceptor will react to it.<br>
- * A simple evaluation if an interceptor should react to the message would
be:<br>
- * <code>boolean react = (getOptionFlag() == (getOptionFlag() &
ChannelMessage.getOptions()));</code><br>
+ * and if the bit is set, this interceptor will react to it.
+ * <p>
+ * A simple evaluation if an interceptor should react to the message would
be:
+ * <br>
+ * <code>boolean react = (getOptionFlag() == (getOptionFlag() &
ChannelMessage.getOptions()));</code>
+ * <br>
* The default option is 0, meaning there is no way for the application to
trigger the
- * interceptor. The interceptor itself will decide.<br>
+ * interceptor. The interceptor itself will decide.
* @return int
* @see ChannelMessage#getOptions()
*/
@@ -76,13 +80,16 @@ public interface ChannelInterceptor extends
MembershipListener, Heartbeat {
/**
* The <code>sendMessage</code> method is called when a message is being
sent to one more destinations.
* The interceptor can modify any of the parameters and then pass on the
message down the stack by
- * invoking <code>getNext().sendMessage(destination,msg,payload)</code><br>
+ * invoking <code>getNext().sendMessage(destination,msg,payload)</code>.
+ * <p>
* Alternatively the interceptor can stop the message from being sent by
not invoking
- * <code>getNext().sendMessage(destination,msg,payload)</code><br>
+ * <code>getNext().sendMessage(destination,msg,payload)</code>.
+ * <p>
* If the message is to be sent asynchronous the application can be
notified of completion and
- * errors by passing in an error handler attached to a payload object.<br>
+ * errors by passing in an error handler attached to a payload object.
+ * <p>
* The ChannelMessage.getAddress contains Channel.getLocalMember, and can
be overwritten
- * to simulate a message sent from another node.<br>
+ * to simulate a message sent from another node.
* @param destination Member[] - the destination for this message
* @param msg ChannelMessage - the message to be sent
* @param payload InterceptorPayload - the payload, carrying an error
handler and future useful data, can be null
@@ -93,7 +100,7 @@ public interface ChannelInterceptor extends
MembershipListener, Heartbeat {
void sendMessage(Member[] destination, ChannelMessage msg,
InterceptorPayload payload) throws ChannelException;
/**
- * the <code>messageReceived</code> is invoked when a message is received.
+ * The <code>messageReceived</code> is invoked when a message is received.
* <code>ChannelMessage.getAddress()</code> is the sender, or the reply-to
address
* if it has been overwritten.
* @param data ChannelMessage
@@ -141,12 +148,14 @@ public interface ChannelInterceptor extends
MembershipListener, Heartbeat {
/**
* Starts up the channel. This can be called multiple times for individual
services to start
* The svc parameter can be the logical or value of any constants
- * @param svc int value of <BR>
- * Channel.DEFAULT - will start all services <BR>
- * Channel.MBR_RX_SEQ - starts the membership receiver <BR>
- * Channel.MBR_TX_SEQ - starts the membership broadcaster <BR>
- * Channel.SND_TX_SEQ - starts the replication transmitter<BR>
- * Channel.SND_RX_SEQ - starts the replication receiver<BR>
+ * @param svc one of:
+ * <ul>
+ * <li>Channel.DEFAULT - will start all services</li>
+ * <li>Channel.MBR_RX_SEQ - starts the membership receiver</li>
+ * <li>Channel.MBR_TX_SEQ - starts the membership broadcaster</li>
+ * <li>Channel.SND_TX_SEQ - starts the replication transmitter</li>
+ * <li>Channel.SND_RX_SEQ - starts the replication receiver</li>
+ * </ul>
* @throws ChannelException if a startup error occurs or the service is
already started.
* @see Channel
*/
@@ -155,12 +164,14 @@ public interface ChannelInterceptor extends
MembershipListener, Heartbeat {
/**
* Shuts down the channel. This can be called multiple times for
individual services to shutdown
* The svc parameter can be the logical or value of any constants
- * @param svc int value of <BR>
- * Channel.DEFAULT - will shutdown all services <BR>
- * Channel.MBR_RX_SEQ - stops the membership receiver <BR>
- * Channel.MBR_TX_SEQ - stops the membership broadcaster <BR>
- * Channel.SND_TX_SEQ - stops the replication transmitter<BR>
- * Channel.SND_RX_SEQ - stops the replication receiver<BR>
+ * @param svc one of:
+ * <ul>
+ * <li>Channel.DEFAULT - will shutdown all services</li>
+ * <li>Channel.MBR_RX_SEQ - stops the membership receiver</li>
+ * <li>Channel.MBR_TX_SEQ - stops the membership broadcaster</li>
+ * <li>Channel.SND_TX_SEQ - stops the replication transmitter</li>
+ * <li>Channel.SND_RX_SEQ - stops the replication receiver</li>
+ * </ul>
* @throws ChannelException if a startup error occurs or the service is
already started.
* @see Channel
*/
@@ -189,6 +200,4 @@ public interface ChannelInterceptor extends
MembershipListener, Heartbeat {
String getEventTypeDesc();
ChannelInterceptor getInterceptor();
}
-
-
}
diff --git a/java/org/apache/catalina/tribes/ChannelListener.java
b/java/org/apache/catalina/tribes/ChannelListener.java
index f591d59407..e774a31aed 100644
--- a/java/org/apache/catalina/tribes/ChannelListener.java
+++ b/java/org/apache/catalina/tribes/ChannelListener.java
@@ -21,13 +21,13 @@ import java.io.Serializable;
* An interface to listens to incoming messages from a channel.
* <p>
* When a message is received, the Channel will invoke the channel listener in
a conditional sequence.
- * <code>if ( listener.accept(msg,sender) )
listener.messageReceived(msg,sender);</code><br>
+ * <code>if (listener.accept(msg,sender))
listener.messageReceived(msg,sender);</code>
+ * <p>
* A ChannelListener implementation MUST NOT return true on
<code>accept(Serializable, Member)</code>
* if it doesn't intend to process the message. The channel can this way track
whether a message
* was processed by an above application or if it was just received and forgot
about, a feature required
* to support message-response(RPC) calls
*/
-
public interface ChannelListener {
/**
diff --git a/java/org/apache/catalina/tribes/ChannelMessage.java
b/java/org/apache/catalina/tribes/ChannelMessage.java
index 4421c569ed..66a6f953f2 100644
--- a/java/org/apache/catalina/tribes/ChannelMessage.java
+++ b/java/org/apache/catalina/tribes/ChannelMessage.java
@@ -23,7 +23,7 @@ import org.apache.catalina.tribes.io.XByteBuffer;
/**
* Message that is passed through the interceptor stack after the
* data serialized in the Channel object and then passed down to the
- * interceptor and eventually down to the ChannelSender component
+ * interceptor and eventually down to the ChannelSender component.
*
*/
public interface ChannelMessage extends Serializable, Cloneable {
@@ -31,7 +31,7 @@ public interface ChannelMessage extends Serializable,
Cloneable {
/**
* Get the address that this message originated from.
- * Almost always <code>Channel.getLocalMember(boolean)</code><br>
+ * Almost always <code>Channel.getLocalMember(boolean)</code>.
* This would be set to a different address
* if the message was being relayed from a host other than the one
* that originally sent it.
diff --git a/java/org/apache/catalina/tribes/ChannelReceiver.java
b/java/org/apache/catalina/tribes/ChannelReceiver.java
index 4995512e14..c23c8ab05f 100644
--- a/java/org/apache/catalina/tribes/ChannelReceiver.java
+++ b/java/org/apache/catalina/tribes/ChannelReceiver.java
@@ -19,9 +19,8 @@ package org.apache.catalina.tribes;
import java.io.IOException;
/**
- * ChannelReceiver Interface<br>
* The <code>ChannelReceiver</code> interface is the data receiver component
- * at the bottom layer, the IO layer (for layers see the javadoc for the
{@link Channel} interface).
+ * at the bottom layer, the IO layer (for layers see the {@link Channel}
interface).
* This class may optionally implement a thread pool for parallel processing
of incoming messages.
*/
public interface ChannelReceiver extends Heartbeat {
diff --git a/java/org/apache/catalina/tribes/ChannelSender.java
b/java/org/apache/catalina/tribes/ChannelSender.java
index 4f7ab4b8ad..e271c23b16 100644
--- a/java/org/apache/catalina/tribes/ChannelSender.java
+++ b/java/org/apache/catalina/tribes/ChannelSender.java
@@ -20,10 +20,9 @@ import java.io.IOException;
/**
- * ChannelReceiver Interface<br>
* The <code>ChannelSender</code> interface is the data sender component
- * at the bottom layer, the IO layer (for layers see the javadoc for the
{@link Channel} interface).<br>
- * The channel sender must support "silent" members, ie, be able to send a
message to a member
+ * at the bottom layer, the IO layer (for layers see the {@link Channel}
interface).
+ * The channel sender must support "silent" members, i.e., be able to send a
message to a member
* that is not in the membership, but is part of the destination parameter
*/
public interface ChannelSender extends Heartbeat
diff --git a/java/org/apache/catalina/tribes/ManagedChannel.java
b/java/org/apache/catalina/tribes/ManagedChannel.java
index ef6914e694..06121df2fc 100644
--- a/java/org/apache/catalina/tribes/ManagedChannel.java
+++ b/java/org/apache/catalina/tribes/ManagedChannel.java
@@ -19,7 +19,6 @@ package org.apache.catalina.tribes;
import java.util.Iterator;
/**
- * Channel interface
* A managed channel interface gives you access to the components of the
channels
* such as senders, receivers, interceptors etc for configurations purposes
*/
diff --git a/java/org/apache/catalina/tribes/Member.java
b/java/org/apache/catalina/tribes/Member.java
index 4eca54e9ad..a93485a116 100644
--- a/java/org/apache/catalina/tribes/Member.java
+++ b/java/org/apache/catalina/tribes/Member.java
@@ -20,13 +20,16 @@ import java.io.Serializable;
/**
* The Member interface, defines a member in the group.
- * Each member can carry a set of properties, defined by the actual
implementation.<BR>
- * A member is identified by the host/ip/uniqueId<br>
- * The host is what interface the member is listening to, to receive data<br>
- * The port is what port the member is listening to, to receive data<br>
- * The uniqueId defines the session id for the member. This is an important
feature
+ * Each member can carry a set of properties, defined by the actual
implementation.
+ * <p>
+ * A member is identified by the host/ip/uniqueId.
+ * <ul>
+ * <li>The host is what interface the member is listening to, to receive
data</li>
+ * <li>The port is what port the member is listening to, to receive data</li>
+ * <li>The uniqueId defines the session id for the member. This is an
important feature
* since a member that has crashed and the starts up again on the same
port/host is
- * not guaranteed to be the same member, so no state transfers will ever be
confused
+ * not guaranteed to be the same member, so no state transfers will ever be
confused.</li>
+ * </ul>
*/
public interface Member extends Serializable {
@@ -85,13 +88,13 @@ public interface Member extends Serializable {
void setMemberAliveTime(long memberAliveTime);
/**
- * The current state of the member
+ * The current state of the member.
* @return {@code true} if the member is functioning correctly
*/
boolean isReady();
/**
- * The current state of the member
+ * The current state of the member.
* @return {@code true} if the member is suspect, but the crash has not
been confirmed
*/
boolean isSuspect();
diff --git a/java/org/apache/catalina/tribes/MembershipProvider.java
b/java/org/apache/catalina/tribes/MembershipProvider.java
index 3a7580e95b..235a9b597f 100644
--- a/java/org/apache/catalina/tribes/MembershipProvider.java
+++ b/java/org/apache/catalina/tribes/MembershipProvider.java
@@ -29,20 +29,24 @@ public interface MembershipProvider {
/**
* Start the membership provider.
- * @param level the readiness level <BR>
- * Channel.DEFAULT - will start all services <BR>
- * Channel.MBR_RX_SEQ - starts the membership receiver <BR>
- * Channel.MBR_TX_SEQ - starts the membership broadcaster <BR>
+ * @param level the readiness level
+ * <ul>
+ * <li>Channel.DEFAULT - will start all services</li>
+ * <li>Channel.MBR_RX_SEQ - starts the membership receiver</li>
+ * <li>Channel.MBR_TX_SEQ - starts the membership broadcaster</li>
+ * </ul>
* @throws Exception if an error occurs
*/
void start(int level) throws Exception;
/**
* Stop the membership provider.
- * @param level the readiness level <BR>
- * Channel.DEFAULT - will stop all services <BR>
- * Channel.MBR_RX_SEQ - stops the membership receiver <BR>
- * Channel.MBR_TX_SEQ - stops the membership broadcaster <BR>
+ * @param level the readiness level
+ * <ul>
+ * <li>Channel.DEFAULT - will stop all services</li>
+ * <li>Channel.MBR_RX_SEQ - stops the membership receiver</li>
+ * <li>Channel.MBR_TX_SEQ - stops the membership broadcaster</li>
+ * </ul>
* @return {@code true} if successful
* @throws Exception if an error occurs
*/
diff --git a/java/org/apache/catalina/tribes/MembershipService.java
b/java/org/apache/catalina/tribes/MembershipService.java
index 257f8af83c..22be1e56c4 100644
--- a/java/org/apache/catalina/tribes/MembershipService.java
+++ b/java/org/apache/catalina/tribes/MembershipService.java
@@ -19,9 +19,8 @@ package org.apache.catalina.tribes;
/**
- * MembershipService Interface<br>
* The <code>MembershipService</code> interface is the membership component
- * at the bottom layer, the IO layer (for layers see the javadoc for the
{@link Channel} interface).<br>
+ * at the bottom layer, the IO layer (for layers see the javadoc for the
{@link Channel} interface).
*/
public interface MembershipService {
diff --git a/java/org/apache/catalina/tribes/RemoteProcessException.java
b/java/org/apache/catalina/tribes/RemoteProcessException.java
index 8b05fc6b27..c72b55036e 100644
--- a/java/org/apache/catalina/tribes/RemoteProcessException.java
+++ b/java/org/apache/catalina/tribes/RemoteProcessException.java
@@ -18,7 +18,7 @@ package org.apache.catalina.tribes;
/**
* Message thrown by a sender when USE_SYNC_ACK receives a FAIL_ACK_COMMAND.
- * <br>
+ * <p>
* This means that the message was received on the remote node but the
processing of the message failed.
* This message will be embedded in a ChannelException.FaultyMember
*
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscr...@tomcat.apache.org
For additional commands, e-mail: dev-h...@tomcat.apache.org
