kuby-core 0.8.1 → 0.11.0

data/lib/kuby/docker.rb

@@ -1,3 +1,5 @@
+# typed: strict
+
 require 'kuby/docker/errors'
 
 module Kuby
@@ -9,6 +11,8 @@ module Kuby
     autoload :CopyPhase,      'kuby/docker/copy_phase'
     autoload :Credentials,    'kuby/docker/credentials'
     autoload :Debian,         'kuby/docker/debian'
+    autoload :DevSpec,        'kuby/docker/dev_spec'
+    autoload :Distro,         'kuby/docker/distro'
     autoload :Dockerfile,     'kuby/docker/dockerfile'
     autoload :InlineLayer,    'kuby/docker/inline_layer'
     autoload :Layer,          'kuby/docker/layer'

data/lib/kuby/docker/alpine.rb

@@ -1,40 +1,43 @@
+# typed: strict
+
 module Kuby
   module Docker
-    class Alpine
-      SHELL_EXE = '/bin/sh'.freeze
+    class Alpine < Distro
+      SHELL_EXE = T.let('/bin/sh'.freeze, String)
 
-      DEFAULT_PACKAGES = [
-        [:ca_certificates],
+      DEFAULT_PACKAGES = T.let([
+        [:ca_certificates, nil],
         [:nodejs, '12.14.1'],
         [:yarn, '1.21.1'],
-        [:c_toolchain],
-        [:tzdata]
-      ].freeze
+        [:c_toolchain, nil],
+        [:tzdata, nil]
+      ].freeze, T::Array[[Symbol, T.nilable(String)]])
 
+      sig { returns(Layer) }
       attr_reader :phase
 
-      def initialize(phase)
-        @phase = phase
-      end
-
+      sig { override.params(packages: T::Array[Distro::PackageImpl], into: Dockerfile).void }
       def install(packages, into:)
         dockerfile = into
         install_managed(packages, dockerfile)
         install_unmanaged(packages, dockerfile)
       end
 
+      sig { override.returns(T::Array[[Symbol, T.nilable(String)]]) }
       def default_packages
         DEFAULT_PACKAGES
       end
 
+      sig { override.returns(String) }
       def shell_exe
         SHELL_EXE
       end
 
       private
 
+      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_managed(packages, dockerfile)
-        pkgs = packages.select(&:managed?)
+        pkgs = T.cast(packages.select(&:managed?), T::Array[Distro::ManagedPackageImpl])
 
         unless pkgs.empty?
           package_names = pkgs.map { |pkg| pkg.package_name_for(:alpine) }
@@ -44,6 +47,7 @@ module Kuby
         end
       end
 
+      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_unmanaged(packages, dockerfile)
         packages
           .reject(&:managed?)

data/lib/kuby/docker/assets_phase.rb

@@ -1,6 +1,11 @@
+# typed: strict
+
 module Kuby
   module Docker
     class AssetsPhase < Layer
+      extend T::Sig
+
+      sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         dockerfile.run(
           'bundle', 'exec', 'rake', 'assets:precompile'

data/lib/kuby/docker/bundler_phase.rb

@@ -1,26 +1,58 @@
+# typed: strict
+
 require 'pathname'
 
 module Kuby
   module Docker
     class BundlerPhase < Layer
-      DEFAULT_WITHOUT = ['development', 'test', 'deploy'].freeze
+      extend T::Sig
+
+      DEFAULT_WITHOUT = T.let(
+        ['development', 'test', 'deploy'].freeze, T::Array[String]
+      )
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :version
+
+      sig { params(version: String).void }
+      attr_writer :version
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :gemfile
 
-      attr_accessor :version, :gemfile, :without
+      sig { params(gemfile: String).void }
+      attr_writer :gemfile
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :without
+
+      sig { params(without: T::Array[String]).void }
+      attr_writer :without
+
+      sig { params(environment: Environment).void }
+      def initialize(environment)
+        super
+
+        @version = T.let(@version, T.nilable(String))
+        @gemfile = T.let(@gemfile, T.nilable(String))
+        @without = T.let(@without, T.nilable(T::Array[String]))
+      end
 
+      sig { override.params(dockerfile: Dockerfile).void }
       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}")
+        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.run('mkdir', './bundle')
         dockerfile.env('BUNDLE_PATH=./bundle')
 
         unless wo.empty?
@@ -35,16 +67,18 @@ module Kuby
         )
 
         # generate binstubs and add the bin directory to our path
-        dockerfile.run('bundle binstubs --all')
+        dockerfile.run('bundle', 'binstubs', '--all')
         dockerfile.env("PATH=./bin:$PATH")
       end
 
       private
 
+      sig { returns(String) }
       def default_version
         Bundler::VERSION
       end
 
+      sig { returns(String) }
       def default_gemfile
         Bundler
           .definition

data/lib/kuby/docker/cli.rb

@@ -1,25 +1,35 @@
+# typed: strict
+
 require 'json'
 require 'open3'
+require 'shellwords'
 
 module Kuby
   module Docker
     class CLI < CLIBase
+      extend T::Sig
+
+      sig { returns(String) }
       attr_reader :executable
 
+      sig { params(executable: T.nilable(String)).void }
       def initialize(executable = nil)
-        @executable = executable || `which docker`.strip
+        @executable = T.let(executable || `which docker`.strip, String)
       end
 
+      sig { returns(T.nilable(String)) }
       def config_file
         if File.exist?(default_config_file)
           default_config_file
         end
       end
 
+      sig { returns(String) }
       def default_config_file
         File.join(Dir.home, '.docker', 'config.json')
       end
 
+      sig { params(url: String, username: String, password: String).void }
       def login(url:, username:, password:)
         cmd = [
           executable, 'login', url, '--username', username, '--password-stdin'
@@ -35,17 +45,30 @@ module Kuby
         end
       end
 
+      sig { returns(T::Array[String]) }
       def auths
         return [] unless config_file
 
-        config = JSON.parse(File.read(config_file))
+        config = JSON.parse(File.read(T.must(config_file)))
         config.fetch('auths', {}).keys
       end
 
-      def build(dockerfile:, image_url:, tags:)
+      sig {
+        params(
+          dockerfile: Dockerfile,
+          image_url: String,
+          tags: T::Array[String],
+          build_args: T::Hash[T.any(Symbol, String), String]
+        )
+        .void
+      }
+      def build(dockerfile:, image_url:, tags:, build_args: {})
         cmd = [
           executable, 'build',
           *tags.flat_map { |tag| ['-t', "#{image_url}:#{tag}"] },
+          *build_args.flat_map do |arg, val|
+            ['--build-arg', Shellwords.shellescape("#{arg}=#{val}")]
+          end,
           '-f-', '.'
         ]
 
@@ -59,6 +82,15 @@ module Kuby
         end
       end
 
+      sig {
+        params(
+          image_url: String,
+          tag: String,
+          env: T::Hash[T.any(Symbol, String), String],
+          ports: T::Array[T.any(String, Integer)]
+        )
+        .void
+      }
       def run(image_url:, tag: 'latest', env: {}, ports: [])
         cmd = [
           executable, 'run',
@@ -72,6 +104,7 @@ module Kuby
         execc(cmd)
       end
 
+      sig { params(image_url: String).returns(T::Array[T::Hash[Symbol, String]]) }
       def images(image_url)
         cmd = [
           executable, 'images', image_url,
@@ -85,6 +118,7 @@ module Kuby
         end
       end
 
+      sig { params(image_url: String, tag: String).void }
       def push(image_url, tag)
         systemm([
           executable, 'push', "#{image_url}:#{tag}"
@@ -96,9 +130,32 @@ module Kuby
         end
       end
 
+      sig { params(image_url: String, tag: String).void }
+      def pull(image_url, tag)
+        systemm([
+          executable, 'pull', "#{image_url}:#{tag}"
+        ])
+
+        unless last_status.success?
+          raise PullError, 'pull failed: docker command exited with '\
+            "status code #{last_status.exitstatus}"
+        end
+      end
+
+      sig { returns(Symbol) }
       def status_key
         :kuby_docker_cli_last_status
       end
+
+      sig { returns(Symbol) }
+      def stdout_key
+        :kuby_docker_stdout
+      end
+
+      sig { returns(Symbol) }
+      def stderr_key
+        :kuby_docker_stderr
+      end
     end
   end
 end

data/lib/kuby/docker/copy_phase.rb

@@ -1,19 +1,27 @@
+# typed: strict
+
 module Kuby
   module Docker
     class CopyPhase < Layer
-      DEFAULT_PATHS = ['./'].freeze
+      extend T::Sig
+
+      DEFAULT_PATHS = T.let(['./'].freeze, T::Array[String])
 
+      sig { returns(T::Array[String]) }
       attr_reader :paths
 
-      def initialize(*args)
+      sig { params(environment: Environment).void }
+      def initialize(environment)
         super
-        @paths = []
+        @paths = T.let([], T::Array[String])
       end
 
+      sig { params(path: String).void }
       def <<(path)
         paths << path
       end
 
+      sig { params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         to_copy = paths.empty? ? DEFAULT_PATHS : paths
         to_copy.each { |path| dockerfile.copy(path, '.') }

data/lib/kuby/docker/credentials.rb

@@ -1,3 +1,4 @@
+# typed: strict
 require 'kube-dsl'
 
 module Kuby

data/lib/kuby/docker/debian.rb

@@ -1,38 +1,41 @@
+# typed: strict
+
 module Kuby
   module Docker
-    class Debian
-      SHELL_EXE = '/bin/bash'
+    class Debian < Distro
+      SHELL_EXE = T.let('/bin/bash'.freeze, String)
 
-      DEFAULT_PACKAGES = [
-        [:ca_certificates],
+      DEFAULT_PACKAGES = T.let([
+        [:ca_certificates, nil],
         [:nodejs, '12.14.1'],
         [:yarn, '1.21.1']
-      ].freeze
+      ].freeze, T::Array[[Symbol, T.nilable(String)]])
 
+      sig { returns(Layer) }
       attr_reader :phase
 
-      def initialize(phase)
-        @phase = phase
-      end
-
+      sig { override.params(packages: T::Array[Distro::PackageImpl], into: Dockerfile).void }
       def install(packages, into:)
         dockerfile = into
         install_managed(packages, dockerfile)
         install_unmanaged(packages, dockerfile)
       end
 
+      sig { override.returns(T::Array[[Symbol, T.nilable(String)]]) }
       def default_packages
         DEFAULT_PACKAGES
       end
 
+      sig { override.returns(String) }
       def shell_exe
         SHELL_EXE
       end
 
       private
 
+      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_managed(packages, dockerfile)
-        pkgs = packages.select(&:managed?)
+        pkgs = T.cast(packages.select(&:managed?), T::Array[Distro::ManagedPackageImpl])
 
         pkg_cmd = <<~CMD.strip
           apt-get update -qq && \\
@@ -49,6 +52,7 @@ module Kuby
         dockerfile.run(pkg_cmd)
       end
 
+      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_unmanaged(packages, dockerfile)
         packages
           .reject(&:managed?)

data/lib/kuby/docker/dev_spec.rb

@@ -0,0 +1,195 @@
+# typed: strict
+
+module Kuby
+  module Docker
+    class WebserverDevPhase < Layer
+      extend T::Sig
+
+      DEFAULT_PORT = T.let('3000'.freeze, String)
+
+      sig { params(port: String).void }
+      attr_writer :port
+
+      sig { params(environment: Environment).void }
+      def initialize(environment)
+        super
+
+        @port = T.let(@port, T.nilable(String))
+      end
+
+      sig { override.params(dockerfile: Dockerfile).void }
+      def apply_to(dockerfile)
+        dockerfile.expose(port)
+      end
+
+      sig { returns(String) }
+      def port
+        @port || DEFAULT_PORT
+      end
+    end
+
+    class DevSpec
+      extend T::Sig
+
+      sig { returns(Environment) }
+      attr_reader :environment
+
+      sig { params(environment: Environment).void }
+      def initialize(environment)
+        @environment = environment
+
+        @setup_phase = T.let(@setup_phase, T.nilable(SetupPhase))
+        @package_phase = T.let(@package_phase, T.nilable(PackagePhase))
+        @webserver_phase = T.let(@webserver_phase, T.nilable(WebserverDevPhase))
+        @metadata = T.let(@metadata, T.nilable(Metadata))
+        @distro_spec = T.let(@distro_spec, T.nilable(Distro))
+        @cli = T.let(@cli, T.nilable(CLI))
+        @tags = T.let(@tags, T.nilable(LocalTags))
+        @layer_stack = T.let(@layer_stack, T.nilable(Docker::LayerStack))
+      end
+
+      sig { params(dir: String).void }
+      def working_dir(dir)
+        setup_phase.working_dir = dir
+      end
+
+      sig { params(env: String).void }
+      def rails_env(env)
+        setup_phase.rails_env = env
+      end
+
+      sig {
+        params(
+          package_name: Symbol,
+          version: T.nilable(String)
+        )
+        .void
+      }
+      def package(package_name, version = nil)
+        package_phase.add(package_name, version)
+      end
+
+      sig { params(distro_name: Symbol).void }
+      def distro(distro_name)
+        metadata.distro = distro_name
+        @distro_spec = nil
+      end
+
+      sig { params(port: String).void }
+      def port(port)
+        webserver_phase.port = port
+      end
+
+      sig {
+        params(
+          name: Symbol,
+          layer: T.nilable(Layer),
+          block: T.nilable(T.proc.params(df: Dockerfile).void)
+        )
+        .void
+      }
+      def use(name, layer = nil, &block)
+        layer_stack.use(name, layer, &block)
+      end
+
+      sig {
+        params(
+          name: Symbol,
+          layer: T.nilable(T.any(Layer, T::Hash[Symbol, T.untyped])),
+          options: T::Hash[Symbol, T.untyped],
+          block: T.nilable(T.proc.params(df: Dockerfile).void)
+        )
+        .void
+      }
+      def insert(name, layer = nil, options = {}, &block)
+        layer_stack.insert(name, layer, options, &block)
+      end
+
+      sig { params(name: Symbol).void }
+      def delete(name)
+        layer_stack.delete(name)
+      end
+
+      sig { params(name: Symbol).returns(T::Boolean) }
+      def exists?(name)
+        layer_stack.includes?(name)
+      end
+
+      sig { returns(Dockerfile) }
+      def to_dockerfile
+        Dockerfile.new.tap do |df|
+          layer_stack.each { |layer| layer.apply_to(df) }
+          df.cmd("#{distro_spec.shell_exe} -c 'while test 1; do sleep 5; done'")
+        end
+      end
+
+      sig { returns(SetupPhase) }
+      def setup_phase
+        @setup_phase ||= SetupPhase.new(environment)
+      end
+
+      sig { returns(PackagePhase) }
+      def package_phase
+        @package_phase ||= PackagePhase.new(environment)
+      end
+
+      sig { returns(WebserverDevPhase) }
+      def webserver_phase
+        @webserver_phase ||= WebserverDevPhase.new(environment)
+      end
+
+      sig { returns(Metadata) }
+      def metadata
+        @metadata ||= Metadata.new(environment)
+      end
+
+      sig { returns(Distro) }
+      def distro_spec
+        @distro_spec ||= if distro_klass = Kuby.distros[metadata.distro]
+          distro_klass.new(self)
+        else
+          raise MissingDistroError, "distro '#{metadata.distro}' hasn't been registered"
+        end
+      end
+
+      sig { returns(String) }
+      def tag
+        t = ENV.fetch('KUBY_DOCKER_TAG') do
+          tags.latest_timestamp_tag
+        end
+
+        unless t
+          raise MissingTagError, 'could not find latest timestamped tag'
+        end
+
+        t.to_s
+      end
+
+      sig { params(current_tag: String).returns(String) }
+      def previous_tag(current_tag)
+        raise MissingTagError, 'cannot roll back in the development environment'
+      end
+
+      sig { returns(CLI) }
+      def cli
+        @cli ||= Docker::CLI.new
+      end
+
+      private
+
+      sig { returns(LocalTags) }
+      def tags
+        @tags ||= LocalTags.new(cli, metadata)
+      end
+
+      sig { returns(Docker::LayerStack) }
+      def layer_stack
+        @layer_stack ||= Docker::LayerStack.new.tap do |stack|
+          stack.use(:setup_phase, setup_phase)
+          stack.use(:package_phase, package_phase)
+          stack.use(:webserver_phase, webserver_phase)
+        end
+      end
+    end
+  end
+end