/*
    * $Id$
    *
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *  http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  package gboat2.admin.osgi.action;
  
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.PrintStream;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.jar.Attributes;
  import java.util.jar.JarFile;
  import java.util.jar.Manifest;
  
  import javax.servlet.ServletContext;
  import javax.servlet.http.HttpServletRequest;
  
  import org.apache.felix.shell.ShellService;
  import org.apache.struts2.StrutsStatics;
  import org.apache.struts2.convention.annotation.ResultPath;
  import org.apache.struts2.osgi.BundleAccessor;
  import org.apache.struts2.osgi.DefaultBundleAccessor;
  import org.apache.struts2.osgi.OsgiHost;
  import org.apache.struts2.osgi.StrutsOsgiListener;
  import org.apache.struts2.util.ServletContextAware;
  import org.osgi.framework.Bundle;
  import org.osgi.framework.BundleContext;
  import org.osgi.framework.BundleException;
  import org.osgi.framework.ServiceReference;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.opensymphony.xwork2.ActionContext;
  import com.opensymphony.xwork2.ActionSupport;
  import com.opensymphony.xwork2.config.Configuration;
  import com.opensymphony.xwork2.config.entities.PackageConfig;
  import com.opensymphony.xwork2.inject.Inject;
  
  /**
   * 管理 Bundle 的 Action
   * @date 2014-2-26
   * @since 1.0
   */
  @ResultPath("/content")
  //@gboat2.base.core.annotation.Module(name = "bundle管理", desc = "显示bundle列表及bundle的详细信息")
  public class BundlesAction extends ActionSupport implements ServletContextAware {
  
      private static final long serialVersionUID = -1L;
  
      private final Logger logger = LoggerFactory.getLogger(BundlesAction.class.getName());
  
  	/** bundle 的 Bundle-SymbolicName 属性：{@value} */
  	private static final String BUNDLE_SYMBOLIC_NAME = "Bundle-SymbolicName";
  	
  	/** 获得 webapp 的根目录 */
  	public final static String WEB_APP_ROOT = System.getProperty("webapp.gboat2.root");
  
      /** class 文件存放目录 */
      public final static String CLASS_LOCATION = "WEB-INF/classes/";
  
  	/** bundle存放目录 */
  	public final static String BUNDLE_LOCATION = "WEB-INF/classes/bundles/";
  
  	/** bundle备份目录 */
  	public final static String BACKUP_BUNDLES_LOCATION = "backup/";
  
  	private static final String INSTALL = "install";
 
     /**业务 Bundle 的级别 */
     public final static String BUSINESS_LEVEL = "5" ;
 
 	//业务bundle路径
 	public final static String FIVE_PATH = "bundles/5";
 	public final static String FOUR_PATH = "bundles/4";
 	public final static String THREE_PATH = "bundles/3";
 	public final static String TWO_PATH = "bundles/2";
 
 	private transient BundleAccessor bundleAccessor;
 
     private transient OsgiHost osgiHost;
 
     private transient HttpServletRequest request = this.getRequest1();
 
     private String id;
 
 	private Configuration configuration;
 
 	private String bundleFlag;
 
 	private String output;
 
 	private String bundlePath;
 
 	private String message;
 
     /** 级别目录 */
     private String level = "";
 
 	private String currentLevel;
 
 	/** 判断 安装 操作是否成功  */
 	private boolean failure = false;
 
 	/** ftl 不支持 boolean 型，用这个变量替换一下 */
 	private String failureString = "false";
 
     @Inject
     public void setConfiguration(Configuration configuration) {
         this.configuration = configuration;
     }
 
     @Inject
     public void setBundleAccessor(BundleAccessor bundleAccessor) {
         this.bundleAccessor = bundleAccessor;
     }
 
     @Override
     public void setServletContext(ServletContext servletContext) {
         osgiHost = (OsgiHost) servletContext.getAttribute(StrutsOsgiListener.OSGI_HOST);
     }
 
     private HttpServletRequest getRequest1() {
         return (HttpServletRequest) ActionContext.getContext().get(StrutsStatics.HTTP_REQUEST);
     }
 
 	public String getFailureString() {
 		return failureString;
 	}
 
 	public void setFailureString(String failureString) {
 		this.failureString = failureString;
 	}
 
 	public boolean isFailure() {
 		return failure;
 	}
 
 	public void setFailure(boolean failure) {
 		this.failure = failure;
 	}
 
 	public String getCurrentLevel() {
 		return currentLevel;
 	}
 
 	public void setCurrentLevel(String currentLevel) {
 		this.currentLevel = currentLevel;
 	}
 
 	public String getLevel() {
 		return level;
 	}
 
 	public void setLevel(String level) {
 		this.level = level;
 	}
 
 	public String getMessage() {
 		return message;
 	}
 
 	public void setMessage(String message) {
 		this.message = message;
 	}
 
 	public HttpServletRequest getRequest() {
 		return request;
 	}
 
 	public void setRequest(HttpServletRequest request) {
 		this.request = request;
 	}
 
 	public String getBundlePath() {
 		return bundlePath;
 	}
 
 	public void setBundlePath(String bundlePath) {
 		this.bundlePath = bundlePath;
 	}
 
 	public String getOutput() {
 		return output;
 	}
 
 	public String getBundleFlag() {
 		return bundleFlag;
 	}
 
 	public void setBundleFlag(String bundleFlag) {
 		this.bundleFlag = bundleFlag;
 	}
 
     public String getId() {
         return id;
     }
 
     public void setId(String id) {
         this.id = id;
     }
 
     
 	public String index() {
 		return SUCCESS;
 	}
 
 	public String view() {
 		return SUCCESS;
 	}
 
 	public String install() {
 		return INSTALL;
 	}
 
 	/**
 	 * 启动 Bundle
 	 * @return
 	 * @throws BundleException 启动失败时抛出此异常
 	 */
 	public String start() throws BundleException {
 		Bundle bundle = osgiHost.getBundles().get(id);
 		try {
 			bundle.start();
 			//start() fires a BundleEvent.STARTED, which loads the config
 			//we need to wait until the config is loaded from that bundle but
 			//there no easy way/elegant way to know if the bundle was processed already
 			Thread.sleep(1000);
 		} catch (Exception e) {
 			addActionError(e.toString());
 			logger.error(e.getMessage(),e.getCause());
 		}
 
 		return view();
 	}
 
 	/**
 	 * 停止 Bundle
 	 * @return
 	 * @throws BundleException 停止 Bundle 发生异常时，抛出此异常
 	 */
 	public String stop() throws BundleException {
 		Bundle bundle = osgiHost.getBundles().get(id);
 		try {
 			bundle.stop();
 		} catch (Exception e) {
 			addActionError(e.toString());
 			logger.error(e.getMessage(),e.getCause());
 		}
 
 		return view();
 	}
 	
 	/**
 	 * 通过命令来实现更新操作，直接点击 bundle 进行刷新操作
 	 * @return
 	 * @throws BundleException
 	 */
 	public String refresh() throws BundleException {
 		Bundle bundle = osgiHost.getBundles().get(id);
 		
 		// 设置当前bundle的级别
 		setCurrentLevel(getBoundLevel(bundle.getLocation()));
 		
 		if(BUSINESS_LEVEL.equals(getCurrentLevel())){
 			update(); // 更新
 		}else{
 			executeCommond(" refresh " + bundle.getBundleId());
 		}
 		
 		return view();
 	}
 
 	/**
 	 * 通过命令来实现更新操作
 	 * @return
 	 * @throws BundleException
 	 */
 	public String refreshWithPara(Bundle bundle) throws BundleException {
 		executeCommond(" refresh " + bundle.getBundleId());
 		return view();
 	}
 
 	/**
 	 * 更新 Bundle 的状态
 	 * @return
 	 * @throws BundleException
 	 */
 	public String update() throws BundleException {
 		Bundle bundle = osgiHost.getBundles().get(id);
 		try {
 			bundle.update();
 		} catch (Exception e) {
 			addActionError(e.toString());
 			logger.error(e.getMessage(),e.getCause());
 		}
 
 		return view();
 	}
 
 	/**
 	 * 检查是否存在指定名称的 Bundle，存在则返回对应的 Bundle，反之则返回 null。<br>
 	 * 相应的 bundle 在对应级别的目录存在，但通过 shell 命令把他卸载了，这种情况返回 false
 	 * @param symbolicName Bundle 的名称（唯一标识）
 	 * @throws BundleException
 	 */
 	private Bundle isExistThisBundle(String symbolicName) throws BundleException {
 		//如果symbolicName为空不做任何操作
 		List<Bundle> bundles = new ArrayList<Bundle>(osgiHost.getBundles().values());
 		Bundle bundle = null;
 		for (Iterator<Bundle> iterator = bundles.iterator(); iterator.hasNext();) {
 			bundle = iterator.next();
 			if (bundle.getSymbolicName().equals(symbolicName)) {
 				return bundle;
 			}
 		}
 		return null;
 	}
 
 	/**
 	 * 检查 Bundle 是否为 Struts Bundle
 	 * @param bundle
 	 * @return
 	 */
 	public boolean isStrutsEnabled(Bundle bundle) {
 		return "true".equalsIgnoreCase((String) bundle.getHeaders().get(OsgiHost.OSGI_HEADER_STRUTS_ENABLED));
 	}
 
 	/**
 	 * 通过 Bundle 的 ID 获取对应的 Bundle 实例
 	 * @return
 	 */
 	public Bundle getBundle() {
 		return osgiHost.getBundles().get(id);
 	}
 
 	/**
 	 * 获取指定 Bundle 下 Struts.xml 配置文件中的的所有 package
 	 * @return
 	 */
 	public List<PackageConfig> getPackages() {
 		List<PackageConfig> pkgs = new ArrayList<PackageConfig>();
 		Bundle bundle = getBundle();
 		if (bundle.getState() == Bundle.ACTIVE) {
 		    Set<String> packages = bundleAccessor.getPackagesByBundle(bundle);
 			if (packages == null)
 				return pkgs;
 			
 			PackageConfig packageConfig = null;
 			for (String name : packages) {
 				packageConfig = configuration.getPackageConfig(name);
 				if (packageConfig != null)
 					pkgs.add(packageConfig);
 			}
 		}
 		return pkgs;
 	}
 	
 	public String getNoData(){
 		Object serv = getModuleService();
 		//正在执行刷新操作
 		if(serv == null){
 			return "正在执行更新操作,请稍后。。。。30秒左右后，请点击页面的【refresh】按钮,查看更新后bundle的最新信息";
 		}
 		
 		return null;
 	}
 	
 	/**
 	 * 获取指定 Bundle 下的所有 module
 	 * @return
 	 * @throws NoSuchMethodException 
 	 * @throws SecurityException 
 	 */
 	public Object getModules() {
 		String bundleName = getBundleName();
 		Object serv = getModuleService();
 		// 正在执行刷新操作
 		if(serv == null){
 		   return  new ArrayList<Object>();
 		}
 		
 		Method method = null;
 		Object result = null;; 
 		try {
 			method = serv.getClass().getMethod("getModuleListByBundleName", String.class);
 			method.setAccessible(true);
 			result = method.invoke(serv, bundleName);
 		} catch (Exception e) {
 		    result = new ArrayList<Object>();
 			logger.trace("获取 Bundle[{}] 下的所有 Module 失败！\r\n{}", bundleName, e.getStackTrace());
 		}
 		return result;
 	}
 
 	/**
 	 * 获取指定 Bundle 下的所有 operation
 	 * @return
 	 */
 	public Object getOperations() {
 		String bundleName = getBundleName();
 		Object serv = getModuleService();
 		if(serv == null)
            return  new ArrayList<Object>();
 	    
 		Method method = null;
 		Object result = null;
 		try {
 			method = serv.getClass().getMethod("getOperaByBundleAddAction", String.class, String.class);
 			method.setAccessible(true);
 			result = method.invoke(serv, bundleName, this.getClass().getName());
 		} catch (Exception e) {
 		    result = new ArrayList<Object>(); 
 		    logger.trace("获取 Bundle[{}] 下的所有 Operation 失败！\r\n{}", bundleName, e.getStackTrace());
 		}
 		
 		return result;
 	}
 
 	/**
 	 * @return Bundle 的头信息的所有 key
 	 */
 	public ArrayList<String> getHeaderKeys() {
 		return Collections.list(getBundle().getHeaders().keys());
 	}
 
 	/**
 	 * 根据条件查询 bundle：全部，系统，业务
 	 * @return
 	 */
 	public Collection<Bundle> getBundles() {
 		if ("ALL".equals(getBundleFlag()) || "".equals(getBundleFlag())) {
 			return getAllBundles();
 		}
 		if ("SYSTEM".equals(getBundleFlag())) {
 			return getSystemBundles();
 		}
 		if ("BUSINESS".equals(getBundleFlag())) {
 			return getBusinessBundles();
 		}
 
 		return Collections.emptyList();
 	}
 
 	/**
 	 * 获取所有 Bundle
 	 * @return 所有 Bundle
 	 */
 	private Collection<Bundle> getAllBundles() {
 		List<Bundle> bundles = new ArrayList<Bundle>(osgiHost.getBundles().values());
 		bundleSort(bundles);
 		return bundles;
 	}
 
 	/**
 	 * 获取系统 bundle
 	 * @return 系统 bundle
 	 */
 	private Collection<Bundle> getSystemBundles() {
 		List<Bundle> systemBundles = new ArrayList<Bundle>();
 
 		Collection<Bundle> bundles = getAllBundles();
 		for (Iterator<Bundle> iterator = bundles.iterator(); iterator.hasNext();) {
 			Bundle bundle = (Bundle) iterator.next();
 			String location = bundle.getLocation();
 			location = replaceSeparator(location);
 			if (!(location.indexOf(FIVE_PATH) > 0)) {
 				systemBundles.add(bundle);
 			}
 		}
 
 		bundleSort(systemBundles);
 		return systemBundles;
 	}
 
 	/**
 	 * 获取业务bundle
 	 * @return 业务bundle
 	 */
 	private Collection<Bundle> getBusinessBundles() {
 		List<Bundle> businessBundles = new ArrayList<Bundle>();
 
 		Collection<Bundle> bundles = getAllBundles();
 		for (Iterator<Bundle> iterator = bundles.iterator(); iterator.hasNext();) {
 			Bundle bundle = (Bundle) iterator.next();
 			String location = bundle.getLocation();
 			location = replaceSeparator(location);
 			if (location.indexOf(FIVE_PATH) > 0) {
 				businessBundles.add(bundle);
 			}
 		}
 
 		bundleSort(businessBundles);
 		return businessBundles;
 	}
 
 	/**
 	 * bundle排序，排序规则为先将 Struts Bundle 排前面，然后根据 Bundle 的名称升序
 	 * @param 排序后的 Bundle 集合
 	 */
 	private void bundleSort(List<Bundle> businessBundles) {
 		Collections.sort(businessBundles, new Comparator<Bundle>() {
 			public int compare(Bundle bundle1, Bundle bundle2) {
 				boolean bundle1StrutsEnabled = isStrutsEnabled(bundle1);
 				boolean bundle2StrutsEnabled = isStrutsEnabled(bundle2);
 				if ((bundle1StrutsEnabled && bundle2StrutsEnabled) || (!bundle1StrutsEnabled && !bundle2StrutsEnabled))
 					return bundle1.getSymbolicName().compareTo(bundle2.getSymbolicName());
 				else {
 					return bundle1StrutsEnabled ? -1 : 1;
 				}
 			}
 		});
 	}
 
 	/**
 	 * 添加或者更新bundle前，上传 Bundle 的 jar 包
 	 * @return
 	 */
 	public String upload() {
 		ActionContext context = ActionContext.getContext();
 		Map<String, ?> params = context.getParameters();
 		File[] file = (File[]) params.get("uploadFile");
 		String[] fileNames = (String[]) params.get("uploadFileFileName");
 
 		if (file == null)
 			return checkFileIsNull();
 
 		if (file.length > 0) {
 			String fileName = fileNames[0];
 			if (!fileName.endsWith(".jar")) {
 				this.message = "请上传.jar的文件";
 				this.failure = true;
 				this.failureString = "true";
 				return INSTALL;
 			}
 
 			String pathname = getRealBusinessBundlePath() + File.separator + fileName;
 			File outFile = new File(pathname);
 			setBundlePath(pathname);
 
 			//判断上传的bundle是否已经存在,若存在返回List:备份文件路径和存在的文件
 			List<Object> jarExistPath = jarExistPath(fileName);
 
 			//此为第一种情况，不存在当前上传的bundle
 			if (jarExistPath == null) {
 				//增加
 				failure = addOrUpdateJar(file, failure, outFile);
 				//启动
 				startBundle();
 				this.message = failure ? "安装bundle失败，请查看日志，确定具体原因" : "安装bundle成功";
 				setCurrentLevel(level);
 				return INSTALL;
 
 			} else {
 				//存在当前bundle
 
 				//备份文件名称
 				String backupName = (String) jarExistPath.get(0);
 				//需要备份的文件
 				File oldFile = (File) jarExistPath.get(1);
 				//备份文件路径
 				String backupPath = (String) jarExistPath.get(2);
 
 				//需要备份文件的路径
 				String oldFilePath = (String) jarExistPath.get(3);
 
 				//备份文件路径文件
 				File backupFilePath = new File(backupPath);
 
 				//路径不存在，创建路径
 				if (!backupFilePath.exists()) {
 					boolean mkdirs = backupFilePath.mkdirs();
 					if (!mkdirs) {
 						throw new RuntimeException(" create directory  {" + backupFilePath + "}  fail ");
 					}
 				}
 
 				//创建备份文件
 				File backupOutFile = new File(backupPath, backupName);
 
 				//备份
 				failure = addOrUpdateJar(new File[] { oldFile }, failure, backupOutFile);
 				if (failure) {
 					message = "备份bundle失败";
 					return INSTALL;
 				}
 				//更新
 				failure = addOrUpdateJar(file, failure, oldFile);
 				if (failure) {
 					message = "更新bundle失败";
 					return INSTALL;
 				}
 				
 				try {
 					
 					//更新时，级别与原来bundle所在的级别一致
 					setCurrentLevel(getBoundLevel(oldFilePath));
 					
 					String bundleSymbolicName = getBundleSymbolicName(oldFilePath);
 					
 					Bundle existThisBundle = isExistThisBundle(bundleSymbolicName);
 					
 					if (existThisBundle!=null) {
 						//业务bundle，只负责update，此为第二种情况
 						if(getCurrentLevel().equals(BUSINESS_LEVEL)){
 //							existThisBundle.update();
 							refreshWithPara(existThisBundle);
 							this.message = "更新bundle成功";
 						}
 						//业务bundle，只负责update和刷新，此为第三种情况
 						if(!getCurrentLevel().equals(BUSINESS_LEVEL)){
 							//先执行更新，然后执行刷新
 //							existThisBundle.update();
 //							Thread.sleep(5 * 1000);
 							refreshWithPara(existThisBundle);
 							this.message = "更新bundle,并刷新bundle，此种情况比较费时间，为了安全性，请等一分钟后再做其他操作";
 						}
 						
 					}
 					//此为第四种情况，只安装	
 					else {
 						//执行安装命令
 						installBundle(oldFilePath,bundleSymbolicName);
 						this.message = "安装bundle成功";
 					}
 
 				} catch (BundleException e) {
 					failure = true;
 					this.failureString = "true";
 					message = "更新bundle出现了错误";
 					logger.error(e.getMessage(), e);
 				}
 
 				return INSTALL;
 			}
 		}
 
 		return INSTALL;
 	}
 
 	/**
 	 * 更新时取当前bundle的级别
 	 * @param bundlepath
 	 * @return
 	 */
 	private String getBoundLevel(String bundlepath) {
 		bundlepath = replaceSeparator(bundlepath);
 		if (bundlepath.indexOf(FIVE_PATH) > 0) {
 			return FIVE_PATH.substring(FIVE_PATH.lastIndexOf("/") + 1);
 		}
 		if (bundlepath.indexOf(FOUR_PATH) > 0) {
 			return FOUR_PATH.substring(FOUR_PATH.lastIndexOf("/") + 1);
 		}
 		if (bundlepath.indexOf(THREE_PATH) > 0) {
 			return THREE_PATH.substring(THREE_PATH.lastIndexOf("/") + 1);
 		}
 		if (bundlepath.indexOf(TWO_PATH) > 0) {
 			return TWO_PATH.substring(TWO_PATH.lastIndexOf("/") + 1);
 		}
 
 		return null;
 	}
 
 	private boolean addOrUpdateJar(File[] file, boolean flag, File outFile) {
 		try {
 			InputStream inStream = new FileInputStream(file[0]);
 			OutputStream outStream = new FileOutputStream(outFile);
 			byte[] b = new byte[1024];
 			int len = 0;
 			while ((len = inStream.read(b)) != -1) {
 				outStream.write(b, 0, len);
 			}
 			outStream.close();
 			inStream.close();
 		} catch (FileNotFoundException e1) {
 			flag = true;
 			this.failureString = "true";
 			logger.error(e1.getMessage(), e1.getCause());
 		} catch (IOException e) {
 			flag = true;
 			this.failureString = "true";
 			logger.error(e.getMessage(), e.getCause());
 		}
 		return flag;
 	}
 
 	/**
 	 * 启动 Bundle
 	 * @return
 	 */
 	private String startBundle() {
 		executeCommond("start   file:/" + this.getBundlePath());
 		return INSTALL;
 	}
 
 	/**
 	 * 安装;对于被卸载的bundle只负责安装，不做其他任何操作
 	 * @return
 	 */
 	private String installBundle(String oldFilePath,String bundleSymbolicName)  throws BundleException{
 		executeInstall(oldFilePath);
 		return INSTALL;
 	}
 
 	private void executeInstall(String oldFilePath) {
 		executeCommond(" install   file:/" + oldFilePath);
 	}
 
 	/**
 	 * 执行 Felix 命令
 	 * @param command 要执行的命令
 	 */
 	private void executeCommond(String command) {
 		System.setProperty("java.protocol.handler.pkgs", "org.ops4j.pax.url.assembly");
 
 		// get service
 		ByteArrayOutputStream outByteStream = new ByteArrayOutputStream();
 		ByteArrayOutputStream errByteStream = new ByteArrayOutputStream();
 		PrintStream outStream = new PrintStream(outByteStream);
 		PrintStream errStream = new PrintStream(errByteStream);
 
 		String outString = null;
 		String errString = null;
 		try {
 			//这个方法抛出的异常都被catch掉了
 			executeCommand(command, outStream, errStream);
 			outString = outByteStream.toString().trim();
 			errString = errByteStream.toString().trim();
 		} catch (Exception e) {
 			errString = e.getMessage();
 			logger.error(e.getMessage(), e.getCause());
 			message = errString;
 		} finally {
 			outStream.close();
 			errStream.close();
 		}
 
 		output = errString != null && errString.length() > 0 ? errString : outString;
 	}
 
 	/**
      * 执行 Felix 的 shell 命令
      * @param commandLine 命令行的内容，包括命令及其参数
      * @param out 标准信息输出流
      * @param err 错误信息输出流
      * @throws Exception 执行 shell 命令发生错误时，抛出异常
      */
 	private void executeCommand(String commandLine, PrintStream out, PrintStream err) throws Exception {
 		ShellService shellService = getShellService();
 		if (shellService != null)
 			shellService.executeCommand(commandLine, out, err);
 		else
 			err.println("Apache Felix Shell service is not installed");
 	}
 
 	public String displayProperty(Object obj) {
 		if (obj.getClass().isArray()) {
 			return Arrays.asList((Object[]) obj).toString();
 		} else {
 			return obj.toString();
 		}
 	}
 
 	/**
 	 * 获取 Bundle 的状态字符串
 	 * @param bundle
 	 * @return
 	 */
 	public String getBundleState(Bundle bundle) {
 		switch (bundle.getState()) {
 			case Bundle.ACTIVE:
 				return "Active";
 			case Bundle.INSTALLED:
 				return "Installed";
 			case Bundle.RESOLVED:
 				return "Resolved";
 			case Bundle.STARTING:
 				return "Starting";
 			case Bundle.STOPPING:
 				return "Stopping";
 			case Bundle.UNINSTALLED:
 				return "Uninstalled";
 			default:
 				throw new IllegalStateException("Invalid state");
 		}
 	}
 
 	/**
 	 * 判断 Bundle 是否可以执行指定的操作
 	 * @param bundle 要进行操作的 Bundle
 	 * @param val 要进行操作的命令，如：start、stop、update 等
 	 * @return 可以执行指定的操作，则返回 true，反之则返回 false
 	 */
 	public boolean isAllowedAction(Bundle bundle, String val) {
 		int state = -1;
 		try {
 			state = bundle.getState();
 		} catch (Exception e) {
 			addActionError("Unable to determine bundle state: " + e.getMessage());
 			return false;
 		}
 
 		if ("start".equals(val)) {
 			return state == Bundle.RESOLVED;
 		} else if ("stop".equals(val)) {
 			return state == Bundle.ACTIVE;
 		} else if ("update".equals(val)) {
 			return state == Bundle.ACTIVE || state == Bundle.INSTALLED || state == Bundle.RESOLVED;
 		}
 		throw new IllegalArgumentException("Invalid state");
 	}
 
 	/**
 	 * 获取 module 服务
 	 * @return {@code gboat2.base.core.service.IModuleService} 接口的实例
 	 */
 	private Object getModuleService() {
 		BundleContext bundleContext = osgiHost.getBundleContext();
 		ServiceReference<?> servReference = bundleContext.getServiceReference("gboat2.base.core.service.IModuleService");
 		return servReference == null ? null :  bundleContext.getService(servReference);
 	}
 
 	/**
 	 * 校验 上传的文件不能为空
 	 * @param file
 	 * @return
 	 */
 	private String checkFileIsNull() {
 		this.message = "上传的bundle不能为空,请选择要上传的bundle";
 		this.failure = true;
 		this.failureString = "true";
 		return INSTALL;
 	}
 
 	/**
 	 * 获取 bundle 的名称
 	 * @return
 	 */
 	private String getBundleName() {
 		return osgiHost.getBundles().get(id).getSymbolicName();
 	}
 
 	/**
 	 * 获取 Bundle 的物理路径
 	 * @return
 	 */
 	private String getRealBusinessBundlePath() {
 		String path = WEB_APP_ROOT + BUNDLE_LOCATION + level;
 		File pathDir = new File(path);
 		if (!pathDir.exists()) {
 			boolean mkdirs = pathDir.mkdirs();
 			if (!mkdirs) {
 				throw new RuntimeException(" create directory  {" + path + "}  fail ");
 			}
 		} else if (!pathDir.isDirectory()) {
 			throw new RuntimeException(path + " should be directory");
 		}
 		return path;
 	}
 	
 	/**
 	 * 业务bundle4备份地址
 	 * @return
 	 */
 	private String getRealFiveBundlePath_() {
 		return WEB_APP_ROOT + BACKUP_BUNDLES_LOCATION + FIVE_PATH;
 	}
 
 	/**
 	 * 业务bundle4备份地址
 	 * @return
 	 */
 	private String getRealFourBundlePath_() {
 		return WEB_APP_ROOT + BACKUP_BUNDLES_LOCATION + FOUR_PATH;
 	}
 
 	/**
 	 * 系统bundle3备份地址
 	 * @return
 	 */
 	private String getRealThreeBundlePath() {
 		return WEB_APP_ROOT + BACKUP_BUNDLES_LOCATION + THREE_PATH;
 	}
 
 	/**
 	 * 系统bundle2备份地址
 	 * @return
 	 */
 	private String getRealTwoBundlePath() {
 		return WEB_APP_ROOT + BACKUP_BUNDLES_LOCATION + TWO_PATH;
 	}
 
 	/**
 	 * 业务bundle地址
 	 * @return
 	 */
 	private String getRealFourBundlePathT() {
 		return WEB_APP_ROOT + CLASS_LOCATION + FOUR_PATH;
 	}
 	
 	/**
 	 * 业务bundle地址
 	 * @return
 	 */
 	private String getRealFiveBundlePathT() {
 		return WEB_APP_ROOT + CLASS_LOCATION + FIVE_PATH;
 	}
 
 	/**
 	 * 系统bundle3地址
 	 * @return
 	 */
 	private String getRealThreeBundlePathT() {
 		return WEB_APP_ROOT + CLASS_LOCATION + THREE_PATH;
 	}
 
 	/**
 	 * 系统bundle2地址
 	 * @return
 	 */
 	private String getRealTwoBundlePathT() {
 		return WEB_APP_ROOT + CLASS_LOCATION + TWO_PATH;
 	}
 
 	/**
 	 * 获得felix服务
 	 * @return
 	 */
 	private ShellService getShellService() {
 		//bundle can be de-activated, so keeping a reference aorund is not a good idea
 		DefaultBundleAccessor bundleAcessor = DefaultBundleAccessor.getInstance();
 		ServiceReference<?> ref = bundleAcessor.getServiceReference(ShellService.class.getName());
 		return (ShellService) bundleAcessor.getService(ref);
 	}
 
 	/**
 	 * 判断当前上传的jar是否在系统bundle2,3和业务bundle目录下已经存在，若存在返回当前存在的bundle目录
 	 * @param uploadFileName
 	 * @return
 	 */
 	private List<Object> jarExistPath(String uploadFileName) {
 		List<Object> list = new ArrayList<Object>();
 		
 		File jar5 = new File(getRealFiveBundlePathT());
 		File[] jar5Array = jar5.listFiles();
 		
 		File jar4 = new File(getRealFourBundlePathT());
 		File[] jar4Array = jar4.listFiles();
 		File jar3 = new File(getRealThreeBundlePathT());
 		File[] jar3Array = jar3.listFiles();
 		File jar2 = new File(getRealTwoBundlePathT());
 		File[] jar2Array = jar2.listFiles();
 
 		if (jar5Array != null) {
 			for (int i = 0; i < jar5Array.length; i++) {
 				File jarFile = jar5Array[i];
 				if (uploadFileName.equals(jarFile.getName())) {
 					list.add(getBackupJarFileName(jarFile.getName()));
 					list.add(jarFile);
 					list.add(getRealFiveBundlePath_());
 					list.add(replaceSeparator(jarFile.getPath()));
 					return list;
 				}
 			}
 		}
 		
 		if (jar4Array != null) {
 			for (int i = 0; i < jar4Array.length; i++) {
 				File jarFile = jar4Array[i];
 				if (uploadFileName.equals(jarFile.getName())) {
 					list.add(getBackupJarFileName(jarFile.getName()));
 					list.add(jarFile);
 					list.add(getRealFourBundlePath_());
 					list.add(replaceSeparator(jarFile.getPath()));
 					return list;
 				}
 			}
 		}
 		if (jar3Array != null) {
 			for (int i = 0; i < jar3Array.length; i++) {
 				File jarFile = jar3Array[i];
 				if (uploadFileName.equals(jarFile.getName())) {
 					list.add(getBackupJarFileName(jarFile.getName()));
 					list.add(jarFile);
 					list.add(getRealThreeBundlePath());
 					list.add(replaceSeparator(jarFile.getPath()));
 					return list;
 				}
 			}
 		}
 
 		if (jar2Array != null) {
 			for (int i = 0; i < jar2Array.length; i++) {
 				File jarFile = jar2Array[i];
 				if (uploadFileName.equals(jarFile.getName())) {
 					list.add(getBackupJarFileName(jarFile.getName()));
 					list.add(jarFile);
 					list.add(getRealTwoBundlePath());
 					list.add(replaceSeparator(jarFile.getPath()));
 					return list;
 				}
 			}
 		}
 
 		//上传的bundle为新bundle
 		return null;
 	}
 
 	/**
 	 * 为备份jar包增加时间戳
 	 * @param jarName
 	 * @return
 	 */
 	private String getBackupJarFileName(String jarName) {
 		String name = jarName.substring(0, jarName.lastIndexOf("."));
 		return name + "_" + System.currentTimeMillis() + jarName.substring(jarName.lastIndexOf("."), jarName.length());
 
 	}
 
 	private String replaceSeparator(String path) {
 		return path.replace(File.separator, "/");
 	}
 
 	/**
 	 * 根据 Bundle 的 jar 文件路径获取 Bundle 的名称
 	 * @param filePath jar 文件路径
 	 * @return 对应的 Bundle 的名称
 	 */
 	private String getBundleSymbolicName(String filePath) {
 		if (filePath == null || filePath.equals("") || !filePath.endsWith(".jar")) {
 			return null;
 		}
 		try {
 			JarFile jf = new JarFile(filePath);
 			Manifest mf = jf.getManifest();
 			Attributes attributes = mf.getMainAttributes();
 			String bundleSymbolicName = attributes.getValue(BUNDLE_SYMBOLIC_NAME);
 			if (bundleSymbolicName != null && !bundleSymbolicName.equals("")) {
 				bundleSymbolicName = bundleSymbolicName.split(";")[0];
 				if (bundleSymbolicName != null && !bundleSymbolicName.equals("")) {
 					return bundleSymbolicName;
 				}
 			}
 			return null;
 		} catch (IOException e) {
 			return null;
 		}
 	}
 }