package com.nms.server.thread.dataCollect;

import java.io.File;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import com.nms.server.bean.DetectInfo;
import com.nms.server.bean.MissionResult2;
import com.nms.server.bean.SetInfo;
import com.nms.server.common.Common;
import com.nms.server.common.Constants;
import com.nms.server.thread.file.UnZipManagerThread;
import com.nms.server.thread.socket.SocketCMD;
import com.nms.server.util.socket.SSLSocketCallableForDateCollection;

/**
 * 数据（监测数据、任务结果、回传文件）收集线程 DC发送要收集数据的命令
 * Agent端发送6种数据命令中的一种，就开始收集，如果Agent发送6种数据命令之外的命令，就结束此次通信
 * 
 * @author hyx
 * 
 */
public class DataCollectThread extends SSLSocketCallableForDateCollection {
	Logger logger = Logger.getLogger(DataCollectThread.class);
	private String name; // 自定义Thread Name
	private boolean nmsclientFlag = true;// 是否进行握手监测
	private SetInfo setInfo;
	private long startTime;//数据收集服务器第一次启动的时间

	public DataCollectThread(String name, String ip, Integer port,
			boolean nmsclientFlag, SetInfo setInfo,long startTime) throws Exception {
		super(ip, port);
		this.name = name;
		this.nmsclientFlag = nmsclientFlag;
		this.setInfo = setInfo;
		this.startTime = startTime;	    
	}

	/**
	 * 与Client端进行通信：SSLSocketCallable已经握手过了 收集监测数据、任务结果、回传文件
	 */
	@Override
	protected Object toDo() throws Exception {
		// 为当前线程命名 ，用与开发阶段友好输出。
		Thread.currentThread().setName(name);
		int zipDetect = 0;
		int csvDetect = 0;
		int zipTaskResult = 0;
		int objTaskResult = 0;
		int zipTaskReturn = 0;
		int fileTaskReturn = 0;
		DetectInfo nmscDetec = null;

		try {
			// 进行通信:SSLSocketCallable已经建立握手了
			sendMessage(SocketCMD.REQ_DATA_COLLECT);// DC：要进行数据的收集（监测数据、任务结果、回传文件）
			String msg0 = receiveMessage();// Client:发送数据文件类型（监测数据、任务结果、回传文件的zip、csv或者list），或者没有数据，结束通信，或者关闭socket，则会收到null
			// 执行到此，说明通信已经建立,进行握手
			if (nmsclientFlag && StringUtils.isNotBlank(msg0)) {
				nmscDetec = Common.doNmsClientDetect(ip, setInfo, startTime);
			}
//			else if (StringUtils.isBlank(msg0) && Constants.IS_HANDEL_EXCEPTION_NODE){				
//					nmscDetec = Common.errorNodeToDo(name, nmsclientFlag, setInfo, ip, Calendar.getInstance().getTimeInMillis(), startTime);
//			}
			while (Constants.FLAG_DATA_COLLECT_ONLY_HANDSHAKE==1 && true) {
				logger.info("数据收集，client端" + this.ip + "回应信息：" + msg0);
				if (Thread.currentThread().isInterrupted()) {
					// 线程被中断，结束收集线程
					logger.info("收集线程 被中断，停止收集数据");
					return nmscDetec;
				}
				// 监测数据---start
				if (SocketCMD.DETECT_DATA_ZIP_TYPE.equalsIgnoreCase(msg0)) {
					logger.info("数据类型：监测数据的zip文件");
					this.sendMessage(SUCCESS);// DC告诉client，我知道你要发送zip类型的数据了
					String uploadPath = Constants.ZIP_FILE_DETECT_DATA_DIR;
					String fileName = receiveMessage();// client发送zip文件的名称
					this.sendMessage(SUCCESS);// DC收到zip文件的名称，给client回成功信息
					bpReceiveFile(uploadPath + File.separator + fileName);// client收到zip文件名发送成功后，发送zip文件，DC接收client发送的zip文件
					this.sendMessage(SUCCESS);// DC接收完client发送的zip文件存入指定路径后，给client回接收成功信息

					// 启动并注册 解压文件线程
					Future<?> future = Common.getFutureMap().get(
							Constants.UNZIP_FILE_MANAGER);
					if (future == null) {
						future = Common.scheduled.scheduleWithFixedDelay(
								new UnZipManagerThread(), 0, 30,
								TimeUnit.SECONDS);
						Common.registRunnable(Constants.UNZIP_FILE_MANAGER,
								future);
					}
					zipDetect++;
					msg0 = receiveMessage();// Client:再次发送数据文件类型，或者没有数据，结束通信

				} else if (SocketCMD.DETECT_DATA_CSV_TYPE
						.equalsIgnoreCase(msg0)) {
					logger.info("数据类型：监测数据的csv文件");
					sendMessage(SUCCESS);// DC告诉client，我知道你要发送csv类型的数据了，client端就开始发送csv文件
					LinkedList<byte[]> bslist = receiveFileBytesByBath();// DC端就准备接收csv文件
					if (bslist != null && bslist.size() > 0) {
						int detectDataNum = Common.getAllDeteDataNum();
						
						if(bslist.size()>Constants.MAX_COLLECT_RESOVE_DETECT_DATA_NUM
								|| detectDataNum>=Constants.MAX_DETECT_DATA_RESOVE_LIMIT_NUM){
							//存入dc_overrun/detect/zip_resove，等待之后解析，避免内存过大导致内存溢出
							logger.info("收集数据过多："+bslist.size()+"条，或者 内存中监测数据总数过大："+detectDataNum+" 为避免内存溢出，暂时存入硬盘，待之后解析入库，");
							Common.saveByteToFile(bslist);
						}else {
							Common.addAllDeteDataList(bslist);							
						}
					} else {
						logger.debug("接收 监测数据 文件数:0");
					}
					sendMessage(SUCCESS);// DC端csv文件接收完毕后，告诉client端，文件接收完毕
					csvDetect++;
					msg0 = receiveMessage();// Client:再次发送数据文件类型，或者没有数据，结束通信

				}
				// 监测数据---end
				// 任务结果---start
				else if (SocketCMD.TASK_RESULT_ZIP_TYPE.equalsIgnoreCase(msg0)) {
					logger.info("数据类型：任务结果的zip文件");
					this.sendMessage(SUCCESS);// DC告诉client，我知道你要发送zip类型的数据了
					String uploadPath = Constants.ZIP_FILE_TASK_RESULT_DIR;
					String fileName = receiveMessage();// client发送zip文件的名称
					this.sendMessage(SUCCESS);// DC收到zip文件的名称，给client回成功信息
					bpReceiveFile(uploadPath + File.separator + fileName);// client收到zip文件名发送成功后，发送zip文件，DC接收client发送的zip文件
					this.sendMessage(SUCCESS);// DC接收完client发送的zip文件存入指定路径后，给client回接收成功信息

					// 启动并注册 解压文件线程
					Future<?> future = Common.getFutureMap().get(
							Constants.UNZIP_FILE_MANAGER);
					if (future == null) {
						future = Common.scheduled.scheduleWithFixedDelay(
								new UnZipManagerThread(), 0, 30,
								TimeUnit.SECONDS);
						Common.registRunnable(Constants.UNZIP_FILE_MANAGER,
								future);
					}
					zipTaskResult++;
					msg0 = receiveMessage();// Client:再次发送数据文件类型，或者没有数据，结束通信

				} else if (SocketCMD.TASK_RESULT_OBJ_TYPE
						.equalsIgnoreCase(msg0)) {// --
					// 接收返回的任务结果：修改为receiveObject
					logger.info("数据类型：任务结果的List<String[]>");
					sendMessage(SUCCESS);
					List<String> resultList = (List<String>) receiveObject();
					sendMessage(SUCCESS);
					for (String result : resultList) {
						logger.info("任务结果：" + result);
						String[] misRlt2 = result
								.split(Constants.COMMON_DATA_SPLIT);
						MissionResult2 result2 = Common
								.resoveMissionResult(misRlt2);
						Common.addResultToResultList(result2);// 没有addAll，因为传递的任务结果可能是不同类型的任务结果（1-6）
					}
					objTaskResult++;
					msg0 = receiveMessage();// Client:再次发送数据文件类型，或者没有数据，结束通信
				}
				// 任务结果---end
				// 回传文件---start
				else if (SocketCMD.TASK_RETURN_ZIP_TYPE.equalsIgnoreCase(msg0)) {
					logger.info("数据类型：回传文件的zip文件");
					this.sendMessage(SUCCESS);// DC告诉client，我知道你要发送zip类型的数据了
					String uploadPath = Constants.ZIP_FILE_TASK_RETURN_DIR;
					String fileName = receiveMessage();// client发送zip文件的名称
					this.sendMessage(SUCCESS);// DC收到zip文件的名称，给client回成功信息
					bpReceiveFile(uploadPath + File.separator + fileName);// client收到zip文件名发送成功后，发送zip文件，DC接收client发送的zip文件
					this.sendMessage(SUCCESS);// DC接收完client发送的zip文件存入指定路径后，给client回接收成功信息

					// 启动并注册 解压文件线程
					Future<?> future = Common.getFutureMap().get(
							Constants.UNZIP_FILE_MANAGER);
					if (future == null) {
						future = Common.scheduled.scheduleWithFixedDelay(
								new UnZipManagerThread(), 0, 30,
								TimeUnit.SECONDS);
						Common.registRunnable(Constants.UNZIP_FILE_MANAGER,
								future);
					}
					zipTaskReturn++;
					msg0 = receiveMessage();// Client:再次发送数据文件类型，或者没有数据，结束通信

				} else if (SocketCMD.TASK_RETURN_FILE_TYPE
						.equalsIgnoreCase(msg0)) {// -- 接收任务4“启动”的回传文件

					sendMessage(SUCCESS);

					String msg1 = receiveMessage();
					sendMessage(SUCCESS);

					logger.info(msg1);
					String[] result = msg1.split(Constants.COMMON_DATA_SPLIT);
					MissionResult2 result2 = Common.resoveMissionResult(result);
					String fileName = receiveMessage();
					sendMessage(SUCCESS);
					logger.debug("MISSION_FILE_UPLOAD_DIR"
							+ Constants.MISSION_FILE_UPLOAD_DIR);

					this.bpReceiveFile(Constants.MISSION_FILE_UPLOAD_DIR
							+ fileName);

					sendMessage(SUCCESS);
					logger.debug("MISSION_FILE_UPLOAD_DIR"
							+ Constants.MISSION_FILE_UPLOAD_DIR + fileName);

					result2.setFileInfo(fileName);
					Common.addResultToResultList(result2);
					fileTaskReturn++;

					msg0 = receiveMessage();// Client:再次发送数据文件类型，或者没有数据，结束通信
				}
				// 回传文件---end
				else {// 如果没有这个else，且对方发送的命令非以上6种，则会死循环
					logger.info("数据收集线程：与client端" + this.ip + "的通信结束");
					break;
				}
			}

			logger.debug("client端" + this.ip + ",监测数据zip文件发送次数" + zipDetect);// 每次可以发送多个zip
			logger.debug("client端" + this.ip + ",监测数据csv文件发送次数" + csvDetect);// 每次可以发送多个csv
			logger.debug("client端" + this.ip + ",任务结果zip文件发送次数" + zipTaskResult);// 每次可以发送多个
			logger.debug("client端" + this.ip + ",任务结果obj文件发送次数" + objTaskResult);// 每次可以发送多个
			logger.debug("client端" + this.ip + ",回传文件zip文件发送次数" + zipTaskReturn);// 每次可以发送多个
			logger.debug("client端" + this.ip + ",回传文件file文件发送次数"
					+ fileTaskReturn);// 每次可以发送多个

		} catch (Exception e) {
			logger.error("Anomaly in the process of data collection", e);
//			if(nmscDetec==null && Constants.IS_HANDEL_EXCEPTION_NODE){
//				nmscDetec = Common.errorNodeToDo(name, nmsclientFlag, setInfo, ip, Calendar.getInstance().getTimeInMillis(), startTime);			
//			}
		}
		return nmscDetec;
	}
//	//创建握手监测信息
//	protected void createNmsClientDetectData(DetectInfo  detectInfo){
//		if(detectInfo!=null){			
//			int testTimes = 1;
//			Long checkTime = System.currentTimeMillis();		
//			detectInfo.setTestTimes(testTimes);//尝试次数
//			detectInfo.setCheckTime(checkTime);//监测时间
//			try{
//				/**
//				 * -- 监测数据描述信息非空（web界面的状态信息），才生成监测数据:
//				 *    1、监测数据为空可能是收集线程超时导致ping或者ssh未执行完毕，未生成描述信息
//				 *    2、此时web端进行超周期设置时，过滤掉异常的节点，异常节点的异常信息还是采用之前周期的-此功能 20160906 web端还未实现						     
//				 */
//				if(StringUtils.isNotBlank(detectInfo.getDescInfo())){
//					MonitorUtil.createMonitorData(ip, setInfo, startTime, Common.getAlarmInfoMap().get(setInfo.getId()+ ""), detectInfo);
//				}
//			} catch (Exception ex) {
//				logger.error(ExceptionPrintUtils.printExceptionStack(ex));
//				String processIden = setInfo.getProcessIden()==null ? "" : setInfo.getProcessIden();
//				String[] alarm = Common.alarmExceptionInfo(setInfo.getId(), ip, Constants.DETEC_NMSC_STR,processIden , startTime, 1,Constants.DETECTION_INFO_ALARM_WRONG, ex.getMessage());
//				Common.addAlarmData(alarm);
//			}
//		}
//	}

	// 收集数据前先进行握手监测通信
//	private DetectInfo doNmsClientDetect() {
//		logger.info("开始握手监测>" + ip);
//		DetectInfo detectInfo = null;
//		try {
//			// -- 发送握手命令
//			String sendTime = Calendar.getInstance().getTimeInMillis() + "";
//			// sendMessage(SocketCMD.CLIENT_REQ_HAND_SHAKE);//DC与NC握手通信后，NC会关闭socket，导致无法收集数据
//			// String msg = receiveMessage();//收到回复的信息后，说明握手成功了
//
//			String backTime = Calendar.getInstance().getTimeInMillis() + "";
//			// -- 信息保存到监测信息对象中
//			detectInfo = new DetectInfo();
//
//			StringBuffer nmsClientDetailDetectInfo = new StringBuffer();
//			nmsClientDetailDetectInfo.append(SocketCMD.CLIENT_REQ_HAND_SHAKE);// 发送信息
//			nmsClientDetailDetectInfo.append(MonitorUtil.SEPARATOR);// 分隔符
//			nmsClientDetailDetectInfo.append(SUCCESS + ":"
//					+ SocketCMD.CLIENT_REQ_HAND_SHAKE + "|" + sendTime);// 返回信息:DC端伪造的，因为也不需要NC回复信息了
//			nmsClientDetailDetectInfo.append(MonitorUtil.SEPARATOR);// 分隔符
//			nmsClientDetailDetectInfo.append("0");// 是否可达,0:可达，1：不可达
//			nmsClientDetailDetectInfo.append(MonitorUtil.SEPARATOR);// 分隔符
//			nmsClientDetailDetectInfo.append(sendTime);// 发送时间
//			nmsClientDetailDetectInfo.append(MonitorUtil.SEPARATOR);// 分隔符
//			nmsClientDetailDetectInfo.append(backTime);// 返回时间
//			nmsClientDetailDetectInfo.append(MonitorUtil.SEPARATOR);// 分隔符
//			nmsClientDetailDetectInfo.append(DateUtil.getSecondsFromBeinToEnd(
//					new Date(Long.parseLong(sendTime)).getTime(), new Date(Long
//							.parseLong(backTime)).getTime())
//					+ "");// 延迟时间
//
//			detectInfo.getDetailDatas().add(
//					nmsClientDetailDetectInfo.toString());
//
//			detectInfo.setDescInfo("开始"
//					+ DateUtil.getStringByLongStr(sendTime)
//					+ " NMSClient握手"
//					+ DateUtil.getStringByLongStr(backTime)
//					+ " 成功 ");
//
//		} catch (Exception e) {
//			logger.error("生成节点："+ip+"信息发生异常", e);
//		}finally{
//			if (Thread.currentThread().isInterrupted()) {
//				// 线程被中断，结束收集线程
//				logger.info("收集线程 被中断");
//				return detectInfo;
//			}else {
//				Common.createNmsClientDetectData(setInfo, ip, detectInfo, startTime);
//			}
//		}
//		
//		return detectInfo;
//	}
//	
//	@Override
//	protected DetectInfo errorNodeToDo(Long checkTime){
//		if(Constants.IS_HANDEL_EXCEPTION_NODE) {
//			return Common.errorNodeToDo(name, nmsclientFlag, setInfo, ip, checkTime, startTime);
//		}else {
//			return null;
//		}
//	}

//	@Override
//	protected DetectInfo errorNodeToDo(Long checkTime){
//		Thread.currentThread().setName(name + "(异常节点)");
//		if (Thread.currentThread().isInterrupted()) {
//			// 线程被中断，结束收集线程
//			logger.info("收集线程 被中断");
//			return null;
//		}
//		if(!nmsclientFlag){//对于不需要进行握手监测的节点，则不进行握手
//			return null;
//		}
//		DetectInfo detectInfo = null;
//		String stateInfo = "";
//		try{
//			detectInfo = new DetectInfo();
//			String failStartTime = Calendar.getInstance().getTimeInMillis()
//					+ "";
//			long maxTimes = 1l;
//
//			if (setInfo != null && setInfo.getCheckMaxTimes() != null) {
//				maxTimes = setInfo.getCheckMaxTimes();
//			}
//
//			String[] pingData = pingHandshake(ip, maxTimes);
//
//			String failEndTime = Calendar.getInstance().getTimeInMillis() + "";
//
//			if ((StringUtils.isEmpty(pingData[1]) || "0".equals(pingData[1]))) {// ping不通，无握手监测详细数据
//				stateInfo = "网络异常";
//			} else {
//				// 可以ping通进行ssh测试 如果ssh可以通 就产生一条握手失败信息 如果ssh不同就产生一条ssh失败信息
//				String sshResult = Constants.SUCCESS;
//				if("1".equals(Constants.FLAG_HANDWALK_SSH)){					
//					String[] userPwdInfo = Common.getIpUserPwdMap().get(ip);
//					if (userPwdInfo!=null && 
//							userPwdInfo.length>=3 && "1".equals(userPwdInfo[2])) {//应该判断nc的操作系统，不是dc的,1:linux; 2:windows; 3:other
//						sshResult = sshConnect(ip,userPwdInfo[0],userPwdInfo[1]);
//					}
//				}
//				
//				if (Constants.SUCCESS.equals(sshResult)) {
//					stateInfo = "开始" + DateUtil.getStringByLong(checkTime)
//							+ " NMSClient握手" + DateUtil.getCurrentTime() + " 失败 ";
//					StringBuffer detailInfo = new StringBuffer();
//					detailInfo.append(SocketCMD.CLIENT_REQ_HAND_SHAKE);// 发送信息
//					detailInfo.append(MonitorUtil.SEPARATOR);// 分隔符
//					detailInfo.append("");// 返回信息
//					detailInfo.append(MonitorUtil.SEPARATOR);// 分隔符
//					detailInfo.append("1");// 是否可达,0:可达，1：不可达
//					detailInfo.append(MonitorUtil.SEPARATOR);// 分隔符
//					detailInfo.append(failStartTime);// 发送时间
//					detailInfo.append(MonitorUtil.SEPARATOR);// 分隔符
//					detailInfo.append(failEndTime);// 返回时间
//					detailInfo.append(MonitorUtil.SEPARATOR);// 分隔符
//					detailInfo.append(DateUtil.getSecondsFromBeinToEnd(new Date(
//							Long.parseLong(failStartTime)).getTime(), new Date(Long
//							.parseLong(failEndTime)).getTime())
//							+ "");// 延迟时间
//					detectInfo.getDetailDatas().add(detailInfo.toString());
//			    }else{
//					stateInfo = sshResult;
//			    }
//			}
//		}catch (Exception e) {
//			logger.error("生成异常节点："+ip+"信息发生异常", e);
//		}finally{			
//			detectInfo.setDescInfo(stateInfo);
//			logger.info("与 " + ip + " 的握手监测发生异常  失败：" + stateInfo);
//			createNmsClientDetectData(detectInfo);//生成监测数据信息
//		}
//		return detectInfo;
//	}
//
//	private String[] pingHandshake(String ip, long maxTimes) {
//
//		String command = ""; // 命令语句
//		int minTime = Integer.MAX_VALUE, maxTime = 0, totalTime = 0, curTime; // 最短时间，最长时间，总时间，时间变量
//		int snum = 0, fnum = 0; // 发包成功和失败数
//
//		// 判断系统类型 win or Linux
//		String system = (String) (System.getProperty("os.name")).toLowerCase();
//
//		if (system.toLowerCase().indexOf("win") != -1) {
//			command += "ping -n 4 " + ip;// 尝试次数 -n
//		} else if (system.toLowerCase().indexOf("linux") != -1) {
//			command += "ping -c 4 " + ip;
//		} else {
//			command += "ping -w 4 " + ip;
//		}
//
//		String stateInfo = "";
//		String[] datas2 = new String[7];
//		Process process = null;
//		BufferedReader in = null; // 读取 Ping命令返回的信息
//		StringBuffer buffer = new StringBuffer();
//		try {
//			logger.debug("ping command:" + command);
//			process = Runtime.getRuntime().exec(command);
//			in = new BufferedReader(new InputStreamReader(process
//					.getInputStream()));
//			String line = null;
//			long count = maxTimes + 10;
//			int index;
//			// 最多多读10行
//			while ((line = in.readLine()) != null && count != 0) {
//				if ("".equals(line)) {
//					count--;
//					continue;
//				} // 空串跳过
//				buffer.append(line + "\n");
//				line = line.toLowerCase();
//				logger.debug("line:" + line);
//				if (line.indexOf("ttl") > 0) { // 获得成功响应的数据
//					count--; // 计数器自减1
//					// 截取time 值
//					if ((index = line.lastIndexOf("ms")) != -1) {
//						byte[] buf = line.getBytes();
//						int start = 0, end = buf.length, i, j;
//						// 下标末点
//						for (i = index; i >= 0; i--) {
//							if (Character.isDigit((char) buf[i])) {
//								end = i;
//								break;
//							}
//						}
//						if (i == 0)
//							continue;
//						// 下标起点
//						for (j = end; j >= 0; j--) {
//							if (!Character.isDigit((char) buf[j])) {
//								start = j + 1;
//								break;
//							}
//						}
//						// 时间值截取
//						curTime = Integer.parseInt(new String(buf, start, end
//								+ 1 - start));
//						snum++; // 成功接收次数加1
//						totalTime += curTime; // 计算总时间
//
//						if (curTime < minTime) {
//							minTime = curTime;
//						} // 最小时间
//
//						if (curTime > maxTime) {
//							maxTime = curTime;
//						} // 最大时间
//					}
//				} else if (line.split(" ").length < 4) {
//					count--; // 计数器自减1
//					fnum++; // 失败接收次数加1
//				} else {
//					stateInfo += line + "\n";
//				}
//			}
//
//			if (totalTime == 0) {
//				minTime = 0;
//			}
//
//			// 已发送包数
//			datas2[0] = "" + (snum + fnum);
//			datas2[1] = "" + snum;
//			datas2[2] = "" + fnum;
//
//			BigDecimal fnum0 = new BigDecimal(fnum);
//			BigDecimal tnum0 = new BigDecimal(snum + fnum);
//			DecimalFormat df = new DecimalFormat("####0.00");
//			if (tnum0.intValue() != 0) {
//				datas2[3] = ""
//						+ ((new BigDecimal(df.format(fnum0.divide(tnum0, 4,
//								RoundingMode.HALF_UP))))
//								.multiply(new BigDecimal(100)));
//			}
//			datas2[4] = "" + minTime;
//			datas2[5] = "" + maxTime;
//			datas2[6] = "" + (snum == 0 ? 0 : (totalTime / snum));
//		} catch (Exception e) {
//			logger.error(ExceptionPrintUtils.printExceptionStack(e));
//		} finally {
//			if (in != null) {
//				try {
//					in.close();
//				} catch (IOException e) {
//					logger.error("", e);
//				}
//			}
//			if (process != null)
//				process.destroy();
//			process = null;
//		}
//
//		/*
//		 * if(state==-1){ isSuccess = false; }else{ isSuccess = true; }
//		 */
//		return datas2;
//	}
//
//	private String sshConnect(String hostname, String username, String password) {
//		String result = Constants.SUCCESS;
//		long a = new Date().getTime();
//		Connection conn = null;
//		Session sess = null;
//		try {
//			if(StringUtils.isNotBlank(hostname)){
//				conn = new Connection(hostname);
//				conn.connect();
//				long b = new Date().getTime();
//				logger.debug("SSHConnect----链接ip耗时：" + (b - a) + "毫秒," + (b - a)
//						/ 1000 + "秒");
//				boolean isAuthenticated = conn.authenticateWithPassword(username,
//						password);
//				if (isAuthenticated == true) {
//					sess = conn.openSession();
//					sess.execCommand("date");
//					InputStream stdout = new StreamGobbler(sess.getStdout());
//					BufferedReader stdoutReader = new BufferedReader(
//							new InputStreamReader(stdout, Charset.forName("utf-8")));
//					while (true) {
//						String line = stdoutReader.readLine();
//						if (line == null){
//							break;
//						}
//					}
//				}					
//				long c = new Date().getTime();
//				logger.debug("SSHConnect----测试完成，总耗时：" + (c - a) + "毫秒," + (c - a)/1000 + "秒");
//			}
//		} catch (IOException e) {
//			long d = new Date().getTime();
//			logger.error("SSHConnect----连接异常，耗时：" + (d - a) + "毫秒," + (d - a)
//					/ 1000 + "秒", e);			
//			if(e.getMessage().contains("Authentication")){				
//				result = "SSH 登录用户名或密码错误";
//			}else {
//				result = "SSH 连接失败";
//			}
//		} catch (Exception e1) {
//			long e = new Date().getTime();
//			logger.error("SSHConnect----连接异常，耗时：" + (e - a) + "毫秒," + (e - a)
//					/ 1000 + "秒", e1);			
//			result = "SSH 连接失败";
//		}finally {
//			if(conn!=null){
//				conn.close();
//			}
//			if(sess!=null){
//				sess.close();
//			}
//		}
//		return result;
//	}

//	public static void main(String[] args) {

		/*
		 * try {
		 * 
		 * Future<?> future = null; long start = System.currentTimeMillis();
		 * future = Common.service.submit(new
		 * DataCollectThread("数据收集执行线程","10.0.6.234"
		 * ,Constants.SSL_CLIENT_PORT,true));
		 * System.out.println("done1:"+future.isDone());
		 * 
		 * // System.out.println("new:"+new
		 * DataCollectThread("数据收集执行线程","10.0.6.102"
		 * ,Constants.SSL_CLIENT_PORT,true).toDo()); // Thread.sleep(3000); //
		 * System.out.println("done2:"+future.isDone());
		 * System.out.println("get:"+future.get());
		 * System.out.println("done3:"+future
		 * .isDone()+"="+(System.currentTimeMillis()-start));
		 * 
		 * try { future.get(Constants.MISSION_UPGRADE_DAILY, TimeUnit.SECONDS);
		 * } catch (Exception e) { // logger.error("DC清理数据超时， 缓存数据存入硬盘", e); }
		 * 
		 * 
		 * // new
		 * DataCollectThread("数据收集执行线程","10.0.6.113",Constants.SSL_CLIENT_PORT
		 * ,true).call(); } catch (Exception e) { // TODO Auto-generated catch
		 * block e.printStackTrace(); }
		 */
//	}

}
