java linux machine_java 收集linux信息

public class MachineCollector

implements Runnable

{

private static int DEFAULT_INTERVAL = 30;

private boolean isStopped = false;

private RandomAccessFile procNetDevReader;

private RandomAccessFile procMemInfoReader;

private RandomAccessFile procLoadAvgReader;

private RandomAccessFile procStatReader;

private RandomAccessFile procCpuInfoReader;

private static final Map memInterestKey = new HashMap();

private static final String[] cpuIndexName = { "cpu-place-holder", "cpu_user", "cpu_nice", "cpu_system", "cpu_idle", "cpu_iowait", "cpu_irq", "cpu_softirq", "cpu_steal", "cpu_guest", "cpu_guest_nice" };

private static final Map cpuPreInfo = new HashMap();

private static boolean cpuPreInfoEmpty = true;

private static final Logger logger = Logger.getLogger(MachineCollector.class);

private static MachineCollector instance = new MachineCollector();

static

{

memInterestKey.put("MemTotal", "mem_total");

memInterestKey.put("MemFree", "mem_free");

memInterestKey.put("Buffers", "mem_buffer");

memInterestKey.put("Cached", "mem_cached");

memInterestKey.put("SwapCached", "swap_cached");

memInterestKey.put("SwapTotal", "swap_total");

memInterestKey.put("SwapFree", "swap_free");

}

public static MachineCollector getInstance()

{

return instance;

}

private MachineCollector()

{

try

{

this.procNetDevReader = new RandomAccessFile("/proc/net/dev", "r");

this.procMemInfoReader = new RandomAccessFile("/proc/meminfo", "r");

this.procLoadAvgReader = new RandomAccessFile("/proc/loadavg", "r");

this.procStatReader = new RandomAccessFile("/proc/stat", "r");

this.procCpuInfoReader = new RandomAccessFile("/proc/cpuinfo", "r");

}

catch (FileNotFoundException e)

{

logger.error("No such file, Is /proc mounted?", e);

}

}

public void start()

{

if (this.isStopped) {

return;

}

new Thread(this).start();

}

public void run()

{

this.isStopped = false;

while (!this.isStopped)

{

Map info = getInfoFromProcFile();

sendInfoByJson(info);

try

{

Thread.sleep(DEFAULT_INTERVAL * 1000);

}

catch (InterruptedException e)

{

e.printStackTrace();

}

}

}

public void stop()

{

this.isStopped = true;

}

private Map getInfoFromProcFile()

{

Map info = new HashMap();

readMemUsage(info);

readSysOverload(info);

readCpuUsage(info);

readDiskUsage(info);

readCpuInfo(info);

readNetTraffic(info);

return info;

}

private void readMemUsage(Map info)

{

String line = null;

try

{

int keysNotRead = memInterestKey.size();

this.procMemInfoReader.seek(0L);

while (((line = this.procMemInfoReader.readLine()) != null) && (keysNotRead != 0))

{

int sepIndex = line.indexOf(":");

String key = line.substring(0, sepIndex);

if (memInterestKey.containsKey(key))

{

info.put(memInterestKey.get(key), line.substring(sepIndex + 1, line.length() - 2).trim());

keysNotRead--;

}

}

}

catch (Exception e)

{

logger.error("read /proc/meminfo error", e);

}

}

private void readSysOverload(Map info)

{

String line = null;

String[] terms = null;

try

{

this.procLoadAvgReader.seek(0L);

line = this.procLoadAvgReader.readLine();

terms = line.trim().split("\\s+");

info.put("load_avg1", terms[0]);

info.put("load_avg5", terms[1]);

info.put("load_avg15", terms[2]);

}

catch (Exception e)

{

logger.error("read /proc/loadavg error", e);

}

}

private void readCpuUsage(Map info)

{

String line = null;

String[] terms = null;

try

{

this.procStatReader.seek(0L);

line = this.procStatReader.readLine();

if (!line.startsWith("cpu")) {

return;

}

Long total_p = Long.valueOf(0L);

Long total_n = Long.valueOf(0L);

if (!cpuPreInfoEmpty) {

for (Map.Entry et : cpuPreInfo.entrySet()) {

total_p = Long.valueOf(total_p.longValue() + ((Long)et.getValue()).longValue());

}

}

Map cpuNowInfo = new HashMap();

terms = line.split("\\s+");

for (int i = 1; i < terms.length; i++)

{

long ticks = Long.parseLong(terms[i]);

total_n = Long.valueOf(total_n.longValue() + ticks);

cpuNowInfo.put(cpuIndexName[i], Long.valueOf(ticks));

}

Long total_dif;

if (cpuPreInfoEmpty)

{

cpuPreInfoEmpty = false;

}

else

{

total_dif = Long.valueOf(total_n.longValue() - total_p.longValue());

for (Map.Entry et : cpuNowInfo.entrySet())

{

Long cpu_p = (Long)cpuPreInfo.get(et.getKey());

Long cpu_n = (Long)cpuNowInfo.get(et.getKey());

double cpu = (cpu_n.longValue() - cpu_p.longValue()) / total_dif.longValue() * 100.0D;

info.put(et.getKey(), Double.valueOf(cpu));

}

}

for (Map.Entry et : cpuNowInfo.entrySet()) {

cpuPreInfo.put(et.getKey(), et.getValue());

}

}

catch (Exception e)

{

logger.error("read /proc/stat error", e);

}

}

private void readCpuInfo(Map info)

{

String line = null;

try

{

this.procCpuInfoReader.seek(0L);

int cpuCoreNum = 0;

while ((line = this.procCpuInfoReader.readLine()) != null) {

if (line.startsWith("processor")) {

cpuCoreNum++;

}

}

info.put("cpu_core", Integer.valueOf(cpuCoreNum));

}

catch (Exception e)

{

logger.error("read /proc/cpuinfo error", e);

}

}

private void readDiskUsage(Map info)

{

File fsroot = new File("/");

long disk_total = fsroot.getTotalSpace() >> 20;

long disk_free = fsroot.getFreeSpace() >> 20;

long disk_usable = fsroot.getUsableSpace() >> 20;

info.put("disk_total", String.valueOf(disk_total));

info.put("disk_free", String.valueOf(disk_free));

info.put("disk_usable", String.valueOf(disk_usable));

}

private void readNetTraffic(Map info)

{

String line = null;

try

{

this.procNetDevReader.seek(0L);

this.procNetDevReader.readLine();

this.procNetDevReader.readLine();

List> netinfos = new ArrayList();

while ((line = this.procNetDevReader.readLine()) != null)

{

line = line.trim();

int sep = line.indexOf(':');

String dev = line.substring(0, sep);

String rline = line.substring(sep + 1);

if ((!dev.equals("lo")) && (!dev.startsWith("sit")))

{

Map netinfo = new HashMap();

String[] terms = rline.trim().split("\\s+");

netinfo.put("dev_name", dev);

netinfo.put("rx_bytes", terms[0]);

netinfo.put("rx_packets", terms[1]);

netinfo.put("tx_bytes", terms[8]);

netinfo.put("tx_packets", terms[9]);

netinfos.add(netinfo);

}

}

info.put("net_devs", netinfos);

}

catch (Exception e)

{

logger.error("read /proc/net/dev error", e);

}

}

private void sendInfoByJson(Map info)

{

if (info.containsKey("cpu_user"))

{

String json = JSON.toJSONString(info);

try

{

Message message = new Message();

message.setBody(json.getBytes(Charset.forName("UTF-8")));

message.setCollectcode(Message.COLLECT_CODE.COLLECT_MACHINE);

message.setBusinesscode(Message.SUB_COLLECT_CODE.SC_MAC_DEF);

message.setIp(MonitorModule.ipn);

message.setTimestamp(new Date().getTime());

message.setBiz_name("".getBytes(Charset.forName("UTF-8")));

message.setBiz_name_s(0);

message.setTotalLen(message.getBody().length + 24);

Sender.send(message);

}

catch (Exception e)

{

logger.error("get local ip as int", e);

}

}

}

@Deprecated

public static Map getInfobyExec()

{

result = new HashMap();

InputStream is = null;

InputStreamReader isr = null;

BufferedReader brStat = null;

Process process = null;

try

{

process = Runtime.getRuntime().exec("top -b -n 1");

is = process.getInputStream();

isr = new InputStreamReader(is, Charset.forName("UTF-8"));

brStat = new BufferedReader(isr);

String tem = brStat.readLine();

String[] terms = tem.trim().split("[,:]{1}");

String loadaverage1 = terms[(terms.length - 3)];

String loadaverage5 = terms[(terms.length - 2)];

String loadaverage15 = terms[(terms.length - 1)];

result.put("load_avg1", new Double(loadaverage1));

result.put("load_avg5", new Double(loadaverage5));

result.put("load_avg15", new Double(loadaverage15));

tem = brStat.readLine();

terms = tem.trim().split("[,:]{1}");

String total_task = terms[1].trim().split(" ")[0];

String runnung_task = terms[2].trim().split(" ")[0];

String sleeping_task = terms[3].trim().split(" ")[0];

String stopped_task = terms[4].trim().split(" ")[0];

String zombie_task = terms[5].trim().split(" ")[0];

result.put("total_task", new Integer(total_task));

result.put("runnung_task", new Integer(runnung_task));

result.put("sleeping_task", new Integer(sleeping_task));

result.put("stopped_task", new Integer(stopped_task));

result.put("zombie_task", new Integer(zombie_task));

tem = brStat.readLine();

terms = tem.trim().split("[,:]{1}");

String cpu_us = terms[1].split("%")[0];

String cpu_id = terms[4].split("%")[0];

result.put("cpu_us", new Double(cpu_us));

result.put("cpu_idle", new Double(cpu_id));

tem = brStat.readLine();

terms = tem.trim().split("[,:]{1}");

String mem_total = terms[1].trim().split(" ")[0].replace("k", "");

String mem_used = terms[2].trim().split(" ")[0].replace("k", "");

String mem_free = terms[3].trim().split(" ")[0].replace("k", "");

result.put("mem_total", new Long(mem_total));

result.put("mem_used", new Long(mem_used));

result.put("mem_free", new Long(mem_free));

tem = brStat.readLine();

terms = tem.trim().split("[,:]{1}");

String swap_total = terms[1].trim().split(" ")[0].replace("k", "");

String swap_used = terms[2].trim().split(" ")[0].replace("k", "");

String swap_free = terms[3].trim().split(" ")[0].replace("k", "");

result.put("swap_total", new Long(swap_total));

result.put("swap_used", new Long(swap_used));

result.put("swap_free", new Long(swap_free));

return result;

}

catch (Exception ex)

{

logger.error(ex.getMessage(), ex);

}

finally

{

try

{

if (is != null) {

is.close();

}

if (isr != null) {

isr.close();

}

if (brStat != null) {

brStat.close();

}

if (process != null)

{

try

{

process.waitFor();

}

catch (InterruptedException e)

{

e.printStackTrace();

}

process.destroy();

}

}

catch (IOException ex)

{

logger.error(ex.getMessage(), ex);

}

}

}

public static void setInterval(Integer interval)

{

DEFAULT_INTERVAL = interval.intValue();

}

}