taskproxy.java

一个用于监控WEB服务器和数据库服务器的客户端程序。

							c.set(Calendar.SECOND, second);
							c.add(Calendar.YEAR, count);
							c.add(Calendar.MONTH, diffMonth);
							scheduleDatesClone[i] = c.getTime();
							System.out.println(scheduleDatesClone[i]);
							timer.schedule(
									innerMonthTasksClone[i], 
									scheduleDatesClone[i], 
									persistTime * 60 * 1000
							); 
						}
						attempInnerTasks.add(innerMonthTasksClone);
						count++;
					} 
				};
				timer.schedule(
						outerTask, date, 365 * 24 * 60 * 60 * 1000);
			}
		}
		return outerTask;
	}
	
	private Date getDate(String dateStr, String hourStr, String minuteStr) {
		Date date = null;
		int hour = Integer.parseInt(hourStr);
		int minute = Integer.parseInt(minuteStr);
		now.set(Calendar.HOUR_OF_DAY, hour);
		now.set(Calendar.MINUTE, minute);
		now.set(Calendar.SECOND, 0);
		if (!dateStr.equals("")) {
			try {
				date = new SimpleDateFormat("yyyy-MM-dd").parse(dateStr);
			} catch (ParseException e) {
				e.printStackTrace();
			}
			if (date != null) {
				Calendar c = Calendar.getInstance();
				c.setTime(date);
				now.set(Calendar.YEAR, c.get(Calendar.YEAR));
				now.set(Calendar.MONTH, c.get(Calendar.MONTH));
				now.set(Calendar.DATE, c.get(Calendar.DATE));
			}
			else {
				JOptionPane.showMessageDialog(mainFrame, "日期格式无效！");
				setRunable(false);
				return null;
			}
		}
		return now.getTime();
	}
	
	private boolean stopTask(Integer ID) {
		Task[] t = tasks.remove(ID);
		if (t != null) {
			for(int i=0;i<t.length;i++){
				if (t[i] != null) {
					t[i].cancel();
				}
			}
		}
		ArrayList inner = innerTasks.remove(ID);
		if (inner != null) {
			System.out.println("inner tasks=="+inner.size());
			for(int i=0;i<inner.size();i++){
				Task[] temp = (Task[]) inner.get(i);
				if (temp != null) {
					System.out.println("temp task size="+temp.length);
					for (int j=0;j<temp.length;j++) {
						temp[j].cancel();
					}
				}
			}
		}

		return true;
	}

	private HashMap loadTaskListFile(File file){
		String fileName = file.getAbsolutePath();
		if(fileName.lastIndexOf(".xml") == -1) {
			file = new File(fileName+".xml");
		}
		if(!file.exists()){
			setLoadSuccessful(false);
			return null;
		}
		else{
			try {
				Document doc = reader.read(file);
				Element root = doc.getRootElement();
				List tasks = root.elements();
				for(int i=0;i<tasks.size();i++){
					String[] general = new String[Constant.generalXmlField.length];
					String[] notify = new String[Constant.notifyXmlField.length];
					Element taskChild = ((Element)tasks.get(i)).element("general");
					int count = 0;
					for (Iterator iterator = taskChild.elementIterator(); iterator
							.hasNext();) {
						general[count++] = ((Element) iterator.next()).getText();
					}
					List steps = ((Element)tasks.get(i)).elements("step");
					for (int j = 0; j < steps.size(); j++) {
						taskChild = (Element)steps.get(j);
						String[] oneStep = new String[Constant.stepXmlField.length];
						count = 0;
						for (Iterator iterator = taskChild.elementIterator(); iterator
								.hasNext();) {
							oneStep[count++] = ((Element) iterator.next()).getText();
						}
						step.add(oneStep);
					}
					List attemps = ((Element)tasks.get(i)).elements("attemp");
					for (int j = 0; j < attemps.size(); j++) {
						taskChild = (Element)attemps.get(j);
						String[] oneAttemp = new String[Constant.attempXmlField.length];
						count = 0;
						for (Iterator iterator = taskChild.elementIterator(); iterator
								.hasNext();) {
							oneAttemp[count++] = ((Element) iterator.next()).getText();
						}
						attemp.add(oneAttemp);
					}	
					taskChild = ((Element)tasks.get(i)).element("notify");
					count = 0;
					for (Iterator iterator = taskChild.elementIterator(); iterator
							.hasNext();) {
						notify[count++] = ((Element) iterator.next()).getText();
					}
					Object[] objects = new Object[4];
					objects[0] = general;
					objects[1] = step.clone();
					objects[2] = attemp.clone();
					objects[3] = notify;
					step.clear();
					attemp.clear();
					String ID = ((Element)tasks.get(i)).attributeValue("id");
					map.put(Integer.parseInt(ID), objects);
				}
				HashMap mapClone = (HashMap)(map.clone());
				map.clear();
				if (mapClone != null) {
					mainFrame.setTaskListName(file.getName());
					parser = new LogParser();
					parser.setFileName(file.getName());
					Object[] keys = mapClone.keySet().toArray();	
					parser.setKeys(keys);
					try {
						SAXParserFactory sf = SAXParserFactory.newInstance();
						SAXParser sp = sf.newSAXParser();
						sp.parse(new InputSource(Constant.logPath), parser);
					} 
					catch (Exception e) {
						e.printStackTrace();
						return null;
					}
				}
				return mapClone;
			} catch (Exception e) {
				e.printStackTrace();
				setLoadSuccessful(false);
				return null;
			}
		}
	}
	
	private boolean saveTaskListFile(HashMap map, File file){
		boolean result = false;
		StringBuilder sb = new StringBuilder();
		sb.append("<?xml version=\"1.0\" encoding=\"gb2312\"?>\r\n");
		sb.append("<taskList>\r\n");
		Object[] obj;
		Set set = map.keySet();
		int[] keys = new int[set.size()];
		Iterator it = set.iterator();
		int count = 0;
		while (it.hasNext()) {
			keys[count++] = ((Integer) it.next()).intValue();
		}
		Arrays.sort(keys);
		for (int i = 0; i < keys.length; i++) {
			sb.append("<task id=\"" + (keys[i]) + "\">\r\n");
			obj = (Object[]) map.get(keys[i]);
			String[] general = (String[]) obj[0];
			sb.append("        <general>\r\n");
			for (int k = 0; k < general.length; k++) {
				sb.append("            <" + Constant.generalXmlField[k] + ">"
						+ general[k] + "</" + Constant.generalXmlField[k]
						+ ">\r\n");
			}
			sb.append("        </general>\r\n");
			ArrayList step = (ArrayList) obj[1];
			for (int j = 0; j < step.size(); j++) {
				String[] oneStep = (String[]) step.get(j);
				sb.append("        <step>\r\n");
				for (int k = 0; k < oneStep.length; k++) {
					sb.append("            <" + Constant.stepXmlField[k] + ">"
							+ oneStep[k] + "</" + Constant.stepXmlField[k]
							+ ">\r\n");
				}
				sb.append("        </step>\r\n");
			}
			ArrayList attemp = (ArrayList) obj[2];
			for (int j = 0; j < attemp.size(); j++) {
				String[] oneAttemp = (String[]) attemp.get(j);
				sb.append("        <attemp>\r\n");
				for (int k = 0; k < oneAttemp.length; k++) {
					sb.append("            <" + Constant.attempXmlField[k]
							+ ">" + oneAttemp[k] + "</"
							+ Constant.attempXmlField[k] + ">\r\n");
				}
				sb.append("        </attemp>\r\n");
			}
			String[] notify = (String[]) obj[3];
			sb.append("        <notify>\r\n");
			for (int k = 0; k < notify.length; k++) {
				sb.append("            <" + Constant.notifyXmlField[k] + ">"
						+ notify[k] + "</" + Constant.notifyXmlField[k]
						+ ">\r\n");
			}
			sb.append("        </notify>\r\n");
			sb.append("    </task>\r\n");
		}
		sb.append("</taskList>\r\n");
		BufferedWriter writer;
		try {
			writer = new BufferedWriter(new FileWriter(file));
			writer.write(sb.toString());
			writer.flush();
			writer.close();
			sb = null;
			result = true;
		} catch (IOException e) {
			e.printStackTrace();
			result = false;
		}
		return result;
	}

	private MainFrame mainFrame;
	private TaskDialog taskDialog;
	private JTable table;
	private MainFrameTableModel model;
	private JFileChooser fileChooser;
	
	private Integer ID;
	private Object obj;
	private Task task;
	private Timer timer;
	private HashMap taskMap;
	private HashMap<Integer, Task[]> tasks = new HashMap<Integer, Task[]>();
	private HashMap<Integer, ArrayList> innerTasks = new HashMap<Integer, ArrayList>();
	private HashMap<Integer, Object[]> map;
	private ArrayList<String[]> step, attemp;
			
	private Calendar now = Calendar.getInstance();
	private String[] oneAttemp;
	private int intervalCode;
	private Date endDate;
	private boolean runable, loadSuccessful = false;
	private String managerMail, ccMail;
	private SAXReader reader;
	private String errorMsg = "";
	private LogParser parser;
	private int runType = 0;
	
	private void setRunType(int runType) {
		this.runType = runType;
	}

	public LogParser getParser() {
		return parser;
	}

	public String getManagerMail() {
		return managerMail;
	}

	public void setRunable(boolean runable) {
		this.runable = runable;
	}

	public void setOneAttemp(String[] oneAttemp) {
		this.oneAttemp = oneAttemp;
	}

	public HashMap<Integer, Task[]> getTasks() {
		return tasks;
	}
	public void setTasks(HashMap<Integer, Task[]> tasks) {
		this.tasks = tasks;
	}
	public Task getTask() {
		return task;
	}
	public void setTask(Task task) {
		this.task = task;
	}
	public Integer getID() {
		return ID;
	}
	public void setID(Integer id) {
		ID = id;
	}

	public HashMap getTaskMap() {
		return taskMap;
	}

	public void setTaskMap(HashMap taskMap) {
		this.taskMap = taskMap;
	}

	public TaskDialog getTaskDialog() {
		return taskDialog;
	}

	public void setTaskDialog(TaskDialog taskDialog) {
		this.taskDialog = taskDialog;
	}

	public MainFrame getMainFrame() {
		return mainFrame;
	}

	public void setMainFrame(MainFrame mainFrame) {
		this.mainFrame = mainFrame;
	}

	public JFileChooser getFileChooser() {
		return fileChooser;
	}

	public void setLoadSuccessful(boolean loadSuccessful) {
		this.loadSuccessful = loadSuccessful;
	}

	public boolean isLoadSuccessful() {
		return loadSuccessful;
	}
}