kuby-core 0.11.16 → 0.12.0

data/lib/kuby/docker/image.rb

@@ -0,0 +1,115 @@
+# typed: strict
+
+module Kuby
+  module Docker
+    class Image
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :image_url
+
+      sig { returns(Credentials) }
+      attr_reader :credentials
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :main_tag
+
+      sig { returns T::Array[String] }
+      attr_reader :alias_tags
+
+      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 = [])
+        @dockerfile = T.let(dockerfile, T.any(Dockerfile, T.proc.returns(Dockerfile)))
+        @image_url = T.let(image_url, String)
+        @credentials = T.let(credentials, Credentials)
+        @main_tag = T.let(main_tag, T.nilable(String))
+        @alias_tags = T.let(alias_tags, T::Array[String])
+
+        @image_host = T.let(@image_host, T.nilable(String))
+        @image_hostname = T.let(@image_hostname, T.nilable(String))
+        @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))
+      end
+
+      sig { returns(Image) }
+      def new_version
+        raise NotImplementedError, 'please use a Docker::Image subclass'
+      end
+
+      sig { returns(Image) }
+      def current_version
+        raise NotImplementedError, 'please use a Docker::Image subclass'
+      end
+
+      sig { params(current_tag: T.nilable(String)).returns(Image) }
+      def previous_version(current_tag = nil)
+        raise NotImplementedError, 'please use a Docker::Image subclass'
+      end
+
+      sig { returns(Dockerfile) }
+      def dockerfile
+        if @dockerfile.respond_to?(:call)
+          T.cast(@dockerfile, T.proc.returns(Dockerfile)).call
+        else
+          T.cast(@dockerfile, Dockerfile)
+        end
+      end
+
+      sig { returns(String) }
+      def image_host
+        @image_host ||= "#{image_uri.host}:#{image_uri.port}"
+      end
+
+      sig { returns(String) }
+      def image_hostname
+        @image_hostname ||= image_uri.host
+      end
+
+      sig { returns(String) }
+      def image_repo
+        @image_repo ||= image_uri.path
+      end
+
+      sig { returns(DockerURI) }
+      def image_uri
+        @full_image_uri ||= DockerURI.parse(image_url)
+      end
+
+      sig { returns(T::Array[String]) }
+      def tags
+        [main_tag, *alias_tags].compact
+      end
+
+      sig { params(build_args: T::Hash[String, String]).void }
+      def build(build_args = {})
+        raise NotImplementedError, 'please use a Docker::Image subclass'
+      end
+
+      sig { params(tag: String).void }
+      def push(tag)
+        raise NotImplementedError, 'please use a Docker::Image subclass'
+      end
+
+      sig { returns(Docker::CLI) }
+      def docker_cli
+        @docker_cli ||= Docker::CLI.new
+      end
+
+      private
+
+      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)
+      end
+    end
+  end
+end

data/lib/kuby/docker/layer.rb

@@ -21,13 +21,6 @@ module Kuby
         raise NotImplementedError,
           "#{__method__} must be defined in derived classes"
       end
-
-      private
-
-      sig { returns(Metadata) }
-      def metadata
-        environment.docker.metadata
-      end
     end
   end
 end

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,18 @@
 # 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 { params(environment: Environment).void }
       def initialize(environment)
         @environment = environment
@@ -22,13 +25,18 @@ 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))
+        @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 +77,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 +93,7 @@ module Kuby
 
       sig { params(url: String).void }
       def image_url(url)
-        metadata.image_url = url
+        @image_url_str = url
       end
 
       sig {
@@ -132,16 +140,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
+          )
         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 +188,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) }