monit-client 0.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 33aff1038adc96b78cf28aedeed2f7a5eb3be1f592479c37b3563403773bb14a
+  data.tar.gz: 320f5e8eb157b3678c70e7e945363738cebe4906ea7fcaed97f4cfa9ebf1c526
+SHA512:
+  metadata.gz: 5a649b7bd32fc219abbb05fc463d3bd9307acfe3fbc951f9b7551835dbfe72aa969c5684543881f25096973f018798c2290c69e55316d4577e1d8eaae4f4e8ab
+  data.tar.gz: facd6c2e66dfff0bb34f7516e43b273dda7b55f03dff65ceb6a29a62c61ed3bf83c5f4e707dbb5e0a1036377bccd84fb9cc5a6787e979ae095bec8606e090f0f

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+*.gem
+.bundle
+.yardoc
+doc/*
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,10 @@
+script: "bundle exec rake spec"
+language: ruby
+sudo: false
+rvm:
+  - 2.2
+  - 2.3
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in monit.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Matias Korhonen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+Monit Rubygem
+=============
+
+A Ruby interface for Monit.
+
+## Installation
+
+Just like any other gem:
+
+    gem install monit
+
+## Usage
+
+    status = Monit::Status.new({ :host => "monit.myserver.com",
+                                 :auth => true,
+                                 :username => "foo",
+                                 :password => "bar" })
+    status.get              # => true
+    status.platform         # => <Monit::Platform:0x00000003673dd0 ... >
+    status.platform.cpu     # => 2
+    status.platform.memory  # => 4057712
+
+    # => start/stop/restart/monitor/unmonitor
+    status.services.each do |service|
+      service.stop!
+    end
+
+For more options see the API documentation
+
+## Compatibility and Build Status
+
+[![Build Status](https://travis-ci.org/matiaskorhonen/monit.svg?branch=master)](https://travis-ci.org/matiaskorhonen/monit) [![Code Climate](https://codeclimate.com/github/matiaskorhonen/monit/badges/gpa.svg)](https://codeclimate.com/github/matiaskorhonen/monit)
+
+The gem is only compatible with Ruby 1.8.7 and above, including JRuby 1.6+.
+For the build status, check [Travis CI][travis].
+
+[travis]: http://travis-ci.org/k33l0r/monit
+
+## License and copyright
+
+Copyright © 2010 - 2013 Matias Korhonen & contributors
+
+Licensed under the MIT license, see the LICENSE file for details.

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/monit.rb

@@ -0,0 +1,6 @@
+require "monit/httpd"
+require "monit/platform"
+require "monit/server"
+require "monit/service"
+require "monit/status"
+require "monit/version"

data/lib/monit/httpd.rb

@@ -0,0 +1,12 @@
+module Monit
+  # The HTTPD section from the Monit XML
+  class HTTPD
+    attr_reader :address, :port, :ssl
+
+    def initialize(options = {})
+      @address = options["address"]
+      @port    = options["port"]
+      @ssl     = options["ssl"] == "1" ? true : false
+    end
+  end
+end

data/lib/monit/platform.rb

@@ -0,0 +1,15 @@
+module Monit
+  # The platform section from the Monit XML
+  class Platform
+    attr_reader :name, :release, :version, :machine, :cpu, :memory
+
+    def initialize(options = {})
+      @name = options["name"]
+      @release = options["release"]
+      @version = options["version"]
+      @machine = options["machine"]
+      @cpu = options["cpu"].to_i
+      @memory = options["memory"].to_i
+    end
+  end
+end

data/lib/monit/server.rb

@@ -0,0 +1,18 @@
+module Monit
+  # The server section from the Monit XML
+  class Server
+    attr_reader :id, :incarnation, :version, :uptime, :poll, :startdelay, :localhostname, :controlfile, :httpd
+
+    def initialize(options = {})
+      @id = options["id"]
+      @incarnation = options["incarnation"]
+      @version = options["version"]
+      @uptime = options["uptime"].to_i
+      @poll = options["poll"].to_i
+      @startdelay = options["startdelay"].to_i
+      @localhostname = options["localhostname"]
+      @controlfile = options["controlfile"]
+      @httpd = options["httpd"].is_a?(HTTPD) ? options["httpd"] : HTTPD.new(options["httpd"])
+    end
+  end
+end

data/lib/monit/service.rb

@@ -0,0 +1,61 @@
+require "ostruct"
+module Monit
+  # The service section from the Monit XML. Inherits from OpenStruct.
+  class Service < OpenStruct
+    TYPES = { 0 => "Filesystem", 1 => "Directory", 2 => "File", 3 => "Daemon", 4 => "Connection", 5 => "System" }
+
+    def initialize(hash = nil, options = {})
+      @host     ||= options[:host] || "localhost"
+      @port     ||= options[:port] || 2812
+      @ssl      ||= options[:ssl]  || false
+      @auth     ||= options[:auth] || false
+      @username = options[:username]
+      @password = options[:password]
+
+      hash = rename_service_type(hash) if hash
+      super(hash)
+    end
+
+    def url(path)
+      url_params = { :host => @host, :port => @port, :path => "/#{path}" }
+      @ssl ? URI::HTTPS.build(url_params) : URI::HTTP.build(url_params)
+    end
+
+    [:start, :stop, :restart, :monitor, :unmonitor].each do |action|
+      define_method "#{action}!" do
+        self.do action
+      end
+    end
+
+    def do(action)
+      uri = self.url self.name
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      if @ssl
+        http.use_ssl     = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      request      = Net::HTTP::Post.new(uri.request_uri)
+      request.body = "action=#{action}"
+
+      request.basic_auth(@username, @password) if @auth
+      request["User-Agent"] = "Monit Ruby client #{Monit::VERSION}"
+
+      begin
+        response = http.request(request)
+        !!(response.code =~ /\A2\d\d\z/)
+      rescue Errno::ECONNREFUSED => e
+        false
+      end
+    end
+
+    private
+    # Renames the Service type from "type" to "service_type" to avoid conflicts
+    def rename_service_type(hash)
+      hash["service_type"] = hash["type"]
+      hash.delete("type")
+      hash
+    end
+  end
+end

data/lib/monit/status.rb

@@ -0,0 +1,104 @@
+#require "crack/xml"
+require "active_support/json"
+require "active_support/xml_mini"
+require "active_support/core_ext/hash/conversions"
+require "net/http"
+require "net/https"
+require "uri"
+
+# A Ruby interface for Monit
+module Monit
+  # The +Status+ class is used to get data from the Monit instance. You should not
+  # need to manually instantiate any of the other classes.
+  class Status
+    ::ActiveSupport::XmlMini.backend = "Nokogiri"
+
+    attr_reader :url, :hash, :xml, :server, :platform, :services
+    attr_accessor :username, :auth, :host, :port, :ssl, :auth, :username
+    attr_writer :password
+
+    # Create a new instance of the status class with the given options
+    #
+    # <b>Options:</b>
+    # * +host+ - the host for monit, defaults to +localhost+
+    # * +port+ - the Monit port, defaults to +2812+
+    # * +ssl+ - should we use SSL for the connection to Monit (default: false)
+    # * +auth+ - should authentication be used, defaults to false
+    # * +username+ - username for authentication
+    # * +password+ - password for authentication
+    def initialize(options = {})
+      @host     = options[:host]    || "localhost"
+      @port     = (options[:port]   || 2812).to_i
+      @ssl      = options[:ssl]     || false
+      @auth     = options[:auth]    || false
+      @username = options[:username]
+      @password = options[:password]
+      @services = []
+    end
+
+    # Construct the URL
+    def url
+      url_params = { :host => @host, :port => @port, :path => "/_status", :query => "format=xml" }
+      @ssl ? URI::HTTPS.build(url_params) : URI::HTTP.build(url_params)
+    end
+
+    # Get the status from Monit.
+    def get
+      uri = self.url
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      if @ssl
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      request = Net::HTTP::Get.new(uri.request_uri)
+
+      if @auth
+        request.basic_auth(@username, @password)
+      end
+
+      request["User-Agent"] = "Monit Ruby client #{Monit::VERSION}"
+
+      begin
+        response = http.request(request)
+      rescue Errno::ECONNREFUSED
+        return false
+      end
+
+      if (response.code =~ /\A2\d\d\z/)
+        @xml = response.body
+        return self.parse(@xml)
+      else
+        return false
+      end
+    end
+
+    # Parse the XML from Monit into a hash and into a Ruby representation.
+    def parse(xml)
+      @hash     = Hash.from_xml(xml)
+      @server   = Server.new(@hash["monit"]["server"])
+      @platform = Platform.new(@hash["monit"]["platform"])
+
+      options = {
+        :host     => @host,
+        :port     => @port,
+        :ssl      => @ssl,
+        :auth     => @auth,
+        :username => @username,
+        :password => @password
+      }
+
+      if @hash["monit"]["service"].is_a? Array
+        @services = @hash["monit"]["service"].map do |service|
+          Service.new(service, options)
+        end
+      else
+        @services = [Service.new(@hash["monit"]["service"], options)]
+      end
+      true
+    rescue
+      false
+    end
+  end
+end

data/lib/monit/version.rb

@@ -0,0 +1,3 @@
+module Monit
+  VERSION = "0.3.2"
+end

data/monit.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.expand_path("../lib", __FILE__)
+require "monit/version"
+
+Gem::Specification.new do |gem|
+  gem.authors     = ["Julien Chabanon"]
+  gem.email       = ["julien@chabanon.me"]
+  gem.homepage    = "https://github.com/modulis/monit"
+  gem.summary     = "Connect to Monit"
+  gem.description = "Retrieve server information from Monit."
+  gem.license     = 'MIT'
+
+  gem.name          = "monit-client"
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+  gem.version       = Monit::VERSION
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "bundler"
+  gem.add_development_dependency "rspec", "~> 2.9.0"
+  gem.add_development_dependency "webmock", "~> 1.11.0"
+
+  #gem.add_runtime_dependency "nokogiri", "~> 1.5"
+  #gem.add_runtime_dependency "activesupport", ">= 3.2.22.5"
+end

data/spec/monit_spec.rb

@@ -0,0 +1,224 @@
+# -*- encoding: utf-8 -*-
+require "spec_helper"
+
+SMALLISH_STATUS_PATH  = File.expand_path("../samples/smallish_status.xml", __FILE__)
+LARGISH_STATUS_PATH   = File.expand_path("../samples/largish_status.xml", __FILE__)
+
+describe Monit do
+  describe "Status" do
+    it "should be possible to instatiate it with no options" do
+      @status = Monit::Status.new
+      @status.should be_kind_of Monit::Status
+      @status.host.should == "localhost"
+      @status.port.should == 2812
+      @status.ssl.should be_false
+      @status.auth.should be_false
+      @status.username.should be_nil
+      lambda { @status.password }.should raise_error(NoMethodError)
+      @status.services.should == []
+    end
+
+    it "should generate the correct URL" do
+      @status = Monit::Status.new
+      @status.url.should be_kind_of URI
+      @status.url.to_s.should == "http://localhost:2812/_status?format=xml"
+      @status.ssl = true
+      @status.url.to_s.should == "https://localhost:2812/_status?format=xml"
+      @status.host = "rails.fi"
+      @status.url.to_s.should == "https://rails.fi:2812/_status?format=xml"
+      @status.port = 8080
+      @status.url.to_s.should == "https://rails.fi:8080/_status?format=xml"
+    end
+
+    it "should parse XML into a Hash" do
+      status = Monit::Status.new
+      status.stub!(:xml).and_return(File.read(SMALLISH_STATUS_PATH))
+      status.parse(status.xml)
+      status.hash.should be_kind_of Hash
+      status.hash["monit"].should_not be_nil
+      status.hash["monit"]["server"].should_not be_nil
+      status.hash["monit"]["platform"].should_not be_nil
+      status.hash["monit"]["service"].should_not be_nil
+
+      status.stub!(:xml).and_return(File.read(LARGISH_STATUS_PATH))
+      status.parse(status.xml)
+      status.hash.should be_kind_of Hash
+      status.hash["monit"].should_not be_nil
+      status.hash["monit"]["server"].should_not be_nil
+      status.hash["monit"]["platform"].should_not be_nil
+      status.hash["monit"]["service"].should_not be_nil
+    end
+
+    it "should parse XML into a Ruby representation" do
+      status = Monit::Status.new
+      status.stub!(:xml).and_return(File.read(SMALLISH_STATUS_PATH))
+      status.parse(status.xml)
+
+      status.server.should be_kind_of Monit::Server
+      status.server.httpd.should be_kind_of Monit::HTTPD
+      status.platform.should be_kind_of Monit::Platform
+      status.services.should be_kind_of Array
+      status.services.first.should be_kind_of Monit::Service
+      status.services.first.should be_kind_of OpenStruct
+
+      status.stub!(:xml).and_return(File.read(LARGISH_STATUS_PATH))
+      status.parse(status.xml)
+
+      status.server.should be_kind_of Monit::Server
+      status.server.httpd.should be_kind_of Monit::HTTPD
+      status.platform.should be_kind_of Monit::Platform
+      status.services.should be_kind_of Array
+      status.services.first.should be_kind_of Monit::Service
+      status.services.first.should be_kind_of OpenStruct
+    end
+  end
+
+  describe "Server" do
+    it "should create a new instance of Monit::Server from a hash" do
+      hash = {         "id" => "52255a0b8999c46c98de9697a8daef67",
+        "incarnation" => "1283946152",
+        "version" => "5.1.1",
+        "uptime" => "4",
+        "poll" => "30",
+        "startdelay" => "0",
+        "localhostname" => "Example.local",
+        "controlfile" => "/etc/monitrc",
+        "httpd" => { "address" => nil,
+          "port" => "2812",
+          "ssl" => "0" } }
+      server = Monit::Server.new(hash)
+      server.id.should == "52255a0b8999c46c98de9697a8daef67"
+      server.incarnation.should == "1283946152"
+      server.version.should == "5.1.1"
+      server.uptime.should == 4
+      server.poll.should == 30
+      server.startdelay.should == 0
+      server.localhostname.should == "Example.local"
+      server.controlfile.should == "/etc/monitrc"
+      server.httpd.should be_kind_of Monit::HTTPD
+    end
+  end
+
+  describe "HTTPD" do
+    it "should create a new instance of Monit::HTTPD from a hash" do
+      hash = { "address" => nil,
+        "port" => 2812,
+        "ssl" => "0" }
+      httpd = Monit::HTTPD.new(hash)
+      httpd.address.should be_nil
+      httpd.port.should == 2812
+      httpd.ssl.should be_false
+    end
+  end
+
+  describe "Platform" do
+    it "should create a new instance of Monit::Platform from a hash" do
+      hash = { "name" => "Darwin",
+        "release" => "10.4.0",
+        "version" => "Darwin Kernel Version 10.4.0: Fri Apr 23 18:28:53 PDT 2010; root:xnu-1504.7.4~1/RELEASE_I386",
+        "machine" => "i386",
+        "cpu" => "2",
+        "memory" => "4194304" }
+      platform = Monit::Platform.new(hash)
+      platform.name.should == "Darwin"
+      platform.release.should == "10.4.0"
+      platform.version.should == "Darwin Kernel Version 10.4.0: Fri Apr 23 18:28:53 PDT 2010; root:xnu-1504.7.4~1/RELEASE_I386"
+      platform.machine.should == "i386"
+      platform.cpu.should == 2
+      platform.memory.should == 4194304
+    end
+  end
+
+  describe "Service" do
+    let(:service) do
+      hash = { "collected_sec" => "1283946152",
+        "collected_usec" => "309973",
+        "name" => "Example.local",
+        "status" => "0",
+        "status_hint" => "0",
+        "monitor" => "1",
+        "monitormode" => "0",
+        "pendingaction" => "0",
+        "groups" => { "name" => "server" },
+        "system" => { "load" => { "avg01" => "0.28",
+          "avg05" => "0.43",
+          "avg15" => "0.48" },
+          "cpu" => {   "user" => "10.0",
+            "system" => "4.1" },
+            "memory" => { "percent" => "44.1",
+              "kilobyte" => "1850152" }
+      },
+        "type" => "5" }
+      Monit::Service.new(hash) 
+    end
+
+    it "should create a new instance of Monit::Platform from a hash" do
+      service.should be_kind_of OpenStruct
+      service.should be_kind_of Monit::Service
+      service.collected_sec.should == "1283946152"
+      service.collected_usec.should == "309973"
+      service.name.should == "Example.local"
+      service.status.should == "0"
+      service.status_hint.should == "0"
+      service.monitor.should == "1"
+      service.monitormode.should == "0"
+      service.pendingaction.should == "0"
+      service.groups.should be_kind_of Hash
+      service.system.should be_kind_of Hash
+      service.service_type.should == "5"
+    end
+
+    describe "#start!" do
+      it "sends :start to #do" do
+        service.stub(:do).with(:start)
+        service.start!
+      end
+    end
+
+    describe "#stop!" do
+      it "sends :stop to #do" do
+        service.stub(:do).with(:stop)
+        service.stop!
+      end
+    end
+
+    describe "#restart!" do
+      it "sends :restart to #do" do
+        service.stub(:do).with(:restart)
+        service.restart!
+      end
+    end
+
+    describe "#monitor!" do
+      it "sends :monitor to #do" do
+        service.stub(:do).with(:monitor)
+        service.monitor!
+      end
+    end
+
+    describe "#unmonitor!" do
+      it "sends :unmonitor to #do" do
+        service.stub(:do).with(:unmonitor)
+        service.unmonitor!
+      end
+    end
+
+    describe "#do" do
+      it "returns true if the response code is 2xx" do
+        stub_request(:any, /localhost/).to_return(:status => 200)
+        service.do(:start).should == true
+        stub_request(:any, /localhost/).to_return(:status => 201)
+        service.do(:start).should == true
+      end
+
+      it "returns false if the response code is not 2xx" do
+        stub_request(:any, /localhost/).to_return(:status => 500)
+        service.do(:start).should == false
+        stub_request(:any, /localhost/).to_return(:status => 400)
+        service.do(:start).should == false
+        stub_request(:any, /localhost/).to_return(:status => 302)
+        service.do(:start).should == false
+      end
+    end
+  end
+end