day_planner 0.0.18 → 0.1.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6d6fd31e83428dddd1dc38cc0d61d57f6f548ac
-  data.tar.gz: 7f3f60dd31dad264be4e598219794778af64e578
+  metadata.gz: 2b2cd47bed48216943fca5ceb558f4209b58b887
+  data.tar.gz: be5a04e84a1146461fe40792562c58b32f5065f9
 SHA512:
-  metadata.gz: bbe29034e2ccbad6c0340e07adf11e30059cb422c750896f6801987e58af6c8860093346e2a3d71d4e954c62b547d5977236243cb6f83b99f2184968a0acfe23
-  data.tar.gz: 8a61920ac3da2e6e6c5677008dab78e2361d746bc4cbb1829dc13775f263b64ee038eee7f4932d2ea1629f1dac3a882faeace7d6a3c08c85c54e6ed560aa7597
+  metadata.gz: 4716aa4e9dad6a9f17ae0f662844190b2491bb5a1f29390dab1d7f3151de5ba6ed43f4be4c8b3bded38351966af29aa88838e58f0a92a046bd17460c461981ac
+  data.tar.gz: 8df3a3891c73bb810322e98909b747e165be8e6f762f1f6ec6d860bada59976e7dc10204e272b19b5b99a1f3b91156945b9a15fc2e327a8ede5d72339de160f7

data/README.md

@@ -1,10 +1,10 @@
 # DayPlanner
 
-Day Planner is a simple tool to manage in-process execution of scheduled tasks. There are a lot of tools for running scheduled tasks outside the process ([Clockwork](http://rubygems.org/gems/clockwork) is probably what you're looking for if you want an elegant implementation of scheduled tasks outside the main process).
+Day Planner is a simple tool to manage in-process execution of scheduled tasks in Rails. There are a lot of tools for running scheduled tasks outside the process ([Clockwork](http://rubygems.org/gems/clockwork) is probably what you're looking for if you want an elegant implementation of scheduled tasks outside the main process).
 
 I wrote this because I needed a simple, lightweight tool to schedule small, light tasks on an application running on Heroku, without the extra cost of a dedicated clock process to handle it, but executing more frequently than Heroku's free scheduler permits.
 
-Schedule management is in a thread of its own; scheduled tasks are run in the same thread (I was spawning separate threads for them, but it seemed to be causing issues with database utilization on Heroku). Ruby 2.0's handling of threading is improved over the 1.9 branch, so I require that as a minimum, but I obviously can't guarantee that you won't encounter situations in which poorly behaved tasks block your application's main thread. If you want assurances against that, use any of the other tools (did I mention [Clockwork](http://rubygems.org/gems/clockwork)?)
+Schedule management is in a thread of its own; scheduled tasks are run in the same thread (I was spawning separate threads for them, but it seemed to be causing issues with database utilization on Heroku). Ruby 2.0's handling of threading is improved over the 1.9 branch, so it may be a good idea to use it, but I obviously can't guarantee that you won't still encounter situations in which poorly behaved tasks block your application's main thread. If you want assurances against that, use any of the other tools (did I mention [Clockwork](http://rubygems.org/gems/clockwork)?)
 
 ## Installation
 
@@ -15,14 +15,12 @@ Add this line to your application's Gemfile:
 And then execute:
 
     $ bundle install
-
-If you're using Rails, it'll expect to find a file listing scheduled tasks in 'config/scheduled_tasks.rb'. If you're not using Rails, do whatever makes you happy. Stick some scheduled tasks somewhere and make sure it's somewhere that runs when your application starts.
+    $ rails generate day_planner:install
+    $ rake db:migrate
 
 ## Usage
 
-### Rails
-
-Create a file called config/scheduled_tasks.rb. Put tasks in it like this:
+Installation should have created a file called config/scheduled_tasks.rb. Put tasks in it like this:
 
     DayPlanner.schedule(every: 2.minutes) do
     	MyClass.my_class_method
@@ -30,25 +28,11 @@ Create a file called config/scheduled_tasks.rb. Put tasks in it like this:
 
 This file will be read in and its tasks will be added to the schedule automatically.
 
-### If you're not using Rails
-
-I don't really know if it'll work. I haven't tried.
-
-You will have to create a scheduled tasks file, somewhere. Use the same format, but obviously you won't have those cute little Rails-y time methods. You'll want to include this at the bottom:
-
-    DayPlanner.activate
-
-It's only activated automatically in Rails.
-
-I have not tested it outside of Rails and it may not work at all but ideally I'd prefer that it did. If you can give me feedback, I'd be much obliged.
-
-### Either way
-
 The tasks in the schedule will each be performed on startup and then thereafter according to their stated intervals.
 
-I'm not doing a whole damn ton to protect you from tasks that throw errors, but there is a begin/rescue/end up in there at some point. I definitely am not protecting you from a process that just won't end or anything like that. Remember that your interval is really the minimum possible time between instances of the task being performed, as it does not spawn a new thread for each task. (That seemed to cause problems with Heroku.)
+I'm not doing a whole damn ton to protect you from tasks that throw errors, but there is a begin/rescue/end up in there at some point. I definitely am not protecting you from a process that just won't end or anything like that. Remember that your interval is more or less the minimum possible time between instances of the task being performed, as it does not spawn a new thread for each task. (That seemed to cause problems with Heroku.) Setting a shorter interval will help, as it will endeavor to catch up to the schedule if it falls behind but will never execute tasks between its check intervals. Setting the check interval too short could end up blocking your application's main thread, though, particularly if your tasks end up running long.
 
-### Other options
+### Options
 
 #### name
 
@@ -59,26 +43,20 @@ You can name a task thusly:
     end
 
 If you do, you can find the task later:
-    DayPlanner.find_task("my task")
-
-#### environment
-
-If you're using Rails, you can include environment in your options hash, setting the value to the Rails environment in which you'd like the task executed. For example:
-
-    DayPlanner.schedule(every: 1.hour, name: "occasional task", environment: "production") do
-        # I run every hour, but only if you're using Rails and in production.
-    end
+    DayPlanner.task("my task")
 
 ### Managing DayPlanner and tasks
 
 You can activate or deactivate DayPlanner with those respective methods. You can also check whether it's running with DayPlanner.status.
 
-To cancel a task, you can either call the task's "destroy" method, or call a class method on DayPlanner:
+To cancel a task, call the class method on DayPlanner:
 
     DayPlanner.cancel(task)
 
 You can either pass a name, if you named the task, or the task object.
 
+Avoid trying to interact with tasks via database calls or ActiveRecord objects. DayPlanner shouldn't attempt to execute any task that isn't scheduled via its methods, as the actual task is retained in memory; the database is only used to track task execution times.
+
 #### DayPlanner.interval
 
 By default, DayPlanner checks for tasks to be performed once per minute. You have the power to change this:
@@ -89,11 +67,11 @@ Or, like
 
     DayPlanner.interval = 5
 
-Since tasks are not run in separate threads (this seemed to be giving me database connection issues on Heroku), remember that the interval is basically a minimum possible period before it's performed again -- if a task takes time to run, keep that in mind (or spin off a new thread yourself in the task).
+Since tasks are not run in separate threads (this seemed to be giving me database connection issues on Heroku), remember that the interval is not entirely precise -- if a task takes time to run, keep that in mind (or spin off a new thread yourself in the task). DayPlanner will attempt to run a task before the task's interval has entirely passed in order to get it to execute at its next scheduled time, should the check interval be short enough to manage this, but no guarantees. It will not run the task if less than half of its interval has elapsed since last performance.
 
 Note that if you try to schedule a task with an interval shorter than DayPlanner's interval, it'll complain and fail. If you shorten DayPlanner's interval to less than that of one of its tasks, it'll complain but not fail. The task obviously will only run at scheduler thread's intervals. Use your best judgment.
 
-Specify your preferred interval (and whatever other goodies may be waiting in the pipeline) in config/day_planner_tasks.rb. As long as you set your interval before DayPlanner is activated, you won't have to wait for it to cycle through an interval. If you alter this value while DayPlanner is already running, it won't take effect until the current interval ends.
+Specify your preferred interval (and whatever other settings which may be implemented one day) in config/day_planner_tasks.rb. As long as you set your interval before DayPlanner is activated, you won't have to wait for it to cycle through an interval to change the setting. If you alter this value while DayPlanner is already running, it won't take effect until the current interval ends.
 
 ## Contributing
 

data/app/models/day_planner/task.rb

@@ -0,0 +1,40 @@
+module DayPlanner
+	class Task < ActiveRecord::Base
+		self.table_name = :day_planner_tasks
+
+		validate :check_name
+
+		def self.schedule(options)
+			unless options[:every]
+				raise ArgumentError, "Must specify task interval with :every, other scheduling methods are not yet implemented"
+			end
+
+			if options[:every].to_i < DayPlanner.interval.to_i
+				raise ArgumentError, "Must specify a task interval at least as long as DayPlanner's check interval."
+			end
+
+			fields = {}
+			fields[:name] = options.delete(:name) if options[:name]
+			fields[:interval] = options.delete(:every).to_i if options[:every]
+
+			task = DayPlanner::Task.create(fields)
+		end
+
+		def check_name
+			if name.present?
+				tasks = Task.where(name: name)
+				if tasks.count > 1 || (tasks.count == 1 && tasks.first.id != id)
+					errors.add(:name, "must be unique if specified")
+				end
+			end
+		end
+
+		def block
+			@block
+		end
+
+		def block=(block)
+			@block = block
+		end
+	end
+end

data/day_planner.gemspec

@@ -21,5 +21,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
 
-  spec.required_ruby_version = ">= 2.0.0"
+  spec.add_dependency "activesupport", ">= 3.0.0"
+  spec.add_dependency "rails", ">= 3.0.0"
+
+  spec.required_ruby_version = ">= 1.9.0"
 end

data/lib/day_planner/base.rb

@@ -1,61 +1,28 @@
+require 'day_planner/engine'
+
 module DayPlanner
-	@@tasks = []
-	@@named_tasks = {}
 	@@status = "stopped"
-
-	class Railtie < Rails::Railtie
-		unless $0 =~ /rake/
-			initializer "day_planner.activate", after: :finisher_hook do
-				require File.expand_path('config/scheduled_tasks')
-				DayPlanner.activate
-			end
-		end
-	end
+	@@tasks = []
 
 	class << self
 		def tasks
 			@@tasks
 		end
 
-		def schedule(options, &block)
-			raise ArgumentError unless options.is_a?(Hash)
-
-			Task.new(options, &block)
-		end
-
-		def cancel(task)
-			task = find_task(task) if task.is_a?(String) || task.is_a?(Symbol)
-			raise ArgumentError, "DayPlanner couldn't find this task" if task.nil? || !task.is_a?(DayPlanner::Task)
-			task.destroy
+		def task(task)
+			if task.is_a?(Integer)
+				@@tasks.select{ |t| t.id == task }.first
+			elsif task.is_a?(String)
+				@@task.select{ |t| t.name == task }.first
+			elsif task.is_a?(DayPlanner::Task)
+				@@task.select{ |t| t.id == task.id }.first
+			end
 		end
 
 		def status
 			@@status
 		end
 
-		def deactivate
-			@@master.kill if defined?(@@master)
-			@@status = "stopped"
-		end
-				
-		def activate
-			@@master.kill if defined?(@@master)
-			@@status = "running"
-
-			if defined?(Rails) && Rails.logger
-				Rails.logger.info("DayPlanner activated.")
-			else
-				puts "DayPlanner activated."
-			end
-
-			@@master = Thread.new do
-				while true
-					check_schedule
-					sleep(interval)
-				end
-			end
-		end
-
 		def interval
 			defined?(@@interval) ? @@interval : 60
 		end
@@ -64,112 +31,97 @@ module DayPlanner
 			@@interval = value
 		end
 
-		def find_task(name)
-			@@named_tasks[name.to_s]
+		def clear_tasks
+			@@tasks = []
+			ActiveRecord::Base.connection.execute("TRUNCATE #{DayPlanner::Task.table_name}")
 		end
 
-		def register_task_name(name, task)
-			raise ArgumentError unless task.is_a?(DayPlanner::Task)
-			raise ArgumentError unless @@named_tasks[name.to_s].nil?
-			@@named_tasks[name.to_s] = task
-		end
+		def schedule(options, &block)
+			raise ArgumentError, "Failed to pass an options hash" unless options.is_a?(Hash)
 
-		def delete_task_name(name)
-			@@named_tasks.delete(name)
-		end
+			task = DayPlanner::Task.schedule(options)
 
-	private
-		def check_schedule
-			tasks.each do |t|
-				if Time.now > t.last_executed + t.interval
-					begin
-						t.perform
-					rescue => e
-						if defined?(Rails) && Rails.logger
-							Rails.logger.error("DayPlanner: Scheduled task threw an error! Behave yourselves!\n#{e.inspect}")
-						else
-							puts "DayPlanner: Scheduled task threw an error! Behave yourselves!\n#{e.inspect}"
-						end
-					end
-				end
+			if !task.id.nil?
+				task.block = block
+				@@tasks.push(task)
+			else
+				raise ArgumentError, "Task creation failed. If you specified a name, was it unique?"
 			end
+
+			task
 		end
-	end
 
-	class Task
-		attr_reader :name, :last_executed, :interval
+		def cancel(task)
+			task = DayPlanner::Task.find_by_name(task) if task.is_a?(String) || task.is_a?(Symbol)
+			task = DayPlanner::Task.find(task) if task.is_a?(Integer)
 
-		def perform
-			if @environment.nil? || (defined?(Rails) && defined?(Rails.env) && Rails.env == @environment)
-				@last_executed = Time.now
+			raise ArgumentError, "DayPlanner couldn't find this task" if task.nil? || !task.is_a?(DayPlanner::Task)
 
-				@task.call
-			else
-				log_info = "DayPlanner: "
+			@@tasks.select!{ |t| t.id != task.id }
 
-				if @name
-					log_info += "Skipping task '#{@name}'"
-				else
-					log_info += "Skipping a task"
-				end
+			task.destroy
+		end
 
-				log_info += " because it's set for environment '#{@environment}'."
+		def deactivate
+			@@master.kill if defined?(@@master)
+			@@status = "stopped"
+			@@tasks = []
 
-				if defined?(Rails) && Rails.logger
-					Rails.logger.info(log_info)
-				else
-					puts log_info
-				end
-			end
-		end
+			clear_tasks
 
-		def destroy
-			DayPlanner.tasks.delete(self)
-			if @name
-				DayPlanner.delete_task_name(@name)
-			end
+			true
 		end
+				
+		def activate
+			@@master.kill if defined?(@@master)
+			@@status = "running"
 
-		def initialize(options, &block)
-			if options[:every]
-				@interval = options[:every]
-				raise ArgumentError, "DayPlanner: Task interval is less than scheduler interval. Task not scheduled." if @interval < DayPlanner.interval
+			if defined?(Rails) && Rails.logger
+				Rails.logger.info("DayPlanner activated at #{Time.now.inspect}.")
 			else
-				raise ArgumentError, "DayPlanner: Scheduling tasks at anything other than simple intervals using 'every' is still not implemented, not even a little bit."
+				puts "DayPlanner activated at #{Time.now.inspect}."
 			end
 
-			if options[:name]
-				name = options.delete(:name)
-				if !DayPlanner.find_task(name)
-					@name = name.to_s
-					DayPlanner.register_task_name(name, self)
+			@@master = Thread.new do
+				begin
+					while true
+						check_schedule
+						sleep(interval)
+					end
+				ensure
+					Rails.logger.flush
 				end
 			end
+		end
 
-			@environment = options.delete(:environment) if options[:environment]
+	private
+		def check_schedule
+			begin
+				DayPlanner.tasks.each_with_index do |t, idx|
+					time = Time.now
+					task = DayPlanner::Task.find(t.id)
 
-			@task = block
+					if task.nil?
+						@@tasks.select!{ |item| item.id != t.id }
+					else
+						if task.last_execution.nil? || (time > task.next_execution && time > task.last_execution + (task.interval / 2))
+							task.last_execution = time
 
-			DayPlanner.tasks.push(self)
-			log_info = "DayPlanner: New task added"
-			log_info += ": '#{@name}'" unless @name.nil?
-			log_info += " with an execution interval of #{@interval.to_i} seconds."
+							if !task.next_execution.nil?
+								task.next_execution += task.interval #move it up by interval, regardless of if it's getting executed late
+							else
+								task.next_execution = time + task.interval
+							end
 
-			if defined?(Rails) && Rails.logger
-				Rails.logger.info(log_info)
-			else
-				puts log_info
-			end
+							task.save!
 
-			begin
-				perform
-			rescue => e
-				if defined?(Rails) && Rails.logger
-					Rails.logger.error("DayPlanner: Task caused error on first performance. There's no second chance for a good first impression!\n#{e.inspect}")
-				else
-					puts "DayPlanner: Task caused error on first performance. There's no second chance for a good first impression!\n#{e.inspect}"
+							t.block.call
+						end
+					end
 				end
+			rescue => e
+				Rails.logger.error("DayPlanner: task threw error:\n#{e.inspect}")
 			end
 		end
 	end
-end
+end

data/lib/day_planner/engine.rb

@@ -0,0 +1,15 @@
+require 'day_planner/generators/day_planner_generator'
+
+module DayPlanner
+	class Railtie < Rails::Engine
+		isolate_namespace DayPlanner
+
+		unless $0 =~ /rake/ || defined?(::Rails::Generators) || defined?(::Bundler)# || defined?(::Rails::Console) 
+			initializer "day_planner.activate", after: :finisher_hook do
+				DayPlanner.clear_tasks
+				require File.expand_path('config/scheduled_tasks')
+				DayPlanner.activate
+			end
+		end
+	end
+end

data/lib/day_planner/generators/day_planner_generator.rb

@@ -0,0 +1,45 @@
+require 'rails'
+require 'rails/generators'
+
+module DayPlanner
+	module Generators
+		class InstallGenerator < ::Rails::Generators::Base
+			include ::Rails::Generators::Migration
+
+			source_root File.expand_path('../../templates', __FILE__)
+
+			def copy_migrations
+				copy_migration "create_day_planner_tasks"
+			end
+
+			def create_schedule_file
+				create_file "config/scheduled_tasks.rb", <<-EOS.gsub(/^\w+/, '')
+# Example tasks:
+#
+# DayPlanner.schedule(every: 1.minute, name: "My Task") do
+#   MyClass.my_task
+# End
+				EOS
+			end
+
+		protected
+
+			def copy_migration(filename)
+				if self.class.migration_exists?("db/migrate", filename)
+					say_status("skipped", "Migration #{filename} already exists")
+				else
+					migration_template("migrations/#{filename}.rb", "db/migrate/#{filename}.rb")
+				end
+			end
+
+			def self.next_migration_number(path)
+				unless @previous_migration_number
+					@previous_migration_number = Time.now.utc.strftime('%Y%m%d%H%M%S').to_i
+				else
+					@previous_migration_number += 1
+				end
+				@previous_migration_number.to_s
+			end
+		end
+	end
+end

data/lib/day_planner/templates/migrations/create_day_planner_tasks.rb

@@ -0,0 +1,14 @@
+class CreateDayPlannerTasks < ActiveRecord::Migration
+	def up
+		create_table :day_planner_tasks do |t|
+			t.string   :name
+			t.integer  :interval
+			t.datetime :last_execution
+			t.datetime :next_execution
+		end
+	end
+
+	def down
+		drop_table :day_planner_tasks
+	end
+end

data/lib/day_planner/version.rb

@@ -1,8 +1,9 @@
 module DayPlanner
 	MAJOR = 0
-	MINOR = 0
-	TINY  = 18
+	MINOR = 1
+	TINY  = 0
+	PRE   = "pre1"
 	BUILD = nil
 
-  VERSION = [MAJOR, MINOR, TINY, BUILD].compact.join(".")
+  VERSION = [MAJOR, MINOR, TINY, PRE, BUILD].compact.join(".")
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: day_planner
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.1.0.pre1
 platform: ruby
 authors:
 - Damon Siefert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-30 00:00:00.000000000 Z
+date: 2014-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 description: Simple gem to handle in-process scheduling of tasks
 email:
 - siefert@gmail.com
@@ -51,9 +79,13 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- app/models/day_planner/task.rb
 - day_planner.gemspec
 - lib/day_planner.rb
 - lib/day_planner/base.rb
+- lib/day_planner/engine.rb
+- lib/day_planner/generators/day_planner_generator.rb
+- lib/day_planner/templates/migrations/create_day_planner_tasks.rb
 - lib/day_planner/version.rb
 homepage: ''
 licenses:
@@ -67,12 +99,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.14