jets 0.2.0 → 0.5.0

data/lib/jets/job.rb

@@ -0,0 +1,5 @@
+class Jets::Job
+  autoload :Dsl, "jets/job/dsl"
+  autoload :Base, "jets/job/base"
+  autoload :Task, "jets/job/task"
+end

data/lib/jets/job/base.rb

@@ -0,0 +1,29 @@
+require 'json'
+
+# Job public methods get turned into Lambda functions.
+#
+# Jets::Job::Base < Jets::Lambda::Functions
+# Both Jets::Job::Base and Jets::Lambda::Functions have Dsl modules included.
+# So the Jets::Job::Dsl overrides some of the Jets::Lambda::Functions behavior.
+class Jets::Job
+  class Base < Jets::Lambda::Functions
+    include Dsl
+
+    class << self
+      def process(event, context, meth)
+        job = new(event, context, meth)
+        job.send(meth)
+      end
+
+      def perform_now(meth, event, context=nil)
+        new(event, context, meth).send(meth)
+      end
+
+      def perform_later(meth, event, context=nil)
+        function_name = "#{self.to_s.underscore}-#{meth}"
+        call = Jets::Commands::Call.new(function_name, JSON.dump(event), invocation_type: "Event")
+        call.run
+      end
+    end
+  end
+end

data/lib/jets/job/dsl.rb

@@ -0,0 +1,58 @@
+# Jets::Job::Base < Jets::Lambda::Functions
+# Both Jets::Job::Base and Jets::Lambda::Functions have Dsl modules included.
+# So the Jets::Job::Dsl overrides some of the Jets::Lambda::Functions behavior.
+module Jets::Job::Dsl
+  extend ActiveSupport::Concern
+
+  included do
+    class << self
+      def rate(expression)
+        @rate = expression
+      end
+
+      def cron(expression)
+        @cron = expression
+      end
+
+      # Explicitly disable scheduling for the function
+      def disable(value)
+        @disable = value
+      end
+
+      # This is a property of the AWS::Events::Rule not the Lambda function
+      def state(value)
+        @state = value
+      end
+
+      # Override register_task.
+      # A Job::Task is a Lambda::Task with some added DSL methods like
+      # rate and cron.
+      def register_task(meth, lang=:ruby)
+        if @rate || @cron || @disable
+          # Job lambda function.
+          all_tasks[meth] = Jets::Job::Task.new(self.name, meth,
+            rate: @rate,
+            cron: @cron,
+            state: @state,
+            properties: @properties,
+            lang: lang)
+          true
+        else
+          task_name = "#{name}##{meth}" # IE: HardJob#dig
+          puts "[WARNING] #{task_name} created without a rate or cron expression. " \
+            "Add a rate or cron expression above the method definition if you want this method to be scheduled. " \
+            "If #{task_name} is not meant to be a scheduled lambda function, you can put the method under after a private keyword to get rid of this warning. " \
+            "#{task_name} defined at #{caller[1].inspect}."
+          false
+        end
+        # Done storing options, clear out for the next added method.
+        clear_properties
+      end
+
+      def clear_properties
+        super
+        @rate, @cron, @state, @disable = nil, nil, nil, nil
+      end
+    end
+  end
+end

data/lib/jets/job/task.rb

@@ -0,0 +1,17 @@
+class Jets::Job::Task < Jets::Lambda::Task
+  attr_reader :state
+  def initialize(class_name, meth, options={})
+    super
+    @rate = options[:rate]
+    @cron = options[:cron]
+    @state = options[:state] || 'ENABLED'
+  end
+
+  def schedule_expression
+    if @rate
+      "rate(#{@rate})"
+    elsif @cron
+      "cron(#{@cron})"
+    end
+  end
+end

data/lib/jets/klass.rb

@@ -0,0 +1,71 @@
+# Loading a class can usually be loaded via .constantize.
+# But app/functions files are anonymous ruby classes created with
+# Class.new.  Anonymous classes cannot be loaded via .constantize and
+# go through standard autoloading.
+#
+# Jets::Klass provides a way to load app classes in app/controllers, app/jobs,
+# app/functions in a consistent way without having to worry about the anonymous
+# class loading quirk. Classes that are not anonymously defined like controllers
+# and jobs are loaded via autoloading with .constantize. Anonymously defined
+# classes like functions are loaded via Object.const_set.
+#
+# Examples:
+#
+#   Jets::Klass.from_path("app/controllers/posts_controller.rb")
+#   Jets::Klass.from_path("app/jobs/hard_job.rb")
+#   Jets::Klass.from_path("app/functions/hello.rb")
+#   Jets::Klass.from_path("app/functions/hello_function.rb")
+#
+#   Jets::Klass.from_task(task)
+#
+# The from_task method takes a Jets::Lambda::Task as an argument and is useful
+# for the CloudFormation child stack generation there the registered task info
+# is available but the path info is now.
+class Jets::Klass
+  class << self
+    # from_path allows us to load any app classes in consistent way for
+    # app/controllers, app/jobs, and app/functions.
+    def from_path(path)
+      class_name = class_name(path)
+
+      if path.include?("/functions/") # simple function
+        load_anonymous_class(class_name, path)
+      end
+
+      class_name.constantize # autoload or nothing if load_anonymous_class called
+    end
+
+    # app/controllers/posts_controller.rb => PostsController
+    def class_name(path)
+      path.sub(%r{.*app\/(.*?)/},'').sub(/\.rb$/,'').classify
+    end
+
+    def from_task(task)
+      class_name = task.class_name
+      filename = class_name.underscore
+
+      # Examples of filename: posts_controller, hard_job, security_rule,
+      #   hello_function, hello
+      valid_types = %w[controller job rule]
+      type = filename.split('_').last
+      type = "function" unless valid_types.include?(type)
+
+      path = "app/#{type.pluralize}/#{filename}.rb"
+      from_path(path)
+    end
+
+    @@loaded_anonymous_classes = []
+    def load_anonymous_class(class_name, path)
+      constructor = Jets::Lambda::FunctionConstructor.new(path)
+      # Dont load anonyomous class more than once to avoid these warnings:
+      #   warning: already initialized constant Hello
+      #   warning: previous definition of Hello was here
+      unless @@loaded_anonymous_classes.include?(class_name)
+        # use class_name as the variable name for prettier class name.
+        Object.const_set(class_name, constructor.build)
+        @@loaded_anonymous_classes << class_name
+      end
+    end
+
+  end
+end

data/lib/jets/lambda.rb

@@ -0,0 +1,18 @@
+# Task vs Functions
+#
+# Functions is inherited by Job::Base and Controller::Base.
+# It is holds the event and context is used for processing when you
+# call the lambda function.
+#
+# Task is a holds information for the method that gets registered
+# with method_add and is used to build up the CloudFormation Lambda
+# Function definition.
+#
+# Overview diagram : http://bit.ly/2zQeoF3
+module Jets::Lambda
+  autoload :Dsl, "jets/lambda/dsl"
+  autoload :FunctionConstructor, "jets/lambda/function_constructor"
+  autoload :Function, "jets/lambda/function"
+  autoload :Functions, "jets/lambda/functions"
+  autoload :Task, "jets/lambda/task"
+end

data/lib/jets/lambda/dsl.rb

@@ -0,0 +1,153 @@
+module Jets::Lambda::Dsl
+  extend ActiveSupport::Concern
+
+  def lambda_functions
+    self.class.lambda_functions
+  end
+
+  included do
+    class << self
+      def class_properties(options=nil)
+        if options
+          @class_properties ||= {}
+          @class_properties.deep_merge!(options)
+        else
+          @class_properties || {}
+        end
+      end
+      alias_method :class_props, :class_properties
+
+      def class_timeout(value)
+        class_properties(timeout: value)
+      end
+
+      def class_environment(hash)
+        environment = {}
+        environment[:variables] ||= {}
+        environment[:variables].merge!(hash)
+        class_properties(environment: environment)
+      end
+      alias_method :class_env, :class_environment
+
+      def class_memory_size(value)
+        class_properties(memory_size: value)
+      end
+      alias_method :class_memory, :class_memory_size
+
+      def class_role(name)
+        class_properties(role: name)
+      end
+
+      def class_handler(name)
+        class_properties(handler: name)
+      end
+
+      # convenience method that set properties
+      def timeout(value)
+        properties(timeout: value)
+      end
+
+      # convenience method that set properties
+      def environment(hash)
+        environment = {}
+        environment[:variables] ||= {}
+        environment[:variables].merge!(hash)
+        properties(environment: environment)
+      end
+      alias_method :env, :environment
+
+      # convenience method that set properties
+      def memory_size(value)
+        properties(memory_size: value)
+      end
+      alias_method :memory, :memory_size
+
+      def handler(value)
+        properties(handler: value)
+      end
+
+      def runtime(value)
+        properties(runtime: value)
+      end
+
+      def properties(options={})
+        @properties ||= {}
+        @properties.deep_merge!(options)
+      end
+      alias_method :props, :properties
+
+      # meth is a Symbol
+      def method_added(meth)
+        return if %w[initialize method_missing].include?(meth.to_s)
+        return unless public_method_defined?(meth)
+
+        register_task(meth)
+      end
+
+      def register_task(meth, lang=:ruby)
+        # Note: for anonymous classes like for app/functions self.name is ""
+        # We adjust the class name when we build the functions later in
+        # FunctionContstructor#adjust_tasks.
+        all_tasks[meth] = Jets::Lambda::Task.new(self.name, meth,
+          properties: @properties, lang: lang)
+
+        # Done storing options, clear out for the next added method.
+        clear_properties
+        # Important to clear @properties at the end of registering outside of
+        # register_task because register_task is overridden in Jets::Job::Dsl
+        #
+        #   Jets::Job::Base < Jets::Lambda::Functions
+        #
+        # Both Jets::Job::Base and Jets::Lambda::Functions have Dsl modules included.
+        # So the Jets::Job::Dsl overrides some of the Jets::Lambda::Dsl behavior.
+
+        true
+      end
+
+      def clear_properties
+        @properties = nil
+      end
+
+      # Returns the all tasks for this class with their method names as keys.
+      #
+      # ==== Returns
+      # OrderedHash:: An ordered hash with tasks names as keys and JobTask
+      #               objects as values.
+      #
+      def all_tasks
+        @all_tasks ||= ActiveSupport::OrderedHash.new
+      end
+
+      # Returns the tasks for this class in Array form.
+      #
+      # ==== Returns
+      # Array of task objects
+      #
+      def tasks
+        all_tasks.values
+      end
+
+      # The public methods defined in the project app class ulimately become
+      # lambda functions.
+      #
+      # Example return value:
+      #   [:index, :new, :create, :show]
+      def lambda_functions
+        all_tasks.keys
+      end
+
+      # Polymorphic support
+      def defpoly(lang, meth)
+        register_task(meth, lang)
+      end
+
+      def python(meth)
+        defpoly(:python, meth)
+      end
+
+      def node(meth)
+        defpoly(:node, meth)
+      end
+    end
+  end
+end

data/lib/jets/lambda/function.rb

@@ -0,0 +1,29 @@
+module Jets::Lambda
+  class Function < Functions
+    # Override and change the signature so we do not have to provide info at
+    # initialization. So:
+    #
+    #   hello_function = HelloFunction.new
+    #   hello_function.lambda_handler(event, context)
+    #
+    # Normally controller and job functions initialize like this:
+    #
+    #   controller = PostController.new(event, context, "handler_handler")
+    def initialize
+    end
+
+    def self.handler
+      handler_task.meth
+    end
+
+    def self.handler_task
+      tasks.first
+    end
+
+    # Used by main_processor.rb.  Same interface as controllers and jobs.
+    def self.process(event, context, meth)
+      function = new
+      function.send(handler, event, context)
+    end
+  end
+end

data/lib/jets/lambda/function_constructor.rb

@@ -0,0 +1,60 @@
+# Builds an anonymous class that represents a single Lambda function from code
+# in app/functions.
+#
+# The build method returns an anonymous class using Class.new that contains
+# the methods defined in the app/functions/hello.rb code.
+#
+# Ruby Class.new docs:
+#
+# Creates a new anonymous (unnamed) class with the given superclass (or
+# Object if no parameter is given). You can give a class a name by
+# assigning the class object to a constant.
+# http://ruby-doc.org/core-2.1.1/Class.html#method-c-new
+#
+# So assigning the result of build to a constant makes for a prettier
+# class name. Example:
+#
+#   constructor = FunctionConstructor.new(code_path)
+#   HelloFunction = constructor.build
+#
+# The class name will be HelloFunction instead of (anonymous). Then usage would
+# be:
+#
+#   hello_function = HelloFunction.new
+#   hello_function(hello_function.handler, event, context)
+#
+# Or call with the process class method:
+#
+#   HelloFunction.process(event, context, "world")
+module Jets::Lambda
+  class FunctionConstructor
+    def initialize(code_path)
+      @code_path = full(code_path)
+    end
+
+    def full(path)
+      path = "#{Jets.root}#{path}" unless path.include?(Jets.root.to_s)
+      path
+    end
+
+    def build
+      code = IO.read(@code_path)
+      function_klass = Class.new(Jets::Lambda::Function)
+      function_klass.module_eval(code)
+      adjust_tasks(function_klass)
+      function_klass # assign this to a Constant for a pretty class name
+    end
+
+    # For anonymous classes method_added during task registeration contains ""
+    # for the class name.  We adjust it here.
+    def adjust_tasks(klass)
+      class_name = @code_path.sub(/.*app\/functions\//,'').sub(/\.rb$/, '')
+      class_name = class_name.classify
+      klass.tasks.each do |task|
+        task.class_name = class_name
+        task.type = "function"
+      end
+    end
+  end
+end
+