kuby-core 0.11.16 → 0.15.0

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

@@ -47,27 +47,23 @@ module Kuby
             environment.kubernetes.plugins[@database.plugin_name] = @database.plugin
             environment.kubernetes.add_plugin(:kube_db)
 
-            unless environment.development?
-              environment.docker do
-                insert :rewrite_db_config, RewriteDbConfig.new, after: :copy_phase
-              end
+            environment.docker do
+              insert :rewrite_db_config, RewriteDbConfig.new, after: :copy_phase
             end
           end
 
-          unless environment.development?
-            environment.kubernetes.add_plugin(:nginx_ingress)
-            environment.kubernetes.add_plugin(:rails_assets) do
-              asset_url context.asset_url
-              packs_url context.packs_url
-              asset_path context.asset_path
-            end
+          environment.kubernetes.add_plugin(:nginx_ingress)
+          environment.kubernetes.add_plugin(:rails_assets) do
+            asset_url context.asset_url
+            packs_url context.packs_url
+            asset_path context.asset_path
+          end
 
-            if @tls_enabled
-              context = self
+          if @tls_enabled
+            context = self
 
-              environment.kubernetes.add_plugin(:cert_manager) do
-                email context.environment.docker.credentials.email
-              end
+            environment.kubernetes.add_plugin(:cert_manager) do
+              email context.environment.docker.credentials.email
             end
           end
         end
@@ -79,14 +75,13 @@ module Kuby
         def before_deploy(manifest)
           # Make sure plugin has been configured. If not, do nothing.
           if cert_manager = environment.kubernetes.plugin(:cert_manager)
-            cert_manager.annotate_ingress(ingress)
+            cert_manager.annotate_ingress(ingress) if tls_enabled
           end
 
-          image_with_tag = "#{docker.metadata.image_url}:#{kubernetes.tag}"
+          image_with_tag = "#{docker.image.image_url}:#{kubernetes.tag || Kuby::Docker::LATEST_TAG}"
 
           if assets = environment.kubernetes.plugin(:rails_assets)
             assets.configure_ingress(ingress, hostname)
-            assets.configure_deployment(deployment, image_with_tag)
           end
 
           spec = self
@@ -99,14 +94,12 @@ module Kuby
                     image image_with_tag
                   end
 
-                  unless spec.environment.development?
-                    init_container(:create_db) do
-                      image image_with_tag
-                    end
+                  init_container(:create_db) do
+                    image image_with_tag
+                  end
 
-                    init_container(:migrate_db) do
-                      image image_with_tag
-                    end
+                  init_container(:migrate_db) do
+                    image image_with_tag
                   end
                 end
               end
@@ -248,7 +241,7 @@ module Kuby
               annotations do
                 add(
                   'getkuby.io/dockerfile-checksum',
-                  kube_spec.environment.docker.to_dockerfile.checksum
+                  kube_spec.environment.docker.image.dockerfile.checksum
                 )
               end
             end
@@ -303,117 +296,57 @@ module Kuby
                       end
                     end
 
-                    unless kube_spec.environment.development?
-                      readiness_probe do
-                        success_threshold 1
-                        failure_threshold 2
-                        initial_delay_seconds 15
-                        period_seconds 3
-                        timeout_seconds 1
-
-                        http_get do
-                          path '/healthz'
-                          port kube_spec.docker.webserver_phase.port
-                          scheme 'HTTP'
-                        end
-                      end
-                    end
-
-                    if kube_spec.environment.development?
-                      env do
-                        name 'BUNDLE_PATH'
-                        value '/bundle'
-                      end
-
-                      env do
-                        name 'GEM_HOME'
-                        value '/bundle'
-                      end
-
-                      env do
-                        name 'BOOTSNAP_CACHE_DIR'
-                        value '/usr/src/bootsnap'
-                      end
-
-                      volume_mount do
-                        name "#{kube_spec.selector_app}-code"
-                        mount_path '/usr/src/app'
-                      end
-
-                      volume_mount do
-                        name "#{kube_spec.selector_app}-bundle"
-                        mount_path '/bundle'
-                      end
-
-                      volume_mount do
-                        name "#{kube_spec.selector_app}-bootsnap"
-                        mount_path '/usr/src/bootsnap'
+                    readiness_probe do
+                      success_threshold 1
+                      failure_threshold 2
+                      initial_delay_seconds 15
+                      period_seconds 3
+                      timeout_seconds 1
+
+                      http_get do
+                        path '/healthz'
+                        port kube_spec.docker.webserver_phase.port
+                        scheme 'HTTP'
                       end
                     end
                   end
 
-                  if kube_spec.environment.development?
-                    volume do
-                      name "#{kube_spec.selector_app}-code"
+                  init_container(:create_db) do
+                    name "#{kube_spec.selector_app}-create-db"
+                    command %w(bundle exec rake kuby:rails_app:db:create_unless_exists)
 
-                      persistent_volume_claim do
-                        claim_name kube_spec.code_volume_claim.metadata.name
+                    env_from do
+                      config_map_ref do
+                        name kube_spec.config_map.metadata.name
                       end
                     end
 
-                    volume do
-                      name "#{kube_spec.selector_app}-bundle"
-
-                      persistent_volume_claim do
-                        claim_name kube_spec.bundle_volume_claim.metadata.name
+                    env_from do
+                      secret_ref do
+                        name kube_spec.app_secrets.metadata.name
                       end
                     end
+                  end
 
-                    volume do
-                      name "#{kube_spec.selector_app}-bootsnap"
+                  init_container(:migrate_db) do
+                    name "#{kube_spec.selector_app}-migrate-db"
+                    command %w(bundle exec rake db:migrate)
 
-                      persistent_volume_claim do
-                        claim_name kube_spec.bootsnap_volume_claim.metadata.name
-                      end
-                    end
-                  else
-                    init_container(:create_db) do
-                      name "#{kube_spec.selector_app}-create-db"
-                      command %w(bundle exec rake kuby:rails_app:db:create_unless_exists)
-
-                      env_from do
-                        config_map_ref do
-                          name kube_spec.config_map.metadata.name
-                        end
-                      end
-
-                      env_from do
-                        secret_ref do
-                          name kube_spec.app_secrets.metadata.name
-                        end
+                    env_from do
+                      config_map_ref do
+                        name kube_spec.config_map.metadata.name
                       end
                     end
 
-                    init_container(:migrate_db) do
-                      name "#{kube_spec.selector_app}-migrate-db"
-                      command %w(bundle exec rake db:migrate)
-
-                      env_from do
-                        config_map_ref do
-                          name kube_spec.config_map.metadata.name
-                        end
-                      end
-
-                      env_from do
-                        secret_ref do
-                          name kube_spec.app_secrets.metadata.name
-                        end
+                    env_from do
+                      secret_ref do
+                        name kube_spec.app_secrets.metadata.name
                       end
                     end
+                  end
 
-                    image_pull_secret do
-                      name kube_spec.environment.kubernetes.registry_secret.metadata.name
-                    end
+                  image_pull_secret do
+                    name kube_spec.environment.kubernetes.registry_secret.metadata.name
                   end
 
                   restart_policy 'Always'
@@ -470,118 +403,6 @@ module Kuby
           @ingress
         end
 
-        def code_volume(&block)
-          spec = self
-
-          if environment.development?
-            @code_volume ||= KubeDSL.persistent_volume do
-              metadata do
-                name "#{spec.selector_app}-code"
-              end
-
-              spec do
-                access_modes ['ReadWriteMany']
-
-                capacity do
-                  add :storage, '1Mi'
-                end
-
-                host_path do
-                  path File.expand_path(spec.root)
-                end
-
-                storage_class_name 'hostpath'
-              end
-            end
-
-            @code_volume.instance_eval(&block) if block
-            @code_volume
-          end
-        end
-
-        def code_volume_claim(&block)
-          spec = self
-
-          if environment.development?
-            @code_volume_claim ||= KubeDSL.persistent_volume_claim do
-              metadata do
-                name "#{spec.selector_app}-code"
-                namespace spec.namespace.metadata.name
-              end
-
-              spec do
-                access_modes ['ReadWriteMany']
-
-                resources do
-                  requests do
-                    add :storage, '1Mi'
-                  end
-                end
-
-                storage_class_name 'hostpath'
-                volume_name spec.code_volume.metadata.name
-              end
-            end
-
-            @code_volume_claim.instance_eval(&block) if block
-            @code_volume_claim
-          end
-        end
-
-        def bundle_volume_claim(&block)
-          spec = self
-
-          if environment.development?
-            @bundle_volume_claim ||= KubeDSL.persistent_volume_claim do
-              metadata do
-                name "#{spec.selector_app}-bundle"
-                namespace spec.namespace.metadata.name
-              end
-
-              spec do
-                access_modes ['ReadWriteMany']
-                storage_class_name 'hostpath'
-
-                resources do
-                  requests do
-                    add :storage, '2Gi'
-                  end
-                end
-              end
-            end
-
-            @bundle_volume_claim.instance_eval(&block) if block
-            @bundle_volume_claim
-          end
-        end
-
-        def bootsnap_volume_claim(&block)
-          spec = self
-
-          if environment.development?
-            @bootsnap_volume_claim ||= KubeDSL.persistent_volume_claim do
-              metadata do
-                name "#{spec.selector_app}-bootsnap"
-                namespace spec.namespace.metadata.name
-              end
-
-              spec do
-                access_modes ['ReadWriteMany']
-                storage_class_name 'hostpath'
-
-                resources do
-                  requests do
-                    add :storage, '2Gi'
-                  end
-                end
-              end
-            end
-
-            @bootsnap_volume_claim.instance_eval(&block) if block
-            @bootsnap_volume_claim
-          end
-        end
-
         def resources
           @resources ||= [
             service,
@@ -590,10 +411,6 @@ module Kuby
             app_secrets,
             deployment,
             ingress,
-            code_volume,
-            code_volume_claim,
-            bundle_volume_claim,
-            bootsnap_volume_claim,
             *database&.plugin&.resources
           ]
         end

data/lib/kuby/plugins/rails_app.rb

@@ -3,6 +3,7 @@ module Kuby
   module Plugins
     module RailsApp
       autoload :AssetCopyTask,   'kuby/plugins/rails_app/asset_copy_task'
+      autoload :AssetsImage,     'kuby/plugins/rails_app/assets_image'
       autoload :Assets,          'kuby/plugins/rails_app/assets'
       autoload :Database,        'kuby/plugins/rails_app/database'
       autoload :MySQL,           'kuby/plugins/rails_app/mysql'

data/lib/kuby/tasks.rb

@@ -9,65 +9,57 @@ module Kuby
       @environment = environment
     end
 
-    def print_dockerfile
-      theme = Rouge::Themes::Base16::Solarized.new
-      formatter = Rouge::Formatters::Terminal256.new(theme)
-      lexer = Rouge::Lexers::Docker.new
-      tokens = lexer.lex(Kuby.environment.docker.to_dockerfile.to_s)
-      puts formatter.format(tokens)
+    def print_dockerfiles(only = nil)
+      kubernetes.docker_images.each do |image|
+        next if only && image.identifier != only
+
+        image = image.current_version
+        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
+        tokens = lexer.lex(image.dockerfile.to_s)
+        puts formatter.format(tokens)
+      end
     end
 
     def setup
       environment.kubernetes.setup
     end
 
-    def build
-      build_args = {}
+    def build(build_args = {}, docker_args = [], only = nil)
+      check_platform(docker_args)
 
-      unless ENV.fetch('RAILS_MASTER_KEY', '').empty?
-        build_args['RAILS_MASTER_KEY'] = ENV['RAILS_MASTER_KEY']
-      end
+      kubernetes.docker_images.each do |image|
+        next if only && image.identifier != only
 
-      docker.cli.build(
-        dockerfile: docker.to_dockerfile,
-        image_url:  docker.metadata.image_url,
-        tags:       docker.metadata.tags,
-        build_args: build_args
-      )
-    end
+        return unless perform_docker_login_if_necessary(image)
 
-    def push
-      if environment.development?
-        fail 'Cannot push Docker images built for the development environment'
+        image = image.new_version
+        Kuby.logger.info("Building image #{image.image_url} with tags #{image.tags.join(', ')}")
+        image.build(build_args, docker_args)
       end
+    end
 
-      host = docker.metadata.image_host
-
-      if docker.credentials.username && !docker.cli.auths.include?(host)
-        Kuby.logger.info("Attempting to log in to registry at #{host}")
+    def push(only = nil)
+      kubernetes.docker_images.each do |image|
+        next if only && image.identifier != only
 
-        begin
-          docker.cli.login(
-            url: docker.metadata.image_host,
-            username: docker.credentials.username,
-            password: docker.credentials.password
-          )
-        rescue Kuby::Docker::LoginError => e
-          Kuby.logger.fatal("Couldn't log in to the registry at #{host}")
-          Kuby.logger.fatal(e.message)
-          return
-        end
+        image = image.current_version
+        Kuby.logger.info("Pushing image #{image.image_url} with tags #{image.tags.join(', ')}")
+        push_image(image)
       end
+    end
 
-      image_url = docker.metadata.image_url
+    def push_image(image)
+      return unless perform_docker_login_if_necessary(image)
 
       begin
-        docker.tags.local.latest_tags.each do |tag|
-          docker.cli.push(image_url, tag)
-        end
+        image.tags.each { |tag| image.push(tag) }
       rescue Kuby::Docker::MissingTagError => e
         msg = "#{e.message} Run kuby build to build the "\
-          'Docker image before running this task.'
+          'Docker images before running this task.'
 
         Kuby.logger.fatal(msg)
         Kuby.logger.fatal(e.message)
@@ -82,10 +74,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
@@ -135,42 +133,73 @@ module Kuby
       kubernetes_cli.restart_deployment(namespace, deployment)
     end
 
-    def dev_deployment_ok
-      return true unless Kuby.environment.development?
+    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 perform_docker_login_if_necessary(image)
+      auth_uris = image.docker_cli.auths.map do |url|
+        Kuby::Docker::DockerURI.parse_uri(url)
+      end
 
-      deployments = kubernetes_cli.get_objects(
-        'deployments', namespace, match_labels.serialize
+      logged_in = image.credentials.username && (
+        auth_uris.any? do |uri|
+          image.image_hostname == uri.host ||
+            image.registry_index_hostname == uri.host
+        end
       )
 
-      if deployments.empty?
-        puts 'No development environment detected.'
-        STDOUT.write('Set up development environment? (y/n): ')
-        answer = STDIN.gets.strip.downcase
-        return false unless answer =~ /ye?s?/
-        return DevSetup.new(environment).run
-      else
-        depl = deployments.first
-        deployed_checksum = depl.dig('metadata', 'annotations', 'getkuby.io/dockerfile-checksum')
-        current_checksum = docker.to_dockerfile.checksum
-
-        if deployed_checksum != current_checksum
-          puts "Development environment appears to be out-of-date."
-          puts "Environment checksum: #{deployed_checksum}"
-          puts "Current checksum:     #{current_checksum}"
-          STDOUT.write('Update development environment? (y/n): ')
-          answer = STDIN.gets.strip.downcase
-          # return true here to prevent letting an out-of-date deployment
-          # stop us from running commands
-          return true unless answer =~ /ye?s?/
-          return DevSetup.new(environment).run
+      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
 
-    private
-
     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.11.16'.freeze
+  VERSION = '0.15.0'.freeze
 end

data/lib/kuby.rb

@@ -13,7 +13,6 @@ module Kuby
   autoload :CLIBase,        'kuby/cli_base'
   autoload :Commands,       'kuby/commands'
   autoload :Definition,     'kuby/definition'
-  autoload :DevSetup,       'kuby/dev_setup'
   autoload :Docker,         'kuby/docker'
   autoload :Environment,    'kuby/environment'
   autoload :Kubernetes,     'kuby/kubernetes'
@@ -21,7 +20,6 @@ module Kuby
   autoload :Plugin,         'kuby/plugin'
   autoload :PluginRegistry, 'kuby/plugin_registry'
   autoload :Plugins,        'kuby/plugins'
-  autoload :RailsCommands,  'kuby/rails_commands'
   autoload :Tasks,          'kuby/tasks'
   autoload :TrailingHash,   'kuby/trailing_hash'
 
@@ -52,24 +50,6 @@ module Kuby
       @definition = Definition.new(name.to_s)
       @definition.instance_eval(&block)
 
-      # default development environment
-      @definition.environment(:development) do
-        kubernetes do
-          add_plugin(:rails_app) do
-            tls_enabled false
-
-            database do
-              if requires_credentials?
-                user(DEFAULT_DB_USER)
-                password(DEFAULT_DB_PASSWORD)
-              end
-            end
-          end
-
-          provider :docker_desktop
-        end
-      end
-
       @definition.environments.each do |_, env|
         env.kubernetes.after_configuration
       end
@@ -174,3 +154,5 @@ Kuby.register_package(:c_toolchain,
   debian: 'build-essential',
   alpine: 'build-base'
 )
+
+Kuby.register_package(:git, 'git')