perus 0.1.0

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

@@ -0,0 +1,11 @@
+module Perus::Pinger
+    class Mem < Command
+        description 'Measures overall RAM usage as a percentage on the client.'
+        metric!
+
+        def run
+            percent = `cat /proc/meminfo | awk '{if ($1=="MemTotal:") total = $2; if ($1 == "MemFree:") free = $2;} END {print (1 - (free / total))*100}'`
+            {mem_all: percent.to_f}
+        end
+    end
+end

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

@@ -0,0 +1,27 @@
+module Perus::Pinger
+    class Process < Command
+        description 'Measures percentage of RAM and CPU used by the process
+                     specified by "process_path". The results are returned to
+                     the server under 2 metrics called "cpu_{name}" and
+                     "mem_{name}". Valid values for "process_path" are
+                     contained in the pinger config file.'
+        option :process_path, restricted: true
+        option :name
+        metric!
+
+        def run
+            path = options.process_path.gsub("/", "\\\\\\/")
+            cpu, mem = `ps aux | awk '/#{path}/ {cpu += $3; mem += $4} END {print cpu, mem;}'`.split
+            if `uname -s`.strip == 'Darwin'
+                core_count = `sysctl -n hw.ncpu`
+            else
+                core_count = `cat /proc/cpuinfo | grep processor | awk '{count += 1} END {print count}'`
+            end
+
+            {
+                "cpu_#{options.name}" => cpu.to_f / core_count.to_i,
+                "mem_#{options.name}" => mem.to_f
+            }
+        end
+    end
+end

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

@@ -0,0 +1,36 @@
+module Perus::Pinger
+    class Screenshot < Command
+        description 'Takes a screenshot of the primary screen on the client and
+                     uploads it. The screenshot is saved to "path" before being
+                     uploaded. Valid values for "path" are contained in the
+                     pinger config file.'
+        option :path, default: '/tmp/screenshot.jpg', restricted: true
+        option :resize, default: '20%'
+        metric!
+
+        def run
+            if `uname -s`.strip == 'Darwin'
+                if options.resize[-1] != '%'
+                    raise 'Non percent resize option unsupported by OS X currently'
+                else
+                    percent = options.resize.to_f / 100
+                end
+
+                `screencapture -m -t jpg -x #{options.path}`
+                width  = `sips -g pixelWidth #{options.path}`.match(/pixelWidth: (\d+)/)[1]
+                height = `sips -g pixelHeight #{options.path}`.match(/pixelHeight: (\d+)/)[1]
+                `sips -z #{height.to_i * percent} #{width.to_i * percent} #{options.path}`
+            else
+                `export DISPLAY=:0; import -window root -resize #{options.resize} #{options.path}`
+            end
+
+            @screenshot_file = File.new(options.path)
+            {screenshot: @screenshot_file}
+        end
+
+        def cleanup
+            @screenshot_file.close unless @screenshot_file.closed?
+            File.delete(options.path)
+        end
+    end
+end

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

@@ -0,0 +1,18 @@
+module Perus::Pinger
+    class Temp < Command
+        description 'Measures the temperature of "device" on the client. By
+                     default, this will be a CPU.'
+        option :device, default: 'Physical id 0'
+        metric!
+        
+        def run
+            if `uname -s`.strip == 'Darwin'
+                degrees = `istats cpu temp`.split[2].match(/([0-9\.]+)/)[0]
+            else
+                degrees = `sensors | grep "#{options.device}:"`.match(/#{options.device}:\s+(\S+)/)[1]
+            end
+
+            {temp: degrees.to_f}
+        end
+    end
+end

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

@@ -0,0 +1,10 @@
+module Perus::Pinger
+    class Uptime < Command
+        description 'Runs the uptime command and returns the result'
+        metric!
+        
+        def run
+            {uptime: `uptime`.strip}
+        end
+    end
+end

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

@@ -0,0 +1,18 @@
+module Perus::Pinger
+    class Value < Command
+        description 'Searches the file specified by "path" with the regular
+                     expression specified by "grep". Returns the resulting
+                     string to the server under the metric called "name". Valid
+                     values for "path" are contained in the pinger config file.'
+        option :path, restricted: true
+        option :grep
+        option :name
+        metric!
+        
+        def run
+            line = `cat #{options.path} | grep #{options.grep}`
+            value = line.match(Regexp.compile(options.match))[1]
+            {options.name => value}
+        end
+    end
+end

data/lib/perus/pinger/pinger.rb

@@ -0,0 +1,218 @@
+require 'securerandom'
+require 'rest-client'
+require 'ostruct'
+require 'json'
+require 'uri'
+
+DEFAULT_PINGER_OPTIONS = {
+    '__anonymous__' => {
+        'system_id' => 1,
+        'server' => 'http://127.0.0.1:3000/'
+    },
+
+    # restricted values
+    'Value' => {
+        'path' => []
+    },
+
+    'Screenshot' => {
+        'path' => []
+    },
+
+    'Process' => {
+        'process_path' => []
+    },
+
+    'Upload' => {
+        'path' => []
+    },
+
+    'Replace' => {
+        'path' => []
+    },
+
+    'RemovePath' => {
+        'path' => []
+    },
+
+    'KillProcess' => {
+        'process_name' => []
+    }
+}
+
+module Perus::Pinger
+    class Pinger
+        def self.options
+            @options ||= Perus::Options.new
+        end
+
+        def initialize(options_path = DEFAULT_PINGER_OPTIONS_PATH)
+            Pinger.options.load(options_path, DEFAULT_PINGER_OPTIONS)
+
+            # cache urls on initialisation since the urls depend on values known
+            # at startup and that won't change over the object lifetime
+            config_path = URI("/systems/#{Pinger.options.system_id}/config")
+            pinger_path = URI("/systems/#{Pinger.options.system_id}/ping")
+            server_uri  = URI(Pinger.options.server)
+
+            @config_url = (server_uri + config_path).to_s
+            @pinger_url = (server_uri + pinger_path).to_s
+
+            @metrics = []
+            @metric_results = {}
+            @metric_errors = {}
+
+            @actions = []
+            @action_results = {}
+            @late_actions = []
+        end
+
+        def run
+            load_config
+            run_metrics
+            run_actions
+            send_response
+            cleanup
+        end
+
+        #----------------------
+        # configuration
+        #----------------------
+        def load_config
+            # load the system config by requesting it from the perus server
+            json = JSON.parse(RestClient.get(@config_url))
+            json['metrics'] ||= []
+            json['actions'] ||= []
+
+            # load metric and command modules based on the config
+            json['metrics'].each do |config|
+                begin
+                    if ::Perus::Pinger.const_defined?(config['type'])
+                        metric = ::Perus::Pinger.const_get(config['type'])
+                        @metric_errors[metric.name] ||= []
+                        @metrics << metric.new(config['options'])
+                    else
+                        @metric_errors[config['type']] = e.inspect
+                    end
+                rescue => e
+                    @metric_errors[metric.name] << e.inspect
+                end
+            end
+
+            json['actions'].each do |config|
+                begin
+                    command = ::Perus::Pinger.const_get(config['type'])
+                    @actions << command.new(config['options'], config['id'])
+                rescue => e
+                    if config['id']
+                        @action_results[config['id']] = e.inspect
+                    else
+                        puts 'Error - action does not have an associated id'
+                        p config
+                    end
+                end
+            end
+        end
+
+        #----------------------
+        # run
+        #----------------------
+        def run_metrics
+            @metrics.each do |metric|
+                begin
+                    result = metric.run
+                    @metric_results.merge!(result)
+                rescue => e
+                    @metric_errors[metric.class.name] << e.inspect
+                end
+            end
+        end
+
+        def run_actions
+            @actions.each do |action|
+                begin
+                    result = action.run
+
+                    if result.instance_of?(Proc)
+                        @late_actions << result
+                        result = true
+                    end
+
+                    @action_results[action.id] = result
+
+                rescue => e
+                    @action_results[action.id] = e.inspect
+                end
+            end
+        end
+
+        #----------------------
+        # response
+        #----------------------
+        def add_to_payload(payload, field, results)
+            results.each do |name, val|
+                next unless val.instance_of?(File)
+                uuid = SecureRandom.uuid
+                results[name] = {file: uuid}
+                payload[uuid] = val
+            end
+
+            payload[field] = JSON.dump(results)
+        end
+
+        def send_response
+            # prepare the response and replace file results with a reference
+            # to the uploaded file. files are sent as top level parameters in
+            # the payload, while metric and action results are sent as a json
+            # object with a reference to these files.
+            payload = {}
+            add_to_payload(payload, 'metrics', @metric_results)
+            add_to_payload(payload, 'actions', @action_results)
+
+            # metric_errors is created with a key for each metric type. most
+            # metrics should run without any errors, so remove these entries
+            # before adding errors to the payload.
+            @metric_errors.reject! {|metric, errors| errors.empty?}
+            add_to_payload(payload, 'metric_errors', @metric_errors)
+
+            begin
+                RestClient.post(@pinger_url, payload)
+            rescue => e
+                puts 'Ping failed with exception'
+                puts e.inspect
+            end
+        end
+
+        #----------------------
+        # cleanup
+        #----------------------
+        def cleanup
+            @metrics.each do |metric|
+                begin
+                    metric.cleanup
+                rescue => e
+                    puts 'Error running metric cleanup'
+                    puts e.inspect
+                end
+            end
+
+            @actions.each do |action|
+                begin
+                    action.cleanup
+                rescue => e
+                    puts 'Error running action cleanup'
+                    puts e.inspect
+                end
+            end
+
+            @late_actions.each do |code|
+                begin
+                    code.call
+                rescue => e
+                    puts 'Error running late action'
+                    puts e.inspect
+                end
+            end
+        end
+    end
+end

data/lib/perus/pinger.rb

@@ -0,0 +1,38 @@
+module Perus
+    module Pinger
+        Dir.chdir(__dir__) do
+            # commands
+            require './pinger/command'
+            require './pinger/chrome_command'
+            require './pinger/commands/chrome_execute'
+            require './pinger/commands/chrome_navigate'
+            require './pinger/commands/chrome_reload'
+            require './pinger/commands/kill_process'
+            require './pinger/commands/remove_path'
+            require './pinger/commands/replace'
+            require './pinger/commands/restart'
+            require './pinger/commands/upload'
+            require './pinger/commands/upgrade'
+            require './pinger/commands/script'
+
+            # metrics
+            require './pinger/metrics/chrome'
+            require './pinger/metrics/cpu'
+            require './pinger/metrics/hd'
+            require './pinger/metrics/mem'
+            require './pinger/metrics/process'
+            require './pinger/metrics/screenshot'
+            require './pinger/metrics/temp'
+            require './pinger/metrics/value'
+            require './pinger/metrics/uptime'
+
+            # pinger
+            require './pinger/pinger'
+        end
+
+        # options file
+        DEFAULT_PINGER_OPTIONS_PATH = '/etc/perus-pinger'
+    end
+
+    Pinger::Pinger.new.run if __FILE__ == $0
+end

data/lib/perus/server/admin.rb

@@ -0,0 +1,83 @@
+module Perus::Server
+    module Admin
+        def admin(type, redirect_to_record = false)
+            plural   = type.to_s.pluralize
+            singular = plural.singularize
+            title    = singular.titleize
+            klass    = title
+
+            class_eval "
+                use Sinatra.new {
+                    helpers Helpers
+
+                    before do
+                        @plural = '#{plural}'
+                        @title = '#{title}'
+                        load_site_information
+                    end
+
+                    # list
+                    get '/admin/#{plural}' do
+                        @records = #{klass}.all
+                        erb :'admin/index'
+                    end
+
+                    # new form
+                    get '/admin/#{plural}/new' do
+                        @record = #{klass}.new
+                        @form = Form.new(@record)
+                        erb :'admin/new'
+                    end
+
+                    # create
+                    post '/admin/#{plural}' do
+                        @record = #{klass}.new(params[:record])
+                        if @record.valid?
+                            begin
+                                @record.save
+                                if #{redirect_to_record}
+                                    redirect url_prefix + 'admin/#{plural}/' + @record.id.to_s
+                                else
+                                    redirect url_prefix + 'admin/#{plural}'
+                                end
+                            rescue
+                            end
+                        end
+
+                        @form = Form.new(@record)
+                        erb :'admin/new'
+                    end
+
+                    # edit
+                    get '/admin/#{plural}/:id' do
+                        @record = #{klass}.with_pk!(params['id'])
+                        @form = Form.new(@record)
+                        erb :'admin/edit'
+                    end
+
+                    # update
+                    put '/admin/#{plural}/:id' do
+                        @record = #{klass}.with_pk!(params['id'])
+                        if @record.valid?
+                            begin
+                                @record.update(params[:record])
+                                redirect url_prefix + 'admin/#{plural}'
+                            rescue
+                            end
+                        end
+                        
+                        @form = Form.new(@record)
+                        erb :'admin/edit'
+                    end
+
+                    # delete
+                    delete '/admin/#{plural}/:id' do
+                        @record = #{klass}.with_pk!(params['id'])
+                        @record.destroy
+                        redirect url_prefix + 'admin/#{plural}'
+                    end
+                }
+            "
+        end
+    end
+end