144 lines
3.3 KiB
Ruby
Executable File
144 lines
3.3 KiB
Ruby
Executable File
#!/usr/bin/env ruby
|
|
|
|
require "socket"
|
|
require "fileutils"
|
|
require "json"
|
|
|
|
SOCKET_PATH = "/run/malpd/malpd.sock"
|
|
|
|
def human_capacity(bytes)
|
|
units = ["B", "KB", "MB", "GB", "TB", "PB"]
|
|
i = 0
|
|
size = bytes.to_f
|
|
while size >= 1000 && i < units.length - 1
|
|
size /= 1000
|
|
i += 1
|
|
end
|
|
precision = i <= 3 ? 0 : 1
|
|
"%g %s" % [size.round(precision), units[i]]
|
|
end
|
|
|
|
def drive_type(name)
|
|
return "nvme" if name.start_with?("nvme")
|
|
rotational = File.read("/sys/block/#{name}/queue/rotational").strip
|
|
rotational == "1" ? "hdd" : "ssd"
|
|
end
|
|
|
|
def read_smart(name)
|
|
out = `smartctl -j -A -H /dev/#{name} 2>/dev/null`
|
|
return nil if out.empty?
|
|
data = JSON.parse(out) rescue nil
|
|
return nil unless data
|
|
|
|
result = {}
|
|
passed = data.dig("smart_status", "passed")
|
|
result["passed"] = passed unless passed.nil?
|
|
|
|
if (t = data.dig("temperature", "current"))
|
|
result["temperature"] = t
|
|
end
|
|
if (poh = data.dig("power_on_time", "hours"))
|
|
result["power_on_hours"] = poh
|
|
end
|
|
|
|
if name.start_with?("nvme")
|
|
log = data["nvme_smart_health_information_log"] || {}
|
|
result["percentage_used"] = log["percentage_used"] if log.key?("percentage_used")
|
|
result["media_errors"] = log["media_errors"] if log.key?("media_errors")
|
|
result["critical_warning"] = log["critical_warning"] if log.key?("critical_warning")
|
|
else
|
|
attrs = data.dig("ata_smart_attributes", "table") || []
|
|
attrs.each do |a|
|
|
raw = a.dig("raw", "value")
|
|
next if raw.nil?
|
|
case a["id"]
|
|
when 5 then result["reallocated_sectors"] = raw
|
|
when 10 then result["spin_retry"] = raw
|
|
when 197 then result["pending_sectors"] = raw
|
|
when 199 then result["crc_errors"] = raw
|
|
end
|
|
end
|
|
end
|
|
|
|
result
|
|
end
|
|
|
|
def handle_info(conn)
|
|
info = []
|
|
|
|
Dir.glob("/sys/block/*").each do |block_path|
|
|
name = File.basename(block_path)
|
|
next unless name.match?(/^(sd[a-z]+|nvme\d+n\d+)$/)
|
|
|
|
device_path = File.realpath("#{block_path}/device") rescue next
|
|
next if device_path.include?("/usb")
|
|
|
|
model = (File.read("#{block_path}/device/model").strip rescue "Unknown")
|
|
bytes = File.read("#{block_path}/size").strip.to_i * 512
|
|
|
|
entry = {
|
|
"type" => "drive",
|
|
"drivetype" => drive_type(name),
|
|
"name" => name,
|
|
"model" => model,
|
|
"capacity" => human_capacity(bytes)
|
|
}
|
|
if (smart = read_smart(name))
|
|
entry["smart"] = smart
|
|
end
|
|
info << entry
|
|
end
|
|
|
|
if conn
|
|
conn.puts JSON.generate(info)
|
|
else
|
|
puts JSON.pretty_generate(info)
|
|
end
|
|
end
|
|
|
|
if ARGV.include?("-t")
|
|
handle_info(nil)
|
|
exit
|
|
end
|
|
|
|
if Process.uid != 0
|
|
$stderr.puts "malpd must be run as root"
|
|
exit(1)
|
|
end
|
|
|
|
if ENV["LISTEN_FDS"]
|
|
server = UNIXServer.for_fd(3)
|
|
else
|
|
FileUtils.mkdir_p(File.dirname(SOCKET_PATH))
|
|
FileUtils.rm_f(SOCKET_PATH)
|
|
|
|
server = UNIXServer.new(SOCKET_PATH)
|
|
File.chmod(0660, SOCKET_PATH)
|
|
FileUtils.chown(nil, "apache", SOCKET_PATH)
|
|
end
|
|
|
|
Signal.trap("TERM") { server.close }
|
|
Signal.trap("INT") { server.close }
|
|
|
|
loop do
|
|
conn = server.accept
|
|
request = conn.gets&.chomp
|
|
|
|
begin
|
|
case request
|
|
when nil
|
|
# empty request
|
|
when "info"
|
|
handle_info(conn)
|
|
else
|
|
conn.puts "unknown request: #{request}"
|
|
end
|
|
rescue => e
|
|
$stderr.puts "error handling request: #{e.message}"
|
|
ensure
|
|
conn.close
|
|
end
|
|
rescue IOError
|
|
break
|
|
end
|