perus 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 50163f19be6adf3f481d868e88b7efe33d563425
+  data.tar.gz: 46fbde86dcfb9d0f6194849517f9b6bae81ec8cd
+SHA512:
+  metadata.gz: 504e5ec4a3c322c18de258f2ee67eea50267bb82aff92473eca31b2205091b4058e16f1f3ef17a8d2581b536d0bf99fadd8b7eae87c3b6b0632a3f2aec87404a
+  data.tar.gz: faa25da90c07daac501192daac00106c568ab73e177fa93578de5116abbb333f50697706d31e2fbf8ded7327c8709f4d0e38f5f656a06abcaa73b45980ba036b

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+*.db
+uploads
+

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.10.4

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 ACA
+
+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,16 @@
+# Perus
+
+A simple system management and monitoring service. Systems ping a server with screenshots and data, and the server provides a simple overview page.
+
+
+## Installation
+
+Install on a server and each system you'd like to monitor
+
+    $ gem install perus
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "perus"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/perus-pinger

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'perus'
+require 'optparse'
+
+options_path = Perus::Pinger::DEFAULT_PINGER_OPTIONS_PATH
+
+ARGV.options do |opts|
+    opts.banner = "Usage: perus-pinger [options]"
+
+    opts.on('-c', '--config', String, "Path to config file (default: #{Perus::Pinger::DEFAULT_PINGER_OPTIONS_PATH})") do |c|
+        options_path = c
+    end
+
+    opts.on('-h', '--help', 'Prints this help') do
+        puts opts
+        exit
+    end
+
+    opts.parse!
+end
+
+pinger = Perus::Pinger::Pinger.new(options_path)
+pinger.run

data/exe/perus-server

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'perus'
+require 'optparse'
+
+options_path = Perus::Server::DEFAULT_SERVER_OPTIONS_PATH
+
+ARGV.options do |opts|
+    opts.banner = "Usage: perus-server [options]"
+
+    opts.on('-c', '--config', String, "Path to config file (default: #{Perus::Server::DEFAULT_SERVER_OPTIONS_PATH})") do |c|
+        options_path = c
+    end
+
+    opts.on('-h', '--help', 'Prints this help') do
+        puts opts
+        exit
+    end
+
+    opts.parse!
+end
+
+server = Perus::Server::Server.new(options_path)
+server.run

data/lib/perus/options.rb

@@ -0,0 +1,30 @@
+require 'iniparse'
+
+module Perus
+    class Options
+        def initialize()
+            @defaults = {}
+        end
+
+        def load(path, defaults)
+            if File.exists?(path)
+                user_options = IniParse.parse(IO.read(path)).to_h
+            else
+                user_options = {}
+            end
+            @options = defaults.merge(user_options)
+        end
+
+        def method_missing(name, *params, &block)
+            if @options.include?(name.to_s)
+                @options[name.to_s]
+            else
+                @options['__anonymous__'][name.to_s]
+            end
+        end
+
+        def [](name)
+            @options[name]
+        end
+    end
+end

data/lib/perus/pinger/chrome_command.rb

@@ -0,0 +1,54 @@
+require 'faye/websocket'
+require 'eventmachine'
+require 'rest-client'
+require 'json'
+
+module Perus::Pinger
+    class ChromeCommand < Command
+        option :timeout_seconds, default: 2
+        option :host, default: 'localhost'
+        option :port, default: 9222
+        abstract!
+
+        def send_command(command)
+            @ws.send(command)
+        end
+
+        def execute(commands, &message_callback)
+            # discover the first page shown in chrome
+            pages = JSON.parse(RestClient.get("http://#{options.host}:#{options.port}/json"))
+            pages.reject! {|page| page['url'].include?('chrome-extension')}
+            @page = pages.first
+
+            EM.run do
+                @ws = Faye::WebSocket::Client.new(@page['webSocketDebuggerUrl'])
+
+                @ws.on :error do |event|
+                    puts "Chrome error: #{event}"
+                    EM.stop_event_loop
+                end
+
+                @ws.on :close do |event|
+                    EM.stop_event_loop
+                end
+
+                @ws.on :message do |event|
+                    if block_given?
+                        json = JSON.parse(event.data)
+                        message_callback.call(json)
+                    end
+                end
+
+                # send each command, responses will appear
+                commands.each do |command|
+                    send_command(command)
+                end
+
+                # cutoff console message loading after N seconds
+                EM.add_timer(options.timeout_seconds) do
+                    @ws.close
+                end
+            end
+        end
+    end
+end

data/lib/perus/pinger/command.rb

@@ -0,0 +1,123 @@
+require 'ostruct'
+
+module Perus::Pinger
+    class Option
+        attr_reader :name, :default, :restricted
+
+        def initialize(name, settings, command)
+            @name = name
+            @command = command
+            @default = settings[:default]
+            @restricted = settings[:restricted] == true
+        end
+
+        def boolean?
+            default.is_a?(TrueClass) || default.is_a?(FalseClass)
+        end
+
+        def process(results, values)
+            value = values[name.to_s]
+            value = value || default
+
+            if value.nil?
+                raise "#{name} is a required option"
+            end
+
+            if restricted
+                allowed = Pinger.options[@command.name.demodulize][@name.to_s]
+                raise "the value passed to #{@name} is not allowed" unless allowed.include?(value)
+            end
+
+            results[name] = value
+        end
+    end
+
+    class Command
+        attr_reader :options, :id
+
+        def self.human_name
+            name.demodulize.underscore.humanize.titlecase
+        end
+
+        # set or get command/metric description
+        def self.description(text = nil)
+            if text
+                @description = text
+            else
+                @description
+            end
+        end
+
+        # add an option to the command/metric. both the class and instances
+        # of the class have an options method. the class version returns a
+        # list of Option objects representing possible options for the
+        # command. the object version returns an OpenStruct hash of options
+        # and their values (defaults merged with provided values)
+        def self.option(name, option_settings = {})
+            @options ||= []
+            @options << Option.new(name, option_settings, self)
+        end
+
+        def self.options
+            @options ||= []
+        end
+
+        def self.inherited(subclass)
+            subclass.options.concat(self.options)
+            Command.subclasses << subclass
+        end
+
+        def self.subclasses
+            @subclasses ||= []
+        end
+
+        # command classes which are intended to run as metrics call this method
+        def self.metric!
+            @metric = true
+        end
+
+        def self.metric?
+            @metric
+        end
+
+        def self.abstract!
+            @abstract = true
+        end
+
+        def self.abstract?
+            @abstract
+        end
+
+        # create a command instance and initialise it with the provided option
+        # values (hash where keys are option names). any restricted options are
+        # validated first, and an exception is thrown if the provided value is
+        # not one of the allowed values for the option.
+        def initialize(option_values, id = nil)
+            @options = OpenStruct.new
+            self.class.options.each do |option|
+                option.process(@options, option_values)
+            end
+
+            # commands (not metrics) have ids that uniquely identify a command
+            # instance and its response
+            @id = id
+        end
+
+        def run
+            # run command/metric, return types for a command are:
+            # true: successful (will show as success on the server)
+            # string: failed, string should provide the reason
+            # file: file to upload
+            # proc: code to run after returning success to server
+            # hash: metrics are expected to only return a hash with
+            # keys indicating metric names, and values restricted to
+            # files, numerics and strings.
+            # exceptions are caught and shown as errors on the server.
+        end
+
+        def cleanup
+            # called after sending data to server. remove temporary
+            # files etc.
+        end
+    end
+end

data/lib/perus/pinger/commands/chrome_execute.rb

@@ -0,0 +1,26 @@
+module Perus::Pinger
+    class ChromeExecute < ChromeCommand
+        description 'Executes JavaScript in the top Chrome window. The result
+                     of the execution is stored and sent to the server.'
+        option :js
+
+        def run
+            result = false
+            command = '{"id":1,"method":"Runtime.evaluate","params":{"expression":"' + options.js.gsub('"', '\\"') + '","objectGroup":"perus","returnByValue":true}}'
+            
+            execute([command]) do |message|
+                if message.include?('id') && message['id'] == 1
+                    if message.include?('result')
+                        result = message['result'].to_s
+                    elsif message.include?('error')
+                        result = message['error'].to_s
+                    else
+                        result = false
+                    end
+                end
+            end
+
+            result
+        end
+    end
+end

data/lib/perus/pinger/commands/chrome_navigate.rb

@@ -0,0 +1,25 @@
+module Perus::Pinger
+    class ChromeNavigate < ChromeCommand
+        description 'Changes the URL of the top Chrome window to "url"'
+        option :url
+
+        def run
+            result = false
+            command = '{"id":1,"method":"Page.navigate","params":{"url":"' + options.url + '"}}'
+
+            execute([command]) do |message|
+                if message.include?('id') && message['id'] == 1
+                    if message.include?('result')
+                        result = true
+                    elsif message.include?('error')
+                        result = message['error'].to_s
+                    else
+                        result = message.to_s
+                    end
+                end
+            end
+
+            result
+        end
+    end
+end

data/lib/perus/pinger/commands/chrome_reload.rb

@@ -0,0 +1,29 @@
+module Perus::Pinger
+    class ChromeReload < ChromeCommand
+        description 'Reloads the top Chrome window. When "ignore_cache" is true
+                     the effect is equivalent to performing a force reload.'
+        option :ignore_cache, default: false
+
+        def run
+            result = false
+
+            execute(['{"id":1,"method":"Page.reload"}']) do |message|
+                if message.include?('id') && message['id'] == 1
+                    if message.include?('result')
+                        if message['result'] == {}
+                            result = true
+                        else
+                            result = message['result'].to_s
+                        end
+                    elsif message.include?('error')
+                        result = message['error'].to_s
+                    else
+                        result = message.to_s
+                    end
+                end
+            end
+
+            result
+        end
+    end
+end

data/lib/perus/pinger/commands/kill_process.rb

@@ -0,0 +1,13 @@
+module Perus::Pinger
+    class KillProcess < Command
+        description 'Kills all instances of a process. Valid values for
+                     "process_name" are contained in the pinger config file.'
+        option :process_name, restricted: true
+        option :signal, default: 'KILL'
+
+        def run
+            result = `killall -#{option.signal} #{option.process_name}`
+            result.include?('no process found') ? result : true
+        end
+    end
+end

data/lib/perus/pinger/commands/remove_path.rb

@@ -0,0 +1,15 @@
+require'fileutils'
+
+module Perus::Pinger
+    class RemovePath < Command
+        description 'Deletes a file or folder. If "path" is a folder, all files
+                     and folders within the folder are deleted as well. Valid
+                     values for "path" are contained in the pinger config file.'
+        option :path, restricted: true
+
+        def run
+            FileUtils.rm_rf([File.expand_path(options.path)], secure: true)
+            true # with no exceptions, the removal was successful
+        end
+    end
+end

data/lib/perus/pinger/commands/replace.rb

@@ -0,0 +1,18 @@
+module Perus::Pinger
+    class Replace < Command
+        description 'Looks for the string matched by "grep" in the file
+                     specified by "path" and replaces it with "replacement".
+                     Valid values for "path" are contained in the pinger
+                     config file.'
+        option :path, restricted: true
+        option :grep
+        option :replacement
+
+        def run
+            text = IO.read(options.path)
+            text.gsub!(/#{options.grep}/, options.replacement)
+            IO.write(options.path, text)
+            true
+        end
+    end
+end

data/lib/perus/pinger/commands/restart.rb

@@ -0,0 +1,9 @@
+module Perus::Pinger
+    class Restart < Command
+        description 'Restarts the client computer'
+
+        def run
+            -> { `sudo reboot` }
+        end
+    end
+end

data/lib/perus/pinger/commands/script.rb

@@ -0,0 +1,59 @@
+module Perus::Pinger
+    class Script < Command
+        option :commands
+        abstract!
+
+        def run
+            actions = []
+            results = []
+            late_actions = []
+
+            options.commands.each do |config|
+                begin
+                    command = ::Perus::Pinger.const_get(config['type'])
+                    actions << command.new(config['options'], config['id'])
+                rescue => e
+                    if config['id']
+                        results[config['id']] = e.inspect
+                    else
+                        puts 'Error - action does not have an associated id'
+                        p config
+                    end
+                end
+            end
+
+            actions.each do |action|
+                begin
+                    result = action.run
+
+                    if result.instance_of?(Proc)
+                        late_actions << result
+                        result = true
+                    end
+
+                    results << result
+                rescue => e
+                    results << e.inspect
+                end
+            end
+
+            failed = results.any? {|result| result.is_a?(String)}
+            return results.join(', ') if failed
+
+            if late_actions.empty?
+                true
+            else
+                Proc.new do
+                    late_actions.each do |code|
+                        begin
+                            code.call
+                        rescue => e
+                            puts 'Error running late action'
+                            puts e.inspect
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/perus/pinger/commands/upgrade.rb

@@ -0,0 +1,16 @@
+module Perus::Pinger
+    class Upgrade < Command
+        description 'Upgrades Perus on the client machine'
+        option :sudo, default: false
+
+        def run
+            if options.sudo
+                result = `sudo gem upgrade perus`
+            else
+                result = `gem upgrade perus`
+            end
+
+            result.include?('ERROR') ? result : true
+        end
+    end
+end

data/lib/perus/pinger/commands/upload.rb

@@ -0,0 +1,15 @@
+module Perus::Pinger
+    class Upload < Command
+        description 'Uploads a file from the client to the server. Valid values
+                     for "path" are contained in the pinger config file.'
+        option :path, restricted: true
+
+        def run
+            @file = File.new(options.path)
+        end
+
+        def cleanup
+            @file.close unless @file.nil? || @file.closed?
+        end
+    end
+end

data/lib/perus/pinger/metrics/chrome.rb

@@ -0,0 +1,33 @@
+module Perus::Pinger
+    class Chrome < ChromeCommand
+        description 'Connects to Chrome with the remote debugger and counts the
+                     number of warnings and errors currently in the console of
+                     the top Chrome window. The URL of the page is also sent
+                     and can be compared to an expected string in an alert.'
+        metric!
+                     
+        def run
+            # we use a debugging protocol connection to read the console messages
+            # in the top level window to count the number of warnings and errors
+            warning_count = 0
+            error_count = 0
+
+            execute(['{"id":1,"method":"Console.enable"}']) do |json|
+                if json['method'] == 'Console.messageAdded'
+                    level = json['params']['message']['level']
+                    if level == 'error'
+                        error_count += 1
+                    elsif level == 'warning'
+                        warning_count += 1
+                    end
+                end
+            end
+
+            {
+                chrome_warnings: warning_count,
+                chrome_errors: error_count,
+                chrome_url: @page['url']
+            }
+        end
+    end
+end

data/lib/perus/pinger/metrics/cpu.rb

@@ -0,0 +1,17 @@
+module Perus::Pinger
+    class CPU < Command
+        description 'Measures overall system CPU usage as a percentage on the
+                     client.'
+        metric!
+
+        def run
+            if `uname -s`.strip == 'Darwin'
+                percent = 100 - `iostat -n 0`.split("\n")[2].split[2].to_i
+            else
+                percent = `grep 'cpu ' /proc/stat | awk '{print (1 - ($5 / ($2+$3+$4+$5+$6+$7+$8)))*100}'`
+            end
+            
+            {cpu_all: percent.to_f}
+        end
+    end
+end

data/lib/perus/pinger/metrics/hd.rb

@@ -0,0 +1,14 @@
+module Perus::Pinger
+    class HD < Command
+        description 'Measures the percentage of disk space currently used on
+                     the specified drive.'
+        option :drive
+        metric!
+        
+        def run
+            regex = "/^#{options.drive.gsub("/", "\\/")}/"
+            percent = `df -h / | awk '#{regex} {print $5}'`
+            {hd_used: percent.to_i}
+        end
+    end
+end