kuby-core 0.16.0 → 0.18.0

data/lib/kuby/docker/timestamped_image.rb

@@ -5,52 +5,56 @@ 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
-      }
+      # extend T::Sig
+
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     dockerfile: T.any(Dockerfile, T.proc.returns(Kuby::Docker::Dockerfile)),
+      #     image_url: String,
+      #     credentials: Kuby::Docker::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))
+        # @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))
+        # @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) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Image) }
       def new_version
         @new_version ||= duplicate_with_tags(
-          TimestampTag.new(Time.now).to_s, [Kuby::Docker::LATEST_TAG]
+          TimestampTag.now.to_s, [Kuby::Docker::LATEST_TAG]
         )
       end
 
-      sig { returns(Image) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::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
+          new_version
+        end
       end
 
-      sig { params(current_tag: T.nilable(String)).returns(Image) }
+      # T::Sig::WithoutRuntime.sig { params(current_tag: T.nilable(String)).returns(Kuby::Docker::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) }
+      # T::Sig::WithoutRuntime.sig { params(current_tag: T.nilable(String)).returns(Kuby::Docker::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
@@ -64,48 +68,70 @@ module Kuby
         idx ||= 0
         raise MissingTagError, 'could not find previous timestamp tag' unless idx > 0
 
-        T.must(all_tags[idx - 1])
+        all_tags[idx - 1]
       end
 
-      sig { returns(TimestampTag) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::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
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     build_args: T::Hash[String, String],
+      #     docker_args: T::Array[String],
+      #     context: T.nilable(String),
+      #     cache_from: T.nilable(String)
+      #   ).void
+      # }
+      def build(build_args = {}, docker_args = [], context: nil, cache_from: nil)
+        docker_cli.build(
+          self,
+          build_args: build_args,
+          docker_args: docker_args,
+          context: context,
+          cache_from: cache_from
+        )
       end
 
-      sig { params(tag: String).void }
+      # T::Sig::WithoutRuntime.sig { params(tag: String).void }
       def push(tag)
         docker_cli.push(image_url, tag)
       end
 
+      # T::Sig::WithoutRuntime.sig { params(tag: String).void }
+      def pull(tag)
+        docker_cli.pull(image_url, tag)
+      end
+
+      # T::Sig::WithoutRuntime.sig { returns(T::Boolean) }
+      def exists?
+        return false unless main_tag
+        timestamp_tags.include?(TimestampTag.try_parse(main_tag))
+      end
+
       private
 
-      sig { returns(::Docker::Remote::Client) }
+      # T::Sig::WithoutRuntime.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]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[Kuby::Docker::TimestampTag]) }
       def timestamp_tags
         (local.timestamp_tags + remote.timestamp_tags).uniq
       end
 
-      sig { returns(LocalTags) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::LocalTags) }
       def local
         @local ||= LocalTags.new(docker_cli, image_url)
       end
 
-      sig { returns(RemoteTags) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::RemoteTags) }
       def remote
         @remote ||= RemoteTags.new(remote_client, registry_index_host)
       end

data/lib/kuby/docker/webserver_phase.rb

@@ -3,28 +3,28 @@
 module Kuby
   module Docker
     class WebserverPhase < Layer
-      extend T::Sig
+      # extend T::Sig
 
       class Webserver
-        extend T::Sig
-        extend T::Helpers
+        # extend T::Sig
+        # extend T::Helpers
 
-        abstract!
+        # abstract!
 
-        sig { returns(WebserverPhase) }
+        # T::Sig::WithoutRuntime.sig { returns(WebserverPhase) }
         attr_reader :phase
 
-        sig { params(phase: WebserverPhase).void }
+        # T::Sig::WithoutRuntime.sig { params(phase: WebserverPhase).void }
         def initialize(phase)
           @phase = phase
         end
 
-        sig { abstract.params(dockerfile: Dockerfile).void }
+        # T::Sig::WithoutRuntime.sig { abstract.params(dockerfile: Dockerfile).void }
         def apply_to(dockerfile); end
       end
 
       class Puma < Webserver
-        sig { override.params(dockerfile: Dockerfile).void }
+        # T::Sig::WithoutRuntime.sig { override.params(dockerfile: Dockerfile).void }
         def apply_to(dockerfile)
           dockerfile.cmd(
             'puma',
@@ -39,43 +39,43 @@ module Kuby
         end
       end
 
-      DEFAULT_PORT = T.let(8080, Integer)
-      WEBSERVER_MAP = T.let({ puma: Puma }.freeze, T::Hash[Symbol, T.class_of(Webserver)])
+      DEFAULT_PORT = 8080
+      WEBSERVER_MAP = { puma: Puma }.freeze
 
-      sig { params(port: Integer).void }
+      # T::Sig::WithoutRuntime.sig { params(port: Integer).returns(Integer) }
       attr_writer :port
 
-      sig { returns(T.nilable(Symbol)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(Symbol)) }
       attr_reader :webserver
 
-      sig { params(webserver: Symbol).void }
+      # T::Sig::WithoutRuntime.sig { params(webserver: Symbol).returns(Symbol) }
       attr_writer :webserver
 
-      sig { override.params(environment: Environment).void }
+      # T::Sig::WithoutRuntime.sig { override.params(environment: Environment).void }
       def initialize(environment)
         super
 
-        @port = T.let(@port, T.nilable(Integer))
-        @webserver = T.let(@webserver, T.nilable(Symbol))
+        # @port = T.let(@port, T.nilable(Integer))
+        # @webserver = T.let(@webserver, T.nilable(Symbol))
       end
 
-      sig { override.params(dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         ws = webserver || default_webserver
-        ws_class = WEBSERVER_MAP[T.must(ws)]
+        ws_class = WEBSERVER_MAP[ws]
         raise "No webserver named #{ws}" unless ws_class
 
         ws_class.new(self).apply_to(dockerfile)
       end
 
-      sig { returns(Integer) }
+      # T::Sig::WithoutRuntime.sig { returns(Integer) }
       def port
         @port || DEFAULT_PORT
       end
 
       private
 
-      sig { returns(T.nilable(Symbol)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(Symbol)) }
       def default_webserver
         if Gem.loaded_specs.include?('puma')
           :puma

data/lib/kuby/docker/yarn_phase.rb

@@ -3,13 +3,37 @@
 module Kuby
   module Docker
     class YarnPhase < Layer
-      extend T::Sig
+      # extend T::Sig
 
-      sig { params(dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
-        # use character classes as a hack to only copy the files if they exist
-        dockerfile.copy('package.json yarn.loc[k] .npmr[c] .yarnr[c]', './')
-        dockerfile.run('yarn', 'install')
+        host_path = environment.docker.app_root_path
+
+        # if more than one file is passed to the COPY directive, the destination must be
+        # a directory and must end with a slash
+        container_path = ensure_trailing_delimiter(
+          File.join(
+            dockerfile.current_workdir,
+            environment.docker.app_root_path
+          )
+        )
+
+        if File.exist?(File.join(host_path, 'package.json'))
+          # use brackets as a hack to only copy the files if they exist
+          dockerfile.copy(
+            "#{host_path}/package.json #{host_path}/yarn.loc[k] #{host_path}/.npmr[c] #{host_path}/.yarnr[c]",
+            container_path
+          )
+
+          dockerfile.run('yarn', 'install', '--cwd', container_path)
+        end
+      end
+
+      private
+
+      # T::Sig::WithoutRuntime.sig { params(path: String).returns(String) }
+      def ensure_trailing_delimiter(path)
+        path.end_with?(File::SEPARATOR) ? path : File.join(path, '')
       end
     end
   end

data/lib/kuby/docker.rb

@@ -4,10 +4,11 @@ require 'kuby/docker/errors'
 
 module Kuby
   module Docker
-    LATEST_TAG = T.let('latest'.freeze, String)
+    LATEST_TAG = 'latest'.freeze
 
     autoload :Alpine,           'kuby/docker/alpine'
     autoload :AppImage,         'kuby/docker/app_image'
+    autoload :AppPhase,         'kuby/docker/app_phase'
     autoload :AssetsPhase,      'kuby/docker/assets_phase'
     autoload :BundlerPhase,     'kuby/docker/bundler_phase'
     autoload :CLI,              'kuby/docker/cli'

data/lib/kuby/kubernetes/bare_metal_provider.rb

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

data/lib/kuby/kubernetes/deployer.rb

@@ -8,10 +8,8 @@ require 'yaml'
 module Kuby
   module Kubernetes
     class Deployer
-      extend T::Sig
-
       attr_reader :environment
-      attr_accessor :logdev
+      attr_writer :logdev
 
       def initialize(environment)
         @environment = environment
@@ -19,7 +17,7 @@ module Kuby
 
       def deploy
         restart_rails_deployment_if_necessary do
-          namespaced, global = all_resources.partition do |resource|
+          resource_groups = all_resources.group_by do |resource|
             # Unfortunately we can't use respond_to here because all KubeDSL
             # objects use ObjectMeta, which has a namespace field. Not sure
             # why, since it makes no sense for a namespace to have a namespace.
@@ -27,8 +25,21 @@ module Kuby
             resource.metadata.namespace
           end
 
-          deploy_global_resources(global)
-          deploy_namespaced_resources(namespaced)
+          deploy_global_resources(resource_groups[nil])
+
+          resource_groups.each_pair do |ns, resources|
+            next if !ns
+
+            begin
+              deploy_namespaced_resources(resources, ns)
+            rescue => e
+              puts e.message
+
+              if bt = e.backtrace
+                puts bt.join("\n")
+              end
+            end
+          end
         end
       end
 
@@ -69,10 +80,11 @@ module Kuby
         end
       rescue KubernetesCLI::InvalidResourceError => e
         Kuby.logger.fatal(e.message)
-        Kuby.logger.fatal(e.resource.to_resource.to_yaml)
+        resource = e.resource&.to_resource
+        Kuby.logger.fatal(resource) if resource
       end
 
-      def deploy_namespaced_resources(resources)
+      def deploy_namespaced_resources(resources, ns)
         old_kubeconfig = ENV['KUBECONFIG']
         ENV['KUBECONFIG'] = provider.kubeconfig_path
 
@@ -87,7 +99,7 @@ module Kuby
         end
 
         task = ::Kuby::Kubernetes::DeployTask.new(
-          namespace: namespace.metadata.name,
+          namespace: ns,
           context: cli.current_context,
           filenames: [tmpdir]
         )
@@ -97,7 +109,7 @@ module Kuby
         task.run!(verify_result: true, prune: false)
       ensure
         ENV['KUBECONFIG'] = old_kubeconfig
-        FileUtils.rm_rf(T.must(tmpdir))
+        FileUtils.rm_rf(tmpdir)
       end
 
       def restart_rails_deployment_if_necessary

data/lib/kuby/kubernetes/docker_config.rb

@@ -1,4 +1,5 @@
 # typed: true
+
 require 'base64'
 require 'kube-dsl'
 

data/lib/kuby/kubernetes/provider.rb

@@ -1,4 +1,5 @@
 # typed: true
+
 require 'kubernetes-cli'
 
 module Kuby

data/lib/kuby/kubernetes/spec.rb

@@ -1,5 +1,7 @@
 # typed: false
+
 require 'kube-dsl'
+require 'rake'
 
 module Kuby
   module Kubernetes
@@ -13,6 +15,7 @@ module Kuby
         @plugins = TrailingHash.new
 
         # default plugins
+        add_plugin(:system)
         add_plugin(:rails_app)
       end
 
@@ -69,17 +72,59 @@ module Kuby
       def after_configuration
         @plugins.each { |_, plg| plg.after_configuration }
         provider.after_configuration
+        environment.docker.after_configuration
+
+        spec = self
+
+        # this must be done _after_ docker has been configured
+        registry_secret do
+          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
       end
 
       def before_deploy
         @tag ||= docker.image.current_version.main_tag
 
+        check_dependencies!
+
         provider.before_deploy(resources)
         @plugins.each { |_, plg| plg.before_deploy(resources) }
       ensure
         @tag = nil
       end
 
+      def check_dependencies!(plugins = @plugins)
+        error_messages = []
+
+        plugins.each do |plg_name, plg|
+          plg.class.dependencies.each do |dependency|
+            dependable = Kuby.dependables[dependency.name]
+
+            unless dependable
+              error_messages << "The #{plg_name} plugin depends on #{dependency.name}, "\
+                "but that dependency has not been registered."
+
+              next
+            end
+
+            unless dependency.satisfied_by?(dependable)
+              error_messages << "The #{plg_name} plugin depends on #{dependency.name} "\
+                "#{dependency.constraints}, but the available version is #{dependable.version}."
+            end
+          end
+        end
+
+        unless error_messages.empty?
+          error_messages.each { |msg| Kuby.logger.fatal(msg) }
+          exit 1
+        end
+      end
+
       def after_deploy
         @tag ||= docker.image.current_version.main_tag
 
@@ -89,13 +134,25 @@ module Kuby
         @tag = nil
       end
 
-      def setup
-        provider.before_setup
-        provider.setup
+      def setup(only: [])
+        plugins = if only.empty?
+          @plugins
+        else
+          @plugins.each_with_object({}) do |(name, plg), memo|
+            memo[name] = plg if only.include?(name)
+          end
+        end
+
+        check_dependencies!(plugins)
 
-        @plugins.each { |_, plg| plg.before_setup }
-        @plugins.each { |_, plg| plg.setup }
-        @plugins.each { |_, plg| plg.after_setup }
+        if only.empty?
+          provider.before_setup
+          provider.setup
+        end
+
+        plugins.each { |_, plg| plg.before_setup }
+        plugins.each { |_, plg| plg.setup }
+        plugins.each { |_, plg| plg.after_setup }
 
         provider.after_setup
       end
@@ -149,13 +206,6 @@ module Kuby
             name "#{spec.selector_app}-registry-secret"
             namespace spec.namespace.metadata.name
           end
-
-          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

data/lib/kuby/plugin.rb

@@ -1,4 +1,5 @@
-# typed: true
+# typed: false
+
 module Kuby
   class Plugin
     attr_reader :environment
@@ -8,14 +9,35 @@ module Kuby
       after_initialize
     end
 
+    class << self
+      # returns an array of directories containing .rake files
+      def task_dirs
+        []
+      end
+
+      def depends_on(dependable_name, *constraints)
+        dependencies << Kuby::Dependency.new(dependable_name, *constraints)
+      end
+
+      def dependencies
+        @dependencies ||= []
+      end
+    end
+
     def configure(&block)
       # do nothing by default
     end
 
+    # install any global resources like operators, etc
     def setup
       # do nothing by default
     end
 
+    # remove all global resources installed by #setup
+    def remove
+      # do nothing by default
+    end
+
     # additional kubernetes resources that should be deployed
     def resources
       []

data/lib/kuby/plugin_registry.rb

@@ -1,6 +1,8 @@
 # typed: false
 module Kuby
   class PluginRegistry
+    include Enumerable
+
     ANY = 'any'.freeze
 
     def register(plugin_name, plugin_klass, environment: ANY)
@@ -19,6 +21,19 @@ module Kuby
       plugins_by_env[environment] || plugins_by_env[ANY]
     end
 
+    def each(&block)
+      return to_enum(__method__) unless block
+
+      @plugins.each_pair do |plugin_name, plugins_by_env|
+        plugins_by_env.each_pair do |env, plugin_klass|
+          case env
+            when ANY, Kuby.env
+              yield plugin_name, plugin_klass
+          end
+        end
+      end
+    end
+
     private
 
     def plugins