Index: DistributedBackupService/src/chunk/FileManager.java
===================================================================
--- DistributedBackupService/src/chunk/FileManager.java	(revision 1)
+++ DistributedBackupService/src/chunk/FileManager.java	(revision 2)
@@ -38,30 +38,6 @@
 		this.chunkMap = chunksInfo;
 	}
 
-	public String getFileID() {
-		return fileID;
-	}
-
-	public int getNumChunks() {
-		return numChunks;
-	}
-
-	public String getPathname() {
-		return pathName;
-	}
-
-	public String getFileName() {
-		return fileName;
-	}
-
-	public int getWantedReplication() {
-		return wantedReplication;
-	}
-
-	public HashMap<String, Chunk> getChunks() {
-		return chunkMap;
-	}
-
 	synchronized public static FileManager loadDatabase(File file) throws ClassNotFoundException {
 		FileManager db = null;
 
@@ -125,10 +101,6 @@
 		chunkRepository.remove(fileID);
 	}
 
-	public int getNumChunks(String pathname) {
-		return fileRepository.get(pathname).getNumChunks();
-	}
-
 	public Integer getRecognizedReplication(String fileID, int chunkNo) 
 	{
 		int ret;
@@ -141,12 +113,90 @@
 		return ret;
 	}
 
+	// Getters e Setters
+	
 	public boolean chunkExists(String fileID) {
 		return chunkRepository.containsKey(fileID);
 	}
 
+	public ConcurrentMap<String, FileManager> getFileRepository() {
+		return fileRepository;
+	}
+
+	public void setFileRepository(ConcurrentMap<String, FileManager> fileRepository) {
+		this.fileRepository = fileRepository;
+	}
+
+	public ConcurrentMap<String, ConcurrentMap<Integer, Chunk>> getChunkRepository() {
+		return chunkRepository;
+	}
+
+	public void setChunkRepository(ConcurrentMap<String, ConcurrentMap<Integer, Chunk>> chunkRepository) {
+		this.chunkRepository = chunkRepository;
+	}
+
+	public String getPathName() {
+		return pathName;
+	}
+
+	public void setPathName(String pathName) {
+		this.pathName = pathName;
+	}
+
+	public HashMap<String, Chunk> getChunkMap() {
+		return chunkMap;
+	}
+
+	public void setChunkMap(HashMap<String, Chunk> chunkMap) {
+		this.chunkMap = chunkMap;
+	}
+
+	public void setFileID(String fileID) {
+		this.fileID = fileID;
+	}
+
+	public void setFileName(String fileName) {
+		this.fileName = fileName;
+	}
+
+	public void setNumChunks(int numChunks) {
+		this.numChunks = numChunks;
+	}
+
+	public void setWantedReplication(int wantedReplication) {
+		this.wantedReplication = wantedReplication;
+	}
+
 	public Set<Integer> getFileChunksKey(String fileID) {
 		return chunkRepository.get(fileID).keySet();
 	}
+	
+	public String getFileID() {
+		return fileID;
+	}
 
+	public int getNumChunks() {
+		return numChunks;
+	}
+
+	public String getPathname() {
+		return pathName;
+	}
+
+	public String getFileName() {
+		return fileName;
+	}
+
+	public int getWantedReplication() {
+		return wantedReplication;
+	}
+
+	public HashMap<String, Chunk> getChunks() {
+		return chunkMap;
+	}
+	
+	public int getNumChunks(String pathname) {
+		return fileRepository.get(pathname).getNumChunks();
+	}
+
 }
\ No newline at end of file
Index: DistributedBackupService/src/chunk/FolderManager.java
===================================================================
--- DistributedBackupService/src/chunk/FolderManager.java	(revision 1)
+++ DistributedBackupService/src/chunk/FolderManager.java	(revision 2)
@@ -38,7 +38,19 @@
 		File file = new File(name);
 		file.mkdirs();
 	}
+	
+	public static ArrayList<Chunk> loadChunks(String path, int chunksNumber) throws IOException {
+		ArrayList<Chunk> chunks = new ArrayList<>();
 
+		for (int i = 0; i <= chunksNumber; i++) {
+			byte[] information = loadFile(new File(path + "/" + i));
+			Chunk chunk = new Chunk("", i, 1, information);
+			chunks.add(chunk);
+		}
+
+		return chunks;
+	}
+
 	synchronized public static boolean backupFile(String name, String path, byte[] information) throws IOException {
 		if (getFreeMemory() < information.length) {
 			System.out.println("Without space to backup file");
@@ -65,18 +77,6 @@
 		return information;
 	}
 
-	public static ArrayList<Chunk> loadChunks(String path, int chunksNumber) throws IOException {
-		ArrayList<Chunk> chunks = new ArrayList<>();
-
-		for (int i = 0; i <= chunksNumber; i++) {
-			byte[] information = loadFile(new File(path + "/" + i));
-			Chunk chunk = new Chunk("", i, 1, information);
-			chunks.add(chunk);
-		}
-
-		return chunks;
-	}
-
 	public static ArrayList<Chunk> fileSplit(byte[] fileInformation, String fileID, int replication) {
 		ArrayList<Chunk> chunks;
 		int numChunks;
@@ -110,10 +110,6 @@
 	}
 
 
-	public String getChunkPath(String fileID, int chunkNo) {
-		return getChunksPath() + fileID + "/" + chunkNo;
-	}
-
 	public byte[] loadChunk(String fileID, int chunkNo) {
 		byte[] chunkinformation = null;
 		String chunkPath = getChunksPath() + fileID + "/" + chunkNo;
@@ -127,25 +123,8 @@
 		return chunkinformation;
 	}
 
-
-	public String getRootPath() {
-		return path;
-	}
-
-	public String getChunksPath() {
-		return path + Utils.CHUNKS;
-	}
-
-	public String getRestoresPath() {
-		return path + Utils.RESTORES;
-	}
-
-	public FileManager getDatabase() {
-		return fileManager;
-	}
-
 	public void deleteChunk(String fileID, int chunkNo) {
-		String chunkPath = getChunkPath(fileID, chunkNo);
+		String chunkPath = getChunksPath() + fileID + "/" + chunkNo;
 		File file = new File(chunkPath);
 
 		long chunkSize = file.length();
@@ -154,22 +133,6 @@
 		fileManager.deleteChunk(fileID, chunkNo);
 	}
 
-	public static long getMaxMemory() {
-		return maxMemory;
-	}
-
-	public static void setMaxMemory(int maxMemory) {
-		FolderManager.maxMemory = maxMemory;
-	}
-
-	public static long getUsedMemory() {
-		return FolderManager.usedMemory;
-	}
-
-	public static long getFreeMemory() {
-		return maxMemory - usedMemory;
-	}
-
 	private static void decUsedMemory(long n) {
 		usedMemory -= n;
 		if (usedMemory < 0) {
@@ -187,4 +150,42 @@
 		System.out.println("Used memory: " + usedMemory + " / " + maxMemory);
 		return true;
 	}
+	
+	// Getters and setters 
+	
+	public static long getMaxMemory() { return maxMemory; }
+
+	public static void setMaxMemory(int maxMemory) { FolderManager.maxMemory = maxMemory; }
+
+	public static long getUsedMemory() { return FolderManager.usedMemory; }
+
+	public static long getFreeMemory() { return maxMemory - usedMemory; }
+
+	public String getRootPath() { return path; }
+
+	public String getChunksPath() { return path + Utils.CHUNKS; }
+
+	public String getRestoresPath() { return path + Utils.RESTORES; }
+
+	public FileManager getDatabase() { return fileManager; }
+
+	public Peer getPeer() { return peer; }
+
+	public void setPeer(Peer peer) { this.peer = peer; }
+
+	public String getPath() { return path; }
+
+	public void setPath(String path) { this.path = path; }
+
+	public FileManager getFileManager() { return fileManager; }
+
+	public void setFileManager(FileManager fileManager) { this.fileManager = fileManager; }
+
+	public static int getChunkSizeLimit() {	return chunkSizeLimit; }
+
+	public static void setChunkSizeLimit(int chunkSizeLimit) { FolderManager.chunkSizeLimit = chunkSizeLimit; }
+
+	public static void setMaxMemory(long maxMemory) { FolderManager.maxMemory = maxMemory; }
+
+	public static void setUsedMemory(long usedMemory) {	FolderManager.usedMemory = usedMemory; }
 }
\ No newline at end of file
Index: DistributedBackupService/src/client/TestApp.java
===================================================================
--- DistributedBackupService/src/client/TestApp.java	(revision 1)
+++ DistributedBackupService/src/client/TestApp.java	(revision 2)
@@ -12,85 +12,92 @@
 public class TestApp implements Runnable {
 
 	private InitiatorPeer initiatorPeer;
-	
-    private String peer_ap;
-    private String sub_protocol;
-    private String opnd_1;
-    private String opnd_2;
 
-    private Map<String, Runnable> protocols;
-    
+	private String peer_ap;
+	private String sub_protocol;
+	private String opnd_1;
+	private String opnd_2;
 
-    public static void main(String[] args) {
-        if (args.length < 2 || args.length > 4) {
-        	System.out.println("Usage: <java TestApp <peer_ap> <sub_protocol> <opnd_1> <opnd_2> >");
+	private Map<String, Runnable> protocols;
+
+
+	public static void main(String[] args) {
+		if (args.length < 2 || args.length > 4) {
+			System.out.println("Usage: <java TestApp <peer_ap> <sub_protocol> <opnd_1> <opnd_2> >");
 			System.out.println("<peer_ap> - peer access point");
 			System.out.println("<sub_protocol> - BACKUP, RESTORE, DELETE, RECLAIM");
 			System.out.println("<opnd_1> - path name of the file to backup/restore/delete");
 			System.out.println("<opnd_2> - replication degree");
 			System.exit(1);
-        }
-        
-        String peer_ap = args[0];
-        String sub_protocol = args[1];
-        String opnd_1;
-        String opnd_2;
-        
-        if(args.length > 2) 
-        	opnd_1 = args[2];
-        else
-        	opnd_1 = null;
-        
-        if(args.length > 3) 
-        	opnd_2 = args[3];
-        else
-        	opnd_2 = null;
+		}
 
-        TestApp app = new TestApp(peer_ap, sub_protocol, opnd_1, opnd_2);
-        new Thread(app).start();
-    }
+		String peer_ap = args[0];
+		String sub_protocol = args[1];
+		String opnd_1;
+		String opnd_2;
 
-    public TestApp(String peer_ap, String sub_protocol, String opnd_1, String opnd_2) {
-    	protocols = new HashMap<>();
-    	
-        this.peer_ap = peer_ap;
-        this.sub_protocol = sub_protocol;
-        this.opnd_1 = opnd_1;
-        this.opnd_2 = opnd_2;
+		if(args.length > 2) 
+			opnd_1 = args[2];
+		else
+			opnd_1 = null;
 
-        protocols.put("BACKUP", this::handleBackup);
-        protocols.put("DELETE", this::handleDelete);
+		if(args.length > 3) 
+			opnd_2 = args[3];
+		else
+			opnd_2 = null;
 
-    }
+		TestApp app = new TestApp(peer_ap, sub_protocol, opnd_1, opnd_2);
+		new Thread(app).start();
+	}
 
-    @Override
-    public void run() {
-    	try {
-            Registry registry = LocateRegistry.getRegistry(null);
-            initiatorPeer = (InitiatorPeer) registry.lookup(peer_ap);
-        } catch (Exception e) {
-        	System.out.println("Error when opening RMI stub");
-            e.printStackTrace();
-        }
-        protocols.get(sub_protocol).run();
-    }
-    
-    private void handleBackup() {
-        File file = new File(this.opnd_1);
-        System.out.println("--> BACKUP :: Saving chunks at " + file.getAbsolutePath() + "\"");
-        try {
-            initiatorPeer.backup(file, Integer.parseInt(this.opnd_2));
-        } catch (RemoteException e) {
-        	e.printStackTrace();
-        }
-    }
+	public TestApp(String peer_ap, String sub_protocol, String opnd_1, String opnd_2) {
+		protocols = new HashMap<>();
 
-    private void handleDelete() {
-    	System.out.println("--> DELETE :: delete file: " + opnd_1 + "\"");
-        try {
-            initiatorPeer.delete(this.opnd_1);
-        } catch (RemoteException e) {
-        	e.printStackTrace();
-        }
-    }
+		this.peer_ap = peer_ap;
+		this.sub_protocol = sub_protocol;
+		this.opnd_1 = opnd_1;
+		this.opnd_2 = opnd_2;
+
+		protocols.put("BACKUP", () -> {
+			try {
+				backup();
+			} catch (NumberFormatException e) {
+				e.printStackTrace();
+			} catch (RemoteException e) {
+				e.printStackTrace();
+			}
+		});
+		protocols.put("DELETE", () -> {
+			try {
+				delete();
+			} catch (RemoteException e) {
+				e.printStackTrace();
+			}
+		});
+
+	}
+
+	@Override
+	public void run() {
+		try {
+			Registry registry = LocateRegistry.getRegistry(null);
+			initiatorPeer = (InitiatorPeer) registry.lookup(peer_ap);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		protocols.get(sub_protocol).run();
+	}
+
+	private void backup() throws NumberFormatException, RemoteException {
+		File file = new File(this.opnd_1);
+		System.out.println("--> BACKUP :: Saving chunks at " + file.getAbsolutePath() + "\"");
+		initiatorPeer.backup(file, Integer.parseInt(this.opnd_2));
+
+	}
+
+	private void delete() throws RemoteException {
+		System.out.println("--> DELETE :: delete file: " + opnd_1 + "\"");
+		initiatorPeer.delete(this.opnd_1);
+
+	}
 }
Index: DistributedBackupService/src/handlers/BackupChunkHandler.java
===================================================================
--- DistributedBackupService/src/handlers/BackupChunkHandler.java	(revision 1)
+++ DistributedBackupService/src/handlers/BackupChunkHandler.java	(revision 2)
@@ -11,67 +11,104 @@
 import protocols.BackupChunk;
 
 public class BackupChunkHandler implements Runnable {
+	private Peer peer;
+	private Chunk chunk;
+	private final String protocolVersion;
+	private AtomicIntegerArray replication;
+	private int retries = 5;
 
-    private final String protocolVersion;
-    private Peer parentPeer;
-    private Chunk chunk;
-    private AtomicIntegerArray chunkReplication;
-    private int retries = 5;
+	public BackupChunkHandler(BackupChunk backupChunk, Chunk chunk) {
+		this.chunk = chunk;
+		this.peer = backupChunk.getPeer();
+		this.protocolVersion = backupChunk.getVersion();
+		this.replication = peer.getPeerInformation().getChunkReplication(chunk.getFileID());
+	}
 
-    public BackupChunkHandler(BackupChunk backupInitiator, Chunk chunk) {
-        this.chunk = chunk;
-        this.parentPeer = backupInitiator.getPeer();
-        this.protocolVersion = backupInitiator.getVersion();
-        this.chunkReplication = parentPeer.getPeerInformation().getChunkReplication(chunk.getFileID());
-    }
+	BackupChunkHandler(Peer peer, Chunk chunk) {
+		this.chunk = chunk;
+		this.peer = peer;
+		this.protocolVersion = Utils.VERSION;
+		this.replication = null;
+	}
 
-    BackupChunkHandler(Peer parentPeer, Chunk chunk) {
-        this.chunk = chunk;
-        this.parentPeer = parentPeer;
-        this.protocolVersion = Utils.VERSION;
-        this.chunkReplication = null;
-    }
+	@Override
+	public void run() {
+		int waitTime = 1000;
+		Message msg = generatePutChunkMsg(chunk, protocolVersion);
 
-    @Override
-    public void run() {
+		for (int i = 0; i < retries; ++i) {
+			if (isReplicationtheWantedOne() == true) {
+				System.out.println("Achieved desired replication at i=" + i);
+				break;
+			}
+			try {
+				peer.sendMsg(Socket.SocketType.MDB, msg);
+			} catch (IOException e1) {
+				e1.printStackTrace();
+			}
 
-        int waitTime = 1000;
-        Message msg = generatePutChunkMsg(chunk, protocolVersion);
+			try {
+				sleep(waitTime);
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
 
-        for (int i = 0; i < retries; ++i) {
-            if (isDesiredReplicationDegree()) {
-            	System.out.println("Achieved desired replication at i=" + i);
-                break;
-            }
+			waitTime *= 2;
+		}
+	}
 
-            try {
-                parentPeer.sendMsg(Socket.SocketType.MDB, msg);
-            } catch (IOException e) {
-            	System.out.println(e.getMessage());
-            }
+	protected boolean isReplicationtheWantedOne() {
+		if(replication != null && replication.get(chunk.getChunkNo()) >= chunk.getReplication())
+			return true;
+		else return false;
+	}
 
-            sleep(waitTime);
-            waitTime *= 2;
-        }
-    }
+	private void sleep(int waitTime) throws InterruptedException {
+		Thread.sleep(waitTime);
+	}
 
-    protected boolean isDesiredReplicationDegree() {
-        return chunkReplication != null && chunkReplication.get(chunk.getChunkNo()) >= chunk.getReplication();
-    }
+	private Message generatePutChunkMsg(Chunk chunk, String protocolVersion) {
+		String[] args = { protocolVersion, Integer.toString(peer.getID()), chunk.getFileID(), Integer.toString(chunk.getChunkNo()), Integer.toString(chunk.getReplication()) };
+		
+		return new Message(Utils.MessageType.PUTCHUNK, args, chunk.getData());
+	}
 
-    private void sleep(int waitTime) {
-        try {
-            Thread.sleep(waitTime);
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-    }
+	// Getters and Setters
 
-    private Message generatePutChunkMsg(Chunk chunk, String protocolVersion) {
-        String[] args = { protocolVersion, Integer.toString(parentPeer.getID()), chunk.getFileID(), Integer.toString(chunk.getChunkNo()), Integer.toString(chunk.getReplication())
-        };
+	public Peer getPeer() {
+		return peer;
+	}
 
-        return new Message(Utils.MessageType.PUTCHUNK, args, chunk.getData());
-    }
+	public Chunk getChunk() {
+		return chunk;
+	}
 
+	public String getProtocolVersion() {
+		return protocolVersion;
+	}
+
+	public AtomicIntegerArray getReplication() {
+		return replication;
+	}
+
+	public int getRetries() {
+		return retries;
+	}
+
+	public void setPeer(Peer peer) {
+		this.peer = peer;
+	}
+
+	public void setChunk(Chunk chunk) {
+		this.chunk = chunk;
+	}
+
+	public void setReplication(AtomicIntegerArray replication) {
+		this.replication = replication;
+	}
+
+	public void setRetries(int retries) {
+		this.retries = retries;
+	}
+
 }
Index: DistributedBackupService/src/handlers/Handler.java
===================================================================
--- DistributedBackupService/src/handlers/Handler.java	(revision 1)
+++ DistributedBackupService/src/handlers/Handler.java	(revision 2)
@@ -10,19 +10,20 @@
 import chunk.FileManager;
 
 public class Handler implements Runnable {
-	private Peer parentPeer;
+	private BlockingQueue<Message> msgQueue;
+	private ScheduledExecutorService agent;
+	private Peer peer;
 	private Chunk peerInformation;
-	private BlockingQueue<Message> msgQueue;
-	private ScheduledExecutorService executor;
+
 	private int delayLimit;
 
 	private Random random;
 
-	public Handler(Peer parentPeer) {
-		this.parentPeer = parentPeer;
-		this.peerInformation = parentPeer.getPeerInformation();
+	public Handler(Peer peer) {
+		this.peer = peer;
+		this.peerInformation = peer.getPeerInformation();
 		msgQueue = new LinkedBlockingQueue<>();
-		executor = Executors.newScheduledThreadPool(5);
+		agent = Executors.newScheduledThreadPool(5);
 		delayLimit = 300;
 
 		this.random = new Random();
@@ -36,28 +37,20 @@
 			try {
 				msg = msgQueue.take();
 				if (msg == null) {
-					System.out.println("Null Message Received");
+					System.out.println("No msg received!");
 					return;
 				}
-
-				System.out.println("R: " + msg.toString());
-
+				System.out.println("R:: " + msg.toString());
 				switch (msg.getType()) {
 				case PUTCHUNK:
-					Backup backup = new Backup(parentPeer, msg);
-					executor.execute(backup);
+					Backup backup = new Backup(peer, msg);
+					agent.execute(backup);
 					break;
 				case STORED:
 					peerInformation.addChunkReplication(msg.getFileID(), msg.getChunkNo());
 					break;
-				case GETCHUNK:
-
-					break;
-				case CHUNK:
-
-					break;
 				case REMOVED:
-					FileManager database = parentPeer.getDatabase();
+					FileManager database = peer.getDatabase();
 					String fileID = msg.getFileID();
 					int chunkNo = msg.getChunkNo();
 					
@@ -67,10 +60,10 @@
 					int targetReplication = chunkInfo.getReplication();
 
 					if (perceivedReplication < targetReplication) {
-						byte[] chunkData = parentPeer.loadChunk(fileID, chunkNo);
+						byte[] chunkData = peer.loadChunk(fileID, chunkNo);
 
-						executor.schedule(
-								new RemovedChunkHandler(parentPeer, chunkInfo, chunkData),
+						agent.schedule(
+								new RemovedChunkHandler(peer, chunkInfo, chunkData),
 								this.random.nextInt(delayLimit + 1),
 								TimeUnit.MILLISECONDS
 								);
@@ -77,8 +70,8 @@
 					}
 					break;
 				case DELETE:
-					Delete delete = new Delete(parentPeer, msg);
-					executor.execute(delete);
+					Delete delete = new Delete(peer, msg);
+					agent.execute(delete);
 					break;
 				default:
 					return;
@@ -89,9 +82,58 @@
 		}
 	}
 
-
 	public void pushMessage(byte[] data, int length) {
 		Message msgParsed = new Message(data, length);
 		msgQueue.add(msgParsed);
 	}
+
+	// Getters and setters
+	
+	public BlockingQueue<Message> getMsgQueue() {
+		return msgQueue;
+	}
+
+	public ScheduledExecutorService getAgent() {
+		return agent;
+	}
+
+	public Peer getPeer() {
+		return peer;
+	}
+
+	public Chunk getPeerInformation() {
+		return peerInformation;
+	}
+
+	public int getDelayLimit() {
+		return delayLimit;
+	}
+
+	public Random getRandom() {
+		return random;
+	}
+
+	public void setMsgQueue(BlockingQueue<Message> msgQueue) {
+		this.msgQueue = msgQueue;
+	}
+
+	public void setAgent(ScheduledExecutorService agent) {
+		this.agent = agent;
+	}
+
+	public void setPeer(Peer peer) {
+		this.peer = peer;
+	}
+
+	public void setPeerInformation(Chunk peerInformation) {
+		this.peerInformation = peerInformation;
+	}
+
+	public void setDelayLimit(int delayLimit) {
+		this.delayLimit = delayLimit;
+	}
+
+	public void setRandom(Random random) {
+		this.random = random;
+	}
 }
\ No newline at end of file
Index: DistributedBackupService/src/handlers/Message.java
===================================================================
--- DistributedBackupService/src/handlers/Message.java	(revision 1)
+++ DistributedBackupService/src/handlers/Message.java	(revision 2)
@@ -86,7 +86,6 @@
 	}
 
 	private void translateHeader(String[] headerSplit) {
-
 		switch (headerSplit[0]) {
 		case "PUTCHUNK": 
 		{
@@ -162,6 +161,26 @@
 		}
 	}
 
+	@Override
+	public String toString() {
+		String str;
+		if(msgType == MessageType.PUTCHUNK)
+		{
+			str = "<" + msgType +">" + " " + "<" + version+">" + " " + "<" + senderID+">" + " " +"<" + fileID+">" + " " + "<" +chunkNo+">";
+		} 
+		else if(msgType == MessageType.DELETE) 
+		{
+			str = "<" + msgType +">" + " " + "<" + version+">" + " " + "<" + senderID+">" + " " +"<" + fileID+">";
+		}
+		else 
+		{
+			str = "<" + msgType +">" + " " + "<" + version+">" + " " + "<" + senderID+">" + " " +"<" + fileID+">" + " " + "<" +chunkNo+">";
+		}
+		return str;
+	}
+	
+	// Getters and Setters
+	
 	public String getVersion() {
 		return version;
 	}
@@ -190,22 +209,48 @@
 		return msgType;
 	}
 
-	@Override
-	public String toString() {
-		String str;
-		if(msgType == MessageType.PUTCHUNK)
-		{
-			str = "<" + msgType +">" + " " + "<" + version+">" + " " + "<" + senderID+">" + " " +"<" + fileID+">" + " " + "<" +chunkNo+">";
-		} 
-		else if(msgType == MessageType.DELETE) 
-		{
-			str = "<" + msgType +">" + " " + "<" + version+">" + " " + "<" + senderID+">" + " " +"<" + fileID+">";
-		}
-		else 
-		{
-			str = "<" + msgType +">" + " " + "<" + version+">" + " " + "<" + senderID+">" + " " +"<" + fileID+">" + " " + "<" +chunkNo+">";
-		}
-		return str;
+	public int getArgsNo() {
+		return argsNo;
 	}
 
+	public int getReplication() {
+		return replication;
+	}
+
+	public MessageType getMsgType() {
+		return msgType;
+	}
+
+	public void setArgsNo(int argsNo) {
+		this.argsNo = argsNo;
+	}
+
+	public void setChunkNo(int chunkNo) {
+		this.chunkNo = chunkNo;
+	}
+
+	public void setSenderID(int senderID) {
+		this.senderID = senderID;
+	}
+
+	public void setFileID(String fileID) {
+		this.fileID = fileID;
+	}
+
+	public void setVersion(String version) {
+		this.version = version;
+	}
+
+	public void setReplication(int replication) {
+		this.replication = replication;
+	}
+
+	public void setMsgType(MessageType msgType) {
+		this.msgType = msgType;
+	}
+
+	public void setBody(byte[] body) {
+		this.body = body;
+	}
+
 }
\ No newline at end of file
Index: DistributedBackupService/src/handlers/RemovedChunkHandler.java
===================================================================
--- DistributedBackupService/src/handlers/RemovedChunkHandler.java	(revision 1)
+++ DistributedBackupService/src/handlers/RemovedChunkHandler.java	(revision 2)
@@ -4,16 +4,28 @@
 import server.Peer;
 
 public class RemovedChunkHandler extends BackupChunkHandler {
-    private Chunk chunkInfo;
+    private Chunk chunkInformation;
 
-    public RemovedChunkHandler(Peer parentPeer, Chunk chunkInfo, byte[] chunkData) {
-        super(parentPeer, new Chunk(chunkInfo, chunkData));
+    public RemovedChunkHandler(Peer peer, Chunk chunkInformation, byte[] chunkData) {
+        super(peer, new Chunk(chunkInformation, chunkData));
 
-        this.chunkInfo = chunkInfo;
+        this.chunkInformation = chunkInformation;
     }
 
     @Override
-    protected boolean isDesiredReplicationDegree() {
-        return chunkInfo.getNumChunks() >= chunkInfo.getReplication();
+    protected boolean isReplicationtheWantedOne() {
+         if(chunkInformation.getNumChunks() >= chunkInformation.getReplication())
+        	 return true;
+         else
+        	 return false;
     }
+
+    // Getters and setters
+	public Chunk getChunkInfo() {
+		return chunkInformation;
+	}
+
+	public void setChunkInfo(Chunk chunkInfo) {
+		this.chunkInformation = chunkInfo;
+	}
 }
