aws-flow 1.0.0

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://www.rubygems.org"
+
+gemspec
+
+group :test do
+  gem "rspec", "1.3.0"
+  gem "rake"
+end

data/LICENSE.TXT

@@ -0,0 +1,15 @@
+# @markup markdown
+# @title AWS Flow Framework for Ruby License
+
+Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"). You
+may not use this file except in compliance with the License. A copy of
+the License is located at:
+
+* <http://aws.amazon.com/apache2.0/>
+
+or in the "LICENSE" file accompanying this file. This file is
+distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific
+language governing permissions and limitations under the License.

data/NOTICE.TXT

@@ -0,0 +1,14 @@
+AWS Flow for Ruby
+Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+This product includes software developed by
+Amazon Technologies, Inc (http://www.amazon.com/).
+
+**********************
+THIRD PARTY COMPONENTS
+**********************
+This software includes third party software subject to the following copyrights:
+- XML parsing and utility functions from JetS3t - Copyright 2006-2009 James Murty.
+- JSON parsing and utility functions from JSON.org - Copyright 2002 JSON.org.
+
+The licenses for these third party components are included in LICENSE.txt

data/Rakefile

@@ -0,0 +1,39 @@
+##
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License").
+# You may not use this file except in compliance with the License.
+# A copy of the License is located at
+#
+#  http://aws.amazon.com/apache2.0
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+##
+
+require 'spec/rake/spectask'
+
+desc "Run unit tests in test/"
+Spec::Rake::SpecTask.new(:unit_tests) do |t|
+  t.libs << 'lib'
+  t.spec_opts = ['--color', '--format nested']
+  t.spec_files = FileList['test/**/*.rb']
+  t.spec_files.delete_if {|x| x =~ /.*factories.rb/ || x =~ /.*spec_helper.rb/ || x =~ /.*integration.*/}
+  t.spec_files.unshift("test/aws/factories.rb")
+  t.spec_files.unshift("test/aws/spec_helper.rb")
+end
+task :test => :unit_tests
+
+desc "Run integration tests in test/"
+Spec::Rake::SpecTask.new do |t|
+  t.libs << 'lib'
+  #t.ruby_opts = ['-rspec/test/unit'] # Add this line in if you're using Test::Unit instead of RSpec
+  t.spec_opts = ['--color', '--format nested']
+  t.spec_files = FileList['test/**/*.rb']
+  t.spec_files.delete_if {|x| x =~ /.*factories.rb/ || x =~ /.*spec_helper.rb/}
+  t.spec_files.unshift("test/aws/factories.rb")
+  t.spec_files.unshift("test/aws/spec_helper.rb")
+end
+task :integration_tests => :spec

data/aws-flow-core/Gemfile

@@ -0,0 +1,9 @@
+source "http://www.rubygems.org"
+
+gemspec
+
+group :test do
+  gem "rspec", "1.3.0"
+  gem "factory_girl"
+  gem "rake"
+end

data/aws-flow-core/LICENSE.TXT

@@ -0,0 +1,15 @@
+# @markup markdown
+# @title AWS Flow Framework for Ruby License
+
+Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"). You
+may not use this file except in compliance with the License. A copy of
+the License is located at:
+
+* <http://aws.amazon.com/apache2.0/>
+
+or in the "LICENSE" file accompanying this file. This file is
+distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific
+language governing permissions and limitations under the License.

data/aws-flow-core/NOTICE.TXT

@@ -0,0 +1,14 @@
+AWS Flow for Ruby
+Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+This product includes software developed by
+Amazon Technologies, Inc (http://www.amazon.com/).
+
+**********************
+THIRD PARTY COMPONENTS
+**********************
+This software includes third party software subject to the following copyrights:
+- XML parsing and utility functions from JetS3t - Copyright 2006-2009 James Murty.
+- JSON parsing and utility functions from JSON.org - Copyright 2002 JSON.org.
+
+The licenses for these third party components are included in LICENSE.txt

data/aws-flow-core/Rakefile

@@ -0,0 +1,27 @@
+##
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License").
+# You may not use this file except in compliance with the License.
+# A copy of the License is located at
+#
+#  http://aws.amazon.com/apache2.0
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+##
+
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.libs << 'lib'
+  t.spec_opts = ['--color', '--format nested']
+  t.spec_files = FileList['test/**/*.rb']
+  t.spec_files.delete_if {|x| x =~ /.*factories.rb/ || x =~ /.*spec_helper.rb/}
+  t.spec_files.unshift("test/aws/factories.rb")
+  t.spec_files.unshift("test/aws/spec_helper.rb")
+end
+
+task :test => :spec

data/aws-flow-core/aws-flow-core.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = 'aws-flow-core'
+  s.version     = '1.0.0'
+  s.date        = Time.now
+  s.summary     = "AWS Flow Core"
+  s.description = "Library to provide all the base asynchronous constructs that aws-flow uses"
+  s.authors     = "Michael Steger"
+  s.email       = ""
+  s.files       = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths << "lib/aws/"
+end

data/aws-flow-core/lib/aws/flow.rb

@@ -0,0 +1,26 @@
+##
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License").
+# You may not use this file except in compliance with the License.
+# A copy of the License is located at
+#
+#  http://aws.amazon.com/apache2.0
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+##
+
+def require_all(path)
+  glob = File.join(File.dirname(__FILE__), path, "*.rb")
+  Dir[glob].each { |f| require f}
+  Dir[glob].map { |f| File.basename(f) }
+end
+
+
+# Everything depends on fiber, so we have to require that before anything else
+require 'aws/flow/fiber'
+
+$RUBY_FLOW_FILES = require_all 'flow/'

data/aws-flow-core/lib/aws/flow/async_backtrace.rb

@@ -0,0 +1,134 @@
+##
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License").
+# You may not use this file except in compliance with the License.
+# A copy of the License is located at
+#
+#  http://aws.amazon.com/apache2.0
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+##
+
+# This file contains AsyncBacktrace, which takes care of decorating and properly filtering backtraces
+
+module AWS
+  module Flow
+    module Core
+      # @!visibility private
+      class AsyncBacktrace
+
+        # @!visibility private
+        def initialize(parent, backtrace)
+          @backtrace = AsyncBacktrace.filter(backtrace)
+          @parent = parent
+        end
+
+        # @!visibility private
+        def backtrace
+          if @parent
+            AsyncBacktrace.merge(@backtrace, @parent.backtrace)
+          else
+            @backtrace
+          end
+        end
+
+        # @!visibility private
+        class << self
+
+          # @!visibility private
+          def create(parent, frames_to_skip)
+
+            unless @disable_async_backtrace
+              b = AsyncBacktrace.caller(frames_to_skip)
+              AsyncBacktrace.new(parent, b)
+            end
+          end
+
+          # @!visibility private
+          def create_from_exception(parent, exception)
+            unless @disable_async_backtrace
+              AsyncBacktrace.new(parent, exception.backtrace);
+            end
+          end
+
+          # Remove all framework related frames after application frames. Keep framework frames before application
+          # frames.
+          #
+          # @todo
+          #   The correct implementation should not have framework frames before application frames as it is expected to
+          #   call Kernel.caller with the correct number.  But in cases when due to changes this number is not correct
+          #   the frames are kept to not create confusion.
+          #
+          def filter(backtrace)
+            if @disable_filtering
+              backtrace
+            else
+              do_filter(backtrace)
+            end
+          end
+
+          # @!visibility private
+          def merge(*backtraces)
+            result = []
+            backtraces.each do | b |
+              if b
+                result << "------ continuation ------" if result.size > 0
+                result += b
+              end
+            end
+            result
+          end
+
+          # @!visibility private
+          def disable_filtering
+            @disable_filtering = true
+          end
+
+          # @!visibility private
+          def enable_filtering
+            @disable_filtering = false
+          end
+
+          # @!visibility private
+          def disable
+            @disable_async_backtrace = true
+          end
+
+          # @!visibility private
+          def enable
+            @disable_async_backtrace = false
+          end
+
+          # @!visibility private
+          def caller(skip)
+            random_var = Kernel.caller 0
+            this_stuff =  1.upto(6).map { |x| Kernel.caller(x) }
+            other_var = Kernel.caller skip
+            Kernel.caller(@disable_filtering ? 0 : skip)
+          end
+
+          private
+
+          # @!visibility private
+          def do_filter(backtrace)
+            return nil unless backtrace
+            # keep asynchrony frames at the top of the backtrace only
+            # then cut all frames starting from asynchrony frame
+            skip_asynchrony_frames = false
+            @backtrace = backtrace.take_while do |frame|
+              if ! $RUBY_FLOW_FILES.select {|file| Regexp.new(file) =~ frame}.empty?
+                !skip_asynchrony_frames
+              else
+                skip_asynchrony_frames = true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/aws-flow-core/lib/aws/flow/async_scope.rb

@@ -0,0 +1,195 @@
+##
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License").
+# You may not use this file except in compliance with the License.
+# A copy of the License is located at
+#
+#  http://aws.amazon.com/apache2.0
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+##
+
+# This module contains the Root of the heirarchy for calls into flow, the AsyncScope
+
+module AWS
+  module Flow
+    module Core
+
+      def gate_by_version(version, method, &block)
+        if RUBY_VERSION.send(method, version)
+          block.call
+        end
+      end
+
+      # @!visibility private
+      class AsyncScope
+        attr_accessor :stackTrace, :root, :failure, :root_context
+
+        def is_complete?
+          @root_context.complete
+        end
+
+        def get_closest_containing_scope
+          @root_error_handler
+        end
+
+        def cancel(error); @root_error_handler.cancel(error); end
+
+        def initialize(&block)
+          @root_context = RootAsyncScope.new
+
+
+
+          # 1 for the function that skips frames
+          # 1 for the create function
+          # 1 for the the initialize of the backtrace
+
+          # "./lib/aws/rubyflow/asyncBacktrace.rb:75:in `caller'"
+          # "./lib/aws/rubyflow/asyncBacktrace.rb:21:in `create'"
+          # "./lib/aws/rubyflow/asyncScope.rb:18:in `initialize'"
+
+          @root_context.backtrace = AsyncBacktrace.create(nil, 3)
+          @root_error_handler = BeginRescueEnsure.new(:parent => @root_context)
+          begin
+            @root_error_handler.begin lambda { block.call if ! block.nil? }
+            @root_error_handler.rescue(Exception, lambda { |e| raise e })
+          end
+          @root_context << @root_error_handler
+        end
+
+        # Collects all the heirs of a task for use in async_stack_dump
+        def get_heirs
+          @root_error_handler.get_heirs
+        end
+
+        # Execute all queued tasks. If execution of those tasks results in addition of new tasks to the queue, execute
+        # them as well.
+        #
+        # Unless there are external dependencies or bugs in the tasks to be executed, a single call to this method
+        # performs the complete asynchronous execution.
+        #
+        # @note In the presence of external dependencies, it is expected that {AsyncScope#eventLoop} is called every
+        # time after a change in the state in a dependency can unblock asynchronous execution.
+        #
+        def eventLoop
+          #TODO Figure out when to raise Done raise "Done" if ! @root_task.alive?
+          raise IllegalStateException, "Already complete" if is_complete?
+          @root_context.eventLoop
+          # TODO Does this need to be taken care of? It's supposed to protect
+          # against people having errors that are classes, so like, passing
+          # Exception into cancel. We might want to just catch that at the
+          # entry point
+          if @root_context.failure
+            if @root_context.failure.respond_to? :message
+              failure_message = @root_context.failure.message + "\n" +
+                @root_context.failure.backtrace.join("\n")
+              raise @root_context.failure, failure_message
+            else
+              raise @root_context.failure
+            end
+          end
+
+          return is_complete?
+        end
+
+        def <<(task)
+          @root_context << task
+          task.parent = @root_context
+        end
+      end
+
+      # @!visibility private
+      class RootAsyncScope < FlowFiber
+
+        attr_accessor :backtrace, :failure, :executor, :complete
+
+        def initialize(options = {}, &block)
+          @parent = options[:parent_context]
+          @daemon = options[:daemon]
+          @context = @parent
+          @executor = AsyncEventLoop.new
+          @task_queue = []
+          @complete = false
+          @task_queue << Task.new(context, &block) if block
+        end
+
+        # The only thing that should be removed from the RootAsyncScope is the
+        # root BeginRescueEnsure, so upon removal we are complete
+        def remove(task)
+          @complete = true
+        end
+
+        # As with remove, the only thing that is under RootAsyncScope should be
+        # the root BeginRescueEnsure, so upon failure we will be complete. Also
+        # sets failure variable for later raising.
+        def fail(task, error)
+          @failure = error
+          @complete = true
+        end
+
+        def <<(this_task)
+          @executor << this_task
+        end
+
+        # Reture self, a RootAsyncScope is the closest containing scope
+        def get_closest_containing_scope
+          self
+        end
+
+        # Call out to the AsyncEventLoop
+        def eventLoop
+          @executor.executeQueuedTasks
+        end
+
+
+        private
+        DELEGATED_METHODS = [:push, :<<, :enq, :empty?, :length, :size, :delete, :shift]
+
+        def method_missing(method_name, *args)
+          if DELEGATED_METHODS.include? method_name
+            @executor.send(method_name, *args)
+          else
+            super
+          end
+        end
+      end
+
+      # @!visibility private
+      class AsyncEventLoop
+
+        def initialize
+          @tasks = []
+        end
+
+        def remove(task)
+          @tasks.delete(task)
+        end
+        # TODO Make sure that it's okay to fail from the AsyncEventLoop, and that
+        # this is the correct behavior
+        def fail(task, error)
+          raise error
+        end
+        def <<(task)
+          @tasks << task
+
+        end
+
+
+        # TODO should this be synchronized somehow?
+
+        # Actually executes the eventLoop
+        def executeQueuedTasks
+          until @tasks.empty?
+            task = @tasks.shift
+            task.resume if task.alive?
+          end
+        end
+      end
+
+    end
+  end
+end