kuby-core 0.13.0 → 0.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a443b66d4dff19f6a2112b6365a9579b0490b049ef51ab612ad9e6cf4a807901
-  data.tar.gz: 2b38151be094c758a64ecdc95c585f184f4e9eea1affbdc4d071cc7a20d499a0
+  metadata.gz: 5cbd792443dc33de6a20d02f6969f6d59d535f1b68fb75c9a8945615fd870a28
+  data.tar.gz: 3add1ef85d6758a2590d35d7aa0bfb4fffaeae55ef6567a34cf3b7557a56e55a
 SHA512:
-  metadata.gz: 6cf93a88bc24ab142fa497daddc7227d417c138391f46db6f5b77a862c96e9c2733d880eded21d464170963902364ac0f2806f84cd083d0a5b408231987bcf2b
-  data.tar.gz: dab2dcd180ff19421ef44aef1a3384e1faa0b49511925e6557d54500a652a5c854217a8c463cd738cd6a745b2eb1804262e35539635fdb4d98ed13d2abc90aa2
+  metadata.gz: 7d855f57aae01d93c2fa44e285ee417ebcc00f12de6f9c4b989a39626ec9ec13a4659eafe0b8924592de5d860666158376e5adbf69c70373703eb2a9074ca75d
+  data.tar.gz: dc553aa0b22e5ab262fa18fa1a60bebb421862eab7e747e06c63907fefe8f5371be56415d0bde2e959ffa775140b624aee3aa53006f1dbee272122c87bf53cc6

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## 0.16.1
+* Fix a few bugs caused by leaving `continue-on-error: true` in the GitHub actions config 🤦
+  - Docker builds would fail if no previous images existed in the registry.
+  - The assets image would fail to build because `RAILS_MASTER_KEY` was not propagated correctly.
+* Use the kuby-prebundler gem in the integration tests instead of a custom layer.
+
+## 0.16.0
+* Allow Bundler executable to be customized.
+  - Main use-case is to allow adding in the Prebundler plugin, https://github.com/getkuby/kuby-prebundler.
+* Print error message and exit on missing Docker build args.
+  - Ignore with `--ignore-missing-args`.
+
+## 0.15.0
+* Add an extra parameter to the Docker spec for specifying the URL of the Docker registry index.
+  - In most cases, the registry and registry index URLs will be the same. However Docker Hub, the default registry, uses index.docker.io for API requests (catalog, tags, etc) but only allows pushes to docker.io.
+* Add config/master.key to the .dockerignore created by the Rails generator.
+  - This was an unfortunate oversight, but such are the perils of using pre-1.0 software.
+* Print an error message if building images on non-x86 hardware.
+  - People with M1 Macs are running into mismatches between their laptop's arch and the arch of their hosting provider's hardware. The error message asks you to explicitly pass the `--platform` flag to Docker.
+  - We may need to revisit this in the future if ARM processors become more popular.
+
+## 0.14.0
+* Make RAILS_MASTER_KEY available in the assets image (@palkan, #63)
+* Allow specifying custom docker build options via CLI (@palkan, #65)
+
 ## 0.13.0
 * Fix handling rails/rake options in remote exec (@palkan, #60)
 * Add `bundler_phase.gemfiles(*paths)` to allow adding additional gemfiles (@palkan, #61)

data/lib/kuby/commands.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: false
 
 require 'kuby/version'
 require 'gli'
@@ -65,23 +65,32 @@ module Kuby
     desc 'Builds the Docker image.'
     command :build do |c|
       c.flag [:a, :arg], required: false, multiple: true
-      c.action do |global_options, options, args|
+      c.switch [:'ignore-missing-args'], required: false, default: false
+      c.flag [:only], required: false
+      c.flag [:c, :context], required: false
+      c.action do |global_options, options, docker_args|
         build_args = {}.tap do |build_args|
           (options[:arg] || []).each do |a|
-            key, value = a.split('=')
+            key, value = a.split('=', 2)
             value = value[1..-2] if value.start_with?('"') || value.start_with?("'")
             build_args[key] = value
           end
         end
 
-        tasks.build(build_args)
+        tasks.build(
+          build_args, docker_args,
+          only: options[:only],
+          ignore_missing_args: options[:'ignore-missing-args'],
+          context: options[:context]
+        )
       end
     end
 
     desc 'Pushes the Docker image to the configured registry.'
     command :push do |c|
+      c.flag [:only], required: false
       c.action do |global_options, options, args|
-        tasks.push
+        tasks.push(only: options[:only])
       end
     end
 
@@ -94,8 +103,9 @@ module Kuby
 
     desc 'Prints the effective Dockerfiles used to build Docker images.'
     command :dockerfiles do |c|
+      c.flag [:only], required: false
       c.action do |global_options, options, args|
-        tasks.print_dockerfiles
+        tasks.print_dockerfiles(only: options[:only])
       end
     end
 
@@ -117,8 +127,10 @@ module Kuby
 
     desc 'Prints the effective Kubernetes resources that will be applied on deploy.'
     command :resources do |c|
+      c.flag [:K, :kind], required: false
+      c.flag [:N, :name], required: false
       c.action do |global_options, options, args|
-        tasks.print_resources
+        tasks.print_resources(options[:kind], options[:name])
       end
     end
 
@@ -165,7 +177,7 @@ module Kuby
       rc.desc 'Runs an arbitrary command inside a running Rails pod.'
       rc.command :exec do |c|
         c.action do |global_options, options, args|
-          tasks.remote_exec([*args, *@rails_options])
+          tasks.remote_exec([*args, *T.unsafe(@rails_options)])
         end
       end
 

data/lib/kuby/docker/app_image.rb

@@ -6,13 +6,19 @@ module Kuby
     class AppImage < ::Kuby::Docker::TimestampedImage
       extend T::Sig
 
-      sig { params(build_args: T::Hash[String, String]).returns(AppImage) }
-      def build(build_args = {})
-        unless ENV.fetch('RAILS_MASTER_KEY', '').empty?
-          build_args['RAILS_MASTER_KEY'] = T.must(ENV['RAILS_MASTER_KEY'])
-        end
-
-        super(build_args)
+      sig {
+        params(
+          dockerfile: T.any(Dockerfile, T.proc.returns(Dockerfile)),
+          image_url: String,
+          credentials: Credentials,
+          registry_index_url: T.nilable(String),
+          main_tag: T.nilable(String),
+          alias_tags: T::Array[String]
+        ).void
+      }
+      def initialize(dockerfile, image_url, credentials, registry_index_url = nil, main_tag = nil, alias_tags = [])
+        super
+        @identifier = "app"
       end
     end
   end

data/lib/kuby/docker/bundler_phase.rb

@@ -29,6 +29,12 @@ module Kuby
       sig { params(without: T::Array[String]).void }
       attr_writer :without
 
+      sig { returns(T.nilable(String)) }
+      attr_reader :executable
+
+      sig { params(executable: String).void }
+      attr_writer :executable
+
       sig { params(environment: Environment).void }
       def initialize(environment)
         super
@@ -37,6 +43,7 @@ module Kuby
         @gemfile = T.let(@gemfile, T.nilable(String))
         @gemfiles = T.let([], T::Array[String])
         @without = T.let(@without, T.nilable(T::Array[String]))
+        @executable = T.let(@executable, T.nilable(String))
       end
 
       sig { override.params(dockerfile: Dockerfile).void }
@@ -61,14 +68,14 @@ module Kuby
         end
 
         dockerfile.run(
-          'bundle', 'install',
+          executable || 'bundle', 'install',
           '--jobs', '$(nproc)',
           '--retry', '3',
           '--gemfile', gf
         )
 
         # generate binstubs and add the bin directory to our path
-        dockerfile.run('bundle', 'binstubs', '--all')
+        dockerfile.run(executable || 'bundle', 'binstubs', '--all')
         dockerfile.env("PATH=./bin:$PATH")
       end
 

data/lib/kuby/docker/cli.rb

@@ -53,15 +53,24 @@ module Kuby
         config.fetch('auths', {}).keys
       end
 
-      sig { params(image: Image, build_args: T::Hash[T.any(Symbol, String), String]).void }
-      def build(image, build_args: {})
+      sig {
+        params(
+          image: Image,
+          build_args: T::Hash[T.any(Symbol, String), String],
+          docker_args: T::Array[String],
+          context: T.nilable(String)
+        ).void
+      }
+      def build(image, build_args: {}, docker_args: [], context: nil)
         cmd = [
           executable, 'build',
           *image.tags.flat_map { |tag| ['-t', "#{image.image_url}:#{tag}"] },
           *build_args.flat_map do |arg, val|
             ['--build-arg', Shellwords.shellescape("#{arg}=#{val}")]
           end,
-          '-f-', '.'
+          '-f-',
+          *docker_args,
+          context || '.'
         ]
 
         open3_w(cmd) do |stdin, _wait_threads|

data/lib/kuby/docker/docker_uri.rb

@@ -5,11 +5,36 @@ module Kuby
     class DockerURI
       extend T::Sig
 
-      DEFAULT_REGISTRY_HOST = T.let('index.docker.io'.freeze, String)
-      DEFAULT_REGISTRY_PORT = T.let(443, Integer)
+      DEFAULT_REGISTRY_HOST = T.let('docker.io'.freeze, String)
+      DEFAULT_REGISTRY_INDEX_HOST = T.let('index.docker.io'.freeze, String)
+      DEFAULT_PORT = T.let(443, Integer)
 
       sig { params(url: String).returns(DockerURI) }
-      def self.parse(url)
+      def self.parse_uri(url)
+        parse(
+          url,
+          default_host: DEFAULT_REGISTRY_HOST,
+          default_port: DEFAULT_PORT
+        )
+      end
+
+      sig { params(url: String).returns(DockerURI) }
+      def self.parse_index_uri(url)
+        parse(
+          url,
+          default_host: DEFAULT_REGISTRY_INDEX_HOST,
+          default_port: DEFAULT_PORT
+        )
+      end
+
+      sig {
+        params(
+          url: String,
+          default_host: T.nilable(String),
+          default_port: T.nilable(Integer)
+        ).returns(DockerURI)
+      }
+      def self.parse(url, default_host:, default_port:)
         if idx = url.index('://')
           url = url[(idx + 3)..-1] || ''
         end
@@ -17,9 +42,9 @@ module Kuby
         host_port, *path = url.split('/')
         host, port, *path = if host_port =~ /[.:]/
           hst, prt = T.must(host_port).split(':')
-          [T.must(hst), prt || DEFAULT_REGISTRY_PORT, *path]
+          [T.must(hst), prt || default_port, *path]
         else
-          [DEFAULT_REGISTRY_HOST, DEFAULT_REGISTRY_PORT, host_port, *path]
+          [default_host, default_port, host_port, *path]
         end
 
         new(host.to_s, port.to_i, (path || []).join('/'))
@@ -40,6 +65,11 @@ module Kuby
         @port = port
         @path = path
       end
+
+      sig { returns(T::Boolean) }
+      def has_default_port?
+        port == DEFAULT_PORT
+      end
     end
   end
 end

data/lib/kuby/docker/image.rb

@@ -5,9 +5,15 @@ module Kuby
     class Image
       extend T::Sig
 
+      sig { returns(T.nilable(String)) }
+      attr_reader :identifier
+
       sig { returns(String) }
       attr_reader :image_url
 
+      sig { returns(T.nilable(String)) }
+      attr_reader :registry_index_url
+
       sig { returns(Credentials) }
       attr_reader :credentials
 
@@ -22,19 +28,25 @@ module Kuby
           dockerfile: T.any(Dockerfile, T.proc.returns(Dockerfile)),
           image_url: String,
           credentials: Credentials,
+          registry_index_url: T.nilable(String),
           main_tag: T.nilable(String),
           alias_tags: T::Array[String]
         ).void
       }
-      def initialize(dockerfile, image_url, credentials, main_tag = nil, alias_tags = [])
+      def initialize(dockerfile, image_url, credentials, registry_index_url = nil, main_tag = nil, alias_tags = [])
         @dockerfile = T.let(dockerfile, T.any(Dockerfile, T.proc.returns(Dockerfile)))
         @image_url = T.let(image_url, String)
+        @registry_index_url = T.let(registry_index_url, T.nilable(String))
         @credentials = T.let(credentials, Credentials)
         @main_tag = T.let(main_tag, T.nilable(String))
         @alias_tags = T.let(alias_tags, T::Array[String])
+        @identifier = T.let(@identifier, T.nilable(String))
 
         @image_host = T.let(@image_host, T.nilable(String))
         @image_hostname = T.let(@image_hostname, T.nilable(String))
+        @registry_index_host = T.let(@registry_index_host, T.nilable(String))
+        @registry_index_hostname = T.let(@registry_index_hostname, T.nilable(String))
+        @registry_index_uri = T.let(@registry_index_uri, T.nilable(DockerURI))
         @image_repo = T.let(@image_repo, T.nilable(String))
         @full_image_uri = T.let(@full_image_uri, T.nilable(DockerURI))
         @docker_cli = T.let(@docker_cli, T.nilable(Docker::CLI))
@@ -69,6 +81,16 @@ module Kuby
         @image_host ||= "#{image_uri.host}:#{image_uri.port}"
       end
 
+      sig { returns(String) }
+      def registry_index_host
+        @registry_index_host ||= "#{registry_index_uri.host}:#{registry_index_uri.port}"
+      end
+
+      sig { returns(String) }
+      def registry_index_hostname
+        @registry_index_hostname ||= registry_index_uri.host
+      end
+
       sig { returns(String) }
       def image_hostname
         @image_hostname ||= image_uri.host
@@ -81,7 +103,12 @@ module Kuby
 
       sig { returns(DockerURI) }
       def image_uri
-        @full_image_uri ||= DockerURI.parse(image_url)
+        @full_image_uri ||= DockerURI.parse_uri(image_url)
+      end
+
+      sig { returns(DockerURI) }
+      def registry_index_uri
+        @registry_index_uri ||= DockerURI.parse_index_uri(registry_index_url || image_url)
       end
 
       sig { returns(T::Array[String]) }
@@ -89,8 +116,8 @@ module Kuby
         [main_tag, *alias_tags].compact
       end
 
-      sig { params(build_args: T::Hash[String, String]).void }
-      def build(build_args = {})
+      sig { params(build_args: T::Hash[String, String], docker_args: T::Array[String], context: T.nilable(String)).void }
+      def build(build_args = {}, docker_args = [], context: nil)
         raise NotImplementedError, 'please use a Docker::Image subclass'
       end
 
@@ -108,7 +135,7 @@ module Kuby
 
       sig { params(main_tag: String, alias_tags: T::Array[String]).returns(Image) }
       def duplicate_with_tags(main_tag, alias_tags)
-        self.class.new(dockerfile, image_url, credentials, main_tag, alias_tags)
+        self.class.new(dockerfile, image_url, credentials, registry_index_url, main_tag, alias_tags)
       end
     end
   end

data/lib/kuby/docker/spec.rb

@@ -13,6 +13,9 @@ module Kuby
       sig { returns(T.nilable(String)) }
       attr_reader :image_url_str
 
+      sig { returns(T.nilable(String)) }
+      attr_reader :registry_index_url_str
+
       sig { params(environment: Environment).void }
       def initialize(environment)
         @environment = environment
@@ -31,6 +34,7 @@ module Kuby
         @layer_stack = T.let(@layer_stack, T.nilable(Kuby::Docker::LayerStack))
 
         @image_url_str = T.let(@image_url_str, T.nilable(String))
+        @registry_index_url_str = T.let(@registry_index_url_str, T.nilable(String))
         @image = T.let(@image, T.nilable(Docker::AppImage))
       end
 
@@ -96,6 +100,11 @@ module Kuby
         @image_url_str = url
       end
 
+      sig { params(url: String).void }
+      def registry_index_url(url)
+        @registry_index_url_str = url
+      end
+
       sig {
         params(
           name: Symbol,
@@ -148,7 +157,7 @@ module Kuby
           end
 
           Docker::AppImage.new(
-            dockerfile, T.must(image_url_str), credentials
+            dockerfile, T.must(image_url_str), credentials, registry_index_url_str
           )
         end
       end

data/lib/kuby/docker/timestamped_image.rb

@@ -12,11 +12,12 @@ module Kuby
           dockerfile: T.any(Dockerfile, T.proc.returns(Dockerfile)),
           image_url: String,
           credentials: Credentials,
+          registry_index_url_str: T.nilable(String),
           main_tag: T.nilable(String),
           alias_tags: T::Array[String]
         ).void
       }
-      def initialize(dockerfile, image_url, credentials, main_tag = nil, alias_tags = [])
+      def initialize(dockerfile, image_url, credentials, registry_index_url_str = nil, main_tag = nil, alias_tags = [])
         @new_version = T.let(@new_version, T.nilable(Image))
         @current_version = T.let(@current_version, T.nilable(Image))
         @previous_version = T.let(@previous_version, T.nilable(Image))
@@ -30,16 +31,18 @@ module Kuby
 
       sig { returns(Image) }
       def new_version
-        @new_version ||= duplicate_with_tags(
-          TimestampTag.new(Time.now).to_s, [Kuby::Docker::LATEST_TAG]
-        )
+        @new_version ||= create_new_version
       end
 
       sig { returns(Image) }
       def current_version
-        @current_version ||= duplicate_with_tags(
-          latest_timestamp_tag.to_s, [Kuby::Docker::LATEST_TAG]
-        )
+        @current_version ||= begin
+          duplicate_with_tags(
+            latest_timestamp_tag.to_s, [Kuby::Docker::LATEST_TAG]
+          )
+        rescue MissingTagError
+          create_new_version
+        end
       end
 
       sig { params(current_tag: T.nilable(String)).returns(Image) }
@@ -73,9 +76,9 @@ module Kuby
         tag
       end
 
-      sig { params(build_args: T::Hash[String, String]).void }
-      def build(build_args = {})
-        docker_cli.build(new_version, build_args: build_args)
+      sig { params(build_args: T::Hash[String, String], docker_args: T::Array[String], context: T.nilable(String)).void }
+      def build(build_args = {}, docker_args = [], context: nil)
+        docker_cli.build(new_version, build_args: build_args, docker_args: docker_args, context: context)
         @current_version = new_version
         @new_version = nil
       end
@@ -87,10 +90,17 @@ module Kuby
 
       private
 
+      sig { returns(Image) }
+      def create_new_version
+        duplicate_with_tags(
+          TimestampTag.new(Time.now).to_s, [Kuby::Docker::LATEST_TAG]
+        )
+      end
+
       sig { returns(::Docker::Remote::Client) }
       def remote_client
         @remote_client ||= ::Docker::Remote::Client.new(
-          image_host, image_repo, credentials.username, credentials.password,
+          registry_index_host, image_repo, credentials.username, credentials.password,
         )
       end
 
@@ -106,7 +116,7 @@ module Kuby
 
       sig { returns(RemoteTags) }
       def remote
-        @remote ||= RemoteTags.new(remote_client, image_url)
+        @remote ||= RemoteTags.new(remote_client, registry_index_host)
       end
     end
   end

data/lib/kuby/plugins/rails_app/assets.rb

@@ -296,7 +296,7 @@ module Kuby
         end
 
         def image
-          @image ||= RailsApp::AssetsImage.new(docker.image, -> { dockerfile })
+          @image ||= RailsApp::AssetsImage.new(docker.image, -> { dockerfile }, docker.image.registry_index_url)
         end
 
         private
@@ -317,14 +317,16 @@ module Kuby
             tags.each_cons(2) do |prev_tag, tag|
               prev_image_name = "#{app_name}-#{prev_tag}"
               df.from("#{base_image.image_url}:#{prev_tag}", as: prev_image_name)
+              df.arg('RAILS_MASTER_KEY')
               df.run("mkdir -p #{RAILS_MOUNT_PATH}")
-              df.run("bundle exec rake kuby:rails_app:assets:copy")
+              df.run("env RAILS_MASTER_KEY=$RAILS_MASTER_KEY bundle exec rake kuby:rails_app:assets:copy")
 
               if tag
                 image_name = "#{app_name}-#{tag}"
                 df.from("#{base_image.image_url}:#{tag}", as: image_name)
+                df.arg('RAILS_MASTER_KEY')
                 df.copy("--from=#{prev_image_name} #{RAILS_MOUNT_PATH}", RAILS_MOUNT_PATH)
-                df.run("bundle exec rake kuby:rails_app:assets:copy")
+                df.run("env RAILS_MASTER_KEY=$RAILS_MASTER_KEY bundle exec rake kuby:rails_app:assets:copy")
               end
             end
 

data/lib/kuby/plugins/rails_app/assets_image.rb

@@ -4,9 +4,10 @@ module Kuby
       class AssetsImage < ::Kuby::Docker::Image
         attr_reader :base_image
 
-        def initialize(base_image, dockerfile, main_tag = nil, alias_tags = [])
-          super(dockerfile, base_image.image_url, base_image.credentials, main_tag, alias_tags)
+        def initialize(base_image, dockerfile, registry_index_url = nil, main_tag = nil, alias_tags = [])
+          super(dockerfile, base_image.image_url, base_image.credentials, registry_index_url, main_tag, alias_tags)
           @base_image = base_image
+          @identifier = "assets"
         end
 
         def new_version
@@ -27,8 +28,8 @@ module Kuby
           )
         end
 
-        def build(build_args = {})
-          docker_cli.build(current_version, build_args: build_args)
+        def build(build_args = {}, docker_args = [], context: nil)
+          docker_cli.build(current_version, build_args: build_args, docker_args: docker_args, context: context)
         end
 
         def push(tag)
@@ -41,6 +42,7 @@ module Kuby
           self.class.new(
             base_image,
             dockerfile,
+            registry_index_url,
             annotate_tag(image.main_tag),
             image.alias_tags.map { |at| annotate_tag(at) }
           )

data/lib/kuby/plugins/rails_app/generators/kuby.rb

@@ -86,16 +86,38 @@ class KubyGenerator < Rails::Generators::Base
     create_file(
       '.dockerignore',
       <<~END
-        .bundle/
-        vendor/bundle
-        node_modules/
-        .node_modules/
-        **/.git*
-        tmp/
-        log/
-        engines/**/log/
-        engines/**/tmp/
+        .git/
+
+        # Ignore bundler config.
+        .bundle
+
+        # Ignore all logfiles and tempfiles.
+        log/*
+        tmp/*
+        !log/.keep
+        !tmp/.keep
+
+        # Ignore pidfiles, but keep the directory.
+        tmp/pids/*
+        !tmp/pids/
+        !tmp/pids/.keep
+
+        # Ignore uploaded files in development.
+        storage/*
+        !storage/.keep
+
         public/assets
+        **/.byebug_history
+
+        # Ignore master key for decrypting credentials and more.
+        config/master.key
+
+        public/packs
+        public/packs-test
+        node_modules
+        yarn-error.log
+        **/yarn-debug.log*
+        **/.yarn-integrity
       END
     )
   end

data/lib/kuby/tasks.rb

@@ -9,10 +9,13 @@ module Kuby
       @environment = environment
     end
 
-    def print_dockerfiles
+    def print_dockerfiles(only: nil)
       kubernetes.docker_images.each do |image|
+        next if only && image.identifier != only
+
         image = image.current_version
-        Kuby.logger.info("Dockerfile for image #{image.image_url} with tags #{image.tags.join(', ')}")
+        identifier = image.identifier ? " ##{image.identifier}" : ""
+        Kuby.logger.info("Dockerfile for#{identifier} image #{image.image_url} with tags #{image.tags.join(', ')}")
         theme = Rouge::Themes::Base16::Solarized.new
         formatter = Rouge::Formatters::Terminal256.new(theme)
         lexer = Rouge::Lexers::Docker.new
@@ -25,16 +28,31 @@ module Kuby
       environment.kubernetes.setup
     end
 
-    def build(build_args = {})
+    def build(build_args = {}, docker_args = [], only: nil, ignore_missing_args: false, context: nil)
+      check_platform(docker_args)
+
+      build_args['RAILS_MASTER_KEY'] ||= ENV['RAILS_MASTER_KEY'] || begin
+        master_key_file = File.join('config', 'master.key')
+        File.exist?(master_key_file) ? File.read(master_key_file).strip : nil
+      end
+
+      check_build_args(build_args) unless ignore_missing_args
+
       kubernetes.docker_images.each do |image|
+        next if only && image.identifier != only
+
+        return unless perform_docker_login_if_necessary(image)
+
         image = image.new_version
         Kuby.logger.info("Building image #{image.image_url} with tags #{image.tags.join(', ')}")
-        image.build(build_args)
+        image.build(build_args, docker_args, context: context)
       end
     end
 
-    def push
+    def push(only: nil)
       kubernetes.docker_images.each do |image|
+        next if only && image.identifier != only
+
         image = image.current_version
         Kuby.logger.info("Pushing image #{image.image_url} with tags #{image.tags.join(', ')}")
         push_image(image)
@@ -42,21 +60,7 @@ module Kuby
     end
 
     def push_image(image)
-      if image.credentials.username && !image.docker_cli.auths.include?(image.image_host)
-        Kuby.logger.info("Attempting to log in to registry at #{image.image_host}")
-
-        begin
-          image.docker_cli.login(
-            url: image.image_host,
-            username: image.credentials.username,
-            password: image.credentials.password
-          )
-        rescue Kuby::Docker::LoginError => e
-          Kuby.logger.fatal("Couldn't log in to the registry at #{image.image_host}")
-          Kuby.logger.fatal(e.message)
-          return
-        end
-      end
+      return unless perform_docker_login_if_necessary(image)
 
       begin
         image.tags.each { |tag| image.push(tag) }
@@ -77,10 +81,16 @@ module Kuby
       environment.kubernetes.rollback
     end
 
-    def print_resources
+    def print_resources(kind = nil, name_pattern = nil)
       kubernetes.before_deploy
 
+      name_rxp = Regexp.new(name_pattern) if name_pattern
+
       kubernetes.resources.each do |res|
+        next if kind && res.kind_sym.to_s != kind
+
+        next if name_rxp && !name_rxp.match?(res.metadata.name)
+
         puts res.to_resource.serialize.to_yaml
       end
     end
@@ -132,6 +142,106 @@ module Kuby
 
     private
 
+    def check_platform(docker_args)
+      arch, * = RUBY_PLATFORM.split('-')
+
+      if arch != 'x86_64' && !docker_args.include?('--platform')
+        Kuby.logger.fatal(<<~END)
+          Hey there! It looks like your processor isn't x86-compatible.
+          By default, Docker will try to build images that match the
+          current architecture, in this case #{arch}. Most hosting
+          providers run x86 hardware, meaning Docker images built using
+          this computer's architecture might fail to run when deployed
+          to production. You can fix this by running the build command
+          with a special --platform flag, eg:
+
+          bundle exec kuby -e production build -- --platform linux/amd64
+
+          If you meant to build for the current architecture, you can
+          prevent this error by passing the --platform argument for the
+          current architecture, eg. --platform linux/arm64 for ARM, etc.
+        END
+
+        exit 1
+      end
+    end
+
+    def check_build_args(build_args)
+      required_args = kubernetes.docker_images.flat_map do |image|
+        image.dockerfile.commands.flat_map do |command|
+          case command
+            when Kuby::Docker::Dockerfile::Arg
+              command.args
+            else
+              []
+          end
+        end
+      end
+
+      required_args.uniq!
+
+      if File.exist?(File.join('config', 'master.key'))
+        required_args.delete('RAILS_MASTER_KEY')
+      end
+
+      missing_args = required_args - build_args.keys
+
+      if missing_args.any?
+        Kuby.logger.fatal(<<~END)
+          The following Docker build arguments are missing: #{missing_args.join(', ')}.
+          Please pass each argument to `kuby build` using the -a or --arg parameter (note
+          that the -a/--arg parameter can be specified multiple times). For example:
+
+          kuby build -a #{missing_args.first}=value ...
+
+          To ignore missing build args, pass the --ignore-missing-args parameter.
+        END
+
+        exit 1
+      end
+    end
+
+    def perform_docker_login_if_necessary(image)
+      auth_uris = image.docker_cli.auths.map do |url|
+        Kuby::Docker::DockerURI.parse_uri(url)
+      end
+
+      logged_in = image.credentials.username && (
+        auth_uris.any? do |uri|
+          image.image_hostname == uri.host ||
+            image.registry_index_hostname == uri.host
+        end
+      )
+
+      if !logged_in
+        Kuby.logger.info("Attempting to log in to registry at #{image.image_host}")
+
+        begin
+          # For some reason, Docker login with a port doesn't work for some
+          # registries (most notably Docker Hub). Since the default is 443 anyway,
+          # it should be fine to omit it.
+          url = if image.image_uri.has_default_port?
+            image.image_hostname  # host without port
+          else
+            image.image_host      # host with port
+          end
+
+          image.docker_cli.login(
+            url: url,
+            username: image.credentials.username,
+            password: image.credentials.password
+          )
+        rescue Kuby::Docker::LoginError => e
+          Kuby.logger.fatal("Couldn't log in to the registry at #{image.image_host}")
+          Kuby.logger.fatal(e.message)
+
+          return false
+        end
+      end
+
+      true
+    end
+
     def get_first_pod
       pods = kubernetes_cli.get_objects(
         'pods', namespace, match_labels.serialize

data/lib/kuby/version.rb

@@ -1,5 +1,5 @@
 # typed: true
 
 module Kuby
-  VERSION = '0.13.0'.freeze
+  VERSION = '0.16.1'.freeze
 end

data/spec/docker/timestamped_image_spec.rb

@@ -19,8 +19,8 @@ describe Kuby::Docker::TimestampedImage do
     subject { image.current_version&.main_tag }
 
     context 'with no local or remote tags' do
-      it 'raises an error' do
-        expect { subject }.to raise_error(Kuby::Docker::MissingTagError)
+      it 'creates a new tag' do
+        expect(subject).to match(/\d{14}/)
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kuby-core
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.16.1
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-24 00:00:00.000000000 Z
+date: 2022-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize