swarm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ac77d75a6ccdfd4d0c9109f0cc85e95b17f78531
+  data.tar.gz: 7ec1237fac5184c8f72fb80c53d65c66283378ff
+SHA512:
+  metadata.gz: a9d1c231467a7d4635abc5d6534c7792a886d7d05813dbe2e0cc6993c11802eef6e8059d807e8601721db5984b6c18dd76345191c52f01320433f9816a92e025
+  data.tar.gz: aa831187f5085cad88a575d4ca4ef1259386112aa46906d09b6f1501fa579c6bfad34674d1211904cc386f28263c1673def8d8afa5282f76fb8602bdc70431bc

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+2.1.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in swarm.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Ravi Gadad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Swarm
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/swarm`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'swarm'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install swarm
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/swarm/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec, :tag) do |t, task_args|
+  if task_args[:tag]
+    t.rspec_opts = "--tag #{task_args[:tag]}"
+  end
+end
+
+task :default => [:spec]
+
+Rake::TaskManager.record_task_metadata = true

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "swarm"
+
+# 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

data/bin/setup

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

data/lib/swarm/engine/base/job.rb

@@ -0,0 +1,31 @@
+module Swarm
+  module Engine
+    class Job
+      class AlreadyReservedError < StandardError; end
+
+      def to_h
+        raise "Not implemented yet!"
+      end
+
+      def reserved?
+        raise "Not implemented yet!"
+      end
+
+      def bury
+        raise "Not implemented yet!"
+      end
+
+      def release
+        raise "Not implemented yet!"
+      end
+
+      def delete
+        raise "Not implemented yet!"
+      end
+
+      def exists?
+        raise "Not implemented yet!"
+      end
+    end
+  end
+end

data/lib/swarm/engine/base/queue.rb

@@ -0,0 +1,60 @@
+require_relative "job"
+
+module Swarm
+  module Engine
+    class Queue
+      class JobReservationFailed < StandardError; end
+      class JobNotFoundError < StandardError; end
+
+      attr_reader :name
+
+      def initialize(name:)
+        @name = name
+      end
+
+      def prepare_for_work(worker)
+        raise "Not implemented yet!"
+      end
+
+      def add_job(data)
+        raise "Not implemented yet!"
+      end
+
+      def reserve_job(worker)
+        raise "Not implemented yet!"
+      end
+
+      def delete_job(job)
+        job.delete
+      end
+
+      def bury_job(job)
+        job.bury if job.exists?
+      end
+
+      def clean_up_job(job)
+        job.bury if job.exists? && job.reserved?
+      end
+
+      def remove_worker(worker, stop_job:)
+        if worker_count <= 1
+          stop_job.delete
+        else
+          stop_job.release
+        end
+      end
+
+      def clear
+        raise "Not implemented yet!"
+      end
+
+      def idle?
+        raise "Not implemented yet!"
+      end
+
+      def worker_count
+        raise "Not implemented yet!"
+      end
+    end
+  end
+end

data/lib/swarm/engine/volatile/job.rb

@@ -0,0 +1,57 @@
+module Swarm
+  module Engine
+    module Volatile
+      class Job < Swarm::Engine::Job
+        attr_reader :queue, :data, :id, :reserved_by, :buried
+
+        def initialize(queue:, data:)
+          @queue = queue
+          @data = data
+          @id = SecureRandom.uuid
+          @reserved_by = nil
+          @buried = false
+        end
+
+        def to_h
+          Swarm::Support.symbolize_keys(data)
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.id == id
+        end
+
+        def reserve!(worker)
+          if reserved_by && reserved_by != worker
+            raise AlreadyReservedError
+          end
+          @reserved_by = worker
+        end
+
+        def reserved?
+          !reserved_by.nil?
+        end
+
+        def bury
+          @buried = true
+        end
+
+        def available?
+          !reserved? && !buried
+        end
+
+        def release
+          @reserved_by = nil
+        end
+
+        def delete
+          queue.delete_job(self)
+        end
+
+        def exists?
+          queue.has_job?(self)
+        end
+      end
+    end
+  end
+end

data/lib/swarm/engine/volatile/queue.rb

@@ -0,0 +1,85 @@
+require_relative "job"
+
+module Swarm
+  module Engine
+    module Volatile
+      class Queue < Swarm::Engine::Queue
+        Tube = Struct.new(:jobs, :workers)
+
+        extend Forwardable
+        def_delegators :tube, :jobs, :workers
+
+        attr_reader :tube, :name
+
+        class << self
+          def tubes
+            @tubes ||= {}
+          end
+
+          def get_tube(name)
+            tubes[name] ||= Tube.new([], [])
+          end
+        end
+
+        def initialize(name:)
+          @name = name
+          @tube = self.class.get_tube(name)
+        end
+
+        def prepare_for_work(worker)
+          add_worker(worker) unless workers.include?(worker)
+          self
+        end
+
+        def add_job(data)
+          new_job = Job.new(queue: self, data: data)
+          jobs << new_job
+          new_job
+        end
+
+        def wait_for_job
+          delay_time = 0
+          until jobs.count > 0
+            delay_time += 0.01 unless delay_time > 1.0
+            sleep(delay_time)
+          end
+        end
+
+        def reserve_job(worker)
+          wait_for_job
+          index = jobs.index { |job| job.available? }
+          raise JobNotFoundError unless index
+          job = jobs[index]
+          job.reserve!(worker)
+          job
+        rescue JobNotFoundError, Job::AlreadyReservedError
+          raise JobReservationFailed
+        end
+
+        def delete_job(job_to_delete)
+          jobs.delete_if { |job| job == job_to_delete }
+        end
+
+        def has_job?(job_to_find)
+          jobs.any? { |job| job == job_to_find }
+        end
+
+        def clear
+          tube.jobs = []
+        end
+
+        def worker_count
+          workers.count
+        end
+
+        def add_worker(worker)
+          workers << worker
+        end
+
+        def idle?
+          jobs.empty?
+        end
+      end
+    end
+  end
+end

data/lib/swarm/engine/worker/command.rb

@@ -0,0 +1,61 @@
+module Swarm
+  module Engine
+    class Worker
+      class Command
+        class MissingObjectError < StandardError; end
+
+        class << self
+          def from_job(job, hive: Hive.default)
+            data = job.to_h
+            action, metadata = data.values_at(:action, :metadata)
+            new(action: action, metadata: metadata, hive: hive)
+          end
+        end
+
+        attr_reader :action, :metadata, :hive
+
+        def initialize(hive: Hive.default, action:, metadata:)
+          @hive = hive
+          @action = action
+          @metadata = Swarm::Support.symbolize_keys(metadata || {})
+        end
+
+        def run!
+          raise MissingObjectError if object.nil?
+          observers.each(&:before_action)
+          object.send("_#{action}")
+          observers.each(&:after_action)
+        end
+
+        def observers
+          @observers ||= hive.registered_observers.map { |observer_class|
+            observer_class.new(self)
+          }
+        end
+
+        def object
+          @object ||= begin
+            return nil unless metadata[:type] && metadata[:id]
+            hive.fetch(metadata[:type], metadata[:id])
+          end
+        end
+
+        def stop?
+          action == "stop_worker"
+        end
+
+        def to_hash
+          {
+            action: action,
+            metadata: metadata,
+            object: object
+          }
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && other.to_hash == to_hash
+        end
+      end
+    end
+  end
+end

data/lib/swarm/engine/worker.rb

@@ -0,0 +1,73 @@
+require_relative "worker/command"
+
+module Swarm
+  module Engine
+    class Worker
+      class NotRunningError < StandardError; end
+
+      attr_reader :hive, :queue
+
+      def initialize(hive: Hive.default)
+        @hive = hive
+      end
+
+      def setup
+        @queue = hive.work_queue.prepare_for_work(self)
+      end
+
+      def teardown
+        @queue = nil
+      end
+
+      def run!
+        setup
+        @running = true
+        while running?
+          process_next_job
+        end
+        teardown
+      end
+
+      def process_next_job
+        begin
+          @current_job = queue.reserve_job(self)
+          @working = true
+          work_on(@current_job)
+          queue.delete_job(@current_job) if @current_job
+        rescue Queue::JobReservationFailed
+          retry
+        rescue StandardError
+          queue.bury_job(@current_job) if @current_job
+        ensure
+          queue.clean_up_job(@current_job) if @current_job
+          @working = false
+          @current_job = nil
+        end
+      end
+
+      def working?
+        @working == true
+      end
+
+      def running?
+        @running == true && queue
+      end
+
+      def stop!
+        @running = false
+        @current_job = nil
+      end
+
+      def work_on(queue_job)
+        raise NotRunningError unless running?
+        command = Command.from_job(queue_job, hive: hive)
+        if command.stop?
+          queue.remove_worker(self, :stop_job => queue_job)
+          stop!
+        else
+          command.run!
+        end
+      end
+    end
+  end
+end

data/lib/swarm/evaluation/expression_evaluator.rb

@@ -0,0 +1,40 @@
+require_relative "workitem_context"
+
+module Swarm
+  class ExpressionEvaluator
+    extend Forwardable
+
+    attr_reader :expression
+    def_delegators :expression, :workitem, :arguments
+
+    def initialize(expression)
+      @expression = expression
+    end
+
+    def workitem_context
+      @workitem_context ||= WorkitemContext.new(workitem)
+    end
+
+    def eval(string)
+      workitem_context.instance_eval(string)
+    end
+
+    def all_conditions_met?
+      conditions.all? { |type, exp|
+        check_condition(type, exp)
+      }
+    end
+
+    def check_condition(type, exp)
+      unless ["if", "unless"].include?(type)
+        raise ArgumentError.new("Not a conditional")
+      end
+      result = eval(exp)
+      type == "if" ? result : !result
+    end
+
+    def conditions
+      Swarm::Support.slice(arguments, "if", "unless")
+    end
+  end
+end

data/lib/swarm/evaluation/workitem_context.rb

@@ -0,0 +1,17 @@
+module Swarm
+  class WorkitemContext
+    attr_reader :workitem
+
+    def initialize(workitem)
+      @workitem = Support.symbolize_keys(workitem)
+    end
+
+    def method_missing(method, *args)
+      if workitem.has_key?(method)
+        workitem.fetch(method, nil)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/swarm/expression.rb

@@ -0,0 +1,107 @@
+require_relative "evaluation/expression_evaluator"
+
+module Swarm
+  class Expression < HiveDweller
+    class << self
+      def storage_type
+        "Expression"
+      end
+
+      def inherited(subclass)
+        super
+        subclass.set_columns *columns
+      end
+    end
+
+    set_columns :parent_id, :position, :workitem, :child_ids, :milestones, :process_id
+    many_to_one :process, :class_name => "Swarm::Process"
+
+    def branch_position
+      @branch_position ||= position.last
+    end
+
+    def evaluator
+      @evaluator ||= Swarm::ExpressionEvaluator.new(self)
+    end
+
+    def meets_conditions?
+      evaluator.all_conditions_met?
+    end
+
+    def root?
+      process_id == parent_id
+    end
+
+    def parent
+      if root?
+        process
+      else
+        Expression.fetch(parent_id, hive: hive)
+      end
+    end
+
+    def apply
+      hive.queue('apply', self)
+    end
+
+    def reply
+      save
+      hive.queue('reply', self)
+    end
+
+    def _apply
+      set_milestone("applied_at")
+      meets_conditions? ? work : reply
+      save
+    end
+
+    def _reply
+      set_milestone("replied_at")
+      save
+      reply_to_parent
+    end
+
+    def reply_to_parent
+      parent.move_on_from(self)
+    end
+
+    def replied_at
+      get_milestone("replied_at")
+    end
+
+    def replied?
+      reload!
+      !!replied_at
+    end
+
+    def node
+      @node ||= parent.node_at_position(branch_position)
+    end
+
+    def command
+      node[0]
+    end
+
+    def arguments
+      node[1]
+    end
+
+    def tree
+      node[2]
+    end
+
+    def node_at_position(position)
+      tree[position]
+    end
+
+  private
+
+    def set_milestone(name, at: Time.now.to_i)
+      self.milestones = (milestones || {}).merge(name => at)
+    end
+
+    def get_milestone(name)
+      (milestones || {})[name]
+    end
+  end
+end

data/lib/swarm/expressions/activity_expression.rb

@@ -0,0 +1,11 @@
+module Swarm
+  class ActivityExpression < Expression
+    def work
+      if command == "trace"
+        TraceParticipant.new(hive: hive, expression: self).work
+      else
+        StorageParticipant.new(hive: hive, expression: self).work
+      end
+    end
+  end
+end