perus 0.1.0

data/lib/perus/server/models/action.rb

@@ -0,0 +1,71 @@
+module Perus::Server
+    class Action < Sequel::Model
+        plugin :validation_helpers
+        plugin :serialization
+
+        many_to_one :system
+        many_to_one :command_config
+        many_to_one :script
+        
+        serialize_attributes :json, :file
+
+        def config_hash
+            if command_config_id
+                hash = command_config.config_hash
+            else
+                hash = script.config_hash
+            end
+
+            # replace the command config/script id with the action's id
+            hash['id'] = id
+            hash
+        end
+
+        def command_name
+            if script_id
+                script.name
+            else
+                command_config.command
+            end
+        end
+
+        def options
+            if script_id
+                {}
+            else
+                command_config.options
+            end
+        end
+
+        def file_name
+            file['original_name']
+        end
+
+        def file_url
+            prefix = URI(Server.options.uploads_url)
+            path = File.join(system_id.to_s, file['filename'])
+            (prefix + path).to_s
+        end
+
+        def file_path
+            File.join(system.uploads_dir, file['filename'])
+        end
+
+        def validate
+            super
+            validates_presence :system_id
+        end
+
+        def after_destroy
+            super
+            
+            if command_config_id
+                command_config.destroy
+            end
+
+            if file
+                File.unlink(file_path)
+            end
+        end
+    end
+end

data/lib/perus/server/models/alert.rb

@@ -0,0 +1,9 @@
+module Perus::Server
+    class Alert < Sequel::Model
+        def execute(systems)
+            systems.select do |system|
+                system.instance_eval(code)
+            end
+        end
+    end
+end

data/lib/perus/server/models/command_config.rb

@@ -0,0 +1,58 @@
+module Perus::Server
+    class CommandConfig < Sequel::Model
+        plugin :validation_helpers
+        plugin :serialization
+        serialize_attributes :json, :options
+
+        def config_hash
+            {
+                id: id,
+                type: command,
+                options: options
+            }
+        end
+
+        def validate
+            super
+            validates_presence :command
+        end
+
+        def command_class
+            Perus::Pinger.const_get(command)
+        end
+
+        def update_options!(params)
+            self.options = self.class.process_options(params)
+            save
+        end
+
+        def self.process_options(params)
+            return {} if params['options'].nil?
+
+            # ignore empty options (will use default)
+            options = params['options'].reject do |attr, value|
+                value.empty?
+            end
+
+            # replace 'true' and 'false' with actual boolean values
+            # but only for boolean options
+            command = Perus::Pinger.const_get(params['command'])
+            command.options.each do |option|
+                next unless option.boolean?
+                next unless options.include?(option.name.to_s)
+                value = options[option.name.to_s]
+                options[option.name.to_s] = value == 'true'
+            end
+
+            options
+        end
+
+        def self.create_with_params(params)
+            options = process_options(params)
+            CommandConfig.create(
+                command: params['command'],
+                options: options
+            )
+        end
+    end
+end

data/lib/perus/server/models/config.rb

@@ -0,0 +1,30 @@
+module Perus::Server
+    class Config < Sequel::Model
+        plugin :validation_helpers
+        one_to_many :systems
+        one_to_many :config_metrics, order: 'name asc'
+
+        def metric_hashes
+            config_metrics.collect(&:config_hash)
+        end
+
+        def largest_order
+            if config_metrics.empty?
+                0
+            else
+                config_metrics.last.order
+            end
+        end
+
+        def validate
+            super
+            validates_presence  :name
+            validates_unique    :name
+        end
+
+        def after_destroy
+            super
+            config_metrics.each(&:destroy)
+        end
+    end
+end

data/lib/perus/server/models/config_metric.rb

@@ -0,0 +1,15 @@
+module Perus::Server
+    class ConfigMetric < Sequel::Model
+        many_to_one :config
+        many_to_one :command_config
+
+        def config_hash
+            command_config.config_hash
+        end
+
+        def after_destroy
+            super
+            command_config.destroy
+        end
+    end
+end

data/lib/perus/server/models/error.rb

@@ -0,0 +1,5 @@
+module Perus::Server
+    class Error < Sequel::Model
+        many_to_one :system
+    end
+end

data/lib/perus/server/models/group.rb

@@ -0,0 +1,12 @@
+module Perus::Server
+    class Group < Sequel::Model
+        plugin :validation_helpers
+        one_to_many :systems
+        
+        def validate
+            super
+            validates_presence  :name
+            validates_unique    :name
+        end
+    end
+end

data/lib/perus/server/models/metric.rb

@@ -0,0 +1,53 @@
+require 'uri'
+
+module Perus::Server
+    class Metric < Sequel::Model
+        plugin :serialization
+        many_to_one :system
+        serialize_attributes :json, :file
+
+        def numeric?
+            type == 'num'
+        end
+
+        def string?
+            type == 'str'
+        end
+
+        def file?
+            type == 'file'
+        end
+
+        def url
+            prefix = URI(Server.options.uploads_url)
+            path = File.join(system_id.to_s, file['filename'])
+            (prefix + path).to_s
+        end
+
+        def self.add(name, system_id, type, file_data = nil)
+            existing = Metric.where(system_id: system_id, name: name, type: type).first
+
+            if existing
+                return if type != 'file'
+                record = existing
+            else
+                record = Metric.new(system_id: system_id, name: name, type: type)
+            end
+
+            record.file = file_data
+            record.save
+        end
+
+        def self.add_numeric(name, system_id)
+            self.add(name, system_id, 'num')
+        end
+
+        def self.add_string(name, system_id)
+            self.add(name, system_id, 'str')
+        end
+
+        def self.add_file(name, system_id, file_data)
+            self.add(name, system_id, 'file', file_data)
+        end
+    end
+end

data/lib/perus/server/models/script.rb

@@ -0,0 +1,39 @@
+module Perus::Server
+    class Script < Sequel::Model
+        plugin :validation_helpers
+        one_to_many :script_commands, order: 'name asc'
+
+        def code_name
+            name.gsub(' ', '_').camelize
+        end
+
+        def config_hash
+            {
+                id: id,
+                type: 'Script',
+                options: {
+                    commands: script_commands.collect(&:config_hash)
+                }
+            }
+        end
+
+        def largest_order
+            if script_commands.empty?
+                0
+            else
+                script_commands.last.order
+            end
+        end
+
+        def validate
+            super
+            validates_presence  :name
+            validates_unique    :name
+        end
+
+        def after_destroy
+            super
+            script_commands.each(&:destroy)
+        end
+    end
+end

data/lib/perus/server/models/script_command.rb

@@ -0,0 +1,15 @@
+module Perus::Server
+    class ScriptCommand < Sequel::Model
+        many_to_one :script
+        many_to_one :command_config
+
+        def config_hash
+            command_config.config_hash
+        end
+
+        def after_destroy
+            super
+            command_config.destroy
+        end
+    end
+end

data/lib/perus/server/models/system.rb

@@ -0,0 +1,160 @@
+require 'fileutils'
+require 'json'
+
+module Perus::Server
+    class System < Sequel::Model
+        plugin :validation_helpers
+
+        many_to_one :config
+        many_to_one :group
+        one_to_many :metrics
+        one_to_many :values
+        one_to_many :actions
+        one_to_many :collection_errors, class_name: 'Perus::Server::Error'
+
+        def validate
+            super
+            validates_presence  :name
+            validates_unique    :name
+        end
+
+        def pending_actions
+            actions_dataset.where(timestamp: nil).all
+        end
+
+        def action_hashes
+            # actions referring to a command_config return a hash when calling
+            # config_hashes, actions referring to scripts return an array.
+            # flatten is needed to merge the two response types together.
+            pending_actions.collect(&:config_hashes).flatten
+        end
+
+
+        # ---------------------------------------
+        # metrics
+        # ---------------------------------------
+        def save_metric_errors(params, timestamp)
+            errors = JSON.parse(params['metric_errors'])
+
+            errors.each do |module_name, module_errors|
+                module_errors.each do |error|
+                    Error.create(
+                        system_id: id,
+                        timestamp: timestamp,
+                        module: module_name,
+                        description: error
+                    )
+                end
+            end
+        end
+
+        def save_values(params, timestamp)
+            # store the set of known metrics for this system. metrics have either
+            # str or num values.
+            values = JSON.parse(params['metrics'])
+
+            values.each do |(metric_name, value)|
+                # file uploads are treated specially and don't need a value
+                # record created for them
+                if value.kind_of?(Hash)
+                    file_data = save_file(params, value, metric_name)
+                    Metric.add_file(metric_name, id, file_data)
+                    next
+                end
+
+                attrs = {
+                    system_id: id,
+                    timestamp: timestamp,
+                    metric: metric_name
+                }
+
+                if value.kind_of?(Numeric)
+                    attrs[:num_value] = value
+                    Metric.add_numeric(metric_name, id)
+                else
+                    attrs[:str_value] = value
+                    Metric.add_string(metric_name, id)
+                end
+
+                Value.create(attrs)
+            end
+        end
+
+        def latest(name)
+            values_dataset.where(metric: name).order_by('timestamp desc').first
+        end
+
+
+        # ---------------------------------------
+        # actions
+        # ---------------------------------------
+        def save_actions(params, timestamp)
+            actions = JSON.parse(params['actions'])
+
+            actions.each do |id, result|
+                # JSON.dump turns integer keys into strings
+                action = Action.with_pk!(id.to_i)
+                action.timestamp = timestamp
+
+                if result == true
+                    action.success = true
+                elsif result.is_a?(Hash)
+                    action.success = true
+                    action.file = save_file(params, result, action.id)
+                else
+                    action.success = false
+                    action.response = result.to_s
+                end
+
+                action.save
+            end
+        end
+
+
+        # ---------------------------------------
+        # files
+        # ---------------------------------------
+        def uploads_dir
+            @uploads_dir ||= File.join(Server.options.uploads_dir, id.to_s)
+        end
+
+        def save_file(params, entry, name)
+            # entry should be a hash with a single key 'file', which is the
+            # key name used to find the file in params
+            raise 'Invalid file upload' unless entry.is_a?(Hash) && entry.include?('file')
+
+            # ensure the uploads directory exists for this system
+            FileUtils.mkdir_p(uploads_dir)
+
+            # files are sent as top level parameters. metrics rename files
+            # with their own name (i.e 'screenshot' saves a file called
+            # 'screenshot'), while actions rename files to the action id
+            upload = params[entry['file']]
+
+            # store the file
+            name = name.to_s + File.extname(upload[:filename])
+            File.open(File.join(uploads_dir, name.to_s), 'wb') do |f|
+                f.write(upload[:tempfile].read)
+            end
+
+            # return details of the file so it can be served with the correct
+            # original filename and mimetype
+            {filename: name, original_name: upload[:filename], mimetype: upload[:type]}
+        end
+
+        def upload_urls
+            file_metrics = metrics_dataset.where(type: 'file').all
+            pairs = file_metrics.collect do |metric|
+                [metric.name, metric.url]
+            end
+
+            # convert to name => url hash
+            Hash[pairs]
+        end
+
+        def screenshot_url
+            screenshot = metrics_dataset.where(name: 'screenshot').first
+            screenshot ? screenshot.url : ''
+        end
+    end
+end

data/lib/perus/server/models/value.rb

@@ -0,0 +1,11 @@
+module Perus::Server
+    class Value < Sequel::Model
+        plugin :validation_helpers
+        many_to_one :system
+
+        def validate
+            super
+            validates_presence [:system_id, :metric, :timestamp]
+        end
+    end
+end

data/lib/perus/server/public/css/reset.css

@@ -0,0 +1,102 @@
+/* 
+html5doctor.com Reset Stylesheet
+v1.6.1
+Last Updated: 2010-09-17
+Author: Richard Clark - http://richclarkdesign.com 
+Twitter: @rich_clark
+*/
+
+html, body, div, span, object, iframe,
+h1, h2, h3, h4, h5, h6, p, blockquote, pre,
+abbr, address, cite, code,
+del, dfn, em, img, ins, kbd, q, samp,
+small, strong, sub, sup, var,
+b, i,
+dl, dt, dd, ol, ul, li,
+fieldset, form, label, legend,
+table, caption, tbody, tfoot, thead, tr, th, td,
+article, aside, canvas, details, figcaption, figure, 
+footer, header, hgroup, menu, nav, section, summary,
+time, mark, audio, video {
+    margin:0;
+    padding:0;
+    border:0;
+    outline:0;
+    font-size:100%;
+    vertical-align:baseline;
+    background:transparent;
+}
+
+body {
+    line-height:1;
+}
+
+article,aside,details,figcaption,figure,
+footer,header,hgroup,menu,nav,section { 
+    display:block;
+}
+
+nav ul {
+    list-style:none;
+}
+
+blockquote, q {
+    quotes:none;
+}
+
+blockquote:before, blockquote:after,
+q:before, q:after {
+    content:'';
+    content:none;
+}
+
+a {
+    margin:0;
+    padding:0;
+    font-size:100%;
+    vertical-align:baseline;
+    background:transparent;
+}
+
+/* change colours to suit your needs */
+ins {
+    background-color:#ff9;
+    color:#000;
+    text-decoration:none;
+}
+
+/* change colours to suit your needs */
+mark {
+    background-color:#ff9;
+    color:#000; 
+    font-style:italic;
+    font-weight:bold;
+}
+
+del {
+    text-decoration: line-through;
+}
+
+abbr[title], dfn[title] {
+    border-bottom:1px dotted;
+    cursor:help;
+}
+
+table {
+    border-collapse:collapse;
+    border-spacing:0;
+}
+
+/* change border colour to suit your needs */
+hr {
+    display:block;
+    height:1px;
+    border:0;   
+    border-top:1px solid #cccccc;
+    margin:1em 0;
+    padding:0;
+}
+
+input, select {
+    vertical-align:middle;
+}