sdis1819-t4g14

javac -cp /Users/zemiguel/IdeaProjects/SDIS-P1/src/ main/java/testapp/TestApp.java

java -Djava.net.preferIPv4Stack=true -Djava.rmi.serv.codebase=file:/Users/zemiguel/IdeaProjects/SDIS-P1/src/main/java/service/ main/java/testapp/TestApp 127.0.0.1/obj RESTORE test1.pdf

find . -type f -name '*.class' -delete

javac -cp /Users/zemiguel/IdeaProjects/SDIS-P1/src/ main/java/peer/Peer.java

java -Djava.net.preferIPv4Stack=true -Djava.rmi.server.codebase=file:/Users/zemiguel/IdeaProjects/SDIS-P1/src/main/java/service/ main/java/peer/Peer 1.0 0 192.168.0.1 224.0.0.0:8000 224.0.0.0:8001 224.0.0.0:8002

# SDIS-P1

## From the src/ folder:

### Compile the Peer:

javac main/java/peer/Peer.java

### Compile the TestApp:

javac main/java/testapp/TestApp.java

### Run RMI:

rmiregistry &

### Run Peer that launches RMI:

java main/java/peer/Peer <protocol_version> <peer_id> <RMI_Access_Point> <MC_IP>:<MP_PORT> <MDB_IP>:<MDP_PORT> <MDR_IP>:<MDR_PORT>

ex:

java main/java/peer/Peer 1.0 0 192.168.0.1 224.0.0.0:8000 224.0.0.0:8001 224.0.0.0:8002

### Run normal peers:

java main/java/peer/Peer <protocol_version> <peer_id> <MC_IP>:<MP_PORT> <MDB_IP>:<MDP_PORT> <MDR_IP>:<MDR_PORT>

ex:

java main/java/peer/Peer 1.0 1 224.0.0.0:8000 224.0.0.0:8001 224.0.0.0:8002

### Run a TestApp:

## Backup:

java main/java/testapp/TestApp <rmi_peer_ip>/obj BACKUP <file_path> <replication_degree>

ex:

java main/java/testapp/TestApp 127.0.0.1/obj BACKUP /Users/zemiguel/IdeaProjects/SDIS-P1/src/files/test1.pdf 1

## Restore:

java main/java/testapp/TestApp <rmi_peer_ip>/obj RESTORE <file_name> <replication_degree>

ex:

java main/java/testapp/TestApp 127.0.0.1/obj RESTORE test1.pdf

## Delete:

java main/java/testapp/TestApp <rmi_peer_ip>/obj DELETE <file_name>

ex:

java main/java/testapp/TestApp 127.0.0.1/obj DELETE test1.pdf

## Reclaim:

java main/java/testapp/TestApp <rmi_peer_ip>/obj RECLAIM <amount>

ex:

java main/java/testapp/TestApp 127.0.0.1/obj RECLAIM 0

## State:

java main/java/testapp/TestApp <rmi_peer_ip>/obj STATE

ex:

java main/java/testapp/TestApp 127.0.0.1/obj STATE

FICHEIRO DE TESTE

package main.java.database;

import main.java.file.FileChunkID;

import main.java.file.FileID;

import main.java.peer.Peer;

import java.io.File;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

public class Database implements Serializable {

    private static final long serialVersionUID = 1L;

    private ConcurrentHashMap<FileChunkID, ArrayList<Integer>> perceivedRepDeg;

    private ConcurrentHashMap<FileChunkID, Integer> desiredRepDeg;

    private List<FileID> storedFiles;

    public Database() {

        storedFiles = new ArrayList<>();

        perceivedRepDeg = new ConcurrentHashMap<FileChunkID, ArrayList<Integer>>();

        desiredRepDeg = new ConcurrentHashMap<FileChunkID, Integer>();

    }

    public synchronized void insertChunkInfo(FileID fileID, int replicationDegree, int chunkNo, int peerID) {

        FileChunkID id = new FileChunkID(fileID.toString(), chunkNo);

        perceivedRepDeg.put(id, new ArrayList<>());

        perceivedRepDeg.get(id).add(peerID);

        desiredRepDeg.put(id, replicationDegree);

        Peer.saveDBToDisk();

    }

    public synchronized void removeChunkInfo(FileChunkID chunkID){

        desiredRepDeg.remove(chunkID);

        perceivedRepDeg.remove(chunkID);

        Peer.saveDBToDisk();

    }

    public void printDatabase() {

        /*

        For each file whose backup it has initiated:

                The file pathname

                The backup service id of the file

                The desired replication degree

                    For each chunk of the file:

                        Its id

                        Its perceived replication degree

         */

        System.out.println("----------------------------------------------------");

        System.out.println("Printing Database Info...\n\n");

        if(!storedFiles.isEmpty()){

            System.out.println("Files I have backed up: ");

            for (FileID fid: storedFiles){

                if(fid.getNumChunks()!=-1){

                    System.out.println("\t id: " + fid.toString());

                    System.out.println("\t Desired rep degree: " + fid.getDesiredRepDeg());

                    System.out.println("\t Chunks: ");

                    Iterator<Map.Entry<FileChunkID, ArrayList<Integer>>> it = perceivedRepDeg.entrySet().iterator();

                    while (it.hasNext()) {

                        Map.Entry<FileChunkID, ArrayList<Integer>> pair = it.next();

                        FileChunkID cID = pair.getKey();

                        if(cID.getFileID().equals(fid.toString())){

                            ArrayList<Integer> replications = pair.getValue();

                            System.out.println("\t\t ChunkNo:" + cID.getChunkNumber()+ " Perceived Replication Degree:"

                            + replications.size());

                        }

                        it.remove(); // avoids a ConcurrentModificationException

                    }

                }

            }

            System.out.println("----------------------------------------------------");

            System.out.println("Chunks on my system: ");

            for (FileID fid: storedFiles){

                if(fid.getNumChunks()==-1){

                    Iterator<Map.Entry<FileChunkID, ArrayList<Integer>>> it = perceivedRepDeg.entrySet().iterator();

                    while (it.hasNext()) {

                        Map.Entry<FileChunkID, ArrayList<Integer>> pair = it.next();

                        FileChunkID cID = pair.getKey();

                        if(cID.getFileID().equals(fid.toString())){

                            ArrayList<Integer> replications = pair.getValue();

                            File f = new File("peer"+Peer.getID()+"/Backup/"+fid.toString().split("\\.")[0]+

                                    "/"+cID.toString());

                            System.out.println("\t\t ChunkNo:" + cID.getChunkNumber()+ " Perceived Replication Degree:"

                                    + replications.size() + " Size:"+ f.length());

                        }

                        it.remove(); // avoids a ConcurrentModificationException

                    }

                }

            }

            System.out.println("----------------------------------------------------");

        }

    }

    public synchronized void insertFile(FileID fileID) {

        if(!storedFiles.contains(fileID)){

            storedFiles.add(fileID);

            Peer.saveDBToDisk();

        }

        else {

            int i = storedFiles.indexOf(fileID);

            storedFiles.get(i).setNumChunks(fileID.getNumChunks());

        }

    }

    public synchronized void removeFile(FileID fileID){

        storedFiles.remove(fileID);

        Peer.saveDBToDisk();

    }

    public synchronized int getNumChunksOfFile(FileID fID){

        int index = storedFiles.indexOf(fID);

        if(index!=-1)

            return storedFiles.get(index).getNumChunks();

        else

            return -1;

    }

    public String printStoredFiles() {

        return "\t Stored Files: \n " +

                storedFiles.toString() + "\n";

    }

    public boolean isFileStored(FileID fID) {

        return storedFiles.contains(fID);

    }

    public List<String> getFileChunksofFileID(FileID fileID) {

        List<String> chunksOfFile = new ArrayList<>();

        printDatabase();

        for(FileID fid : storedFiles) {

            if(fid.equals(fileID)) {

                for (int i = 0; i < fid.getNumChunks(); i++){

                    chunksOfFile.add(fid + "-" + i);

                }

            }

        }

        return chunksOfFile;

    }

    public synchronized void addNewRepDegCounter(FileChunkID chunkID, Integer repDeg){

        if (!perceivedRepDeg.containsKey(chunkID)) {

            perceivedRepDeg.put(chunkID, new ArrayList<>());

        }

        if (!desiredRepDeg.containsKey(chunkID)) {

            desiredRepDeg.put(chunkID, repDeg);

        }

        System.out.println("SAVING DB");

        Peer.saveDBToDisk();

    }

    public void removeRepDegCounter(FileChunkID chunkID){

        perceivedRepDeg.remove(chunkID);

        desiredRepDeg.remove(chunkID);

    }

    public synchronized void increasePerceivedRepDeg(FileChunkID chunkID, int senderID){

        if(perceivedRepDeg.containsKey(chunkID)) {

            if (!perceivedRepDeg.get(chunkID).contains(senderID)) {

                perceivedRepDeg.get(chunkID).add(senderID);

                System.out.println("SAVING DB");

                //dumpPerceived();

                Peer.saveDBToDisk();

            }

        }

        else {

            perceivedRepDeg.put(chunkID, new ArrayList<>());

            perceivedRepDeg.get(chunkID).add(senderID);

        }

    }

    public void dumpPerceived() {

        System.out.println("DUMPING PERCEIVED!");

        for (FileChunkID name: perceivedRepDeg.keySet()){

            String key =name.toString();

            String value = perceivedRepDeg.get(name).toString();

            System.out.println(key + " " + value);

        }

    }

    public void decreasePerceivedRepDeg(FileChunkID chunkID, int senderID){

        if(perceivedRepDeg.containsKey(chunkID)) {

            if (perceivedRepDeg.get(chunkID).contains(senderID)) {

                System.out.println("DECRESING FROM: " + perceivedRepDeg.get(chunkID).size());

                perceivedRepDeg.get(chunkID).remove(senderID);

                if(perceivedRepDeg.get(chunkID).size()==0)

                    perceivedRepDeg.remove(chunkID);

                System.out.println("DECRESING TO: " + perceivedRepDeg.get(chunkID).size());

                System.out.println("SAVING DB");

                Peer.saveDBToDisk();

            }

        }

    }

    public int getPerceivedRepDeg(FileChunkID chunkID){

        //dumpPerceived();

        if(perceivedRepDeg.containsKey(chunkID))

            return perceivedRepDeg.get(chunkID).size();

        else

            return -1;

    }

    public Integer getDesiredRepDeg(FileChunkID chunkID){

        if(desiredRepDeg.containsKey(chunkID))

            return desiredRepDeg.get(chunkID);

        else

            return -1;

    }

    public synchronized FileChunkID getHighestPerceivedRepDegChunk() {

        FileChunkID best = null;

        for (FileChunkID chunkID : perceivedRepDeg.keySet()) {

            if (best == null || perceivedRepDeg.get(chunkID).size() > perceivedRepDeg.get(best).size())

                best = chunkID;

        }

        return best;

    }

}

package main.java.file;

import java.io.Serializable;

public class FileChunk implements Serializable {

    private static final long serialVersionUID = 1L;

    private static final int CHUNK_MAX_SIZE = 64000;

    private int replicationDegree;

    private int chunkNo;

    private FileID fileID;

    private byte[] chunkData;

    public FileChunk(int replicationDegree, int chunkNo, FileID fileID, byte[] chunkData) {

        this.replicationDegree = replicationDegree;

        this.chunkNo = chunkNo;

        this.fileID = fileID;

        this.chunkData = chunkData;

    }

    public int getChunkNo() {

        return chunkNo;

    }

    public FileID getFileID() {

        return fileID;

    }

    public byte[] getChunkData() {

        return chunkData;

    }

    public int getReplicationDegree() {

        return replicationDegree;

    }

    @Override

    public String toString() {

        return new String(chunkData);

    }

}

package main.java.file;

import java.io.Serializable;

public class FileChunkID implements Serializable {

    private static final long serialVersionUID = 1L;

    private String fileID;

    private int chunkNumber;

    public FileChunkID(String fileID, int chunkNumber) {

        this.fileID = fileID;

        this.chunkNumber = chunkNumber;

    }

    public String getFileID() {

        return fileID;

    }

    public int getChunkNumber() {

        return chunkNumber;

    }

    @Override

    public int hashCode() {

        int result = 17;

        result = 31 * result + fileID.hashCode();

        result = 31 * result + chunkNumber;

        return result;

    }

    @Override

    public boolean equals(Object obj) {

        if (this == obj)

            return true;

        if (obj == null)

            return false;

        FileChunkID other = (FileChunkID) obj;

        if (this.chunkNumber != other.chunkNumber)

            return false;

        return this.fileID.equals(other.fileID);

    }

    @Override

    public String toString() {

        return fileID + "-" + chunkNumber;

    }

}

package main.java.file;

import java.io.Serializable;

public class FileID implements Serializable {

    private static final long serialVersionUID = 1L;

    private String fileID;

    private int numChunks;

    private int desiredRepDeg;

    public FileID(String fileID, int desiredRepDeg) {

        this.fileID = fileID;

        this.numChunks = -1;

        this.desiredRepDeg = desiredRepDeg;

    }

    @Override

    public String toString() {

        String[] fileIDSplitted = fileID.split("/");

        return fileIDSplitted[fileIDSplitted.length - 1];

    }

    @Override

    public boolean equals(Object o) {

        if (o == this) {

            return true;

        }

        if (!(o instanceof FileID)) {

            return false;

        }

        FileID c = (FileID) o;

        return fileID.equals(c.fileID);

    }

    public void setNumChunks(int numChunks) {

        this.numChunks = numChunks;

    }

    public int getNumChunks() {

        return numChunks;

    }

    public int getDesiredRepDeg() {

        return desiredRepDeg;

    }

}

package main.java.listeners;

import main.java.file.FileChunk;

import main.java.file.FileChunkID;

import main.java.file.FileID;

import main.java.peer.Peer;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.net.DatagramPacket;

import static main.java.utils.Utilities.*;

import static main.java.utils.Constants.*;

public class Broker {

    public static void sendSTORED(FileChunkID chunkID) {

        byte message[] = messageConstructor("STORED", null, chunkID, null);

        try {

            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

            outputStream.write(message);

            byte messageToSend[] = outputStream.toByteArray();

            Broker.sendToMC(messageToSend);

        }

        catch(IOException e){

            e.printStackTrace();

        }

    }

    public static void sendDELETE(FileID fileID) {

        byte message[] = messageConstructor("DELETE", null, null, fileID);

        try {

            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

            outputStream.write(message);

            byte messageToSend[] = outputStream.toByteArray();

            Broker.sendToMC(messageToSend);

        }

        catch(IOException e){

            e.printStackTrace();

        }

    }

    public static void sendPUTCHUNK(FileChunk chunk) throws InterruptedException {

        byte message[] = messageConstructor("PUTCHUNK", chunk, null, null);

        try {

            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

            outputStream.write(message);

            byte messageToSend[] = outputStream.toByteArray();

            Broker.sendToMDB(messageToSend);

        }

        catch(IOException e){

            e.printStackTrace();

        }

    }

    public static void sendREMOVED(FileChunkID chunkID){

        byte message[] = messageConstructor("REMOVED", null, chunkID, null);

        try {

            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

            outputStream.write(message);

            byte messageToSend[] = outputStream.toByteArray();

            Broker.sendToMC(messageToSend);

        }

        catch(IOException e){

            e.printStackTrace();

        }

    }

    public static void sendGETCHUNK(FileChunkID chunkID) {

        byte message[] = messageConstructor("GETCHUNK", null, chunkID, null);

        try {

            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

            outputStream.write(message);

            byte messageToSend[] = outputStream.toByteArray();

            Broker.sendToMC(messageToSend);

        }

        catch(IOException e){

            e.printStackTrace();

        }

    }

    public static void sendCHUNK(FileChunk chunk, FileChunkID chunkID) {

        byte message[] = messageConstructor("CHUNK", chunk, chunkID, null);

        try {

            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

            outputStream.write(message);

            byte messageToSend[] = outputStream.toByteArray();

            Broker.sendToMDR(messageToSend);

        }

        catch(IOException e){

            e.printStackTrace();

        }

    }

    private static void sendToMDB(byte[] backupMessage) throws InterruptedException {

        DatagramPacket messagePacket = new DatagramPacket(backupMessage, backupMessage.length, Peer.getMDBListener().address, Peer.getMDBListener().port);

        try {

            Peer.getMDBListener().send(messagePacket);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    private static void sendToMC(byte[] backupMessage) {

        DatagramPacket messagePacket = new DatagramPacket(backupMessage, backupMessage.length, Peer.getMCListener().address, Peer.getMCListener().port);

        try {

            Peer.getMCListener().send(messagePacket);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    private static void sendToMDR(byte[] restoreMessage) {

        DatagramPacket messagePacket = new DatagramPacket(restoreMessage, restoreMessage.length, Peer.getMDRListener().address, Peer.getMDRListener().port);

        try {

            Peer.getMDRListener().send(messagePacket);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

package main.java.listeners;

import main.java.file.FileChunk;

import main.java.file.FileChunkID;

import main.java.peer.Peer;

import main.java.service.PacketHandler;

import main.java.utils.Constants;

import java.io.IOException;

import java.net.DatagramPacket;

import java.net.InetAddress;

import java.net.MulticastSocket;

import java.util.ArrayList;

import java.util.concurrent.ConcurrentHashMap;

import static main.java.utils.Constants.*;

public class Listener implements Runnable {

    private MulticastSocket multicastSocket;

    public InetAddress address;

    public int port;

    public volatile ConcurrentHashMap<String, ArrayList<FileChunk>> chunksReceived;

    private ConcurrentHashMap<FileChunkID, ArrayList<String>> storedChunks;

    private ConcurrentHashMap<FileChunkID, ArrayList<String>> putChunks;

    public Listener(InetAddress addr, int prt) {

        address = addr;

        port = prt;

        storedChunks = new ConcurrentHashMap<>();

        putChunks = new ConcurrentHashMap<>();

        chunksReceived = new ConcurrentHashMap<>();

    }

    @Override

    public void run() {

        try {

            multicastSocket = new MulticastSocket(port);

            multicastSocket.setTimeToLive(1);

            multicastSocket.joinGroup(address);

        } catch (IOException e) {

            e.printStackTrace();

        }

        boolean end = false;

        while(!end) {

            byte[] buffer = new byte[PACKET_MAX_SIZE];

            Thread t;

            try {

                DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

                multicastSocket.receive(packet);

                t = new Thread(new PacketHandler(packet));

                t.start();

                try {

                    t.join();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

        multicastSocket.close();

    }

    public void startCountingStoreds(FileChunkID fileChunkID) {

        if (!storedChunks.containsKey(fileChunkID)) {

            //System.out.println("Starting to count:" + chunkID.toString());

            storedChunks.put(fileChunkID, new ArrayList<>());

        }

    }

    public void clearCount(FileChunkID fileChunkID) {

        storedChunks.get(fileChunkID).clear();

    }

    public int getCount(FileChunkID fileChunkID) {

        return storedChunks.get(fileChunkID).size();

    }

    public void dumpHashmap() {

        for (FileChunkID name: storedChunks.keySet()){

            String key =name.toString();

            String value = storedChunks.get(name).toString();

            System.out.println(key + " " + value);

        }

    }

    public void stopCounting(FileChunkID fileChunkID) {

        storedChunks.remove(fileChunkID);

    }

    public void send(DatagramPacket messagePacket) throws IOException {

        multicastSocket.send(messagePacket);

    }

    public synchronized void countStored(FileChunkID chunkID, String senderID) {

        if (storedChunks.containsKey(chunkID))

            if (!storedChunks.get(chunkID).contains(senderID)) {

                storedChunks.get(chunkID).add(senderID);

                Peer.getDb().increasePerceivedRepDeg(chunkID, Integer.parseInt(senderID));

            }

            else

                System.out.println("Already counted this peer");

    }

    public synchronized void startCountingPutChunks(FileChunkID chunkID) {

        if (!putChunks.containsKey(chunkID))

            putChunks.put(chunkID, new ArrayList<>());

    }

    public synchronized void countPutChunk(FileChunkID chunkID, String senderID) {

        if (putChunks.containsKey(chunkID))

            if (!putChunks.get(chunkID).contains(senderID))

                putChunks.get(chunkID).add(senderID);

    }

    public synchronized int getCountPutChunks(FileChunkID chunkID) {

        return putChunks.get(chunkID).size();

    }

    public synchronized void stopSavingPutChunks(FileChunkID chunkID) {

        putChunks.remove(chunkID);

    }

    public boolean isCounting(FileChunkID fileChunkID) {

        if(storedChunks.containsKey(fileChunkID))

            return true;

        else {

            return false;

        }

    }

    /*

        MDR

     */

    public synchronized void queueChunk(FileChunk chunk) {

        //System.out.println("CHUNK TO MERGE: " + chunk.getFileID().toString());

        ArrayList<FileChunk> fileChunks = chunksReceived.get(chunk.getFileID().toString());

        fileChunks.add(chunk);

        //System.out.println("File Chunks: " + fileChunks);

        //printChunksReceived();

        notifyAll();

    }

    public synchronized ArrayList<FileChunk> retrieveChunk(String fileID) {

        ArrayList<FileChunk> receivedChunks = chunksReceived.get(fileID);

        return receivedChunks;

    }

    public void printChunksReceived() {

        for (String name: chunksReceived.keySet()){

            String value = chunksReceived.get(name).toString();

            System.out.println(name + ": " + value);

        }

    }

}

package main.java.peer;

import main.java.database.Database;

import main.java.file.FileID;

import main.java.listeners.Listener;

import main.java.protocols.Backup;

import main.java.protocols.Delete;

import main.java.protocols.Reclaim;

import main.java.protocols.Restore;

import main.java.service.RMI;

import java.io.IOException;

import java.net.InetAddress;

import java.net.MulticastSocket;

import java.io.*;

import java.net.*;

import java.rmi.RemoteException;

import java.rmi.registry.LocateRegistry;

import java.rmi.registry.Registry;

import java.rmi.server.UnicastRemoteObject;

import java.util.concurrent.ConcurrentHashMap;

import static main.java.utils.Utilities.getLocalAddress;

import static main.java.utils.Constants.*;

public class Peer implements RMI {

    private static Listener MCChannel;  //MC CHANNEL

    private static Listener MDBChannel; //BACKUP CHANNEL

    private static Listener MDRChannel; //RESTORE CHANNEL

    private static String rmiRemoteObject;

    private static int ID;

    private static float protocolVersion;

    private static InetAddress MCAddress;

    private static InetAddress MDBAddress;

    private static InetAddress MDRAddress;

    private static int MCPort;

    private static int MDBPort;

    private static int MDRPort;

    private static InetAddress ip;

    private static volatile Database db;

    private static Disk disk;

    public static boolean restoring;

    /*

        javac -cp /Users/zemiguel/IdeaProjects/SDIS-P1/src/ peer/Peer.java

        DENTRO DO /src/: rmiregistry &

        usage:

        protocol version,the server id, service access point, MC, MDB, MDR

        rmi init example:

        java -Djava.net.preferIPv4Stack=true -Djava.rmi.server.codebase=file:/Users/zemiguel/IdeaProjects/SDIS-P1/src/

        main/java/service/ main/java/peer/Peer 1.0 0 192.168.0.1 224.0.0.0:8000 224.0.0.0:8001 224.0.0.0:8002

        1.0, 0, 192.168.0.1, 224.0.0.0:8000, 224.0.0.0:8001, 224.0.0.0:8002

        normal peer example:

        java peer.Peer 1.0 1 224.0.0.0:8000 224.0.0.0:8001 224.0.0.0:8002

    */

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        if(!parseArgs(args)) {

            System.out.println("Bad arguments");

            System.out.println("USAGE (RMI): java peer.Peer <protocol_version> <service_access_point> <MCADDR>:<MCPORT> " +

                    "<MDBADDR>:<MDBPORT> <MDRADDR>:<MDRPORT>");

            System.out.println("USAGE (NON-RMI): java peer.Peer <protocol_version> <MCADDR>:<MCPORT> " +

                    "<MDBADDR>:<MDBPORT> <MDRADDR>:<MDRPORT>");

            return;

        }

        ip = getLocalAddress();

        MCChannel = new Listener(MCAddress, MCPort);

        MDBChannel = new Listener(MDBAddress, MDBPort);

        MDRChannel = new Listener(MDRAddress, MDRPort);

        loadDisk();

        loadDatabase();

        db.printDatabase();

        disk.printDisk();

        restoring = false;

        System.out.println("Start Listening on MC Channel...");

        new Thread(MCChannel).start();

        System.out.println("Start Listening on MDB Channel...");

        new Thread(MDBChannel).start();

        System.out.println("Start Listening on MDR Channel...");

        new Thread(MDRChannel).start();

        return;

    }

    public static void saveDBToDisk() {

        File dir = new File("peer"+getID()+"/database/");

        if(!dir.exists()){

            System.out.println("creating directory: " + dir.getName());

            try{

                dir.mkdirs();

            }

            catch(SecurityException se){

                se.printStackTrace();

            }

        }

        FileOutputStream fos = null;

        try {

            fos = new FileOutputStream("peer"+getID()+"/database/dbs.data");

        } catch (FileNotFoundException e) {

            e.printStackTrace();

            System.out.println("Database does not exist!");

            createDB();

            System.out.println("New DB created and saved to disk...");

        }

        ObjectOutputStream oos = null;

        try {

            oos = new ObjectOutputStream(fos);

        } catch (IOException e) {

            e.printStackTrace();

        }

        try {

            assert oos != null;

            oos.writeObject(db);

        } catch (IOException e) {

            e.printStackTrace();

        }

        try {

            oos.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    private static void createDB() {

        db = new Database();

        saveDBToDisk();

    }

    private static void loadDatabase() {

        System.out.println("Loading database...");

        try {

            FileInputStream fileInputStream = new FileInputStream("peer"+getID()+"/database/dbs.data");

            ObjectInputStream objectInputStream = new ObjectInputStream(

                    fileInputStream);

            db = (Database) objectInputStream.readObject();

            objectInputStream.close();

        } catch (FileNotFoundException e) {

            System.out.println("Database not found");

            createDB();

        } catch (IOException | ClassNotFoundException e) {

            e.printStackTrace();

        }

    }

    private static boolean parseArgs(String[] args) {

        //args == 6 -> INITIALIZE RMI

        if(args.length == 6) {

            protocolVersion = Float.parseFloat(args[0]);

            ID = Integer.parseInt(args[1]);

            rmiRemoteObject = args[2];

            try {

                MCAddress = InetAddress.getByName(args[3].split(":")[0]);

                MDBAddress = InetAddress.getByName(args[4].split(":")[0]);

                MDRAddress = InetAddress.getByName(args[5].split(":")[0]);

                MCPort = Integer.parseInt(args[3].split(":")[1]);

                MDBPort = Integer.parseInt(args[4].split(":")[1]);

                MDRPort = Integer.parseInt(args[5].split(":")[1]);

            }

            catch (UnknownHostException e){

                System.out.println("Address not found");

                return false;

            }

            System.out.println("\t LAUNCHING RMI");

            launchRMI();

        } else if (args.length == 5) {//normal peer

            protocolVersion = Float.parseFloat(args[0]);

            ID = Integer.parseInt(args[1]);

            try {

                MCAddress = InetAddress.getByName(args[2].split(":")[0]);

                MDBAddress = InetAddress.getByName(args[3].split(":")[0]);

                MDRAddress = InetAddress.getByName(args[4].split(":")[0]);

                MCPort = Integer.parseInt(args[2].split(":")[1]);

                MDBPort = Integer.parseInt(args[3].split(":")[1]);

                MDRPort = Integer.parseInt(args[4].split(":")[1]);

            }

            catch (UnknownHostException e){

                System.out.println("Address not found");

                return false;

            }

        }

        else return false;

        return true;

    }

    private static void launchRMI() {

        //System.setProperty("java.rmi.server.hostname", "localhost");

        //System.setProperty("rmi.server.codebase", "file:/Users/zemiguel/IdeaProjects/SDIS-P1/src/main/java/service/bin/");

        try {

            RMI peer = new Peer();

            RMI stub = (RMI) UnicastRemoteObject.exportObject(peer, 0);

            Registry registry = LocateRegistry.getRegistry();

            registry.rebind("obj", stub);

        } catch (Exception e) {

            System.err.println("Server exception: " + e.toString());

            e.printStackTrace();

        }

    }

    public static Database getDb() {

        return db;

    }

    public static Listener getMCListener() {

        return MCChannel;

    }

    public static Listener getMDBListener() {

        return MDBChannel;

    }

    public static Listener getMDRListener() {

        return MDRChannel;

    }

    public static void saveDisk(){

        FileOutputStream fos = null;

        File dir = new File("peer"+getID()+"/disk/");

        if(!dir.exists()){

            System.out.println("creating directory: " + dir.getName());

            try{

                dir.mkdirs();

            }

            catch(SecurityException se){

                se.printStackTrace();

            }

        }

        try {

            fos = new FileOutputStream("peer"+getID()+"/disk/disk.data");

        } catch (FileNotFoundException e) {

            e.printStackTrace();

            System.out.println("Disk does not exist!");

            createDisk();

            System.out.println("New Disk created and saved to disk...");

        }

        ObjectOutputStream oos = null;

        try {

            oos = new ObjectOutputStream(fos);

        } catch (IOException e) {

            e.printStackTrace();

        }

        try {

            oos.writeObject(disk);

        } catch (IOException e) {

            e.printStackTrace();

        }

        try {

            oos.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    private static void loadDisk() throws ClassNotFoundException, IOException {

        System.out.println("Loading disk...");

        try {

            FileInputStream fileInputStream = new FileInputStream("peer"+getID()+"/disk/disk.data");

            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);

            disk = (Disk) objectInputStream.readObject();

            objectInputStream.close();

        } catch (FileNotFoundException e) {

            System.out.println("Disk not found");

            createDisk();

        } catch (IOException | ClassNotFoundException e) {

            e.printStackTrace();

        }

    }

    public static void createDisk(){

        disk = new Disk();

        saveDisk();

    }

    @Override

    public void backup(File file, int replicationDegree) throws RemoteException {

        Thread t = new Thread(new Backup(file, replicationDegree));

        t.start();

        try {

            t.join();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    @Override

    public void delete(String filePath) throws RemoteException {

        Thread t = new Thread(new Delete(new FileID(filePath, 0)));

        t.start();

        try {

            t.join();

        } catch (InterruptedException e){

            e.printStackTrace();

        }

    }

    @Override

    public void restore(File file) throws RemoteException {

        Thread t = new Thread(new Restore(file));

        t.start();

        try {

            t.join();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    @Override

    public String state() throws RemoteException {

        db.printDatabase();

        disk.printDisk();

        return null;

    }

    @Override

    public void reclaim(int amount) throws RemoteException {

        Thread t = new Thread(new Reclaim(amount));

        t.start();

        try {

            t.join();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    public static int getID() {

        return ID;

    }

    public static InetAddress getAddress() {

        return ip;

    }

    public static float getProtocolVersion() {

        return protocolVersion;

    }

    public static Disk getDisk(){ return disk; }

}

package main.java.protocols;

import main.java.file.*;

import main.java.peer.Peer;

import java.io.*;

import java.util.Arrays;

import static main.java.utils.Constants.*;

import static main.java.utils.Utilities.*;

public class Backup implements Runnable{

    private File file;

    private int repDeg;

    private String encryptedID;

    private FileID fileID;

    private int fileParts;

    //private static Message message;

    public Backup(File file, int replicationDegree) {

        this.file = file;

        this.repDeg = replicationDegree;

    }

    /**

     * @param file File to split into chunks and later backed up

     * @return Number of chunks that the file was split into

     * @throws IOException exception to be thrown in case of an invalid file.

     */

    public int createChunks(File file) throws IOException {

        byte[] fileData = loadFileData(file);

        fileParts = fileData.length / CHUNK_MAX_SIZE;

        String fileName = file.getName();

        ByteArrayInputStream streamBuffer = new ByteArrayInputStream(fileData);

        byte[] data = new byte[CHUNK_MAX_SIZE];

        for(int i = 0; i <= fileParts; i++) {

            FileChunkID id = new FileChunkID(file.getName(), i);

            byte[] chunkData;

            /*

                Size of last chunk is always shorter than CHUNK_MAX_SIZE

                If the file size is a multiple of CHUNK_MAX_SIZE, the last chunk has size 0.

             */

            if(i == fileParts - 1 && file.length() % CHUNK_MAX_SIZE == 0) {

                chunkData = new byte[0];

            } else {

                int bytesRead = streamBuffer.read(data, 0, data.length);

                chunkData = Arrays.copyOfRange(data, 0, bytesRead);

            }

            fileID = new FileID(sha256(file.getName()), repDeg);

            fileID.setNumChunks(fileParts + 1);