cutlass 0.1.0

data/lib/cutlass/container_boot.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "container_control"
+
+module Cutlass
+  # Boots containers and tears 'em down
+  #
+  # Has a single method ContainerBoot#call which returns an instance of
+  #
+  #   boot = ContainerBoot.new(image_id: @image.id)
+  #   boot.call do |container_control|
+  #     container_control.class # => ContainerControl
+  #     container_control.bash_exec("pwd")
+  #   end
+  #
+  # The number one reason to boot a container is to be able to exercise a booted server from
+  # within the container. To do this you need to tell docker want port to expose
+  # inside of the container. Docker will expose that port and bind it to a free port
+  # on the "host" i.e. your local machine. From there you can make queries to various
+  # docker ports:
+  #
+  #   boot = ContainerBoot.new(image_id: @image.id, expose_ports: [8080])
+  #   boot.call do |container_control|
+  #     local_port = container_control.get_host_port(8080)
+  #
+  #     `curl localhost:#{local_port}`
+  #   end
+  #
+  # Note: Booting a container only works if the image has an ENTRYPOINT that does
+  # not exit.
+  #
+  # Note: Running `bash_exec` commands from this context gives you a raw access to the
+  # container. It does not execute the container's entrypoint. That means if you're running
+  # inside of a CNB image, that env vars won't be set and the directory might be different.
+  class ContainerBoot
+    def initialize(image_id:, expose_ports: [])
+      @expose_ports = Array(expose_ports)
+      config = {
+        "Image" => image_id,
+        "ExposedPorts" => {},
+        "HostConfig" => {
+          "PortBindings" => {}
+        }
+      }
+
+      port_bindings = config["HostConfig"]["PortBindings"]
+
+      @expose_ports.each do |port|
+        config["ExposedPorts"]["#{port}/tcp"] = {}
+
+        # If we do not specify a port, Docker will grab a random unused one:
+        port_bindings["#{port}/tcp"] = [{"HostPort" => ""}]
+      end
+
+      @container = Docker::Container.create(config)
+    end
+
+    def call
+      raise "Must call with a block" unless block_given?
+
+      @container.start!
+
+      puts @container.logs(stdout: 1) if Cutlass.debug?
+      puts @container.logs(stderr: 1) if Cutlass.debug?
+
+      yield ContainerControl.new(@container, ports: @expose_ports)
+    rescue => error
+      raise error, <<~EOM
+        message #{error.message}
+
+        boot stdout: #{@container.logs(stdout: 1)}
+        boot stderr: #{@container.logs(stderr: 1)}
+      EOM
+    ensure
+      @container&.delete(force: true)
+    end
+  end
+end

data/lib/cutlass/container_control.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Cutlass
+  # This class is exposed via a ContainerBoot instance
+  #
+  # Once a container is booted, if a port is bound an instance will
+  # return the local port that can be used to send network requests to the container.
+  #
+  # In addition bash commands can be executed via ContainerControl#bash_exec
+  #
+  class ContainerControl
+    def initialize(container, ports: [])
+      @container = container
+      @ports = ports
+    end
+
+    def get_host_port(port)
+      raise "Port not bound inside container: #{port}, bound ports: #{@ports.inspect}" unless @ports.include?(port)
+      @container.json["NetworkSettings"]["Ports"]["#{port}/tcp"][0]["HostPort"]
+    end
+
+    def contains_file?(path)
+      bash_exec("[[ -f '#{path}' ]]", exception_on_failure: false).status == 0
+    end
+
+    def get_file_contents(path)
+      bash_exec("cat '#{path}'").stdout
+    end
+
+    def bash_exec(cmd, exception_on_failure: true)
+      stdout_ish, stderr, status = @container.exec(["bash", "-c", cmd])
+
+      result = BashResult.new(stdout: stdout_ish.first, stderr: stderr, status: status)
+
+      return result if result.success?
+      return result unless exception_on_failure
+
+      raise <<~EOM
+        bash_exec(#{cmd}) failed
+
+        stdout: #{stdout}
+        stderr: #{stderr}
+      EOM
+    end
+  end
+end

data/lib/cutlass/docker_diff.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Cutlass
+  # Diffs docker images
+  #
+  #   diff = DockerDiff.new
+  #
+  #   diff.call.changed? # => false
+  #
+  #   BashResult.run("docker build .")
+  #
+  #   diff.call.changed? # => true
+  class DockerDiff
+    def initialize(before_ids: nil, get_image_ids_proc: -> { Docker::Image.all.map(&:id) })
+      @before_ids = before_ids || get_image_ids_proc.call
+      @get_image_ids_proc = get_image_ids_proc
+    end
+
+    def call
+      DiffValue.new(
+        before_ids: @before_ids,
+        now_ids: @get_image_ids_proc.call
+      )
+    end
+
+    class DiffValue
+      attr_reader :diff_ids
+
+      def initialize(before_ids:, now_ids:)
+        @diff_ids = now_ids - before_ids
+      end
+
+      def changed?
+        @diff_ids.any?
+      end
+
+      def same?
+        !changed?
+      end
+
+      def leaked_images
+        diff_ids.map do |id|
+          Docker::Image.get(id)
+        end
+      end
+
+      def to_s
+        leaked_images.map do |image|
+          "  tags: #{image.info["RepoTags"]}, id: #{image.id}"
+        end.join($/)
+      end
+    end
+  end
+end

data/lib/cutlass/env_diff.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Cutlass
+  # Diffs the environment
+  #
+  #   diff = EnvDiff.new
+  #
+  #   diff.changed? # => false
+  #
+  #   ENV["LOL"] = "rofl"
+  #
+  #   diff.changed? # => true
+  class EnvDiff
+    attr_reader :before_env, :env, :skip_keys
+
+    def initialize(before_env: ENV.to_h.dup, skip_keys: [], env: ENV)
+      @env = env
+      @before_env = before_env.freeze
+      @skip_keys = skip_keys
+    end
+
+    def to_s
+      env_keys.map do |k|
+        next if @env[k] == @before_env[k]
+
+        "  ENV['#{k}'] changed from '#{@before_env[k]}' to '#{@env[k]}'"
+      end.compact.join($/)
+    end
+
+    def same?
+      !changed?
+    end
+
+    def changed?
+      env_keys.detect do |k|
+        @env[k] != @before_env[k]
+      end
+    end
+
+    def env_keys
+      keys = (@before_env.keys + @env.keys) - skip_keys
+      keys.uniq
+    end
+  end
+end

data/lib/cutlass/local_buildpack.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Cutlass
+  # Converts a buildpack in a local directory into an image that pack can use natively
+  #
+  #   MY_BUILDPACK = LocalBuildpack.new(directory: "/tmp/muh_buildpack").call
+  #   puts MY_BUILDPACK.name #=> "docker:://cutlass_local_buildpack_abcd123"
+  #
+  #   Cutlass.config do |config|
+  #     config.default_buildapacks = [MY_BUILDPACK]
+  #   end
+  #
+  # Note: Make sure that any built images are torn down in in your test suite
+  #
+  #    config.after(:suite) do
+  #      MY_BUILDPACK.teardown
+  #
+  #      Cutlass::CleanTestEnv.check
+  #    end
+  #
+  class LocalBuildpack
+    private
+
+    attr_reader :image_name
+
+    public
+
+    def initialize(directory:)
+      @built = false
+      @directory = Pathname(directory)
+      @image_name = "cutlass_local_buildpack_#{SecureRandom.hex(10)}"
+    end
+
+    def teardown
+      return unless built?
+
+      image = Docker::Image.get(image_name)
+      image.remove(force: true)
+    end
+
+    def name
+      call
+      "docker://#{image_name}"
+    end
+
+    def call
+      return if built?
+      raise "must be directory: #{@directory}" unless @directory.directory?
+
+      @built = true
+
+      call_build_sh
+      call_pack_buildpack_package
+
+      self
+    end
+
+    private def call_pack_buildpack_package
+      raise "must contain package.toml: #{@directory}" unless @directory.join("package.toml").exist?
+
+      command = "pack buildpack package #{image_name} --config #{@directory.join("package.toml")} --format=image"
+      result = BashResult.run(command)
+
+      puts command if Cutlass.debug?
+      puts result.stdout if Cutlass.debug?
+      puts result.stderr if Cutlass.debug?
+
+      return if result.success?
+      raise <<~EOM
+        While packaging meta-buildpack: pack exited with status code #{result.status},
+        indicating an error and failed build!
+
+        stdout: #{result.stdout}
+        stderr: #{result.stderr}
+      EOM
+    end
+
+    private def call_build_sh
+      build_sh = @directory.join("build.sh")
+      return unless build_sh.exist?
+
+      command = "cd #{@directory} && bash #{build_sh}"
+      result = BashResult.run(command)
+
+      puts command if Cutlass.debug?
+      puts result.stdout if Cutlass.debug?
+      puts result.stderr if Cutlass.debug?
+
+      return if result.success?
+
+      raise <<~EOM
+        Buildpack build step failed!
+
+        stdout: #{result.stdout}
+        stderr: #{result.stderr}
+      EOM
+    end
+
+    def built?
+      @built
+    end
+  end
+end

data/lib/cutlass/pack_build.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Cutlass
+  # Build an image with `pack` and cloud native buildpacks
+  #
+  #  begin
+  #    build = PackBuild.new(app_dir: dir, buildpacks: ["heroku/ruby"], builder: "heroku/buildpacks:18")
+  #    build.call
+  #
+  #    build.stdout # => "...Successfully built image"
+  #    build.success? # => true
+  #  ensure
+  #    build.teardown
+  #  end
+  #
+  class PackBuild
+    private
+
+    attr_reader :app_dir, :config, :builder, :image_name, :buildpacks, :exception_on_failure, :env_arguments
+
+    public
+
+    def initialize(
+      app_dir:,
+      config: {},
+      builder: nil,
+      buildpacks: [],
+      image_name: Cutlass.default_image_name,
+      exception_on_failure: true
+    )
+      @app_dir = app_dir
+      @builder = builder
+      @image_name = image_name
+      @env_arguments = config.map { |key, value| "--env #{key}=#{value}" }.join(" ")
+      @exception_on_failure = exception_on_failure
+      @image = nil
+      @result = nil
+
+      @buildpacks = Array(buildpacks).map do |buildpack|
+        if buildpack.respond_to?(:name)
+          buildpack.name
+        else
+          buildpack
+        end
+      end
+    end
+
+    def image_id
+      raise "No image ID, container was not successfully built, #{error_message}" if @image.nil?
+      @image.id
+    end
+
+    def result
+      raise "Must execute method `call` first" unless @result
+
+      @result
+    end
+
+    def teardown
+      @image&.remove(force: true)
+    end
+
+    def stdout
+      result.stdout
+    end
+
+    def stderr
+      result.stderr
+    end
+
+    def call
+      puts pack_command if Cutlass.debug?
+      call_pack
+
+      puts @result.stdout if Cutlass.debug?
+      puts @result.stderr if Cutlass.debug?
+      self
+    end
+
+    def failed?
+      !success?
+    end
+
+    def success?
+      result.success?
+    end
+
+    private def call_pack
+      @result = BashResult.run(pack_command)
+
+      if @result.success?
+        @image = Docker::Image.get(image_name)
+      else
+        @image = nil
+
+        raise error_message if exception_on_failure
+      end
+    end
+
+    private def error_message
+      <<~EOM
+        Pack exited with status code #{@result.status}, indicating a build failed
+
+        command: #{pack_command}
+        stdout: #{stdout}
+        stderr: #{stderr}
+      EOM
+    end
+
+    def builder_arg
+      "-B #{builder}" if builder
+    end
+
+    def pack_command
+      "pack build #{image_name} --path #{app_dir} #{builder_arg} --buildpack #{buildpacks.join(",")} #{env_arguments} #{"-v" if Cutlass.debug?}"
+    end
+  end
+end