time_scheduler 1.0.0

data/Rakefile

@@ -0,0 +1,96 @@
+require "bundler/gem_helper"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+class Bundler::GemHelper
+
+  def git_archive( dir = "../#{Time.now.strftime("%Y%m%d")}" )
+    FileUtils.mkdir_p  dir
+    dest_path  =  File.join(dir, "#{name}-#{version}.zip")
+    cmnd  =  "git archive --format zip --prefix=#{name}/ HEAD > #{dest_path}"
+
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't archive gem,"  unless  code == 0
+
+    Bundler.ui.confirm "#{name} #{version} archived to #{dest_path}."
+  end
+
+  def git_push
+    ver  =  version.to_s
+
+    cmnd  =  "git push origin  #{ver} "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git push origin."  unless  code == 0
+
+    cmnd  =  "git push "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git push."         unless  code == 0
+
+    Bundler.ui.confirm "Git Push #{ver}."
+  end
+
+  def update_version( new_version )
+    version_filename  =  %x[ find . -type f -name "version.rb" | grep -v vendor | head -1 ].chomp
+    version_pathname  =  File.expand_path( version_filename )
+    lines  =  File.open( version_pathname ).read
+    lines  =  lines.gsub( /VERSION\s*=\s*\"\d+\.\d+\.\d+\"/, "VERSION = \"#{new_version}\"" )
+    File.open( version_pathname, "w" ) do |file|
+      file.write( lines )
+    end
+
+    cmnd  =  "git add  #{version_pathname} "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git add,"  unless  code == 0
+
+    cmnd  =  "git commit -m  '#{new_version}' "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git commit."  unless  code == 0
+
+    cmnd  =  "git tag        #{new_version} "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git tag."          unless  code == 0
+
+    Bundler.ui.confirm "Update Tags to #{new_version}."
+  end
+
+end
+
+Bundler::GemHelper.new(Dir.pwd).instance_eval do
+
+  desc "Archive #{name}-#{version}.zip from repository"
+  task 'zip' do
+    git_archive
+  end
+
+  desc "Git Push"
+  task 'push' do
+    git_push
+  end
+
+  desc "Update Version Tiny"
+  task 'tiny' do
+    major, minor, tiny  =  version.to_s.split('.')
+    new_version  =  [major, minor, tiny.to_i + 1].join('.')
+    update_version( new_version )
+  end
+
+  desc "Update Version Minor"
+  task 'minor' do
+    major, minor, tiny  =  version.to_s.split('.')
+    new_version  =  [major, minor.to_i + 1, 0].join('.')
+    update_version( new_version )
+  end
+
+  desc "Update Version Major"
+  task 'major' do
+    major, minor, tiny  =  version.to_s.split('.')
+    new_version  =  [major.to_i + 1, 0, 0].join('.')
+    update_version( new_version )
+  end
+
+end
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "time_scheduler"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/time_scheduler.rb

@@ -0,0 +1,4 @@
+require "time_scheduler/version"
+require "time_scheduler/event"
+require "time_scheduler/scheduler"
+

data/lib/time_scheduler/event.rb

@@ -0,0 +1,84 @@
+require "set"
+
+class TimeScheduler
+
+  class Error < StandardError; end
+
+  class EventItem
+    include ::Comparable
+
+    attr_reader :time, :queue, :ident
+
+    def initialize( time, queue, ident )
+      @time  =  time
+      @queue  =  queue
+      @ident  =  ident
+    end
+
+    def <=>( other )
+      return  nil    unless other.is_a?( EventItem )
+      self.time <=> other.time
+    end
+  end
+
+  class EventQueue
+
+    REFRESH_TIME  =  3600.0
+
+    def initialize( **option )
+      @event_mutex  =  ::Mutex.new
+      @event_queue  =  ::Queue.new
+      @event_set  =  ::SortedSet.new
+      run
+    end
+
+    def reserve( time, queue, ident )
+      @event_mutex.synchronize do
+        @event_set.add( EventItem.new( time, queue, ident ) )
+        wait_time  =  [time - Time.now, REFRESH_TIME + rand * 2 - 1].min
+        if  wait_time <= 0
+          @event_queue.push( 1 )
+        else
+          Thread.start do
+            ::Kernel.sleep( wait_time )
+            @event_queue.push( 1 )
+          end
+        end
+      end
+    end
+
+    def refresh( time )
+      wait_time  =  [time - Time.now, REFRESH_TIME + rand * 2 - 1].min
+      Thread.start do
+        ::Kernel.sleep( wait_time )
+        @event_queue.push( 1 )
+      end
+    end
+
+    def run
+      Thread.start do
+        begin
+          while  true
+            @event_queue.pop
+            @event_mutex.synchronize do
+              event_item  =  @event_set.first
+
+              now  =  Time.now
+              if  event_item.time <= now
+                @event_set.delete( event_item )
+                event_item.queue.push( [now, event_item.ident] )
+              else
+                refresh( event_item.time )
+              end
+            end
+          end
+        rescue => e
+          raise  ::TimeScheduler::Error, "#{__FILE__}: #{e.message}"
+        end
+      end
+    end
+
+  end
+
+end
+

data/lib/time_scheduler/scheduler.rb

@@ -0,0 +1,226 @@
+require "time_cursor"
+
+class TimeScheduler
+
+  class Schedule
+    NICE_TIME  =  0.001
+
+    class << self
+      def active?
+        ! @@pause
+      end
+
+      def suspend
+        @@pause  =  true
+      end
+
+      def resume
+        @@pause  =  false
+      end
+    end
+
+    def initialize
+      @schedule_thread  =  nil
+      @schedule_mutex  =  ::Mutex.new
+      @signal_queue  =  ::Queue.new
+
+      @@pause  =  false
+      @@EventQueue  ||=  TimeScheduler::EventQueue.new
+    end
+
+    def cancel
+      @signal_queue.push( nil )
+    end
+
+    def setup( **option, &block )
+      @option  =  option
+      @action  =  option[:action]  ||  block  ||  @action
+
+      opt  =  {}
+      @option.each do |k, v|
+        if  [:at, :cron, :year, :month, :day, :wday, :hour, :min, :sec, :msec].include?(k)
+          opt[k]  =  v
+        end
+      end
+      @time_cursor  =  TimeCursor.new( **opt )
+      @nice_time  =  option[:nice].to_i  *  NICE_TIME
+      time  =  Time.now
+      @ident  =  time.to_i * 1000000 + time.usec
+    end
+
+    def wait_each( **option, &block )
+      setup( **option, &block )
+
+      @schedule_thread  =  ::Thread.start do
+        while  true
+          target_time  =  @time_cursor.next
+          if  target_time.nil?
+            @signal_queue.clear
+            break
+          end
+
+          @@EventQueue.reserve( target_time + @nice_time, @signal_queue, @ident )
+
+          while  true
+            time, ident  =  * @signal_queue.pop
+            break    if  time.nil?  ||  ident == @ident
+          end
+
+          if  time.nil?
+            @signal_queue.clear
+            break
+          end
+
+          next    if  @@pause
+
+          ::Thread.start( time ) do
+            @schedule_mutex.synchronize do
+              @action.call( time )
+            end
+          end
+        end
+        nil
+      end
+      nil
+    end
+
+    def wait_once( **option )
+      setup( **option )
+
+      @schedule_thread  =  ::Thread.start do
+        target_time  =  @time_cursor.next
+        if  target_time.nil?
+          @signal_queue.clear
+          break
+        end
+
+        @@EventQueue.reserve( target_time + @nice_time, @signal_queue, @ident )
+
+        while  true
+          time, ident  =  * @signal_queue.pop
+          break    if  time.nil?  ||  ident  == @ident
+        end
+
+        if  time.nil?
+          @signal_queue.clear
+        end
+        time
+      end
+
+      @schedule_thread.join
+      time  =  @schedule_thread.value
+      time
+    end
+
+    def wait_reset( **option, &block )
+      if @action
+        setup( **option, &block )
+      else
+        option[:action]  =  nil
+        setup( **option )
+      end
+
+      time_next  =  @time_cursor.next
+      @@EventQueue.reserve( time_next + @nice_time, @signal_queue, @ident )    if  time_next
+    end
+  end
+
+  class Scheduler
+    def schedules
+      @schedules  ||=  {}
+    end
+
+    def reserved?( topic )
+      schedules.has_key?( topic )
+    end
+
+    def wait_reset( topic, **option, &block )
+      if  schedule  =  schedules[topic]
+        schedule.wait_reset( **option, &block )
+        topic
+      end
+    end
+
+    def wait_each( topic, **option, &block )
+      schedule  =  TimeScheduler::Schedule.new
+      schedules[topic]  =  schedule
+      schedule.wait_each( **option, &block )
+      topic
+    end
+
+    def wait_once( topic, **option )
+      schedule  =  TimeScheduler::Schedule.new
+      schedules[topic]  =  schedule
+      schedule.wait_once( **option )
+    ensure
+      schedules.delete( topic )
+    end
+
+    def topics
+      schedules.keys.dup
+    end
+
+    def cancel( topic )
+      if  schedule  =  schedules[topic]
+        schedule.cancel
+      end
+    rescue => e
+      puts  e.backtrace
+    ensure
+      schedules.delete( topic )
+    end
+
+    def join
+      while  schedules.size > 0
+        topic  =  schedules.keys.first
+        schedule  =  schedules[topic]
+        schedule.join
+      end
+    end
+  end
+
+  def initialize
+  end
+
+  def scheduler
+    @@Scheduler  ||=  TimeScheduler::Scheduler.new
+  end
+
+  def wait( topic = Time.now.iso8601(6), **option, &block )
+    raise  TimeScheduler::Error, "option missing."    if  option.empty?
+
+    if scheduler.reserved?( topic )
+      scheduler.wait_reset( topic, **option, &block )
+    else
+      if option[:action].nil?  &&  block.nil?
+        scheduler.wait_once( topic, **option )
+      else
+        scheduler.wait_each( topic, **option, &block )
+      end
+    end
+  end
+
+  def topics
+    scheduler.topics
+  end
+
+  def cancel( *topics )
+    topics.each do |topic|
+      scheduler.cancel( topic )
+    end
+  end
+
+  def active?
+    TimeScheduler::Schedule.active?
+  end
+
+  def suspend
+    TimeScheduler::Schedule.suspend
+  end
+
+  def resume
+    TimeScheduler::Schedule.resume
+  end
+
+end
+

data/lib/time_scheduler/version.rb

@@ -0,0 +1,3 @@
+class TimeScheduler
+  VERSION = "1.0.0"
+end

data/sample/base_1.rb

@@ -0,0 +1,11 @@
+
+require "time_scheduler"
+
+Scheduler  =  TimeScheduler.new
+
+goal  =  Time.now + 3
+while  time  =  Scheduler.wait( sec: "*" )
+  p Time.now.iso8601(3)
+  break    if time > goal
+end
+