Java Code Examples for org.apache.catalina.tribes.Channel#MBR_TX_SEQ

@Override
public void broadcast(ChannelMessage message) throws ChannelException {
    if (impl==null || (impl.startLevel & Channel.MBR_TX_SEQ)!=Channel.MBR_TX_SEQ )
        throw new ChannelException(sm.getString("mcastService.noStart"));

    byte[] data = XByteBuffer.createDataPackage((ChannelData)message);
    if (data.length>McastServiceImpl.MAX_PACKET_SIZE) {
        throw new ChannelException(sm.getString("mcastService.exceed.maxPacketSize",
                Integer.toString(data.length) ,
                Integer.toString(McastServiceImpl.MAX_PACKET_SIZE)));
    }
    DatagramPacket packet = new DatagramPacket(data,0,data.length);
    try {
        impl.send(false, packet);
    } catch (Exception x) {
        throw new ChannelException(x);
    }
}
 

@Override
public void broadcast(ChannelMessage message) throws ChannelException {
    if (impl==null || (impl.startLevel & Channel.MBR_TX_SEQ)!=Channel.MBR_TX_SEQ )
        throw new ChannelException("Multicast send is not started or enabled.");
    
    byte[] data = XByteBuffer.createDataPackage((ChannelData)message);
    if (data.length>McastServiceImpl.MAX_PACKET_SIZE) {
        throw new ChannelException("Packet length["+data.length+"] exceeds max packet size of "+McastServiceImpl.MAX_PACKET_SIZE+" bytes.");
    }
    DatagramPacket packet = new DatagramPacket(data,0,data.length);
    try {
        impl.send(false, packet);
    } catch (Exception x) {
        throw new ChannelException(x);
    }
}
 

@Override
public void broadcast(ChannelMessage message) throws ChannelException {
    if (impl==null || (impl.startLevel & Channel.MBR_TX_SEQ)!=Channel.MBR_TX_SEQ )
        throw new ChannelException("Multicast send is not started or enabled.");
    
    byte[] data = XByteBuffer.createDataPackage((ChannelData)message);
    if (data.length>McastServiceImpl.MAX_PACKET_SIZE) {
        throw new ChannelException("Packet length["+data.length+"] exceeds max packet size of "+McastServiceImpl.MAX_PACKET_SIZE+" bytes.");
    }
    DatagramPacket packet = new DatagramPacket(data,0,data.length);
    try {
        impl.send(false, packet);
    } catch (Exception x) {
        throw new ChannelException(x);
    }
}
 

/**
 * 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 - 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>
 * @throws ChannelException if a startup error occurs or the service is already started.
 */
protected synchronized void internalStop(int svc) throws ChannelException {
    try {
        //make sure we don't pass down any flags that are unrelated to the bottom layer
        svc = svc & Channel.DEFAULT;

        if (startLevel == 0) return; //we have already stopped up all components
        if (svc == 0 ) return;//nothing to stop

        boolean valid = false;
        if ( Channel.SND_RX_SEQ==(svc & Channel.SND_RX_SEQ) ) {
            clusterReceiver.stop();
            clusterReceiver.setMessageListener(null);
            valid = true;
        }
        if ( Channel.SND_TX_SEQ==(svc & Channel.SND_TX_SEQ) ) {
            clusterSender.stop();
            valid = true;
        }

        if ( Channel.MBR_RX_SEQ==(svc & Channel.MBR_RX_SEQ) ) {
            membershipService.stop(MembershipService.MBR_RX);
            membershipService.setMembershipListener(null);
            valid = true;

        }
        if ( Channel.MBR_TX_SEQ==(svc & Channel.MBR_TX_SEQ) ) {
            valid = true;
            membershipService.stop(MembershipService.MBR_TX);
        }
        if ( !valid) {
            throw new IllegalArgumentException(sm.getString("channelCoordinator.invalid.startLevel"));
        }

        startLevel = (startLevel & (~svc));
        setChannel(null);
    } catch (Exception x) {
        throw new ChannelException(x);
    }
}
 

/**
 * Start the service
 * @param level 1 starts the receiver, level 2 starts the sender
 * @throws IOException if the service fails to start
 * @throws IllegalStateException if the service is already started
 */
public synchronized void start(int level) throws IOException {
    boolean valid = false;
    if ( (level & Channel.MBR_RX_SEQ)==Channel.MBR_RX_SEQ ) {
        if ( receiver != null ) throw new IllegalStateException(sm.getString("mcastServiceImpl.receive.running"));
        try {
            if ( sender == null ) socket.joinGroup(address);
        }catch (IOException iox) {
            log.error(sm.getString("mcastServiceImpl.unable.join"));
            throw iox;
        }
        doRunReceiver = true;
        receiver = new ReceiverThread();
        receiver.setDaemon(true);
        receiver.start();
        valid = true;
    }
    if ( (level & Channel.MBR_TX_SEQ)==Channel.MBR_TX_SEQ ) {
        if ( sender != null ) throw new IllegalStateException(sm.getString("mcastServiceImpl.send.running"));
        if ( receiver == null ) socket.joinGroup(address);
        //make sure at least one packet gets out there
        send(false);
        doRunSender = true;
        sender = new SenderThread(sendFrequency);
        sender.setDaemon(true);
        sender.start();
        //we have started the receiver, but not yet waited for membership to establish
        valid = true;
    }
    if (!valid) {
        throw new IllegalArgumentException(sm.getString("mcastServiceImpl.invalid.startLevel"));
    }
    //pause, once or twice
    waitForMembers(level);
    startLevel = (startLevel | level);
}
 

/**
 * Start the service
 * @param level 1 starts the receiver, level 2 starts the sender
 * @throws IOException if the service fails to start
 * @throws IllegalStateException if the service is already started
 */
public synchronized void start(int level) throws IOException {
    boolean valid = false;
    if ( (level & Channel.MBR_RX_SEQ)==Channel.MBR_RX_SEQ ) {
        if ( receiver != null ) throw new IllegalStateException("McastService.receive already running.");
        try {
            if ( sender == null ) socket.joinGroup(address);
        }catch (IOException iox) {
            log.error("Unable to join multicast group, make sure your system has multicasting enabled.");
            throw iox;
        }
        doRunReceiver = true;
        receiver = new ReceiverThread();
        receiver.setDaemon(true);
        receiver.start();
        valid = true;
    } 
    if ( (level & Channel.MBR_TX_SEQ)==Channel.MBR_TX_SEQ ) {
        if ( sender != null ) throw new IllegalStateException("McastService.send already running.");
        if ( receiver == null ) socket.joinGroup(address);
        //make sure at least one packet gets out there
        send(false);
        doRunSender = true;
        sender = new SenderThread(sendFrequency);
        sender.setDaemon(true);
        sender.start();
        //we have started the receiver, but not yet waited for membership to establish
        valid = true;
    } 
    if (!valid) {
        throw new IllegalArgumentException("Invalid start level. Only acceptable levels are Channel.MBR_RX_SEQ and Channel.MBR_TX_SEQ");
    }
    //pause, once or twice
    waitForMembers(level);
    startLevel = (startLevel | level);
}
 

/**
 * Start the service
 * @param level 1 starts the receiver, level 2 starts the sender
 * @throws IOException if the service fails to start
 * @throws IllegalStateException if the service is already started
 */
public synchronized void start(int level) throws IOException {
    boolean valid = false;
    if ( (level & Channel.MBR_RX_SEQ)==Channel.MBR_RX_SEQ ) {
        if ( receiver != null ) throw new IllegalStateException("McastService.receive already running.");
        try {
            if ( sender == null ) socket.joinGroup(address);
        }catch (IOException iox) {
            log.error("Unable to join multicast group, make sure your system has multicasting enabled.");
            throw iox;
        }
        doRunReceiver = true;
        receiver = new ReceiverThread();
        receiver.setDaemon(true);
        receiver.start();
        valid = true;
    } 
    if ( (level & Channel.MBR_TX_SEQ)==Channel.MBR_TX_SEQ ) {
        if ( sender != null ) throw new IllegalStateException("McastService.send already running.");
        if ( receiver == null ) socket.joinGroup(address);
        //make sure at least one packet gets out there
        send(false);
        doRunSender = true;
        sender = new SenderThread(sendFrequency);
        sender.setDaemon(true);
        sender.start();
        //we have started the receiver, but not yet waited for membership to establish
        valid = true;
    } 
    if (!valid) {
        throw new IllegalArgumentException("Invalid start level. Only acceptable levels are Channel.MBR_RX_SEQ and Channel.MBR_TX_SEQ");
    }
    //pause, once or twice
    waitForMembers(level);
    startLevel = (startLevel | level);
}
 

/**
 * 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>
 * @throws ChannelException if a startup error occurs or the service is already started.
 */
protected synchronized void internalStart(int svc) throws ChannelException {
    try {
        boolean valid = false;
        //make sure we don't pass down any flags that are unrelated to the bottom layer
        svc = svc & Channel.DEFAULT;

        if (startLevel == Channel.DEFAULT) return; //we have already started up all components
        if (svc == 0 ) return;//nothing to start

        if (svc == (svc & startLevel)) {
            throw new ChannelException(sm.getString("channelCoordinator.alreadyStarted",
                    Integer.toString(svc)));
        }

        //must start the receiver first so that we can coordinate the port it
        //listens to with the local membership settings
        if ( Channel.SND_RX_SEQ==(svc & Channel.SND_RX_SEQ) ) {
            clusterReceiver.setMessageListener(this);
            clusterReceiver.setChannel(getChannel());
            clusterReceiver.start();
            //synchronize, big time FIXME
            Member localMember = getChannel().getLocalMember(false);
            if (localMember instanceof StaticMember) {
                // static member
                StaticMember staticMember = (StaticMember)localMember;
                staticMember.setHost(getClusterReceiver().getHost());
                staticMember.setPort(getClusterReceiver().getPort());
                staticMember.setSecurePort(getClusterReceiver().getSecurePort());
            } else {
                // multicast member
                membershipService.setLocalMemberProperties(getClusterReceiver().getHost(),
                        getClusterReceiver().getPort(),
                        getClusterReceiver().getSecurePort(),
                        getClusterReceiver().getUdpPort());
            }
            valid = true;
        }
        if ( Channel.SND_TX_SEQ==(svc & Channel.SND_TX_SEQ) ) {
            clusterSender.setChannel(getChannel());
            clusterSender.start();
            valid = true;
        }

        if ( Channel.MBR_RX_SEQ==(svc & Channel.MBR_RX_SEQ) ) {
            membershipService.setMembershipListener(this);
            membershipService.setChannel(getChannel());
            if (membershipService instanceof McastService) {
                ((McastService)membershipService).setMessageListener(this);
            }
            membershipService.start(MembershipService.MBR_RX);
            valid = true;
        }
        if ( Channel.MBR_TX_SEQ==(svc & Channel.MBR_TX_SEQ) ) {
            membershipService.setChannel(getChannel());
            membershipService.start(MembershipService.MBR_TX);
            valid = true;
        }

        if (!valid) {
            throw new IllegalArgumentException(sm.getString("channelCoordinator.invalid.startLevel"));
        }
        startLevel = (startLevel | svc);
    }catch ( ChannelException cx ) {
        throw cx;
    }catch ( Exception x ) {
        throw new ChannelException(x);
    }
}
 

/**
 * 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>
 * @throws ChannelException if a startup error occurs or the service is already started.
 */
protected synchronized void internalStart(int svc) throws ChannelException {
    try {
        boolean valid = false;
        //make sure we don't pass down any flags that are unrelated to the bottom layer
        svc = svc & Channel.DEFAULT;

        if (startLevel == Channel.DEFAULT) return; //we have already started up all components
        if (svc == 0 ) return;//nothing to start
        
        if (svc == (svc & startLevel)) throw new ChannelException("Channel already started for level:"+svc);

        //must start the receiver first so that we can coordinate the port it
        //listens to with the local membership settings
        if ( Channel.SND_RX_SEQ==(svc & Channel.SND_RX_SEQ) ) {
            clusterReceiver.setMessageListener(this);
            clusterReceiver.start();
            //synchronize, big time FIXME
            membershipService.setLocalMemberProperties(getClusterReceiver().getHost(), 
                                                       getClusterReceiver().getPort(),
                                                       getClusterReceiver().getSecurePort(),
                                                       getClusterReceiver().getUdpPort());
            valid = true;
        }
        if ( Channel.SND_TX_SEQ==(svc & Channel.SND_TX_SEQ) ) {
            clusterSender.start();
            valid = true;
        }
        
        if ( Channel.MBR_RX_SEQ==(svc & Channel.MBR_RX_SEQ) ) {
            membershipService.setMembershipListener(this);
            if (membershipService instanceof McastService) {
                ((McastService)membershipService).setMessageListener(this);
            }
            membershipService.start(MembershipService.MBR_RX);
            valid = true;
        }
        if ( Channel.MBR_TX_SEQ==(svc & Channel.MBR_TX_SEQ) ) {
            membershipService.start(MembershipService.MBR_TX);
            valid = true;
        }
        
        if ( !valid) {
            throw new IllegalArgumentException("Invalid start level, valid levels are:SND_RX_SEQ,SND_TX_SEQ,MBR_TX_SEQ,MBR_RX_SEQ");
        }
        startLevel = (startLevel | svc);
    }catch ( ChannelException cx ) {
        throw cx;
    }catch ( Exception x ) {
        throw new ChannelException(x);
    }
}
 

/**
 * 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 - 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>
 * @throws ChannelException if a startup error occurs or the service is already started.
 */
protected synchronized void internalStop(int svc) throws ChannelException {
    try {
        //make sure we don't pass down any flags that are unrelated to the bottom layer
        svc = svc & Channel.DEFAULT;

        if (startLevel == 0) return; //we have already stopped up all components
        if (svc == 0 ) return;//nothing to stop

        boolean valid = false;
        if ( Channel.SND_RX_SEQ==(svc & Channel.SND_RX_SEQ) ) {
            clusterReceiver.stop();
            clusterReceiver.setMessageListener(null);
            valid = true;
        }
        if ( Channel.SND_TX_SEQ==(svc & Channel.SND_TX_SEQ) ) {
            clusterSender.stop();
            valid = true;
        }

        if ( Channel.MBR_RX_SEQ==(svc & Channel.MBR_RX_SEQ) ) {
            membershipService.stop(MembershipService.MBR_RX);
            membershipService.setMembershipListener(null);
            valid = true;
            
        }
        if ( Channel.MBR_TX_SEQ==(svc & Channel.MBR_TX_SEQ) ) {
            valid = true;
            membershipService.stop(MembershipService.MBR_TX);
        }            
        if ( !valid) {
            throw new IllegalArgumentException("Invalid start level, valid levels are:SND_RX_SEQ,SND_TX_SEQ,MBR_TX_SEQ,MBR_RX_SEQ");
        }

        startLevel = (startLevel & (~svc));
        
    }catch ( Exception x ) {
        throw new ChannelException(x);
    } finally {
        
    }

}
 

/**
 * 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>
 * @throws ChannelException if a startup error occurs or the service is already started.
 */
protected synchronized void internalStart(int svc) throws ChannelException {
    try {
        boolean valid = false;
        //make sure we don't pass down any flags that are unrelated to the bottom layer
        svc = svc & Channel.DEFAULT;

        if (startLevel == Channel.DEFAULT) return; //we have already started up all components
        if (svc == 0 ) return;//nothing to start
        
        if (svc == (svc & startLevel)) throw new ChannelException("Channel already started for level:"+svc);

        //must start the receiver first so that we can coordinate the port it
        //listens to with the local membership settings
        if ( Channel.SND_RX_SEQ==(svc & Channel.SND_RX_SEQ) ) {
            clusterReceiver.setMessageListener(this);
            if (clusterReceiver instanceof ReceiverBase) {
                ((ReceiverBase)clusterReceiver).setChannel(getChannel());
            }
            clusterReceiver.start();
            //synchronize, big time FIXME
            Member localMember = getChannel().getLocalMember(false);
            if (localMember instanceof StaticMember) {
                // static member
                StaticMember staticMember = (StaticMember)localMember;
                staticMember.setHost(getClusterReceiver().getHost());
                staticMember.setPort(getClusterReceiver().getPort());
                staticMember.setSecurePort(getClusterReceiver().getSecurePort());
            } else {
                // multicast member
                membershipService.setLocalMemberProperties(getClusterReceiver().getHost(),
                        getClusterReceiver().getPort(),
                        getClusterReceiver().getSecurePort(),
                        getClusterReceiver().getUdpPort());
               
            }
            valid = true;
        }
        if ( Channel.SND_TX_SEQ==(svc & Channel.SND_TX_SEQ) ) {
            if (clusterSender instanceof ReplicationTransmitter) {
                ((ReplicationTransmitter)clusterSender).setChannel(getChannel());
            }
            valid = true;
            clusterSender.start();
        }
        
        if ( Channel.MBR_RX_SEQ==(svc & Channel.MBR_RX_SEQ) ) {
            membershipService.setMembershipListener(this);
            if (membershipService instanceof McastService) {
                ((McastService)membershipService).setMessageListener(this);
                ((McastService)membershipService).setChannel(getChannel());
            }
            membershipService.start(MembershipService.MBR_RX);
            valid = true;
        }
        if ( Channel.MBR_TX_SEQ==(svc & Channel.MBR_TX_SEQ) ) {
            if (membershipService instanceof McastService) {
                ((McastService)membershipService).setChannel(getChannel());
            }
            membershipService.start(MembershipService.MBR_TX);
            valid = true;
        }
        
        if ( !valid) {
            throw new IllegalArgumentException("Invalid start level, valid levels are:SND_RX_SEQ,SND_TX_SEQ,MBR_TX_SEQ,MBR_RX_SEQ");
        }
        startLevel = (startLevel | svc);
    }catch ( ChannelException cx ) {
        throw cx;
    }catch ( Exception x ) {
        throw new ChannelException(x);
    }
}
 

/**
 * 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 - 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>
 * @throws ChannelException if a startup error occurs or the service is already started.
 */
protected synchronized void internalStop(int svc) throws ChannelException {
    try {
        //make sure we don't pass down any flags that are unrelated to the bottom layer
        svc = svc & Channel.DEFAULT;

        if (startLevel == 0) return; //we have already stopped up all components
        if (svc == 0 ) return;//nothing to stop

        boolean valid = false;
        if ( Channel.SND_RX_SEQ==(svc & Channel.SND_RX_SEQ) ) {
            clusterReceiver.stop();
            clusterReceiver.setMessageListener(null);
            valid = true;
        }
        if ( Channel.SND_TX_SEQ==(svc & Channel.SND_TX_SEQ) ) {
            clusterSender.stop();
            valid = true;
        }

        if ( Channel.MBR_RX_SEQ==(svc & Channel.MBR_RX_SEQ) ) {
            membershipService.stop(MembershipService.MBR_RX);
            membershipService.setMembershipListener(null);
            valid = true;
            
        }
        if ( Channel.MBR_TX_SEQ==(svc & Channel.MBR_TX_SEQ) ) {
            valid = true;
            membershipService.stop(MembershipService.MBR_TX);
        }            
        if ( !valid) {
            throw new IllegalArgumentException("Invalid start level, valid levels are:SND_RX_SEQ,SND_TX_SEQ,MBR_TX_SEQ,MBR_RX_SEQ");
        }

        startLevel = (startLevel & (~svc));
        setChannel(null);
    }catch ( Exception x ) {
        throw new ChannelException(x);
    } finally {
        
    }

}