boxxspring-workers 1.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a8ab0b25057afe43c90af53902ec1410d5230c2
+  data.tar.gz: f57b1b142e88bac02e52d893f1824fd63e19cacf
+SHA512:
+  metadata.gz: 141d7d76f6209efe1b7beb56673094e1ed549dbf572dfef923524b4ab295ea35741b6961e4b655a612b91b0f52dabd8f81c47674fc74ca565b3f1c884e7d0e0a
+  data.tar.gz: 3f135b6596edf3a741e9df12d2870a9eafa8a3aded85205c198e17e94a2f651056452de89213be800bf81a54ed5bcfbb0ab38df2cb665786d91cb847b3a43abc

data/lib/boxxspring/abstract.rb

@@ -0,0 +1,37 @@
+module Boxxspring
+
+  class Abstract
+
+    def initialize( attributes = {} )
+      @attributes = {}
+      attributes.each_pair do | key, value |
+        self.send( key, value )
+      end
+    end
+
+    def to_hash
+      return @attributes
+    end
+
+    def method_missing( method, *arguments, &block )
+      result = nil
+      if arguments.length == 0 
+        result = @attributes[ method.to_sym ] 
+        if result.nil? 
+          result = Abstract.new
+          result.instance_eval( &block ) unless block.nil?
+          @attributes[ method.to_sym ] = result 
+        end 
+      elsif arguments.length == 1
+        method = method.to_s.gsub( /=$/, '' )
+        result = arguments[ 0 ]
+        @attributes[ method.to_sym ] = result 
+      else
+        result = super 
+      end
+      result
+    end    
+
+  end
+
+end

data/lib/boxxspring/journal.rb

@@ -0,0 +1,60 @@
+module Boxxspring
+
+  class Journal
+
+    def initialize( name )
+      @db_name = name
+    end
+
+    def write( id, attributes )
+      db_attributes = []
+      attributes.each_pair do | key, value |
+        db_attributes.push( { 
+          name: key.to_s, value: value.to_s, replace: true
+        } )
+      end
+      self.db.put_attributes( {
+        domain_name: @db_name,
+        item_name: id.to_s,
+        attributes: db_attributes 
+      } )
+    end
+    
+    def read( id )
+      result = nil
+      db_record = self.db.get_attributes(
+        domain_name:      @db_name,
+        item_name:        id.to_s,
+        consistent_read:  true
+      )
+      if db_record.present? && 
+         db_record.attributes.present? &&
+         db_record.attributes.length > 0 
+        result = {}
+        db_record.attributes.each do | attribute |
+          result[ attribute.name.to_sym ] =  attribute.value
+        end
+      end
+      result
+    end
+
+    def delete( id )
+      db_record = self.db.delete_attributes(
+        domain_name:      @db_name,
+        item_name:        id.to_s
+      )
+    end
+
+    protected; def db 
+      @db ||= begin 
+        db = Aws::SimpleDB::Client.new
+        db.create_domain(
+          domain_name: @db_name
+        )
+        db
+      end    
+    end
+
+  end
+
+end

data/lib/boxxspring/synchronization/configuration.rb

@@ -0,0 +1,32 @@
+module Boxxspring
+
+  module Synchronization 
+
+    class Configuration 
+
+      include Singleton
+
+      def self.field( field_name, options = {} )
+
+        class_eval(
+          "def #{field_name}( *arguments ); " +
+             "@#{field_name} = arguments.first unless arguments.empty?; " +
+             "@#{field_name} || " +
+               ( options[ :default ].blank? ?
+                  "nil" :
+                  ( options[ :default ].is_a?( String ) ? 
+                      "'#{options[ :default ]}'" : 
+                        "#{options[ :default ]}" ) ) + ";" +
+          "end",
+          __FILE__, 
+          __LINE__
+        )
+
+      end
+
+      field :url,         default: "redis://127.0.0.1:6379/0"
+
+    end
+
+  end
+end

data/lib/boxxspring/synchronization/mutex.rb

@@ -0,0 +1,24 @@
+module Boxxspring
+  module Synchronization
+
+    class Mutex 
+
+      def initialize( name, signature = nil )
+        @orchestrator = Synchronization::Orchestrator.instance
+        @name = name
+        @signature = signature || SecureRandom.hex
+      end
+
+      def lock( options = {} )
+        @orchestrator.lock( @name, @signature, options )
+      end
+
+      def unlock
+        @orchestrator.unlock( @name, @signature )
+      end
+
+    end
+
+  end
+
+end

data/lib/boxxspring/synchronization/operations.rb

@@ -0,0 +1,81 @@
+module Boxxspring
+  module Synchronization
+
+    self.const_set 'Operations', {
+
+      lock: 
+        "local result = false; "\
+        "local value = redis.call( 'get', KEYS[ 1 ] ); "\
+        "if ( not value ) then "\
+          "redis.call( 'set', KEYS[ 1 ], ARGV[ 1 ] ); "\
+          "result = true; "\
+        "elseif value == ARGV[ 1 ] then "\
+          "result = true; "\
+        "end; "\
+        "if result == true and not ( ARGV[ 2 ] == '' ) then "\
+          "redis.call( 'pexpire', KEYS[ 1 ], ARGV[ 2 ] ); "\
+        "end; "\
+        "return result",
+
+      unlock: 
+        "local result = false; "\
+        "local value = redis.call( 'get', KEYS[ 1 ] ); "\
+        "if ( not value ) then "\
+          "result = true; "\
+        "elseif value == ARGV[ 1 ] then "\
+          "redis.call( 'del', KEYS[ 1 ] ); "\
+          "result = true; "\
+        "else "\
+          "result = false; "\
+        "end; " \
+        "return result",
+
+      write_if_greater_than: 
+        "local value = redis.call( 'get', KEYS[ 1 ] ); "\
+        "if ( not value ) or ( ARGV[ 1 ] > value ) then "\
+          "redis.call( 'set', KEYS[ 1 ], ARGV[ 1 ] ); "\
+          "return true; "\
+        "else "\
+          "return false;"\
+        "end",
+
+      write_if_greater_than_or_equal_to: 
+        "local value = redis.call( 'get', KEYS[ 1 ] ); "\
+        "if ( not value ) or ( ARGV[ 1 ] >= value ) then "\
+          "redis.call( 'set', KEYS[ 1 ], ARGV[ 1 ] ); "\
+          "return true; "\
+        "else "\
+          "return false;"\
+        "end",
+
+      write_if_equal_to: 
+        "local value = redis.call( 'get', KEYS[ 1 ] ); "\
+        "if ( not value ) or ( ARGV[ 1 ] == value ) then "\
+          "redis.call( 'set', KEYS[ 1 ], ARGV[ 1 ] ); "\
+          "return true; "\
+        "else "\
+          "return false;"\
+        "end",
+        
+      write_if_less_than_or_equal_to: 
+        "local value = redis.call( 'get', KEYS[ 1 ] ); "\
+        "if ( not value ) or ( ARGV[ 1 ] <= value ) then "\
+          "redis.call( 'set', KEYS[ 1 ], ARGV[ 1 ] ); "\
+          "return true; "\
+        "else "\
+          "return false;"\
+        "end",
+
+      write_if_less_than: 
+        "local value = redis.call( 'get', KEYS[ 1 ] ); "\
+        "if ( not value ) or ( ARGV[ 1 ] < value ) then "\
+          "redis.call( 'set', KEYS[ 1 ], ARGV[ 1 ] ); "\
+          "return true; "\
+        "else "\
+          "return false;"\
+        "end"
+        
+    }    
+
+  end
+end

data/lib/boxxspring/synchronization/orchestrator.rb

@@ -0,0 +1,74 @@
+require 'redis'
+
+module Boxxspring
+  module Synchronization
+
+    class Orchestrator 
+
+      include Singleton
+
+      def initialize 
+        @provider = ::Redis.new(
+          url: Synchronization.configuration.url,
+          timeout: 10.0
+        )
+        @operations = {}
+      end
+
+      def lock( key, signature, options = {} )
+        ttl = options[ :ttl ];
+        ttl = ttl * 1000 if ttl.is_a? ActiveSupport::Duration
+        self.execute_operation( :lock, [ key ], [ signature, ttl ] ) ?
+          true : false
+      end
+
+      def unlock( key, signature )
+        self.execute_operation( :unlock, [ key ], [ signature ] ) ?
+          true : false
+      end
+
+      def read( key )
+        @provider.get( key )
+      end
+
+      def write( key, value, options = {} )
+        ttl = options[ :ttl ]
+        if ttl 
+          ttl = ttl.to_i if ttl.is_a? ActiveSupport::Duration
+          ( @provider.set( key, value ) == "OK" ) && 
+          ( @provider.expire( key, ttl ) ) ? true : false
+        else
+          ( @provider.set( key, value ) == "OK" ) ? true : false
+        end
+      end
+
+      def write_if_condition( key, value, condition )
+        operation = "write_if_#{condition}"
+        operation_sha = @operations[ operation.to_sym ]
+        raise 'Synchronization: An unknown condition was requested.' \
+          if operation_sha.nil?
+        @provider.evalsha( operation_sha, [ key ], [ value ] ) ? true : false
+      end
+
+      protected; def execute_operation( operation, keys, arguments )
+        try ||= 1
+        sha = @operations[ operation ] || install_operation( operation )
+        @provider.evalsha( sha, keys, arguments ) ? true : false
+      rescue Redis::CommandError => error
+        raise error unless error.message.match( /\ANOSCRIPT/ )
+        self.install_operation( operation )
+        retry if ( try -= 1 ) >= 0
+      end
+
+      protected; def install_operation( operation )
+        @operations[ operation ] = @provider.script( 
+          :load, 
+          Operations[ operation ] 
+        )
+      end
+
+    end
+
+  end
+
+end

data/lib/boxxspring/synchronization/variable.rb

@@ -0,0 +1,26 @@
+module Boxxspring
+  module Synchronization
+
+    class Variable 
+
+      def initialize( name )
+        @orchestrator = Synchronization::Orchestrator.instance
+        @name = name
+      end
+
+      def read
+        @orchestrator.read( @name )
+      end
+
+      def write( value, options={} )
+        @orchestrator.write( @name, value, options )
+      end
+
+      def write_if_condition( value, condition )
+        @orchestrator.write_if_condition( @name, value, condition )
+      end
+
+    end
+
+  end
+end

data/lib/boxxspring/synchronization.rb

@@ -0,0 +1,17 @@
+#
+# module. Synchronization
+#
+# The synchornization module implements lock/unlock and key/value read/write 
+# operations accross multiple instances of the application.
+
+module Boxxspring
+  module Synchronization
+
+    def self.configuration( &block )
+      configuration = Synchronization::Configuration.instance
+      configuration.instance_eval( &block ) unless block.nil?
+      configuration
+    end
+
+  end
+end

data/lib/boxxspring/worker/base.rb

@@ -0,0 +1,185 @@
+module Boxxspring 
+
+  module Worker
+
+    QUEUE_MESSAGE_REQUEST_COUNT   = 10
+    QUEUE_MESSAGE_WAIT_IN_SECONDS = 4
+
+    class Base
+
+      #------------------------------------------------------------------------
+      # class attributes
+
+      class_attribute :queue_name
+      class_attribute :processor
+
+      #------------------------------------------------------------------------
+      # class methods
+
+      class << self 
+
+        public; def process( &block )
+          self.processor = block
+        end
+
+        def queue_interface
+          @queue_interface ||= Aws::SQS::Client.new
+        end
+
+        def queue_url
+          unless @queue_url.present?
+            response = self.queue_interface.create_queue( 
+              queue_name: self.full_queue_name 
+            )
+            @queue_url = response[ :queue_url ]       
+          end
+          @queue_url
+        end
+
+        protected; def full_queue_name
+          name = ( Worker.env == 'development' ) ?
+            ( ENV[ 'USER' ] || 'development' ) :
+            Worker.env 
+          name += '-' + 
+                  ( self.queue_name || 
+                    self.name.
+                      underscore.
+                      gsub( /[\/]/, '-' ).
+                      gsub( /_worker\Z/, '' ) )
+        end
+
+      end
+
+      #------------------------------------------------------------------------
+      # operations
+
+      def process 
+        messages = self.receive_messages() || [] 
+        messages.each do | message |
+          if message.present?
+            payload = self.payload_from_message( message )
+            if payload.present?
+              begin
+                result = self.process_payload( payload )
+                # note: if an exception is raised the message will be deleted
+                self.delete_message( message ) unless result == false
+              rescue StandardError => error
+                self.logger.error(
+                  "The #{ self.human_name } worker failed to process the " + 
+                  "payload. "
+                )
+                self.logger.error( error.message )
+                self.logger.error( error.backtrace.join( "\n" ) )
+              end
+            else
+              # note: messages with invalid payloads are deleted
+              self.delete_message( message )
+              self.logger.error(
+                "The #{ self.human_name } worker received an invalid payload."
+              )
+            end
+          end
+        end
+      end
+
+      protected; def logger
+        @logger ||= Boxxspring::Worker.configuration.logger
+      end
+
+      #------------------------------------------------------------------------
+      # implementation
+
+      protected; def receive_messages
+        messages = nil
+        begin
+          response = self.class.queue_interface.receive_message( 
+            queue_url: self.class.queue_url,
+            max_number_of_messages: QUEUE_MESSAGE_REQUEST_COUNT,
+            wait_time_seconds: QUEUE_MESSAGE_WAIT_IN_SECONDS 
+          )
+          messages = response[ :messages ]
+        rescue StandardError => error
+          raise RuntimeError.new( 
+            "The #{ self.human_name } worker is unable to receive a message " +
+            "from the queue. #{error.message}."
+          )
+        end
+        messages
+      end
+
+      protected; def delete_message( message )
+        begin
+          self.class.queue_interface.delete_message( 
+            queue_url: self.class.queue_url,
+            receipt_handle: message[ :receipt_handle ]
+          )
+        rescue StandardError => error
+          raise RuntimeError.new( 
+            "The #{ self.human_name } worker is unable to delete the " + 
+            "message from the queue. #{error.message}."
+          )
+        end
+        message
+      end
+
+      protected; def payload_from_message( message )
+        payload = message.body
+        if ( payload.present? )
+          payload = JSON.parse( payload ) rescue payload 
+          if ( payload.is_a?( Hash ) && 
+               payload.include?( 'Type' ) && 
+               payload[ 'Type' ] == 'Notification' )
+            payload = payload[ 'Message' ]
+            payload = payload.present? ? 
+              ( JSON.parse( payload ) rescue payload ) : 
+              payload
+          end 
+        end
+        payload
+      end
+
+      protected; def process_payload( payload )
+        if self.class.processor.present? 
+          self.class.processor.call( payload )
+        else
+          raise RuntimeError.new( 
+            "The worker lacks a processor"
+          )
+        end
+      end
+
+      protected; def delegate_payload( queue_name, payload )
+        queue_name_prefix = ( Worker.env == 'development' ) ?
+          ( ENV[ 'USER' ] || 'development' ) : Worker.env 
+       queue_name = queue_name_prefix + '-' + queue_name
+        begin
+          response = self.class.queue_interface.create_queue( 
+            queue_name: queue_name 
+          )
+          queue_url = response[ :queue_url ]       
+          if queue_url.present?
+            self.class.queue_interface.send_message(
+              queue_url: queue_url,
+              message_body: payload.to_json
+            )
+          end
+        rescue StandardError => error
+          raise RuntimeError.new( 
+            "The #{ self.human_name } worker was unable to delegate the " + 
+            "payload to the queue name '#{ queue_name }'. #{error.message}."
+          )
+        end
+      end
+
+      protected; def human_name
+        self.class.name.  
+          underscore.
+          gsub( /[\/]/, ' ' ).
+          gsub( /_worker\Z/, '' )
+      end
+
+    end
+
+  end
+
+end

data/lib/boxxspring/worker/configuration.rb

@@ -0,0 +1,41 @@
+require 'singleton'
+
+module Boxxspring
+
+  module Worker
+
+    def self.configuration( &block )
+      Configuration.instance().instance_eval( &block ) unless block.nil?
+      Configuration.instance()
+    end
+
+    def self.env 
+      self.configuration.env
+    end
+
+    class Configuration < Abstract
+
+      include Singleton
+
+      def initialize
+        super( { 
+          env: ENV[ 'WORKERS_ENV' ] || 'development',
+          logger: Logger.new( STDOUT )
+        } )  
+      end
+
+      def self.reloadable?
+        false
+      end
+
+      def from_hash( configuration )
+        configuration.each_pair do | name, value |
+          self.send( "@#{name}", value )
+        end
+      end  
+
+    end
+
+  end
+
+end

data/lib/boxxspring/worker/task_base.rb

@@ -0,0 +1,151 @@
+module Boxxspring
+
+  module Worker
+
+    class TaskBase < Base
+
+      #------------------------------------------------------------------------
+      # class attributes
+
+      class_attribute :task_type_name
+      class_attribute :task_state
+
+      #------------------------------------------------------------------------
+      # operations
+
+      protected; def process_task( task )
+        if self.class.processor.present? 
+          self.class.processor.call( task )
+        else
+          raise RuntimeError.new( 
+            "The #{self.human_name} worker lacks a task processor"
+          )
+        end
+      end
+
+      #------------------------------------------------------------------------
+      # implementation
+
+      protected; def process_payload( payload )
+
+        result = true
+        type_names = self.task_type_name.blank? ? 
+          nil : 
+          [ self.task_type_name ].flatten
+        states = self.task_state.blank? ?
+          nil :
+          [ self.task_state ].flatten
+
+        tasks = payload[ 'tasks' ]
+        if ( tasks.present? && tasks.respond_to?( :each ) ) 
+          tasks.each do | task |
+            task_id = task[ 'id' ]
+            if ( type_names.blank? || type_names.include?( task[ 'type_name' ] ) )
+              task = task_read( task[ 'property_id' ], task_id )
+              if task.is_a?( Boxxspring::Task )
+                if ( states.blank? || states.include?( task.state ) )
+                  self.logger.info(  
+                    "The task (id: #{task.id}) processing has started."
+                  )
+                  begin
+                    result = self.process_task( task )
+                    message = "The task (id: #{task.id}) processing has ended"
+                    message += " and the message has been retained." if result == false
+                    self.logger.info(  
+                      message
+                    )
+                  rescue SignalException, StandardError => error
+                    if error.is_a?( SignalException )
+                      task_state = 'idle'
+                      task_message = "The task (id: #{task.id}) has restarted."
+                    else
+                      task_state = 'failed'
+                      task_message = "The task (id: #{task.id}) processing has failed."
+                    end
+                    task = task_write_state(task,
+                                            task_state,
+                                            task_message)
+                    self.logger.error( error.message )
+                    self.logger.error( error.backtrace.join( "\n" ) )
+                    raise error if error.is_a?( SignalException )
+                  end
+                end
+              elsif task.is_a?(Array) &&
+                    task.first.is_a?(Boxxspring::ForbiddenError)
+                self.logger.error(task.first.message)
+              else
+                self.logger.error(
+                  "The #{self.human_name} worker is unable to retrieve the " +
+                  "task with the id #{task_id}."
+                )
+              end
+            end
+          end
+        end
+
+        result
+      
+      end
+
+      protected; def task_read( property_id, task_id )
+        # why did this not work?
+        # self.task_operation( property_id ).where( id: task_id ).read
+        Boxxspring::Operation.new( 
+          "/properties/#{property_id}/tasks/#{task_id}",
+          Worker.configuration.api_credentials.to_hash
+        ).read      
+      end
+
+      protected; def task_write( task )
+        self.task_operation( task.property_id ).write( 'tasks', task ).first
+      end
+
+      protected; def task_write_state( task, state, message )
+        self.logger.send( ( state == 'failed' ? 'error' : 'info' ), message ) \
+          unless message.blank?
+        task.state = state
+        task.message = message
+        self.task_write( task )
+      end
+
+      protected; def task_operation( property_id )
+        Boxxspring::Operation.new( 
+          "/properties/#{ property_id }/tasks",
+          Worker.configuration.api_credentials.to_hash
+        )
+      end
+
+      protected; def task_property_read( task, include = nil )
+        operation = Boxxspring::Operation.new( 
+          "/properties/#{ task.property_id }", 
+          Worker.configuration.api_credentials.to_hash
+        )
+        operation = operation.include( include ) \
+          unless ( include.blank? ) 
+        operation.read
+      end
+
+      protected; def task_delegate( queue_name, task )
+        serializer = Boxxspring::Serializer.new( task )
+        payload = serializer.serialize( 'tasks' )
+        payload.merge!( { 
+          '$this' => { 
+            'type_name' => 'tasks', 
+            'unlimited_count' => 1
+          }
+        } )
+        self.delegate_payload( queue_name, payload )
+      end
+
+      protected; def operation(endpoint)
+        Boxxspring::Operation.new(
+          endpoint,
+          Boxxspring::Worker.configuration.api_credentials.to_hash
+        )
+      end
+
+    end
+
+  end
+
+end

data/lib/boxxspring-worker-version.rb

@@ -0,0 +1,5 @@
+module Boxxspring
+  module Worker
+    VERSION = '1.1.4'
+  end
+end

data/lib/boxxspring-worker.rb

@@ -0,0 +1,15 @@
+require 'aws-sdk'
+require 'active_support/all'
+
+$LOAD_PATH.unshift( File.expand_path( '..', File.dirname( __FILE__ ) ) )
+require 'lib/boxxspring/abstract'
+require 'lib/boxxspring/journal'
+require 'lib/boxxspring/worker/configuration'
+require 'lib/boxxspring/worker/base'
+require 'lib/boxxspring/worker/task_base'
+require 'lib/boxxspring/synchronization/configuration'
+require 'lib/boxxspring/synchronization'
+require 'lib/boxxspring/synchronization/operations'
+require 'lib/boxxspring/synchronization/orchestrator'
+require 'lib/boxxspring/synchronization/mutex'
+require 'lib/boxxspring/synchronization/variable'

data/lib/tasks/workers.rake

@@ -0,0 +1,38 @@
+namespace :worker do
+
+  descendants = Boxxspring::Worker::Base.descendants
+
+  # remove base class workers
+  descendants.delete( Boxxspring::Worker::TaskBase )
+
+  descendants.each do | worker_class |
+
+    worker_name = worker_class.
+                    name.
+                    underscore.
+                    gsub( /[\/]/, '-' ). 
+                    gsub( /_worker\Z/, '' )
+
+    desc "#{worker_name.humanize.downcase} worker."
+    task worker_name.to_sym do
+      spinner = %w{| / - \\}
+      worker = worker_class.new
+      print 'working...  ' 
+      Boxxspring::Worker.configuration.logger.info(
+        "The #{worker_name.humanize.downcase} worker has started." 
+      )
+      begin
+        loop do 
+          print "\b" + spinner.rotate!.first
+          worker.process
+        end
+      rescue SystemExit, Interrupt
+        Boxxspring::Worker.configuration.logger.info(
+          "The #{worker_name.humanize.downcase} worker has stopped." 
+        )
+        puts 'stopped'
+        exit 130
+      end 
+    end
+  end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: boxxspring-workers
+version: !ruby/object:Gem::Version
+  version: 1.1.4
+platform: ruby
+authors:
+- Kristoph Cichocki-Romanov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: boxxspring
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.1
+- !ruby/object:Gem::Dependency
+  name: remote_syslog_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: The boxxspring workers gem is implements the framework used to construct
+  boxxspring workers.
+email: kristoph@bedrocket.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/boxxspring-worker-version.rb
+- lib/boxxspring-worker.rb
+- lib/boxxspring/abstract.rb
+- lib/boxxspring/journal.rb
+- lib/boxxspring/synchronization.rb
+- lib/boxxspring/synchronization/configuration.rb
+- lib/boxxspring/synchronization/mutex.rb
+- lib/boxxspring/synchronization/operations.rb
+- lib/boxxspring/synchronization/orchestrator.rb
+- lib/boxxspring/synchronization/variable.rb
+- lib/boxxspring/worker/base.rb
+- lib/boxxspring/worker/configuration.rb
+- lib/boxxspring/worker/task_base.rb
+- lib/tasks/workers.rake
+homepage: http://bedrocket.com
+licenses:
+- MS-RL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Bedrocket Media Ventrures Boxxspring Worker framework.
+test_files: []