slugly 0.0.2

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2012 Action Verb, LLC.
+
+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,84 @@
+Slugly
+======
+
+Proxy for Wormly.com's health monitoring to enable monitoring of machines that
+are behind firewalls or where you don't want to run Wormly's HTTP and PHP-based
+monitoring script. Requires only Ruby on the proxy server and nothing at all on
+the machines being monitored when the SSH-based back-end is used.
+
+
+Configuring Slugly
+==================
+
+Configuring Slugly is simple! Simply create a config.yaml like the example
+shown below. 
+
+Slugly needs to know where to listen for incoming HTTP requests. The `host`
+and `port` entries are for telling Slugly where it should be listening for
+Wormly.com's health monitoring polls.
+
+The `wormly_key` is your Wormly.com API key. This key is used for enabling and
+directing Wormly.com's Linux health monitoring polls to the Slugly URLs for 
+that host.
+
+Slugly serves up health information for each node according to the `nodes`
+entry in the configuration file. A node entry consists of:
+
+ * a `path` specifying the URL where this health monitoring information should
+   be found.
+ * an optional `wormly_id` for this node.
+ * a `provider` for gathering the health-related metadata
+ * and any `options` required by this provider.
+
+Specifying a valid `wormly_key` together with a `wormly_id` for a given node
+will cause Slugly to attempt to notify Wormly.com that health data is
+available at the corresponding Slugly URL. If either is omitted, invalid, or
+if the Wormly.com API call fails, Slugly will still host metadata for this
+node. However, Wormly may be unaware unless a successful API call is made by
+ other means.
+
+Currently, there are two providers available:
+ * the `HealthProvider` which provides metadata for the local machine.
+ * and the `SSHHealthProvider` which gathers health metadata from a remote
+   Linux machine by way of SSH.
+
+The `SSHHealthProvider` takes two additional options: the `hostname` of the 
+target machine and a `username` of a user on that machine. Slugly assumes that
+password-less SSH is configured between the user running Slugly and the host 
+identified by `hostname`.
+
+    host: publichostname.com
+    port: 8088
+    wormly_key: 1Xs3cr3tk3ys
+    nodes:
+      - path      : /ssh
+        wormly_id : 12345
+        provider  : SSHHealthProvider
+        options:
+          hostname: localhost
+          username: ubuntu
+      - path      : /local
+        wormly_id : 67890
+        provider  : HealthProvider
+
+Running Slugly
+==============
+
+It's just `slugly -c /path/to/myconfig.yaml`. What could be simpler than that?
+
+Notes on Security
+=================
+Slugly does not store passwords. Password-less SSH is required for use of the
+SSHHealthProvider.
+
+Slugly is a work in progress, and is not quite yet ready for use in a 
+production environment. In particular, the current version of Slugly has two
+security-related weaknesses:
+
+* The current version of Slugly does not have SSL enabled
+
+* Slugly does not require that the Wormly.com supplied password be present or 
+correct. As a result Slugly openly provides health related metadata to any and
+all who request it.
+
+

data/bin/slugly

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), %w{.. lib}))
+
+require 'optparse'
+require 'uri'
+require 'yaml'
+
+require 'slugly/server'
+require 'slugly/health_provider'
+require 'slugly/ssh_health_provider'
+require 'slugly/wormly_api'
+
+options_h = {}
+
+optparse = OptionParser.new do |options|
+  options.on('-c', '--config FILENAME', 'config file path') do |cfgfile|
+    options_h[:cfgfile] = cfgfile
+  end
+
+  options.on('-h', '--help', 'display this screen') do
+    puts options
+    exit
+  end
+end
+
+begin
+  optparse.parse!
+  required = [:cfgfile]
+  missing = required.select{ |param| options_h[param].nil? }
+  if not missing.empty?
+    puts "missing required options: #{missing.join(', ')}"
+    puts optparse
+    exit
+  end
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument
+  puts $!.to_s
+  puts optparse
+  exit
+end
+
+providers = {
+ 'HealthProvider'    => HealthProvider,
+ 'SSHHealthProvider' => SSHHealthProvider
+}
+
+config = YAML.load_file(options_h[:cfgfile])
+wormly_key = config['wormly_key']
+host  = config['host']
+port  = config['port']
+nodes = config['nodes']
+
+wormly_url_list = []
+
+routes = {}
+nodes.each do |node| 
+  path = node['path']
+  provider = providers[node['provider']]
+  options = node['options']
+  wormly_id = node['wormly_id']
+
+  if wormly_id and wormly_key
+    uri = URI::HTTP.build({
+      :host => host, :port => port, :path => path
+    })
+
+    wormly_url_list.push([wormly_id, uri])
+  end
+
+  routes[path] = provider.new(options)
+end
+
+slugly_server = Server.new(host, port, routes)
+slugly_server.serve() do 
+  #once the server is running tell wormly we're up
+  #wormly verifies that the server responds so we avoid blocking with a new thread
+  Thread.new() do
+    wormly_api = WormlyAPI.new(wormly_key)
+
+    wormly_url_list.each do |wormly_id, uri|
+      res = wormly_api.enable_host_hm_linux(wormly_id, uri)
+      status = res.errorcode.zero? ? "succeeded" : "failed with error '#{res.errormsg}'"
+      puts "Enabling Health Monitoring for wormly_id #{wormly_id} at #{uri} #{status}."
+    end
+
+  end
+
+end
+

data/config.yaml.example

@@ -0,0 +1,13 @@
+wormly_key: 1Xs3cr3tk3ys
+host: publichostname.com
+port: 8088
+nodes:
+  - path      : /ssh
+    wormly_id : 12345
+    provider  : SSHHealthProvider
+    options:
+      hostname: localhost
+      username: ubuntu
+  - path      : /local
+    wormly_id : 67890
+    provider  : HealthProvider

data/lib/slugly/health_provider.rb

@@ -0,0 +1,52 @@
+class HealthProvider
+
+  CMD_TIME       = "date +%s | tr -d '\\n'"
+  CMD_UPTIME     = "uptime"
+  CMD_MEMINFO    = "cat /proc/meminfo"
+  CMD_UNAME      = "uname -a"
+  CMD_DF         = "df -P"
+  CMD_TRAFFIC    = "cat /proc/net/dev"
+  CMD_VMSTAT_PRE = <<-EOS
+    if [ ! -f /tmp/slugly.work ];
+    then
+      nohup sh -c "vmstat 300 2 1>/tmp/slugly.work 2>&1; mv /tmp/slugly.work /tmp/slugly.vmstat" < /dev/null > /dev/null 2>&1 &
+    fi
+  EOS
+  CMD_VMSTAT     = "cat /tmp/slugly.vmstat"
+  CMD_WORK_MTIME = "stat -c %Y /tmp/slugly.work"
+  CMD_WORK_CLEAN = "find /tmp -maxdepth 1 -mmin +5 -type f -name 'slugly.work' -exec rm -f /tmp/slugly.work \\;"
+
+  def initialize(options)
+  end
+
+  def time
+    %x{#{CMD_TIME}}
+  end
+  def uptime
+    %x{#{CMD_UPTIME}}
+  end
+  def meminfo
+    %x{#{CMD_MEMINFO}}
+  end
+  def uname
+    %x{#{CMD_UNAME}}
+  end
+  def df
+    %x{#{CMD_DF}}
+  end
+  def traffic
+    %x{#{CMD_TRAFFIC}}
+  end
+
+  def vmstat
+    %x{#{CMD_VMSTAT_PRE}}
+    %x{#{CMD_VMSTAT}}
+  end
+
+  def work_mtime
+    res = %x{#{CMD_WORK_MTIME}}
+    %x{#{CMD_WORK_CLEAN}}
+    res
+  end
+
+end

data/lib/slugly/server.rb

@@ -0,0 +1,18 @@
+require 'webrick'
+require 'slugly/slugly_servlet'
+require 'slugly/wormly_serializer0_91'
+
+class Server
+  def initialize(host, port, routes)
+    @host = host
+    @port = port
+    @routes = routes
+  end
+
+  def serve(&f)
+    server = WEBrick::HTTPServer.new(:BindAddress => @host, :Port => @port, :StartCallback => f)
+    server.mount "/", SluglyServlet, @routes, WormlySerializer0_91.new()
+    ['INT', 'TERM'].each {|sig| trap(sig) {server.shutdown}}
+    server.start
+  end
+end

data/lib/slugly/slugly_servlet.rb

@@ -0,0 +1,32 @@
+require 'webrick'
+
+class SluglyServlet < WEBrick::HTTPServlet::AbstractServlet
+  def initialize(server, providers, wormlyserializer)
+    super(server)
+    @serializer = wormlyserializer
+    @providers  = providers
+  end
+
+  def do_POST(request, response)
+    response['Content-Type'] = 'text/plain'
+
+    if not @providers.has_key?(request.path)
+      response.status = 404
+      response.body = "Unknown Route"
+    else
+      begin
+        p = @providers[request.path]
+        response.body = @serializer.serialize(p)
+        response.status = 200
+        response['X-Wormly-Version'] = @serializer.version
+       rescue
+         response.body = "Internal Server Error"
+         response.status = 500
+       end
+    end
+  end
+
+  def do_GET(request, response)
+    do_POST(request, response)
+  end
+end

data/lib/slugly/ssh_health_provider.rb

@@ -0,0 +1,73 @@
+require 'net/ssh'
+require 'slugly/health_provider'
+
+class SSHHealthProvider < HealthProvider
+  CACHE_TIME = 15
+  def initialize(options)
+    @hostname = options['hostname']
+    @username = options['username']
+    @last_update = Time.now - 2*CACHE_TIME
+  end
+
+  def time
+    update
+    @_time
+  end
+
+  def uptime
+    update
+    @_uptime
+  end
+
+  def meminfo
+    update
+    @_meminfo
+  end
+
+  def uname
+    update
+    @_uname
+  end
+
+  def df
+    update
+    @_df
+  end
+
+  def traffic
+    update
+    @_traffic
+  end
+
+  def vmstat
+    update
+    @_vmstat
+  end
+
+  def work_mtime
+    update
+    @_work_mtime
+  end
+
+  private
+
+  def update()
+    delta = (Time.now - @last_update).to_i
+    if delta >= CACHE_TIME
+      Net::SSH.start(@hostname, @username) do |ssh| 
+        @_time        = ssh.exec!(CMD_TIME)
+        @_uptime      = ssh.exec!(CMD_UPTIME) 
+        @_meminfo     = ssh.exec!(CMD_MEMINFO) 
+        @_uname       = ssh.exec!(CMD_UNAME) 
+        @_df          = ssh.exec!(CMD_DF) 
+        @_traffic     = ssh.exec!(CMD_TRAFFIC)
+                        ssh.exec!(CMD_VMSTAT_PRE) 
+        @_vmstat      = ssh.exec!(CMD_VMSTAT) 
+        @_work_mtime  = ssh.exec!(CMD_WORK_MTIME) 
+                        ssh.exec!(CMD_WORK_CLEAN)
+        @last_update = Time.now
+      end
+    end 
+  end
+end
+

data/lib/slugly/wormly_api.rb

@@ -0,0 +1,32 @@
+require 'httparty'
+require 'ostruct'
+
+class WormlyAPI
+  include HTTParty
+
+  format :json
+  base_uri 'https://api.wormly.com/'
+
+  def initialize(key)
+    super()
+    @key = key
+  end
+
+  def enable_host_hm_linux(id, agenturl)
+    query('enableHostHMLinux', {:hostid => id, :agenturl => agenturl})
+  end
+
+  private
+  def query(cmd, args ={})
+    params = {
+      :key => @key,
+      :response => 'json',
+      :cmd => cmd
+    }
+    
+    qargs = args.clone
+    qargs.update(params)
+    
+    OpenStruct.new(self.class.post("/", :query=>qargs))
+  end
+end

data/lib/slugly/wormly_serializer0_91.rb

@@ -0,0 +1,25 @@
+require 'slugly/wormly_serializer_base'
+
+class WormlySerializer0_91 < WormlySerializerBase
+  def version
+      '0.91'
+  end
+
+  def serialize(provider)
+    meta1 = [
+      [:moment, provider.time],
+      [:version, version],
+      [:safe_mode, 0]
+    ]
+
+    s  = stanza('meta-1', "", meta1)
+    s += stanza('top-1', provider.uptime)
+    s += stanza('vmstat-1', provider.vmstat)
+    s += stanza('ps-1', provider.work_mtime)
+    s += stanza('ram-1', provider.meminfo)
+    s += stanza('sysinfo-1', provider.uname)
+    s += stanza('dfdiskspace-1', provider.df)
+    s += stanza('traffic-1', provider.traffic)
+    s += "\n\n\n"
+  end
+end

data/lib/slugly/wormly_serializer_base.rb

@@ -0,0 +1,17 @@
+class WormlySerializerBase
+  def version
+    # e.g. '0.91'
+  end
+
+  def stanza(name, body = "", values ={})
+    s = "[#{name}]\n"
+    values.each do |k,v|
+      s += "#{k}:#{v}\n"
+    end
+    s += "#{body}\n"
+  end
+
+  def serialize(provider)
+    #serialize as per agent.php
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: slugly
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Alfred Rossi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-04 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Proxy for Wormly.com's health monitoring to enable monitoring of machines that are behind firewalls or where you don't want to run Wormly's HTTP and PHP-based monitoring script. Requires only Ruby on the proxy server and nothing at all on the machines being monitored when the SSH-based backend is used.
+email: 
+- alfred@actionverb.com
+executables: 
+- slugly
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/slugly
+- lib/slugly/wormly_api.rb
+- lib/slugly/ssh_health_provider.rb
+- lib/slugly/health_provider.rb
+- lib/slugly/slugly_servlet.rb
+- lib/slugly/wormly_serializer_base.rb
+- lib/slugly/server.rb
+- lib/slugly/wormly_serializer0_91.rb
+- LICENSE
+- README.md
+- config.yaml.example
+has_rdoc: true
+homepage: https://github.com/bombino/slugly
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Slugly is a health monitoring service for wormly with support for multiple backend machines.
+test_files: []
+