schedule 0.0.1

data/README.md

@@ -0,0 +1 @@
+A Ruby replacement for Cron

data/Rakefile

@@ -0,0 +1,115 @@
+require "rubygems"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "rake/testtask"
+
+task :default => :test
+
+spec = Gem::Specification.new do |s|
+  s.name              = "schedule"
+  s.version           = "0.0.1"
+  s.summary           = "A Ruby replacement for Cron"
+  s.author            = "Mark Dodwell"
+  s.email             = "hi@mkdynamic.co.uk"
+  s.homepage          = "http://github.com/mkdynamic/schedule"
+
+  # Rdoc
+  # s.has_rdoc          = true
+  # s.extra_rdoc_files  = %w(README.md)
+  # s.rdoc_options      = %w(--main README.md)
+
+  # Files
+  s.files             = %w(Rakefile README.md) + Dir.glob("{bin,lib,test}/**/*")
+  s.executables       = FileList["bin/**"].map { |f| File.basename(f) }
+  s.require_paths     = ["bin", "lib"]
+
+  # Dependencies
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.3")
+  s.add_development_dependency("shoulda")
+  s.add_development_dependency("timecop")
+end
+
+#
+# Specification
+#
+
+desc "Build the gemspec file #{spec.name}.gemspec"
+task :gemspec do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, "w") { |f| f.write(spec.to_ruby) }
+end
+
+#
+# Build
+#
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+task :package => :gemspec # build gemspec when packaging
+
+#
+# Tests
+#
+
+Rake::TestTask.new do |t|
+  t.libs = [File.expand_path("lib"), "test"]
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+#
+# Documentation
+#
+
+# Rake::RDocTask.new do |rd|
+#   rd.main = "README.md"
+#   rd.rdoc_files.include("README.md", "lib/**/*.rb")
+#   rd.rdoc_dir = "rdoc"
+# end
+
+# desc "Clear out RDoc and generated packages"
+# task :clean => [:clobber_rdoc, :clobber_package] do
+#   rm "#{spec.name}.gemspec"
+# end
+
+#
+# Release
+#
+
+desc "Tag the repository in git with gem version number"
+task :tag do
+  #`git fetch --tags`
+  if `git tag`.split("\n").include?("v#{spec.version}")
+    raise "Version #{spec.version} has already been released."
+  end
+  
+  changed_files = `git diff --cached --name-only`.split("\n") + `git diff --name-only`.split("\n")
+  if changed_files == ["Rakefile"]
+    # MAGIC! automatically update Schedule::VERSION constant
+    file = "lib/#{spec.name}.rb"
+    s = File.read(file)
+    File.open(file, "w") do |f|
+      f.write(s.gsub(/^(\s*)VERSION(\s*)=(\s*)(["'])[\d\.]+(['"])(\s*)$/, %{\\1VERSION\\2=\\3\\4#{spec.version.to_s}\\5\\6}))
+    end
+    if File.read(file).match(/^\s*VERSION\s*=\s*"([\d\.]+)"\s*$/)[1] != spec.version.to_s
+      "VERSION constant in #{file} differs from gemspec version."
+    end
+    
+    Rake::Task["package"].invoke
+    
+    `git add #{File.expand_path("../#{spec.name}.gemspec", __FILE__)} Rakefile lib/schedule.rb`
+    `git commit -m "prepare version #{spec.version}"`
+    `git tag v#{spec.version}`
+    #`git push --tags`
+    #`git push`
+  else
+    raise "Repository contains uncommitted changes; either commit or stash."
+  end
+end
+
+# desc "Tag and publish the gem to rubygems.org"
+# task :publish => :tag do
+#   `gem push pkg/#{spec.name}-#{spec.version}.gem`
+# end

data/bin/cr

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + "/../lib")
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require "schedule/task"
+require "schedule/runner"
+require "schedule/notifier"
+require "schedule/logger"
+
+def invalid_arg!(arg, options, command)
+  raise "Invalid argument: #{options.inspect} / #{command.inspect} / #{arg.inspect}"
+end
+
+args = ARGV.dup
+command = nil
+options = {}
+until args.empty? do
+  case (arg = args.shift.strip)
+  when /^[^\-]/ 
+    invalid_arg!(arg, options, command) unless command.nil?
+    command = arg
+  when "-n", "--name" then options[:name] = args.shift
+  when "-l", "--log" then options[:log] = args.shift
+  when "-e", "--email" then options[:email] = args.shift
+  when "--" # noop
+  else invalid_arg!(arg, options, command)
+  end
+end
+
+raise "Did not pass any command to run" unless command
+
+task = Schedule::Task.new(options[:name], command)
+
+logger = if options[:log]
+  Schedule::Logger.new(options[:log], options[:name])
+else
+  nil
+end
+
+notifier = if options[:email]
+  Schedule::Notifier::Email.new({
+    :to => options[:email]
+  })
+else
+  nil
+end
+
+exit Schedule::Runner.new(task, logger, notifier).run

data/lib/schedule.rb

@@ -0,0 +1,8 @@
+require "schedule/task"
+require "schedule/notifier"
+require "schedule/logger"
+require "schedule/runner"
+
+module Schedule
+  VERSION = "0.0.1"
+end

data/lib/schedule/logger.rb

@@ -0,0 +1,56 @@
+require "thread"
+require "stringio"
+
+module Schedule
+  class Logger
+    LINE_SEPERATOR = /\r\n|\n|\r/ # CRLF, LF or CR
+    
+    attr_reader :buffer
+    
+    def initialize(device, prefix)
+      if device == STDOUT
+        @device = device
+      elsif device.is_a?(String)
+        @device = File.open(device, File::WRONLY | File::APPEND | File::CREAT)
+        @device.sync = true
+      else
+        raise ArgumentError, "Log device must be a file path or STDOUT"
+      end
+      
+      @formatter = Proc.new { |line, timestamp| "#{timestamp.strftime("%Y-%m-%d %H:%M:%S")} [#{@prefix}] #{line}" }
+      @buffer = StringIO.new
+      @prefix = prefix
+      @semaphore = Mutex.new
+    end
+
+    def log(msg)
+      timestamp = Time.now
+      
+      # split into lines, preserving whitespace
+      lines = msg.split(LINE_SEPERATOR)
+      msg.scan(LINE_SEPERATOR).size.times { lines << "\n" } if lines.empty?
+      
+      unless lines.empty?
+        @semaphore.synchronize do
+          @device.flock(File::LOCK_EX) if device_is_file?
+          begin
+            @device.write(lines.map { |line| @formatter.call(line, timestamp) }.join("\n") + "\n")#
+            @buffer.write(lines.join("\n") + "\n")
+          ensure
+            @device.flock(File::LOCK_UN) if device_is_file?
+          end
+        end
+      end
+    end
+
+    def close
+      @device.close
+    end
+
+    private
+
+    def device_is_file?
+      @device_is_file ||= @device.is_a?(File)
+    end
+  end
+end

data/lib/schedule/notifier.rb

@@ -0,0 +1,3 @@
+require "schedule/notifier/base"
+require "schedule/notifier/console"
+require "schedule/notifier/email"

data/lib/schedule/notifier/base.rb

@@ -0,0 +1,21 @@
+module Schedule
+  module Notifier
+    class Base
+      def initialize(opts = {})
+        @options = opts
+      end
+
+      def notify(task, message)
+        @task = task
+        @message = message
+        notify!
+      end
+      
+      protected
+      
+      def notify!
+        raise NotImplementedError, "You must subclass this method!"
+      end
+    end
+  end
+end

data/lib/schedule/notifier/console.rb

@@ -0,0 +1,24 @@
+require "schedule/notifier/base"
+
+module Schedule
+  module Notifier
+    class Console < Base
+      private
+
+      def notify!
+        mail = []
+        mail << "From: #{@options[:from]} <#{@options[:from]}>"
+        mail << "To: #{@options[:to]} <#{@options[:to]}>"
+        mail << "Subject: #{subject}"
+        mail << "\n#{@message}"
+        mail = mail.join("\n")
+
+        puts mail
+      end
+
+      def subject
+        "[Schedule] #{@task.name}"
+      end
+    end
+  end
+end

data/lib/schedule/notifier/email.rb

@@ -0,0 +1,42 @@
+require "schedule/notifier/base"
+require "net/smtp"
+require "tempfile"
+
+module Schedule
+  module Notifier
+    class Email < Base
+      private
+
+      def notify!
+        mail = []
+        mail << "From: #{@options[:from]} <#{@options[:from]}>" if @options[:from]
+        mail << "To: #{@options[:to]} <#{@options[:to]}>"
+        mail << "Subject: #{subject}"
+        mail << "\n#{@message}"
+        mail = mail.join("\n")
+
+        begin
+          Net::SMTP.start("localhost") do |smtp|
+            smtp.send_message(mail, @options[:from], @options[:to])
+          end
+        rescue
+          mail_file = Tempfile.new("mail")
+          mail_file.write(mail)
+          mail_file.close
+          begin
+            result = system("sendmail #{@options[:to]} < #{File.expand_path(mail_file.path)}")
+            raise unless result
+          rescue => e
+            raise "Could not deliver email using either local SMTP or sendmail!"
+          ensure
+            mail_file.unlink rescue nil
+          end
+        end
+      end
+
+      def subject
+        "[Schedule] #{@task.name}"
+      end
+    end
+  end
+end

data/lib/schedule/runner.rb

@@ -0,0 +1,101 @@
+require "schedule/logger"
+
+module Schedule
+  class Runner
+    def initialize(task, logger = nil, notifier = nil)
+      @task = task
+      @logger = logger || Logger.new(STDOUT, @task.name)
+      @notifier = notifier
+    end
+    
+    def run
+      @logger.log "=== Started (#{@task.command}) ==="
+    
+      status = nil
+      
+      duration = with_timing do
+        status = execute(@task.command) do |output|
+          buffer = ""
+          begin
+            while (buffer << output.readpartial(1024))
+              if lines = buffer.slice!(/^.*[\n\r]/m)
+                @logger.log(lines)
+              end
+            end
+          rescue EOFError
+            @logger.log(buffer) unless buffer == ""
+          ensure
+            buffer = nil
+          end
+        end
+      end
+    
+      exit_status = if status && status.exitstatus == 0
+        0
+      elsif status && status.exitstatus
+        status.exitstatus
+      else
+        1
+      end
+    
+      if exit_status == 0
+        @logger.log "=== Completed successfully (took #{duration} seconds) ==="
+      else
+        @logger.log "=== Failed (took #{duration} seconds) ==="
+      end
+      
+      if @notifier
+        @notifier.notify(@task, @logger.buffer.string)
+      end
+      
+      return exit_status
+    end
+
+    private
+
+    # executes system command as a child process (fork + exec)
+    # returns stdout and stderr as a single stream
+    # will execute code inside block
+    def execute(cmd)
+      status = nil
+      
+      begin
+        pipe = IO::pipe
+        
+        pid = fork do
+          pipe[0].close
+          STDOUT.reopen(pipe[1])
+          pipe[1].close
+
+          STDERR.reopen(STDOUT)
+
+          begin
+            exec cmd
+          rescue => e 
+            # only some ruby level errors (e.g. exec('nonexistentfile')), caught here by this rescue
+            # once the process is exec'd it'll take us over so any errors at that
+            # level will be piped to STDERR/STDOUT and dealt with in out execute block in #run
+            STDERR.puts "Error running command: #{e.to_s} (#{e.class.name})"#\n#{e.backtrace.map { |l| "    from #{l}" }.join("\n")}"
+            exit(1)
+          end
+        end
+
+        pipe[1].close
+        
+        yield pipe[0]
+      ensure
+        _, status = Process.waitpid2(pid)# rescue nil
+        pipe.each { |io| io.close unless io.closed? }# rescue nil
+      end
+      
+      status
+    end
+  
+    def with_timing
+      started = Time.now
+      yield
+      finished = Time.now
+      finished - started
+    end
+  end
+end

data/lib/schedule/task.rb

@@ -0,0 +1,10 @@
+module Schedule
+  class Task
+    attr_reader :name, :command
+    
+    def initialize(name, command)
+      @name = name
+      @command = command
+    end
+  end
+end

data/test/commands/flushing

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+11.times do |i|
+  $stdout.printf("\rProgress: %s", "#{i * 10}%")
+  $stdout.flush
+  sleep 0.25
+end

data/test/commands/raises_exception

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+`touch #{ARGV.first}`
+puts "Running command..."
+raise "Error!"
+puts "done."

data/test/commands/success

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+`touch #{ARGV.first}`
+puts "Running command..."
+puts "done."

data/test/integration/binary_test.rb

@@ -0,0 +1,44 @@
+require "test_helper"
+require "tempfile"
+
+class BinaryTest < Test::Unit::TestCase
+  context "command runner" do
+    context "successful command" do
+      setup do
+        @file = Tempfile.new("log")
+        @path = @file.path
+        @file.close
+        @file.unlink
+
+        command_to_run_path = File.expand_path("../../commands/success", __FILE__)
+        @command_to_run = "#{command_to_run_path} #{@path}"
+        @command_runner_path = File.expand_path("../../../bin/cr", __FILE__)
+      end
+      
+      context "no options" do
+        setup do
+          @command = %{#{@command_runner_path} "#{@command_to_run}"}
+        end
+        
+        should "execute command" do
+          silence_stream(STDOUT) do
+            system(@command)
+            assert File.exists?(@path)
+          end
+        end
+
+        should "return status code 0" do
+          silence_stream(STDOUT) do
+            assert_equal true, system(@command)
+          end
+        end
+        
+        should "log to stdout"
+      end
+      
+      teardown do
+        File.unlink(@path) rescue nil
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require "rubygems"
+require "test/unit"
+require "shoulda"
+
+class Test::Unit::TestCase
+  # from ActiveSupport 3
+  def silence_stream(stream)
+    old_stream = stream.dup
+    stream.reopen(RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ ? "NUL:" : "/dev/null")
+    stream.sync = true
+    yield
+  ensure
+    stream.reopen(old_stream)
+  end
+end

data/test/unit/logger_test.rb

@@ -0,0 +1,109 @@
+require "test_helper"
+require "schedule/logger"
+require "tempfile"
+require "timecop"
+
+class LoggerTest < Test::Unit::TestCase
+  context "creating a new logger" do
+    context "with the path of an existing file" do
+      setup do
+        @file = Tempfile.new("log")
+        @path = @file.path
+        
+        @file.write "Line 1\nLine2"
+        @file.close
+        
+        @logger = Schedule::Logger.new(@path, "")
+      end
+      
+      should "not overwrite the file" do
+        assert_equal "Line 1\nLine2", File.read(@path)
+      end
+      
+      teardown do
+        @file.unlink
+      end
+    end
+    
+    context "with the path of a non-existing file" do
+      setup do
+        file = Tempfile.new("log")
+        @path = file.path
+        file.close
+        file.unlink
+        
+        @logger = Schedule::Logger.new(@path, "")
+      end
+      
+      should "create the file" do
+        assert File.exists?(@path)
+      end
+    end
+    
+    context "with stdout" do
+      should "not explode" do
+        assert_nothing_raised { Schedule::Logger.new(STDOUT, "") }
+      end
+    end
+  end
+  
+  context "logging a message" do
+    setup do
+      file = Tempfile.new("log")
+      @path = file.path
+      file.close
+      file.unlink
+      
+      @logger = Schedule::Logger.new(@path, "Awesome")
+      @now = Time.now
+    end
+    
+    context "single line" do
+      setup do
+        Timecop.freeze(@now) do
+          @logger.log("Testing 123")
+        end
+      end
+
+      should "write to file immediately" do
+        assert_match "Testing 123", File.read(@path)
+      end
+
+      should "prefix message with time and label" do
+        assert_match /^.*#{@now.strftime("%Y-%m-%d %H:%M:%S")}.*Awesome.*Testing 123.*$/, File.read(@path)
+      end
+
+      context "logging a subsequent message" do
+        setup do
+          @logger.log("Entry number 2")
+        end
+
+        should "be written to a seperate line" do
+          lines = File.read(@path).split(/\n/)
+          assert_match "Testing 123", lines[0]
+          assert_match "Entry number 2", lines[1]
+        end
+      end
+    end
+    
+    context "multiple lines" do
+      setup do
+        Timecop.freeze(@now) do
+          @logger.log("Multiline 1  \n\n Multiline 2\rMultiline 3  ")
+        end
+      end
+
+      should "write as multiple, prefixed lines, preserving per-line whitespace and blank lines" do
+        expecting = []
+        expecting << "#{@now.strftime("%Y-%m-%d %H:%M:%S")} [Awesome] Multiline 1  "
+        expecting << "#{@now.strftime("%Y-%m-%d %H:%M:%S")} [Awesome] "
+        expecting << "#{@now.strftime("%Y-%m-%d %H:%M:%S")} [Awesome]  Multiline 2"
+        expecting << "#{@now.strftime("%Y-%m-%d %H:%M:%S")} [Awesome] Multiline 3  "
+        expecting << ""
+        expecting = expecting.join("\n")
+        
+        assert_match expecting, File.read(@path)
+      end
+    end
+  end
+end

data/test/unit/runner_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+require "schedule/task"
+require "schedule/runner"
+require "tempfile"
+
+class RunnerTest < Test::Unit::TestCase
+  context "a successful task" do
+    setup do
+      @file = Tempfile.new("log")
+      @path = @file.path
+      @file.close
+      
+      @task = Schedule::Task.new("Test", "echo `pwd` > #{@path}")
+      @runner = Schedule::Runner.new(@task)
+    end
+    
+    should "return 0" do
+      silence_stream(STDOUT) do
+        assert_equal 0, @runner.run
+      end
+    end
+    
+    should "execute command" do
+      silence_stream(STDOUT) do
+        @runner.run
+        assert_equal `pwd`, File.read(@path)
+      end
+    end
+    
+    teardown do
+      @file.unlink
+    end
+  end
+  
+  context "a non-existent command" do
+    setup do
+      @task = Schedule::Task.new("Test", "fsjfslsfdanl")
+      @runner = Schedule::Runner.new(@task)
+    end
+    
+    should "return 1" do
+      silence_stream(STDOUT) do
+        assert_equal 1, @runner.run
+      end
+    end
+  end
+  
+  context "a command which uses carriage returns to seperate lines" do
+    setup do
+      @task = Schedule::Task.new("Flushing", File.expand_path("../../commands/flushing", __FILE__))
+      @runner = Schedule::Runner.new(@task)
+    end
+    
+    should "return 0" do
+      silence_stream(STDOUT) do
+        assert_equal 0, @runner.run
+      end
+    end
+  end
+  
+  context "a command that raises an exception" do
+    setup do
+      @file = Tempfile.new("log")
+      @path = @file.path
+      @file.close
+      @file.unlink
+      
+      @task = Schedule::Task.new("Test", File.expand_path("../../commands/raises_exception #{@path}", __FILE__))
+      @runner = Schedule::Runner.new(@task)
+    end
+    
+    should "execute command" do#
+      silence_stream(STDOUT) do
+        @runner.run
+        assert File.exists?(@path)
+      end
+    end
+    
+    should "return 1" do
+      silence_stream(STDOUT) do
+        assert_equal 1, @runner.run
+      end
+    end
+    
+    teardown do
+      File.unlink(@path) rescue nil
+    end
+  end
+end

data/test/unit/task_test.rb

@@ -0,0 +1,18 @@
+require "test_helper"
+require "schedule/task"
+
+class TaskTest < Test::Unit::TestCase
+  context "a new task" do
+    setup do
+      @task = Schedule::Task.new("Testing", "pwd")
+    end
+    
+    should "return #name of Testing" do
+      assert_equal "Testing", @task.name
+    end
+    
+    should "return #command of pwd" do
+      assert_equal "pwd", @task.command
+    end
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: schedule
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mark Dodwell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: timecop
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: 
+email: hi@mkdynamic.co.uk
+executables: 
+- cr
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README.md
+- bin/cr
+- lib/schedule/logger.rb
+- lib/schedule/notifier/base.rb
+- lib/schedule/notifier/console.rb
+- lib/schedule/notifier/email.rb
+- lib/schedule/notifier.rb
+- lib/schedule/runner.rb
+- lib/schedule/task.rb
+- lib/schedule.rb
+- test/commands/flushing
+- test/commands/raises_exception
+- test/commands/success
+- test/integration/binary_test.rb
+- test/test_helper.rb
+- test/unit/logger_test.rb
+- test/unit/runner_test.rb
+- test/unit/task_test.rb
+has_rdoc: true
+homepage: http://github.com/mkdynamic/schedule
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- bin
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      version: "1.3"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Ruby replacement for Cron
+test_files: []
+