LogConfigAction

/**
 * Copyright (c) Glodon Co. Ltd.
 */
package gboat2.base.logging.action;

import gboat2.base.core.annotation.Domain;
import gboat2.base.core.annotation.Module;
import gboat2.base.core.annotation.Preference;
import gboat2.base.core.logging.BusinessLogEntry;
import gboat2.base.core.web.BaseActionSupport;
import gboat2.base.core.web.JsonResultSupport;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.LogManager;
import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.helpers.Loader;
import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.spi.LoggerRepository;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.ResultPath;
import org.apache.struts2.convention.annotation.Results;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author zhangxj-a
 *
 */
@Preference("/系统配置/日志配置")
@Results(value = { @Result(name = "success", location = "/content/index.vm"), @Result(name = "list", location = "/content/index-list.vm") })
@ParentPackage(value = "log")
@Domain(value = BusinessLogEntry.class)
@ResultPath("/content")
@Module(name = "日志配置管理", desc = "配置日志的记录级别")
public class LogConfigAction extends BaseActionSupport {

	/** */
	private static final long serialVersionUID = 1L;

	private static Logger logger = LoggerFactory.getLogger(LogConfigAction.class.getName());

	private static final String BR = "\r\n";

	/**
	 * 获得WEB_APP_ROOT
	 */
	public final static String WEB_APP_ROOT = System.getProperty("webapp.gboat2.root");

	/**
	 * 业务日志地址LOG_CONFIG_LOCATION
	 */
	public final static String BUSI_LOG_CONFIG_LOCATION = "WEB-INF/config/businessLog.properties";

	/**
	 * 系统日志地址LOG_CONFIG_LOCATION
	 */
	public final static String SYS_LOG_CONFIG_LOCATION = "WEB-INF/config/log4j.properties";

	/**
	 * 系统日志地址DIRECTORY
	 */
	public final static String SYS_LOG_DIRECTORY = "WEB-INF/config";

	/**
	 * 文件名称
	 */
	public final static String LOG4J_FILENAME = "log4j.properties";

	/**业务日志级别key */
	public final static String BUSINESS_LEVEL = "business.level";

	/**系统日志级别key */
	public final static String LOG4J_ROOTLOGGER = "log4j.rootLogger";

	private String businessLevel;

	private String systemLogRootLevel;

	private String properties;

	public String getProperties() {
		return properties;
	}

	public void setProperties(String properties) {
		this.properties = properties;
	}

	public String getBusinessLevel() {
		return businessLevel;
	}

	public void setBusinessLevel(String businessLevel) {
		this.businessLevel = businessLevel;
	}

	public String getSystemLogRootLevel() {
		return systemLogRootLevel;
	}

	public void setSystemLogRootLevel(String systemLogRootLevel) {
		this.systemLogRootLevel = systemLogRootLevel;
	}

	/* (non-Javadoc)
	 * @see gboat2.base.action.IBaseAction#edit()
	 */
	public String execute() {
		//准备默认数据
		setDefaultRootLevel();
		//把默认值设置到页面
		setDefaultValueToPage();

		return null;
	}

	/**
	 * 业务，系统日志配置页面
	 * @return null
	 * @throws IOException  对response中的writer操作抛出检查异常IOException
	 */
	public String properties() throws IOException {
		setProperties(readFromFile(getSystemLogRealPath()));

		//		JSONArray data = new JSONArray();
		//		JSONObject obj = new JSONObject();
		//		obj.accumulate("properties", getProperties());
		//		data.add(obj);

		//		JSONObject wrap = JsonResultSupport.wrap(true);
		//		wrap.accumulate("data", data);
		//		JsonResultSupport.output(wrap);

		return null;
	}

	/**
	 * 更新log4j.properties
	 * @return null
	 * @throws IOException 对response中的writer操作抛出检查异常IOException
	 */
	public String saveLog4jConfig() throws IOException {
		//写入配置文件
		writeToFile(getProperties());

		JsonResultSupport.output(JsonResultSupport.wrap(true));

		return null;
	}

	/**
	 * 为页面设置默认值
	 * @throws IOException 对response中的writer操作抛出检查异常IOException
	 */
	private void setDefaultValueToPage() {
		//		JSONArray data = new JSONArray();
		//		JSONObject obj = new JSONObject();
		//		obj.accumulate("businessLevel", getBusinessLevel());
		//		obj.accumulate("systemLogRootLevel", getSystemLogRootLevel());
		//		data.add(obj);
		//
		//		JSONObject wrap = JsonResultSupport.wrap(true);
		//		wrap.accumulate("data", data);
		//		JsonResultSupport.output(wrap, response);
	}

	private String getBusinessLogRealPath() {
		checkWebAppRootKeyExist();
		return WEB_APP_ROOT + BUSI_LOG_CONFIG_LOCATION;
	}

	private void checkWebAppRootKeyExist() {
		if (WEB_APP_ROOT == null) {
			LogLog.warn("can't get web app root,please add context param into web.xml like below:");
			LogLog.warn("<context-param><param-name>webAppRootKey</param-name><param-value>webapp.gboat2.root</param-value></context-param>");
		}
	}

	private String getSystemLogRealPath() {
		checkWebAppRootKeyExist();
		return WEB_APP_ROOT + SYS_LOG_CONFIG_LOCATION;
	}

	/**
	 * 使修改的系统日志级别生效
	 * @return null
	 * @throws IOException   io操作异常
	 * @throws IllegalAccessException 非法访问
	 * @throws InstantiationException 实例创建失败
	 * @throws InvocationTargetException 反射异常
	 * @throws NoSuchMethodException   发射
	 */
	public String apply() throws IOException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException {

		try {
			Properties busiProps = loadProperties(getBusinessLogRealPath());
			Properties sysProps = loadProperties(getSystemLogRealPath());

			//读取系统配置文件的内容
			setProperties(readFromFile(getSystemLogRealPath()));

			//业务日志采用properties.store方式处理
			busiProps.put(BUSINESS_LEVEL, getBusinessLevel());
			storeProperties(busiProps, getBusinessLogRealPath());
			//系统日志采用流的方式处理，防止格式会乱
			writeToFile(getProperties());

			//重新配置日志(bundle内部)
			reBundleConfigLog4jProperies(sysProps);

			//重新配置外部环境日志
			reRuntimeEnvConfigLog4jProperties();

		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			LogLog.warn("  log properties don't not exist ,please check ");
			JsonResultSupport.output(JsonResultSupport.wrap(false));
			return null;
		} catch (IOException e) {
			// TODO Auto-generated catch block
			JsonResultSupport.output(JsonResultSupport.wrap(false));
			LogLog.warn("  log properties don't not exist ,please check ");
			return null;
		} catch (ClassNotFoundException e) {
			LogLog.warn("  log properties don't not exist ,please check ");
			// TODO Auto-generated catch block
		} catch (Exception e) {
			LogLog.warn("  log properties don't not exist ,please check ");
			// TODO Auto-generated catch block
		}

		JsonResultSupport.output(JsonResultSupport.wrap(true));

		return null;
	}

	/**
	 * 重新加载外部环境的日志，使外部容器的日志生效
	 * @throws ClassNotFoundException 异常
	 * @throws NoSuchMethodException  异常
	 * @throws IllegalAccessException 异常
	 * @throws InvocationTargetException 异常
	 * @throws InstantiationException 异常
	 */
	@SuppressWarnings("unchecked")
	private void reRuntimeEnvConfigLog4jProperties() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException,
			InvocationTargetException, InstantiationException {
		Class<?> propertyConfigurator = Loader.loadClass(PropertyConfigurator.class.getName());
		Class<?> loggerRepository = Loader.loadClass(LoggerRepository.class.getName());
		Class<?> logManager = Loader.loadClass(LogManager.class.getName());
		Method getLoggerRepository = logManager.getMethod("getLoggerRepository");
		Class[] paramTypes = new Class[] { String.class, loggerRepository };
		Object[] params = new Object[] { getSystemLogRealPath(), getLoggerRepository.invoke(null) };
		Method doConfigure = propertyConfigurator.getMethod("doConfigure", paramTypes);
		doConfigure.invoke(propertyConfigurator.newInstance(), params);
	}

	/**
	 * 应用bundle之间的日志配置
	 * @param props 文件内容
	 */
	private void reBundleConfigLog4jProperies(Properties props) {
		//把当前线程的加载器换成系统加载器，不然会导致日志类加载不一致
		LogManager.resetConfiguration();
		LogManager.shutdown();
		ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
		Thread.currentThread().setContextClassLoader(ClassLoader.getSystemClassLoader());
		PropertyConfigurator.configure(props);
		Thread.currentThread().setContextClassLoader(contextClassLoader);
		logger.debug("gboat2 bundle log apply  successful.");

	}

	/**
	 * 为页面设置默认级别
	 * TODO
	 */
	private void setDefaultRootLevel() {
		//业务日志
		try {
			Properties busiProps = loadProperties(getBusinessLogRealPath());
			String level = (String) busiProps.get(BUSINESS_LEVEL);
			if (StringUtils.isEmpty(level)) {
				setBusinessLevel("DEBUG");
			} else {
				setBusinessLevel(level.toUpperCase());
			}
		} catch (FileNotFoundException e) {
			LogLog.warn("  no business log level could be found for Gboat2. ");
			LogLog.warn("  businessLog.properties not found ,Gboat2 use default level DEBUG . ");
			LogLog.warn("  adding businessLog.properties in directory of WEB-INF/config  can change business log behavior . ");
			LogLog.warn("  the Content as follows:business.level=DEBUG;business.level=INFO;business.level=WARN;business.level=ERROR . ");
		} catch (IOException e) {
			LogLog.warn("  gboat2 use default level DEBUG  ");
		}

		//系统日志
		try {
			Properties sysProps = loadProperties(getSystemLogRealPath());
			String level = (String) sysProps.get(LOG4J_ROOTLOGGER);
			if (StringUtils.isEmpty(level)) {
				setBusinessLevel("DEBUG");
			} else {
				String[] split = level.split(",");
				setSystemLogRootLevel(split[0].toUpperCase());
			}
		} catch (FileNotFoundException e) {
			LogLog.warn("  No appenders could be found for Gboat2. ");
			LogLog.warn("  Please initialize the log4j system properly. ");
			LogLog.warn("  Please add log4j.properties in the directory: WEB-INF/config. ");
		} catch (IOException e) {
			LogLog.warn("  log4j.properties  don't load. ");
		}

	}

	/**
	 * load屬性文件
	 * @param path 路径
	 * @return 读取文件内容
	 * @throws IOException io异常
	 */
	private Properties loadProperties(String path) throws IOException {
		Properties props = new Properties();
		FileInputStream logStream;
		logStream = new FileInputStream(path);
		props.load(logStream);

		logStream.close();
		return props;
	}

	/**
	 * load属性文件
	 * @param props 属性
	 * @param path  文件路径
	 * @return  文件内容
	 * @throws IOException store文件抛出异常
	 */
	private Properties storeProperties(Properties props, String path) throws IOException {
		FileOutputStream logOutStream;
		logOutStream = new FileOutputStream(path);
		props.store(logOutStream, "存储成功");
		logOutStream.close();
		return props;
	}

	/**
	 * 读取文件
	 * @param fileName 文件名称
	 * @return 文件内容
	 */
	private String readFromFile(String fileName) {
		try {
			File file = new File(fileName);
			BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
			StringBuilder stringBuilder = new StringBuilder();
			int content;
			while ((content = bufferedReader.read()) != -1) {
				stringBuilder.append((char) content);
			}

			bufferedReader.close();

			return stringBuilder.toString();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 写文件
	 * @param content 内容
	 * @throws IOException io异常
	 */
	private void writeToFile(String content) throws IOException {
		if (StringUtils.isEmpty(content))
			return;
		String path = WEB_APP_ROOT + SYS_LOG_DIRECTORY;
		File fileDir = new File(path);
		if (!fileDir.exists()) {
			boolean mkdirs = fileDir.mkdirs();
			if (!mkdirs) {
				throw new RuntimeException(" create directory  {" + path + "}  fail ");
			}
		} else if (!fileDir.isDirectory()) {
			throw new RuntimeException(path + " should be directory");
		}
		//创建日志文件
		File f = new File(fileDir, LOG4J_FILENAME);

		//用FileOutputSteam包装文件，并设置文件可追加
		OutputStream out = null;
		try {
			out = new FileOutputStream(f);
			//这个地方在不同的系统下可能有问题
			//由于单独的修改根级别，所有智能按照行来操作
			String[] split = content.split(BR);
			if (split.length == 1) {
				String[] temp = content.split("\n");
				if (temp.length >= 1) {
					split = temp;
				}
			}
			if (split == null) {
				out.close();
				return;
			}
			for (int i = 0; i < split.length; i++) {
				String lineContent = split[i];
				if (!StringUtils.isEmpty(lineContent)) {
					if (lineContent.indexOf("log4j.rootLogger") >= 0) {
						if (!StringUtils.isEmpty(getSystemLogRootLevel())) {
							String afterEqual = lineContent.substring(lineContent.indexOf("=") + 1);
							String[] appenders = afterEqual.split(",");
							StringBuffer appenderStrings = new StringBuffer();
							if (appenders.length >= 2) {
								for (int j = 1; j < appenders.length; j++) {
									appenderStrings = appenderStrings.append(appenders[j]);
									if (j < appenders.length - 1) {
										appenderStrings = appenderStrings.append(",");
									}
								}
							}
							if ("".equals(appenderStrings.toString())) {
								lineContent = "log4j.rootLogger = " + getSystemLogRootLevel();
							} else
								lineContent = "log4j.rootLogger = " + getSystemLogRootLevel() + "," + appenderStrings;
						}
					}
				}
				out.write(lineContent.getBytes());
				out.write('\r'); // \r\n表示换行
				out.write('\n');
			}

			out.close(); //关闭输出流
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}