fork_break 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47b8e876f9207b88a02d344a00c2d88bc9c39b60
-  data.tar.gz: 3dd3b0fb931ffb70c12e29b58a663d3bcd68bb06
+  metadata.gz: b499c0a1fefcb573b97b0b927c0715efc4b570b7
+  data.tar.gz: 4245c08783830dd2819a342e9e02a6247641e110
 SHA512:
-  metadata.gz: dca4960c3a050d933cf8628907c74d5fce4663530b3afa393863920e2d21665f900690d36f1f711bc4b5e8448b5b6b295f0f54af83c3a24be2fb2aef14e45930
-  data.tar.gz: cb72d3c1a9676f5bfd77bff21d254bc6d37c55ef743ca745f64f74e32b84998222a09f8cbf1b39cfd83c3a3f0ff86e79c53a6b2125d64d56361b1886eb7f0154
+  metadata.gz: b2ae727120864671c37f8422ff1e9a541829a6751e36cf02b7db2296735e29a1b82134ad5f4241763be90d5d967a1935333b21206fd9efad7d2ab62a9187e866
+  data.tar.gz: 58c7081315b18fa3d8296a67006c2dd0caeb229b787b2443ef67af6c6cfa8eedf31a57aedeb79314669a4218b5ffc1391d0e87e20e3862da76d88a20ab4fa7ef

data/.rubocop.yml

@@ -0,0 +1,21 @@
+Documentation:
+  Enabled: false
+
+LineLength:
+  Max: 120
+
+Lint/RescueException:
+  Enabled: false
+
+SignalException:
+  EnforcedStyle: only_raise
+  SupportedStyles:
+    - only_raise
+    - only_fail
+    - semantic
+
+Metrics/AbcSize:
+  Max: 18
+
+Metrics/MethodLength:
+  Max: 15

data/README.md

@@ -98,6 +98,16 @@ puts counter_after_synced_execution("counter_with_lock",    true)  # => 2
 puts counter_after_synced_execution("counter_without_lock", false) # => 1
 ```
 
+There's also the possibility of adding a predefined timeout to the wait function and having it raise an exception.
+
+```ruby
+process = ForkBreak::Process.new do
+  sleep(5)
+end
+
+process.finish.wait(timeout: 1) # will raise ForkBreak::WaitTimeout after 1 second
+```
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -1,2 +1,2 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'

data/fork_break.gemspec

@@ -1,20 +1,23 @@
-# -*- encoding: utf-8 -*-
+require_relative 'lib/fork_break/version'
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Petter Remen"]
-  gem.email         = ["petter.remen@gmail.com"]
-  gem.summary       = %q{Testing multiprocess behaviour is difficult and requires a way to synchronize processes at
-specific execution points. This gem allows the parent process to control the behaviour of child processes using
-breakpoints. It was originally built for testing the behaviour of database transactions and locking mechanisms. }
-  gem.description   = %q{Fork with breakpoints for syncing child process execution}
-  gem.homepage      = "http://github.com/remen/fork_break"
+  gem.authors       = ['Petter Remen']
+  gem.email         = ['petter.remen@gmail.com']
+  gem.summary       =
+    'Testing multiprocess behaviour is difficult and requires a way to synchronize processes at specific execution ' \
+    'points. This gem allows the parent process to control the behaviour of child processes using breakpoints. It was' \
+    'originally built for testing the behaviour of database transactions and locking mechanisms.'
+  gem.description   = 'Fork with breakpoints for syncing child process execution'
+  gem.homepage      = 'http://github.com/remen/fork_break'
+  gem.licenses      = ['MIT']
 
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "fork_break"
-  gem.require_paths = ["lib"]
-  gem.version       = "0.1.2"
-  gem.add_dependency "fork"              , "= 1.0.1"
-  gem.add_development_dependency "rspec" , "= 3.1.0"
+  gem.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  gem.executables   = gem.files.grep(/^bin\//).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(/^(test|spec|features)\//)
+  gem.name          = 'fork_break'
+  gem.require_paths = ['lib']
+  gem.version       = ForkBreak::VERSION
+  gem.add_dependency 'fork', '= 1.0.1'
+  gem.add_development_dependency 'rspec', '~> 3.1', '>= 3.1.0'
+  gem.add_development_dependency 'rubocop', '~> 0.27', '>= 0.27.1'
 end

data/lib/fork_break/breakpoint_setter.rb

@@ -0,0 +1,19 @@
+module ForkBreak
+  class BreakpointSetter
+    def initialize(fork, debug = false)
+      @fork = fork
+      @next_breakpoint = :forkbreak_start
+      @debug = debug
+    end
+
+    def <<(symbol)
+      @fork.send_object(symbol)
+      if symbol == @next_breakpoint
+        @next_breakpoint = @fork.receive_object unless symbol == :forkbreak_end
+        puts "#{@fork.pid} received #{@next_breakpoint}" if @debug
+      end
+    rescue EOFError => exception
+      raise @fork.exception || exception
+    end
+  end
+end

data/lib/fork_break/breakpoints.rb

@@ -0,0 +1,7 @@
+module ForkBreak
+  module Breakpoints
+    def breakpoints
+      ForkBreak::Process.breakpoint_setter
+    end
+  end
+end

data/lib/fork_break/process.rb

@@ -0,0 +1,49 @@
+module ForkBreak
+  class Process
+    class << self
+      attr_accessor :breakpoint_setter
+    end
+
+    def initialize(debug = false, &block)
+      @debug = debug
+      @fork = Fork.new(:return, :to_fork, :from_fork) do |child_fork|
+        self.class.breakpoint_setter = breakpoints = BreakpointSetter.new(child_fork, debug)
+
+        breakpoints << :forkbreak_start
+        block.call(breakpoints)
+        breakpoints << :forkbreak_end
+
+        self.class.breakpoint_setter = nil
+      end
+    end
+
+    def run_until(breakpoint)
+      @next_breakpoint = breakpoint
+      @fork.execute unless @fork.pid
+      puts "Parent is sending object #{breakpoint} to #{@fork.pid}" if @debug
+      @fork.send_object(breakpoint)
+      self
+    end
+
+    def wait(options = {})
+      # A timeout value of nil will execute the block without any timeout
+      Timeout.timeout(options[:timeout], WaitTimeout) do
+        loop do
+          brk = @fork.receive_object
+          puts "Parent is receiving object #{brk} from #{@fork.pid}" if @debug
+          if brk == @next_breakpoint
+            return self
+          elsif brk == :forkbreak_end
+            raise BreakpointNotReachedError, "Never reached breakpoint #{@next_breakpoint.inspect}"
+          end
+        end
+      end
+    rescue EOFError => exception
+      raise @fork.exception || exception
+    end
+
+    def finish
+      run_until(:forkbreak_end)
+    end
+  end
+end

data/lib/fork_break/version.rb

@@ -0,0 +1,3 @@
+module ForkBreak
+  VERSION = '0.1.3'.freeze
+end

data/lib/fork_break.rb

@@ -1,74 +1,10 @@
 require 'fork'
+require 'fork_break/breakpoint_setter'
+require 'fork_break/breakpoints'
+require 'fork_break/process'
+require 'timeout'
 
 module ForkBreak
-  class BreakpointNotReachedError < StandardError ; end
-
-  module Breakpoints
-    def breakpoints
-      return ForkBreak::Process.breakpoint_setter
-    end
-  end
-
-  class Process
-    class << self
-      attr_accessor :breakpoint_setter
-    end
-
-    def initialize(debug = false, &block)
-      @debug = debug
-      @fork = Fork.new(:return, :to_fork, :from_fork) do |child_fork|
-        self.class.breakpoint_setter = breakpoints = BreakpointSetter.new(child_fork, debug)
-
-        breakpoints << :forkbreak_start
-        block.call(breakpoints)
-        breakpoints << :forkbreak_end
-
-        self.class.breakpoint_setter = nil
-      end
-    end
-
-    def run_until(breakpoint)
-      @next_breakpoint = breakpoint
-      @fork.execute unless @fork.pid
-      puts "Parent is sending object #{breakpoint} to #{@fork.pid}" if @debug
-      @fork.send_object(breakpoint)
-      self
-    end
-
-    def wait
-      loop do
-        brk = @fork.receive_object
-        puts "Parent is receiving object #{brk} from #{@fork.pid}" if @debug
-        if brk == @next_breakpoint
-          return self
-        elsif brk == :forkbreak_end
-          raise BreakpointNotReachedError.new("Never reached breakpoint #{@next_breakpoint.inspect}")
-        end
-      end
-    rescue EOFError => exception
-      raise @fork.exception || exception
-    end
-
-    def finish
-      run_until(:forkbreak_end)
-    end
-  end
-
-  class BreakpointSetter
-    def initialize(fork, debug = false)
-      @fork = fork
-      @next_breakpoint = :forkbreak_start
-      @debug = debug
-    end
-
-    def <<(symbol)
-      @fork.send_object(symbol)
-      if symbol == @next_breakpoint
-        @next_breakpoint = @fork.receive_object unless symbol == :forkbreak_end
-        puts "#{@fork.pid} received #{@next_breakpoint}" if @debug
-      end
-    rescue EOFError => exception
-      raise @fork.exception || exception
-    end
-  end
+  class BreakpointNotReachedError < StandardError; end
+  class WaitTimeout < StandardError; end
 end

data/spec/fork_break_spec.rb

@@ -1,104 +1,106 @@
 require 'spec_helper'
 require 'tmpdir'
 
-module ForkBreak
-  describe Process do
-    it "works as intented" do
-      Dir.mktmpdir do |tmpdir|
-        first_file = File.join(tmpdir, "first_file")
-        second_file = File.join(tmpdir, "second_file")
-        process = Process.new do |breakpoints|
-          FileUtils.touch(first_file)
-          breakpoints << :after_first_file
-          FileUtils.touch(second_file)
-        end
-        expect(File.exists?(first_file)).to be_falsey
-        expect(File.exists?(second_file)).to be_falsey
-        
-        process.run_until(:after_first_file).wait
-        expect(File.exists?(first_file)).to be_truthy
-        expect(File.exists?(second_file)).to be_falsey
-
-        process.finish.wait
-        expect(File.exists?(first_file)).to be_truthy
-        expect(File.exists?(second_file)).to be_truthy
+describe ForkBreak::Process do
+  it 'works as intented' do
+    Dir.mktmpdir do |tmpdir|
+      first_file = File.join(tmpdir, 'first_file')
+      second_file = File.join(tmpdir, 'second_file')
+      process = ForkBreak::Process.new do |breakpoints|
+        FileUtils.touch(first_file)
+        breakpoints << :after_first_file
+        FileUtils.touch(second_file)
       end
+      expect(File.exist?(first_file)).to be_falsey
+      expect(File.exist?(second_file)).to be_falsey
+
+      process.run_until(:after_first_file).wait
+      expect(File.exist?(first_file)).to be_truthy
+      expect(File.exist?(second_file)).to be_falsey
+
+      process.finish.wait
+      expect(File.exist?(first_file)).to be_truthy
+      expect(File.exist?(second_file)).to be_truthy
     end
-  
-    it "raises an error (on wait) if a breakpoint is not encountered" do
-      foo = Process.new do |breakpoints|
-        if false
-          breakpoints << :will_not_run
-        end
-      end
-      expect do
-        foo.run_until(:will_not_run).wait
-      end.to raise_error(BreakpointNotReachedError)
+  end
+
+  it 'raises an error (on wait) if a breakpoint is not encountered' do
+    foo = ForkBreak::Process.new do |breakpoints|
+      breakpoints << :will_not_run if false # rubocop:disable LiteralInCondition
     end
+    expect do
+      foo.run_until(:will_not_run).wait
+    end.to raise_error(ForkBreak::BreakpointNotReachedError)
+  end
+
+  it 'works for the documentation example' do
+    class FileCounter
+      include ForkBreak::Breakpoints
+
+      def self.open(path, use_lock = true)
+        file = File.open(path, File::RDWR | File::CREAT, 0600)
+        new(file, use_lock)
+      end
+
+      def initialize(file, use_lock = true)
+        @file = file
+        @use_lock = use_lock
+      end
 
-    it "works for the documentation example" do
-      class FileCounter
-        include ForkBreak::Breakpoints
-
-        def self.open(path, use_lock = true)
-          file = File.open(path, File::RDWR|File::CREAT, 0600)
-          return new(file, use_lock)
-        end
-
-        def initialize(file, use_lock = true)
-          @file = file
-          @use_lock = use_lock
-        end
-
-        def increase
-          breakpoints << :before_lock
-          @file.flock(File::LOCK_EX) if @use_lock
-          value = @file.read.to_i + 1
-          breakpoints << :after_read
-          @file.rewind
-          @file.write("#{value}\n")
-          @file.flush
-          @file.truncate(@file.pos)
-        end
+      def increase
+        breakpoints << :before_lock
+        @file.flock(File::LOCK_EX) if @use_lock
+        value = @file.read.to_i + 1
+        breakpoints << :after_read
+        @file.rewind
+        @file.write("#{value}\n")
+        @file.flush
+        @file.truncate(@file.pos)
       end
+    end
 
-      def counter_after_synced_execution(counter_path, with_lock)
-        process1, process2 = 2.times.map do
-          ForkBreak::Process.new do
-            FileCounter.open(counter_path, with_lock).increase
-          end
-        end
+    def counter_after_synced_execution(counter_path, with_lock) # rubocop:disable Metrics/AbcSize
+      process1, process2 = 2.times.map do
+        ForkBreak::Process.new { FileCounter.open(counter_path, with_lock).increase }
+      end
 
-        process1.run_until(:after_read).wait
+      process1.run_until(:after_read).wait
 
-        # process2 can't wait for read since it will block
-        process2.run_until(:before_lock).wait
-        process2.run_until(:after_read) && sleep(0.1)
+      # process2 can't wait for read since it will block
+      process2.run_until(:before_lock).wait
+      process2.run_until(:after_read) && sleep(0.1)
 
-        process1.finish.wait # Finish process1
-        process2.finish.wait # Finish process2
+      process1.finish.wait # Finish process1
+      process2.finish.wait # Finish process2
 
-        File.read(counter_path).to_i
-      end
+      File.read(counter_path).to_i
+    end
 
-      Dir.mktmpdir do |tmpdir|
-        counter_path = File.join(tmpdir, "counter")
+    Dir.mktmpdir do |tmpdir|
+      counter_path = File.join(tmpdir, 'counter')
 
-        expect(counter_after_synced_execution(counter_path, with_lock = true)).to eq(2)
+      expect(counter_after_synced_execution(counter_path, true)).to eq(2)
 
-        File.unlink(counter_path)
-        expect(counter_after_synced_execution(counter_path, with_lock = false)).to eq(1)
-      end
+      File.unlink(counter_path)
+      expect(counter_after_synced_execution(counter_path, false)).to eq(1)
     end
+  end
 
-    it "raises the process exception" do
-      class MyException < StandardError; end
+  it 'raises the process exception' do
+    class MyException < StandardError; end
 
-      process = ForkBreak::Process.new do
-        raise MyException
-      end
+    process = ForkBreak::Process.new do
+      raise MyException
+    end
 
-      expect { process.finish.wait }.to raise_error(MyException)
+    expect { process.finish.wait }.to raise_error(MyException)
+  end
+
+  it 'raises a wait timeout eror when the process takes longer than the specified wait timeout' do
+    process = ForkBreak::Process.new do
+      sleep(1)
     end
+
+    expect { process.finish.wait(timeout: 0.01) }.to raise_error(ForkBreak::WaitTimeout)
   end
 end

data/spec/spec_helper.rb

@@ -1,12 +1,6 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'fork_break' # and any other gems you need
+require_relative '../lib/fork_break'
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fork_break
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Petter Remen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-28 00:00:00.000000000 Z
+date: 2015-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fork
@@ -28,16 +28,42 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.27'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.27.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.27'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.27.1
 description: Fork with breakpoints for syncing child process execution
 email:
 - petter.remen@gmail.com
@@ -47,16 +73,22 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - fork_break.gemspec
 - lib/fork_break.rb
+- lib/fork_break/breakpoint_setter.rb
+- lib/fork_break/breakpoints.rb
+- lib/fork_break/process.rb
+- lib/fork_break/version.rb
 - spec/fork_break_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/remen/fork_break
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -79,8 +111,8 @@ signing_key:
 specification_version: 4
 summary: Testing multiprocess behaviour is difficult and requires a way to synchronize
   processes at specific execution points. This gem allows the parent process to control
-  the behaviour of child processes using breakpoints. It was originally built for
-  testing the behaviour of database transactions and locking mechanisms.
+  the behaviour of child processes using breakpoints. It wasoriginally built for testing
+  the behaviour of database transactions and locking mechanisms.
 test_files:
 - spec/fork_break_spec.rb
 - spec/spec_helper.rb