sdis1819-t4g11

package peer;

import java.io.IOException;

import java.net.DatagramPacket;

import java.net.InetAddress;

import java.net.MulticastSocket;

import java.net.UnknownHostException;

import java.rmi.RemoteException;

import java.rmi.registry.LocateRegistry;

import java.rmi.registry.Registry;

import java.rmi.server.UnicastRemoteObject;

import disk.Disk;

import message.Message;

import peer.channels.Listener;

import peer.protocols.backup.Backup;

import peer.protocols.delete.Delete;

import peer.protocols.restore.Restore;

public class Peer /*extends UnicastRemoteObject*/ implements PeerInterface {

        //private static final long serialVersionUID = 4988282307993613946L;

        private int peerId;

        private Disk disk;

        private Registry rmiReg;

        private String pVersion;

        private String accessPoint;

        private MulticastSocket socket;

        private InetAddress mcAddress;

        private InetAddress mdbAddress;

        private InetAddress mdrAddress;

        private int mcPort;

        private int mdbPort;

        private int mdrPort;

        private Listener mcChannel;

        private Listener mdbChannel;

        private Listener mdrChannel;

        public Peer(String pVersion, int sid, String accessPoint, String mcAddress, int mcPort, String mdbAddress,

                        int mdbPort, String mdrAddress, int mdrPort) throws RemoteException {

                this.peerId = sid;

                try {

                        this.mcAddress = InetAddress.getByName(mcAddress);

                        this.mdbAddress = InetAddress.getByName(mdbAddress);

                        this.mdrAddress = InetAddress.getByName(mdrAddress);

                } catch (UnknownHostException e1) {

                        e1.printStackTrace();

                }

                this.mcPort = mcPort;

                this.mdbPort = mdbPort;

                this.mdrPort = mdrPort;

                this.disk = new Disk("peer" + peerId);

                this.pVersion = pVersion;

                this.accessPoint = accessPoint;

                this.rmiReg = null;

                try {

                        this.socket = new MulticastSocket();

                } catch (IOException e) {

                        e.printStackTrace();

                }

                this.startRMI();

                try {

                        this.startChannels(mcAddress, mcPort, mdbAddress, mdbPort, mdrAddress, mdrPort);

                } catch (IOException e) {

                        e.printStackTrace();

                }

                System.out.println("Peer " + this.peerId + " running...");

        }

        public static void main(String[] args) {

                int id = Integer.parseInt(args[1]);

                int mcPort = Integer.parseInt(args[4]);

                int mdbPort = Integer.parseInt(args[6]);

                int mdrPort = Integer.parseInt(args[8]);

                Peer peer;

                try {

                        peer = new Peer(args[0], id, args[2], args[3], mcPort, args[5], mdbPort, args[7], mdrPort);

                } catch (RemoteException e) {

                        e.printStackTrace();

                        return;

                }

                //String filePath = Disk.resourcesPath + "loremipsum.pdf";

        }

        public void startRMI() {

                try {

                        try {

                                this.rmiReg = LocateRegistry.createRegistry(Registry.REGISTRY_PORT);

                        } catch(Exception e) {

                                this.rmiReg = LocateRegistry.getRegistry(Registry.REGISTRY_PORT);

                        }

                        PeerInterface stub = (PeerInterface) UnicastRemoteObject.exportObject(this, 0);

                        rmiReg.rebind(this.accessPoint, stub);

                } catch (RemoteException e) {

                        e.printStackTrace();

                }

        }

        public void startChannels(String mcA, int mcP, String mdbA, int mdbP, String mdrA, int mdrP) throws IOException {

                this.mcChannel = new Listener(this, mcA, mcP);

                this.mdbChannel = new Listener(this, mdbA, mdbP);

                this.mdrChannel = new Listener(this, mdrA, mdrP);

                Thread mcListener = new Thread(this.mcChannel);

                Thread mdbListener = new Thread(this.mdbChannel);

                Thread mdrListener = new Thread(this.mdrChannel);

                mcListener.start();

                mdbListener.start();

                mdrListener.start();

        }

        public void backup(String path, int replicationDeg) {

                Thread t = new Thread(new Backup(this, path, replicationDeg));

                t.start();

                try {

                        t.join();

                } catch (InterruptedException e) {

                        e.printStackTrace();

                }

        }

        public void delete(String path) {

                Thread t = new Thread(new Delete(this, path));

                t.start();

                try {

                        t.join();

                } catch (InterruptedException e) {

                        e.printStackTrace();

                }

        }

        public void restore(String path) {

                Thread t = new Thread(new Restore(this, path));

                t.start();

                try {

                        t.join();

                } catch (InterruptedException e) {

                        e.printStackTrace();

                }

        }

        public void reclaim(float space) {

        }

        public String state() {

                return "test";

        }

        public void sendToMc(Message m) throws IOException {

                byte[] buf = m.toBytes();

                DatagramPacket packet = new DatagramPacket(buf, buf.length, this.mcChannel.getAddress(),

                                this.mcChannel.getPort());

                socket.send(packet);

        }

        public void sendToMdb(Message m) throws IOException {

                byte[] buf = m.toBytes();

                DatagramPacket packet = new DatagramPacket(buf, buf.length, this.mdbChannel.getAddress(),

                                this.mdbChannel.getPort());

                socket.send(packet);

        }        

        public void sendToMdr(Message m) throws IOException {

                byte[] buf = m.toBytes();

                DatagramPacket packet = new DatagramPacket(buf, buf.length, this.mdrChannel.getAddress(),

                                this.mdrChannel.getPort());

                socket.send(packet);

        }

        /**

         * @return the peerId

         */

        public int getPeerId() {

                return peerId;

        }

        /**

         * @return the disk

         */

        public Disk getDisk() {

                return disk;

        }

        /**

         * @return the rmiReg

         */

        public Registry getRmiReg() {

                return rmiReg;

        }

        /**

         * @return the pVersion

         */

        public String getpVersion() {

                return pVersion;

        }

        /**

         * @return the accessPoint

         */

        public String getAccessPoint() {

                return accessPoint;

        }

        /**

         * @return the socket

         */

        public MulticastSocket getSocket() {

                return socket;

        }

        /**

         * @return the mcChannel

         */

        public Listener getMcChannel() {

                return mcChannel;

        }

        /**

         * @return the mdbChannel

         */

        public Listener getMdbChannel() {

                return mdbChannel;

        }

        /**

         * @return the mdrChannel

         */

        public Listener getMdrChannel() {

                return mdrChannel;

        }

        /**

         * @return the mcAddress

         */

        public InetAddress getMcAddress() {

                return mcAddress;

        }

        /**

         * @return the mcPort

         */

        public int getMcPort() {

                return mcPort;

        }

        /**

         * @return the mdbAddress

         */

        public InetAddress getMdbAddress() {

                return mdbAddress;

        }

        /**

         * @return the mdbPort

         */

        public int getMdbPort() {

                return mdbPort;

        }

        /**

         * @return the mdrAddress

         */

        public InetAddress getMdrAddress() {

                return mdrAddress;

        }

        /**

         * @return the mdrPort

         */

        public int getMdrPort() {

                return mdrPort;

        }

}