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<String, String> 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<String, Long> 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<String, Object> info = getInfoFromProcFile();
sendInfoByJson(info);
try
{
Thread.sleep(DEFAULT_INTERVAL * 1000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
public void stop()
{
this.isStopped = true;
}
private Map<String, Object> getInfoFromProcFile()
{
Map<String, Object> info = new HashMap();
readMemUsage(info);
readSysOverload(info);
readCpuUsage(info);
readDiskUsage(info);
readCpuInfo(info);
readNetTraffic(info);
return info;
}
private void readMemUsage(Map<String, Object> 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<String, Object> 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<String, Object> 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<String, Long> et : cpuPreInfo.entrySet()) {
total_p = Long.valueOf(total_p.longValue() + ((Long)et.getValue()).longValue());
}
}
Map<String, Long> 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<String, Long> 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<String, Long> et : cpuNowInfo.entrySet()) {
cpuPreInfo.put(et.getKey(), et.getValue());
}
}
catch (Exception e)
{
logger.error("read /proc/stat error", e);
}
}
private void readCpuInfo(Map<String, Object> 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<String, Object> 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<String, Object> info)
{
String line = null;
try
{
this.procNetDevReader.seek(0L);
this.procNetDevReader.readLine();
this.procNetDevReader.readLine();
List<Map<String, String>> 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<String, String> 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<String, Object> 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<String, Number> 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();
}
}