threasy 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: b06dfdee1ca788c21cf8cdd036eb0b7b7995bba3
+  data.tar.gz: ae7b941674e8d3db405fd8227ce206a3f0e7f62e
+SHA512: 
+  metadata.gz: d7ce1d2e0829dfca7ae76891df339164fdf379a647d3e601c416dccd7eabb91412cf8bc647bbc97fb4e5c5613a46a83917e15f55aa0ec7a2fc56786b6c38f3ac
+  data.tar.gz: 7ef14d1a0917a5104a0508697ee7d486f07601eef86e6057860336705da471039debc1ddf4b80697566eb5c7d7ec10b8a71316b26cfd4614b6b4ecdea9b5e4e9

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+platform :rbx do
+  gem "rubysl-mutex_m"
+  gem "rubysl-singleton"
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Carl Zulauf
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,84 @@
+# Threasy [![Build Status][travis-image]][travis-link]
+
+[travis-image]: https://secure.travis-ci.org/carlzulauf/threasy.png?branch=master
+[travis-link]: http://travis-ci.org/carlzulauf/threasy
+
+Dead simple in-process threaded background job solution.
+
+Includes scheduling for jobs in the future and/or recurring jobs.
+
+Work waiting to be processed is stored in a thread-safe `Queue` and worked on by a small pool of worker threads.
+
+### What to expect
+
+* Dead simple-ness
+* Ability to queue or schedule ruby blocks for asynchronus execution
+* Extremely light-weight
+* No dependencies (outside ruby stdlib)
+* Portable: jruby, rubinius, and MRI
+* Good performance
+* Thread-safe
+* Great solution for low to medium traffic single instance apps
+* Ability to conserve memory on small VMs by doing as much in a single process as possible
+* Plays nice with threaded or single process rack servers (puma, thin, rainbows)
+
+### What __not__ to expect
+
+* Failed job retrying/recovery (might be added, but just logs failures for now)
+* Good solution for large scale deployments
+* Avoidance of GIL contention issues in MRI during non-blocking jobs
+* Plays nice with forking or other multi-process rack servers (passenger, unicorn)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'threasy'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install threasy
+
+## Usage
+
+### `enqueue`
+
+```ruby
+# Use a block
+Threasy.enqueue{ puts "This will happen in the background" }
+
+# Use an object that responds to #perform or #call
+Threasy.enqueue MyJob.new(1,2,3)
+```
+
+### `schedule`
+
+Puts a job onto the schedule. Once the scheduler sees a job is due for processessing, it is enqueued into the work queue to be processed like any other job.
+
+Available options:
+
+* `:every`: number of seconds between repetition. Can be combined with `:at` or `:in`.
+* `:in`: number of seconds until job is (next) triggered.
+* `:at`: `Time` job is (next) triggered.
+
+Example:
+
+```ruby
+# Use a block
+Threasy.schedule(:in => 5.minutes) { puts "In the background, 5 minutes from now" }
+
+# Use an job object
+Threasy.schedule(MyJob.new(1,2,3), every: 5.minutes)
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/threasy/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => [:spec]

data/lib/threasy/config.rb

@@ -0,0 +1,16 @@
+module Threasy
+  class Config
+    include Singleton
+
+    attr_accessor :max_workers
+    attr_writer :logger
+
+    def initialize
+      self.max_workers = 5
+    end
+
+    def logger
+      @logger ||= Logger.new(STDOUT).tap{|l| l.level = Logger::INFO }
+    end
+  end
+end

data/lib/threasy/schedule.rb

@@ -0,0 +1,104 @@
+module Threasy
+  class Schedule
+    include Singleton
+
+    def initialize
+      @semaphore = Mutex.new
+      @schedules = []
+      @watcher = Thread.new{ watch }
+    end
+
+    def add(*args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      job = block_given? ? block : args.first
+      add_entry Entry.new(job, options)
+    end
+
+    def add_entry(entry)
+      sync do
+        @schedules << entry
+        @schedules.sort_by!(&:at)
+      end
+      tickle_watcher
+    end
+
+    def tickle_watcher
+      @watcher.wakeup if @watcher.stop?
+    end
+
+    def sync
+      @semaphore.synchronize{ yield }
+    end
+
+    def entries
+      @schedules
+    end
+
+    def clear
+      sync{ @schedules.clear }
+    end
+
+    def watch
+      loop do
+        Thread.stop if @schedules.empty?
+        entries_due.each do |entry|
+          log.debug "Adding scheduled job to work queue"
+          entry.work!
+          add_entry entry if entry.repeat?
+        end
+        next_job = @schedules.first
+        if next_job && next_job.future?
+          seconds = next_job.at - Time.now
+          log.debug "Schedule watcher sleeping for #{seconds} seconds"
+          sleep seconds
+        end
+      end
+    end
+
+    def entries_due
+      [].tap do |entries|
+        sync do
+          while @schedules.first && @schedules.first.due?
+            entries << @schedules.shift
+          end
+        end
+      end
+    end
+
+    def count
+      @schedules.count
+    end
+
+    def log
+      Threasy.logger
+    end
+
+    class Entry
+      attr_accessor :job, :at, :repeat
+
+      def initialize(job, options = {})
+        self.job = job
+        seconds = options[:in] || options[:every]
+        self.at = options.fetch(:at){ Time.now + seconds }
+        self.repeat = options[:every]
+      end
+
+      def repeat?
+        !! repeat
+      end
+
+      def due?
+        Time.now > at
+      end
+
+      def future?
+        ! due?
+      end
+
+      def work!
+        Threasy.enqueue job
+        self.at = Time.now + repeat if repeat?
+      end
+    end
+  end
+end

data/lib/threasy/version.rb

@@ -0,0 +1,3 @@
+module Threasy
+  VERSION = "0.0.1"
+end

data/lib/threasy/work.rb

@@ -0,0 +1,97 @@
+module Threasy
+  class Work
+    include Singleton
+
+    attr_reader :queue, :pool
+
+    def initialize
+      @queue = TimeoutQueue.new
+      @pool = Set.new
+    end
+
+    def enqueue(job = nil, &block)
+      queue.push(block_given? ? block : job).tap{ check_workers }
+    end
+
+    alias_method :enqueue_block, :enqueue
+
+    def grab
+      queue.pop
+    end
+
+    def max_workers
+      Threasy.config.max_workers
+    end
+
+    def check_workers
+      pool_size = pool.size
+      queue_size = queue.size
+      log "Checking workers. Pool: #{pool_size}, Max: #{max_workers}, Queue: #{queue_size}"
+      if pool_size < max_workers
+        add_worker if pool_size == 0 || queue_size > max_workers
+      end
+    end
+
+    def add_worker
+      log "Adding new worker to pool"
+      Worker.new(pool.size).work(self)
+    end
+
+    def log(msg)
+      Threasy.logger.debug msg
+    end
+
+    class Worker
+      def initialize(id)
+        @id = id
+      end
+
+      def work(work)
+        Thread.start do
+          work.pool.add Thread.current
+          while job = work.grab
+            log.debug "Worker ##{@id} has grabbed a job"
+            begin
+              job.respond_to?(:perform) ? job.perform : job.call
+            rescue Exception => e
+              log.error %|Worker ##{@id} error: #{e.message}\n#{e.backtrace.join("\n")}|
+            end
+          end
+          log.debug "Worker ##{@id} removing self from pool"
+          work.pool.delete Thread.current
+        end
+      end
+
+      def log
+        Threasy.logger
+      end
+    end
+
+    class TimeoutQueue
+      include Timeout
+
+      def initialize
+        @queue = Queue.new
+      end
+
+      def push(item)
+        @queue << item
+        true
+      end
+
+      def pop(seconds = 5)
+        timeout(seconds) { @queue.pop }
+      rescue Timeout::Error
+        nil
+      end
+
+      def size
+        @queue.size
+      end
+
+      def clear
+        @queue.clear
+      end
+    end
+  end
+end

data/lib/threasy.rb

@@ -0,0 +1,34 @@
+require "logger"
+require "singleton"
+
+require "threasy/version"
+require "threasy/config"
+require "threasy/work"
+require "threasy/schedule"
+
+module Threasy
+  def self.config
+    yield Config.instance if block_given?
+    Config.instance
+  end
+
+  def self.logger
+    config.logger
+  end
+
+  def self.work
+    Work.instance
+  end
+
+  def self.enqueue(*args, &block)
+    work.enqueue *args, &block
+  end
+
+  def self.schedules
+    Schedule.instance
+  end
+
+  def self.schedule(*args, &block)
+    schedules.add *args, &block
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "..", "lib", "threasy")

data/spec/threasy/schedule_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe "Threasy::Schedule" do
+
+  before :each do
+    @schedule = Threasy::Schedule.instance
+  end
+
+  describe "#add" do
+    it "should allow a job to be processed after specified delay" do
+      job = double("job")
+      expect(job).to receive(:perform)
+      @schedule.add(job, in: 0.5)
+      sleep 1
+    end
+
+    it "should allow a job to be processed at the specified time" do
+      job = double("job")
+      expect(job).to receive(:perform)
+      @schedule.add(job, at: Time.now + 1)
+      sleep 2
+    end
+
+    it "should allow a job to be repeated at the specified interval" do
+      job = double("job")
+      expect(job).to receive(:perform).at_least(:twice)
+      @schedule.add(job, every: 1)
+      sleep 3
+    end
+
+    it "should allow blocks to be processed on schedule" do
+      job = double("job")
+      i = 0
+      @schedule.add(:in => 0.5){ i += 1 }
+      expect(i).to eq(0)
+      sleep 1
+      expect(i).to eq(1)
+    end
+  end
+
+  after :each do
+    @schedule.clear
+  end
+
+end

data/spec/threasy/work_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe "Threasy::Work" do
+  before :each do
+    @work = Threasy::Work.instance
+  end
+
+  describe "#enqueue" do
+    it "should allow a job object to be enqueued and worked" do
+      job = double("job")
+      expect(job).to receive(:perform).once
+      @work.enqueue job
+      sleep 0.5
+    end
+
+    it "should allow a job block to be enqueued and worked" do
+      i = 0
+      @work.enqueue do
+        sleep 0.5
+        i += 1
+      end
+      expect(i).to eq(0)
+      sleep 1
+      expect(i).to eq(1)
+    end
+  end
+end

data/threasy.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'threasy/version'
+
+Gem::Specification.new do |s|
+  s.name          = "threasy"
+  s.version       = Threasy::VERSION
+  s.authors       = ["Carl Zulauf"]
+  s.email         = ["carl@linkleaf.com"]
+  s.summary       = %q{Simple threaded background jobs and scheduling.}
+  s.description   = %q{Dead simple in-process background job solution using threads, with support for scheduled jobs.}
+  s.homepage      = "http://github.com/carlzulauf/threasy"
+  s.license       = "MIT"
+
+  s.files         = %w( Gemfile README.md Rakefile LICENSE.txt threasy.gemspec )
+  s.files        += Dir.glob("lib/**/*")
+  s.files        += Dir.glob("spec/**/*")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "bundler", "~> 1.5"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: threasy
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Carl Zulauf
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-01-21 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.5"
+  name: bundler
+  type: :development
+  requirement: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - &id003 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  name: rake
+  type: :development
+  requirement: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id003
+  name: pry
+  type: :development
+  requirement: *id004
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id003
+  name: rspec
+  type: :development
+  requirement: *id005
+  prerelease: false
+description: Dead simple in-process background job solution using threads, with support for scheduled jobs.
+email: 
+- carl@linkleaf.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/threasy.rb
+- lib/threasy/config.rb
+- lib/threasy/schedule.rb
+- lib/threasy/version.rb
+- lib/threasy/work.rb
+- spec/spec_helper.rb
+- spec/threasy/schedule_spec.rb
+- spec/threasy/work_spec.rb
+- threasy.gemspec
+homepage: http://github.com/carlzulauf/threasy
+licenses: 
+- MIT
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id003
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id003
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Simple threaded background jobs and scheduling.
+test_files: 
+- spec/spec_helper.rb
+- spec/threasy/schedule_spec.rb
+- spec/threasy/work_spec.rb