lamma 0.2.1

data/lib/lamma/cli/init.rb

@@ -0,0 +1,61 @@
+require 'pathname'
+require 'lamma/runtime'
+
+module Lamma
+  class CLI::Init
+    include Thor::Actions
+    attr_reader :target, :thor, :options, :runtime
+
+    def initialize(options, function_name, thor)
+      @options = options
+      @thor = thor
+      runtime_str = options.fetch('runtime') { raise ArgumentError.new('runtime must be set.') }
+      @runtime = Lamma::Runtime.new(runtime_str)
+      @target = Pathname.pwd.join(function_name)
+    end
+
+    def run
+      if Dir.exist?(target)
+        abort("Directory '#{target}' already exists.")
+      end
+
+      tpath = File.join(File.dirname(__FILE__), '..', 'templates', runtime.to_dirname)
+      templates = Dir.glob(File.join(tpath, '**/*.erb')).map do |path|
+        tar_file = path[tpath.length..path.length - 5] # /foo/bar/templates/RUNTIME/baz/lambda_function.py.erb => /baz/lambda_function.py
+
+        [File.expand_path(path), File.join(target, tar_file)]
+      end.to_h
+
+      unless Dir.exists?(target)
+        FileUtils.makedirs(target)
+      end
+
+      templates.each do |src, dst|
+        File.open(dst, "w") do |f|
+          template = File.read(src)
+          formatted = ERB.new(template).result(binding)
+          f.write(formatted)
+        end
+      end
+
+      Dir.chdir(target) do
+        `git init`
+        `git add .`
+      end
+    end
+  end
+
+  private
+
+  def default_region
+    'us-east-1'
+  end
+
+  def default_account_id
+    nil
+  end
+
+  def default_role_name
+    nil
+  end
+end

data/lib/lamma/cli/rollback.rb

@@ -0,0 +1,60 @@
+require 'yaml'
+
+require 'lamma'
+require 'lamma/function'
+require 'lamma/alias'
+
+module Lamma
+  class CLI::Rollback
+    attr_reader :options, :thor, :path
+
+    def initialize(options, thor)
+      @options = options
+      @thor = thor
+      @conf_path = options['path'] || Lamma::DEFAULT_CONF_PATH
+    end
+
+    def run
+      unless File.exists?(@conf_path)
+        abort("Config file #{@conf_path} is missing.")
+      end
+
+      f = Lamma::Function.new(@conf_path)
+
+      unless f.remote_exists?
+        abort("Remote function #{f.name} doesn't seem to be exists. You have to create or deploy it first")
+      end
+
+      unless options['alias']
+        abort("You can't rollback with alias (-a) option.")
+      end
+
+      a = Lamma::Alias.new(f, options['alias'])
+
+      unless a.remote_exists?
+        abort("Alias #{a.name} doesn't exist. You have to deploy the function first.")
+      end
+
+      la = Lamma::Alias.new(f, "#{options['alias']}_#{Lamma::LAST_DEPLOY_SUFFIX}")
+
+      unless la.remote_exists?
+        abort("Alias #{la.name} doesn't exist. You have to deploy the function first.")
+      end
+
+      v = a.remote_version
+      lv = la.remote_version
+
+      if v == lv
+        abort("Aliases #{a.name} and #{la.name} indicates same version #{v}. Deploy it first?")
+      end
+
+      a.version = lv
+      a.update
+    end
+
+    private
+    def templates_path
+      File.expand_path(File.join(File.dirname(__FILE__), '../templates'))
+    end
+  end
+end

data/lib/lamma/cli/show.rb

@@ -0,0 +1,20 @@
+module Lamma
+  class CLI::Show
+    def initialize(options, function_name, thor)
+      @options = options
+      @thor = thor
+      @function_name = function_name
+      @conf_path = options[:path] || Lamma::DEFAULT_CONF_PATH
+    end
+
+    def run
+      f = Lamma::Function.new(@function_name)
+
+      unless f.remote_exists?
+        thor.say("Function #{f.name} doesn't exist in remote.")
+      end
+
+      thor.say(f) # XXX:
+    end
+  end
+end

data/lib/lamma/code.rb

@@ -0,0 +1,133 @@
+require 'digest/md5'
+require 'zip'
+
+require 'lamma/logger'
+
+module Lamma
+  class Code
+    BUILD_FILE_NAME = 'build.zip'
+
+    def initialize(function, yaml)
+      @function = function
+      @source_path = yaml.fetch('source_path', '.')
+      @prebuild = yaml.fetch('prebuild', nil)
+      @build_path = yaml.fetch('build_path', nil)
+    end
+
+    def zip_io
+      return @zip_io if @zip_io
+
+      if h = cached_build_hash
+        bp = File.join(build_path, h, BUILD_FILE_NAME)
+        Lamma.logger.info "Using cached build: #{bp}"
+        @zip_io = File.open(bp, 'rb')
+      else
+        unless File.directory?(@source_path)
+          raise "Source path #{@source_path} doesn't exists"
+        end
+
+        # prebuild script
+        if @prebuild
+          Lamma.logger.info 'Running prebuild script...'
+          raise unless system(@prebuild)
+        elsif @function.runtime == Lamma::Runtime::PYTHON_27 \
+          && File.exist?(File.join(@source_path, 'requirements.txt'))
+          raise unless system("pip", "install", "-r", "requirements.txt", "-t", ".")
+          # XXX: verbose?
+        elsif [Lamma::Runtime::EDGE_NODE_43, Lamma::Runtime::NODE_43].include? @function.runtime \
+          && File.exist?(File.join(@source_path, 'package.json'))
+          raise unless system("npm", "install", "--production")
+        end
+
+        io = Zip::OutputStream.write_buffer do |zio|
+          active_paths.each do |path|
+            next unless File.file?(path)
+            File.open(path) do |source_io|
+              zio.put_next_entry(path)
+              data = source_io.read
+              zio.write(data)
+            end
+          end
+        end
+
+        io.rewind
+        if true # XXX: option save_builds?
+          File.open(File.join(zipfile_path, BUILD_FILE_NAME), 'w').write(io.read)
+          Lamma.logger.info("Saved the build: #{zipfile_path}")
+          io.rewind
+        end
+        @zip_io = io
+      end
+
+      @zip_io
+    end
+
+    def to_h
+      {
+        zip_file: zip_io
+      }
+    end
+
+    private
+
+    def cached_build_hash
+      Dir.glob(File.join(build_path, "*/"))
+        .map{|path| File.basename(path)}.each do |h|
+        if hash == h
+          return h
+        end
+      end
+
+      nil
+    end
+
+    def hash
+      return @hash if @hash
+
+      h = Digest::MD5.new
+
+      active_paths.each do |path|
+        next unless File.file?(path)
+        h.update(path)
+        t = Digest::MD5.file(path)
+        h.update(t.digest)
+      end
+
+      @hash = h.to_s
+    end
+
+    def active_paths
+      Dir.glob(File.join(@source_path, '**/*')).select do |path|
+        !ignores.include?(path)
+      end
+    end
+
+    def build_path
+      if @build_path
+        unless File.directory?(@build_path)
+          FileUtils.mkdir_p(@build_path)
+        end
+      else
+        @build_path = File.join(Dir.tmpdir, 'lamma')
+      end
+
+      @build_path
+    end
+
+    def zipfile_path
+      return @zipfile_path if @zipfile_path
+
+      path = File.join(build_path, hash)
+      unless File.directory?(path)
+        FileUtils.mkdir_p(path)
+      end
+
+      @zipfile_path = path
+    end
+
+    def ignores
+      # TODO: impl
+      %w||
+    end
+  end
+end

data/lib/lamma/dead_letter_config.rb

@@ -0,0 +1,7 @@
+module Lamma
+  class DeadLetterConfig
+    def initialize(yaml)
+      @target_arn = yaml.fetch('target_arn', nil)
+    end
+  end
+end

data/lib/lamma/environment.rb

@@ -0,0 +1,13 @@
+module Lamma
+  class Environment
+    def initialize(yaml)
+      @variables = yaml.fetch('variables', {})
+    end
+
+    def to_h
+      {
+        variables: @variables
+      }
+    end
+  end
+end

data/lib/lamma/event_source_mapping.rb

@@ -0,0 +1,7 @@
+require 'lamma'
+
+module Lamma
+  class EventSourceMapping
+
+  end
+end

data/lib/lamma/function.rb

@@ -0,0 +1,175 @@
+require 'lamma'
+require 'yaml'
+
+require 'lamma/runtime'
+require 'lamma/code'
+require 'lamma/vpc_config'
+require 'lamma/dead_letter_config'
+require 'lamma/environment'
+
+module Lamma
+  class Function
+    attr_reader :name, :region
+    attr_accessor :publish
+
+    def initialize(yaml_path)
+      path = Pathname.new(yaml_path)
+      @id = path.basename.sub_ext('').to_s
+      @root_path = path.parent
+      yaml = YAML.load(path.open)
+
+      @conf = yaml.fetch('function', {})
+
+      @publish = false
+      @name = @conf.fetch('name', nil)
+      @role_arn = @conf.fetch('role_arn', nil)
+      @description = @conf.fetch('description', nil)
+      @timeout = @conf.fetch('timeout', 3)
+      @memory_size = @conf.fetch('memory_size', 128)
+      # @dead_letter_config = dead_letter_config(@conf)
+      @region = @conf.fetch('region') { raise ValidationError.new('region must be set.') }
+      @kms_key_arn = @conf.fetch('kms_key_arn', nil)
+    end
+
+    def code
+      @code ||= Code.new(self, @conf.fetch('code', {}))
+    end
+
+    def create
+      Lamma.logger.info("Creating new function #{@name}...")
+
+      resp = lambda_client.create_function({
+        function_name: @name,
+        runtime: runtime.to_s,
+        role: @role_arn,
+        handler: handler,
+        code: code.to_h,
+        description: @description,
+        timeout: @timeout,
+        memory_size: @memory_size,
+        publish: publish,
+        vpc_config: vpc_config.to_h,
+        environment: environment.to_h,
+        kms_key_arn: @kms_key_arn
+      })
+
+      Lamma.logger.info(resp)
+    end
+
+    def update
+      Lamma.logger.info('Updating function configuration...')
+
+      resp = lambda_client.update_function_configuration({
+        function_name: @name,
+        runtime: runtime.to_s,
+        role: @role_arn,
+        handler: handler,
+        description: @description,
+        timeout: @timeout,
+        memory_size: @memory_size,
+        vpc_config: vpc_config.to_h,
+        environment: environment.to_h,
+        kms_key_arn: @kms_key_arn
+      })
+
+      Lamma.logger.info("Updated configuration for function: #{resp.function_arn}")
+
+      Lamma.logger.info('Updating function code...')
+
+      resp = lambda_client.update_function_code({
+        function_name: @name,
+        zip_file: code.to_h[:zip_file],
+        publish: publish
+      })
+
+      Lamma.logger.info("Updated code for function: #{resp.function_arn}")
+    end
+
+    def update_or_create
+      if remote_exists?
+        update
+      else
+        create
+      end
+    end
+
+    def aliases
+      lambda_client.list_aliases({
+        function_name: @name
+      }).aliases.map do |a|
+        Lamma::Alias.new(self, a.name, a.description)
+      end
+    end
+
+    def versions
+      lambda_client.list_versions_by_function({
+        function_name: @name
+      }).versions
+    end
+
+    def publish_version(v_desc, validate=nil)
+      Lamma.logger.info("Publishing...")
+      resp = lambda_client.publish_version({
+        function_name: @name,
+        code_sha_256: validate,
+        description: v_desc
+      })
+      Lamma.logger.info("Published $LATEST version as version #{resp.version} of funtion: #{resp.function_arn}")
+      resp
+    end
+
+    def remote_exists?
+      begin
+        lambda_client.get_function_configuration({
+          function_name: @name,
+        })
+      rescue Aws::Lambda::Errors::ResourceNotFoundException
+        false
+      end
+    end
+
+    private
+
+    def runtime
+      runtime_str = @conf.fetch('runtime') { raise ValidationError.new('runtime must be set') }
+
+      @runtime ||= Lamma::Runtime.new(runtime_str)
+    end
+
+    def handler
+      @conf.fetch('handler', default_handler)
+    end
+
+    def dead_letter_config
+      DeadLetterConfig.new(@conf.fetch('dead_letter_config', {}))
+    end
+
+    def environment
+      Environment.new(@conf.fetch('environment', {}))
+    end
+
+    def vpc_config
+      VpcConfig.new(@conf.fetch('vpc_config', {}))
+    end
+
+    def default_handler
+      case runtime.type
+      when Runtime::C_SHARP
+        raise ValidationError.new('handler must be set for C# runtime')
+      when Runtime::JAVA_8
+        raise ValidationError.new('handler must be set for Java8 runtime')
+      when Runtime::NODE_43
+        'index.handler'
+      when Runtime::EDGE_NODE_43
+        'index.handler'
+      when Runtime::PYTHON_27
+        'lambda_function.lambda_handler'
+      end
+    end
+
+
+    def lambda_client
+      @lambda_client ||= Aws::Lambda::Client.new(region: @region)
+    end
+  end
+end