kuby-core 0.16.0 → 0.18.0

data/lib/kuby/commands.rb

@@ -3,9 +3,12 @@
 require 'kuby/version'
 require 'gli'
 
+# run the pre hook for the help command
+GLI::Commands::Help.skips_pre = false
+
 module Kuby
   class Commands
-    extend T::Sig
+    # extend T::Sig
     extend GLI::App
 
     # GLI doesn't have a wildcard option, so it's impossible to tell it to
@@ -19,12 +22,12 @@ module Kuby
     # avoid the usual series of cryptic alias_method calls (note that there
     # is no singleton class version of #prepend in the Ruby language).
     singleton_class.send(:prepend, Module.new do
-      extend T::Sig
+      # extend T::Sig
 
-      sig { params(args: T::Array[String]).void }
+      # T::Sig::WithoutRuntime.sig { params(args: T::Array[String]).void }
       def run(args)
         if idx = args.index('rails') || idx = args.index('rake')
-          @rails_options = T.let(@rails_options, T.nilable(T::Array[String]))
+          # @rails_options = T.let(@rails_options, T.nilable(T::Array[String]))
           @rails_options = args[(idx + 1)..-1]
           super(args[0..idx])
         else
@@ -34,11 +37,24 @@ module Kuby
       end
     end)
 
-    sig { returns(Kuby::Tasks) }
+    # T::Sig::WithoutRuntime.sig { returns(Kuby::Tasks) }
     def self.tasks
       Kuby::Tasks.new(Kuby.environment)
     end
 
+    # T::Sig::WithoutRuntime.sig {
+    #   params(
+    #     global_options: T::Hash[T.any(String, Symbol), T.any(String, Integer)]
+    #   ).void
+    # }
+    def self.load_kuby_config!(global_options)
+      return if @kuby_config_loaded
+
+      Kuby.env = global_options[:environment] if global_options[:environment]
+      Kuby.load!(global_options[:config])
+      @kuby_config_loaded = true
+    end
+
     program_desc 'Kuby command-line interface. Kuby is a convention '\
       'over configuration approach for running Rails apps in Kubernetes.'
 
@@ -54,19 +70,59 @@ module Kuby
     default_value './kuby.rb'
     flag [:c, :config]
 
+    command_missing do |command_name, global_options|
+      load_kuby_config!(global_options)
+      cmd = nil
+
+      # command_name is also the name of the plugin
+      if plugin_klass = Kuby.plugins.find(command_name)
+        if plugin_klass.respond_to?(:install_commands)
+          desc "Run commands for the #{command_name} plugin."
+          cmd = command(command_name) do |c|
+            # the plugin now defines its own commands on c
+            plugin_klass.install_commands(c)
+          end
+        end
+      end
+
+      cmd
+    end
+
     pre do |global_options, options, args|
-      Kuby.env = global_options[:environment] if global_options[:environment]
-      Kuby.load!(global_options[:config])
+      load_kuby_config!(global_options)
+
+      Kuby.plugins.each do |plugin_name, plugin_klass|
+        if plugin_klass.respond_to?(:commands) && !@commands[plugin_name]
+          desc "Run commands for the #{plugin_name} plugin."
+          command plugin_name.to_sym do |c|
+            plugin_klass.commands(c)
+          end
+        end
+      end
 
       # GLI will abort unless this block returns a truthy value
       true
     end
 
-    desc 'Builds the Docker image.'
+    desc 'Builds Docker images.'
     command :build do |c|
+      c.desc 'Docker build argument.'
       c.flag [:a, :arg], required: false, multiple: true
-      c.switch [:'ignore-missing-args'], required: false, default: false
-      c.flag [:only], required: false
+
+      c.desc 'When enabled, ignores missing build arguments.'
+      c.switch [:'ignore-missing-args'], required: false, default_value: false
+
+      c.desc 'Build only the images associated with the specified identifier(s). '\
+             'Run `kuby images` for a list of all valid identifiers (note that '\
+             'identifiers can be associated with more than one image).'
+      c.flag [:only], required: false, multiple: true
+
+      c.desc 'The directory to use as the Docker build context.'
+      c.flag [:c, :context], required: false
+
+      c.desc 'Pull the latest images from the registry and reuse any previously built layers.'
+      c.switch [:l, :'cache-from-latest'], required: false, default_value: true
+
       c.action do |global_options, options, docker_args|
         build_args = {}.tap do |build_args|
           (options[:arg] || []).each do |a|
@@ -79,14 +135,19 @@ module Kuby
         tasks.build(
           build_args, docker_args,
           only: options[:only],
-          ignore_missing_args: options[:'ignore-missing-args']
+          ignore_missing_args: options[:'ignore-missing-args'],
+          context: options[:context],
+          cache_from_latest: options[:'cache-from-latest']
         )
       end
     end
 
-    desc 'Pushes the Docker image to the configured registry.'
+    desc 'Pushes Docker images to their associated registries.'
     command :push do |c|
-      c.flag [:only], required: false
+      c.desc 'Push only the images associated with the specified identifier(s). '\
+             'Run `kuby images` for a list of all valid identifiers (note that '\
+             'identifiers can be associated with more than one image).'
+      c.flag [:only], required: false, multiple: true
       c.action do |global_options, options, args|
         tasks.push(only: options[:only])
       end
@@ -94,14 +155,18 @@ module Kuby
 
     desc 'Gets your Kubernetes cluster ready to run your Rails app.'
     command :setup do |c|
+      c.desc 'Run the setup routines for only the specified plugin identifier(s).'
+      c.flag [:only], required: false, multiple: true
       c.action do |global_options, options, args|
-        tasks.setup
+        tasks.setup(only: options[:only])
       end
     end
 
     desc 'Prints the effective Dockerfiles used to build Docker images.'
     command :dockerfiles do |c|
-      c.flag [:only], required: false
+      c.desc 'Print Dockerfiles for only the images associated with the specified '\
+             'identifier(s).'
+      c.flag [:only], required: false, multiple: true
       c.action do |global_options, options, args|
         tasks.print_dockerfiles(only: options[:only])
       end
@@ -116,7 +181,7 @@ module Kuby
       end
     end
 
-    desc 'Rolls back to the previous Docker tag.'
+    desc 'Rolls back to the previous release.'
     command :rollback do |c|
       c.action do |global_options, options, args|
         tasks.rollback
@@ -125,26 +190,38 @@ module Kuby
 
     desc 'Prints the effective Kubernetes resources that will be applied on deploy.'
     command :resources do |c|
+      c.desc 'Only print resources of the given kind.'
       c.flag [:K, :kind], required: false
+
+      c.desc 'Only print resources that match the given name.'
       c.flag [:N, :name], required: false
+
       c.action do |global_options, options, args|
         tasks.print_resources(options[:kind], options[:name])
       end
     end
 
-    desc 'Prints out the contents of the kubeconfig Kuby is using to communicate with your cluster.'
+    desc 'Prints out the contents of the kubeconfig file Kuby is using to communicate '\
+         'with your cluster.'
     command :kubeconfig do |c|
       c.action do |global_options, options, args|
         tasks.print_kubeconfig
       end
     end
 
+    desc 'Prints out the URLs to the latest Docker images in the Docker registry.'
+    command :images do |c|
+      c.action do |global_options, options, args|
+        tasks.print_images
+      end
+    end
+
     desc 'Runs an arbitrary kubectl command.'
     command :kubectl do |c|
       c.desc 'Prefixes the kubectl command with the namespace associated with '\
-        'the current environment. For example, if the Kuby env is "production", '\
-        'this option will prefix the kubectl command with "-n myapp-production".'
-      c.switch [:N, :namespaced], default: false
+             'the current environment. For example, if the Kuby env is "production", '\
+             'this option will prefix the kubectl command with "-n myapp-production".'
+      c.switch [:N, :namespaced], default_value: false
       c.action do |global_options, options, args|
         if options[:namespaced]
           # sorry Demeter
@@ -156,6 +233,43 @@ module Kuby
       end
     end
 
+    desc 'Provides information about plugins.'
+    command :plugin do |rc|
+      rc.desc "Run a plugin's remove routine, i.e. uninstall it's resources from your cluster."
+      rc.command :remove do |c|
+        c.desc 'The plugin to remove. Run `kuby plugin list` for a list of valid plugin '\
+               'identifiers.'
+        c.flag [:p, :plugin], required: true
+        c.action do |global_options, options, args|
+          tasks.remove_plugin(options[:plugin])
+        end
+      end
+
+      rc.desc 'List plugins.'
+      rc.command :list do |c|
+        c.desc 'Show all available plugins, not just the ones in use.'
+        c.switch [:a, :all], default_value: false
+        c.action do |global_options, options, args|
+          tasks.list_plugins(all: options[:all])
+        end
+      end
+
+      rc.desc "Run one of a plugin's rake tasks. Omit task names to print all tasks."
+      rc.arg_name 'task_name', [:multiple, :optional]
+      rc.command :rake do |c|
+        c.action do |global_options, options, args|
+          # Args come through as @rails_options here because of the monkeypatch
+          # at the top of this file. Should revisit the patch at some point because
+          # I think GLI's arg concept can replace it.
+          if @rails_options.empty?
+            tasks.list_rake_tasks
+          else
+            tasks.run_rake_tasks(@rails_options)
+          end
+        end
+      end
+    end
+
     desc 'Runs commands, etc against the Kubernetes cluster.'
     command :remote do |rc|
       rc.desc 'Tails (i.e. continuously streams) the Rails log from your running application.'
@@ -175,7 +289,7 @@ module Kuby
       rc.desc 'Runs an arbitrary command inside a running Rails pod.'
       rc.command :exec do |c|
         c.action do |global_options, options, args|
-          tasks.remote_exec([*args, *T.unsafe(@rails_options)])
+          tasks.remote_exec([*args, *@rails_options])
         end
       end
 

data/lib/kuby/definition.rb

@@ -2,23 +2,23 @@
 
 module Kuby
   class Definition
-    extend T::Sig
+    # extend T::Sig
 
-    sig { returns(String) }
+    # T::Sig::WithoutRuntime.sig { returns(String) }
     attr_reader :app_name
 
-    sig { params(app_name: String, block: T.nilable(T.proc.void)).void }
+    # T::Sig::WithoutRuntime.sig { params(app_name: String, block: T.nilable(T.proc.void)).void }
     def initialize(app_name, &block)
       @app_name = app_name
-      @environments = T.let(@environments, T.nilable(T::Hash[Symbol, Environment]))
+      # @environments = T.let(@environments, T.nilable(T::Hash[Symbol, Environment]))
     end
 
-    sig {
-      params(
-        name: Symbol,
-        block: T.nilable(T.proc.void)
-      ).returns(Environment)
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   params(
+    #     name: Symbol,
+    #     block: T.nilable(T.proc.void)
+    #   ).returns(Kuby::Environment)
+    # }
     def environment(name = Kuby.env, &block)
       name = name.to_s
 
@@ -28,10 +28,10 @@ module Kuby
         environments[name].instance_eval(&block)
       end
 
-      T.must(environments[name])
+      environments[name]
     end
 
-    sig { returns(T::Hash[Symbol, Environment]) }
+    # T::Sig::WithoutRuntime.sig { returns(T::Hash[Symbol, Kuby::Environment]) }
     def environments
       @environments ||= {}
     end

data/lib/kuby/dependable.rb

@@ -0,0 +1,20 @@
+module Kuby
+  class Dependable
+    attr_reader :name, :version_or_callable
+
+    def initialize(name, version_or_callable)
+      @name = name
+      @version_or_callable = version_or_callable
+    end
+
+    def version
+      @version ||= Kuby::Utils::SemVer.parse_version(
+        if version_or_callable.respond_to?(:call)
+          version_or_callable.call
+        else
+          version_or_callable
+        end
+      )
+    end
+  end
+end

data/lib/kuby/dependency.rb

@@ -0,0 +1,14 @@
+module Kuby
+  class Dependency
+    attr_reader :name, :constraints
+
+    def initialize(name, *constraints)
+      @name = name
+      @constraints = Kuby::Utils::SemVer.parse_constraints(*constraints)
+    end
+
+    def satisfied_by?(dependable)
+      constraints.satisfied_by?(dependable.version)
+    end
+  end
+end

data/lib/kuby/docker/alpine.rb

@@ -3,42 +3,42 @@
 module Kuby
   module Docker
     class Alpine < Distro
-      SHELL_EXE = T.let('/bin/sh'.freeze, String)
+      SHELL_EXE = '/bin/sh'.freeze
 
-      DEFAULT_PACKAGES = T.let([
+      DEFAULT_PACKAGES = [
         [:ca_certificates, nil],
         [:nodejs, '12.14.1'],
         [:yarn, '1.21.1'],
         [:c_toolchain, nil],
         [:tzdata, nil],
         [:git, nil]
-      ].freeze, T::Array[[Symbol, T.nilable(String)]])
+      ].freeze
 
-      sig { returns(Layer) }
+      # T::Sig::WithoutRuntime.sig { returns(Layer) }
       attr_reader :phase
 
-      sig { override.params(packages: T::Array[Distro::PackageImpl], into: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { override.params(packages: T::Array[Distro::PackageImpl], into: Dockerfile).void }
       def install(packages, into:)
         dockerfile = into
         install_managed(packages, dockerfile)
         install_unmanaged(packages, dockerfile)
       end
 
-      sig { override.returns(T::Array[[Symbol, T.nilable(String)]]) }
+      # T::Sig::WithoutRuntime.sig { override.returns(T::Array[[Symbol, T.nilable(String)]]) }
       def default_packages
         DEFAULT_PACKAGES
       end
 
-      sig { override.returns(String) }
+      # T::Sig::WithoutRuntime.sig { override.returns(String) }
       def shell_exe
         SHELL_EXE
       end
 
       private
 
-      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_managed(packages, dockerfile)
-        pkgs = T.cast(packages.select(&:managed?), T::Array[Distro::ManagedPackageImpl])
+        pkgs = packages.select(&:managed?)
 
         unless pkgs.empty?
           package_names = pkgs.map { |pkg| pkg.package_name_for(:alpine) }
@@ -48,7 +48,7 @@ module Kuby
         end
       end
 
-      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_unmanaged(packages, dockerfile)
         packages
           .reject(&:managed?)

data/lib/kuby/docker/app_image.rb

@@ -4,31 +4,22 @@
 module Kuby
   module Docker
     class AppImage < ::Kuby::Docker::TimestampedImage
-      extend T::Sig
+      # extend T::Sig
 
-      sig {
-        params(
-          dockerfile: T.any(Dockerfile, T.proc.returns(Dockerfile)),
-          image_url: String,
-          credentials: Credentials,
-          registry_index_url: T.nilable(String),
-          main_tag: T.nilable(String),
-          alias_tags: T::Array[String]
-        ).void
-      }
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     dockerfile: T.any(Dockerfile, T.proc.returns(Dockerfile)),
+      #     image_url: String,
+      #     credentials: Credentials,
+      #     registry_index_url: T.nilable(String),
+      #     main_tag: T.nilable(String),
+      #     alias_tags: T::Array[String]
+      #   ).void
+      # }
       def initialize(dockerfile, image_url, credentials, registry_index_url = nil, main_tag = nil, alias_tags = [])
         super
         @identifier = "app"
       end
-
-      sig { params(build_args: T::Hash[String, String], docker_args: T::Array[String]).returns(AppImage) }
-      def build(build_args = {}, docker_args = [])
-        unless ENV.fetch('RAILS_MASTER_KEY', '').empty?
-          build_args['RAILS_MASTER_KEY'] = T.must(ENV['RAILS_MASTER_KEY'])
-        end
-
-        super(build_args, docker_args)
-      end
     end
   end
 end

data/lib/kuby/docker/app_phase.rb

@@ -0,0 +1,36 @@
+# typed: strict
+
+module Kuby
+  module Docker
+    class AppPhase < Layer
+      # extend T::Sig
+
+      # T::Sig::WithoutRuntime.sig { params(environment: Environment).void }
+      def initialize(environment)
+        super
+
+        @env_vars = {}
+      end
+
+      # T::Sig::WithoutRuntime.sig { override.params(dockerfile: Dockerfile).void }
+      def apply_to(dockerfile)
+        @env_vars.each_pair do |key, value|
+          dockerfile.env("#{key}='#{value}'")
+        end
+
+        absolute_app_root = Pathname(dockerfile.current_workdir)
+          .join(environment.docker.app_root_path)
+          .to_s
+
+        if dockerfile.current_workdir != absolute_app_root
+          dockerfile.workdir(absolute_app_root)
+        end
+      end
+
+      # T::Sig::WithoutRuntime.sig { params(key: String, value: String).void }
+      def env(key, value)
+        @env_vars[key] = value
+      end
+    end
+  end
+end

data/lib/kuby/docker/assets_phase.rb

@@ -3,9 +3,9 @@
 module Kuby
   module Docker
     class AssetsPhase < Layer
-      extend T::Sig
+      # extend T::Sig
 
-      sig { override.params(dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         dockerfile.run(
           'bundle', 'exec', 'rake', 'assets:precompile'

data/lib/kuby/docker/bundler_phase.rb

@@ -5,101 +5,103 @@ require 'pathname'
 module Kuby
   module Docker
     class BundlerPhase < Layer
-      extend T::Sig
+      # extend T::Sig
 
-      DEFAULT_WITHOUT = T.let(
-        ['development', 'test', 'deploy'].freeze, T::Array[String]
-      )
+      DEFAULT_GEMFILE = 'Gemfile'.freeze
+      DEFAULT_WITHOUT = 
+        ['development', 'test', 'deploy'].freeze
+      
 
-      sig { returns(T.nilable(String)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
       attr_reader :version
 
-      sig { params(version: String).void }
+      # T::Sig::WithoutRuntime.sig { params(version: String).returns(String) }
       attr_writer :version
 
-      sig { returns(T.nilable(String)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
       attr_reader :gemfile
 
-      sig { params(gemfile: String).void }
+      # T::Sig::WithoutRuntime.sig { params(gemfile: String).returns(String) }
       attr_writer :gemfile
 
-      sig { returns(T.nilable(T::Array[String])) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(T::Array[String])) }
       attr_reader :without
 
-      sig { params(without: T::Array[String]).void }
+      # T::Sig::WithoutRuntime.sig { params(without: T::Array[String]).returns(T::Array[String]) }
       attr_writer :without
 
-      sig { returns(T.nilable(String)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
       attr_reader :executable
 
-      sig { params(executable: String).void }
+      # T::Sig::WithoutRuntime.sig { params(executable: String).returns(String) }
       attr_writer :executable
 
-      sig { params(environment: Environment).void }
+      # T::Sig::WithoutRuntime.sig { params(environment: Environment).void }
       def initialize(environment)
         super
 
-        @version = T.let(@version, T.nilable(String))
-        @gemfile = T.let(@gemfile, T.nilable(String))
-        @gemfiles = T.let([], T::Array[String])
-        @without = T.let(@without, T.nilable(T::Array[String]))
-        @executable = T.let(@executable, T.nilable(String))
+        # @version = T.let(@version, T.nilable(String))
+        # @gemfile = T.let(@gemfile, T.nilable(String))
+        @gemfiles = []
+        # @without = T.let(@without, T.nilable(T::Array[String]))
+        # @executable = T.let(@executable, T.nilable(String))
       end
 
-      sig { override.params(dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
-        gf = gemfile || default_gemfile
+        gf = gemfile || DEFAULT_GEMFILE
         lf = "#{gf}.lock"
         v = version || default_version
         wo = without || DEFAULT_WITHOUT
 
-        dockerfile.run('gem', 'install', 'bundler', '-v', v)
+        host_path = Pathname(environment.docker.app_root_path)
+        container_path = Pathname(dockerfile.current_workdir).join(environment.docker.app_root_path)
 
-        # bundle install
-        dockerfile.copy(gf, '.')
-        dockerfile.copy(lf, '.')
+        dockerfile.run('gem', 'install', 'bundler', '-v', v)
 
+        dockerfile.copy(host_path.join(gf), container_path.join(gf))
+        dockerfile.copy(host_path.join(lf), container_path.join(lf))
         @gemfiles.each do |file|
-          dockerfile.copy(file, file)
+          dockerfile.copy(host_path.join(file), container_path.join(file))
+          extra_lf = host_path.join("#{file}.lock")
+
+          if extra_lf.exist?
+            dockerfile.copy(extra_lf, container_path.join("#{file}.lock"))
+          end
         end
 
+        dockerfile.env("BUNDLE_GEMFILE=#{container_path.join(gf)}")
+
         unless wo.empty?
           dockerfile.env("BUNDLE_WITHOUT='#{wo.join(' ')}'")
         end
 
+        dockerfile.run(
+          executable || 'bundle', 'lock', '--lockfile', container_path.join(lf)
+        )
+
         dockerfile.run(
           executable || 'bundle', 'install',
           '--jobs', '$(nproc)',
-          '--retry', '3',
-          '--gemfile', gf
+          '--retry', '3'
         )
 
         # generate binstubs and add the bin directory to our path
         dockerfile.run(executable || 'bundle', 'binstubs', '--all')
-        dockerfile.env("PATH=./bin:$PATH")
+        dockerfile.env("PATH=#{container_path.join('bin')}:$PATH")
       end
 
-      sig { params(paths: String).void }
+      # T::Sig::WithoutRuntime.sig { params(paths: String).void }
       def gemfiles(*paths)
         @gemfiles.concat(paths)
       end
 
       private
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def default_version
         Bundler::VERSION
       end
-
-      sig { returns(String) }
-      def default_gemfile
-        Bundler
-          .definition
-          .gemfiles
-          .first
-          .relative_path_from(Pathname(Dir.getwd))
-          .to_s
-      end
     end
   end
 end