dmreaderimpl.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   DMReaderImpl.java

package org.gudy.azureus2.core3.disk.impl.access.impl;

import com.aelitis.azureus.core.diskmanager.access.*;
import com.aelitis.azureus.core.diskmanager.cache.CacheFile;
import java.util.*;
import org.gudy.azureus2.core3.disk.DiskManagerReadRequest;
import org.gudy.azureus2.core3.disk.DiskManagerReadRequestListener;
import org.gudy.azureus2.core3.disk.impl.DiskManagerFileInfoImpl;
import org.gudy.azureus2.core3.disk.impl.DiskManagerHelper;
import org.gudy.azureus2.core3.disk.impl.access.DMReader;
import org.gudy.azureus2.core3.disk.impl.piecemapper.DMPieceList;
import org.gudy.azureus2.core3.disk.impl.piecemapper.DMPieceMapEntry;
import org.gudy.azureus2.core3.logging.*;
import org.gudy.azureus2.core3.util.*;

// Referenced classes of package org.gudy.azureus2.core3.disk.impl.access.impl:
//			DiskManagerReadRequestImpl

public class DMReaderImpl
	implements DMReader
{
	protected class requestDispatcher
		implements DiskAccessRequestListener
	{

		private DiskManagerReadRequest dm_request;
		private DiskManagerReadRequestListener listener;
		private DirectByteBuffer buffer;
		private List chunks;
		private int buffer_length;
		private int chunk_index;
		final DMReaderImpl this$0;

		protected void dispatch()
		{
			try
			{
				if (chunk_index == chunks.size())
				{
					buffer.limit((byte)7, buffer_length);
					buffer.position((byte)7, 0);
					listener.readCompleted(dm_request, buffer);
				} else
				if (chunk_index == 1 && chunks.size() > 32)
				{
					for (int i = 1; i < chunks.size(); i++)
					{
						final AESemaphore sem = new AESemaphore("DMR:dispatch:asyncReq");
						final Throwable error[] = {
							null
						};
						doRequest(new DiskAccessRequestListener() {

							final AESemaphore val$sem;
							final Throwable val$error[];
							final requestDispatcher this$1;

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

							public void requestCancelled(DiskAccessRequest request)
							{
								Debug.out("shouldn't get here");
							}

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

							public int getPriority()
							{
								return listener.getPriority();
							}

							public void requestExecuted(long bytes)
							{
								listener.requestExecuted(bytes);
							}

				
				{
					this$1 = requestDispatcher.this;
					sem = aesemaphore;
					error = athrowable;
					super();
				}
						});
						sem.reserve();
						if (error[0] != null)
							throw error[0];
					}

					buffer.limit((byte)7, buffer_length);
					buffer.position((byte)7, 0);
					listener.readCompleted(dm_request, buffer);
				} else
				{
					doRequest(this);
				}
			}
			catch (Throwable e)
			{
				failed(e);
			}
		}

		protected void doRequest(DiskAccessRequestListener l)
		{
			Object stuff[] = (Object[])(Object[])chunks.get(chunk_index++);
			buffer.limit((byte)7, ((Integer)stuff[2]).intValue());
			short cache_policy = dm_request.getUseCache() ? 1 : 0;
			if (dm_request.getFlush())
				cache_policy |= 2;
			disk_access.queueReadRequest((CacheFile)stuff[0], ((Long)stuff[1]).longValue(), buffer, cache_policy, l);
		}

		public void requestComplete(DiskAccessRequest request)
		{
			dispatch();
		}

		public void requestCancelled(DiskAccessRequest request)
		{
			Debug.out("shouldn't get here");
		}

		public void requestFailed(DiskAccessRequest request, Throwable cause)
		{
			failed(cause);
		}

		public int getPriority()
		{
			return listener.getPriority();
		}

		public void requestExecuted(long bytes)
		{
			listener.requestExecuted(bytes);
		}

		protected void failed(Throwable cause)
		{
			buffer.returnToPool();
			disk_manager.setFailed((new StringBuilder()).append("Disk read error - ").append(Debug.getNestedExceptionMessage(cause)).toString());
			Debug.printStackTrace(cause);
			listener.readFailed(dm_request, cause);
		}


		protected requestDispatcher(DiskManagerReadRequest _request, DiskManagerReadRequestListener _listener, DirectByteBuffer _buffer, List _chunks)
		{
			this$0 = DMReaderImpl.this;
			super();
			dm_request = _request;
			listener = _listener;
			buffer = _buffer;
			chunks = _chunks;
			buffer_length = buffer.limit((byte)7);
			dispatch();
		}
	}


	private static final LogIDs LOGID;
	private DiskManagerHelper disk_manager;
	private DiskAccessController disk_access;
	private int async_reads;
	private Set read_requests;
	private AESemaphore async_read_sem;
	private boolean started;
	private boolean stopped;
	protected AEMonitor this_mon;

	public DMReaderImpl(DiskManagerHelper _disk_manager)
	{
		read_requests = new HashSet();
		async_read_sem = new AESemaphore("DMReader:asyncReads");
		this_mon = new AEMonitor("DMReader");
		disk_manager = _disk_manager;
		disk_access = disk_manager.getDiskAccessController();
	}

	public void start()
	{
		this_mon.enter();
		if (started)
			throw new RuntimeException("can't start twice");
		if (stopped)
			throw new RuntimeException("already been stopped");
		started = true;
		this_mon.exit();
		break MISSING_BLOCK_LABEL_66;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	public void stop()
	{
		this_mon.enter();
		if (stopped || !started)
		{
			this_mon.exit();
			return;
		}
		int read_wait;
		stopped = true;
		read_wait = async_reads;
		this_mon.exit();
		break MISSING_BLOCK_LABEL_59;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
		long log_time = SystemTime.getCurrentTime();
		for (int i = 0; i < read_wait; i++)
		{
			long now = SystemTime.getCurrentTime();
			if (now < log_time)
				log_time = now;
			else
			if (now - log_time > 1000L)
			{
				log_time = now;
				if (Logger.isEnabled())
					Logger.log(new LogEvent(disk_manager, LOGID, (new StringBuilder()).append("Waiting for reads to complete - ").append(read_wait - i).append(" remaining").toString()));
			}
			async_read_sem.reserve();
		}

		return;
	}

	public DiskManagerReadRequest createReadRequest(int pieceNumber, int offset, int length)
	{
		return new DiskManagerReadRequestImpl(pieceNumber, offset, length);
	}

	public boolean hasOutstandingReadRequestForPiece(int piece_number)
	{
		Iterator it;
		this_mon.enter();
		it = read_requests.iterator();
		boolean flag1;
		DiskManagerReadRequest request;
		do
		{
			if (!it.hasNext())
				break MISSING_BLOCK_LABEL_70;
			request = (DiskManagerReadRequest)((Object[])(Object[])it.next())[0];
		} 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 DirectByteBuffer readBlock(int pieceNumber, int offset, int length)
	{
		DiskManagerReadRequest request = createReadRequest(pieceNumber, offset, length);
		final AESemaphore sem = new AESemaphore("DMReader:readBlock");
		final DirectByteBuffer result[] = {
			null
		};
		readBlock(request, new DiskManagerReadRequestListener() {

			final DirectByteBuffer val$result[];
			final AESemaphore val$sem;
			final DMReaderImpl this$0;

			public void readCompleted(DiskManagerReadRequest request, DirectByteBuffer data)
			{
				result[0] = data;
				sem.release();
			}

			public void readFailed(DiskManagerReadRequest request, Throwable cause)
			{
				sem.release();
			}

			public int getPriority()
			{
				return -1;
			}

			public void requestExecuted(long l)
			{
			}

			
			{
				this$0 = DMReaderImpl.this;
				result = adirectbytebuffer;
				sem = aesemaphore;
				super();
			}
		});
		sem.reserve();
		return result[0];
	}

	public void readBlock(DiskManagerReadRequest request, final DiskManagerReadRequestListener _listener)
	{
		final DiskManagerReadRequestListener listener;
		DirectByteBuffer buffer;
		request.requestStarts();
		listener = new DiskManagerReadRequestListener() {

			final DiskManagerReadRequestListener val$_listener;
			final DMReaderImpl this$0;

			public void readCompleted(DiskManagerReadRequest request, DirectByteBuffer data)
			{
				request.requestEnds(true);
				_listener.readCompleted(request, data);
			}

			public void readFailed(DiskManagerReadRequest request, Throwable cause)
			{
				request.requestEnds(false);
				_listener.readFailed(request, cause);
			}

			public int getPriority()
			{
				return _listener.getPriority();
			}

			public void requestExecuted(long bytes)
			{
				_listener.requestExecuted(bytes);
			}

			
			{
				this$0 = DMReaderImpl.this;
				_listener = diskmanagerreadrequestlistener;
				super();
			}
		};
		buffer = null;
		int length;
		length = request.getLength();
		buffer = DirectByteBufferPool.getBuffer((byte)6, length);
		if (buffer == null)
		{
			Debug.out("DiskManager::readBlock:: ByteBufferPool returned null buffer");
			listener.readFailed(request, new Exception("Out of memory"));
			return;
		}
		int pieceNumber;
		int offset;
		DMPieceList pieceList;
		pieceNumber = request.getPieceNumber();
		offset = request.getOffset();
		pieceList = disk_manager.getPieceList(pieceNumber);
		if (pieceList.size() == 0)
		{
			Debug.out((new StringBuilder()).append("no pieceList entries for ").append(pieceNumber).toString());
			listener.readCompleted(request, buffer);
			return;
		}
		List chunks;
		long previousFilesLength = 0L;
		int currentFile = 0;
		long fileOffset;
		for (fileOffset = pieceList.get(0).getOffset(); currentFile < pieceList.size() && pieceList.getCumulativeLengthToPiece(currentFile) < offset; fileOffset = 0L)
		{
			previousFilesLength = pieceList.getCumulativeLengthToPiece(currentFile);
			currentFile++;
		}

		fileOffset += (long)offset - previousFilesLength;
		chunks = new ArrayList();
		for (int buffer_position = 0; buffer_position < length && currentFile < pieceList.size();)
		{
			DMPieceMapEntry map_entry = pieceList.get(currentFile);
			int length_available = map_entry.getLength() - (int)(fileOffset - map_entry.getOffset());
			int entry_read_limit = buffer_position + length_available;
			entry_read_limit = Math.min(length, entry_read_limit);
			chunks.add(((Object) (new Object[] {
				map_entry.getFile().getCacheFile(), new Long(fileOffset), new Integer(entry_read_limit)
			})));
			buffer_position = entry_read_limit;
			currentFile++;
			fileOffset = 0L;
		}

		if (chunks.size() == 0)
		{
			Debug.out((new StringBuilder()).append("no chunk reads for ").append(pieceNumber).toString());
			listener.readCompleted(request, buffer);
			return;
		}
		final Object request_wrapper[];
		DiskManagerReadRequestListener l;
		request_wrapper = (new Object[] {
			request
		});
		l = new DiskManagerReadRequestListener() {

			final DiskManagerReadRequestListener val$listener;
			final DiskManagerReadRequestListener val$_listener;
			final Object val$request_wrapper[];
			final DMReaderImpl this$0;

			public void readCompleted(DiskManagerReadRequest request, DirectByteBuffer data)
			{
				complete();
				listener.readCompleted(request, data);
			}

			public void readFailed(DiskManagerReadRequest request, Throwable cause)
			{
				complete();
				listener.readFailed(request, cause);
			}

			public int getPriority()
			{
				return _listener.getPriority();
			}

			public void requestExecuted(long bytes)
			{
				_listener.requestExecuted(bytes);
			}

			protected void complete()
			{
				this_mon.enter();
				async_reads--;
				if (!read_requests.remove(((Object) (request_wrapper))))
					Debug.out("request not found");
				if (stopped)
					async_read_sem.release();
				this_mon.exit();
				break MISSING_BLOCK_LABEL_88;
				Exception exception1;
				exception1;
				this_mon.exit();
				throw exception1;
			}

			
			{
				this$0 = DMReaderImpl.this;
				listener = diskmanagerreadrequestlistener;
				_listener = diskmanagerreadrequestlistener1;
				request_wrapper = aobj;
				super();
			}
		};
		this_mon.enter();
		if (!stopped)
			break MISSING_BLOCK_LABEL_465;
		buffer.returnToPool();
		listener.readFailed(request, new Exception("Disk reader has been stopped"));
		this_mon.exit();
		return;
		async_reads++;
		read_requests.add(((Object) (request_wrapper)));
		this_mon.exit();
		break MISSING_BLOCK_LABEL_509;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
		new requestDispatcher(request, l, buffer, chunks);
		break MISSING_BLOCK_LABEL_586;
		Throwable e;
		e;
		if (buffer != null)
			buffer.returnToPool();
		disk_manager.setFailed((new StringBuilder()).append("Disk read error - ").append(Debug.getNestedExceptionMessage(e)).toString());
		Debug.printStackTrace(e);
		listener.readFailed(request, e);
	}

	static 
	{
		LOGID = LogIDs.DISK;
	}






}