[JAVA] Esercizio sulla programmazione di reti

[ybor4]

Salve,
sono disperato! Il prof ci ha dato un esercizio da fare a casa in una settimana ed io sono proprio nel pallone! se non mi date una mano non ce la faro mai!!!!! Se non ce la faccio non potrò dare l'esame! :'(

Ecco la Traccia!

 Fornire l'implementazione della classe NeilsenMizuno che estende la classe astratta DAComponent
 e che implementa l'omonimo algoritmo per la mutua esclusione distribuita.
La suddetta classe deve:

    * far parte del pacchetto org.ml.pr0708.mat[numerodimatricola].nm
    * interagisce con le altri componenti utilizzando i metodi del campo server. Allo scopo dovranno essere implementati le 
opportune estensioni delle classi PacketFactory e Packet, 

hiamate NMPacketFactory e NMPacket e appartenenti allo stesso della classe fornita, che descrivono 
i pacchetti dell'algoritmo richiesto.
    * fornisce un solo costruttore public che prende come argomenti (nell'ordine):
          o un oggetto di tipo Server da utilizzare per invocare il costruttore della classe base
          o un oggetto di tipo SocketAddress che server ad identificare il padre del nodo al momento. Questo valore sarà null se la
 componente che viene costruita possiede il token
    * fornisce i metodi doEnter e doLeave che, rispettivamente, implementano le funzionalità per accedere ed uscire dalla sezione critica
    * fornire il metodo doStart che avvia gli opportuni Thread necessari ad implementare l'algoritmo.

I sorgenti devono essere consegnati all'interno di un file jar contenente che:

    * ha nome <matricola>.jar
    * contiene una cartella <matricola> contenente i soli sorgenti sottomessi dallo studente opportunamente strutturati per rispettare la gerarchia dei pacchetti

Seguendo il corso, con l'aiuto del prof abbiamo preparato queste classi!



Qualsiasi consiglio ed aiuto e bene accetto

/**
 * 
 */
package org.ml.pr0708.da;

import java.io.IOException;
import java.net.ConnectException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.Channel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.LinkedList;

import org.ml.pr0708.da.SyncServer.ServerThread;

/**
 * @author loreti
 *
 */
public class AsyncServer implements Server {
	
	private static int RETRY=10;
	private LinkedList<Packet> queue;
	private SocketAddress address;
	private PacketFactory factory;
	
	public AsyncServer( PacketFactory factory , SocketAddress address ) {
		this.address = address;
		this.queue = new LinkedList<Packet>();
		this.factory = factory;
	}
	
	
	private synchronized void addPacket( Packet p ) {
		queue.add(p);
		notifyAll();
	}
	
	public synchronized void read( Packet p ) throws InterruptedException {
		while (true) {
			for (Packet b : queue) {
				if (p.match(b)) {
					queue.remove(b);
					return ;
				}
			}
			wait();
		}
	}

	public void send( Packet p , SocketAddress dest ) throws IOException {
		boolean flag = true;
		SocketChannel c = null;
		while (flag) {
			try {
				c = SocketChannel.open(dest);
				flag = false;
			} catch (ConnectException e) {
				
			}
		}
		ByteBuffer b = p.createBuffer();
		c.write(b);
		c.close();
	}
	
	public void start() {
		try {
			Selector selector = Selector.open();
			ServerSocketChannel ssc = ServerSocketChannel.open();
			ssc.configureBlocking(false);
			ssc.socket().bind(address);
			ssc.register(selector, SelectionKey.OP_ACCEPT);
			Thread t = new Thread(new ServerThread(selector));
			t.start();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public class ServerThread implements Runnable {

		private Selector selector;

		public ServerThread(Selector selector) {
			this.selector = selector;
		}

		public void run() {
			try {
				while (true) {
					selector.select();
					
					Iterator<SelectionKey> it = selector.selectedKeys().iterator();
					
					while (it.hasNext()) {
						SelectionKey key = it.next();
						it.remove();
						
						handleKey( key );
						
						
					}

				}				
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		private void handleKey(SelectionKey key) throws IOException {
			if (key.isValid()&&key.isAcceptable()) {
				ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
				SocketChannel client = ssc.accept();
				client.configureBlocking(false);
				client.register(selector, SelectionKey.OP_READ);
				return ;
			}
			if (key.isValid()&&key.isReadable()) {
				SocketChannel client  = (SocketChannel) key.channel();
				ByteBuffer b = factory.getByteBuffer();
				client.read(b);
				b.flip();
				addPacket(factory.createPacket(b));
				client.close();
			}
			
		}
		
	}

}

package org.ml.pr0708.da;

public class Controller {
	
	private static Controller c = null;

	public static Controller getInstance() {
		if (c==null) {
			c = new Controller();
		}
		return c;
	}

	private boolean free = true;
	private int current = 0;

	public synchronized void enter(int id) {
		if (free) {
			free = false;
			current = id;
		} else {
			System.err.println("Nodes ( "+current+" ) and ( "+id+" ) are both in critical section!!!!");
			System.exit(-1);
		}
	}
	
	public synchronized void exit() {
		free = true;
		current = -1;
	}

}

/**
 * 
 */
package org.ml.pr0708.da;

import java.nio.ByteBuffer;

/**
 * @author loreti
 *
 */
public abstract class Packet {
	
	protected abstract int packetSize();

	protected abstract boolean match( Packet p );
	
	public abstract ByteBuffer createBuffer();
	
}

/**
 * 
 */
package org.ml.pr0708.da;

import java.nio.ByteBuffer;

/**
 * @author loreti
 *
 */
public interface PacketFactory {

	public ByteBuffer getByteBuffer();
	public Packet	  createPacket(ByteBuffer b);

}

package org.ml.pr0708.da;

import java.io.IOException;
import java.net.SocketAddress;

public interface Server {

	public abstract void read(Packet p) throws InterruptedException;

	public abstract void send(Packet p, SocketAddress dest) throws IOException;

	public abstract void start();

}

/**
 * 
 */
package org.ml.pr0708.da;

import java.io.IOException;
import java.net.ConnectException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.LinkedList;

/**
 * @author loreti
 *
 */
public class SyncServer implements Server {
	
	private static int RETRY=10;
	private LinkedList<Packet> queue;
	private SocketAddress address;
	private PacketFactory factory;
	
	public SyncServer( PacketFactory factory , SocketAddress address ) {
		this.address = address;
		this.queue = new LinkedList<Packet>();
		this.factory = factory;
	}
	
	
	private synchronized void addPacket( Packet p ) {
		queue.add(p);
		notifyAll();
	}
	
	/* (non-Javadoc)
	 * @see org.ml.pr0708.da.Server#read(org.ml.pr0708.da.Packet)
	 */
	public synchronized void read( Packet p ) throws InterruptedException {
		while (true) {
			for (Packet b : queue) {
				if (p.match(b)) {
					queue.remove(b);
					return ;
				}
			}
			wait();
		}
	}

	/* (non-Javadoc)
	 * @see org.ml.pr0708.da.Server#send(org.ml.pr0708.da.Packet, java.net.SocketAddress)
	 */
	public void send( Packet p , SocketAddress dest ) throws IOException {
		boolean flag = true;
		SocketChannel c = null;
		while (flag) {
			try {
				c = SocketChannel.open(dest);
				flag = false;
			} catch (ConnectException e) {
				
			}
		}
		ByteBuffer b = p.createBuffer();
		c.write(b);
		c.close();
	}
	
	/* (non-Javadoc)
	 * @see org.ml.pr0708.da.Server#start()
	 */
	public void start() {
		Thread t = new Thread(new ServerThread());
		t.start();
	}
	
	public class ServerThread implements Runnable {

		public void run() {
			try {
				ServerSocketChannel ssc = ServerSocketChannel.open();
				ssc.socket().bind(address);
				while (true) {
					SocketChannel client = ssc.accept();
					Thread t = new Thread( new Reader(client) );
					t.start();
				}				
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}

	public class Reader implements Runnable {

		private SocketChannel channel;

		public Reader(SocketChannel channel) {
			this.channel = channel;
		}

		public void run() {
			ByteBuffer b = factory.getByteBuffer();
			try {
				channel.read(b);
				b.flip();
				addPacket(factory.createPacket(b));
				channel.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			
		}
		
	}
}

[alka]

Ho spostato la discussione nel forum dedicato a Java.
In futuro, poni qui le tue domande relative a questo linguaggio.

Ciao!