sdis1819-t4g11

package chunk;

import java.io.File;

import java.io.FileOutputStream;

import java.io.RandomAccessFile;

import java.io.UnsupportedEncodingException;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import javax.xml.bind.DatatypeConverter;

public class Chunk {

    public static final int CHUNK_MAX_SIZE = 64000;

    private int chunkNo;

    private String fileID;

    private int repDegree;

    private byte[] data;

    public Chunk(String fileID, int chunkNo, int repDegree, byte[] data) {

        this.chunkNo = chunkNo;

        this.fileID = fileID;

        this.data = data;

        this.repDegree = repDegree;

    }

    /**

     * @return The chunk's file ID

     */

    public String getFileID() {

        return fileID;

    }

    /**

     * @return The chunk number

     */

    public int getChunkNo() {

        return chunkNo;

    }

    /**

     * @return The chunk replication degree

     */

    public int getRepDegree() {

        return repDegree;

    }

    /**

     * @return The chunk data byte array

     */

    public byte[] getData() {

        return data;

    }

    public static Chunk[] splitFile(String path, int repDegree) {

        File file = new File(path);

        return splitFile(file, repDegree);

    }

    public static int getNumberOfFileChunks(File file) {

        long nFileBytes = file.length();

        return (int) ((nFileBytes - 1) / CHUNK_MAX_SIZE + 1);

    }

    public static Chunk[] splitFile(File file, int repDegree) {

        if (!file.isFile()) {

            return null;

        }

        long nFileBytes = file.length();

        int nChunks = getNumberOfFileChunks(file);

        Chunk[] chunks = new Chunk[nChunks];

        String fileId = generateFileId(file);

        try (RandomAccessFile data = new RandomAccessFile(file, "r")) {

            int nReadBytes = 0;

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

                int nBytesToRead;

                int nBytesMissing = (int) (nFileBytes - nReadBytes);

                if (nBytesMissing < CHUNK_MAX_SIZE) {

                    nBytesToRead = nBytesMissing;

                } else {

                    nBytesToRead = CHUNK_MAX_SIZE;

                }

                byte[] newData = new byte[nBytesToRead];

                data.readFully(newData);

                Chunk newChunk = new Chunk(generateFileId(file), i + 1, repDegree, newData);

                chunks[i] = newChunk;

                nReadBytes += CHUNK_MAX_SIZE;

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        return chunks;

    }

    public static String generateFileId(File file) {

        MessageDigest digest;

        try {

            digest = MessageDigest.getInstance("SHA-256");

        } catch (NoSuchAlgorithmException e) {

            e.printStackTrace();

            return null;

        }

        String toEncode = file.getName() + Long.toString(file.length());

        byte[] encodedhash;

        try {

            encodedhash = digest.digest(toEncode.getBytes("UTF-8"));

            return DatatypeConverter.printBase64Binary(encodedhash);

        } catch (UnsupportedEncodingException e) {

            e.printStackTrace();

        }

        return "invalid";

    }

    public static void sortChunkArray(Chunk[] chunks) {

        for (int i = 0; i < chunks.length; i++) {

            Chunk currChunk = chunks[i];

            int nCurrChunk = currChunk.getChunkNo();

            if (nCurrChunk != i + 1) {

                Chunk tempChunk = chunks[i];

                chunks[i] = chunks[nCurrChunk - 1];

                chunks[nCurrChunk - 1] = tempChunk;

            }

        }

    }

    public static void restoreFile(Chunk[] chunks, String filePath) {

        sortChunkArray(chunks);

        try (FileOutputStream fos = new FileOutputStream(filePath)) {

            for (int i = 0; i < chunks.length; i++) {

                fos.write(chunks[i].getData());

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    @Override

    public boolean equals(Object obj) {

        if (obj == null) {

            return false;

        }

        final Chunk c = (Chunk) obj;

        return (c.chunkNo == chunkNo && c.fileID.equals(fileID) && c.repDegree == repDegree);

    }

}

package client;

import utils.Utils;

import java.lang.Integer;

import java.rmi.NotBoundException;

import java.rmi.RemoteException;

import java.rmi.registry.LocateRegistry;

import java.rmi.registry.Registry;

import peer.PeerInterface;

import java.lang.Float;

/**

 * TestApp

 */

public class TestApp {

    private String peer_ap;

    private String operation;

    private String filePath;

    private float diskSpace;

    private int replicationDeg;

    private PeerInterface pInterface;

    public static void main(String[] args){

        TestApp app = new TestApp(args);

        app.processRequest();

    }

    public TestApp(String[] args) {

        if (!handleInputs(args)) {

            usage();

            return;

        }

        connect();

    }

    public void processRequest(){

        switch (operation) {

            case "BACKUP":

                System.out.println("BACKUP:\n\tFile: " + filePath + "\n\tReplication Degree: " + replicationDeg);

                try {

                    pInterface.backup(filePath, replicationDeg);

                } catch (RemoteException e) {

                    System.out.println("BACKUP ERROR!");

                    e.printStackTrace();

                }

                System.out.println("BACKUP SUCCESSFUL!");

                break;

            case "RESTORE":

                System.out.println("RESTORE:\n\tFile: " + filePath);

                try {

                    pInterface.restore(filePath);

                } catch (RemoteException e) {

                    System.out.println("RESTORE ERROR!");

                    e.printStackTrace();

                }

                System.out.println("RESTORE SUCCESSFUL!");

                break;

            case "DELETE":

                System.out.println("DELETE:\n\tFile: " + filePath);

                try {

                    pInterface.delete(filePath);

                } catch (RemoteException e) {

                    System.out.println("DELETE ERROR!");

                    e.printStackTrace();

                }

                System.out.println("DELETE SUCCESSFUL!");

                break;

            case "RECLAIM":

                System.out.println("RECLAIM:\n\tDisk Space: " + diskSpace);

                try {

                    pInterface.reclaim(diskSpace);

                } catch (RemoteException e) {

                    System.out.println("RECLAIM ERROR!");

                    e.printStackTrace();

                }

                System.out.println("RECLAIM SUCCESSFUL!");

                break;

            case "STATE":

                System.out.println("STATE:");

                try {

                    pInterface.state();

                } catch (RemoteException e) {

                    System.out.println("STATE ERROR!");

                    e.printStackTrace();

                }

                System.out.println("STATE SUCCESSFUL!");

                    break;

            default:

                break;

            }

    }

    private boolean handleInputs(String[] args) {

        if (args.length < 2) {

            System.out.println("Error: Invalid number of arguments!");

            return false;

        }

        this.peer_ap = args[0];

        this.operation = args[1].toUpperCase();

        switch (operation) {

        case "BACKUP":

            if (args.length != 4) {

                System.out.println(operation + " error: Invalid number of arguments!");

                return false;

            }

            if (!Utils.fileExists(args[2])) {

                System.out.println(operation + " error: File doesn't exist!");

                return false;

            }

            this.filePath = args[2];

            if (!Utils.isInteger(args[3])) {

                System.out.println(operation + " error: Replication Degree invalid!");

                return false;

            }

            this.replicationDeg = Integer.parseInt(args[3]);

            break;

        case "RESTORE":

            if (args.length != 3) {

                System.out.println(operation + " error: Invalid number of arguments!");

                return false;

            }

            if (!Utils.fileExists(args[2])) {

                System.out.println(operation + " error: File doesn't exist!");

                return false;

            }

            this.filePath = args[2];

            break;

        case "DELETE":

            if (args.length != 3) {

                System.out.println(operation + " error: Invalid number of arguments!");

                return false;

            }

            if (!Utils.fileExists(args[2])) {

                System.out.println(operation + " error: File doesn't exist!");

                return false;

            }

            this.filePath = args[2];

            break;

        case "RECLAIM":

            if (args.length != 3) {

                System.out.println(operation + " error: Invalid number of arguments!");

                return false;

            }

            if (!Utils.isFloat(args[2])) {

                System.out.println(operation + " error: Maximum amount of disk space invalid!");

                return false;

            }

            this.diskSpace = Float.parseFloat(args[2]);

            break;

        case "STATE":

            if (args.length != 2) {

                System.out.println(operation + " error: Invalid number of arguments!");

                return false;

            }

            break;

        default:

            System.out.println("Error: Invalid operation!");

            return false;

        }

        return true;

    }

    private static void usage() {

        System.out.println(

                "Usage:\n\tjava TestApp <peer_ap> <operation> <opnd_1> <opnd2>\n\t\t<peer_app>: Peer's access point;\n\t\t<operation>: Operation the peer of backup service must execute. It must be one of: BACKUP, RESTORE, DELETE, RECLAIM, STATE;\n\t\t<opnd_1>: Path Name of the file in case of operations BACKUP, RESTORE or DELETE or maximum amount of disk space (in KByte) in case of operation RECLAIM\n\t\t<opnd_2>: Integer that specifies the desired replication degree for operation BACKUP");

        return;

    }

    public void connect() {

        try {

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

            this.pInterface = (PeerInterface) rmiReg.lookup(this.peer_ap);

        } catch (RemoteException | NotBoundException e) {

            e.printStackTrace();

        }

    }

package disk;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingDeque;

import chunk.Chunk;

import javafx.util.Pair;

/**

 * ChunkManagement

 */

public class ChunkManagement {

	private static ChunkManagement chunkManagementInstance = null;

	private Map<String, Map<Integer, Integer>> storesCounter;

	private BlockingQueue<Chunk> restoreChunks;

	private ChunkManagement() {

		storesCounter = new HashMap<String, Map<Integer, Integer>>();

		restoreChunks = new LinkedBlockingDeque<Chunk>();

	}

	public static ChunkManagement getInstance() {

		if (chunkManagementInstance == null) {

			chunkManagementInstance = new ChunkManagement();

		}

		return chunkManagementInstance;

	}

	public int getStores(String fileId, int chunkNo) {

		if (!storesCounter.containsKey(fileId)){

			return 0;

		}

		if (!storesCounter.get(fileId).containsKey(chunkNo)){

			return 0;

		}

		return storesCounter.get(fileId).get(chunkNo);

	}

	public int registerStored(String fileId, int chunkNo) {

		if (!storesCounter.containsKey(fileId)) {

			storesCounter.put(fileId, new HashMap<Integer, Integer>());

		}

		if (!storesCounter.get(fileId).containsKey(chunkNo)) {

			storesCounter.get(fileId).put(chunkNo, 1);

		} else {

			int nStores = storesCounter.get(fileId).get(chunkNo);

			storesCounter.get(fileId).put(chunkNo, nStores + 1);

		}

		return storesCounter.get(fileId).get(chunkNo);

	}

	public int registerRemoved(String fileId, int chunkNo) {

		if (!storesCounter.containsKey(fileId)) {

			return 0;

		}

		if (!storesCounter.get(fileId).containsKey(chunkNo)) {

			return 0;

		} else {

			int nStores = storesCounter.get(fileId).get(chunkNo);

			storesCounter.get(fileId).put(chunkNo, nStores - 1);

			return storesCounter.get(fileId).get(chunkNo);

		}

	}

	public void deleteStores(String fileId) {

		storesCounter.remove(fileId);

	}

	public void addRestoreChunk(Chunk chunk) {

		restoreChunks.add(chunk);

	}

	/**

	 * @return the restoreChunks

	 */

	public BlockingQueue<Chunk> getRestoreChunks() {

		return restoreChunks;

	}

}

package disk;

import chunk.*;

import utils.Utils;

import java.io.File;

import java.io.FileOutputStream;

import java.io.FileInputStream;

import java.io.IOException;

/**

 * Disk

 */

public class Disk {

	public static final String fileSeparator = System.getProperty("file.separator");

	public static final String filesPath = "." + fileSeparator + "files" + fileSeparator;

	public static final String resourcesPath = filesPath + "resources" + fileSeparator;

	public static final String defaultDiskLocation = filesPath + "peers" + fileSeparator;

	public static final long defaultDiskSize = 10000000; /* Disk size in KBytes */

	private long size; /* Disk size in bytes */

	private String diskLocation;

	private File directory;

	private File backupDirectory, restoredDirectory;

	public void restoreFile(Chunk[] chunks, String fileName) {

		Chunk.restoreFile(chunks, getRestoredDirectoryPath() + fileSeparator + fileName);

	}

	public Disk(String diskName) {

		this(diskName, defaultDiskSize);

	}

	public Disk(String diskName, float size) {

		this.diskLocation = defaultDiskLocation + diskName;

		this.size = (long) (size * 1000);

		createDiskDirectory();

	}

	/**

	 * @return the backupDirectory

	 */

	public File getBackupDirectory() {

		return backupDirectory;

	}

	/**

	 * @return the defaultDiskLocation

	 */

	public static String getDefaultDiskLocation() {

		return defaultDiskLocation;

	}

	/**

	 * @return the directory

	 */

	public File getDirectory() {

		return directory;

	}

	/**

	 * @return the restoredDirectory

	 */

	public File getRestoredDirectory() {

		return restoredDirectory;

	}

	public String getRestoredDirectoryPath() {

		return restoredDirectory.getAbsolutePath();

	}

	public boolean createDiskDirectory() {

		directory = new File(this.diskLocation);

		directory.mkdirs();

		createBackupDirectory();

		createRestoredDirectory();

		return true;

	}

	public boolean createBackupDirectory() {

		backupDirectory = new File(this.diskLocation + fileSeparator + "backup");

		if (backupDirectory.mkdirs()) {

			return true;

		}

		return false;

	}

	public boolean createRestoredDirectory() {

		restoredDirectory = new File(this.diskLocation + fileSeparator + "restored");

		if (restoredDirectory.mkdirs()) {

			return true;

		}

		return false;

	}

	public String getDiskLocation() {

		return diskLocation;

	}

	public long getSize() {

		return size;

	}

	public long getOccupiedSpace() {

		return folderSize(this.directory);

	}

	public long getFreeSpace() {

		return size - getOccupiedSpace();

	}

	public static long folderSize(File directory) {

		long length = 0;

		for (File file : directory.listFiles()) {

			if (file.isFile())

				length += file.length();

			else

				length += folderSize(file);

		}

		return length;

	}

	public File createFileFolder(String fileId) {

		File fileFolder = new File(backupDirectory.getPath() + fileSeparator + fileId);

		fileFolder.mkdirs();

		return fileFolder;

	}

	public boolean storeChunk(Chunk chunk) {

		String fileName = chunk.getChunkNo() + "-" + chunk.getRepDegree();

		File folder = createFileFolder(chunk.getFileID());

		File chunkFile = new File(folder.getPath() + fileSeparator + fileName);

		if (chunkFile.exists()) {

			return false;

		}

		try (FileOutputStream fos = new FileOutputStream(chunkFile)) {

			fos.write(chunk.getData());

		} catch (Exception e) {

			e.printStackTrace();

			return false;

		}

		return true;

	}

	public File[] getFileChunkFiles(String fileId) {

		File fileChunkDirectory = getFileChunkDirectory(fileId);

		return fileChunkDirectory.listFiles();

	}

	public Chunk[] getFileChunks(String fileId) {

		File chunkFiles[] = getFileChunkFiles(fileId);

		Chunk[] chunks = new Chunk[chunkFiles.length];

		for (int i = 0; i < chunkFiles.length; i++) {

			chunks[i] = parseFileToChunk(fileId, chunkFiles[i]);

		}

		return chunks;

	}

	public File getChunkFile(String fileId, int chunkId) {

		File chunkFiles[] = getFileChunkFiles(fileId);

		for (File chunkFile : chunkFiles) {

			if (chunkFile.getName().startsWith(chunkId + "-")) {

				return chunkFile;

			}

		}

		return null;

	}

	public Chunk getChunk(String fileId, int chunkId) {

		Chunk[] chunks = getFileChunks(fileId);

		for (Chunk chunk : chunks) {

			if (chunk.getChunkNo() == chunkId) {

				return chunk;

			}

		}

		return null;

	}

	public File getFileChunkDirectory(String fileId) {

		return new File(backupDirectory.getPath() + fileSeparator + fileId);

	}

	public static Chunk parseFileToChunk(String fileId, File chunkFile) {

		String fileName = chunkFile.getName();

		String parsedName[] = fileName.split("-");

		int chunkId = Integer.parseInt(parsedName[0]);

		int repDegree = Integer.parseInt(parsedName[1]);

		byte[] data = new byte[(int) chunkFile.length()];

		try (FileInputStream fis = new FileInputStream(chunkFile)) {

			fis.read(data);

		} catch (Exception e) {

		}

		Chunk chunk = new Chunk(fileId, chunkId, repDegree, data);

		return chunk;

	}

	public void deleteFileDirectory(String fileId) {

		//File fileDir = getFileChunkDirectory(fileId);

		/*try {

			Utils.deleteDirectoryRecursively(fileDir);

		} catch (IOException e) {

			e.printStackTrace();

			return false;

		}

		return true;

		*/

		File fileDir = new File(backupDirectory + "\\" + fileId);

		System.out.println("FileDir: \"" + fileDir + "\"");

		Utils.deleteDirectoryRecursively(fileDir);

	}

	public boolean deleteChunk(String fileId, int chunkId) {

		File chunkFile = getChunkFile(fileId, chunkId);

		if (!chunkFile.delete()) {

			System.out.println("Failed to delete " + chunkFile);

			return false;

		}

		return true;

	}

}

package disk;

/**

 * DiskFailedToInitialize

 */

public class DiskFailedToInitialize extends Exception {

	public DiskFailedToInitialize() {

		super();

	}

package message;

/**

 * InvalidHeaderParameters

 */

public class InvalidHeaderParameters extends Exception {

	private static final long serialVersionUID = -1129574923771068119L;

package message;

public class InvalidSenderProtocolVersion extends Exception {

	private static final long serialVersionUID = -6896672292724504010L;

}

package message;

import chunk.Chunk;

import peer.Peer;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

public class Message {

    public static final int MESSAGE_PACKET_MAX_SIZE = Chunk.CHUNK_MAX_SIZE + MessageHeader.MESSAGE_HEADER_MAX_SIZE;

    private MessageHeader header;

    private byte[] body;

    public Message(byte[] data) {

        String rawMessage = new String(data);

        int index = rawMessage.indexOf(MessageHeader.CRLF) + 4;

        byte[] rawHeader = new byte[index+1];

        System.arraycopy(data, 0, rawHeader, 0, index - 4);

        header = new MessageHeader(new String(rawHeader));

        int bodyLength = data.length - index;

        body = new byte[bodyLength];

        System.arraycopy(data, index, body, 0, bodyLength);

    }

    public Message(MessageHeader header, byte[] body) {

        this.header = header;

        this.body = body;

    }

    public byte[] toBytes() throws IOException {

        byte[] result;

        ByteArrayOutputStream bos = new ByteArrayOutputStream();

        bos.write(header.toString().getBytes());

        if (body != null)

            bos.write(body);

        result = bos.toByteArray();

        return result;

    }

    public MessageHeader getHeader() {

        return header;

    }

    public byte[] getBody() {

        return body;

    }

    /*

     * public static boolean isValid(String message) { String myString =

     * message.substring(0,message.indexOf("\r\n\r\n"));

     * 

     * return

     * myString.matches(".* [0-9].[0-9] [0-9]+ .{32} .{6} [0-9]\r\n\r\n(.*)?"); }

     */

    public static Message parsePutChunkMessage(Chunk chunk, Peer peer) {

        MessageHeader header = new MessageHeader("PUTCHUNK", peer.getpVersion(), peer.getPeerId(), chunk.getFileID(), chunk.getChunkNo(),

                chunk.getRepDegree());

        Message message = new Message(header, chunk.getData());

        return message;

    }

    public static Message parseStoredMessage(Chunk chunk, Peer peer) {

        try {

            MessageHeader header = new MessageHeader("STORED", peer.getpVersion(), peer.getPeerId(), chunk.getFileID(), chunk.getChunkNo());

            Message message = new Message(header, null);

            return message;

        } catch (InvalidHeaderParameters e) {

            e.printStackTrace();

        }

        return null;

    }

    public static Message parseDeleteMessage(String fileId, Peer peer) {

        try {

            MessageHeader header = new MessageHeader("DELETE", peer.getpVersion(), peer.getPeerId(), fileId);

            Message message = new Message(header, null);

            return message;

        } catch (InvalidHeaderParameters e) {

            e.printStackTrace();

        }

        return null;

    }

    public static Message parseGetChunkMessage(String fileId, int chunkNo, Peer peer) {

        try {