asynr 1.0.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af65e3652194e677bf1e61997ad7e279a90f43922c0d0c55df91a104975fa94f
-  data.tar.gz: 890b147fb197d9d5926b2cf6f88afd1d9f3f50df672e27c06723069de9b19b10
+  metadata.gz: be2122555ff23eaa2ab0c58a772e456a6a2348dd4918247be899032fd005e45c
+  data.tar.gz: bccd692489a429f25b11146b05af9bf83069bc7030190784e4d6689f7952e08d
 SHA512:
-  metadata.gz: fb32e46c307a524d5376ce25a26458bde2c448952dee08efe94498116e3b32ea2c03d3572e7fb6ed125a3916938f77a16845a965f280d55adb1de6c1f8420b99
-  data.tar.gz: 40262c7d19e54bdaf196894c591d401585ccf0441bf014176886097ce7dadaaf29ae16cb0a8d8d452aee1a61295cd10ce87734728b603760b56211c5a18e4e1a
+  metadata.gz: 736797b5859756d0de5538d45760b146acad553c39a25c2d868b04cf1ad6710cf5c9925ac7eb9e50bd825466c30bff6114b6295009407d9772806bd1ddc0930b
+  data.tar.gz: 424c018cb3b2eeca345ba621049ce90d412565849b4f769193587ae94dc9eb0b8f14806cf22fba666e05f1f3f6b1fcb8a78736a1c872e8adcf3ca7e7816b4d35

data/.gitignore

@@ -7,5 +7,6 @@
 /spec/reports/
 /tmp/
 /.vendor/
+/.Gemfile.lock
 # rspec failure tracking
 .rspec_status

data/Gemfile.lock

@@ -1,20 +1,12 @@
 PATH
   remote: .
   specs:
-    asynr (1.0.1)
-      rufus-scheduler (~> 3.6.0)
+    asynr (1.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    concurrent-ruby (1.1.5)
     diff-lcs (1.3)
-    et-orbi (1.2.2)
-      tzinfo
-    fugit (1.3.3)
-      et-orbi (~> 1.1, >= 1.1.8)
-      raabro (~> 1.1)
-    raabro (1.1.6)
     rake (10.5.0)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
@@ -29,10 +21,6 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
     rspec-support (3.8.2)
-    rufus-scheduler (3.6.0)
-      fugit (~> 1.1, >= 1.1.6)
-    tzinfo (2.0.0)
-      concurrent-ruby (~> 1.0)
 
 PLATFORMS
   ruby
@@ -42,7 +30,6 @@ DEPENDENCIES
   bundler (~> 2.0)
   rake (~> 10.0)
   rspec (~> 3.0)
-  rufus-scheduler
 
 BUNDLED WITH
    2.0.2

data/README.md

@@ -1,115 +1,108 @@
 # Asynr
 
-A Ruby async scheduler based-upon Rufus::Scheduler gem.
-
-# How to install
-
-```bash
-$ gem install asynr
-$ echo "gem 'asynr'" >> Gemfile
-$  bundle install
-``` 
-
-# How to use
-
-## Minimal setup
+(This gem is a rebuild of a previous one located at the same Github repository).
+\
+Asynr is a gem to perform asynchronous tasks by evaluating directly classes and entrypoints.
+This is highly inspired by Rufus-Scheduler.
 
-Asynr needs to know which class to be evaluated and scheduled. Require any class file before launching it.
+## How it works ?
 
+When you want to create a scheduler running several tasks separated by classes, you can instantiate Asynr and launch them asynchronously an easy way.
+\
+Asynr is based-upon Ruby threads and requires no dependency.
 ```ruby
+# example
 require "asynr"
-require_relative "./random_lib_with_class"
-...
+Dir.glob(Dir.pwd + "/lib/*_class.rb").each &method(:require)
+
+class Worker
+  def self._start
+    scheduler = Asynr.new
+    scheduler.in 3, ARandomClass
+    scheduler.every 3600, 2, AnotherClass, {entrypoint: :new}
+    scheduler.at (Time.now + 10), AgainAnother, {arg1: :hello, arg2: :world}
+  
+    scheduler.start
+  end
+end
 ```
 
-## Add a new job
-
-Jobs are minimal, since all Rufus methods aren't intented to be implemented. Here are the four parameters currently supported by Asynr.
-
-* name: each job has a name which can be used to remove the concerned job.
-* action: is the evaluated class name. Async will search for a run method inside of this class.
-* first_in: directly taken from Rufus, time before the action starts.
-* every: time between two class executions.
+* We require asynr and all the files containing independant classes.
+* We instantiate a new scheduler, which is gonna be empty
+* We create .in, .every and .at jobs (read definitions)
+* We start it
 
-## Remove a job
+## launch a job in two days
 
-Jobs can be removed dynamically with their name: 
+```ruby 
+secrets = File.read '/a/secret/path/secrets.txt'
 
-```ruby
-...
-inst.job(name: :Test, action: :RandomTest, every: 10, first_in: 0)
-inst.queue.length # 1
-inst.remove :Test
-inst.queue.length # 0
-...
+scheduler = Asynr.new
+scheduler.at (Time.now + (3600 * 24) * 2), BackupFiles, {password: secrets}
+scheduler.start
 ```
 
-## Start all jobs
+In this example, we are using the arguments API of Asynr. It allows us to bind any value to any key when calling a .in, .every or .at method.
 
-Once launched, a new job cannot be defined and added. We need to set all the jobs and related timers before starting the scheduler.
 
+## launch a job every hour
 ```ruby
-require "asynr"
+url = "https://acoolwebsitetoscrap.com"
 
-inst = Asynr.new
-inst.job(name: :Test, action: RandomTest, every: 10, first_in: 0)
-inst.job(name: :Again, action: AnotherTest, every: 3, first_in: 1)
-inst.queue.length # 2
-
-inst.start!
+scheduler = Asynr.new
+scheduler.every 3600, 0, WebScrapper, {entrypoint: :new, url: url, save_to: "/tmp/scrapper"}
+scheduler.start
 ```
 
-# Working example 
-
-Since the logic behind it may confuse you regarding the class evaluation, here's a working example of how to use Asynr. Minimal yet functionnal.
+We typically want to download a whole page every hour since it may change soon. This snippet allows you to send the url and the path where you want to save scrapped file.
 \
-This example will save a HTTP request launched every 60 seconds, for ever (until it is stopped).
 
+### Entrypoint argument
+Entrypoint is a quite special argument, since it allows you to select which class method is gonna be called by the class evaluator. `new` allows you to create objects, and the default value is `self._entrypoint`.
+
+Here is what a default Asynr-compliante class may look like.
 ```ruby
-require "asynr"
-require "typhoeus"
-
-class JSONFetcher
-    def self.run
-        res = Typhoeus::Request.get("https://httpbin.org/get")
-        f = File.open "./http_bin_get.log", "a+"
-        f.puts res.body
-    end
+class WebScrapper
+  def self._entrypoint(*args)
+    body = AnyHTTPLib.get(URI.parse(args[:url])).body
+    f = File.open("%s/%s" % [args[:save_to], Time.now.strftime('%y-%m-%d')])
+    f.puts body
+    f.close
+  end
 end
+```
 
-inst = Asynr.new
-inst.job(name: :JSONFetcher, action: JSONFetcher, first_in: 1, every: 60)
-inst.start!
+## Launch a job in two minutes
+```ruby
+scheduler = Asynr.new
+scheduler.in 120, PrintHelloWorld
 ```
 
-## Optional architecture
+This is a quite easy method to understand. Please mind you are free to put arguments at the end of this line or select another entrypoint than `_entrypoint`.
 
-With the previous example, we saw how Asynr works, but its initial goal is to allow us to create easy-to-develop softwares with integrated scheduler, such as API aggregator, or middlewares.
+# Why an entrypoint ?
+Ruby doesn't have any entrypoint function as main() could be one in Go, for example. This function is typically intended to provide a "entrypoint" where function-calls tree will be created and attached to. Since Ruby doesn't have it, without a entrypoint method, Asynr wouldn't be able to load and execute the class in a cool way.
 \
-Here's a software architecture that works.
+I called this temporary main method `_entrypoint`. The `_` means it is special and it allows us to avoid common names mistakes. This method must be registred as `self` into a class to be called as it.
 
-```
-Gemfile
-scheduler.rb
-worker/
-    - download_first_file.rb
-    - download_second_file.rb
-    - download_third_file.rb
-lib/
-    - dependency.rb
+```ruby
+class RandomTest ; def self._entrypoint(*args) ; end ; end
 ```
 
-Asynr can easily handle all these executions every 60 seconds, for example.
+You can override this parameter (in order to create instance through .new method, for example) by adding a `{entrypoint: :any_method}` argument to .in, .every and .at methods.
+\
+Please note the `*args` method parameter. It allows us to bind any information comming from the scheduler to attach it into the entrypoint method.
 \
-Into scheduler.rb : 
+Working example : 
 ```ruby
-require "asynr"
-Dir.glob(Dir.pwd + "/worker/*.rb").each &method(:require)
+url = "https://rubygems.org"
 
-asynr = Asynr.new
-asynr.job(name: :firstFile, action: DownloadFirstFile, first_in: 0, every: 60)
-asynr.job(name: :secondFile, action: DownloadSecondFile, first_in: 0, every: 60)
-asynr.job(name: :thirFile, action: DownloadThirdFile, first_in: 0, every: 60)
+scheduler = Asynr.new
+scheduler.in 3, DisplaySomething, {text: url}
 
-asynr.start!
+class DisplaySomething
+  def self._entrypoint(*args)
+    puts args[:text]
+  end
+end
 ```

data/asynr.gemspec

@@ -5,19 +5,19 @@ require "asynr/version"
 Gem::Specification.new do |spec|
   spec.name          = "asynr"
   spec.version       = Asynr::VERSION
-  spec.authors       = ["Atille"]
-  spec.email         = ["gfrancoisfrancois@outlook.com"]
+  spec.authors       = ["Gautier François"]
+  spec.email         = ["gfrancois@online.net"]
 
-  spec.summary       = %q{Async job planner based upon Rufus scheduler}
-  spec.description   = %q{Async job planner based upon Rufus scheduler Ruby gem and threads, with history and states.}
-  spec.homepage      = "https://rubygems.org/gems/asynr"
+  spec.summary       = %q{Asynchronous scheduler based upon threads.}
+  spec.description   = %q{Asynr evaluates asynchrounsly Ruby classes by calling entrypoint methods. It intends to be useful to schedule job tasks an easier way than currently.}
+  spec.homepage      = "https://github.com/atilleh/asynr"
   spec.license       = "MIT"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
   spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/atilleh/async"
-  spec.metadata["changelog_uri"] = "https://github.com/atilleh/async"
+  spec.metadata["source_code_uri"] = "https://github.com/atilleh/asynr"
+  spec.metadata["changelog_uri"] = "https://github.com/atilleh/asynr/tree/master/CHANGELOG.md"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -31,7 +31,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "rufus-scheduler"
-
-  spec.add_runtime_dependency 'rufus-scheduler', '~> 3.6.0'
 end

data/lib/asynr.rb

@@ -1,17 +1,15 @@
 require "asynr/version"
 require "asynr/core"
 require "asynr/job"
+require "asynr/scheduler"
 
 module Asynr
 
-  # Shortcut returning Core object
-  # Will be called with Asynr.new instead of 
-  # Asynr::Core.new
-  #
-  # @param params [Hash] defaults options
-  # @return self [Object] self from Asynr::Core
+  # Create a new scheduler
+  # @param params [Hash] default option to create a scheduler.
+  # @return self [Object] scheduler object from #Core
   def self.new(params={})
-    Asynr::Core.new(params)
+    Core.new(params)
   end
 
   class Error < StandardError; end

data/lib/asynr/core.rb

@@ -1,52 +1,68 @@
-require "rufus-scheduler"
-
 module Asynr
-  # Main gem class
+  # Core class exposes user-related methods 
+  # to configure the scheduler jobs.
   class Core
-    # Creates a new Rufus Scheduler and waits to 
-    # populate the local queue.
-    # This local queue is gonna be converted into a 
-    # rufus queue.
-    def initialize(params={})
+    def initialize(params)
       @params = params
-      @local_queue = []
-      @queue = Rufus::Scheduler.new
+      @scheduler = {
+        jobs: []
+      }
+    end
+
+    # Create a new :in job
+    # @param seconds [Int32] seconds to wait before running the job
+    # @param action_class [Object] class to evaluate
+    # @param arguments [Hash] optional arguments to pass to the job creator.
+    def in(seconds, action_class, *arguments)
+      @scheduler[:jobs].append(Job.new(
+        type: :in,
+        params: { seconds: seconds },
+        action: action_class,
+        arguments: arguments ||= nil
+      ))
     end
 
-    # @return .local_queue [Array] already registered but unlaunched jobs.
-    def queue
-      @local_queue
+    # Create a new :every job
+    # @param seconds [Int32] seconds to wait between two occurences
+    # @param delay [Int32] amount of seconds before running it the first time
+    # @param action_class [Object] class to instantiate and execute.
+    # @param arguments [Hash] optional argument to transmit to the entrypoint.
+    def every(seconds, delay, action_class, *arguments)
+      @scheduler[:jobs].append(Job.new(
+        type: :every,
+        params: { seconds: seconds, delay: delay},
+        action: action_class,
+        arguments: arguments ||= nil
+      ))
     end
 
-    # Create a new job
-    # @see Job.new
-    # @return job [Object] newly created job object.
-    def job(options={})
-      job = Asynr::Job.new(options)
-      @local_queue.append job
-      job
+    # Create a new :at job
+    # @param date_to [Object] Time object cursor to run the job.
+    # @param action_class [Object] class to instantiate and execute.
+    # @param arguments [hash] optional arguments to transmit to the entrypoint.
+    def at(date_to, action_class, *arguments)
+      @scheduler[:jobs].append(Job.new(
+        type: :at,
+        params: { date: date_to },
+        action: action_class,
+        arguments: arguments ||= nil
+      ))
     end
 
-    # Removes a job from the local queue.
-    # Useless if the queue has already been converted by .dispatch!
-    # @see dispatch!
-    def remove(name)
-      @local_queue.delete_if {|i| i.name == name}
+    # Starts the scheduler.
+    def start
+      Scheduler.new(@scheduler)
     end
 
-    # Converts the local_queue to rufus queue
-    # execute it.
-    def start!
-      dispatch!
-      @queue.join
+    # @return @scheduler [Hash] current scheduler instance
+    def config
+      @scheduler
     end
 
-    # dispatch! converts local queue to rufus every object queue.
-    protected
-    def dispatch!
-      @local_queue.each do |job|
-        @queue.every job.every, first_in: job.first_in do job.action.send(:run) ; end
-      end
-    end				
+    # @return @scheduler [Hash] current job queue
+    def jobs
+      @scheduler[:jobs]
+    end
   end
-end
+end
+      

data/lib/asynr/job.rb

@@ -1,31 +1,59 @@
 module Asynr
-  
-  # Class for job initialization
   class Job
-    # Creates a new job instance, returned to Core library.
-    # @param options [Hash] job options before start! call
-    # @return nil
-    def initialize(options={first_in: 60, every: 60})
-      @options = options
-    end
-
-    # Setter/Getter of name option.
-    def name ; @options[:name] ; end
-    # @param name [Symbol] job short name
-    def name=(name) ; @options[:name] = name ; end
-    
-    def action ; @options[:action] ; end
-    # @param action [Class] class instance to evaluate
-    def action=(action) ; @options[:action] = action ; end
-
-    # Time to wait before running a job twice
-    def every ; @options[:every] ; end
-    # @param every [Int] amount of seconds
-    def every=(every) ; @options[:every] = every ; end
-
-    # Time to wait before starting the first job occurence
-    def first_in ; @options[:first_in] ; end
-    # @param first_in [Int] amount of seconds
-    def first_in=(first_in) ; @options[:first_in] = first_in ; end
+    def initialize(job_descriptor)
+      @job = job_descriptor
+      @job[:metas] = {
+        created_at: Time.now,
+        created_at_timestamp: Time.now.to_i,
+        updated_at: Time.now,
+        status: :awaiting
+      }
+
+      if job_descriptor[:arguments][0].key? :entrypoint
+        @job[:entrypoint] = job_descriptor[:arguments][0][:entrypoint]
+      else
+        @job[:entrypoint] = :_entrypoint
+      end
+    end
+
+    def type
+      @job[:type]
+    end
+
+    def params
+      @job[:params]
+    end
+
+    def arguments
+      @job[:arguments]
+    end
+
+    def action
+      @job[:action]
+    end
+
+    def metas
+      @job[:metas]
+    end
+
+    def update
+      @job[:metas][:updated_at] = Time.now
+    end
+
+    def declare_running
+      @job[:metas][:status] = :running
+    end
+
+    def declare_finished
+      @job[:metas][:status] = :finished
+    end
+
+    def declare_scheduled
+      @job[:metas][:status] = :scheduled
+    end
+
+    def entrypoint
+      @job[:entrypoint]
+    end
   end
 end

data/lib/asynr/scheduler.rb

@@ -0,0 +1,100 @@
+module Asynr
+  # Scheduler class creates new threads for any job
+  # added to scheduler.
+  # @see Core#start
+  class Scheduler
+    # Creates an empty array of threads
+    # For each job, determines its type and create a thread based
+    #  on it.
+    # Finally, executes the threads.
+    def initialize(scheduler)
+      @threads = []
+      scheduler[:jobs].each do |job|
+        @threads.append(_in(job)) if job.type == :in
+        @threads.append(_every(job)) if job.type == :every
+        @threads.append(_at(job)) if job.type == :at
+      end
+
+      @threads.each do |thr|
+        p thr.inspect
+        thr.join
+      end
+    end
+
+    protected
+    # Creates a new :in job.
+    # @param job [Object] job instance
+    # @return thx [Thread] thread transition
+    def _in(job)
+      thx = Thread.new do
+        job.declare_running
+        sleep job.params[:seconds]
+        job.action.send(job.entrypoint, job.arguments[0])
+        job.update
+        job.declare_finished
+      end
+
+      thx
+    end
+
+    # Creates a new :every job
+    # Will sleep if a delay has been set.
+    # Will be executed only once if kill parameter submitted.
+    # @param job [Object] job instance
+    # @return thx [Thread] thread transition
+    def _every(job)
+      thx = Thread.new do |thx|
+        job.declare_running
+        sleep job.params[:delay] ||= 0
+        x = true
+
+        while x == true
+          job.action.send(job.entrypoint, job.arguments[0])
+          job.update
+
+          if job.arguments[0][:kill]
+            puts "Job will sleep."
+            x = false
+          end
+
+          sleep job.params[:seconds]
+        end
+      end
+
+      thx
+    end
+
+    # Creates a new :at job
+    # Will be killed if kill argument specified.
+    # By default, execute the same job every day.
+    # @param job [Object] job object
+    # @return thx [Thread] thread transition
+    def _at(job)
+      thx = Thread.new do |thx|
+        job.declare_scheduled
+
+        x = false
+
+        while x == false
+          if Time.now.to_i == job.params[:date].to_i
+            job.declare_running
+            job.action.send(job.entrypoint, job.arguments[0])
+            job.update
+            job.declare_finished
+
+            if job.arguments[0][:kill]
+              x = true
+            end
+
+            job.params[:date] = Time.now + 86400
+          else
+            sleep 1
+          end
+        end
+      end
+
+      thx
+    end
+
+  end
+end

data/lib/asynr/version.rb

@@ -1,3 +1,3 @@
 module Asynr
-  VERSION = "1.0.1"
+  VERSION = "1.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: asynr
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.3.0
 platform: ruby
 authors:
-- Atille
+- Gautier François
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-30 00:00:00.000000000 Z
+date: 2019-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,38 +52,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rufus-scheduler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rufus-scheduler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.6.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.6.0
-description: Async job planner based upon Rufus scheduler Ruby gem and threads, with
-  history and states.
+description: Asynr evaluates asynchrounsly Ruby classes by calling entrypoint methods.
+  It intends to be useful to schedule job tasks an easier way than currently.
 email:
-- gfrancoisfrancois@outlook.com
+- gfrancois@online.net
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -103,15 +75,16 @@ files:
 - lib/asynr.rb
 - lib/asynr/core.rb
 - lib/asynr/job.rb
+- lib/asynr/scheduler.rb
 - lib/asynr/version.rb
-homepage: https://rubygems.org/gems/asynr
+homepage: https://github.com/atilleh/asynr
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://rubygems.org/gems/asynr
-  source_code_uri: https://github.com/atilleh/async
-  changelog_uri: https://github.com/atilleh/async
+  homepage_uri: https://github.com/atilleh/asynr
+  source_code_uri: https://github.com/atilleh/asynr
+  changelog_uri: https://github.com/atilleh/asynr/tree/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -131,5 +104,5 @@ rubyforge_project:
 rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
-summary: Async job planner based upon Rufus scheduler
+summary: Asynchronous scheduler based upon threads.
 test_files: []