minicron 0.2 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa2c40fa9887bb6c06b46153ba397a13806ed4f9
-  data.tar.gz: e1fc6d9b267c3e0a21727328f25922ecffeae9e4
+  metadata.gz: 9dd39723811b197138d5655e871e4c07fb49d4d4
+  data.tar.gz: 30b855c523a3ce04c9aaa83bc0a348b950e947c4
 SHA512:
-  metadata.gz: 3f8fa7cdcd2a80623bbf1a0c3f266e575f9c3da024325579e96b65a523158212ac879ced4cffa834a11f150c14c3bfce48d921b90004ec380a5629779af89e14
-  data.tar.gz: 3e48387f403abbf3b34d1efd85bb4f3d33aec113a20abfce5336c6e801794d9a49a6f0e00e7844af12e4aa87a298de04632a6a2bffaf13b8686519ae790e34b7
+  metadata.gz: 5cb855f69d4a2727a5f837df5a96f9c1ff68a85f74150ca2f1c9497729f733af92517e7eb72fbf65457b0483205055c0f2ec9d9b596751f468da79449e2ae13a
+  data.tar.gz: 3181ea25877f42863c5317d39bb8a6998d563b5d55f75f6d06c0f478c140c3c76114e342edc30fd8d49c68e40c56abb7c1aa91318088eb330ede9b94ef116c79

data/README.md

@@ -84,7 +84,7 @@ but I encourage you to give it a try in a non critical environment and help me t
 
 2. On some distributions you may need to install the ````ruby-dev```` and ````build-essential```` packages
 
-3. To install the latest release (currently 0.2) you can ````gem install minicron````, depending on your ruby setup
+3. To install the latest release (currently 0.3) you can ````gem install minicron````, depending on your ruby setup
    you may need to run this with ````sudo````
 
 4. Set your database configuration options in ````/etc/minicron.toml````, you can use the [default.config.toml](https://github.com/jamesrwhite/minicron/blob/master/default.config.toml) as a guide on what options are configurable
@@ -144,7 +144,7 @@ by default it will bind to port 9292 on the host 127.0.0.1 but this can be confi
 arguments ````--host```` ````--port```` and ````--path```` or in the config file.
 
 By default the server will run as a daemon with its process id stored in ````/tmp/minicron.pid````
-you can also use the ````stop```` ````restart```` and ````status```` commands to control the server.
+you can also use the ````stop```` and ````status```` commands to control the server.
 
 To run the server in debug mode, i.e not as a daemon so you can see its output you can pass the ````--debug````
 option.

data/bin/minicron

@@ -1,11 +1,14 @@
 #!/usr/bin/env ruby
+require 'insidious'
 require 'minicron'
+require 'minicron/cli'
+require 'minicron/transport/server'
 
 begin
   # Capture any output from STDERR so we can handle it how we want to
   Minicron.capture_output(:type => :stderr) do
     # Run the CLI and pass it all arguments passed to us
-    Minicron::CLI.new.run(ARGV) do |output|
+    Minicron::CLI.run(ARGV) do |output|
       print output
       STDOUT.flush
     end
@@ -13,14 +16,26 @@ begin
 # Handle ctrl-c and other nasty interruptions
 rescue Interrupt, SignalException
   puts "\nExiting.."
+
+  # Stop the daemon if it's running i.e tidy up the pid file
+  insidious = Insidious.new(:pid_file => '/tmp/minicron.pid')
+
+  if insidious.running?
+    insidious.stop!
+  end
 # Accept failure
 rescue Exception => e
   $stderr.write("#{e.message}\n")
 
-  if Minicron.config['cli']['trace']
+  if Minicron.config['trace']
     puts
     fail e
   end
 
   exit(1)
+ensure
+  # Shut down the server if it's running
+  if Minicron::Transport::Server.running?
+    Minicron::Transport::Server.stop!
+  end
 end

data/lib/minicron.rb

@@ -1,17 +1,14 @@
 require 'stringio'
 require 'toml'
 require 'sshkey'
-require 'minicron/cli'
 require 'minicron/constants'
 
 # @author James White <dev.jameswhite+minicron@gmail.com>
 module Minicron
   # Default configuration, this can be overriden
   @config = {
-    'global' => {
-      'verbose' => false,
-      'trace' => false
-    },
+    'verbose' => false,
+    'trace' => false,
     'client' => {
       'scheme' => 'http',
       'host' => '127.0.0.1',
@@ -77,22 +74,24 @@ module Minicron
         raise Exception, "Unable to the load the file '#{file_path}', are you sure it exists?"
       end
     rescue Errno::EACCES
-      fail Exception, "Unable to the readthe file '#{file_path}', check it has the right permissions."
+      fail Exception, "Unable to the read the file '#{file_path}', check it has the right permissions."
     rescue TOML::ParseError
       fail Exception, "An error occured parsing the config file '#{file_path}', please check it uses valid TOML syntax."
     end
   end
 
-  # Parses the config options from the cli
-  # @option options [Hash] global global options
-  # @option options [Hash] server server options
-  # @option options [Hash] cli cli options
-  def self.parse_cli_config(options = {})
-    options.each do |type, _|
-      options[type].each do |key, value|
-        if value
-          @config[type][key] = value
+  # Parses the config options from the given hash that matches the expected
+  # config format in Minicron.config
+  def self.parse_config_hash(options = {})
+    options.each do |key, value|
+      if options[key].respond_to?(:each)
+        options[key].each do |k, v|
+          if !v.nil?
+            @config[key][k] = v
+          end
         end
+      else
+        @config[key] = value
       end
     end
   end
@@ -143,21 +142,6 @@ module Minicron
     end
   end
 
-  # Sanitize a filename - taken from http://guides.rubyonrails.org/security.html
-  #
-  # @param filename [String]
-  # @return [String]
-  def self.sanitize_filename(filename)
-    filename.strip.tap do |name|
-      name.sub!(/\A.*(\\|\/)/, '')
-      # Finally, replace all non alphanumeric, underscore
-      # or periods with underscore
-      name.gsub!(/[^\w\.\-]/, '_')
-    end
-
-    filename
-  end
-
   # Used to generate SSH keys for hosts but is completely generic
   #
   # @param type [String] the thing that is using the key, this is just here
@@ -168,8 +152,8 @@ module Minicron
     key = SSHKey.generate(:comment => "minicron public key for #{name}")
 
     # Set the locations to save the public key private key pair
-    private_key_path = sanitize_filename(File.expand_path("~/.ssh/minicron_#{type}_#{id}_rsa"))
-    public_key_path = sanitize_filename(File.expand_path("~/.ssh/minicron_#{type}_#{id}_rsa.pub"))
+    private_key_path = File.expand_path("~/.ssh/minicron_#{type}_#{id}_rsa")
+    public_key_path = File.expand_path("~/.ssh/minicron_#{type}_#{id}_rsa.pub")
 
     # Save the public key private key pair
     File.write(private_key_path, key.private_key)
@@ -181,4 +165,18 @@ module Minicron
 
     key
   end
+
+  # Get the system fully qualified domain name
+  #
+  # @return [String]
+  def self.get_fqdn
+    `hostname -f`.strip
+  end
+
+  # Get the system short hostname
+  #
+  # @return [String]
+  def self.get_hostname
+    `hostname -s`.strip
+  end
 end

data/lib/minicron/alert/pagerduty.rb

@@ -34,7 +34,7 @@ module Minicron
     # @param title [String]
     # @param message [String]
     def send(title, message)
-      @client.trigger(title,  :message => message)
+      @client.trigger(title, :message => message)
     end
   end
 end

data/lib/minicron/cli.rb

@@ -2,8 +2,8 @@ require 'pty'
 require 'English'
 require 'rainbow/ext/string'
 require 'commander'
-require 'insidious'
 require 'minicron/constants'
+require 'minicron/cli/commands'
 require 'minicron/transport'
 require 'minicron/transport/client'
 require 'minicron/transport/server'
@@ -14,20 +14,18 @@ include Commander::UI
 module Minicron
   # Handles the main CLI interaction of minicron
   # TODO: this class is probably too complicated and should be refactored a bit
-  class CLI
+  module CLI
     # Function to the parse the config of the options passed to commands
     #
     # @param opts [Hash] The Commander provided options hash
-    def parse_config(opts)
+    def self.parse_config(opts)
       # Parse the --config file options if it was passed
       Minicron.parse_file_config(opts.config)
 
       # Parse the cli options
-      Minicron.parse_cli_config(
-        'global' => {
-          'verbose' => opts.verbose,
-          'trace' => opts.trace
-        },
+      Minicron.parse_config_hash(
+        'verbose' => opts.verbose,
+        'trace' => opts.trace,
         'cli' => {
           'mode' => opts.mode,
           'dry_run' => opts.dry_run
@@ -46,7 +44,7 @@ module Minicron
     # @param type [Symbol] The type of command output, currently one of :status, :command and :verbose
     # @param output [String]
     # @return [Hash]
-    def structured(type, output)
+    def self.structured(type, output)
       { :type => type, :output => output }
     end
 
@@ -57,7 +55,7 @@ module Minicron
     # @raise [ArgumentError] if no arguments are passed to the run cli command
     # i.e when the argv param is ['run']. A second option (the command to execute)
     # should be present in the array
-    def run(argv)
+    def self.run(argv)
       # replace ARGV with the contents of argv to aid testability
       ARGV.replace(argv)
 
@@ -65,16 +63,16 @@ module Minicron
       @cli = Commander::Runner.new
 
       # Set some default otions on it
-      setup_cli
+      setup
 
       # Add the run command to the cli
-      add_run_cli_command { |output| yield output }
+      Minicron::CLI::Commands.add_run_cli_command(@cli) { |output| yield output }
 
       # Add the server command to the cli
-      add_server_cli_command
+      Minicron::CLI::Commands.add_server_cli_command(@cli)
 
       # Add the db command to the cli
-      add_db_cli_command
+      Minicron::CLI::Commands.add_db_cli_command(@cli)
 
       # And off we go!
       @cli.run!
@@ -88,7 +86,7 @@ module Minicron
     # @option options [Boolean] verbose whether or not to output extra
     # information for debugging purposes.
     # @yieldparam output [String] output from the command execution
-    def run_command(command, options = {})
+    def self.run_command(command, options = {})
       # Default the options
       options[:mode] ||= 'line'
       options[:verbose] ||= false
@@ -159,7 +157,7 @@ module Minicron
     # enabled by default
     #
     # @return [Boolean] whether rainbow is enabled or not
-    def coloured_output?
+    def self.coloured_output?
       Rainbow.enabled
     end
 
@@ -167,7 +165,7 @@ module Minicron
     # by default
     #
     # @return [Boolean] whether rainbow is enabled or not
-    def enable_coloured_output!
+    def self.enable_coloured_output!
       Rainbow.enabled = true
     end
 
@@ -175,14 +173,14 @@ module Minicron
     # by default
     #
     # @return [Boolean] whether rainbow is enabled or not
-    def disable_coloured_output!
+    def self.disable_coloured_output!
       Rainbow.enabled = false
     end
 
     private
 
     # Sets the basic options for a commander cli instance
-    def setup_cli
+    def self.setup
       # basic information for the help menu
       @cli.program :name, 'minicron'
       @cli.program :help, 'Author', 'James White <dev.jameswhite+minicron@gmail.com>'
@@ -195,203 +193,16 @@ module Minicron
 
       # Check if --trace was pased or not
       if @cli.instance_variable_get(:@args).include? '--trace'
-        Minicron.config['global']['trace'] = true
+        Minicron.config['trace'] = true
       end
 
       # Add a global option for verbose mode
       @cli.global_option '--verbose', "Turn on verbose mode. Default: #{Minicron.config['cli']['verbose']}" do
-        Minicron.config['global']['verbose'] = true
+        Minicron.config['verbose'] = true
       end
 
       # Add a global option for passing the path to a config file
       @cli.global_option '--config FILE', 'Set the config file to use'
     end
-
-    # Setup a job by sending the SETUP command to the server
-    #
-    # @param command [String] the job command
-    # @param faye a faye client instance
-    # @return [Hash] the job_id and execution_id
-    def setup_job(command, faye)
-      # Get the fully qualified domain name of the currnet host
-      fqdn = `hostname -f`.strip
-
-      # Get the short hostname of the current host
-      hostname = `hostname -s`.strip
-
-      # Get the md5 hash for the job
-      job_hash = Minicron::Transport.get_job_hash(command, fqdn)
-
-      # Fire up eventmachine
-      faye.ensure_em_running
-
-      # Setup the job on the server
-      ids = faye.setup(job_hash, command, fqdn, hostname)
-
-      # Wait until we get the execution id
-      faye.ensure_delivery
-
-      # Return the ids
-      ids
-    end
-
-    # Start the server and monitor
-    def start_server
-      # Run the execution monitor (this runs in a separate thread)
-      monitor = Minicron::Monitor.new
-      monitor.start!
-
-      # Start the server!
-      server = Minicron::Transport::Server.new
-      server.start!(
-        Minicron.config['server']['host'],
-        Minicron.config['server']['port'],
-        Minicron.config['server']['path']
-      )
-    end
-
-    # Add the `minicron db` command
-    def add_db_cli_command
-      @cli.command :db do |c|
-        c.syntax = 'minicron db [setup]'
-        c.description = 'Sets up the minicron database schema.'
-
-        c.action do |args, opts|
-          # Check that exactly one argument has been passed
-          if args.length != 1
-            fail ArgumentError, 'A valid command to run is required! See `minicron help db`'
-          end
-
-          # Parse the file and cli config options
-          parse_config(opts)
-
-          # These are inlined as we only need them in this use case
-          require 'rake'
-          require 'minicron/hub/app'
-          require 'sinatra/activerecord/rake'
-
-          # Setup the db
-          Minicron::Hub::App.setup_db
-
-          # Tell activerecord where the db folder is, it assumes it is in db/
-          Sinatra::ActiveRecordTasks.db_dir = Minicron::HUB_PATH + '/db'
-
-          # Adjust the task name
-          task = args.first == 'setup' ? 'load' : args.first
-
-          # Run the task
-          Rake.application['db:schema:' + task].invoke
-        end
-      end
-    end
-
-    # Add the `minicron server` command
-    def add_server_cli_command
-      @cli.command :server do |c|
-        c.syntax = 'minicron server [start|stop|restart|status]'
-        c.description = 'Controls the minicron server.'
-        c.option '--host STRING', String, "The host for the server to listen on. Default: #{Minicron.config['server']['host']}"
-        c.option '--port STRING', Integer, "How port for the server to listed on. Default: #{Minicron.config['server']['port']}"
-        c.option '--path STRING', String, "The path on the host. Default: #{Minicron.config['server']['path']}"
-        c.option '--debug', "Enable debug mode. Default: #{Minicron.config['server']['debug']}"
-
-        c.action do |args, opts|
-          # Parse the file and @cli config options
-          parse_config(opts)
-
-          # If we get no arguments then default the action to start
-          action = args.first.nil? ? 'start' : args.first
-
-          # Get an instance of insidious and set the pid file
-          insidious = Insidious.new(
-            :pid_file => '/tmp/minicron.pid',
-            :daemonize => Minicron.config['server']['debug'] == false
-          )
-
-          case action
-          when 'start'
-            insidious.start! { start_server }
-          when 'stop'
-            insidious.stop!
-          when 'restart'
-            insidious.restart! { start_server }
-          when 'status'
-            if insidious.running?
-              puts 'minicron is running'
-            else
-              puts 'minicron is not running'
-            end
-          end
-        end
-      end
-    end
-
-    # Add the `minicron run [command]` command
-    # @yieldparam output [String] output from the cli
-    def add_run_cli_command
-      # Add the run command to the cli
-      @cli.command :run do |c|
-        c.syntax = "minicron run 'command -option value'"
-        c.description = 'Runs the command passed as an argument.'
-        c.option '--mode STRING', String, "How to capture the command output, each 'line' or each 'char'? Default: #{Minicron.config['cli']['mode']}"
-        c.option '--dry-run', "Run the command without sending the output to the server.  Default: #{Minicron.config['cli']['dry_run']}"
-
-        c.action do |args, opts|
-          # Check that exactly one argument has been passed
-          if args.length != 1
-            fail ArgumentError, 'A valid command to run is required! See `minicron help run`'
-          end
-
-          # Parse the file and cli config options
-          parse_config(opts)
-
-          begin
-            # Set up the job and get the job and execution ids
-            unless Minicron.config['cli']['dry_run']
-              # Get a faye instance so we can send data about the job
-              faye = Minicron::Transport::Client.new(
-                Minicron.config['client']['scheme'],
-                Minicron.config['client']['host'],
-                Minicron.config['client']['port'],
-                Minicron.config['client']['path']
-              )
-
-              # Set up the job and get the jexecution and job ids back from the server
-              ids = setup_job(args.first, faye)
-            end
-
-            # Execute the command and yield the output
-            run_command(args.first, :mode => Minicron.config['cli']['mode'], :verbose => Minicron.config['global']['verbose']) do |output|
-              # We need to handle the yielded output differently based on it's type
-              case output[:type]
-              when :status
-                unless Minicron.config['cli']['dry_run']
-                  faye.send(:job_id => ids[:job_id], :execution_id => ids[:execution_id], :type => :status, :message => output[:output])
-                end
-              when :command
-                unless Minicron.config['cli']['dry_run']
-                  faye.send(:job_id => ids[:job_id], :execution_id => ids[:execution_id], :type => :output, :message => output[:output])
-                end
-              end
-
-              yield output[:output] unless output[:type] == :status
-            end
-          rescue Exception => e
-            # Send the exception message to the server and yield it
-            unless Minicron.config['cli']['dry_run']
-              faye.send(:job_id => ids[:job_id], :execution_id => ids[:execution_id], :type => :output, :message => e.message)
-            end
-
-            raise e
-          ensure
-            # Ensure that all messages are delivered and that we
-            unless Minicron.config['cli']['dry_run']
-              faye.ensure_delivery
-              faye.tidy_up
-            end
-          end
-        end
-      end
-    end
   end
 end