lambda_ruby_bundler 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7bf3f89fe8cb3dead5a5d935366eaada4eceb209ceaf3298774d6dd61877e1ee
+  data.tar.gz: 686a6b547bf4983b268f665e11da63aced31f6bd3a367c027adbe04bce11aaae
+SHA512:
+  metadata.gz: a3df72a48792cdc0c04b159b89c9a00a60d08a8831707a4726632f71c7cb20df0e23ec264aa7eba3c99c20d2c95664359f14b8b5d439decf25dd2845bc44e269
+  data.tar.gz: 51465948b799fd031b69a32e726a61c3f6e7540bd969ee29233ce0a30be0a414bbe3dd8140a58f556f380f855aa1e41988b547b53aa44f1a3ec6b3d3163ea2cd

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+spec/tmp/*
+!spec/tmp/.keep

data/.rspec

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

data/.ruby-version

@@ -0,0 +1 @@
+2.5.7

data/.travis.yml

@@ -0,0 +1,12 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.7
+  - 2.6.3
+before_install: gem install bundler -v 2.0.2
+script:
+  - bundle exec rspec
+  - bundle exec rubocop
+services:
+  - docker

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [v1.0.0] - 2019-11-06
+### Features
+- Added initial implementation of the gem.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+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, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at michal.begejowicz@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lambda_ruby_bundler.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,73 @@
+PATH
+  remote: .
+  specs:
+    lambda_ruby_bundler (1.0.0)
+      docker-api
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.0)
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    docile (1.3.2)
+    docker-api (1.34.2)
+      excon (>= 0.47.0)
+      multi_json
+    excon (0.68.0)
+    jaro_winkler (1.5.4)
+    json (2.2.0)
+    method_source (0.9.2)
+    multi_json (1.14.1)
+    parallel (1.18.0)
+    parser (2.6.5.0)
+      ast (~> 2.4.0)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rainbow (3.0.0)
+    rake (13.0.0)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.0)
+      rspec-support (~> 3.9.0)
+    rspec-expectations (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.0)
+    rubocop (0.76.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.6)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 1.7)
+    ruby-progressbar (1.10.1)
+    rubyzip (2.0.0)
+    simplecov (0.17.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    unicode-display_width (1.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  lambda_ruby_bundler!
+  pry
+  rake
+  rspec
+  rubocop
+  rubyzip
+  simplecov
+
+BUNDLED WITH
+   2.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 TD Reply
+
+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,125 @@
+# LambdaRubyBundler
+
+LambdaRubyBundler is a command-line tool for packaging Ruby applications for AWS Lambda.
+
+Most notably, it properly compiles dependencies with C extensions, using a custom Docker image based on [lambci/lambda:build-ruby2.5](https://hub.docker.com/r/lambci/lambda/tags).
+
+## Installation
+
+Add this line to your application's Gemfile for programmatic usage:
+
+```ruby
+gem 'lambda_ruby_bundler'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lambda_ruby_bundler
+
+## Usage
+
+Note that the library requires running Docker on your system!
+
+Let's assume the following directory structure:
+
+```
+/tmp/my_serverless_app
+├── Gemfile
+├── Gemfile.lock
+├── backend/
+│   └── handler.rb
+└── node_modules/...
+```
+
+### Command line usage
+
+Run:
+
+```bash
+lambda_ruby_bundler \
+  --root-path /tmp/my_serverless_app \
+  --app-path backend \
+  --out /tmp/build.zip
+```
+
+It will produce two ZIP files, one with the contents of the application directory:
+
+```
+# build.zip
+├ handler.rb
+```
+
+And one with bundled dependencies:
+
+```
+# build-dependencies.zip
+ruby/gems/2.5.0
+├── gems/...
+```
+
+The first one is meant as the Lambda code, while second will work as Lambda Layer, allowing you to share it between multiple Lambdas using the same codebase.
+
+Note that:
+
+1. The structure will be "flattened" (based on contents of the `--app-path`)
+2. Only gems **not in** development and test groups will be bundled
+3. The first run might be very long. It requires pulling the base image, building Bundler image, fetching and building gems for your application
+
+### Programmatic usage
+
+```ruby
+executor = LambdaRubyBundler::Executor.new(
+  '/tmp/my_serverless_app',
+  'backend',
+  true
+)
+
+result = executor.run
+File.write('bundle.zip', result[:application_bundle].read)
+File.write('dependencies.zip', result[:dependency_layer].read)
+```
+
+### Cache mode
+
+The gem can also automatically assign build paths and cache them. To use Cache Mode, simply use `--cache-dir` option in CLI usage or use `LambdaRubyBundler::CLI::CacheRunner` class to generate the bundles.
+
+```bash
+lambda_ruby_bundler --app-path backend --cache-dir tmp
+```
+
+```ruby
+runner = LambdaRubyBundler::CLI::CacheRunner.new(Dir.pwd, 'backend', 'tmp')
+runner.run
+```
+
+This will save the bundles in cache directory and will output the paths to STDOUT (CLI case) or return them as Hash (programmatic usage).
+
+### Ruby versions
+
+Currently, Lambda supports only Ruby 2.5 environment - specifically, `2.5.5`. At the moment of writing this Readme, newest version from `2.5.x` family is `2.5.7`.
+
+Your application is expected to work properly on Ruby 2.5.5, but the `LambdaRubyBundler` does not verify it in any way. To ease the development of the application, the `ruby` entry from Gemfile will be removed while bundling gems, allowing you to develop your application with any ruby version.
+
+Note that it is still best to use a version from Ruby 2.5.x family - other versions might be packaged successfully, but might not work when deployed to Lambda!
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also 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`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/td-berlin/lambda_ruby_bundler. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open-source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the LambdaRubyBundler project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'lambda_ruby_bundler'
+
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/exe/lambda_ruby_bundler

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'lambda_ruby_bundler'
+
+options = LambdaRubyBundler::CLI::OptionParser.new.parse!(ARGV)
+
+runner = if options[:cache_dir]
+           LambdaRubyBundler::CLI::CacheRunner.new(
+             options[:root_path], options[:app_path], options[:cache_dir]
+           )
+         else
+           LambdaRubyBundler::CLI::StandardRunner.new(
+             options[:root_path],
+             options[:app_path],
+             options[:build_dependencies],
+             application_bundle: options[:output_path],
+             dependency_layer: options[:dependencies_path]
+           )
+         end
+
+puts runner.run.to_json

data/lambda_ruby_bundler.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lambda_ruby_bundler/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lambda_ruby_bundler'
+  spec.version       = LambdaRubyBundler::VERSION
+  spec.authors       = ['TD Reply']
+  spec.email         = ['michal.begejowicz@gmail.com']
+
+  spec.summary       = 'Bundler for Ruby applications running on lambda'
+  spec.description   = <<~DESC
+    Bundler for Ruby applications running on lambda.
+
+    It manages proper building of dependencies and native extensions.
+  DESC
+
+  spec.homepage      = 'https://github.com/td-berlin/lambda_ruby_bundler'
+  spec.license       = 'MIT'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been
+  # added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^spec/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'docker-api'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubyzip'
+  spec.add_development_dependency 'simplecov'
+end

data/lib/lambda_ruby_bundler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'lambda_ruby_bundler/version'
+
+require 'digest'
+require 'docker'
+require 'forwardable'
+require 'optparse'
+require 'json'
+require 'singleton'
+
+require 'lambda_ruby_bundler/image'
+require 'lambda_ruby_bundler/volume'
+require 'lambda_ruby_bundler/container'
+require 'lambda_ruby_bundler/executor'
+
+require 'lambda_ruby_bundler/cli'
+require 'lambda_ruby_bundler/cli/option_parser'
+require 'lambda_ruby_bundler/cli/base_runner'
+require 'lambda_ruby_bundler/cli/cache_runner'
+require 'lambda_ruby_bundler/cli/standard_runner'
+
+module LambdaRubyBundler
+  class Error < StandardError; end
+end

data/lib/lambda_ruby_bundler/Dockerfile

@@ -0,0 +1,11 @@
+FROM lambci/lambda:build-ruby2.5
+
+RUN mkdir -p /workspace/build
+WORKDIR /workspace
+
+ENV BUNDLE_WITHOUT=development:test
+
+RUN mkdir /app /scripts
+COPY packager.rb /scripts/packager.rb
+
+ENTRYPOINT [ "/scripts/packager.rb" ]

data/lib/lambda_ruby_bundler/cli.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module LambdaRubyBundler
+  # Namespace for handling Command Line Interface
+  module CLI
+  end
+end

data/lib/lambda_ruby_bundler/cli/base_runner.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LambdaRubyBundler
+  module CLI
+    # Runs the executor.
+    # @api private
+    class BaseRunner
+      attr_reader :root_path, :app_path
+
+      def initialize(root_path, app_path)
+        @root_path = root_path
+        @app_path = app_path
+      end
+
+      private
+
+      def bundle(build_dependencies)
+        executor = LambdaRubyBundler::Executor.new(
+          root_path, app_path, build_dependencies
+        )
+
+        result = executor.run
+
+        save(result[:application_bundle], paths[:application_bundle])
+        return unless build_dependencies
+
+        save(result[:dependency_layer], paths[:dependency_layer])
+      end
+
+      def save(io, path)
+        File.open(path, 'wb+') { |file| file.write(io.read) }
+      end
+    end
+  end
+end

data/lib/lambda_ruby_bundler/cli/cache_runner.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module LambdaRubyBundler
+  module CLI
+    # Runs the executor in Cache Mode.
+    class CacheRunner < BaseRunner
+      MD5_EXTRACT_REGEX = /build(?:dep)?-([a-f0-9]{32}).zip/.freeze
+
+      attr_reader :cache_dir
+
+      # Creates new instance of cache runner.
+      #
+      # @param [String] root_path
+      #   Path to the root of application (containing Gemfile.lock)
+      # @param [String] app_path
+      #   Path (relative to root_path) containing application code
+      # @param [String]
+      #   cache_dir Directory containing cached builds
+      def initialize(root_path, app_path, cache_dir)
+        super(root_path, app_path)
+        @cache_dir = cache_dir
+      end
+
+      # Runs the executor, if necessary. Returns hash with two keys:
+      #   :application_bundle => path to the application code bundle
+      #   :dependency_layer => path to dependency bundle
+      #
+      # @return [Hash] Paths to the builds
+      def run
+        build_dependencies = !dependencies_builds.key?(dependencies_hash)
+        build_application = !application_builds.key?(application_hash)
+
+        if build_application || build_dependencies
+          clear_cache
+          bundle(build_dependencies)
+        end
+
+        paths
+      end
+
+      private
+
+      def clear_cache
+        (application_builds.values + dependencies_builds.values).each do |file|
+          FileUtils.rm(file)
+        end
+      end
+
+      def paths
+        @paths ||= {
+          application_bundle:
+            File.join(cache_dir, "build-#{application_hash}.zip"),
+          dependency_layer:
+            File.join(cache_dir, "builddep-#{dependencies_hash}.zip")
+        }
+      end
+
+      def application_hash
+        @application_hash ||= begin
+          files = Dir[File.join(root_path, app_path, '**', '*')]
+          digest = Digest::MD5.new
+
+          files.each do |file|
+            digest << File.read(file) if File.file?(file)
+          end
+
+          digest.hexdigest
+        end
+      end
+
+      def dependencies_hash
+        @dependencies_hash ||= begin
+          path = File.join(root_path, 'Gemfile.lock')
+          content = File.read(path)
+          Digest::MD5.hexdigest(content)
+        end
+      end
+
+      def application_builds
+        @application_builds ||= fetch_builds('build-*.zip')
+      end
+
+      def dependencies_builds
+        @dependencies_builds ||= fetch_builds('builddep-*.zip')
+      end
+
+      def fetch_builds(name_glob)
+        Dir[File.join(cache_dir, name_glob)]
+          .group_by(&method(:extract_md5))
+          .transform_values(&:first)
+          .tap { |result| result.delete(nil) }
+      end
+
+      def extract_md5(path)
+        MD5_EXTRACT_REGEX.match(path)&.captures&.at(0)
+      end
+    end
+  end
+end

data/lib/lambda_ruby_bundler/cli/option_parser.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module LambdaRubyBundler
+  module CLI
+    # Custom OptionParser which collects user-supplied options about the build.
+    # @api private
+    class OptionParser < ::OptionParser
+      attr_reader :options
+
+      OPTIONS = %i[
+        root_path_option
+        app_path_option
+        output_option
+        no_dependencies_option
+        dependencies_path_option
+        cache_dir_option
+      ].freeze
+
+      def initialize
+        @options = defaults
+
+        super { |builder| OPTIONS.each { |option| send(option, builder) } }
+      end
+
+      def parse!(*)
+        super
+
+        options[:dependencies_path] ||= build_default_dependencies_path(
+          options[:output_path]
+        )
+
+        options
+      end
+
+      private
+
+      def defaults
+        {
+          root_path: Dir.pwd,
+          app_path: '.',
+          build_dependencies: true,
+          dependencies_path: nil,
+          output_path: 'build.zip',
+          cache_dir: nil
+        }
+      end
+
+      def build_default_dependencies_path(output_path)
+        File.join(
+          File.dirname(output_path),
+          [File.basename(output_path, '.*'), 'dependencies.zip'].join('-')
+        )
+      end
+
+      def root_path_option(builder)
+        builder.on(
+          '--root-path=ROOT_PATH',
+          'Sets root path (containing Gemfile) of the application' \
+          ' (defaults to current directory)'
+        ) do |path|
+          options[:root_path] = File.expand_path(path)
+        end
+      end
+
+      def app_path_option(builder)
+        builder.on(
+          '--app-path=APP_PATH',
+          'Sets application path (relative to root) with the application code' \
+          ' (defaults to current directory)',
+          &assign_option(:app_path)
+        )
+      end
+
+      def output_option(builder)
+        builder.on(
+          '--out=OUT_PATH',
+          'Sets output path, to which the ZIP with the bundled code ' \
+          'will be saved',
+          &assign_option(:output_path)
+        )
+      end
+
+      def no_dependencies_option(builder)
+        builder.on(
+          '--no-dependencies', 'Prevents building dependency layer'
+        ) do |option|
+          options[:build_dependencies] = option
+        end
+      end
+
+      def dependencies_path_option(builder)
+        builder.on(
+          '--dependencies-path=APP_PATH',
+          'Sets path for the dependencies layer package (defaults to ' \
+          '{OUT_PATH}-dependencies.zip)',
+          &assign_option(:dependencies_path)
+        )
+      end
+
+      def cache_dir_option(builder)
+        builder.on(
+          '--cache-dir=CACHE_DIR',
+          'Enables Cache Mode and uses chosen directory as target directory ' \
+          'for the builds.',
+          &assign_option(:cache_dir)
+        )
+      end
+
+      def assign_option(option)
+        proc { |value| options[option] = value }
+      end
+    end
+  end
+end

data/lib/lambda_ruby_bundler/cli/standard_runner.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LambdaRubyBundler
+  module CLI
+    # Runs the executor with given parameters.
+    class StandardRunner < BaseRunner
+      attr_reader :build_dependencies, :paths
+
+      # Creates new instance of cache runner.
+      #
+      # @param [String] root_path
+      #   Path to the root of application (containing Gemfile.lock)
+      # @param [String] app_path
+      #   Path (relative to root_path) containing application code
+      # @param [Boolean] build_dependencies
+      #   Whether or not to build dependencies
+      # @param [Hash] paths
+      #   Hash with :application_bundle and :dependency_layer output paths
+      def initialize(root_path, app_path, build_dependencies, paths)
+        super(root_path, app_path)
+        @build_dependencies = build_dependencies
+        @paths = paths
+      end
+
+      # Runs the executo. Returns hash with two keys:
+      #   :application_bundle => path to the application code bundle
+      #   :dependency_layer => path to dependency bundle
+      #
+      # @return [Hash] Paths to the builds
+      def run
+        bundle(build_dependencies)
+      end
+    end
+  end
+end

data/lib/lambda_ruby_bundler/container.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module LambdaRubyBundler
+  # Wrapper around [Docker::Container] for creating, running and removing
+  # bundler containers.
+  # @api private
+  class Container
+    attr_reader :root_path, :app_path, :volume, :build_dependencies
+
+    def initialize(root_path, app_path, volume, build_dependencies)
+      @root_path = root_path
+      @app_path = app_path
+      @volume = volume
+      @build_dependencies = build_dependencies
+    end
+
+    def run(timeout: 120)
+      container.start
+
+      container.attach({}, read_timeout: timeout)
+    end
+
+    def destroy
+      container.remove
+      @container = nil
+    end
+
+    private
+
+    def container
+      @container ||= Docker::Container.create(container_arguments)
+    end
+
+    def container_arguments
+      { 'Cmd' => [app_path, build_dependencies ? 'use-deps' : 'no-deps'],
+        'Image' => Image.instance.id,
+        'HostConfig' => {
+          'AutoRemove' => true,
+          'Mounts' => mounts
+        } }
+    end
+
+    def mounts
+      [
+        { 'Target' => '/app',
+          'Source' => root_path,
+          'Type' => 'bind',
+          'ReadOnly' => true },
+        { 'Target' => '/workspace/build/vendor/bundle',
+          'Source' => volume.id,
+          'Type' => 'volume' }
+      ]
+    end
+  end
+end

data/lib/lambda_ruby_bundler/executor.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module LambdaRubyBundler
+  # Main entrypoint to the application, which packages the code from given
+  # directory into ZIP.
+  #
+  # The packaging is done inside a container resembling Lambda environment,
+  # ensuring that the gems with C extensions will work there properly.
+  #
+  #
+  # @example Default use case
+  #     # Given following directory structure:
+  #     # /tmp/my_serverless_app
+  #     # +-- Gemfile
+  #     # +-- Gemfile.lock
+  #     # +-- backend/
+  #     # |   +-- handler.rb
+  #     # +-- node_modules/...
+  #
+  #     executor = LambdaRubyBundler::Executor.new(
+  #       '/tmp/my_serverless_app',
+  #       'backend',
+  #       true
+  #     )
+  #
+  #     result = executor.run
+  #     File.write('bundle.zip', result[:application_bundle].read)
+  #     File.write('dependencies.zip', result[:dependency_layer].read)
+  #
+  #     # Note that resulting structure of the ZIP will be flattened!
+  #     # + handler.rb
+  #     # + vendor/bundle/...
+  class Executor
+    attr_reader :root_path, :app_path, :build_dependencies
+
+    # Creates new instance of the Executor.
+    #
+    # @param [String] root_path
+    #   Path to the root of the application (with Gemfile)
+    # @param [String] app_path
+    #   Path to the Ruby application code, relative to root.
+    # @param [Boolean] build_dependencies
+    #   Flag whether or not to bundle the dependencies.
+    #   Useful in cases when dependencies (Gemfile.lock) does not change
+    #   between builds.
+    def initialize(root_path, app_path, build_dependencies)
+      @root_path = root_path
+      @app_path = app_path
+      @build_dependencies = build_dependencies
+    end
+
+    # Generates the ZIP contents.
+    #
+    # @return [Hash{:application_bundle, :dependency_layer => StringIO}]
+    #   Hash with the zip IOs. If `build_dependencies` options was falsey,
+    #   There will be no :dependency_layer key.
+    def run
+      zipped_contents, = container.run.tap { container.destroy }
+      contents = JSON.parse(zipped_contents.join)
+
+      decode(contents)
+    end
+
+    private
+
+    def decode(contents)
+      contents.each_with_object({}) do |(key, data), result|
+        result[key.to_sym] = StringIO.new(Base64.strict_decode64(data))
+      end
+    end
+
+    def application_name
+      @application_name ||= File.basename(root_path)
+    end
+
+    def container
+      @container ||= Container.new(
+        root_path, app_path, volume, build_dependencies
+      )
+    end
+
+    def volume
+      @volume ||= Volume.new(application_name)
+    end
+  end
+end

data/lib/lambda_ruby_bundler/image.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module LambdaRubyBundler
+  # Wrapper around [Docker::Image] for building the image for the bundler
+  # containers.
+  # @api private
+  class Image
+    include Singleton
+    extend Forwardable
+
+    delegate id: :@image
+
+    def initialize
+      @image = Docker::Image.build_from_dir(__dir__, 't' => tag)
+    end
+
+    def tag
+      @tag ||= [
+        'lambda-ruby-bundler',
+        VERSION
+      ].join(':')
+    end
+  end
+end

data/lib/lambda_ruby_bundler/packager.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Packager script run inside the container
+
+require 'fileutils'
+require 'json'
+require 'base64'
+
+APPLICATION_DIRECTORY, = ARGV
+BUNDLE_DEPS = ARGV.include?('use-deps')
+
+def silent(command)
+  system(command, out: File::NULL, err: File::NULL)
+end
+
+def bundle_install(*additional_options)
+  [
+    'bundle install',
+    '--path build/vendor/bundle',
+    *additional_options
+  ].join(' ')
+end
+
+RUBY_ENTRY_REGEX = /\A\s*ruby\s+("|')\d+\.\d+\.\d+("|')\s*\z/.freeze
+
+result = {}
+
+if BUNDLE_DEPS
+  # Copy Gemfile and Gemfile.lock to the workspace
+  FileUtils.cp('/app/Gemfile', '/workspace/Gemfile')
+  FileUtils.cp('/app/Gemfile.lock', '/workspace/Gemfile.lock')
+
+  # Clean Ruby version requirement from Gemfile
+  contents = File.read('/workspace/Gemfile').lines
+  contents.reject! { |line| RUBY_ENTRY_REGEX.match(line) }
+  File.write('/workspace/Gemfile', contents.join)
+
+  # Check if all gems are installed
+  all_installed = silent(bundle_install('--local'))
+
+  # Install if some gems are missing locally
+  silent(bundle_install) unless all_installed
+
+  # Clean unused gems
+  silent('bundle clean')
+
+  # Create proper structure for AWS Layer
+  FileUtils.mkdir_p('/tmp/layer/ruby/gems')
+  FileUtils.symlink(
+    '/workspace/build/vendor/bundle/ruby/2.5.0',
+    '/tmp/layer/ruby/gems/2.5.0'
+  )
+
+  # Zip the dependencies
+  silent('cd /tmp/layer && zip -r /tmp/dependencies.zip .')
+
+  # Add serialized ZIP to result
+  content = File.read('/tmp/dependencies.zip')
+  result[:dependency_layer] = Base64.strict_encode64(content)
+end
+
+# Zip the application code
+app_path = File.join('/app', APPLICATION_DIRECTORY)
+silent("cd #{app_path} && zip -r /tmp/app.zip .")
+
+# Add serialized ZIP to result
+content = File.read('/tmp/app.zip')
+result[:application_bundle] = Base64.strict_encode64(content)
+
+puts(result.to_json)

data/lib/lambda_ruby_bundler/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LambdaRubyBundler
+  VERSION = '1.0.0'
+end

data/lib/lambda_ruby_bundler/volume.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LambdaRubyBundler
+  # Wrapper around [Docker::Volume] for creating and fetching bundler volumes,
+  # which are used to cache built gems. This speeds up the process
+  # significantly.
+  # @api private
+  class Volume
+    NAME_TEMPLATE = 'lambda-ruby-bundler-%<app>s-volume'
+
+    attr_reader :application_name
+
+    def initialize(application_name)
+      @application_name = application_name
+    end
+
+    def id
+      volume.id
+    end; alias name id
+
+    private
+
+    def volume
+      @volume ||= fetch_volume
+    end
+
+    def fetch_volume
+      name = format(NAME_TEMPLATE, app: application_name)
+
+      Docker::Volume.get(name)
+    rescue Docker::Error::NotFoundError
+      Docker::Volume.create(name)
+    end
+  end
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: lambda_ruby_bundler
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- TD Reply
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-11-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Bundler for Ruby applications running on lambda.
+
+  It manages proper building of dependencies and native extensions.
+email:
+- michal.begejowicz@gmail.com
+executables:
+- lambda_ruby_bundler
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/lambda_ruby_bundler
+- lambda_ruby_bundler.gemspec
+- lib/lambda_ruby_bundler.rb
+- lib/lambda_ruby_bundler/Dockerfile
+- lib/lambda_ruby_bundler/cli.rb
+- lib/lambda_ruby_bundler/cli/base_runner.rb
+- lib/lambda_ruby_bundler/cli/cache_runner.rb
+- lib/lambda_ruby_bundler/cli/option_parser.rb
+- lib/lambda_ruby_bundler/cli/standard_runner.rb
+- lib/lambda_ruby_bundler/container.rb
+- lib/lambda_ruby_bundler/executor.rb
+- lib/lambda_ruby_bundler/image.rb
+- lib/lambda_ruby_bundler/packager.rb
+- lib/lambda_ruby_bundler/version.rb
+- lib/lambda_ruby_bundler/volume.rb
+homepage: https://github.com/td-berlin/lambda_ruby_bundler
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/td-berlin/lambda_ruby_bundler
+  source_code_uri: https://github.com/td-berlin/lambda_ruby_bundler
+  changelog_uri: https://github.com/td-berlin/lambda_ruby_bundler/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6.2
+signing_key: 
+specification_version: 4
+summary: Bundler for Ruby applications running on lambda
+test_files: []