cuted 1.0.0

data/bin/cute

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+# David Selassie
+# April 28, 2011
+
+# USAGE: cute CMD
+# Enqueues a command to be executed by cuted.
+
+require 'trollop'
+require 'drb'
+
+config = {'uri' => 'drbunix:///tmp/cuted.sock'}
+if File.exists?(File.expand_path('~/.cuterc')) then
+  config.merge!(ParseConfig.new(File.expand_path('~/.cuterc')).params)
+end
+
+options = Trollop::options do
+  opt :dir, 'run command in a dir other than the CWD', :default => Dir.pwd
+  opt :weight, 'weight of this command', :default => 1
+  opt :priority, 'priority of this command', :default => 0
+  opt :log, 'custom log file to use'
+  opt :prowl_key, 'custom Prowl key to notify'
+  opt :uri, 'server to submit commands to', :type => :string,
+    :default => ENV['cuted_uri'] || config['uri']
+end
+Trollop::die 'cute: You must specify a command' if ARGV.length < 1
+
+# Join together the rest of the arguments as the command.
+cmd = ARGV.join(' ')
+
+begin
+  DRb.start_service
+  queue = DRbObject.new(nil, options[:uri])
+
+  # Get the real command stored in the queue.
+  cmd = queue.push_cmd(cmd)
+
+  # Set up attributes.
+  cmd.dir = options[:dir]
+  cmd.priority = options[:priority]
+  cmd.weight = options[:weight]
+  # Set a custom Prowl key if one is specified.
+  cmd.prowl_key = options[:prowl_key] if options[:prowl_key]
+  # Set a custom log if one is specified and it isn't empty.
+  cmd.log = options[:log] if options[:log] and options[:log].size > 0
+
+  # Try to run tasks.
+  queue.pop_run
+
+  puts "Command '#{cmd}' submitted"
+rescue DRb::DRbConnError => err
+  puts "Could not connect to '#{options[:server]}'"
+
+  exit 1
+end

data/bin/cuted

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+# David Selassie
+# April 28, 2011
+
+# USAGE: cuted start | stop | run [-- ...]
+# A simple process queue daemon. Add processes using the cute command.
+
+# Requires a daemonizer!
+require 'daemons'
+# Also requires this simple config parser.
+require 'parseconfig'
+require 'logger'
+require 'drb'
+
+require 'cuted/queue'
+
+Daemons.run_proc('cuted', :dir => '~', :log_output => true) do
+  logger = Logger.new(STDOUT)
+
+  # Set up defaults that might be overwritten.
+  config = {'max_concurrent' => 4, 'log' => 'cute.log',
+    'uri' => 'drbunix:///tmp/cuted.sock'}
+  # See if there's any user settings in ~/.cuterc and write them on top.
+  if File.exists?(File.expand_path('~/.cuterc'))
+    config.merge!(ParseConfig.new(File.expand_path('~/.cuterc')).params)
+    # If the log variable is there but blank, make it nil.
+    if config['log'] and config['log'].strip.length == 0 then
+      config['log'] = nil
+    end
+  end
+
+  # Use the environment variable PROWLKEY if it's there.
+  config['prowl_key'] = ENV['PROWLKEY'] if ENV['PROWLKEY']
+
+  logger.info "Will run #{config['max_concurrent']} processes concurrently"
+  logger.info 'Will log command outputs' if config['log']
+  if config['prowl_key'] then
+    logger.info "Will notify Prowl key #{config['prowl_key']} of completions"
+  end
+
+  begin
+    queue = Cuted::Queue.new(:logger => logger,
+                            :max_concurrent => config['max_concurrent'],
+                            :defaults => {:prowl_key => config['prowl_key'],
+                              :log => config['log']})
+    DRb.start_service(config['uri'], queue)
+
+    logger.info "Running on #{DRb.uri}"
+    ENV['cuted_uri'] = DRb.uri
+
+    # Wait. Let clients call methods on the queue.
+    DRb.thread.join
+  rescue Interrupt
+    logger.info 'Exiting'
+  end
+end

data/lib/cuted/command.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+# David Selassie
+# March 29, 2012
+# cutejob.rb
+
+# Structure for holding a queued shell command.
+
+module Cuted
+  class Command
+    require 'drb'
+    require 'fileutils'
+
+    # Make sure the command is stored on the server.
+    include DRbUndumped
+
+    attr_accessor :dir, :cmd, :weight, :priority, :log, :prowl_key
+    attr_reader :pid
+
+    def initialize(cmd, opts = {})
+      @cmd = cmd.to_s
+      # If the options are set, use them; otherwise defaults.
+      @dir = opts[:dir] || Dir.pwd
+      # Since we can force opts[:log] to be nil, and we don't want the default.
+      @log = opts.has_key?(:log) ? opts[:log] : 'cute.log'
+      @priority = opts[:priority] || 0
+      @weight = opts[:weight] || 1
+    end
+
+    # Runs in the current thread.
+    def run
+      # Make sure the desired working directory exists.
+      FileUtils.makedirs(@dir) if not File.directory?(@dir)
+      # Actually run the command.
+      if @log then
+        @pid = spawn(@cmd, :chdir => @dir, [:out, :err] => [@log, 'a'])
+      else
+        @pid = spawn(@cmd, :chdir => @dir, [:out, :err] => '/dev/null')
+      end
+
+      # In the forked process, wait for the command to be done.
+      Process.waitall
+
+      # Report that this command finished.
+      begin
+        require 'prowler'
+        Prowler.verify_certificate = false
+        Prowler.application = 'cuted'
+        Prowler.notify(@cmd, "Finished in #{@dir}", @prowl_key) if @prowl_key
+      rescue LoadError
+      end
+
+      # Return the CuteCommand.
+      self
+    end
+
+    # Print out dir> command string.
+    def to_s
+      "#{@dir}> #{@cmd}"
+    end
+  end
+end

data/lib/cuted/queue.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+# David Selassie
+# March 29, 2012
+# cutequeue.rb
+
+# Priority command queue.
+
+module Cuted
+  class Queue
+    attr_accessor :running, :queue
+
+    def initialize(opts = {})
+      @queue = []
+      @running = []
+
+      # If the options are set, then use them; otherwise defaults.
+      @defaults = opts[:defaults] || {}
+      @max_concurrent = opts[:max_concurrent] || 4
+      @logger = opts[:logger]
+    end
+
+    # Takes the text of a command or any structure that responds to :run.
+    def push_cmd(cmd)
+      @logger.info "Pushed command '#{cmd}'" if @logger
+
+      # Really we just need a command to be able to run.
+      if not cmd.respond_to?(:run)
+        require 'cuted/command'
+        cmd = Command.new(cmd)
+      end
+    
+      # Set up the command with the default values.
+      @defaults.each do |k, v|
+        cmd.send("#{k}=", v) if cmd.respond_to?("#{k}=")
+      end
+
+      @queue << cmd
+      sort
+
+      cmd
+    end
+
+    # Puts the highest priority commands first.
+    def sort
+      # If there is no priority, use 0.
+      @queue.sort_by! { |cmd| cmd.respond_to?(:priority) ? -cmd.priority : 0 }
+
+      self
+    end
+
+    # Return the highest priority command.
+    def peek
+      @queue[0]
+    end
+
+    # Find the highest priority item and run it.
+    #  If continue is true, then run other commands in the queue when done.
+    def pop_run(continue = true)
+      # If there are no commands, do nothing.
+      if @queue.length < 1 then
+        @logger.info 'No commands to run' if @logger
+        return
+        # If there isn't enough free weight to run, do nothing.
+      elsif peek.weight > @max_concurrent - @running.size and
+          @running.size > 0 then
+        @logger.info 'Not enough free weight to run' if @logger
+        return
+      end
+
+      # Pop off the highest priority command.
+      cmd = @queue.delete_at(0)
+      sort
+
+      # Run the command and return it.
+      @logger.info "Starting #{cmd}" if @logger
+
+      # Find out the weight of this command.
+      weight = cmd.respond_to?(:weight) ? cmd.weight : 1
+      # Add this command that many times to the running array.
+      @running.concat([cmd] * weight)
+
+      # In a separate thread...
+      thread = Thread.new do
+        # Run the command.
+        cmd.run
+
+        @logger.info "Finished #{cmd}" if @logger
+        # Make the command remove itself from the running list.
+        @running.delete_if { |o| o === cmd }
+        # Try to run queued commands once this one is done if we're continuing.
+        pop_run if continue
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: cuted
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- David Selassie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: riot
+  requirement: &70245431926940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: *70245431926940
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: &70245431926160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70245431926160
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: &70245431925580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70245431925580
+- !ruby/object:Gem::Dependency
+  name: parseconfig
+  requirement: &70245431924920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70245431924920
+description: 
+email: selassid@gmail.com
+executables:
+- cuted
+- cute
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cuted/queue.rb
+- lib/cuted/command.rb
+- !binary |-
+  YmluL2N1dGVk
+- !binary |-
+  YmluL2N1dGU=
+homepage: http://github.com/selassid/cuted
+licenses: []
+post_install_message: Install optional gem 'prowler' for Prowl notifications when
+  commands are complete.
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: A simple single-machine batch queueing system.
+test_files: []