coiasira 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+pkg/

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+# Specify your gem's dependencies in activerecord-sqlanywhere-adapter.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,79 @@
+# Rakefile for Coiasira.  -*-ruby-*-
+require 'bundler'
+
+def install_tasks(opts = nil)
+  dir = caller.find{|c| /Rakefile:/}[/^(.*?)\/Rakefile:/, 1]
+  h = Bundler::GemHelper.new(dir, opts && opts[:name])
+  h.install
+  h
+end
+helper = install_tasks
+spec = helper.gemspec
+
+require 'rake/clean'
+CLEAN.include 'pkg'
+
+task :git_local_check do
+  sh "git diff --no-ext-diff --ignore-submodules --quiet --exit-code" do |ok, _|
+    raise "working directory is unclean" if !ok
+    sh "git diff-index --cached --quiet --ignore-submodules HEAD --" do |ok, _|
+      raise "git index is unclean" if !ok
+    end
+  end
+end
+
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "#{spec.name} #{spec.version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+#require 'rake/rdoctask'
+#require 'rake/testtask'
+#require File.join(File.dirname(__FILE__), 'lib', 'coiasira', 'version')
+
+#desc "Default Task"
+#task :default => [:package]
+
+#desc "Do predistribution stuff"
+#task :predist => [:chmod, :rdoc]
+
+
+#desc "Make an archive as .tar.gz"
+#task :dist => [:test, :predist] do
+#  sh "git archive --format=tar --prefix=#{release}/ HEAD^{tree} >#{release}.tar"
+#  sh "pax -waf #{release}.tar -s ':^:#{release}/:' RDOX doc"
+#  sh "gzip -f -9 #{release}.tar"
+#end
+
+#desc "Make binaries executable"
+#task :chmod do
+#  Dir["bin/*"].each { |binary| File.chmod(0775, binary) }
+#  Dir["test/cgi/test*"].each { |binary| File.chmod(0775, binary) }
+#end
+
+#desc "Run all the tests"
+#task :test => [:chmod] do
+#  sh "specrb -Ilib:test -w #{ENV['TEST'] || '-a'} #{ENV['TESTOPTS']}"
+#end
+
+#def gem_version
+#  Coiasira::VERSION::STRING
+#end
+
+#def release
+#  "coiasira-#{gem_version}"
+#end
+
+#def manifest
+#  `svn ls -R`.split("\n")
+#end
+
+#task :install => [:gem] do
+#  sh "gem install pkg/#{release}.gem"
+#end
+

data/bin/coiasira

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# -*- ruby -*-
+
+require 'optparse'

data/coiasira.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/coiasira", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "coiasira"
+  s.version     = Coiasira::VERSION
+  s.author      = 'Brian Olsen'
+  s.email       = 'brian@maven-group.org'
+  s.homepage    = "http://github.com/griff/coaisira"
+  s.summary     = "some helpers for running scheduled jobs"
+  s.description = "Something something"
+
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+
+  s.test_files      = Dir['spec/*_spec.rb']
+
+end

data/lib/coiasira/base.rb

@@ -0,0 +1,51 @@
+module Coiasira
+  class Base
+    # Accepts a logger conforming to the interface of Log4r or the default Ruby 1.8+ Logger class, which is then passed
+    # on to any new database connections made and which can be retrieved on both a class and instance level by calling +logger+.
+    unless defined? @@logger
+      @@logger = nil
+    end
+
+    def self.logger
+      @@logger
+    end
+
+    def self.logger=(obj)
+      @@logger = obj
+    end
+
+    def logger
+      @@logger
+    end
+
+    class << self
+      def process(context)
+        new.process(context)
+      end
+      
+      def default_action
+        'default'
+      end
+    end
+    
+    def initialize()
+      @action = self.class.default_action
+    end
+    
+#    def logger
+#      merged.logger || self.class.logger
+#    end
+    
+    def process(context)
+      @action = context.action if context && context.respond_to?(:action) && context.action
+      logger.info("Starting job #{self.class.name.underscore} with action #{@action}")
+      begin
+        self.__send__(@action, context)
+        logger.info("Finished job #{self.class.name.underscore} with action #{@action}")
+      rescue
+        logger.info("Failed job #{self.class.name.underscore} with action #{@action}")
+        raise
+      end
+    end
+  end
+end

data/lib/coiasira/commands/job.rb

@@ -0,0 +1,33 @@
+if defined? Rails::Initializer
+  require "#{RAILS_ROOT}/config/environment"
+end
+
+def setup
+  puts "script/job <job_name> [action] [arguments]"
+  exit 1
+end
+
+setup if ARGV.include?('--help') || ARGV.include?('-h') || ARGV.size == 0
+
+command = ARGV.shift
+runner = Coiasira::Runner.new
+
+unless runner.has_command?(command)
+  puts "No job named '#{command}'"
+  setup
+end
+
+log = Logger.new(STDOUT)
+log.level = Logger::DEBUG
+Coiasira::Base.logger = log
+
+context = Coiasira::Context.new
+if( ARGV.size > 0 )
+  action = ARGV.shift
+  context.action = action
+  ARGV.each do |arg|
+    name, value = arg.split('=')
+    context.details.data[name] = value
+  end
+end
+runner.process(command, context)

data/lib/coiasira/context.rb

@@ -0,0 +1,42 @@
+module Coiasira
+  class Context
+    attr_reader :merged, :details, :trigger, :previous_fire_time, :next_fire_time, :scheduled_fire_time
+
+    def initialize
+      @details = JobDetail.new
+      @trigger = Trigger.new
+      @merged = JobData.new
+      @data = Hash.new
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, value)
+      @data[key] = value
+    end
+
+    def action
+      details.data.action
+    end
+
+    def action=(value)
+      details.data.action=value.to_s
+    end
+
+    def prepare
+      @merged.merge! details.data
+      @merged.merge! trigger.data
+    end
+
+    def method_missing(sym, value=nil)
+      sym = sym.to_s
+      if sym =~ /^(.*)=$/
+        return self[$~[1]] = value
+      else
+        return self[sym]
+      end
+    end
+  end
+end

data/lib/coiasira/job_data.rb

@@ -0,0 +1,12 @@
+module Coiasira
+  class JobData < Hash
+    def method_missing(sym, value=nil)
+      sym = sym.to_s
+      if sym =~ /^(.*)=$/
+        return self[$~[1]] = value
+      else
+        return self[sym]
+      end
+    end
+  end
+end

data/lib/coiasira/job_detail.rb

@@ -0,0 +1,46 @@
+module Coiasira
+  class JobDetail
+    attr_accessor :name, :group, :description
+    attr_reader :data
+
+    def initialize
+      @data = JobData.new
+    end
+
+    def full_name
+      "#{group}.#{name}"
+    end
+
+    def volatility=(value)
+      @volatility = value
+    end
+
+    def volatility?
+      @volatility
+    end
+
+    def durability=(value)
+      @durability = value
+    end
+
+    def durability?
+      @durability
+    end
+
+    def requests_recovery=(value)
+      @requests_recovery = value
+    end
+
+    def requests_recovery?
+      @requests_recovery
+    end
+
+    def stateful=(value)
+      @stateful = value
+    end
+
+    def stateful?
+      @stateful
+    end
+  end
+end

data/lib/coiasira/job_execution_error.rb

@@ -0,0 +1,13 @@
+module Coiasira
+  class JobExecutionError < SchedulerError
+    attr_accessor :refire, :unschedule_firing_trigger, :unchedule_all_triggers
+    
+    def initialize(options={})
+      unknown_keys = options.keys - [:refire_immediately, :unschedule_firing_trigger, :unchedule_all_triggers].flatten
+      raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+      @refire = options[:refire_immediately] || false
+      @unschedule_trigger = options[:unschedule_firing_trigger] || false
+      @unchedule_all_triggers = options[:unchedule_all_triggers] || false
+    end
+  end
+end

data/lib/coiasira/job_wrapper.rb

@@ -0,0 +1,15 @@
+module Coiasira
+  class JobWrapper
+    attr_reader :job_class
+    
+    def initialize(name)
+      @name = name
+      @job_class = nil
+    end
+    
+    def process(context)
+      @job_class = Jobs.find_class(@name) unless job_class
+      job_class.process(context)
+    end
+  end
+end

data/lib/coiasira/jobs.rb

@@ -0,0 +1,83 @@
+module Coiasira
+  module Jobs
+    # The root paths which may contain job files
+    unless defined? @@job_paths
+      @@job_paths = []
+    end
+    
+    def self.job_paths
+      @@job_paths
+    end
+
+    def job_paths
+      @@job_paths
+    end
+    def self.job_paths=(obj)
+      @@job_paths = obj
+    end
+    def job_paths=(obj)
+      @@job_paths = obj
+    end
+    
+    class << self
+    # Returns an array of paths, cleaned of double-slashes and relative path references.
+    # * "\\\" and "//"  become "\\" or "/". 
+    # * "/foo/bar/../config" becomes "/foo/config".
+    # The returned array is sorted by length, descending.
+      def normalize_paths(paths)
+        # do the hokey-pokey of path normalization...
+        paths = paths.collect do |path|
+          path = path.
+            gsub("//", "/").           # replace double / chars with a single
+            gsub("\\\\", "\\").        # replace double \ chars with a single
+            gsub(%r{(.)[\\/]$}, '\1')  # drop final / or \ if path ends with it
+
+          # eliminate .. paths where possible
+          re = %r{[^/\\]+[/\\]\.\.[/\\]}
+          path.gsub!(re, "") while path.match(re)
+          path
+        end
+
+        # start with longest path, first
+        paths = paths.uniq.sort_by { |path| - path.length }
+      end
+
+    # Returns the array of job names currently available.
+      def possible_jobs
+        unless @possible_jobs
+          @possible_jobs = []
+          paths = job_paths.select { |path| File.directory?(path) && path != "." }
+
+          seen_paths = Hash.new {|h, k| h[k] = true; false}
+          normalize_paths(paths).each do |load_path|
+            Dir["#{load_path}/**/*_job.rb"].collect do |path|
+              next if seen_paths[path.gsub(%r{^\.[/\\]}, "")]
+
+              job_name = path[(load_path.length + 1)..-1]
+
+              job_name.gsub!(/_job\.rb\Z/, '')
+              @possible_jobs << job_name
+            end
+          end
+
+          # remove duplicates
+          @possible_jobs.uniq!
+        end
+        @possible_jobs
+      end
+      
+      def has_job?(name)
+        possible_jobs.include?(name)
+      end
+            
+      def load_job(name)
+        raise NameError, name unless has_job?(name)
+        JobWrapper.new(name)
+      end
+    
+      def find_class(name)
+        "#{name.camelize}Job".constantize
+      end
+    end
+  end
+end

data/lib/coiasira/rails/initializer.rb

@@ -0,0 +1,90 @@
+module Rails
+  class Initializer
+    def self.alias_method_chain(target, feature)
+      # Strip out punctuation on predicates or bang methods since
+      # e.g. target?_without_feature is not a valid method name.
+      aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+      yield(aliased_target, punctuation) if block_given?
+
+      with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+      alias_method without_method, target
+      alias_method target, with_method
+
+      case
+        when public_method_defined?(without_method)
+          public target
+        when protected_method_defined?(without_method)
+          protected target
+        when private_method_defined?(without_method)
+          private target
+      end
+    end
+    
+    def initialize_coiasira
+      return unless configuration.frameworks.include?(:coiasira)
+      ::Coiasira::Jobs.job_paths = configuration.job_paths
+#    ActionController::Routing::Routes.configuration_file = configuration.routes_configuration_file
+#    ActionController::Routing::Routes.reload
+    end
+        
+    def initialize_routing_with_coiasira
+      initialize_routing_without_coiasira
+      initialize_coiasira
+    end
+    alias_method_chain :initialize_routing, :coiasira
+  end
+  
+  class Configuration
+    def self.alias_method_chain(target, feature)
+      # Strip out punctuation on predicates or bang methods since
+      # e.g. target?_without_feature is not a valid method name.
+      aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+      yield(aliased_target, punctuation) if block_given?
+
+      with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+      alias_method without_method, target
+      alias_method target, with_method
+
+      case
+        when public_method_defined?(without_method)
+          public target
+        when protected_method_defined?(without_method)
+          protected target
+        when private_method_defined?(without_method)
+          private target
+      end
+    end
+
+    attr_accessor :coiasira
+
+    # The list of paths that should be searched for jobs. (Defaults
+    # to <tt>app/jobs</tt>.)
+    attr_accessor :job_paths
+
+    def initialize_with_coiasira
+      initialize_without_coiasira
+      self.job_paths = default_job_paths
+    end
+    alias_method_chain :initialize, :coiasira
+
+  private
+    def default_frameworks_with_coiasira
+      default_frameworks_without_coiasira + [ :coiasira ]
+    end
+    alias_method_chain :default_frameworks, :coiasira
+    
+    def default_load_paths_with_coiasira
+      paths = default_load_paths_without_coiasira
+      
+      # Add the app's job directory
+      paths.concat(Dir["#{root_path}/app/jobs/"])
+    end
+    alias_method_chain :default_load_paths, :coiasira
+
+    def default_job_paths
+      [File.join(root_path, 'app', 'jobs')]
+    end
+  end
+end

data/lib/coiasira/runner.rb

@@ -0,0 +1,12 @@
+module Coiasira
+  class Runner
+    def has_command?(cmd)
+      Jobs.has_job?(cmd)
+    end
+    
+    def process(cmd, context=nil)
+      context.prepare if context.respond_to? :prepare
+      Jobs.load_job(cmd).process(context)
+    end
+  end
+end

data/lib/coiasira/scheduler_error.rb

@@ -0,0 +1,4 @@
+module Coiasira
+  class SchedulerError < StandardError
+  end
+end

data/lib/coiasira/trigger.rb

@@ -0,0 +1,9 @@
+module Coiasira
+  class Trigger
+    attr_reader :data
+
+    def initialize
+      @data = JobData.new
+    end
+  end
+end

data/lib/coiasira/version.rb

@@ -0,0 +1,3 @@
+module Coiasira #:nodoc:
+  VERSION = '0.1.0'
+end

data/lib/coiasira.rb

@@ -0,0 +1,41 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+=begin comment
+unless defined?(ActiveSupport)
+  begin
+    $:.unshift "#{File.dirname(__FILE__)}/../../activesupport/lib"
+    require 'active_support'
+  rescue LoadError
+    require 'rubygems'
+    begin
+      gem 'activesupport'
+    rescue LoadError
+      require 'coiasira/core_ext'
+    end
+  end
+end
+=end
+
+require 'coiasira/version'
+require 'coiasira/scheduler_error'
+require 'coiasira/job_execution_error'
+require 'coiasira/job_data'
+require 'coiasira/job_detail'
+require 'coiasira/trigger'
+require 'coiasira/context'
+require 'coiasira/base'
+require 'coiasira/job_wrapper'
+require 'coiasira/jobs'
+require 'coiasira/runner'
+
+module Coiasira
+  def self.silence_warnings
+    oldv, $VERBOSE = $VERBOSE, nil
+    begin
+      yield
+    ensure
+      $VERBOSE = oldv
+    end
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: coiasira
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Brian Olsen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-13 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
+description: Something something
+email: brian@maven-group.org
+executables: 
+- coiasira
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- bin/coiasira
+- coiasira.gemspec
+- lib/coiasira.rb
+- lib/coiasira/base.rb
+- lib/coiasira/commands/job.rb
+- lib/coiasira/context.rb
+- lib/coiasira/job_data.rb
+- lib/coiasira/job_detail.rb
+- lib/coiasira/job_execution_error.rb
+- lib/coiasira/job_wrapper.rb
+- lib/coiasira/jobs.rb
+- lib/coiasira/rails/initializer.rb
+- lib/coiasira/runner.rb
+- lib/coiasira/scheduler_error.rb
+- lib/coiasira/trigger.rb
+- lib/coiasira/version.rb
+- test/spec_coiasira.rb
+homepage: http://github.com/griff/coaisira
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: some helpers for running scheduled jobs
+test_files: []
+