package com.nms.server.thread.monitor;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import com.nms.server.bean.AlarmInfo;
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.monitor.util.MonitorUtil;
import com.nms.server.thread.socket.SocketCMD;
import com.nms.server.util.CSVUtils;
import com.nms.server.util.DateUtil;
import com.nms.server.util.ExceptionPrintUtils;
import com.nms.server.util.socket.SocketUtils;
import com.nms.server.util.socket.limiter.InputStreamLimiter;
import com.nms.server.util.socket.limiter.OutputStreamLimiter;

/**
 *  监测数据
 *  监测NMSClient端是否执行执行线程
 *	@author ZhangGang
 *
 */
public class NMSClientForSocketThread extends SocketUtils implements  Runnable{
	private Logger logger = Logger.getLogger(NMSClientForSocketThread.class);
	private SimpleDateFormat format = new SimpleDateFormat(Constants.COMMON_DATE_FORMAT);
	private String name;
	private String checkTypeName = null;
	private Long startTime = null;
	private Long sitInfoId = null;
	private long outTime = 2;
	private long maxTimes = 3;
	private long gap = 0 ;
//	private String cmd = SocketCMD.CLIENT_REQ_HAND_SHAKE;
	private String processIden = null;
//	protected Socket socket = null;		//Socket
	private CountDownLatch downLatch;
	
	private SetInfo info;
	/**
	 * 构造方法
	 * @param name 线程名称
	 * @param ip 被监测端IP	
	 * @param port socket通信端口
	 * @param info
	 */
	public NMSClientForSocketThread(String name,String ip,int port,SetInfo info,Long startTime,CountDownLatch downLatch) {
		super(ip, port);
		this.name = name;
		this.sitInfoId = info.getId();
		this.checkTypeName = info.getCheckTypeName();
		this.startTime = startTime;
		this.outTime = info.getCheckOutTime();
		this.maxTimes = info.getCheckMaxTimes();
		this.processIden = info.getProcessIden()==null ? "" : info.getProcessIden();
		this.downLatch = downLatch;
		
		this.info = info;
	}
	
	public NMSClientForSocketThread(String name,String ip,int port,SetInfo info,Long startTime) {
		super(ip, port);
		this.name = name;
		this.sitInfoId = info.getId();
		this.checkTypeName = info.getCheckTypeName();
		this.startTime = startTime;
		this.outTime = info.getCheckOutTime();
		this.maxTimes = info.getCheckMaxTimes();
		this.processIden = info.getProcessIden()==null ? "" : info.getProcessIden();
		this.downLatch = downLatch;
		
		this.info = info;
	}
	
	@Override
	public void run() {
		
		Thread.currentThread().setName(name+" "+ip);	
		try {
			
			/**
			 * 
			 * ping不通时，无握手监测详细数据
			 * 握手失败时，有握手监测详细数据
			 * 握手成功时，有握手监测详细数据
			 * 
			 */
			
			Long checkTime = System.currentTimeMillis();
			
			int a = 0;
			DetectInfo  detectInfo = null;
			String failStartTime =  "";
			String failEndTime =  "";
			
			
			loop:
				for(; a < maxTimes ;){
					failStartTime = Calendar.getInstance().getTimeInMillis()+"";
					detectInfo = this.getNMSClientBysocket();
					failEndTime = Calendar.getInstance().getTimeInMillis()+"";
					a++;
					if(detectInfo != null){	//成功,如果第一次就成功的话，那么尝试次数为1
						break loop;
					}else{	//失败
						continue loop;
					}
				}
			
			if(detectInfo == null){//握手失败
				detectInfo = new DetectInfo();					
				String stateInfo = "";
				String [] pingData = pingHandshake();
				
				if ((StringUtils.isEmpty(pingData[1]) || "0".equals(pingData[1])) ) {//ping不通，无握手监测详细数据
//					stateInfo = "网络异常";
//					stateInfo = "Network Exception";
					stateInfo = "i18n_server.NMSClientForSNMPThread.netErr_n81i";
				} else {//如果可以ping通，但是握手失败，则有详细握手监测数据
//					stateInfo = "开始"+format.format(new Date(checkTime))+ " NMSClient握手" + 
//							format.format(new Date()) + " 失败 ";
//					stateInfo = "Start"+format.format(new Date(checkTime))+ " NMSClient Shakehand" + 
//							format.format(new Date()) + " failed ";
					stateInfo = "i18n_server.NMSClientForSNMPThread.begin_n81i"+format.format(new Date(checkTime))+ " i18n_server.NMSClientForSocketThread.nmsShake_n81i" + 
								format.format(new Date()) + " i18n_server.NMSClientForSNMPThread.fail_n81i ";
					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());				
				}
				
				detectInfo.setDescInfo(stateInfo);
				logger.info("与 "+ip+" 的握手监测 异常："+stateInfo);
			} else {//握手成功，则进行监测数据的收集？？
				logger.info("与 "+ip+" 的握手监测 正常，开始收集数据");
//				Thread.currentThread().setName("数据收集:>"+ip);
				Thread.currentThread().setName("Data Collection:>"+ip);
				collectDatas();//收集数据
				Thread.currentThread().setName(name+" "+ip);
			}
			
			detectInfo.setTestTimes(a);//尝试次数
			detectInfo.setCheckTime(checkTime);//监测时间
			
			//-- 生成监测数据
			MonitorUtil.createMonitorData(ip, info, startTime, Common.getAlarmInfoMap().get(info.getId()+ ""), detectInfo);
		} catch (Exception ex) {
			logger.error(ExceptionPrintUtils.printExceptionStack(ex));
			String[] alarm = Common.alarmExceptionInfo(sitInfoId, ip, Constants.DETEC_NMSC_STR, processIden, startTime, 1,Constants.DETECTION_INFO_ALARM_WRONG, ex.getMessage());
			Common.addAlarmData(alarm);
		}finally{
			if(downLatch!=null){
				downLatch.countDown();
			}
		}
	}
	
	private DetectInfo getNMSClientBysocket(){
		
		DetectInfo detectInfo = null;
		//set up a connection
		try {
			//-- 创建通讯
			this.createClientSocket();
			
			//-- 发送握手命令
			String sendTime = Calendar.getInstance().getTimeInMillis()+"";
			sendMessage(SocketCMD.CLIENT_REQ_HAND_SHAKE);		
			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(msg);//返回信息
			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("开始"+format.format(new Date(Long.parseLong(sendTime)))+ " NMSClient握手" +
//					format.format(new Date(Long.parseLong(backTime))) + " 成功 ");
//			detectInfo.setDescInfo("Start"+format.format(new Date(Long.parseLong(sendTime)))+ " NMSClient Shakehand" +
//					format.format(new Date(Long.parseLong(backTime))) + "success ");
			detectInfo.setDescInfo("i18n_server.NMSClientForSNMPThread.begin_n81i"+format.format(new Date(Long.parseLong(sendTime)))+ " i18n_server.NMSClientForSocketThread.nmsShake_n81i" +
					format.format(new Date(Long.parseLong(backTime))) + "i18n_server.NMSClientForSNMPThread.success_n81i ");
			
		} catch (Exception e) {
			logger.error("Failure to shake hands with"+ip+e.getMessage());
		}finally{
			close();
		}
		
		return detectInfo;
	}

	public static long getMinutesFromBeginToEnd(long begin, long end) {
		return (end - begin) / (60 * 1000);
	}
	
	private String[] pingHandshake(){
		
		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");
			datas2[3] = "" + ((new BigDecimal(df.format(fnum0.divide(tnum0))))
							.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;
	}
	
	//收集数据：DC端主动收集数据（监测数据、任务结果、回传文件）
	private void collectDatas(){
		int zipDetect = 0;
		int csvDetect = 0;
		int zipTaskResult = 0;
		int objTaskResult = 0;
		int zipTaskReturn = 0;
		int fileTaskReturn = 0;
		
		try {
			//- 非升级操作判断
			if(Common.SERVER_UN_UPGRADE_FLAG){
				this.createClientSocket();
				sendMessage(SocketCMD.REQ_DATA_COLLECT);//DC：要进行数据的收集（监测数据、任务结果、回传文件）
				String msg0 = receiveMessage();//Client:发送数据文件类型（监测数据、任务结果、回传文件的zip、csv或者list），或者没有数据，结束通信，或者关闭socket，则会收到null
				
				while(true) {
					logger.info("数据收集，client端"+this.ip+"回应信息："+msg0);
					
					//监测数据---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文件:可能是多个csv文件
						if(bslist!=null && bslist.size()>0){
							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.info("client端"+this.ip+",监测数据zip文件发送次数"+zipDetect);//每次可以发送多个zip
				logger.info("client端"+this.ip+",监测数据csv文件发送次数"+csvDetect);//每次可以发送多个csv
				logger.info("client端"+this.ip+",任务结果zip文件发送次数"+zipTaskResult);//每次可以发送多个
				logger.info("client端"+this.ip+",任务结果obj文件发送次数"+objTaskResult);//每次可以发送多个
				logger.info("client端"+this.ip+",回传文件zip文件发送次数"+zipTaskReturn);//每次可以发送多个
				logger.info("client端"+this.ip+",回传文件file文件发送次数"+fileTaskReturn);//每次可以发送多个
				
			}
			
		} catch (Exception e) {
			logger.error("The DC side actively collects data (monitoring data, task results, return files) exceptions",e);
		}
	}
	
//	public void run() {
//		
//		Thread.currentThread().setName(name+" "+ip);
//		
//		try {
//
//			Calendar checkTime =  Calendar.getInstance();
//			Calendar nextTime =  Calendar.getInstance();
//			nextTime.add(Calendar.MINUTE, Long.valueOf(gap).intValue());
//			
//			List<String> datas = new ArrayList<String>();		//拼写数据格式 已安全进入公共数据解析入口
//			
//			//--初始部分数据整理
//			datas.add(Common.getIpSeqIdMap().get(ip)+"");//IP，
//			datas.add(sitInfoId+"");//监测设置ID，
//			datas.add(checkTypeName);//监测类别，
//			datas.add(processIden);//进程名称（检查类别设置名称），
//				
//			String stateInfo ="";
//			int state = -1;//测试使用
//			String[] datas2 = new String[6];
//			int a = 0;
//			String [] msgArr = null;
//
//			loop:
//				for(int i = 0 ; i < maxTimes ;i++){
//					datas2[3] = Calendar.getInstance().getTimeInMillis()+"";
//					msgArr = this.sockeHandshake();
//					a = a+1;
//					datas2[4] = Calendar.getInstance().getTimeInMillis()+"";
//					if("1".equals(msgArr[0])){	//成功
//						break loop;							
//					}else{	//失败
//						continue loop;
//					}
//				}
//			datas2[0] = SocketCMD.CLIENT_REQ_HAND_SHAKE;
//			datas2[1] = msgArr[1];
//			stateInfo += "开始"+format.format(new Date(Long.parseLong(datas2[3])))+ " NMSClient握手";
//			if("1".equals(msgArr[0])){			//成功
//				if(msgArr[1] != null && !"".equals(msgArr[1])){
//					String mreturn[] = msgArr[1].split("\\|");
//					if(mreturn != null && mreturn.length >= 2){
//						datas.add(mreturn[1]);//监测服务启动时间，
//					}
//				}
//				stateInfo += format.format(new Date(Long.parseLong(datas2[4]))) + " 成功 ";
//				datas2[2] = "0";
//			}else{		//失败
//				datas.add(startTime+"");//监测服务启动时间，
//				stateInfo += format.format(new Date(Long.parseLong(datas2[4]))) + " 失败 ";
//				datas2[2] = "1";
//				String [] pingData = pingHandshake();
//				
//				if ((StringUtils.isEmpty(pingData[1]) || "0".equals(pingData[1])) ) {
//					stateInfo = "网络异常";
//				} else {
////					stateInfo = "请检查目标主机NMSClient是否启动";
//				}
//			}
//			datas2[5] = DateUtil.getSecondsFromBeinToEnd(new Date(Long
//					.parseLong(datas2[3].toString())).getTime(), new Date(Long
//					.parseLong(datas2[4].toString())).getTime())
//					+ "";
//			state = 0;
//	
//				
//			datas.add("0");//检测时延（秒）
//			datas.add(checkTime.getTimeInMillis()+"");//本次检测时间，
//			
//			if(state!=-1){
//				datas.add(a+"");// 尝试次数，+"/"+maxTimes
//				datas.add(nextTime.getTimeInMillis()+"");// 下次计划监测时间，
//				String [] pArray = getAlarmState(Common.getAlarmInfoMap().get(sitInfoId.longValue()+""), datas2);
//				if("1".equals(msgArr[0])){
//					datas.add("1"); // 执行状态
//					datas.add(""); // 告警列序号，
//					datas.add(""); // 告警级别，
//					datas.add(""); // 告警值，
//				}else {
//					datas.add("0"); // 执行状态
//					datas.add(pArray==null?"":pArray[0]); // 告警列序号，
//					datas.add(pArray==null?"":pArray[1]); // 告警级别，
//					datas.add(pArray==null?"":pArray[2]); // 告警值，
//				}
//				datas.add(stateInfo); // 状态信息（描述信息），
//				datas.add(stateInfo); // 性能数据，
//				datas.addAll(Arrays.asList(datas2));//监测具体数据信息（每个字段一列）
//			} else {//测试告警的代码，无用
//				datas.add(a+"");// 尝试次数，+"/"+maxTimes
//				datas.add(nextTime.getTimeInMillis()+"");// 下次计划监测时间，
//				datas.add("-1"); // 执行状态
//				datas.add("3"); // 告警列序号，(丢包数 列 序号 为3)
//				datas.add("1"); // 告警级别，
//				datas.add("1"); // 告警值，
//				datas.add(stateInfo); // 状态信息（描述信息），
//				datas.add(stateInfo); // 性能数据，
//			}
//			datas.add(checkTime.getTimeInMillis()+"");//本次检测时间，
//	
//			//- 存入缓存
//			try {
//				logger.debug("data："+Arrays.toString(datas.toArray()));
//				Common.addDeteData(CSVUtils.csvBytesPrinter(datas, Constants.COMMON_TEXT_CODING));
//				logger.debug("监测数据以 CSV格式 保存完成");
//			} catch (Exception e) {
//				logger.error("监测数据以 CSV格式 保存异常", e);
//			}
//		} catch (Exception ex) {
//			logger.error(ExceptionPrintUtils.printExceptionStack(ex));
//			String[] alarm = Common.alarmExceptionInfo(sitInfoId, ip, Constants.DETEC_NMSC_STR, processIden, startTime, 1,Constants.DETECTION_INFO_ALARM_WRONG, ex.getMessage());
//			Common.addAlarmData(alarm);
//		}finally{
//			if(downLatch!=null){
//				downLatch.countDown();
//			}
//		}
//	}
//	
//	private String[] sockeHandshake(){//此方法无用了
//		String [] msgArr = new String[2];
//		msgArr[0] = 0+"";
//
//		//set up a connection
//		SSLSocketFactory ssf = null;
//		try {
//			//-- create SocketFactory
//			ssf = sSLContext.getSocketFactory();
//			
//			//-- create socket
//			socket=(SSLSocket)ssf.createSocket(ip,port);
//			logger.debug("create socket success.");
//			socket.setSoTimeout((int)3000);
//			//-- handshake 握手
//			((SSLSocket) socket).startHandshake();
//			logger.debug("handshake success.");
//			
//			outl = new OutputStreamLimiter(socket.getOutputStream());
//			inl = new InputStreamLimiter(socket.getInputStream());
//			
//			sendMessage(SocketCMD.CLIENT_REQ_HAND_SHAKE);
//			msgArr[1] = receiveMessage();
//			
//			msgArr[0] = 1+"";
//		}catch (IOException e) {
//			logger.error("",e);
//		} catch (Exception e) {
//			logger.error("",e);
//		}finally{
//			close();
//		}
//		
//		return msgArr;
//	}
	
	
	
	
	//获得当前的报警设置信息，与相应字段值比较
//	private String[] getAlarmState(List<AlarmInfo> alarmInfos, String[] sysData){
//		String[] strs = null;
//		if(alarmInfos!=null){
//			strs = new String[]{"", "", ""};
//			for(AlarmInfo alarm : alarmInfos){
//				if(sysData.length>=alarm.getShowNum()){
//					Double data = Math.abs(Double.parseDouble(sysData[alarm.getShowNum()-1]));
//					if("equal".equals(alarm.getPoliceSysmbols())){
//						if((data+"").equals(alarm.getPoliceValue())){
//							strs[0] += alarm.getShowNum() + "|";// 告警序列号
//							strs[1] += alarm.getPoliceLevel() + "|"; //告警级别
//							strs[2] += alarm.getPoliceValue() + "|"; //告警值
//						}
//					}
//					else if("include".equals(alarm.getPoliceSysmbols())){
//						if((data+"").indexOf(alarm.getPoliceValue())!=-1){
//							strs[0] += alarm.getShowNum() + "|";// 告警序列号
//							strs[1] += alarm.getPoliceLevel() + "|"; //告警级别
//							strs[2] += alarm.getPoliceValue() + "|"; //告警值
//						}
//					}
//					else if("exclude".equals(alarm.getPoliceSysmbols())){
//						if((data+"").indexOf(alarm.getPoliceValue())==-1){
//							strs[0] += alarm.getShowNum() + "|";// 告警序列号
//							strs[1] += alarm.getPoliceLevel() + "|"; //告警级别
//							strs[2] += alarm.getPoliceValue() + "|"; //告警值
//						}
//					}
//					else{
//						double result = data - Double.parseDouble(alarm.getPoliceValue());
//						if ((">".equals(alarm.getPoliceSysmbols()) && result > 0)
//								|| ("<".equals(alarm.getPoliceSysmbols()) && result < 0)
//								|| ("=".equals(alarm.getPoliceSysmbols()) && result == 0)
//								|| (">=".equals(alarm.getPoliceSysmbols()) && result >= 0)
//								|| ("<=".equals(alarm.getPoliceSysmbols()) && result <=0) ) {
//							strs[0] += alarm.getShowNum() + "|";// 告警序列号
//							strs[1] += alarm.getPoliceLevel() + "|"; //告警级别
//							strs[2] += alarm.getPoliceValue() + "|"; //告警值
//						}
//					}
//				}
//			}
//			for(int i=0; i<strs.length; i++){
//				if(strs[i].length()>0){
//					strs[i] = strs[i].substring(0, strs[i].length()-1);
//				}
//			}
//		}
//		
//		if(strs!=null && "".equals(strs[0])){
//			strs = null;
//		}
//		
//		return strs;
//	}

	
	//main测试使用的构造方法
	public NMSClientForSocketThread(String name,Long sitInfoId,String socketIp,int socketPort,long gap,long outTime,long maxTimes) {
		super(socketIp, socketPort);
		this.name = name;
		this.sitInfoId = sitInfoId;
		this.outTime = outTime;
		this.maxTimes = maxTimes;
		this.gap = gap;	
		
	}
	
 	public static void main(String [] args) {
		Thread thread = new Thread(new NMSClientForSocketThread("NMSC Thread",10l,"10.0.6.102",60701,2,100,3));
//		String name,Long sitInfoId,String socketIp,int socketPort,long gap,long outTime,long maxTimes
		thread.start();
	}
	
}
