loggerimpl.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:   LoggerImpl.java

package org.gudy.azureus2.core3.logging.impl;

import java.io.OutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.List;
import org.gudy.azureus2.core3.config.ParameterListener;
import org.gudy.azureus2.core3.config.impl.ConfigurationManager;
import org.gudy.azureus2.core3.internat.MessageText;
import org.gudy.azureus2.core3.logging.*;
import org.gudy.azureus2.core3.util.*;

public class LoggerImpl
{
	private class RedirectorStream extends OutputStream
	{

		protected PrintStream ps;
		protected StringBuffer buffer;
		protected LogIDs logID;
		protected int logType;
		final LoggerImpl this$0;

		public void write(int data)
		{
			char c = (char)data;
			if (c == '\n')
			{
				if (!bLogToStdOut)
					ps.println(buffer);
				log(new LogEvent(logID, logType, buffer.toString()));
				buffer.setLength(0);
			} else
			if (c != '\r')
				buffer.append(c);
		}

		public void write(byte b[], int off, int len)
		{
			for (int i = off; i < off + len; i++)
			{
				int d = b[i];
				if (d < 0)
					d += 256;
				write(d);
			}

		}

		protected RedirectorStream(PrintStream _ps, LogIDs _logID, int _logType)
		{
			this$0 = LoggerImpl.this;
			super();
			buffer = new StringBuffer(1024);
			ps = _ps;
			logType = _logType;
			logID = _logID;
		}
	}


	private final int MAXHISTORY = 256;
	private boolean bLogToStdOut;
	private boolean bEventLoggingEnabled;
	private PrintStream psOldOut;
	private PrintStream psOldErr;
	private PrintStream psOut;
	private PrintStream psErr;
	private List logListeners;
	private AEDiagnosticsLogger alertLogger;
	private List alertListeners;
	private List alertHistory;
	private boolean logToStdErrAllowed;

	public LoggerImpl()
	{
		bLogToStdOut = System.getProperty("azureus.log.stdout") != null;
		bEventLoggingEnabled = false;
		psOldOut = null;
		psOldErr = null;
		logListeners = new ArrayList();
		alertListeners = new ArrayList();
		alertHistory = new ArrayList();
		logToStdErrAllowed = true;
		doRedirects();
	}

	public void init()
	{
		bEventLoggingEnabled = true;
		final ConfigurationManager config = ConfigurationManager.getInstance();
		boolean overrideLog = System.getProperty("azureus.overridelog") != null;
		if (overrideLog)
		{
			bEventLoggingEnabled = true;
		} else
		{
			bEventLoggingEnabled = config.getBooleanParameter("Logger.Enabled");
			config.addParameterListener("Logger.Enabled", new ParameterListener() {

				final ConfigurationManager val$config;
				final LoggerImpl this$0;

				public void parameterChanged(String parameterName)
				{
					bEventLoggingEnabled = config.getBooleanParameter("Logger.Enabled");
				}

			
			{
				this$0 = LoggerImpl.this;
				config = configurationmanager;
				super();
			}
			});
		}
	}

	public void doRedirects()
	{
		try
		{
			if (System.out != psOut)
			{
				if (psOldOut == null)
					psOldOut = System.out;
				psOut = new PrintStream(new RedirectorStream(psOldOut, LogIDs.STDOUT, 0));
				System.setOut(psOut);
			}
			if (System.err != psErr)
			{
				if (psOldErr == null)
					psOldErr = System.err;
				psErr = new PrintStream(new RedirectorStream(psOldErr, LogIDs.STDERR, 3));
				System.setErr(psErr);
			}
		}
		catch (Throwable e)
		{
			Debug.printStackTrace(e);
		}
	}

	public boolean isEnabled()
	{
		return bEventLoggingEnabled;
	}

	public void log(LogEvent event)
	{
		if (bLogToStdOut && psOldOut != null)
			psOldOut.println(event.text);
		if (event.entryType == 3)
		{
			if (AEDiagnostics.isStartupComplete())
				Debug.outDiagLoggerOnly((new StringBuilder()).append("[").append(event.logID).append("] ").append(event.text).toString());
			if (logToStdErrAllowed && psOldErr != null && event.logID != LogIDs.STDERR)
				psOldErr.println((new StringBuilder()).append("[").append(event.logID).append("] ").append(event.text).toString());
		}
		if (bEventLoggingEnabled)
		{
			for (int i = 0; i < logListeners.size(); i++)
				try
				{
					Object listener = logListeners.get(i);
					if (listener instanceof ILogEventListener)
						((ILogEventListener)listener).log(event);
					continue;
				}
				catch (Throwable e)
				{
					if (logToStdErrAllowed && psOldErr != null)
					{
						psOldErr.println((new StringBuilder()).append("Error while logging: ").append(e.getMessage()).toString());
						e.printStackTrace(psOldErr);
					}
				}

		}
		if (event.err != null && event.entryType == 3)
			Debug.printStackTrace(event.err);
	}

	public void logTextResource(LogEvent event)
	{
		event.text = MessageText.getString(event.text);
		log(event);
	}

	public void logTextResource(LogEvent event, String params[])
	{
		event.text = MessageText.getString(event.text, params);
		log(event);
	}

	public void addListener(ILogEventListener aListener)
	{
		logListeners.add(aListener);
	}

	public void removeListener(ILogEventListener aListener)
	{
		logListeners.remove(aListener);
	}

	public void log(LogAlert alert)
	{
		String logText = (new StringBuilder()).append("Alert:").append(alert.entryType).append(":").append(alert.text).toString();
		LogEvent alertEvent = new LogEvent(LogIDs.ALERT, alert.entryType, logText);
		alertEvent.err = alert.err;
		Logger.log(alertEvent);
		synchronized (this)
		{
			if (alertLogger == null)
				alertLogger = AEDiagnostics.getLogger("alerts");
		}
		alertLogger.log(logText);
		alertHistory.add(alert);
		if (alertHistory.size() > 256)
			alertHistory.remove(0);
		for (int i = 0; i < alertListeners.size(); i++)
			try
			{
				Object listener = alertListeners.get(i);
				if (listener instanceof ILogAlertListener)
					((ILogAlertListener)listener).alertRaised(alert);
				continue;
			}
			catch (Throwable f)
			{
				if (psOldErr != null)
				{
					psOldErr.println((new StringBuilder()).append("Error while alerting: ").append(f.getMessage()).toString());
					f.printStackTrace(psOldErr);
				}
			}

	}

	public void logTextResource(LogAlert alert)
	{
		alert.text = MessageText.getString(alert.text);
		log(alert);
	}

	public void logTextResource(LogAlert alert, String params[])
	{
		alert.text = MessageText.getString(alert.text, params);
		log(alert);
	}

	public void addListener(ILogAlertListener l)
	{
		alertListeners.add(l);
		for (int i = 0; i < alertHistory.size(); i++)
		{
			LogAlert alert = (LogAlert)alertHistory.get(i);
			l.alertRaised(alert);
		}

	}

	public void removeListener(ILogAlertListener l)
	{
		alertListeners.remove(l);
	}

	public PrintStream getOldStdErr()
	{
		return psOldErr;
	}

	public void allowLoggingToStdErr(boolean allowed)
	{
		logToStdErrAllowed = allowed;
	}


}