| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.hadoop.contrib.failmon; |
| |
| import java.net.InetAddress; |
| import java.util.ArrayList; |
| import java.util.Calendar; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| /********************************************************** |
| * Objects of this class parse the output of smartmontools to |
| * gather information about the state of disks in the system. The |
| * smartmontools utility reads the S.M.A.R.T. attributes from |
| * the disk devices and reports them to the user. Note that since |
| * running smartctl requires superuser provileges, one should |
| * grand sudo privileges to the running user for the command smartctl |
| * (without a password). Alternatively, one can set up a cron job that |
| * periodically dumps the output of smartctl into a user-readable file. |
| * See the configuration file for details. |
| * |
| **********************************************************/ |
| |
| public class SMARTParser extends ShellParser { |
| |
| String[] devices; |
| |
| /** |
| * Constructs a SMARTParser and reads the list of disk |
| * devices to query |
| */ |
| public SMARTParser() { |
| super(); |
| String devicesStr = Environment.getProperty("disks.list"); |
| System.out.println("skato " + devicesStr); |
| if (devicesStr != null) |
| devices = devicesStr.split(",\\s*"); |
| } |
| |
| /** |
| * Reads and parses the output of smartctl for a specified disk and |
| * creates an appropriate EventRecord that holds the desirable |
| * information for it. Since the output of smartctl is different for |
| * different kinds of disks, we try to identify as many attributes as |
| * posssible for all known output formats. |
| * |
| * @param device the disk device name to query |
| * |
| * @return the EventRecord created |
| */ |
| public EventRecord query(String device) throws Exception { |
| String conf = Environment.getProperty("disks." + device + ".source"); |
| StringBuffer sb; |
| |
| if (conf == null) |
| sb = Environment.runCommand("sudo smartctl --all " + device); |
| else |
| sb = Environment.runCommand("cat " + conf); |
| |
| EventRecord retval = new EventRecord(InetAddress.getLocalHost() |
| .getCanonicalHostName(), InetAddress.getAllByName(InetAddress.getLocalHost() |
| .getHostName()), Calendar.getInstance(), "SMART", "Unknown", |
| (conf == null ? "sudo smartctl --all " + device : "file " + conf), "-"); |
| // IBM SCSI disks |
| retval.set("model", findPattern("Device\\s*:\\s*(.*)", sb.toString(), 1)); |
| retval.set("serial", findPattern("Serial\\s+Number\\s*:\\s*(.*)", sb |
| .toString(), 1)); |
| retval.set("firmware", findPattern("Firmware\\s+Version\\s*:\\s*(.*)", sb |
| .toString(), 1)); |
| retval.set("capacity", findPattern("User\\s+Capacity\\s*:\\s*(.*)", sb |
| .toString(), 1)); |
| retval.set("status", findPattern("SMART\\s*Health\\s*Status:\\s*(.*)", sb |
| .toString(), 1)); |
| retval.set("current_temperature", findPattern( |
| "Current\\s+Drive\\s+Temperature\\s*:\\s*(.*)", sb.toString(), 1)); |
| retval.set("trip_temperature", findPattern( |
| "Drive\\s+Trip\\s+Temperature\\s*:\\s*(.*)", sb.toString(), 1)); |
| retval.set("start_stop_count", findPattern( |
| "start\\s+stop\\s+count\\s*:\\s*(\\d*)", sb.toString(), 1)); |
| |
| String[] var = { "read", "write", "verify" }; |
| for (String s : var) { |
| retval.set(s + "_ecc_fast", findPattern(s + "\\s*:\\s*(\\d*)", sb |
| .toString(), 1)); |
| retval.set(s + "_ecc_delayed", findPattern(s |
| + "\\s*:\\s*(\\d+\\s+){1}(\\d+)", sb.toString(), 2)); |
| retval.set(s + "_rereads", findPattern( |
| s + "\\s*:\\s*(\\d+\\s+){2}(\\d+)", sb.toString(), 2)); |
| retval.set(s + "_GBs", findPattern(s |
| + "\\s*:\\s*(\\d+\\s+){5}(\\d+.?\\d*)", sb.toString(), 2)); |
| retval.set(s + "_uncorrected", |
| findPattern(s + "\\s*:\\s*(\\d+\\s+){5}(\\d+.?\\d*){1}\\s+(\\d+)", sb |
| .toString(), 3)); |
| } |
| |
| // Hitachi IDE, SATA |
| retval.set("model", findPattern("Device\\s*Model\\s*:\\s*(.*)", sb |
| .toString(), 1)); |
| retval.set("serial", findPattern("Serial\\s+number\\s*:\\s*(.*)", sb |
| .toString(), 1)); |
| retval.set("protocol", findPattern("Transport\\s+protocol\\s*:\\s*(.*)", sb |
| .toString(), 1)); |
| retval.set("status", "PASSED".equalsIgnoreCase(findPattern( |
| "test\\s*result\\s*:\\s*(.*)", sb.toString(), 1)) ? "OK" : "FAILED"); |
| |
| readColumns(retval, sb); |
| |
| return retval; |
| } |
| |
| /** |
| * Reads attributes in the following format: |
| * |
| * ID# ATTRIBUTE_NAME FLAG VALUE WORST THRESH TYPE UPDATED WHEN_FAILED RAW_VALUE |
| * 3 Spin_Up_Time 0x0027 180 177 063 Pre-fail Always - 10265 |
| * 4 Start_Stop_Count 0x0032 253 253 000 Old_age Always - 34 |
| * 5 Reallocated_Sector_Ct 0x0033 253 253 063 Pre-fail Always - 0 |
| * 6 Read_Channel_Margin 0x0001 253 253 100 Pre-fail Offline - 0 |
| * 7 Seek_Error_Rate 0x000a 253 252 000 Old_age Always - 0 |
| * 8 Seek_Time_Performance 0x0027 250 224 187 Pre-fail Always - 53894 |
| * 9 Power_On_Minutes 0x0032 210 210 000 Old_age Always - 878h+00m |
| * 10 Spin_Retry_Count 0x002b 253 252 157 Pre-fail Always - 0 |
| * 11 Calibration_Retry_Count 0x002b 253 252 223 Pre-fail Always - 0 |
| * 12 Power_Cycle_Count 0x0032 253 253 000 Old_age Always - 49 |
| * 192 PowerOff_Retract_Count 0x0032 253 253 000 Old_age Always - 0 |
| * 193 Load_Cycle_Count 0x0032 253 253 000 Old_age Always - 0 |
| * 194 Temperature_Celsius 0x0032 037 253 000 Old_age Always - 37 |
| * 195 Hardware_ECC_Recovered 0x000a 253 252 000 Old_age Always - 2645 |
| * |
| * This format is mostly found in IDE and SATA disks. |
| * |
| * @param er the EventRecord in which to store attributes found |
| * @param sb the StringBuffer with the text to parse |
| * |
| * @return the EventRecord in which new attributes are stored. |
| */ |
| private EventRecord readColumns(EventRecord er, StringBuffer sb) { |
| |
| Pattern pattern = Pattern.compile("^\\s{0,2}(\\d{1,3}\\s+.*)$", |
| Pattern.MULTILINE); |
| Matcher matcher = pattern.matcher(sb); |
| |
| while (matcher.find()) { |
| String[] tokens = matcher.group(1).split("\\s+"); |
| boolean failed = false; |
| // check if this attribute is a failed one |
| if (!tokens[8].equals("-")) |
| failed = true; |
| er.set(tokens[1].toLowerCase(), (failed ? "FAILED:" : "") + tokens[9]); |
| } |
| |
| return er; |
| } |
| |
| /** |
| * Invokes query() to do the parsing and handles parsing errors for |
| * each one of the disks specified in the configuration. |
| * |
| * @return an array of EventRecords that holds one element that represents |
| * the current state of the disk devices. |
| */ |
| public EventRecord[] monitor() { |
| ArrayList<EventRecord> recs = new ArrayList<EventRecord>(); |
| |
| for (String device : devices) { |
| try { |
| recs.add(query(device)); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| EventRecord[] T = new EventRecord[recs.size()]; |
| |
| return recs.toArray(T); |
| } |
| |
| /** |
| * Return a String with information about this class |
| * |
| * @return A String describing this class |
| */ |
| public String getInfo() { |
| String retval = "S.M.A.R.T. disk attributes parser for disks "; |
| for (String device : devices) |
| retval += device + " "; |
| return retval; |
| } |
| |
| } |
