dmcheckerimpl.java

java 文件下载器。可自定义

			{
				request.requestEnds(true);
				int piece_number = request.getPieceNumber();
				DiskManagerPiece piece = disk_manager.getPiece(request.getPieceNumber());
				piece.setDone(passed);
				if (passed)
				{
					DMPieceList piece_list = disk_manager.getPieceList(piece_number);
					for (int i = 0; i < piece_list.size(); i++)
					{
						DMPieceMapEntry piece_entry = piece_list.get(i);
						piece_entry.getFile().dataChecked(piece_entry.getOffset(), piece_entry.getLength());
					}

				}
				listener.checkCompleted(request, passed);
				if (Logger.isEnabled())
					if (passed)
						Logger.log(new LogEvent(disk_manager, DMCheckerImpl.LOGID, 0, (new StringBuilder()).append("Piece ").append(request.getPieceNumber()).append(" passed hash check.").toString()));
					else
						Logger.log(new LogEvent(disk_manager, DMCheckerImpl.LOGID, 1, (new StringBuilder()).append("Piece ").append(request.getPieceNumber()).append(" failed hash check.").toString()));
				break MISSING_BLOCK_LABEL_374;
				Exception exception;
				exception;
				listener.checkCompleted(request, passed);
				if (Logger.isEnabled())
					if (passed)
						Logger.log(new LogEvent(disk_manager, DMCheckerImpl.LOGID, 0, (new StringBuilder()).append("Piece ").append(request.getPieceNumber()).append(" passed hash check.").toString()));
					else
						Logger.log(new LogEvent(disk_manager, DMCheckerImpl.LOGID, 1, (new StringBuilder()).append("Piece ").append(request.getPieceNumber()).append(" failed hash check.").toString()));
				throw exception;
			}

			public void checkCancelled(DiskManagerCheckRequest request)
			{
				request.requestEnds(false);
				listener.checkCancelled(request);
				if (Logger.isEnabled())
					Logger.log(new LogEvent(disk_manager, DMCheckerImpl.LOGID, 1, (new StringBuilder()).append("Piece ").append(request.getPieceNumber()).append(" hash check cancelled.").toString()));
			}

			public void checkFailed(DiskManagerCheckRequest request, Throwable cause)
			{
				request.requestEnds(false);
				disk_manager.getPiece(request.getPieceNumber()).setDone(false);
				listener.checkFailed(request, cause);
				if (Logger.isEnabled())
					Logger.log(new LogEvent(disk_manager, DMCheckerImpl.LOGID, 1, (new StringBuilder()).append("Piece ").append(request.getPieceNumber()).append(" failed hash check - ").append(Debug.getNestedExceptionMessage(cause)).toString()));
				break MISSING_BLOCK_LABEL_185;
				Exception exception;
				exception;
				listener.checkFailed(request, cause);
				if (Logger.isEnabled())
					Logger.log(new LogEvent(disk_manager, DMCheckerImpl.LOGID, 1, (new StringBuilder()).append("Piece ").append(request.getPieceNumber()).append(" failed hash check - ").append(Debug.getNestedExceptionMessage(cause)).toString()));
				throw exception;
			}

			
			{
				this$0 = DMCheckerImpl.this;
				listener = diskmanagercheckrequestlistener;
				super();
			}
		}, read_flush);
	}

	protected void enqueueCheckRequestSupport(final DiskManagerCheckRequest request, final DiskManagerCheckRequestListener listener, boolean read_flush)
	{
		int pieceNumber;
		if (!checking_enabled)
		{
			listener.checkCompleted(request, true);
			return;
		}
		pieceNumber = request.getPieceNumber();
		final byte required_hash[];
		DMPieceList pieceList;
		required_hash = disk_manager.getPieceHash(pieceNumber);
		pieceList = disk_manager.getPieceList(pieceNumber);
		boolean all_compact;
		int i;
		all_compact = pieceList.size() > 0;
		i = 0;
_L2:
		DiskManagerFileInfoImpl file_info;
		CacheFile cache_file;
		if (i >= pieceList.size())
			break MISSING_BLOCK_LABEL_171;
		DMPieceMapEntry piece_entry = pieceList.get(i);
		file_info = piece_entry.getFile();
		cache_file = file_info.getCacheFile();
		if (cache_file.compareLength(piece_entry.getOffset()) < 0L)
		{
			listener.checkCompleted(request, false);
			return;
		}
		if (all_compact && (cache_file.getStorageType() != 2 || file_info.getNbPieces() <= 2))
			all_compact = false;
		i++;
		if (true) goto _L2; else goto _L1
_L1:
		if (all_compact)
		{
			listener.checkCompleted(request, false);
			return;
		}
		break MISSING_BLOCK_LABEL_198;
		Throwable e;
		e;
		listener.checkCancelled(request);
		return;
		DiskManagerReadRequest read_request;
		int this_piece_length = disk_manager.getPieceLength(pieceNumber);
		read_request = disk_manager.createReadRequest(pieceNumber, 0, this_piece_length);
		this_mon.enter();
		if (!stopped)
			break MISSING_BLOCK_LABEL_256;
		listener.checkCancelled(request);
		this_mon.exit();
		return;
		async_reads++;
		this_mon.exit();
		break MISSING_BLOCK_LABEL_288;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
		read_request.setFlush(read_flush);
		read_request.setUseCache(!request.isAdHoc());
		disk_manager.enqueueReadRequest(read_request, new DiskManagerReadRequestListener() {

			final DiskManagerCheckRequestListener val$listener;
			final DiskManagerCheckRequest val$request;
			final byte val$required_hash[];
			final DMCheckerImpl this$0;

			public void readCompleted(DiskManagerReadRequest read_request, DirectByteBuffer buffer)
			{
				complete();
				this_mon.enter();
				if (!stopped)
					break MISSING_BLOCK_LABEL_52;
				buffer.returnToPool();
				listener.checkCancelled(request);
				this_mon.exit();
				return;
				async_checks++;
				this_mon.exit();
				break MISSING_BLOCK_LABEL_91;
				Exception exception1;
				exception1;
				this_mon.exit();
				throw exception1;
				try
				{
					final DirectByteBuffer f_buffer = buffer;
					ConcurrentHasher.getSingleton().addRequest(buffer.getBuffer((byte)8), new ConcurrentHasherRequestListener() {

						final DirectByteBuffer val$f_buffer;
						final 5 this$1;

						public void complete(ConcurrentHasherRequest hash_request)
						{
							int async_result = 3;
							byte testHash[] = hash_request.getResult();
							if (testHash != null)
							{
								async_result = 1;
								int i = 0;
								do
								{
									if (i >= testHash.length)
										break;
									if (testHash[i] != required_hash[i])
									{
										async_result = 2;
										break;
									}
									i++;
								} while (true);
							}
							break MISSING_BLOCK_LABEL_337;
							local;
							f_buffer.returnToPool();
							if (async_result == 1)
								listener.checkCompleted(request, true);
							else
							if (async_result == 2)
								listener.checkCompleted(request, false);
							else
								listener.checkCancelled(request);
							this_mon.enter();
							async_checks--;
							if (stopped)
								async_check_sem.release();
							this_mon.exit();
							break MISSING_BLOCK_LABEL_335;
							Exception exception3;
							exception3;
							this_mon.exit();
							throw exception3;
							Exception exception4;
							exception4;
							this_mon.enter();
							async_checks--;
							if (stopped)
								async_check_sem.release();
							this_mon.exit();
							break MISSING_BLOCK_LABEL_332;
							Exception exception5;
							exception5;
							this_mon.exit();
							throw exception5;
							throw exception4;
							JVM INSTR ret 6;
						}

					
					{
						this$1 = 5.this;
						f_buffer = directbytebuffer;
						super();
					}
					}, request.isLowPriority());
				}
				catch (Throwable e)
				{
					Debug.printStackTrace(e);
					buffer.returnToPool();
					listener.checkFailed(request, e);
				}
				return;
			}

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

			public int getPriority()
			{
				return DMCheckerImpl.checking_read_priority ? 0 : -1;
			}

			public void requestExecuted(long l)
			{
			}

			protected void complete()
			{
				this_mon.enter();
				async_reads--;
				if (stopped)
					async_read_sem.release();
				this_mon.exit();
				break MISSING_BLOCK_LABEL_69;
				Exception exception1;
				exception1;
				this_mon.exit();
				throw exception1;
			}

			
			{
				this$0 = DMCheckerImpl.this;
				listener = diskmanagercheckrequestlistener;
				request = diskmanagercheckrequest;
				required_hash = abyte0;
				super();
			}
		});
		break MISSING_BLOCK_LABEL_391;
		Throwable e;
		e;
		disk_manager.setFailed((new StringBuilder()).append("Piece check error - ").append(Debug.getNestedExceptionMessage(e)).toString());
		Debug.printStackTrace(e);
		listener.checkFailed(request, e);
	}

	static 
	{
		LOGID = LogIDs.DISK;
		fully_async = COConfigurationManager.getBooleanParameter("diskmanager.perf.checking.fully.async");
		if (fully_async)
			(new AEThread2("DMCheckerImpl:asyncCheckScheduler", true) {

				public void run()
				{
_L2:
					DMCheckerImpl.async_check_queue_sem.reserve();
					Object entry[];
					DMCheckerImpl.class_mon.enter();
					entry = (Object[])(Object[])DMCheckerImpl.async_check_queue.remove(0);
					int queue_size = DMCheckerImpl.async_check_queue.size();
					if (queue_size % 100 == 0 && queue_size > 0)
						System.out.println((new StringBuilder()).append("async check queue size=").append(DMCheckerImpl.async_check_queue.size()).toString());
					DMCheckerImpl.class_mon.exit();
					break MISSING_BLOCK_LABEL_98;
					Exception exception;
					exception;
					DMCheckerImpl.class_mon.exit();
					throw exception;
					((DMCheckerImpl)entry[0]).enqueueCheckRequest((DiskManagerCheckRequest)entry[1], (DiskManagerCheckRequestListener)entry[2], DMCheckerImpl.flush_pieces);
					if (true) goto _L2; else goto _L1
_L1:
				}

			}).start();
		ParameterListener param_listener = new ParameterListener() {

			public void parameterChanged(String str)
			{
				DMCheckerImpl.flush_pieces = COConfigurationManager.getBooleanParameter("diskmanager.perf.cache.flushpieces");
				DMCheckerImpl.checking_read_priority = COConfigurationManager.getBooleanParameter("diskmanager.perf.checking.read.priority");
			}

		};
		COConfigurationManager.addAndFireParameterListeners(new String[] {
			"diskmanager.perf.cache.flushpieces", "diskmanager.perf.checking.read.priority"
		}, param_listener);
	}









}