kuby-core 0.1.0

data/lib/kuby/definition.rb

@@ -0,0 +1,29 @@
+module Kuby
+  class Definition
+    attr_reader :environment, :app
+
+    def initialize(environment, app, &block)
+      @environment = environment
+      @app = app
+
+      instance_eval(&block) if block
+      kubernetes.after_configuration
+    end
+
+    def docker(&block)
+      @docker ||= Docker::Spec.new(self)
+      @docker.instance_eval(&block) if block
+      @docker
+    end
+
+    def kubernetes(&block)
+      @kubernetes ||= Kubernetes::Spec.new(self)
+      @kubernetes.instance_eval(&block) if block
+      @kubernetes
+    end
+
+    def app_name
+      @app_name ||= app.class.module_parent.name
+    end
+  end
+end

data/lib/kuby/docker.rb

@@ -0,0 +1,27 @@
+require 'kuby/docker/errors'
+
+module Kuby
+  module Docker
+    autoload :Alpine,         'kuby/docker/alpine'
+    autoload :AssetsPhase,    'kuby/docker/assets_phase'
+    autoload :BundlerPhase,   'kuby/docker/bundler_phase'
+    autoload :CLI,            'kuby/docker/cli'
+    autoload :CopyPhase,      'kuby/docker/copy_phase'
+    autoload :Credentials,    'kuby/docker/credentials'
+    autoload :Debian,         'kuby/docker/debian'
+    autoload :Dockerfile,     'kuby/docker/dockerfile'
+    autoload :LayerStack,     'kuby/docker/layer_stack'
+    autoload :LocalTags,      'kuby/docker/local_tags'
+    autoload :Metadata,       'kuby/docker/metadata'
+    autoload :Packages,       'kuby/docker/packages'
+    autoload :PackagePhase,   'kuby/docker/package_phase'
+    autoload :Phase,          'kuby/docker/phase'
+    autoload :RemoteTags,     'kuby/docker/remote_tags'
+    autoload :SetupPhase,     'kuby/docker/setup_phase'
+    autoload :Spec,           'kuby/docker/spec'
+    autoload :Tags,           'kuby/docker/tags'
+    autoload :TimestampTag,   'kuby/docker/timestamp_tag'
+    autoload :WebserverPhase, 'kuby/docker/webserver_phase'
+    autoload :YarnPhase,      'kuby/docker/yarn_phase'
+  end
+end

data/lib/kuby/docker/alpine.rb

@@ -0,0 +1,62 @@
+module Kuby
+  module Docker
+    class Alpine
+      SHELL_EXE = '/bin/sh'.freeze
+
+      DEFAULT_PACKAGES = [
+        [:ca_certificates],
+        [:nodejs, '12.14.1'],
+        [:yarn, '1.21.1'],
+        [:c_toolchain],
+        [:sqlite_dev],
+        [:tzdata]
+      ].freeze
+
+      attr_reader :phase
+
+      def initialize(phase)
+        @phase = phase
+      end
+
+      def install(packages, into:)
+        dockerfile = into
+        install_managed(packages, dockerfile)
+        install_unmanaged(packages, dockerfile)
+      end
+
+      def default_packages
+        DEFAULT_PACKAGES
+      end
+
+      def shell_exe
+        SHELL_EXE
+      end
+
+      private
+
+      def install_managed(packages, dockerfile)
+        pkgs = packages.select(&:managed?)
+
+        unless pkgs.empty?
+          package_names = pkgs.map { |pkg| pkg.package_name_for(:alpine) }
+          dockerfile.run(
+            "apk add --no-cache #{package_names.join(' ')}"
+          )
+        end
+      end
+
+      def install_unmanaged(packages, dockerfile)
+        packages
+          .reject(&:managed?)
+          .each do |package|
+            if package.respond_to?(:install_on_alpine)
+              package.send(:install_on_alpine, dockerfile)
+            else
+              raise UnsupportedDistroError, "Couldn't install #{package.name} "\
+                "because alpine is an unsupported distro"
+            end
+          end
+      end
+    end
+  end
+end

data/lib/kuby/docker/assets_phase.rb

@@ -0,0 +1,11 @@
+module Kuby
+  module Docker
+    class AssetsPhase < Phase
+      def apply_to(dockerfile)
+        dockerfile.run(
+          'bundle', 'exec', 'rake', 'assets:precompile'
+        )
+      end
+    end
+  end
+end

data/lib/kuby/docker/bundler_phase.rb

@@ -0,0 +1,56 @@
+module Kuby
+  module Docker
+    class BundlerPhase < Phase
+      DEFAULT_WITHOUT = ['development', 'test', 'deploy'].freeze
+
+      attr_accessor :version, :gemfile, :without
+
+      def apply_to(dockerfile)
+        gf = gemfile || default_gemfile
+        lf = "#{gf}.lock"
+        v = version || default_version
+        wo = without || DEFAULT_WITHOUT
+
+        dockerfile.run("gem install bundler -v #{v}")
+
+        # bundle install
+        dockerfile.copy(gf, '.')
+        dockerfile.copy(lf, '.')
+
+        # set bundle path so docker will cache the bundle
+        dockerfile.run('mkdir ./bundle')
+        dockerfile.env('BUNDLE_PATH=./bundle')
+
+        unless wo.empty?
+          dockerfile.env("BUNDLE_WITHOUT='#{wo.join(' ')}'")
+        end
+
+        dockerfile.run(
+          'bundle', 'install',
+          '--jobs', '$(nproc)',
+          '--retry', '3',
+          '--gemfile', gf
+        )
+
+        # generate binstubs and add the bin directory to our path
+        dockerfile.run('bundle binstubs --all')
+        dockerfile.env("PATH=./bin:$PATH")
+      end
+
+      private
+
+      def default_version
+        Bundler::VERSION
+      end
+
+      def default_gemfile
+        Bundler
+          .definition
+          .gemfiles
+          .first
+          .relative_path_from(app.root)
+          .to_s
+      end
+    end
+  end
+end

data/lib/kuby/docker/cli.rb

@@ -0,0 +1,72 @@
+require 'json'
+require 'open3'
+
+module Kuby
+  module Docker
+    class CLI < CLIBase
+      attr_reader :executable
+
+      def initialize(executable = nil)
+        @executable = executable || `which docker`.strip
+      end
+
+      def build(dockerfile:, image_url:, tags:)
+        cmd = [
+          executable, 'build',
+          *tags.flat_map { |tag| ['-t', "#{image_url}:#{tag}"] },
+          '-f-', '.'
+        ]
+
+        open3_w({}, cmd) do |stdin, _wait_threads|
+          stdin.puts(dockerfile.to_s)
+        end
+
+        unless last_status.success?
+          raise BuildError, 'build failed: docker command exited with '\
+            "status code #{last_status.exitstatus}"
+        end
+      end
+
+      def run(image_url:, tag: 'latest', env: {}, ports: [])
+        cmd = [
+          executable, 'run',
+          *env.flat_map { |k, v| ['-e', "#{k}=#{v}"] },
+          *ports.flat_map { |port| ['-p', "#{port}:#{port}"] },
+          '--init',
+          '--rm',
+          "#{image_url}:#{tag}"
+        ]
+
+        execc(cmd)
+      end
+
+      def images(image_url)
+        cmd = [
+          executable, 'images', image_url,
+          '--format', '"{{json . }}"'
+        ]
+
+        backticks(cmd).split("\n").map do |image_data|
+          JSON.parse(image_data).each_with_object({}) do |(k, v), ret|
+            ret[k.underscore.to_sym] = v
+          end
+        end
+      end
+
+      def push(image_url, tag)
+        systemm([
+          executable, 'push', "#{image_url}:#{tag}"
+        ])
+
+        unless last_status.success?
+          raise PushError, 'push failed: docker command exited with '\
+            "status code #{last_status.exitstatus}"
+        end
+      end
+
+      def status_key
+        :kuby_docker_cli_last_status
+      end
+    end
+  end
+end

data/lib/kuby/docker/copy_phase.rb

@@ -0,0 +1,23 @@
+module Kuby
+  module Docker
+    class CopyPhase < Phase
+      DEFAULT_PATHS = ['./'].freeze
+
+      attr_reader :paths
+
+      def initialize(*args)
+        super
+        @paths = []
+      end
+
+      def <<(path)
+        paths << path
+      end
+
+      def apply_to(dockerfile)
+        to_copy = paths.empty? ? DEFAULT_PATHS : paths
+        to_copy.each { |path| dockerfile.copy(path, '.') }
+      end
+    end
+  end
+end

data/lib/kuby/docker/credentials.rb

@@ -0,0 +1,11 @@
+require 'kube-dsl'
+
+module Kuby
+  module Docker
+    class Credentials
+      extend ::KubeDSL::ValueFields
+
+      value_fields :username, :password, :email
+    end
+  end
+end

data/lib/kuby/docker/debian.rb

@@ -0,0 +1,66 @@
+module Kuby
+  module Docker
+    class Debian
+      SHELL_EXE = '/bin/bash'
+
+      DEFAULT_PACKAGES = [
+        [:ca_certificates],
+        [:nodejs, '12.14.1'],
+        [:yarn, '1.21.1']
+      ].freeze
+
+      attr_reader :phase
+
+      def initialize(phase)
+        @phase = phase
+      end
+
+      def install(packages, into:)
+        dockerfile = into
+        install_managed(packages, dockerfile)
+        install_unmanaged(packages, dockerfile)
+      end
+
+      def default_packages
+        DEFAULT_PACKAGES
+      end
+
+      def shell_exe
+        SHELL_EXE
+      end
+
+      private
+
+      def install_managed(packages, dockerfile)
+        pkgs = packages.select(&:managed?)
+
+        pkg_cmd = <<~CMD.strip
+          apt-get update -qq && \\
+            DEBIAN_FRONTEND=noninteractive apt-get install -qq -y --no-install-recommends apt-transport-https && \\
+            DEBIAN_FRONTEND=noninteractive apt-get install -qq -y --no-install-recommends apt-utils && \\
+            DEBIAN_FRONTEND=noninteractive apt-get install -qq -y --no-install-recommends
+        CMD
+
+        unless pkgs.empty?
+          package_names = pkgs.map { |pkg| pkg.package_name_for(:debian) }
+          pkg_cmd << " \\\n  #{package_names.join(" \\\n  ")}"
+        end
+
+        dockerfile.run(pkg_cmd)
+      end
+
+      def install_unmanaged(packages, dockerfile)
+        packages
+          .reject(&:managed?)
+          .each do |package|
+            if package.respond_to?(:install_on_debian)
+              package.send(:install_on_debian, dockerfile)
+            else
+              raise UnsupportedDistroError, "Couldn't install #{package.name} "\
+                "because debian is an unsupported distro"
+            end
+          end
+      end
+    end
+  end
+end

data/lib/kuby/docker/dockerfile.rb

@@ -0,0 +1,128 @@
+module Kuby
+  module Docker
+    class Dockerfile
+      class Command
+        attr_reader :args
+
+        def initialize(*args)
+          @args = args
+        end
+
+        def to_s
+          args.join(' ')
+        end
+      end
+
+      class From < Command
+        attr_reader :image_url, :as
+
+        def initialize(image_url, as: nil)
+          @image_url = image_url
+          @as = as
+        end
+
+        def to_s
+          str = "FROM #{image_url}"
+          str << " AS #{as}" if as
+          str
+        end
+      end
+
+      class Workdir < Command
+        def to_s; "WORKDIR #{super}"; end
+      end
+
+      class Env < Command
+        def to_s; "ENV #{super}"; end
+      end
+
+      class Run < Command
+        def to_s; "RUN #{super}"; end
+      end
+
+      class Copy < Command
+        attr_reader :source, :dest, :from
+
+        def initialize(source, dest, from: nil)
+          @source = source
+          @dest = dest
+          @from = from
+        end
+
+        def to_s
+          cmd = ['COPY']
+          cmd << "--from=#{from}" if from
+          cmd += [source, dest]
+          cmd.join(' ')
+        end
+      end
+
+      class Expose < Command
+        def to_s; "EXPOSE #{super}"; end
+      end
+
+      class Cmd < Command
+        def to_s; "CMD #{super}"; end
+      end
+
+      attr_reader :commands, :cursor
+
+      def initialize
+        @commands = []
+        @cursor = 0
+      end
+
+      def from(*args, **kwargs)
+        add From.new(*args, **kwargs)
+      end
+
+      def workdir(*args)
+        add Workdir.new(*args)
+      end
+
+      def env(*args)
+        add Env.new(*args)
+      end
+
+      def run(*args)
+        add Run.new(*args)
+      end
+
+      def copy(*args, **kwargs)
+        add Copy.new(*args, **kwargs)
+      end
+
+      def expose(*args)
+        add Expose.new(*args)
+      end
+
+      def cmd(*args)
+        add Cmd.new(*args)
+      end
+
+      def to_s
+        commands.map(&:to_s).join("\n")
+      end
+
+      def exposed_ports
+        commands
+          .select { |c| c.is_a?(Expose) }
+          .map { |c| c.args.first }
+      end
+
+      def insert_at(pos)
+        @cursor = pos
+        yield
+      ensure
+        @cursor = commands.size
+      end
+
+      private
+
+      def add(cmd)
+        commands.insert(cursor, cmd)
+        @cursor += 1
+      end
+    end
+  end
+end