ntl-orchestra 0.9.2 → 0.9.3

data/lib/orchestra/dsl/operations.rb

@@ -5,61 +5,61 @@ module Orchestra
         attr_writer :command, :result
 
         def initialize
-          @nodes = {}
+          @steps = {}
         end
 
         def build_operation
           raise ArgumentError, "Must supply a result" if @result.nil?
-          raise ArgumentError, "Must supply at least one node" if @nodes.empty?
+          raise ArgumentError, "Must supply at least one step" if @steps.empty?
           Operation.new(
             :command => @command,
-            :nodes   => @nodes,
+            :steps   => @steps,
             :result  => @result,
           )
         end
 
-        def add_node name_or_object, args = {}, &block
-          name, node = case name_or_object
-          when nil then build_anonymous_node block
-          when Operation then build_embedded_operation_node name_or_object
-          when ::String, ::Symbol then build_inline_node name_or_object, block
-          else build_object_node name_or_object, args
+        def add_step name_or_object, args = {}, &block
+          name, step = case name_or_object
+          when nil then build_anonymous_step block
+          when Operation then build_embedded_operation_step name_or_object
+          when ::String, ::Symbol then build_inline_step name_or_object, block
+          else build_object_step name_or_object, args
           end
-          node.provisions << name.to_sym if node.provisions.empty?
-          set_node name.to_sym, node
+          step.provisions << name.to_sym if step.provisions.empty?
+          set_step name.to_sym, step
         end
 
-        def set_node name, node
-          if @nodes.has_key? name
-            raise ArgumentError, "There are duplicate nodes named #{name.inspect}"
+        def set_step name, step
+          if @steps.has_key? name
+            raise ArgumentError, "There are duplicate steps named #{name.inspect}"
           end
-          @nodes[name] = node
-          node.freeze
+          @steps[name] = step
+          step.freeze
         end
 
-        def build_anonymous_node block
-          node = Node::InlineNode.build &block
-          unless node.provisions.size == 1
-            raise ArgumentError, "Could not infer name for node from a provision"
+        def build_anonymous_step block
+          step = Step::InlineStep.build &block
+          unless step.provisions.size == 1
+            raise ArgumentError, "Could not infer name for step from a provision"
           end
-          name = node.provisions.fetch 0
-          [name, node]
+          name = step.provisions.fetch 0
+          [name, step]
         end
 
-        def build_embedded_operation_node operation
+        def build_embedded_operation_step operation
           name = object_name operation
           [name || operation.result, operation]
         end
 
-        def build_inline_node name, block
-          node = Node::InlineNode.build &block
-          [name, node]
+        def build_inline_step name, block
+          step = Step::InlineStep.build &block
+          [name, step]
         end
 
-        def build_object_node object, args
+        def build_object_step object, args
           name = object_name object
-          node = ObjectAdapter.build_node object, args
-          [name, node]
+          step = ObjectAdapter.build_step object, args
+          [name, step]
         end
 
         private
@@ -75,14 +75,14 @@ module Orchestra
           context.instance_eval &block
         end
 
-        attr :nodes
+        attr :steps
 
         def initialize builder
           @builder = builder
         end
 
-        def node *args, &block
-          @builder.add_node *args, &block
+        def step *args, &block
+          @builder.add_step *args, &block
           nil
         end
 
@@ -92,13 +92,13 @@ module Orchestra
         end
 
         def result name = nil, &block
-          node = @builder.add_node name, &block
-          name ||= node.provisions.fetch 0
+          step = @builder.add_step name, &block
+          name ||= step.provisions.fetch 0
           self.result = name
         end
 
         def finally name = :__finally__, &block
-          @builder.add_node name, &block
+          @builder.add_step name, &block
           @builder.command = true
           self.result = name
         end

data/lib/orchestra/dsl/{nodes.rb → steps.rb}

@@ -1,8 +1,8 @@
 module Orchestra
   module DSL
-    module Nodes
+    module Steps
       class Builder
-        attr_accessor :collection, :perform_block
+        attr_accessor :collection, :execute_block
 
         attr :defaults, :dependencies, :provisions
 
@@ -12,12 +12,12 @@ module Orchestra
           @provisions = []
         end
 
-        def build_node
-          Node::InlineNode.new(
+        def build_step
+          Step::InlineStep.new(
             :collection    => collection,
             :defaults      => defaults,
             :dependencies  => dependencies,
-            :perform_block => perform_block,
+            :execute_block => execute_block,
             :provides      => provisions,
           )
         end
@@ -29,8 +29,6 @@ module Orchestra
           context.instance_eval &block
         end
 
-        attr :collection, :perform
-
         def initialize builder
           @builder = builder
         end
@@ -58,8 +56,8 @@ module Orchestra
           @builder.provisions.concat provisions
         end
 
-        def perform &block
-          @builder.perform_block = block
+        def execute &block
+          @builder.execute_block = block
         end
 
         def iterates_over dependency

data/lib/orchestra/execution.rb

@@ -0,0 +1,158 @@
+module Orchestra
+  module Execution
+    extend self
+
+    def start_operation *args
+      Operation.new *args
+    end
+
+    def execute_step step, input
+      operation_execution = Operation.new Conductor.new, {}, input
+      Step.execute step, 'anonymous', operation_execution
+    end
+
+    class Operation
+      include Observable
+      extend Forwardable
+
+      def_delegators :@run_list, :provisions, :dependencies,
+        :optional_dependencies, :required_dependencies
+
+      attr :conductor, :input, :state, :registry, :run_list
+
+      def initialize conductor, run_list, input
+        @conductor = conductor
+        @input = input.dup
+        @run_list = run_list
+        @registry = conductor.build_registry self
+        @state = registry.merge input
+      end
+
+      def execute
+        ensure_inputs_are_present!
+        run_list.each do |name, step| process name, step end
+      rescue => error
+        publish :error_raised, error
+        raise error
+      end
+
+      def process name, step
+        output = Step.execute step, name, self
+        state.merge! output
+      end
+
+      def ensure_inputs_are_present!
+        has_dep = state.method :[]
+        missing_input = required_dependencies.reject &has_dep
+        raise MissingInputError.new missing_input unless missing_input.empty?
+      end
+
+      def extract_result result
+        state.fetch result
+      end
+
+      def publish event, *payload
+        changed
+        notify_observers event, *payload
+      end
+
+      def thread_pool
+        conductor.thread_pool
+      end
+    end
+
+    class Step
+      def self.execute step, *args
+        instance = new step, *args
+        instance.execute
+      end
+
+      def self.new step, *args
+        if step.is_a? Orchestra::Operation
+          klass = EmbeddedOperation
+        else
+          klass = step.collection ? CollectionStep : self
+        end
+        instance = klass.allocate
+        instance.send :initialize, step, *args
+        instance
+      end
+
+      attr :context, :name, :operation_execution, :step
+
+      def initialize step, name, operation_execution
+        @name = name
+        @operation_execution = operation_execution
+        @step = step
+        @context = build_context
+      end
+
+      def execute
+        operation_execution.publish :step_entered, name, input
+        output = step.process invoke
+        operation_execution.publish :step_exited, name, output
+        output
+      end
+
+      def input
+        registry = operation_execution.registry
+        operation_execution.state.reject do |key, val|
+          registry[key] == val or not step.dependencies.include? key
+        end
+      end
+
+      def invoke
+        context.execute
+      end
+
+      def build_context
+        step.build_context operation_execution.state
+      end
+    end
+
+    class CollectionStep < Step
+      def invoke
+        batch, output = prepare_collection
+        jobs = enqueue_jobs batch do |result, index| output[index] = result end
+        jobs.each &:wait
+        output
+      end
+
+      def enqueue_jobs batch, &block
+        batch.map.with_index do |element, index|
+          enqueue_job element, index, &block
+        end
+      end
+
+      def enqueue_job element, index
+        operation_execution.thread_pool.enqueue do
+          result = context.execute element
+          yield [result, index]
+        end
+      end
+
+      def prepare_collection
+        batch = context.fetch_collection
+        output = [nil] * batch.size
+        [batch, output]
+      end
+    end
+
+    class EmbeddedOperation < Step
+      def invoke
+        super
+        context.state.select do |k,_| k == step.result end
+      end
+
+      def build_context
+        conductor = operation_execution.registry[:conductor]
+        copy_observers = conductor.method :copy_observers
+        step.start_execution conductor, input, &copy_observers
+      end
+
+      def input
+        operation_execution.state
+      end
+    end
+  end
+end

data/lib/orchestra/operation.rb

@@ -12,35 +12,35 @@ module Orchestra
 
     extend Forwardable
 
-    def_delegators :@default_run_list, :node_names, :provisions, :dependencies,
+    def_delegators :@default_run_list, :provisions, :dependencies,
       :optional_dependencies, :required_dependencies
 
-    attr :registry, :result, :nodes
+    attr :registry, :result, :steps
 
     def initialize args = {}
-      @result, @command, @nodes = Util.extract_key_args args,
-        :result, :command => false, :nodes => {}
-      @default_run_list = RunList.build nodes, result, []
+      @result, @command, @steps = Util.extract_key_args args,
+        :result, :command => false, :steps => {}
+      @default_run_list = RunList.build steps, result, []
     end
 
     def process output
       output.select do |key, _| key = result end
     end
 
-    def start_performance *args
+    def start_execution *args
       conductor, input = extract_args args
-      run_list = RunList.build nodes, result, input.keys
-      performance = Performance.new conductor, run_list, input
-      yield performance if block_given?
-      performance.publish :operation_entered, name, input
-      performance
+      run_list = RunList.build steps, result, input.keys
+      execution = Execution.start_operation conductor, run_list, input
+      yield execution if block_given?
+      execution.publish :operation_entered, name, input
+      execution
     end
 
-    def perform *args, &block
-      performance = start_performance *args, &block
-      performance.perform
-      output = performance.extract_result result
-      performance.publish :operation_exited, name, output
+    def execute *args, &block
+      execution = start_execution *args, &block
+      execution.execute
+      output = execution.extract_result result
+      execution.publish :operation_exited, name, output
       @command ? nil : output
     end
 

data/lib/orchestra/recording/playback.rb

@@ -0,0 +1,47 @@
+module Orchestra
+  class Recording
+    class Playback < BasicObject
+      attr :mocks
+
+      def initialize mocks
+        @mocks = mocks
+      end
+
+      def respond_to? meth
+        mocks.has_key? meth
+      end
+
+      def self.build service_recording
+        factory = Factory.new
+        factory.build service_recording
+      end
+
+      class Factory
+        attr :klass, :mocks
+
+        def initialize
+          @klass = Class.new Playback
+          @mocks = Hash.new do |hsh, meth| hsh[meth] = {} end
+        end
+
+        def build service_recording
+          record = method :<<
+          service_recording.each &record
+          klass.new mocks
+        end
+
+        def << record
+          method = record[:method].to_sym
+          unless klass.instance_methods.include? method
+            klass.send :define_method, method do |*args| mocks[method][args] end
+          end
+          mocks[method][record[:input]] = record[:output]
+        end
+
+        def singleton
+          singleton = class << instance ; self end
+        end
+      end
+    end
+  end
+end

data/lib/orchestra/recording.rb

@@ -27,57 +27,17 @@ module Orchestra
       }
     end
 
+    def to_json generator
+      generator.generate to_h
+    end
+
     def self.replay operation, input, service_recordings
       replayed_services = {}
       service_recordings.each do |svc, service_recording|
         replayed_services[svc] = Playback.build service_recording
       end
       conductor = Conductor.new replayed_services
-      conductor.perform operation, input
-    end
-
-    class Playback < BasicObject
-      attr :mocks
-
-      def initialize mocks
-        @mocks = mocks
-      end
-
-      def respond_to? meth
-        mocks.has_key? meth
-      end
-
-      def self.build service_recording
-        factory = Factory.new
-        factory.build service_recording
-      end
-
-      class Factory
-        attr :klass, :mocks
-
-        def initialize
-          @klass = Class.new Playback
-          @mocks = Hash.new do |hsh, meth| hsh[meth] = {} end
-        end
-
-        def build service_recording
-          record = method :<<
-          service_recording.each &record
-          klass.new mocks
-        end
-
-        def << record
-          method = record[:method].to_sym
-          unless klass.instance_methods.include? method
-            klass.send :define_method, method do |*args| mocks[method][args] end
-          end
-          mocks[method][record[:input]] = record[:output]
-        end
-
-        def singleton
-          singleton = class << instance ; self end
-        end
-      end
+      conductor.execute operation, input
     end
   end
 end