Sequencer multicast protocol using Java

Principalele clase ale proiectului sunt:

SeqTest.java
package sequencer;

import java.awt.*;
import java.awt.event.*;
import java.io.PrintStream;
import java.util.EventObject;

// Referenced classes of package sequencer:

// Group

public class SeqTest extends Frame

implements Runnable, Group.MsgHandler, AdjustmentListener, ActionListener
{

public SeqTest(String host, String myName)

{
super("SeqTest");
returned = "Fred";
paused = false;
setSize(200, 200);
this.myName = myName;
slider = new Scrollbar(0, 0, 10, 0, 100);
slider.addAdjustmentListener(this);
rate = slider.getValue();
stopIt = new Button("Quit");
stopIt.addActionListener(this);
pauseIt = new Button("Pause/Continue");
pauseIt.addActionListener(this);
text = new TextField(80);
setLayout(new BorderLayout());
add("North", text);
add("East", stopIt);
add("West", pauseIt);
add("South", slider);
try
{
group = new Group(host, this, myName);
t = new Thread(this);
t.start();
}
catch(Exception ex)
{
System.out.println("Can't create group: " + ex);
}
}

public void adjustmentValueChanged(AdjustmentEvent e)

{
rate = slider.getValue();
slider.setValue(rate);
}

1
public void actionPerformed(ActionEvent e)
{
if(e.getSource() == stopIt)
{
group.leave();
System.exit(1);
} else
if(e.getSource() == pauseIt)
paused = !paused;
}

public void run()

{
try
{
int i = 0;
do
{
do
if(rate <= 90)
try
{
Thread.sleep((90 - rate) * 10);
}
catch(Exception _ex) { }
while(paused);
group.send((new String(myName + ": " + i++)).getBytes());
} while(true);
}
catch(Exception ex)
{
System.out.println("Applet exception " + ex);
}
}

public synchronized void handle(int count, byte msg[])

{
text.setText(new String(msg, 0, count));
}

public static void main(String args[])

{
if(args.length < 2)
{
System.out.println("Usage: prog host clientName");
} else
{
SeqTest st = new SeqTest(args[0], args[1]);
st.show();
}
}

String returned;
Group group;
Thread t;
Scrollbar slider;

2
 Button stopIt;
Button pauseIt;
TextField text;
int rate;
String myName;
boolean paused;
}

Group.java
package sequencer;

import java.io.*;
import java.net.*;
import java.rmi.Naming;
import java.util.Date;

// Referenced classes of package sequencer:

// SequencerJoinInfo, SequencerException, Sequencer, SequencerImpl

public class Group

implements Runnable
{
public class HeartBeater extends Thread
{

public void run()

{
do
try
{
do
Thread.sleep(period * 1000);
while((new Date()).getTime() - lastSendTime < (long)(period * 1000));
sequencer.heartbeat(myName, lastSequenceRecd);
}
catch(Exception _ex) { }
while(true);
}

int period;

public HeartBeater(int period)

{
this.period = period;
}
}

public interface MsgHandler

{

public abstract void handle(int i, byte abyte0[]);

}

public class GroupException extends Exception

{

3
 public GroupException(String s)
{
super(s);
}
}

public Group(String host, MsgHandler handler, String name)

throws GroupException
{
lastSequenceRecd = -1L;
lastSequenceSent = -1L;
try
{
String fred[] = Naming.list("//mpc2/");
for(int i = 0; i < fred.length; i++)
System.out.println(String.valueOf(fred[i]));

myAddr = InetAddress.getLocalHost();
sequencer = (Sequencer)Naming.lookup("//" + host + "/TKSequencer");
myName = name + myAddr;
SequencerJoinInfo joinInfo = sequencer.join(myName);
groupAddr = joinInfo.addr;
lastSequenceRecd = joinInfo.sequence;
System.out.println("ip of group: " + groupAddr);
socket = new MulticastSocket(10000);
socket.joinGroup(groupAddr);
this.handler = handler;
t = new Thread(this);
t.start();
heartBeater = new HeartBeater(5);
heartBeater.start();
}
catch(SequencerException ex)
{
System.out.println("Couldn't create group " + ex);
throw new GroupException(String.valueOf(ex));
}
catch(Exception ex)
{
System.out.println("Couldn't create group " + ex);
throw new GroupException("Couldn't join to sequencer");
}
}

public void send(byte msg[])

throws GroupException
{
if(socket != null)
try
{
sequencer.send(myName, ++lastSequenceSent, lastSequenceRecd, msg);
lastSendTime = (new Date()).getTime();
}
catch(Exception ex)
{
System.out.println("couldn't contact sequencer " + ex);

4
 throw new GroupException("Couldn't send to sequencer");
}
else
throw new GroupException("Group not joined");
}

public void leave()

{
if(socket != null)
try
{
socket.leaveGroup(groupAddr);
sequencer.leave(myName);
}
catch(Exception ex)
{
System.out.println("couldn't leave group " + ex);
}
}

public void run()

{
try
{
while(true)
{
byte buf[] = new byte[10240];
DatagramPacket dgram = new DatagramPacket(buf, buf.length);
socket.receive(dgram);
ByteArrayInputStream bstream = new ByteArrayInputStream(buf, 0, dgram.getLength());
DataInputStream dstream = new DataInputStream(bstream);
long gotSequence = dstream.readLong();
int count = dstream.read(buf);
long wantSeq = lastSequenceRecd + 1L;
if(lastSequenceRecd >= 0L && wantSeq < gotSequence)
{
for(long getSeq = wantSeq; getSeq < gotSequence; getSeq++)
{
byte bufExtra[] = sequencer.getMissing(getSeq);
int countExtra = bufExtra.length;
System.out.println("Group: fetch missing " + getSeq);
handler.handle(countExtra, bufExtra);
}

}
lastSequenceRecd = gotSequence;
handler.handle(count, buf);
}
}
catch(Exception ex)
{
System.out.println("bad in run " + ex);
}
}

Thread t;
Thread heartBeater;

5
 Sequencer sequencer;
MulticastSocket socket;
MsgHandler handler;
long lastSequenceRecd;
long lastSequenceSent;
InetAddress groupAddr;
InetAddress myAddr;
String myName;
long lastSendTime;
}

Sequencer.java
package sequencer;

import java.rmi.Remote;
import java.rmi.RemoteException;

// Referenced classes of package sequencer:

// SequencerException, SequencerJoinInfo

public interface Sequencer

extends Remote
{

public abstract SequencerJoinInfo join(String s)

throws RemoteException, SequencerException;

public abstract void send(String s, long l, long l1, byte abyte0[])

throws RemoteException;

public abstract void leave(String s)

throws RemoteException;

public abstract byte[] getMissing(long l)

throws RemoteException, SequencerException;

public abstract void heartbeat(String s, long l)

throws RemoteException;
}

SequencerImpl.java
package sequencer;

import java.io.*;
import java.net.*;
import java.rmi.*;
import java.rmi.server.UnicastRemoteObject;
import java.util.Vector;

// Referenced classes of package sequencer:

// SequencerJoinInfo, History, SequencerException, Sequencer

public class SequencerImpl extends UnicastRemoteObject

implements Sequencer
{

6
public SequencerImpl(String name)
throws RemoteException
{
this.name = name;
try
{
history = new History();
mySenders = new Vector();
socket = new MulticastSocket();
groupAddr = InetAddress.getByName("228.5.6.7");
// groupAddr = InetAddress.getByName("172.16.4.124");
}
catch(Exception ex)
{
System.out.println("Couldn't initialise seq: " + ex);
}
}

public synchronized SequencerJoinInfo join(String senderName)

throws RemoteException, SequencerException
{
if(mySenders.contains(senderName))
{
throw new SequencerException(senderName + " not unique");
} else
{
mySenders.addElement(senderName);
history.noteReceived(senderName, sequence);
return new SequencerJoinInfo(groupAddr, sequence);
}
}

public synchronized void send(String sender, long id, long lastRecd, byte msg[])
throws RemoteException
{
try
{
ByteArrayOutputStream bstream = new ByteArrayOutputStream(10240);
DataOutputStream dstream = new DataOutputStream(bstream);
dstream.writeLong(++sequence);
dstream.write(msg, 0, msg.length);
socket.send(new DatagramPacket(bstream.toByteArray(), bstream.size(), groupAddr, 10000));
}
catch(Exception ex)
{
System.out.println("problem sending by sequ " + ex);
}
history.noteReceived(sender, lastRecd);
history.addMsg(sender, sequence, msg);
}

public byte[] getMissing(long sequence)

throws RemoteException, SequencerException
{
byte found[] = history.getMsg(sequence);
if(found != null)
{

7
 System.out.println("Sequencer supplies missing " + sequence);
return found;
} else
{
System.out.println("Sequencer couldn't find missing " + sequence);
throw new SequencerException("Couldn't find missing " + sequence);
}
}

public synchronized void heartbeat(String sender, long lastRecd)

{
System.out.println(sender + " HEARTBEAT: " + lastRecd);
history.noteReceived(sender, lastRecd);
}

public synchronized void leave(String senderName)

throws RemoteException
{
mySenders.removeElement(senderName);
history.eraseSender(senderName);
}

public static void main(String args[])

{
System.setSecurityManager(new RMISecurityManager());
try
{
SequencerImpl impl = new SequencerImpl("TKSequencer");
Naming.rebind("/TKSequencer", impl);
System.out.println("Bound OK");
}
catch(Exception ex)
{
System.out.println("Sequencer server failed: " + ex);
}
}

private int sequence;

private String name;
MulticastSocket socket;
public static final int MAX_MSG_LENGTH = 10240;
private static final String ipAddr = "228.5.6.7";
// private static final String ipAddr = "172.16.4.124";
public static final int GROUP_PORT = 10000;
InetAddress groupAddr;
History history;
Vector mySenders;
}

History.java

package sequencer;

import java.io.PrintStream;
import java.util.Enumeration;
import java.util.Hashtable;

8
public class History extends Hashtable
{

public History()
{
historyCleanedTo = -1L;
senders = new Hashtable();
}

public synchronized void noteReceived(String sender, long recvd)

{
senders.put(sender, new Long(recvd));
}

public synchronized void addMsg(String sender, long sequence, byte msg[])

{
if(msg != null)
put(new Long(sequence), msg);
if(size() > 1024)
{
System.out.println("CLEAN HISTORY; size: " + size());
long min = 0x7fffffffffffffffL;
for(Enumeration enum1 = senders.keys(); enum1.hasMoreElements();)
{
String sent = (String)enum1.nextElement();
Long got = (Long)senders.get(sent);
long have = got.longValue();
System.out.println(sent + " has received " + have);
if(have < min)
min = have;
}

System.out.println("clean from " + (historyCleanedTo + 1L) + " to " + min);

for(long s = historyCleanedTo + 1L; s <= min; s++)
{
remove(new Long(s));
historyCleanedTo = s;
}

System.out.println("CLEANED HISTORY; size is now " + size());

}
}

public byte[] getMsg(long sequence)

{
return (byte[])get(new Long(sequence));
}

public synchronized void eraseSender(String sender)

{
senders.remove(sender);
}

private Hashtable senders;

public static final int MAX_HISTORY = 1024;
long historyCleanedTo;
}

9
Alte clase sunt:
SequencerJoinInfo.java
package sequencer;

import java.io.Serializable;
import java.net.InetAddress;

public class SequencerJoinInfo

implements Serializable
{

public SequencerJoinInfo(InetAddress addr, long sequence)

{
this.addr = addr;
this.sequence = sequence;
}

public InetAddress addr;

public long sequence;
}

SequencerImpl_Skel.java
package sequencer;

import java.io.*;
import java.rmi.*;
import java.rmi.server.*;

// Referenced classes of package sequencer:

// SequencerImpl

public final class SequencerImpl_Skel

implements Skeleton
{

public Operation[] getOperations()

{
return operations;
}

public void dispatch(Remote remote, RemoteCall remotecall, int i, long l)

throws RemoteException, Exception
{
if(l != 0x46fe5f6f059e0674L)
throw new SkeletonMismatchException("Hash mismatch");
SequencerImpl sequencerimpl = (SequencerImpl)remote;
switch(i)
{
case 0: // '\0'
long l1;
try
{
ObjectInput objectinput2 = remotecall.getInputStream();
l1 = objectinput2.readLong();
}
catch(IOException ioexception6)

10
 {
throw new UnmarshalException("Error unmarshaling arguments", ioexception6);
}
finally
{
remotecall.releaseInputStream();
}
byte abyte0[] = sequencerimpl.getMissing(l1);
try
{
ObjectOutput objectoutput1 = remotecall.getResultStream(true);
objectoutput1.writeObject(abyte0);
return;
}
catch(IOException ioexception2)
{
throw new MarshalException("Error marshaling return", ioexception2);
}

case 1: // '\001'
String s;
long l2;
try
{
ObjectInput objectinput3 = remotecall.getInputStream();
s = (String)objectinput3.readObject();
l2 = objectinput3.readLong();
}
catch(IOException ioexception7)
{
throw new UnmarshalException("Error unmarshaling arguments", ioexception7);
}
finally
{
remotecall.releaseInputStream();
}
sequencerimpl.heartbeat(s, l2);
try
{
remotecall.getResultStream(true);
return;
}
catch(IOException ioexception3)
{
throw new MarshalException("Error marshaling return", ioexception3);
}

case 2: // '\002'
String s1;
try
{
ObjectInput objectinput = remotecall.getInputStream();
s1 = (String)objectinput.readObject();
}
catch(IOException ioexception4)
{
throw new UnmarshalException("Error unmarshaling arguments", ioexception4);

11
 }
finally
{
remotecall.releaseInputStream();
}
SequencerJoinInfo sequencerjoininfo = sequencerimpl.join(s1);
try
{
ObjectOutput objectoutput = remotecall.getResultStream(true);
objectoutput.writeObject(sequencerjoininfo);
return;
}
catch(IOException ioexception1)
{
throw new MarshalException("Error marshaling return", ioexception1);
}

case 3: // '\003'
String s2;
try
{
ObjectInput objectinput1 = remotecall.getInputStream();
s2 = (String)objectinput1.readObject();
}
catch(IOException ioexception5)
{
throw new UnmarshalException("Error unmarshaling arguments", ioexception5);
}
finally
{
remotecall.releaseInputStream();
}
sequencerimpl.leave(s2);
try
{
remotecall.getResultStream(true);
return;
}
catch(IOException ioexception)
{
throw new MarshalException("Error marshaling return", ioexception);
}

case 4: // '\004'
String s3;
long l3;
long l4;
byte abyte1[];
try
{
ObjectInput objectinput4 = remotecall.getInputStream();
s3 = (String)objectinput4.readObject();
l3 = objectinput4.readLong();
l4 = objectinput4.readLong();
abyte1 = (byte[])objectinput4.readObject();
}
catch(IOException ioexception9)

12
 {
throw new UnmarshalException("Error unmarshaling arguments", ioexception9);
}
finally
{
remotecall.releaseInputStream();
}
sequencerimpl.send(s3, l3, l4, abyte1);
try
{
remotecall.getResultStream(true);
return;
}
catch(IOException ioexception8)
{
throw new MarshalException("Error marshaling return", ioexception8);
}
}
throw new RemoteException("Method number out of range");
}

public SequencerImpl_Skel()
{
}

private static Operation operations[] = {

new Operation("byte getMissing(long)[]"), new Operation("void heartbeat(java.lang.String, long)"),
new Operation("sequencer.SequencerJoinInfo join(java.lang.String)"), new Operation("void
leave(java.lang.String)"), new Operation("void send(java.lang.String, long, long, byte[])")
};
private static final long interfaceHash = 0x46fe5f6f059e0674L;

SequencerImpl_Stub.java
package sequencer;

import java.io.*;
import java.rmi.*;
import java.rmi.server.*;

// Referenced classes of package sequencer:

// Sequencer, SequencerException, SequencerJoinInfo

public final class SequencerImpl_Stub extends RemoteStub

implements Sequencer, Remote
{

public SequencerImpl_Stub()
{
}

public SequencerImpl_Stub(RemoteRef remoteref)

{
super(remoteref);
}

13
public byte[] getMissing(long l)
throws RemoteException, SequencerException
{
int i = 0;
RemoteRef remoteref = super.ref;
RemoteCall remotecall = remoteref.newCall(this, operations, i, 0x46fe5f6f059e0674L);
try
{
ObjectOutput objectoutput = remotecall.getOutputStream();
objectoutput.writeLong(l);
}
catch(IOException ioexception)
{
throw new MarshalException("Error marshaling arguments", ioexception);
}
try
{
remoteref.invoke(remotecall);
}
catch(RemoteException remoteexception)
{
throw remoteexception;
}
catch(SequencerException sequencerexception)
{
throw sequencerexception;
}
catch(Exception exception)
{
throw new UnexpectedException("Unexpected exception", exception);
}
byte abyte0[];
try
{
ObjectInput objectinput = remotecall.getInputStream();
abyte0 = (byte[])objectinput.readObject();
}
catch(IOException ioexception1)
{
throw new UnmarshalException("Error unmarshaling return", ioexception1);
}
catch(ClassNotFoundException classnotfoundexception)
{
throw new UnmarshalException("Return value class not found", classnotfoundexception);
}
catch(Exception exception2)
{
throw new UnexpectedException("Unexpected exception", exception2);
}
finally
{
remoteref.done(remotecall);
}
return abyte0;
}

public void heartbeat(String s, long l)

14
 throws RemoteException
{
int i = 1;
RemoteRef remoteref = super.ref;
RemoteCall remotecall = remoteref.newCall(this, operations, i, 0x46fe5f6f059e0674L);
try
{
ObjectOutput objectoutput = remotecall.getOutputStream();
objectoutput.writeObject(s);
objectoutput.writeLong(l);
}
catch(IOException ioexception)
{
throw new MarshalException("Error marshaling arguments", ioexception);
}
try
{
remoteref.invoke(remotecall);
}
catch(RemoteException remoteexception)
{
throw remoteexception;
}
catch(Exception exception)
{
throw new UnexpectedException("Unexpected exception", exception);
}
remoteref.done(remotecall);
}

public SequencerJoinInfo join(String s)

throws RemoteException, SequencerException
{
byte byte0 = 2;
RemoteRef remoteref = super.ref;
RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x46fe5f6f059e0674L);
try
{
ObjectOutput objectoutput = remotecall.getOutputStream();
objectoutput.writeObject(s);
}
catch(IOException ioexception)
{
throw new MarshalException("Error marshaling arguments", ioexception);
}
try
{
remoteref.invoke(remotecall);
}
catch(RemoteException remoteexception)
{
throw remoteexception;
}
catch(SequencerException sequencerexception)
{
throw sequencerexception;
}

15
 catch(Exception exception)
{
throw new UnexpectedException("Unexpected exception", exception);
}
SequencerJoinInfo sequencerjoininfo;
try
{
ObjectInput objectinput = remotecall.getInputStream();
sequencerjoininfo = (SequencerJoinInfo)objectinput.readObject();
}
catch(IOException ioexception1)
{
throw new UnmarshalException("Error unmarshaling return", ioexception1);
}
catch(ClassNotFoundException classnotfoundexception)
{
throw new UnmarshalException("Return value class not found", classnotfoundexception);
}
catch(Exception exception2)
{
throw new UnexpectedException("Unexpected exception", exception2);
}
finally
{
remoteref.done(remotecall);
}
return sequencerjoininfo;
}

public void leave(String s)

throws RemoteException
{
byte byte0 = 3;
RemoteRef remoteref = super.ref;
RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x46fe5f6f059e0674L);
try
{
ObjectOutput objectoutput = remotecall.getOutputStream();
objectoutput.writeObject(s);
}
catch(IOException ioexception)
{
throw new MarshalException("Error marshaling arguments", ioexception);
}
try
{
remoteref.invoke(remotecall);
}
catch(RemoteException remoteexception)
{
throw remoteexception;
}
catch(Exception exception)
{
throw new UnexpectedException("Unexpected exception", exception);
}
remoteref.done(remotecall);

16
 }

public void send(String s, long l, long l1, byte abyte0[])

throws RemoteException
{
byte byte0 = 4;
RemoteRef remoteref = super.ref;
RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x46fe5f6f059e0674L);
try
{
ObjectOutput objectoutput = remotecall.getOutputStream();
objectoutput.writeObject(s);
objectoutput.writeLong(l);
objectoutput.writeLong(l1);
objectoutput.writeObject(abyte0);
}
catch(IOException ioexception)
{
throw new MarshalException("Error marshaling arguments", ioexception);
}
try
{
remoteref.invoke(remotecall);
}
catch(RemoteException remoteexception)
{
throw remoteexception;
}
catch(Exception exception)
{
throw new UnexpectedException("Unexpected exception", exception);
}
remoteref.done(remotecall);
}

private static Operation operations[] = {

new Operation("byte getMissing(long)[]"), new Operation("void heartbeat(java.lang.String, long)"),
new Operation("sequencer.SequencerJoinInfo join(java.lang.String)"), new Operation("void
leave(java.lang.String)"), new Operation("void send(java.lang.String, long, long, byte[])")
};
private static final long interfaceHash = 0x46fe5f6f059e0674L;

17