kuby-core 0.11.16 → 0.12.0

data/lib/kuby/docker/timestamp_tag.rb

@@ -9,8 +9,15 @@ module Kuby
 
       FORMAT = T.let('%Y%m%d%H%M%S'.freeze, String)
 
-      sig { params(str: String).returns(T.nilable(TimestampTag)) }
+      sig { params(str: T.nilable(String)).returns(T.nilable(TimestampTag)) }
       def self.try_parse(str)
+        return nil unless str
+
+        # The strptime function stops scanning after the pattern has been matched, so
+        # we check for all numbers here to prevent things like 20210424165405-assets
+        # from being treated as a timestamp tag.
+        return nil unless str =~ /\A\d+\z/
+
         time = begin
           Time.strptime(str, FORMAT)
         rescue ArgumentError

data/lib/kuby/docker/timestamped_image.rb

@@ -0,0 +1,113 @@
+# typed: strict
+
+require 'docker/remote'
+
+module Kuby
+  module Docker
+    class TimestampedImage < Image
+      extend T::Sig
+
+      sig {
+        params(
+          dockerfile: T.any(Dockerfile, T.proc.returns(Dockerfile)),
+          image_url: String,
+          credentials: Credentials,
+          main_tag: T.nilable(String),
+          alias_tags: T::Array[String]
+        ).void
+      }
+      def initialize(dockerfile, image_url, credentials, 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))
+
+        @remote_client = T.let(@remote_client, T.nilable(::Docker::Remote::Client))
+        @local = T.let(@local, T.nilable(LocalTags))
+        @remote = T.let(@remote, T.nilable(RemoteTags))
+
+        super
+      end
+
+      sig { returns(Image) }
+      def new_version
+        @new_version ||= duplicate_with_tags(
+          TimestampTag.new(Time.now).to_s, [Kuby::Docker::LATEST_TAG]
+        )
+      end
+
+      sig { returns(Image) }
+      def current_version
+        @current_version ||= duplicate_with_tags(
+          latest_timestamp_tag.to_s, [Kuby::Docker::LATEST_TAG]
+        )
+      end
+
+      sig { params(current_tag: T.nilable(String)).returns(Image) }
+      def previous_version(current_tag = nil)
+        @previous_version ||= duplicate_with_tags(
+          previous_timestamp_tag(current_tag).to_s, []
+        )
+      end
+
+      sig { params(current_tag: T.nilable(String)).returns(TimestampTag) }
+      def previous_timestamp_tag(current_tag = nil)
+        current_tag = TimestampTag.try_parse(current_tag || latest_timestamp_tag.to_s)
+        raise MissingTagError, 'could not find current timestamp tag' unless current_tag
+
+        all_tags = timestamp_tags.sort
+
+        idx = all_tags.index do |tag|
+          tag.time == current_tag.time
+        end
+
+        idx ||= 0
+        raise MissingTagError, 'could not find previous timestamp tag' unless idx > 0
+
+        T.must(all_tags[idx - 1])
+      end
+
+      sig { returns(TimestampTag) }
+      def latest_timestamp_tag
+        tag = timestamp_tags.sort.last
+        raise MissingTagError, 'could not find latest timestamp tag' unless tag
+        tag
+      end
+
+      sig { params(build_args: T::Hash[String, String]).void }
+      def build(build_args = {})
+        docker_cli.build(new_version, build_args: build_args)
+        @current_version = new_version
+        @new_version = nil
+      end
+
+      sig { params(tag: String).void }
+      def push(tag)
+        docker_cli.push(image_url, tag)
+      end
+
+      private
+
+      sig { returns(::Docker::Remote::Client) }
+      def remote_client
+        @remote_client ||= ::Docker::Remote::Client.new(
+          image_host, image_repo, credentials.username, credentials.password,
+        )
+      end
+
+      sig { returns(T::Array[TimestampTag]) }
+      def timestamp_tags
+        (local.timestamp_tags + remote.timestamp_tags).uniq
+      end
+
+      sig { returns(LocalTags) }
+      def local
+        @local ||= LocalTags.new(docker_cli, image_url)
+      end
+
+      sig { returns(RemoteTags) }
+      def remote
+        @remote ||= RemoteTags.new(remote_client, image_url)
+      end
+    end
+  end
+end

data/lib/kuby/environment.rb

@@ -12,12 +12,7 @@ module Kuby
     end
 
     def docker(&block)
-      @docker ||= if development?
-        Docker::DevSpec.new(self)
-      else
-        Docker::Spec.new(self)
-      end
-
+      @docker ||= Docker::Spec.new(self)
       @docker.instance_eval(&block) if block
       @docker
     end
@@ -31,9 +26,5 @@ module Kuby
     def app_name
       definition.app_name
     end
-
-    def development?
-      name == 'development'
-    end
   end
 end

data/lib/kuby/kubernetes/bare_metal_provider.rb

@@ -1,10 +1,13 @@
-# typed: false
+# typed: strict
+
 require 'kube-dsl'
 
 module Kuby
   module Kubernetes
     class BareMetalProvider < Provider
-      STORAGE_CLASS_NAME = 'hostpath'.freeze
+      extend T::Sig
+
+      STORAGE_CLASS_NAME = T.let('hostpath'.freeze, String)
 
       class Config
         extend ::KubeDSL::ValueFields
@@ -12,25 +15,34 @@ module Kuby
         value_fields :kubeconfig
       end
 
+      sig { returns(Config) }
       attr_reader :config
 
+      sig { params(environment: Environment).void }
+      def initialize(environment)
+        @config = T.let(Config.new, Config)
+        super
+      end
+
+      sig { params(block: T.proc.void).void }
       def configure(&block)
         config.instance_eval(&block) if block
       end
 
+      sig { returns(String) }
       def kubeconfig_path
         config.kubeconfig
       end
 
+      sig { returns(String) }
       def storage_class_name
         STORAGE_CLASS_NAME
       end
 
       private
 
+      sig { void }
       def after_initialize
-        @config = Config.new
-
         configure do
           # default kubeconfig path
           kubeconfig File.join(ENV['HOME'], '.kube', 'config')

data/lib/kuby/kubernetes/deployer.rb

@@ -102,7 +102,7 @@ module Kuby
 
       def restart_rails_deployment_if_necessary
         deployed_image = nil
-        current_image = "#{docker.metadata.image_url}:#{docker.tag}"
+        current_image = "#{docker.image.image_url}:#{kubernetes.tag}"
 
         if rails_app = kubernetes.plugin(:rails_app)
           deployment_name = rails_app.deployment.metadata.name

data/lib/kuby/kubernetes/docker_desktop_provider.rb

@@ -18,21 +18,6 @@ module Kuby
         config.instance_eval(&block) if block
       end
 
-      def after_configuration
-        if rails_app = spec.plugin(:rails_app)
-          # Remove ingress and change service type from ClusterIP to
-          # LoadBalancer. No need to set up ingress for Docker Desktop
-          # since it handles all the localhost mapping, etc if you set
-          # up a service LB.
-          rails_app.resources.delete(rails_app.ingress)
-          rails_app.service.spec { type 'LoadBalancer' }
-        end
-
-        if assets = spec.plugin(:rails_assets)
-          assets.service.spec { type 'LoadBalancer' }
-        end
-      end
-
       def kubeconfig_path
         config.kubeconfig
       end

data/lib/kuby/kubernetes/spec.rb

@@ -72,7 +72,7 @@ module Kuby
       end
 
       def before_deploy
-        @tag ||= docker.tag
+        @tag ||= docker.image.current_version.main_tag
 
         provider.before_deploy(resources)
         @plugins.each { |_, plg| plg.before_deploy(resources) }
@@ -81,7 +81,7 @@ module Kuby
       end
 
       def after_deploy
-        @tag ||= docker.tag
+        @tag ||= docker.image.current_version.main_tag
 
         @plugins.each { |_, plg| plg.after_deploy(resources) }
         provider.after_deploy(resources)
@@ -144,24 +144,22 @@ module Kuby
       def registry_secret(&block)
         spec = self
 
-        unless environment.development?
-          @registry_secret ||= RegistrySecret.new do
-            metadata do
-              name "#{spec.selector_app}-registry-secret"
-              namespace spec.namespace.metadata.name
-            end
-
-            docker_config do
-              registry_host spec.docker.metadata.image_hostname
-              username spec.docker.credentials.username
-              password spec.docker.credentials.password
-              email spec.docker.credentials.email
-            end
+        @registry_secret ||= RegistrySecret.new do
+          metadata do
+            name "#{spec.selector_app}-registry-secret"
+            namespace spec.namespace.metadata.name
           end
 
-          @registry_secret.instance_eval(&block) if block
-          @registry_secret
+          docker_config do
+            registry_host spec.docker.image.image_hostname
+            username spec.docker.image.credentials.username
+            password spec.docker.image.credentials.password
+            email spec.docker.image.credentials.email
+          end
         end
+
+        @registry_secret.instance_eval(&block) if block
+        @registry_secret
       end
 
       def resources
@@ -172,6 +170,12 @@ module Kuby
         ].compact)
       end
 
+      def docker_images
+        @docker_images ||= [
+          docker.image, *@plugins.flat_map { |_, plugin| plugin.docker_images }
+        ]
+      end
+
       def selector_app
         @selector_app ||= environment.app_name.downcase
       end

data/lib/kuby/plugin.rb

@@ -21,8 +21,8 @@ module Kuby
       []
     end
 
-    # additional dockerfiles that should be built and pushed
-    def dockerfiles
+    # additional docker images that should be built and pushed
+    def docker_images
       []
     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/plugins/rails_app/assets.rb

@@ -47,38 +47,6 @@ module Kuby
           end
         end
 
-        def configure_deployment(deployment, docker_image)
-          spec = self
-
-          deployment.spec.template.spec do
-            init_container(:copy_assets) do
-              name "#{spec.selector_app}-copy-assets"
-              command %w(bundle exec rake kuby:rails_app:assets:copy)
-              image docker_image
-
-              volume_mount do
-                name 'assets'
-                mount_path RAILS_MOUNT_PATH
-              end
-            end
-
-            container(:web) do
-              volume_mount do
-                name 'assets'
-                mount_path NGINX_MOUNT_PATH
-              end
-            end
-
-            volume do
-              name 'assets'
-
-              persistent_volume_claim do
-                claim_name spec.volume_claim.metadata.name
-              end
-            end
-          end
-        end
-
         def copy_task
           @copy_task ||= AssetCopyTask.new(
             from: asset_path, to: RAILS_MOUNT_PATH
@@ -238,7 +206,7 @@ module Kuby
                   container(:nginx) do
                     name "#{kube_spec.selector_app}-#{kube_spec.role}"
                     image_pull_policy 'IfNotPresent'
-                    image NGINX_IMAGE
+                    image "#{kube_spec.image.image_url}:#{kube_spec.kubernetes.tag || Kuby::Docker::LATEST_TAG}-assets"
 
                     port do
                       container_port NGINX_PORT
@@ -252,11 +220,6 @@ module Kuby
                       sub_path 'nginx.conf'
                     end
 
-                    volume_mount do
-                      name 'assets'
-                      mount_path NGINX_MOUNT_PATH
-                    end
-
                     readiness_probe do
                       success_threshold 1
                       failure_threshold 2
@@ -272,6 +235,10 @@ module Kuby
                     end
                   end
 
+                  image_pull_secret do
+                    name kube_spec.environment.kubernetes.registry_secret.metadata.name
+                  end
+
                   volume do
                     name 'nginx-config'
 
@@ -280,14 +247,6 @@ module Kuby
                     end
                   end
 
-                  volume do
-                    name 'assets'
-
-                    persistent_volume_claim do
-                      claim_name kube_spec.volume_claim.metadata.name
-                    end
-                  end
-
                   restart_policy 'Always'
                   service_account_name kube_spec.service_account.metadata.name
                 end
@@ -299,38 +258,19 @@ module Kuby
           @deployment
         end
 
-        def volume_claim
-          spec = self
-
-          @volume_claim ||= KubeDSL.persistent_volume_claim do
-            metadata do
-              name "#{spec.selector_app}-#{spec.role}"
-              namespace spec.namespace.metadata.name
-            end
-
-            spec do
-              access_modes ['ReadWriteOnce']
-              storage_class_name spec.environment.kubernetes.provider.storage_class_name
-
-              resources do
-                requests do
-                  add :storage, '10Gi'
-                end
-              end
-            end
-          end
-        end
-
         def resources
           @resources ||= [
             service,
             service_account,
             nginx_config,
-            deployment,
-            volume_claim
+            deployment
           ]
         end
 
+        def docker_images
+          @docker_images ||= [docker_spec]
+        end
+
         def namespace
           environment.kubernetes.namespace
         end
@@ -342,6 +282,56 @@ module Kuby
         def role
           ROLE
         end
+
+        def docker
+          environment.docker
+        end
+
+        def kubernetes
+          environment.kubernetes
+        end
+
+        def docker_images
+          @docker_images ||= [image]
+        end
+
+        def image
+          @image ||= RailsApp::AssetsImage.new(docker.image, -> { dockerfile })
+        end
+
+        private
+
+        def dockerfile
+          Docker::Dockerfile.new.tap do |df|
+            base_image = docker.image.current_version
+            cur_tag = base_image.main_tag
+            app_name = environment.app_name.downcase
+
+            tags = begin
+              [base_image.previous_timestamp_tag(cur_tag).to_s, cur_tag]
+            rescue Kuby::Docker::MissingTagError
+              [cur_tag, nil]
+            end
+
+            # this can handle more than 2 tags by virtue of using each_cons :)
+            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.run("mkdir -p #{RAILS_MOUNT_PATH}")
+              df.run("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.copy("--from=#{prev_image_name} #{RAILS_MOUNT_PATH}", RAILS_MOUNT_PATH)
+                df.run("bundle exec rake kuby:rails_app:assets:copy")
+              end
+            end
+
+            df.from(NGINX_IMAGE)
+            df.copy("--from=#{"#{app_name}-#{tags.compact.last}"} #{RAILS_MOUNT_PATH}", NGINX_MOUNT_PATH)
+          end
+        end
       end
     end
   end