kuby-core 0.11.16 → 0.15.0

data/lib/kuby/docker/local_tags.rb

@@ -8,37 +8,36 @@ module Kuby
       sig { returns CLI }
       attr_reader :cli
 
-      sig { returns(Metadata) }
-      attr_reader :metadata
+      sig { returns(String) }
+      attr_reader :image_url
 
       sig {
         params(
           cli: CLI,
-          metadata: Metadata
+          image_url: String
         )
         .void
       }
-      def initialize(cli, metadata)
+      def initialize(cli, image_url)
         @cli = cli
-        @metadata = metadata
-
+        @image_url = image_url
         @latest_timestamp_tag = T.let(@latest_timestamp_tag, T.nilable(TimestampTag))
       end
 
       sig { returns(T::Array[String]) }
       def tags
-        images = cli.images(metadata.image_url)
+        images = cli.images(image_url)
         images.map { |image| T.must(image[:tag]) }
       end
 
       sig { returns(T::Array[String]) }
       def latest_tags
         # find "latest" tag
-        images = cli.images(metadata.image_url)
-        latest = images.find { |image| image[:tag] == Tags::LATEST }
+        images = cli.images(image_url)
+        latest = images.find { |image| image[:tag] == Kuby::Docker::LATEST_TAG }
 
         unless latest
-          raise MissingTagError.new(Tags::LATEST)
+          raise MissingTagError, "could not find tag #{Kuby::Docker::LATEST_TAG}"
         end
 
         # find all tags that point to the same image as 'latest'

data/lib/kuby/docker/package_phase.rb

@@ -69,11 +69,6 @@ module Kuby
           raise MissingPackageError, "package '#{package_name}' hasn't been registered"
         end
       end
-
-      sig { returns(Metadata) }
-      def metadata
-        environment.docker.metadata
-      end
     end
   end
 end

data/lib/kuby/docker/packages.rb

@@ -1,4 +1,5 @@
 # typed: strict
+
 module Kuby
   module Docker
     module Packages

data/lib/kuby/docker/remote_tags.rb

@@ -1,5 +1,7 @@
 # typed: strict
 
+require 'docker/remote'
+
 module Kuby
   module Docker
     class RemoteTags
@@ -8,24 +10,27 @@ module Kuby
       sig { returns(::Docker::Remote::Client) }
       attr_reader :remote_client
 
-      sig { returns(Metadata) }
-      attr_reader :metadata
+      sig { returns(String) }
+      attr_reader :image_url
 
       sig {
         params(
           remote_client: ::Docker::Remote::Client,
-          metadata: Metadata
+          image_url: String
         )
         .void
       }
-      def initialize(remote_client, metadata)
+      def initialize(remote_client, image_url)
         @remote_client = remote_client
-        @metadata = metadata
+        @image_url = image_url
       end
 
       sig { returns(T::Array[String]) }
       def tags
         remote_client.tags
+      rescue ::Docker::Remote::UnknownRepoError
+        # this can happen if we've never pushed to the repo before
+        []
       end
 
       sig { returns(T::Array[String]) }

data/lib/kuby/docker/setup_phase.rb

@@ -7,9 +7,6 @@ module Kuby
 
       DEFAULT_WORKING_DIR = T.let('/usr/src/app'.freeze, String)
 
-      sig { returns(T.nilable(String)) }
-      attr_reader :base_image
-
       sig { params(base_image: String).void }
       attr_writer :base_image
 
@@ -25,35 +22,46 @@ module Kuby
       sig { params(rails_env: String).void }
       attr_writer :rails_env
 
-      sig { params(environment: Environment).void }
-      def initialize(environment)
-        super
+      sig { returns(T.nilable(Docker::Spec)) }
+      attr_reader :docker_spec
+
+      sig { params(environment: Environment, docker_spec: Docker::Spec).void }
+      def initialize(environment, docker_spec)
+        super(environment)
 
         @base_image = T.let(@base_image, T.nilable(String))
         @working_dir = T.let(@working_dir, T.nilable(String))
         @rails_env = T.let(@rails_env, T.nilable(String))
+        @docker_spec = T.let(docker_spec, T.nilable(Docker::Spec))
       end
 
       sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
-        dockerfile.from(base_image || default_base_image)
+        dockerfile.from(base_image)
         dockerfile.workdir(working_dir || DEFAULT_WORKING_DIR)
         dockerfile.env("RAILS_ENV=#{rails_env || Kuby.env}")
         dockerfile.env("KUBY_ENV=#{Kuby.env}")
         dockerfile.arg('RAILS_MASTER_KEY')
       end
 
+      sig { returns(String) }
+      def base_image
+        @base_image || default_base_image
+      end
+
       private
 
       sig { returns(String) }
       def default_base_image
-        case metadata.distro
+        spec = T.must(docker_spec)
+
+        case spec.distro_name
           when :debian
             "ruby:#{RUBY_VERSION}"
           when :alpine
             "ruby:#{RUBY_VERSION}-alpine"
           else
-            raise MissingDistroError, "distro '#{metadata.distro}' hasn't been registered"
+            raise MissingDistroError, "distro '#{spec.distro_name}' hasn't been registered"
         end
       end
     end

data/lib/kuby/docker/spec.rb

@@ -1,15 +1,21 @@
 # typed: strict
 
-require 'docker/remote'
-
 module Kuby
   module Docker
     class Spec
       extend T::Sig
 
+      DEFAULT_DISTRO = :debian
+
       sig { returns(Environment) }
       attr_reader :environment
 
+      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
@@ -22,13 +28,19 @@ module Kuby
         @copy_phase = T.let(@copy_phase, T.nilable(CopyPhase))
         @assets_phase = T.let(@assets_phase, T.nilable(AssetsPhase))
         @webserver_phase = T.let(@webserver_phase, T.nilable(WebserverPhase))
-        @metadata = T.let(@metadata, T.nilable(Metadata))
 
+        @distro_name = T.let(@distro_name, T.nilable(Symbol))
         @distro_spec = T.let(@distro_spec, T.nilable(Distro))
-        @cli = T.let(@cli, T.nilable(CLI))
-        @remote_client = T.let(@remote_client, T.nilable(::Docker::Remote::Client))
-        @tags = T.let(@tags, T.nilable(Tags))
         @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
+
+      sig { returns(Symbol) }
+      def distro_name
+        @distro_name || DEFAULT_DISTRO
       end
 
       sig { params(image_url: String).void }
@@ -69,7 +81,7 @@ module Kuby
 
       sig { params(distro_name: Symbol).void }
       def distro(distro_name)
-        metadata.distro = distro_name
+        @distro_name = distro_name
         @distro_spec = nil
       end
 
@@ -85,7 +97,12 @@ module Kuby
 
       sig { params(url: String).void }
       def image_url(url)
-        metadata.image_url = url
+        @image_url_str = url
+      end
+
+      sig { params(url: String).void }
+      def registry_index_url(url)
+        @registry_index_url_str = url
       end
 
       sig {
@@ -132,16 +149,22 @@ module Kuby
         @credentials
       end
 
-      sig { returns(Dockerfile) }
-      def to_dockerfile
-        Dockerfile.new.tap do |df|
-          layer_stack.each { |layer| layer.apply_to(df) }
+      sig { returns(Docker::AppImage) }
+      def image
+        @image ||= begin
+          dockerfile = Dockerfile.new.tap do |df|
+            layer_stack.each { |layer| layer.apply_to(df) }
+          end
+
+          Docker::AppImage.new(
+            dockerfile, T.must(image_url_str), credentials, registry_index_url_str
+          )
         end
       end
 
       sig { returns(SetupPhase) }
       def setup_phase
-        @setup_phase ||= SetupPhase.new(environment)
+        @setup_phase ||= SetupPhase.new(environment, self)
       end
 
       sig { returns(PackagePhase) }
@@ -174,62 +197,15 @@ module Kuby
         @webserver_phase ||= WebserverPhase.new(environment)
       end
 
-      sig { returns(Metadata) }
-      def metadata
-        @metadata ||= Metadata.new(environment)
-      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)
-        t = tags.previous_timestamp_tag(current_tag)
-
-        unless t
-          raise MissingTagError, 'could not find previous timestamped tag'
-        end
-
-        t.to_s
-      end
-
-      sig { returns(CLI) }
-      def cli
-        @cli ||= Docker::CLI.new
-      end
-
-      sig { returns(::Docker::Remote::Client) }
-      def remote_client
-        @remote_client ||= ::Docker::Remote::Client.new(
-          metadata.image_host, metadata.image_repo,
-          credentials.username, credentials.password,
-        )
-      end
-
       sig { returns(Distro) }
       def distro_spec
-        @distro_spec ||= if distro_klass = Kuby.distros[metadata.distro]
+        @distro_spec ||= if distro_klass = Kuby.distros[distro_name]
           distro_klass.new(self)
         else
-          raise MissingDistroError, "distro '#{metadata.distro}' hasn't been registered"
+          raise MissingDistroError, "distro '#{distro_name}' hasn't been registered"
         end
       end
 
-      sig { returns(Tags) }
-      def tags
-        @tags ||= Tags.new(cli, remote_client, metadata)
-      end
-
       private
 
       sig { returns(Kuby::Docker::LayerStack) }

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,114 @@
+# 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,
+          registry_index_url_str: T.nilable(String),
+          main_tag: T.nilable(String),
+          alias_tags: T::Array[String]
+        ).void
+      }
+      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))
+
+        @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], docker_args: T::Array[String]).void }
+      def build(build_args = {}, docker_args = [])
+        docker_cli.build(new_version, build_args: build_args, docker_args: docker_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(
+          registry_index_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, registry_index_host)
+      end
+    end
+  end
+end

data/lib/kuby/docker.rb

@@ -4,30 +4,32 @@ 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 :DevSpec,        'kuby/docker/dev_spec'
-    autoload :Distro,         'kuby/docker/distro'
-    autoload :Dockerfile,     'kuby/docker/dockerfile'
-    autoload :DockerURI,      'kuby/docker/docker_uri'
-    autoload :InlineLayer,    'kuby/docker/inline_layer'
-    autoload :Layer,          'kuby/docker/layer'
-    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 :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'
+    LATEST_TAG = T.let('latest'.freeze, String)
+
+    autoload :Alpine,           'kuby/docker/alpine'
+    autoload :AppImage,         'kuby/docker/app_image'
+    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 :Distro,           'kuby/docker/distro'
+    autoload :Dockerfile,       'kuby/docker/dockerfile'
+    autoload :DockerURI,        'kuby/docker/docker_uri'
+    autoload :Image,            'kuby/docker/image'
+    autoload :InlineLayer,      'kuby/docker/inline_layer'
+    autoload :Layer,            'kuby/docker/layer'
+    autoload :LayerStack,       'kuby/docker/layer_stack'
+    autoload :LocalTags,        'kuby/docker/local_tags'
+    autoload :Packages,         'kuby/docker/packages'
+    autoload :PackagePhase,     'kuby/docker/package_phase'
+    autoload :RemoteTags,       'kuby/docker/remote_tags'
+    autoload :SetupPhase,       'kuby/docker/setup_phase'
+    autoload :Spec,             'kuby/docker/spec'
+    autoload :TimestampedImage, 'kuby/docker/timestamped_image'
+    autoload :TimestampTag,     'kuby/docker/timestamp_tag'
+    autoload :WebserverPhase,   'kuby/docker/webserver_phase'
+    autoload :YarnPhase,        'kuby/docker/yarn_phase'
   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