dmwriterimpl.java

java 文件下载器。可自定义

		CacheFile cache_file = file.getCacheFile();
		int buffer_size;
		DirectByteBuffer buffer;
		long remainder;
		long written;
		if (length == 0L)
		{
			cache_file.setLength(0L);
			break MISSING_BLOCK_LABEL_328;
		}
		buffer_size = pieceLength >= 0x100000 ? pieceLength : 0x100000;
		buffer_size = ((buffer_size + 1023) / 1024) * 1024;
		buffer = DirectByteBufferPool.getBuffer((byte)7, buffer_size);
		remainder = length;
		written = 0L;
		byte blanks[] = new byte[1024];
		for (int i = 0; i < buffer_size / 1024; i++)
			buffer.put((byte)8, blanks);

		buffer.position((byte)8, 0);
		while (remainder > 0L && !stopped) 
		{
			int write_size = buffer_size;
			if (remainder < (long)write_size)
			{
				write_size = (int)remainder;
				buffer.limit((byte)8, write_size);
			}
			final AESemaphore sem = new AESemaphore("DMW&C:zeroFile");
			final Throwable op_failed[] = {
				null
			};
			disk_access.queueWriteRequest(cache_file, written, buffer, false, new DiskAccessRequestListener() {

				final AESemaphore val$sem;
				final Throwable val$op_failed[];
				final DMWriterImpl this$0;

				public void requestComplete(DiskAccessRequest request)
				{
					sem.release();
				}

				public void requestCancelled(DiskAccessRequest request)
				{
					op_failed[0] = new Throwable("Request cancelled");
					sem.release();
				}

				public void requestFailed(DiskAccessRequest request, Throwable cause)
				{
					op_failed[0] = cause;
					sem.release();
				}

				public int getPriority()
				{
					return -1;
				}

				public void requestExecuted(long l)
				{
				}

			
			{
				this$0 = DMWriterImpl.this;
				sem = aesemaphore;
				op_failed = athrowable;
				super();
			}
			});
			sem.reserve();
			if (op_failed[0] != null)
				throw op_failed[0];
			buffer.position((byte)8, 0);
			written += write_size;
			remainder -= write_size;
			disk_manager.setAllocated(disk_manager.getAllocated() + (long)write_size);
			disk_manager.setPercentDone((int)((disk_manager.getAllocated() * 1000L) / totalLength));
		}
		buffer.returnToPool();
		break MISSING_BLOCK_LABEL_321;
		Exception exception;
		exception;
		buffer.returnToPool();
		throw exception;
		cache_file.flushCache();
		Throwable e;
		return !stopped;
		e;
		Debug.printStackTrace(e);
		throw new DiskManagerException(e);
	}

	public DiskManagerWriteRequest createWriteRequest(int pieceNumber, int offset, DirectByteBuffer buffer, Object user_data)
	{
		return new DiskManagerWriteRequestImpl(pieceNumber, offset, buffer, user_data);
	}

	public boolean hasOutstandingWriteRequestForPiece(int piece_number)
	{
		Iterator it;
		this_mon.enter();
		it = write_requests.iterator();
		boolean flag1;
		DiskManagerWriteRequest request;
		do
		{
			if (!it.hasNext())
				break MISSING_BLOCK_LABEL_62;
			request = (DiskManagerWriteRequest)it.next();
		} while (request.getPieceNumber() != piece_number);
		flag1 = true;
		this_mon.exit();
		return flag1;
		boolean flag = false;
		this_mon.exit();
		return flag;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	public void writeBlock(final DiskManagerWriteRequest request, final DiskManagerWriteRequestListener _listener)
	{
		final DiskManagerWriteRequestListener listener;
		request.requestStarts();
		listener = new DiskManagerWriteRequestListener() {

			final DiskManagerWriteRequestListener val$_listener;
			final DMWriterImpl this$0;

			public void writeCompleted(DiskManagerWriteRequest request)
			{
				request.requestEnds(true);
				_listener.writeCompleted(request);
			}

			public void writeFailed(DiskManagerWriteRequest request, Throwable cause)
			{
				request.requestEnds(false);
				_listener.writeFailed(request, cause);
			}

			
			{
				this$0 = DMWriterImpl.this;
				_listener = diskmanagerwriterequestlistener;
				super();
			}
		};
		DirectByteBuffer buffer;
		List chunks;
		DiskManagerWriteRequestListener l;
		int pieceNumber = request.getPieceNumber();
		buffer = request.getBuffer();
		int offset = request.getOffset();
		final DiskManagerPiece dmPiece = disk_manager.getPieces()[pieceNumber];
		if (dmPiece.isDone())
		{
			buffer.returnToPool();
			listener.writeCompleted(request);
			break MISSING_BLOCK_LABEL_516;
		}
		int buffer_position = buffer.position((byte)8);
		int buffer_limit = buffer.limit((byte)8);
		int previousFilesLength = 0;
		int currentFile = 0;
		DMPieceList pieceList = disk_manager.getPieceList(pieceNumber);
		DMPieceMapEntry current_piece = pieceList.get(currentFile);
		long fileOffset = current_piece.getOffset();
		for (; previousFilesLength + current_piece.getLength() < offset; current_piece = pieceList.get(currentFile))
		{
			previousFilesLength += current_piece.getLength();
			currentFile++;
			fileOffset = 0L;
		}

		chunks = new ArrayList();
		while (buffer_position < buffer_limit) 
		{
			current_piece = pieceList.get(currentFile);
			long file_limit = (long)buffer_position + (current_piece.getFile().getLength() - current_piece.getOffset() - (long)(offset - previousFilesLength));
			if (file_limit > (long)buffer_limit)
				file_limit = buffer_limit;
			if (file_limit > (long)buffer_position)
			{
				long file_pos = fileOffset + (long)(offset - previousFilesLength);
				chunks.add(((Object) (new Object[] {
					current_piece.getFile(), new Long(file_pos), new Integer((int)file_limit)
				})));
				buffer_position = (int)file_limit;
			}
			currentFile++;
			fileOffset = 0L;
			previousFilesLength = offset;
		}
		l = new DiskManagerWriteRequestListener() {

			final DiskManagerWriteRequestListener val$listener;
			final DiskManagerPiece val$dmPiece;
			final DiskManagerWriteRequest val$request;
			final DMWriterImpl this$0;

			public void writeCompleted(DiskManagerWriteRequest request)
			{
				complete();
				listener.writeCompleted(request);
			}

			public void writeFailed(DiskManagerWriteRequest request, Throwable cause)
			{
				complete();
				if (dmPiece.isDone())
				{
					if (Logger.isEnabled())
						Logger.log(new LogEvent(disk_manager, DMWriterImpl.LOGID, (new StringBuilder()).append("Piece ").append(dmPiece.getPieceNumber()).append(" write failed but already marked as done").toString()));
					listener.writeCompleted(request);
				} else
				{
					disk_manager.setFailed((new StringBuilder()).append("Disk write error - ").append(Debug.getNestedExceptionMessage(cause)).toString());
					Debug.printStackTrace(cause);
					listener.writeFailed(request, cause);
				}
			}

			protected void complete()
			{
				this_mon.enter();
				async_writes--;
				if (!write_requests.remove(request))
					Debug.out("request not found");
				if (stopped)
					async_write_sem.release();
				this_mon.exit();
				break MISSING_BLOCK_LABEL_88;
				Exception exception1;
				exception1;
				this_mon.exit();
				throw exception1;
			}

			
			{
				this$0 = DMWriterImpl.this;
				listener = diskmanagerwriterequestlistener;
				dmPiece = diskmanagerpiece;
				request = diskmanagerwriterequest;
				super();
			}
		};
		this_mon.enter();
		if (!stopped)
			break MISSING_BLOCK_LABEL_397;
		buffer.returnToPool();
		listener.writeFailed(request, new Exception("Disk writer has been stopped"));
		this_mon.exit();
		return;
		async_writes++;
		write_requests.add(request);
		this_mon.exit();
		break MISSING_BLOCK_LABEL_440;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
		new requestDispatcher(request, l, buffer, chunks);
		break MISSING_BLOCK_LABEL_516;
		Throwable e;
		e;
		request.getBuffer().returnToPool();
		disk_manager.setFailed((new StringBuilder()).append("Disk write error - ").append(Debug.getNestedExceptionMessage(e)).toString());
		Debug.printStackTrace(e);
		listener.writeFailed(request, e);
	}

	static 
	{
		LOGID = LogIDs.DISK;
	}








}