org.apache.catalina.tribes.ChannelInterceptor Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.catalina.tribes;
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.
*
* Interceptors are tied together in a linked list.
*
* @see org.apache.catalina.tribes.group.ChannelInterceptorBase
*/
public interface ChannelInterceptor extends MembershipListener, Heartbeat {
/**
* An interceptor can react to a message based on a set bit on the 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.
*
* A simple evaluation if an interceptor should react to the message would be:
* boolean react = (getOptionFlag() == (getOptionFlag() & ChannelMessage.getOptions()));
* The default option is 0, meaning there is no way for the application to trigger the interceptor. The interceptor
* itself will decide.
*
* @return int
*
* @see ChannelMessage#getOptions()
*/
int getOptionFlag();
/**
* Sets the option flag
*
* @param flag int
*
* @see #getOptionFlag()
*/
void setOptionFlag(int flag);
/**
* Set the next interceptor in the list of interceptors
*
* @param next ChannelInterceptor
*/
void setNext(ChannelInterceptor next);
/**
* Retrieve the next interceptor in the list
*
* @return ChannelInterceptor - returns the next interceptor in the list or null if no more interceptors exist
*/
ChannelInterceptor getNext();
/**
* Set the previous interceptor in the list
*
* @param previous ChannelInterceptor
*/
void setPrevious(ChannelInterceptor previous);
/**
* Retrieve the previous interceptor in the list
*
* @return ChannelInterceptor - returns the previous interceptor in the list or null if no more interceptors exist
*/
ChannelInterceptor getPrevious();
/**
* The sendMessage 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
* getNext().sendMessage(destination,msg,payload).
*
* Alternatively the interceptor can stop the message from being sent by not invoking
* getNext().sendMessage(destination,msg,payload).
*
* 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.
*
* The ChannelMessage.getAddress contains Channel.getLocalMember, and can be overwritten 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
*
* @throws ChannelException if a serialization error happens.
*
* @see ErrorHandler
* @see InterceptorPayload
*/
void sendMessage(Member[] destination, ChannelMessage msg, InterceptorPayload payload) throws ChannelException;
/**
* The messageReceived is invoked when a message is received. ChannelMessage.getAddress()
* is the sender, or the reply-to address if it has been overwritten.
*
* @param data ChannelMessage
*/
void messageReceived(ChannelMessage data);
/**
* The heartbeat() method gets invoked periodically to allow interceptors to clean up resources, time
* out object and perform actions that are unrelated to sending/receiving data.
*/
@Override
void heartbeat();
/**
* Intercepts the Channel.hasMembers() method
*
* @return boolean - if the channel has members in its membership group
*
* @see Channel#hasMembers()
*/
boolean hasMembers();
/**
* Intercepts the Channel.getMembers() method
*
* @return the members
*
* @see Channel#getMembers()
*/
Member[] getMembers();
/**
* Intercepts the Channel.getLocalMember(boolean) method
*
* @param incAliveTime boolean
*
* @return the member that represents this node
*
* @see Channel#getLocalMember(boolean)
*/
Member getLocalMember(boolean incAliveTime);
/**
* Intercepts the Channel.getMember(Member) method
*
* @param mbr Member
*
* @return Member - the actual member information, including stay alive
*
* @see Channel#getMember(Member)
*/
Member getMember(Member mbr);
/**
* 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 one of:
*
* - Channel.DEFAULT - will start all services
* - Channel.MBR_RX_SEQ - starts the membership receiver
* - Channel.MBR_TX_SEQ - starts the membership broadcaster
* - Channel.SND_TX_SEQ - starts the replication transmitter
* - Channel.SND_RX_SEQ - starts the replication receiver
*
*
* @throws ChannelException if a startup error occurs or the service is already started.
*
* @see Channel
*/
void start(int svc) throws ChannelException;
/**
* 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 one of:
*
* - Channel.DEFAULT - will shutdown all services
* - Channel.MBR_RX_SEQ - stops the membership receiver
* - Channel.MBR_TX_SEQ - stops the membership broadcaster
* - Channel.SND_TX_SEQ - stops the replication transmitter
* - Channel.SND_RX_SEQ - stops the replication receiver
*
*
* @throws ChannelException if a startup error occurs or the service is already started.
*
* @see Channel
*/
void stop(int svc) throws ChannelException;
/**
* Fire an event.
*
* @param event the event
*/
void fireInterceptorEvent(InterceptorEvent event);
/**
* Return the channel that is related to this interceptor
*
* @return Channel
*/
Channel getChannel();
/**
* Set the channel that is related to this interceptor
*
* @param channel The channel
*/
void setChannel(Channel channel);
interface InterceptorEvent {
int getEventType();
String getEventTypeDesc();
ChannelInterceptor getInterceptor();
}
}