/ - Diff - sdis1819-t2g03 - FEUP Project Manager

     		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;
-...
     		chunkRepository.remove(fileID);
+    	}
     	public int getNumChunks(String pathname) {
     		return fileRepository.get(pathname).getNumChunks();
+    	}
     	public Integer getRecognizedReplication(String fileID, int chunkNo)
+    	{
     		int ret;
-...
     		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();
+    	}
+    }

     		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");
-...
     		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;
-...
+    	}
     	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;
-...
     		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();
-...
     		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) {
-...
     		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; }
+    }

     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);
+    	}
+    }

     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;
+    	}
+    }

     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();
-...
     			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();
-...
     					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
     								);
+    					}
     					break;
     				case DELETE:
     					Delete delete = new Delete(parentPeer, msg);
     					executor.execute(delete);
     					Delete delete = new Delete(peer, msg);
     					agent.execute(delete);
     					break;
     				default:
     					return;
-...
+    		}
+    	}
     	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;
+    	}
+    }

+    	}
     	private void translateHeader(String[] headerSplit) {
     		switch (headerSplit[0]) {
     		case "PUTCHUNK":
+    		{
-...
+    		}
+    	}
     	@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;
+    	}
-...
     		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;
+    	}
+    }

     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;
+    	}
+    }

Project

General

Profile

sdis1819-t2g03

Revision 2