minicron 0.1.0

data/lib/minicron/constants.rb

@@ -0,0 +1,7 @@
+module Minicron
+  VERSION = '0.1.0'
+  DEFAULT_CONFIG_FILE = '/etc/minicron.toml'
+  BASE_PATH = File.expand_path('../../../', __FILE__)
+  LIB_PATH = File.expand_path('../../', __FILE__)
+  HUB_PATH = File.expand_path('../../minicron/hub', __FILE__)
+end

data/lib/minicron/cron.rb

@@ -0,0 +1,192 @@
+require 'shellwords'
+
+module Minicron
+  # Used to interact with the crontab on hosts over an ssh connection
+  # TODO: I've had a moment of clarity, I don't need to do all the CRUD
+  # using unix commands. I can cat the crontab, manipulate it in ruby
+  # and then echo it back!
+  class Cron
+    # Initialise the cron class
+    #
+    # @param ssh [Minicron::Transport::SSH] instance
+    def initialize(ssh)
+      @ssh = ssh
+    end
+
+    # Escape the quotes in a command
+    #
+    # @param command [String]
+    # @return [String]
+    def escape_command(command)
+      command.gsub(/\\|'/) { |c| "\\#{c}" }
+    end
+
+    # Build the minicron command to be used in the crontab
+    #
+    # @param command [String]
+    # @param schedule [String]
+    # @return [String]
+    def build_minicron_command(command, schedule)
+      # Escape any quotes in the command
+      command = escape_command(command)
+
+      "#{schedule} root minicron run '#{command}'"
+    end
+
+    # Used to find a string and replace it with another in the crontab by
+    # using the sed command
+    #
+    # @param conn an instance of an open ssh connection
+    # @param find [String]
+    # @param replace [String]
+    def find_and_replace(conn, find, replace)
+      # TODO: move ssh test here for crontab permissions
+
+      # Get the full crontab
+      crontab = conn.exec!('cat /etc/crontab').to_s.strip
+
+      # Replace the full string with the replacement string
+      begin
+        crontab[find] = replace
+      rescue Exception => e
+        raise Exception, "Unable to replace '#{find}' with '#{replace}' in the crontab, reason: #{e}"
+      end
+
+      # Echo the crontab back to the tmp crontab
+      update = conn.exec!("echo #{crontab.shellescape} > /etc/crontab.tmp && echo 'y' || echo 'n'").to_s.strip
+
+      # Throw an exception if it failed
+      if update != 'y'
+        raise Exception, "Unable to replace '#{find}' with '#{replace}' in the crontab"
+      end
+
+      # If it's a delete
+      if replace == ''
+        # Check the original line is no longer there
+        grep = conn.exec!("grep -F \"#{find}\" /etc/crontab.tmp").to_s.strip
+
+        # Throw an exception if we can't see our new line at the end of the file
+        if grep != replace
+          raise Exception, "Expected to find nothing when grepping crontab but found #{grep}"
+        end
+      else
+        # Check the updated line is there
+        grep = conn.exec!("grep -F \"#{replace}\" /etc/crontab.tmp").to_s.strip
+
+        # Throw an exception if we can't see our new line at the end of the file
+        if grep != replace
+          raise Exception, "Expected to find '#{replace}' when grepping crontab but found #{grep}"
+        end
+      end
+
+      # And finally replace the crontab with the new one now we now the change worked
+      move = conn.exec!("mv /etc/crontab.tmp /etc/crontab && echo 'y' || echo 'n'").to_s.strip
+
+      if move != 'y'
+        raise Exception, 'Unable to move tmp crontab with updated crontab'
+      end
+    end
+
+    # Add the schedule for this job to the crontab
+    #
+    # @param job [Minicron::Hub::Job] an instance of a job model
+    # @param schedule [String] the job schedule as a string
+    # @param conn an instance of an open ssh connection
+    def add_schedule(job, schedule, conn = nil)
+      # Open an SSH connection
+      conn ||= @ssh.open
+
+      # Prepare the line we are going to write to the crontab
+      line = build_minicron_command(job.command, schedule)
+      echo_line = "echo \"#{line}\" >> /etc/crontab && echo 'y' || echo 'n'"
+
+      # Append it to the end of the crontab
+      write = conn.exec!(echo_line).strip
+
+      # Throw an exception if it failed
+      if write != 'y'
+        raise Exception, "Unable to write '#{line}' to the crontab"
+      end
+
+      # Check the line is there
+      tail = conn.exec!('tail -n 1 /etc/crontab').strip
+
+      # Throw an exception if we can't see our new line at the end of the file
+      if tail != line
+        raise Exception, "Expected to find '#{line}' at eof but found '#{tail}'"
+      end
+    end
+
+    # Update the schedule for this job in the crontab
+    #
+    # @param job [Minicron::Hub::Job] an instance of a job model
+    # @param old_schedule [String] the old job schedule as a string
+    # @param new_schedule [String] the new job schedule as a string
+    # @param conn an instance of an open ssh connection
+    def update_schedule(job, old_schedule, new_schedule, conn = nil)
+      # Open an SSH connection
+      conn ||= @ssh.open
+
+      # We are looking for the current value of the schedule
+      find = build_minicron_command(job.command, old_schedule)
+
+      # And replacing it with the updated value
+      replace = build_minicron_command(job.command, new_schedule)
+
+      # Replace the old schedule with the new schedule
+      find_and_replace(conn, find, replace)
+    end
+
+    # Remove the schedule for this job from the crontab
+    #
+    # @param job [Minicron::Hub::Job] an instance of a job model
+    # @param schedule [String] the job schedule as a string
+    # @param conn an instance of an open ssh connection
+    def delete_schedule(job, schedule, conn = nil)
+      # Open an SSH connection
+      conn ||= @ssh.open
+
+      # We are looking for the current value of the schedule
+      find = build_minicron_command(job.command, schedule)
+
+      # Replace the old schedule with nothing i.e deleting it
+      find_and_replace(conn, find, '')
+    end
+
+    # Delete a job and all it's schedules from the crontab
+    #
+    # @param job [Minicron::Hub::Job] a job instance with it's schedules
+    # @param conn an instance of an open ssh connection
+    def delete_job(job, conn = nil)
+      conn ||= @ssh.open
+
+      # Loop through each schedule and delete them one by one
+      # TODO: share the ssh connection for this so it's faster when
+      # many schedules exist
+      # TODO: what if one schedule removal fails but others don't? Should
+      # we try and rollback somehow or just return the job with half its
+      # schedules deleted?
+      job.schedules.each do |schedule|
+        delete_schedule(job, schedule.formatted, conn)
+      end
+    end
+
+    # Delete a host and all it's jobs from the crontab
+    #
+    # @param job [Minicron::Hub::Job] a job instance with it's schedules
+    # @param conn an instance of an open ssh connection
+    def delete_host(host, conn = nil)
+      conn ||= @ssh.open
+
+      # Loop through each job and delete them one by one
+      # TODO: share the ssh connection for this so it's faster when
+      # many schedules exist
+      # TODO: what if one schedule removal fails but others don't? Should
+      # we try and rollback somehow or just return the job with half its
+      # schedules deleted?
+      host.jobs.each do |job|
+        delete_job(job, conn)
+      end
+    end
+  end
+end

data/lib/minicron/hub/app.rb

@@ -0,0 +1,132 @@
+require 'minicron'
+require 'sinatra/base'
+require 'sinatra/activerecord'
+require 'sinatra/assetpack'
+require 'erubis'
+require 'oj'
+
+module Minicron::Hub
+  class App < Sinatra::Base
+    register Sinatra::ActiveRecordExtension
+    register Sinatra::AssetPack
+
+    # Set the application root
+    set :root, Minicron::HUB_PATH
+
+    configure do
+      # Don't log them. We'll do that ourself
+      set :dump_errors, false
+
+      # Don't capture any errors. Throw them up the stack
+      set :raise_errors, true
+
+      # Disable internal middleware for presenting errors
+      # as useful HTML pages
+      set :show_exceptions, false
+    end
+
+    # Configure how we server assets
+    assets do
+      serve '/css',   :from => 'assets/css'
+      serve '/js',    :from => 'assets/js'
+      serve '/fonts', :from => 'assets/fonts'
+      serve '/app',   :from => 'assets/app'
+
+      # Set up the application css
+      css :app, '/css/all.css', [
+        '/css/bootswatch.min.css',
+        '/css/main.css'
+      ]
+
+      # Set up the application javascript
+      js :app, '/js/all.js', [
+        # Dependencies, the order of these is important
+        '/js/jquery-2.1.0.min.js',
+        '/js/handlebars-1.3.0.min.js',
+        '/js/ember-1.4.1.min.js',
+        '/js/ember-data-1.0.0-beta.7.f87cba88.min.js',
+        '/js/faye-browser-1.0.1.min.js',
+        '/js/ansi_up-1.1.1.min.js',
+        '/js/bootstrap-3.1.1.min.js',
+        '/js/moment-2.5.1.min.js',
+
+        # Ember application files
+        '/app/**/*.js'
+      ]
+    end
+
+    # Called on class initilisation, sets up the database and requires all
+    # the application files
+    def initialize
+      super
+
+      # Initialize the db
+      Minicron::Hub::App.setup_db
+
+      # Load all our model serializers
+      Dir[File.dirname(__FILE__) + '/serializers/*.rb'].each do |serializer|
+        require serializer
+      end
+
+      # Load all our models
+      Dir[File.dirname(__FILE__) + '/models/*.rb'].each do |model|
+        require model
+      end
+
+      # Load all our controllers
+      Dir[File.dirname(__FILE__) + '/controllers/**/*.rb'].each do |controller|
+        require controller
+      end
+    end
+
+    # Used to set up the database connection
+    def self.setup_db
+      # Configure the database
+      case Minicron.config['database']['type']
+      when 'mysql'
+        set :database, {
+          :adapter => 'mysql2',
+          :host => Minicron.config['database']['host'],
+          :database => Minicron.config['database']['database'],
+          :username => Minicron.config['database']['username'],
+          :password => Minicron.config['database']['password']
+        }
+      else
+        raise Exception, "The database #{Minicron.config['database']['type']} is not supported"
+      end
+    end
+  end
+
+  # Based on http://hawkins.io/2013/06/error-handling-in-sinatra-apis/
+  class ExceptionHandling
+    def initialize(app)
+      @app = app
+    end
+
+    def handle_exception(env, e, status)
+      if Minicron.config['global']['trace']
+        env['rack.errors'].puts(e)
+        env['rack.errors'].puts(e.backtrace.join("\n"))
+        env['rack.errors'].flush
+      end
+
+      # Display the error message
+      hash = { :error => e.to_s }
+
+      # Display the full trace if tracing is enabled
+      hash[:trace] = e.backtrace if Minicron.config['global']['trace']
+
+      [status, { 'Content-Type' => 'application/json' }, [hash.to_json]]
+    end
+
+    def call(env)
+      begin
+        @app.call env
+      rescue ActiveRecord::RecordNotFound => e
+        handle_exception(env, e, 404)
+      rescue Exception => e
+        handle_exception(env, e, 500)
+      end
+    end
+  end
+end

data/lib/minicron/hub/assets/app/application.js

@@ -0,0 +1,151 @@
+'use strict';
+
+(function() {
+  window.Minicron = Ember.Application.create({
+    LOG_TRANSITIONS: true,
+    LOG_ACTIVE_GENERATION: true,
+    LOG_VIEW_LOOKUPS: true,
+    LOG_TRANSITIONS_INTERNAL: true
+  });
+
+  // This should be called by all views when they are loaded
+  Minicron.onViewLoad = function() {
+    // Twitter tooltip plugin
+    Ember.$('body').tooltip({
+      selector: '[data-toggle=tooltip]'
+    });
+  };
+
+  // Configure Ember Data so it can find the API
+  Minicron.ApplicationAdapter = DS.RESTAdapter.extend({
+    namespace: 'api',
+  });
+
+  Minicron.ApplicationController = Ember.ArrayController.extend({
+    sortedExecutions: function() {
+      return this.get('content').toArray().sort(function(a, b) {
+        a = +moment(a.get('created_at'));
+        b = +moment(b.get('created_at'));
+
+        if (a > b) {
+           return -1;
+        } else if (a < b) {
+          return 1;
+        }
+
+        return 0;
+      });
+    }.property('content.@each').cacheable()
+  });
+
+  Minicron.ApplicationRoute = Ember.Route.extend({
+    actions: {
+      error: function(error) {
+        console.log(error);
+
+        // Create a new error to be passed as the controller
+        var ember_error = new Ember.Error();
+
+        // Set the details of the error we need
+        ember_error.name = 'Error';
+        ember_error.message = error.responseJSON.error;
+        ember_error.number = error.status;
+
+        this.render('fatal-error', {
+          controller: ember_error
+        });
+      }
+    },
+    model: function() {
+      return this.store.find('execution');
+    },
+    setupController: function(controller, model) {
+      controller.set('application', model);
+      this._super(controller, model);
+    },
+    afterModel: function(model, transition) {
+      var client = new Faye.Client(window.location.protocol + '//' + window.location.host + '/faye'),
+          store = model.store,
+          self = this;
+          window.store = store;
+
+      client.addExtension({
+        incoming: function(message, callback) {
+          // We only care about job messages
+          if (message.channel.substr(1, 3) === 'job') {
+            var segments = message.channel.split('/');
+            var job_id = segments[2];
+            var job_execution_id = segments[3];
+            var type = segments[4];
+            var message_data = message.data.message;
+
+            // TODO: remove this!
+            console.log(job_id, job_execution_id, type, message);
+
+            // Is it a status message?
+            if (type === 'status') {
+              // Is it a setup message
+              if (typeof message_data.action != 'undefined' && message_data.action === 'SETUP') {
+                // The SETUP message is defined slightly differently, segment 2 contains the
+                // job hash and segment 3 contains '*job_id*-*job_execution_id*'
+                var ids = job_execution_id.split('-');
+                    job_id = ids[0];
+                    job_execution_id = ids[1];
+
+                // Append the job relationship to it
+                store.find('job', job_id).then(function(job) {
+                  // Create the execution
+                  store.push('execution', {
+                    id: job_execution_id,
+                    created_at: moment.utc(message.data.ts).format('YYYY-MM-DDTHH:mm:ss[Z]'),
+                    job: job
+                  }, true);
+                });
+              // Is it a start message?
+              } else if (message_data.substr(0, 5) === 'START') {
+                // Set the execution start time
+                store.find('execution', job_execution_id).then(function(execution) {
+                  execution.set('started_at', moment.utc(message_data.substr(6)).format('YYYY-MM-DDTHH:mm:ss[Z]'));
+                });
+              // Is it a finish message?
+              } else if (message_data.substr(0, 6) === 'FINISH') {
+                // Set the execution finish time
+                store.find('execution', job_execution_id).then(function(execution) {
+                  execution.set('finished_at', moment.utc(message_data.substr(7)).format('YYYY-MM-DDTHH:mm:ss[Z]'));
+                });
+              // Is it an exit message?
+              } else if (message_data.substr(0, 4) === 'EXIT') {
+                // Set the execution exit status
+                store.find('execution', job_execution_id).then(function(execution) {
+                  execution.set('exit_status', +message_data.substr(5));
+                });
+              }
+            // Is it an output message?
+            } else if (type === 'output') {
+              store.find('execution', job_execution_id).then(function(execution) {
+                // Add this bit of job execution output
+                var output = store.createRecord('job_execution_output', {
+                    id: message.data.job_execution_output_id,
+                    output: message_data,
+                    seq: message.data.seq,
+                    timestamp: moment(message.data.ts).format()
+                });
+
+                output.set('execution', execution);
+
+                execution.get('job_execution_outputs').then(function(outputs) {
+                  outputs.pushObject(output);
+                });
+              });
+            }
+          }
+
+          // We're done with the message, pass it back to Faye
+          callback(message);
+        }
+      });
+
+      client.subscribe('/job/**');
+    }
+  });
+})();