sharingmanagerimpl.java

JMule是一个基于Java开发

	    			 sharedFiles.put(shared_completed_file.getFileHash(), shared_completed_file);
	    			 new_files.add(shared_completed_file);
	    			 
	    			 notifyCompletedFileAdded(shared_completed_file);
	    		 } catch( Throwable t ) {
	    		 		t.printStackTrace(); 
	    		 }
	    	 }
	    	 // write our files in known.met
	    	 if ( need_to_write_metadata ) {
	    		 writeMetadata();
	    	 } 
	    	 
	    	 isDone = true;
		}
		
		public double getPercent() {
			if (file_hashing==null) return 100;
			if (!file_hashing.isAlive()) return 100;
			return file_hashing.getPercent();
		}
		
		public SharedFile getCurrentHashingFile() {
			return current_hashing_file;
		}
		
		public List<CompletedFile> getUnhashedFiles() {
			return files_needed_to_hash;
		}
		
	}
	
	public List<CompletedFile> getUnhashedFiles() {
		if( ( load_completed_files == null ) || ( !load_completed_files.isAlive()))
			return null;
		return load_completed_files.getUnhashedFiles();
	}
	
	public double getCurrentHashingFilePercent() {
			
		if( ( load_completed_files == null ) || ( !load_completed_files.isAlive())) return 0;
		
		return load_completed_files.getPercent(); 
    }
	
	public SharedFile getCurrentHashingFile() {
		
		if( ( load_completed_files == null ) || ( !load_completed_files.isAlive())) return null;
		
		return load_completed_files.getCurrentHashingFile();
	}
	
	public void stopLoadingCompletedFiles() {
		if( ( load_completed_files == null ) || ( !load_completed_files.isAlive())) return;
		load_completed_files.JMStop();
	}
	
	public void stopLoadingPartialFiles() {
		
		if( ( load_partial_files == null ) || ( !load_partial_files.isAlive())) return;
		
		load_partial_files.JMStop();
		
	}
	
	public void loadCompletedFiles() {
		if (load_completed_files != null)
			if (load_completed_files.isAlive()) 
				return ;
		load_completed_files = new LoadCompletedFiles();
		load_completed_files.start();
	}
	
	public void loadPartialFiles() {

		load_partial_files = new LoadPartialFiles();
		
		load_partial_files.start();
 	}
	
	public CompletedFile getCompletedFile(FileHash fileHash) {
		SharedFile sharedFile = sharedFiles.get(fileHash);
		if (sharedFile == null) return null;
		if ( !sharedFile.exists() ) {
			sharedFiles.remove(fileHash);
			return null;
		}
		if (sharedFile instanceof CompletedFile) 
			return (CompletedFile)sharedFile;
		else
			return null;
	}
	
	public PartialFile getPartialFle(FileHash fileHash) {
		SharedFile sharedFile = sharedFiles.get(fileHash);
		if (sharedFile == null) return null;
		if ( !sharedFile.exists() ) {
			sharedFiles.remove(fileHash);
			return null;
		}
		if (sharedFile instanceof PartialFile) 
			return (PartialFile)sharedFile;
		else
			return null;
	}
	
	public void makeCompletedFile(FileHash fileHash) throws SharingManagerException {
		File incoming_dir = new File(ConfigurationManager.INCOMING_DIR);
		
		PartialFile shared_partial_file = getPartialFle(fileHash);
		if( shared_partial_file == null ) throw new SharingManagerException("The file " + fileHash + "doesn't exists");
		shared_partial_file.closeFile();
		shared_partial_file.deletePartialFile();
		File completed_file = new File(incoming_dir.getAbsoluteFile() + File.separator + shared_partial_file.getSharingName());
		UploadManager upload_manager = JMuleCoreFactory.getSingleton().getUploadManager();
		try {
		
			if (upload_manager.hasUpload(fileHash)) { 	// JMule is now uploading file, need to synchronize moving
				UploadSession upload_sessison = upload_manager.getUpload(fileHash);
				synchronized(upload_sessison.getSharedFile()) {
					sharedFiles.remove(fileHash);
					FileUtils.moveFile(shared_partial_file.getFile(), completed_file);
					CompletedFile shared_completed_file = new CompletedFile(completed_file);
					shared_completed_file.setHashSet(shared_partial_file.getHashSet());
					sharedFiles.put(fileHash, shared_completed_file);
					new_files.add(shared_completed_file);
				}
			} else {
				sharedFiles.remove(fileHash);
				FileUtils.moveFile(shared_partial_file.getFile(), completed_file);
				CompletedFile shared_completed_file = new CompletedFile(completed_file);
				shared_completed_file.setHashSet(shared_partial_file.getHashSet());
				sharedFiles.put(fileHash, shared_completed_file);
				new_files.add(shared_completed_file);
			}
			writeMetadata();
		} catch (Throwable e) {
			e.printStackTrace();
			throw new SharingManagerException( e );
		}
	}
	
	public void addPartialFile(PartialFile partialFile){
		sharedFiles.put(partialFile.getFileHash(), partialFile);
	}
	
	public int getFileCount() {
		return sharedFiles.size(); 
	}
	
	public boolean hasFile(FileHash fileHash) {
		return sharedFiles.containsKey(fileHash);
	}
	
	public boolean existsFile(FileHash fileHash) {
	    if( !hasFile(fileHash) ) return false;
	    SharedFile shared_file = sharedFiles.get(fileHash);
	    if( !shared_file.exists() ) return false;
	    return true;
	}
	
	public SharedFile getSharedFile(FileHash fileHash) {
		if (!hasFile(fileHash)) return null;
		SharedFile sharedFile = sharedFiles.get(fileHash);
		
		return sharedFile;
	}
	
	public JMIterable<SharedFile> getSharedFiles() {
		return new JMIterable<SharedFile>(sharedFiles.values().iterator());
	}
	
	public List<PartialFile> getPartialFiles() {
		List<PartialFile> file_list = new LinkedList<PartialFile>();
		for(SharedFile file : sharedFiles.values())
			if (file instanceof PartialFile)
					file_list.add((PartialFile) file);
		
		return file_list;
	}
	
	public List<CompletedFile> getCompletedFiles() {
		List<CompletedFile> file_list = new LinkedList<CompletedFile>();
		
		for(SharedFile file : sharedFiles.values())
			if (file instanceof CompletedFile)
					file_list.add((CompletedFile) file);
		
		return file_list;
	}
	
	/**
	 * Write the all meta-info about files from completed files hash table in known.met
	 */
	private void writeMetadata() {
   	   try {
   		  KnownMet known_met = new KnownMet(ConfigurationManager.KNOWN_MET);
   		  
   		  known_met.writeFile(sharedFiles.values());
	   } catch(Throwable t) {
		   t.printStackTrace();
	   }
	}
	
	public void shutdown() {
		sharing_manager_timer.cancel();
		
		stopLoadingCompletedFiles();
		
		stopLoadingPartialFiles();
		
	}
	
	public List<SharedFile> getUnsharedFiles() {
		return new_files;
	}
	
	public void resetUnsharedFiles() {
		new_files.clear();
		new_files.addAll(sharedFiles.values());
	}
	
	public void addCompletedFileListener(CompletedFileListener listener) {
		
		completed_file_listeners.add(listener);
		
	}
	
	public void removeCompletedFileListener(CompletedFileListener listener) {
		
		completed_file_listeners.remove(listener);
	}
	
	private void notifyCompletedFileAdded(CompletedFile file) {
		
		for(CompletedFileListener listener : completed_file_listeners) {
			
			listener.fileAdded( file );
			
		}
		
	}
	public SharedFile getSharedFile(File file) {
		for(SharedFile shared_file : sharedFiles.values()){
			if (shared_file.getAbsolutePath().equals(file.getAbsolutePath()))
				return shared_file;
		}
		
		return null;
	}

	public void removeSharedFile(FileHash fileHash) {
		SharedFile shared_file = sharedFiles.get(fileHash);
		if (shared_file==null) return ;
		sharedFiles.remove(shared_file);
		if (shared_file instanceof CompletedFile) return ;
		shared_file.closeFile();
		shared_file.delete();
	}
}