Socket 監控服務器運行狀態

想使用socket寫一個跨服務器通信的監控小軟件，用於收集服務器信息，雛形如下

服務端類

package test.serv;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Calendar;
import java.util.Date;
import java.util.regex.Pattern;

public class Server {

    public static void main(String[] args) {
        
        // 啟動3000端口
        int argnum = args.length;
        if (argnum < 2) {
            System.out.println("請輸入IP地址、端口，比如：172.17.201.127 3000");
            return;
        }
        String ipaddr = getIP(args[0]);
        int port = Integer.valueOf(args[1]);
        startService(ipaddr,port);
        /*
        startService("10.168.150.107",3000);
        */
    }    
        
    /**     * 開啟3000端口
     */
    public static void startService(String ipaddr,int port){
        ServerSocket server;
        BufferedReader br = null;
        try{
            server = new ServerSocket();
            server.setReuseAddress(true);
            server.bind(new InetSocketAddress(ipaddr,port));
            Socket sk = null;
            String context = "---服務器端開始接收消息-----";
            String filePath = "./log/"+getlognamebyweek();
            boolean isAppend = true;
            String encoding = "UTF-8";
            while(true){
                sk = server.accept();
                context="<-------服務器端開始接收消息----------->\n\r";
                writeStringToFile(context, filePath, isAppend, encoding);
                br = new BufferedReader(
                        new InputStreamReader(sk.getInputStream()));
                context=br.readLine();
                writeStringToFile(context, filePath, isAppend, encoding);
                br.close();
                context="\n\r<-------服務器端結束接收消息----------->\n\r";
                writeStringToFile(context, filePath, isAppend, encoding);
            }
            
            
        }catch(IOException e){
            System.out.println(e);
        }finally{
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    // TODO 自動生成的 catch 塊
                    e.printStackTrace();
                }
            }
        }
    }
    
    public static void writeStringToFile(String context, String filePath, boolean isAppend, String encoding)
      {
        BufferedWriter bfw = null;
        try {
          bfw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filePath, isAppend), encoding));
          bfw.write(context);
          bfw.flush();
          bfw.close();
        }
        catch (IOException localIOException1)
        {
          try
          {
            if (bfw != null)
              bfw.close();
          }
          catch (IOException e)
          {
            e.printStackTrace();
          }
        }
        finally
        {
          try
          {
            if (bfw != null)
              bfw.close();
          }
          catch (IOException e)
          {
            e.printStackTrace();
          }
        }
      }
    
    /**
     * 將主機名解析為IP
     * @param name
     * @return
     */
    public static String getIP(String name) {
        String pattern = "^[0-9]+.[0-9]+.[0-9]+.[0-9]+$";
        boolean isIP = Pattern.matches(pattern, name);
        if (isIP) {
            return name;
        }
        InetAddress address = null;
        try {
            address = InetAddress.getByName(name);
        } catch (UnknownHostException e) {
            e.printStackTrace();
            System.out.println("獲取失敗");
        }
        return address.getHostAddress().toString();
    }
    
    /**
     * 周一至周日每天一個日志
     * @return
     */
    public static String getlognamebyweek(){
          
          Date date=new Date();
          Calendar c=Calendar.getInstance();
          c.setTime(date);
          //今天是這個星期的第幾天
          int week=c.get(Calendar.DAY_OF_WEEK)-1;
          return week+".log";
      }
}

 

客戶端類

package test.serv;

import java.io.IOException;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.regex.Pattern;

public class Client {
    public static void main(String args[]){
        // 啟動3000端口
        int argnum = args.length;
        if (argnum != 3) {
            System.out.println("請輸入IP地址、端口，比如：172.17.201.127 3000 msg");
            return;
        }
        
        String ipaddr = getIP(args[0]);
        int port = Integer.valueOf(args[1]);
        String msg = args[2];
        
        Socket client;
        PrintStream ps;
        try{
            client = new Socket(ipaddr,port);
            System.out.println("客戶端連接成功");
            ps = new PrintStream(client.getOutputStream());
            ps.println(msg);
            ps.close();
            client.close();
        }catch(IOException e){
            System.out.println();
        }
    }
    
    /**
     * 將主機名解析為IP
     * @param name
     * @return
     */
    public static String getIP(String name) {
        String pattern = "^[0-9]+.[0-9]+.[0-9]+.[0-9]+$";
        boolean isIP = Pattern.matches(pattern, name);
        if (isIP) {
            return name;
        }
        InetAddress address = null;
        try {
            address = InetAddress.getByName(name);
        } catch (UnknownHostException e) {
            e.printStackTrace();
            System.out.println("獲取失敗");
        }
        return address.getHostAddress().toString();
    }
}

測試

將編程后的.class類上傳到服務器上

在被監控機上執行

[root@a12cdg1 scripts]# java test/serv/Server a12cdg1 3000

在監控機上執行

[root@a12csh4 scripts]# java test/serv/Client a12cdg1 3000 "磁盤使用率50%"
客戶端連接成功

查看日志輸出

[root@a12cdg1 log]# tailf 1.log

<-------服務器端開始接收消息----------->
磁盤使用率50%
<-------服務器端結束接收消息----------->

用於內部監控，網絡不出內網，且限定了IP，安全上也沒問題，這樣兩個服務器上就建立了基於TCP/IP的通信渠道，具體的監控內容計划使用python書寫，然后以json方式返回給Java Socket。