diskmanagerimpl.java

一个基于JAVA的多torrent下载程序

	{
		return( allocated );
	}
	
	public void
	setAllocated(
		long		num )
	{
		allocated	= num;
	}
	
	// called when status has CHANGED and should only be called by DiskManagerPieceImpl
	protected void
	setPieceDone(
		DiskManagerPieceImpl	dmPiece,
		boolean					done )
	{
		int piece_number =dmPiece.getPieceNumber();
		int piece_length =dmPiece.getLength();
		DMPieceList piece_list =pieceMap[piece_number];

		try
		{
			file_piece_mon.enter();

			if (dmPiece.isDone() !=done)
			{
				dmPiece.setDoneSupport(done);

				if (done)
					remaining -=piece_length;
				else
					remaining +=piece_length;

				for (int i =0; i <piece_list.size(); i++)
				{

					DMPieceMapEntry piece_map_entry =piece_list.get(i);

					DiskManagerFileInfoImpl this_file =piece_map_entry.getFile();

					long file_length =this_file.getLength();

					long file_done =this_file.getDownloaded();

					long file_done_before =file_done;

					if (done)
						file_done +=piece_map_entry.getLength();
					else
						file_done -=piece_map_entry.getLength();

					if (file_done <0)
					{
						Debug.out("piece map entry length negative");

						file_done =0;

					} else if (file_done >file_length)
					{
						Debug.out("piece map entry length too large");

						file_done =file_length;
					}

					if (this_file.isSkipped())
					{
						skipped_but_downloaded +=(file_done -file_done_before);
					}

					this_file.setDownloaded(file_done);

					// change file modes based on whether or not the file is complete or not
					if (file_done ==file_length &&this_file.getAccessMode() ==DiskManagerFileInfo.WRITE)
					{
						try
						{
							this_file.setAccessMode(DiskManagerFileInfo.READ);

						} catch (Exception e)
						{
							setFailed("Disk access error - " +Debug.getNestedExceptionMessage(e));

							Debug.printStackTrace(e);
						}

						// note - we don't set the access mode to write if incomplete as we may
						// be rechecking a file and during this process the "file_done" amount
						// will not be file_length until the end. If the file is read-only then
						// changing to write will cause trouble!
					}
				}
                listeners.dispatch(LDT_PIECE_DONE_CHANGED, dmPiece);
			}
		} finally
		{
			file_piece_mon.exit();
		}

	}

	public void
	accessModeChanged(
		DiskManagerFileInfoImpl		file,
		int							old_mode,
		int							new_mode )
	{
		listeners.dispatch( 
			LDT_ACCESS_MODE_CHANGED,
			new Object[]{ file, new Integer(old_mode), new Integer(new_mode)});
	}
	
	public DiskManagerPiece[] getPieces()
	{
		return pieces;
	}

	public DiskManagerPiece getPiece(int PieceNumber)
	{
		return pieces[PieceNumber];
	}

	public int getPieceLength() {
		return pieceLength;
	}

	public long getTotalLength() {
		return totalLength;
	}

	public int getLastPieceLength() {
		return lastPieceLength;
	}

	public int getState() {
		return state_set_via_method;
	}

	public void
	setState(
		int		_state ) 
	{
			// we never move from a faulty state
		
		if ( state_set_via_method == FAULTY ){
			
			if ( _state != FAULTY ){
				
				Debug.out( "DiskManager: attempt to move from faulty state to " + _state );
			}
			
			return;
		}
		
		if ( state_set_via_method != _state ){
			
			int params[] = {state_set_via_method, _state};
		  
			state_set_via_method = _state;
			
			listeners.dispatch( LDT_STATECHANGED, params);
		}
	}

	
	public DiskManagerFileInfo[] 
	getFiles() 
	{
		return files;
	}


	private void 
	constructFilesPieces() 
	{
		for (int i = 0; i < pieceMap.length; i++) {
			DMPieceList pieceList = pieceMap[i];
			//for each piece

			for (int j = 0; j < pieceList.size(); j++) {
				//get the piece and the file 
				DiskManagerFileInfoImpl fileInfo = (pieceList.get(j)).getFile();
				if (fileInfo.getFirstPieceNumber() == -1)
					fileInfo.setFirstPieceNumber(i);
				fileInfo.setNbPieces(fileInfo.getNbPieces() + 1);
			}
		}
	}

	public String getErrorMessage() {
		return errorMessage;
	}

	public void
	setFailed(
		final String		reason )
	{
			/**
			 * need to run this on a separate thread to avoid deadlock with the stopping
			 * process - setFailed tends to be called from within the read/write activities
			 * and stopping these requires this.
			 */
		
    	new AEThread("DiskManager:setFailed") 
		{
			public void 
			runSupport() 
			{
				errorMessage	= reason;
				
				Logger.log(new LogAlert(LogAlert.UNREPEATABLE, LogAlert.AT_ERROR,
							errorMessage));
				

				setState( DiskManager.FAULTY );
									
				DiskManagerImpl.this.stop();
			}
		}.start();

	}

	public void
	setFailed(
		final DiskManagerFileInfo		file,
		final String					reason )
	{
			/**
			 * need to run this on a separate thread to avoid deadlock with the stopping
			 * process - setFailed tends to be called from within the read/write activities
			 * and stopping these requires this.
			 */
	
    	new AEThread("DiskManager:setFailed") 
		{
			public void 
			runSupport() 
			{
				errorMessage	= reason;
				
				Logger.log(new LogAlert(LogAlert.UNREPEATABLE, LogAlert.AT_ERROR,
						errorMessage));
				

				setState( DiskManager.FAULTY );
									
				DiskManagerImpl.this.stop();
				
				RDResumeHandler.recheckFile( download_manager, file );
			}
		}.start();

	}
	
	public DMPieceList getPieceList(int piece_number)
	{
		return (pieceMap[piece_number]);
	}
	
	public byte[]
	getPieceHash(
		int	piece_number )
	
		throws TOTorrentException
	{
		return( torrent.getPieces()[ piece_number ]);
	}
	
	public DiskManagerReadRequest
	createReadRequest(
		int pieceNumber,
		int offset,
		int length )
	{
		return( reader.createRequest( pieceNumber, offset, length ));
	}	
  
	public DiskManagerCheckRequest
	createCheckRequest(
		int 	pieceNumber,
		Object	user_data )
	{
		return( checker.createRequest( pieceNumber, user_data ));
	}
	
	public void 
	enqueueCompleteRecheckRequest(
		DiskManagerCheckRequest				request,
		DiskManagerCheckRequestListener 	listener )
		
	{
	  	checker.enqueueCompleteRecheckRequest( request, listener );
	}

	public void 
	enqueueCheckRequest(
		DiskManagerCheckRequest			request,
		DiskManagerCheckRequestListener listener )
	{
	  	checker.enqueueCheckRequest( request, listener );
	}
	  
	public int getCompleteRecheckStatus() 
	{
	  return ( checker.getCompleteRecheckStatus());
	}
  
	public DirectByteBuffer 
	readBlock(
		int pieceNumber, 
		int offset, 
		int length )
	{
		return( reader.readBlock( pieceNumber, offset, length ));
	}
	
	public DiskManagerWriteRequest
	createWriteRequest(
		int 				pieceNumber,
		int 				offset,
		DirectByteBuffer 	data,
		Object 				user_data )
	{
		return( writer.createWriteRequest( pieceNumber, offset, data, user_data ));
	}
	
	public void 
	enqueueWriteRequest(
		DiskManagerWriteRequest			request,
		DiskManagerWriteRequestListener	listener )
	{
		writer.writeBlock( request, listener );
	}
	
	
	public boolean 
	checkBlockConsistency(
		int pieceNumber, 
		int offset, 
		DirectByteBuffer data ) 
	{
		if (pieceNumber < 0) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK1: pieceNumber=" + pieceNumber + " < 0"));
			return false;
		}
		if (pieceNumber >= this.nbPieces) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK1: pieceNumber=" + pieceNumber + " >= this.nbPieces="
								+ this.nbPieces));
			return false;
		}
		int length = this.pieceLength;
		if (pieceNumber == nbPieces - 1) {
			length = this.lastPieceLength;
		}
		if (offset < 0) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK1: offset=" + offset + " < 0"));
			return false;
		}
		if (offset > length) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK1: offset=" + offset + " > length=" + length));
			return false;
		}
		int size = data.remaining(DirectByteBuffer.SS_DW);
		if (size <= 0) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK1: size=" + size + " <= 0"));
			return false;
		}
		if (offset + size > length) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK1: offset=" + offset + " + size=" + size + " > length="
								+ length));
			return false;
		}
		return true;
	}
  
	public boolean 
	checkBlockConsistency(
		int pieceNumber, 
		int offset, 
		int length) 
	{
		if (length > max_read_block_size) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK2: length=" + length + " > " + max_read_block_size));
		  return false;
		}
		if (length <= 0 ) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK2: length=" + length + " <= 0"));
		    return false;
		}	
		if (pieceNumber < 0) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK2: pieceNumber=" + pieceNumber + " < 0"));
		  return false;
		}
		if (pieceNumber >= this.nbPieces) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK2: pieceNumber=" + pieceNumber + " >= this.nbPieces="
								+ this.nbPieces));
		  return false;
		}
		int pLength = this.pieceLength;
		if (pieceNumber == this.nbPieces - 1)
			pLength = this.lastPieceLength;
		if (offset < 0) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK2: offset=" + offset + " < 0"));
		  return false;
		}
		if (offset > pLength) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK2: offset=" + offset + " > pLength=" + pLength));
		  return false;
		}
		if (offset + length > pLength) {
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
						"CHECKBLOCK2: offset=" + offset + " + length=" + length
								+ " > pLength=" + pLength));
		  return false;
		}
        
		if(!pieces[pieceNumber].isDone()) {
            Logger.log(new LogEvent(this, LOGID, LogEvent.LT_ERROR,
                "CHECKBLOCK2: piece #" + pieceNumber + " not done"));
		  return false;
		}
		return true;
	}

	
	public void 
	dumpResumeDataToDisk(
		boolean savePartialPieces, 
		boolean force_recheck )
	
		throws Exception
	{			
		resume_handler.dumpResumeDataToDisk( savePartialPieces, force_recheck );
	}
		
  /**
   * Moves files to the CompletedFiles directory.
   * Returns a string path to the new torrent file.
   */
	
  public void 
  downloadEnded() 
  {
	  try{
    	start_stop_mon.enter();
	    
	    String rPath = download_manager.getAbsoluteSaveLocation().getParent();
	    	    
	    	// don't move non-persistent files as these aren't managed by us
	    
	    if ( !download_manager.isPersistent()){
	    	
	    	return;
	    }
	    
	    //make sure the torrent hasn't already been moved
	
	    	
	  	if ( alreadyMoved ){
	  		
	  		return;
	  	}
	    	
	  	alreadyMoved = true;	
	 
	    boolean moveWhenDone = COConfigurationManager.getBooleanParameter("Move Completed When Done", false);
	    
	    if (!moveWhenDone){
	    	
	    	return;
	    }
	    
	    String moveToDir = COConfigurationManager.getStringParameter("Completed Files Directory", "");
	    
	    if (moveToDir.length() == 0){
	    	
	    	return;
	    }
	
	    boolean moveOnlyInDefault = COConfigurationManager.getBooleanParameter("Move Only When In Default Save Dir");
	      
	    if ( moveOnlyInDefault ){
	      	
	        String defSaveDir = COConfigurationManager.getStringParameter("Default save path");

	        	// canonicalise is as the rpath is canonicalised so links have been followed etc.
	        
	        try{
	        	defSaveDir = new File( defSaveDir ).getCanonicalPath();
	        	
	        }catch( Throwable e ){