kuby-core 0.16.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bb1eba2c179a03610f3f478f595c43638e692b41ebad53c7d6292ef5699000a
-  data.tar.gz: b9003940ecba163e1f9c08100223d6059920f7f9a2d8ebff0c038e1fd5f335ee
+  metadata.gz: c537d5778b44ceab6bbd75ae91b2c8569bdba7356c25112c172ce10533a5b073
+  data.tar.gz: c8fda1880975e51a5e398ccb5e42474ead68e7a179ea403ded3b15ee615dc4f1
 SHA512:
-  metadata.gz: fad183f5c697c6f6a06da8984dff19e0feac91b1996ae79a6605cafb612c77590461f80807ac87854124a97eef31e2999b39a64f997ef4f0fc77564365d81602
-  data.tar.gz: 1df3f9153d1595d085511329a5c1110117fa626632438a635f162c38cbe9c48d53df3098b28300408b89021365298b9972d07bdb9abd17b01bbc236e711ed3b8
+  metadata.gz: ea78f96fa54b86a8917e252af444e92465b43e9017c52e25e9e643df50095a31a15462ba48f8db1f94063aff414ce9d2eb2a9e3617e2c9581823d339c810a0af
+  data.tar.gz: b791c2e2190e8c16a52b1039f565f9e6f04d55bc47395d0133581503beb882019139199da14efecf2d488a26e6229e7beaf649375c5067df69db6c0c7787fcf2

data/CHANGELOG.md

@@ -1,3 +1,61 @@
+## 0.18.0
+* Add the ability to specify your app's root directory.
+  - Call `app_root <path>` inside the `docker` section of your Kuby config file.
+  - Necessary for use-cases like apps living inside gem repos, etc.
+* Add `:app_phase` to set of Docker build phases.
+  - Allows easily setting environment variables.
+  - Sets the working directory to the app root if the app's root directory has been set via the `app_root` feature described above.
+* Upgrade to Nginx ingress controller v1.1.1.
+  - Necessary to support Kind, the local Kubernetes cluster tool (see the kuby-kind gem).
+* Run `bundle lock` before installing gem dependencies.
+* Fix bug causing errors when certain container registries return a 401 if the repo doesn't exist yet.
+  - I'm looking at you, Azure.
+* Don't fail to deploy if the app doesn't use Active Record.
+* Fix git merge issue causing no output when running `kuby dockerfiles`.
+* Upgrade integration tests to Kubernetes 1.23.
+  - This upgrade is incompatible with the version of KubeDB we're currently using.
+  - KubeDB has been replaced with the CockroachDB operator. Kuby will no longer support KubeDB after this release.
+* Add ability to deploy resources into more than one namespace.
+* Remove support for MySQL and Postgres in favor of CockroachDB.
+  - KubeDB has moved to an incompatible licensing model and Kuby can no longer use it.
+  - CockroachDB is now the only managed database offering (aside from SQLite) for the following reasons:
+    - CRDB is cloud-native, i.e. is designed to be run on cloud platforms like Kubernetes.
+    - CRDB can be easily upgraded in-place while both MySQL and Postgres demand a much more manual, error-prone upgrade process that proved very difficult to automate.
+    - CRDB is Postgres wire-compatible, meaning those who use Postgres (and I believe that accounts for the majority of Rails devs) will hardly be impacted by this change at all. While CRDB is not feature-by-feature compatible with Postgres, the differences are unlikely to be important to the average Rails app.
+* Use SSL certificates instead of usernames and passwords for database authentication.
+  - This is the preferred way to communicate with instances of CockroachDB (also supported by Postgres).
+  - Kuby uses cert-manager to establish a custom PKI for database interactions.
+  - The Rails generator now entirely omits the database configuration section, making config simpler.
+* Avoid failing on first deploy.
+  - Previous versions of Kuby did not wait for the database to spin up before attempting to start the Rails app, which resulted in what appeared to be a failed deploy. Kubernetes would eventually sort everything out, but it made for a less than ideal developer experience.
+  - The `create_unless_exists` rake task has been superceded by the `bootstrap` rake task, which is run in an init container whenever the app boots. It is responsible for ensuring the database server is reachable and creating any users defined in the Kuby config.
+* Add the ability for plugins to define their own set of rake tasks.
+  - These are runnable via the CLI.
+* Add the ability for plugins to define a `#remove` routine, which is meant to do the opposite of whatever `#setup` does.
+  - It is now also possible to run a plugin's remove routine from the CLI.
+* Add the ability for plugins to depend on things like Kubernetes and Helm.
+  - Uses semantic versioning and compares required versions to current versions.
+* Avoid using the `which` command to find executables on the current PATH.
+  - `which` has been deprecated in at least one Linux distro (Debian), perhaps others.
+  - Use `Kuby::Utils.which` instead.
+* Support Rails 7.
+  - Don't run `yarn install` if there's no package.json.
+* Automatically cache Docker builds from the latest image, should it exist.
+
+## 0.17.1
+* Allow storage class to be customized when using the built-in bare metal provider.
+* Fix a bug where the assets image would be built using the previous app image instead of the current one.
+* Centralize the lookup of the Rails master key (not user-facing).
+* Add descriptions to numerous CLI commands and their arguments.
+* CLI now accepts multiple `--only` flags passed to subcommands like `build`, `push`, etc.
+* Allow running setup steps for individual plugins.
+
+## 0.16.1
+* Fix a few bugs caused by leaving `continue-on-error: true` in the GitHub actions config 🤦
+  - Docker builds would fail if no previous images existed in the registry.
+  - The assets image would fail to build because `RAILS_MASTER_KEY` was not propagated correctly.
+* Use the kuby-prebundler gem in the integration tests instead of a custom layer.
+
 ## 0.16.0
 * Allow Bundler executable to be customized.
   - Main use-case is to allow adding in the Prebundler plugin, https://github.com/getkuby/kuby-prebundler.

data/Gemfile

@@ -5,8 +5,12 @@ gemspec
 group :development, :test do
   gem 'pry-byebug'
   gem 'rake'
-  # lock to a specific version to prevent breaking CI when new versions come out
-  gem 'sorbet', '= 0.5.6433'
+
+  gem 'curdle', '~> 1.2'
+  gem 'parlour', github: 'camertron/parlour', branch: 'initialize_void' # '~> 7.0'
+  gem 'tapioca', '~> 0.7'
+  gem 'sorbet-runtime', '= 0.5.9897'
+  gem 'sorbet-static', '= 0.5.9897'
 end
 
 group :test do

data/Rakefile

@@ -1,10 +1,12 @@
 require 'bundler'
 require 'rspec/core/rake_task'
-require 'rubygems/package_task'
+require 'curdle'
 
-require 'kuby'
+Curdle::Tasks.install
 
-Bundler::GemHelper.install_tasks
+require 'pry-byebug'
+require 'sorbet-runtime'
+require 'kuby'
 
 task default: :spec
 

data/bin/tapioca

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'tapioca' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("tapioca", "tapioca")

data/kuby-core.gemspec

@@ -13,24 +13,22 @@ Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
 
   s.add_dependency 'colorize', '~> 0.8'
-  s.add_dependency 'docker-remote', '~> 0.6'
-  s.add_dependency 'gli', '~> 2.0'
+  s.add_dependency 'docker-remote', '~> 0.8'
+  s.add_dependency 'gli', '~> 2.21'
   s.add_dependency 'helm-cli', '~> 0.3'
-  # See: https://github.com/Shopify/krane/pull/720
-  # See: https://github.com/Shopify/krane/blob/master/CHANGELOG.md#114
-  s.add_dependency 'krane', '>= 1.1.4', '< 2.0'
-  s.add_dependency 'kuby-cert-manager', '>= 0.3'
-  s.add_dependency 'kube-dsl', '~> 0.4'
-  s.add_dependency 'kuby-kube-db', '>= 0.6'
-  s.add_dependency 'kubernetes-cli', '~> 0.3'
+  s.add_dependency 'krane', '~> 2.0'
+  s.add_dependency 'kuby-cert-manager', '~> 0.4'
+  s.add_dependency 'kuby-crdb', '~> 0.2'
+  s.add_dependency 'kube-dsl', '~> 0.7'
+  s.add_dependency 'kubernetes-cli', '~> 0.4'
   s.add_dependency 'railties', '>= 5.1'
   s.add_dependency 'rouge', '~> 3.0'
-  s.add_dependency 'sorbet-runtime-stub', '~> 0.2'
+  s.add_dependency 'rake'
 
   s.add_development_dependency 'rspec'
 
   s.require_path = 'lib'
   s.executables << 'kuby'
 
-  s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'kuby-core.gemspec']
+  s.files = Dir['{bin,lib,rbi,spec}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'kuby-core.gemspec']
 end

data/lib/kuby/basic_logger.rb

@@ -5,25 +5,25 @@ require 'colorized_string'
 
 module Kuby
   class BasicLogger < Logger
-    extend T::Sig
+    # extend T::Sig
 
-    sig {
-      override.params(
-        logdev: T.any(String, IO, StringIO, NilClass),
-        shift_age: Integer,
-        shift_size: Integer,
-        level: Integer,
-        progname: T.nilable(String),
-        formatter: T.nilable(FormatterProcType),
-        datetime_format: T.nilable(String),
-        shift_period_suffix: T.nilable(String)
-      ).void
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   override.params(
+    #     logdev: T.any(String, IO, StringIO, NilClass),
+    #     shift_age: Integer,
+    #     shift_size: Integer,
+    #     level: Integer,
+    #     progname: T.nilable(String),
+    #     formatter: T.nilable(FormatterProcType),
+    #     datetime_format: T.nilable(String),
+    #     shift_period_suffix: T.nilable(String)
+    #   ).void
+    # }
     def initialize(
         logdev, shift_age = 0, shift_size = 1048576, level: DEBUG,
         progname: nil, formatter: nil, datetime_format: nil,
         shift_period_suffix: '%Y%m%d')
-      @logdev = T.let(@logdev, T.nilable(Logger::LogDevice))
+      # @logdev = T.let(@logdev, T.nilable(Logger::LogDevice))
 
       super
 
@@ -32,12 +32,12 @@ module Kuby
       end
     end
 
-    sig {
-      override.params(
-        progname_or_msg: T.untyped,
-        block: T.nilable(T.proc.returns(T.untyped))
-      ).void
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   override.params(
+    #     progname_or_msg: T.untyped,
+    #     block: T.nilable(T.proc.returns(T.untyped))
+    #   ).void
+    # }
     def info(progname_or_msg = nil, &block)
       if block
         super(progname_or_msg) { ColorizedString[block.call].yellow }
@@ -46,12 +46,12 @@ module Kuby
       end
     end
 
-    sig {
-      override.params(
-        progname_or_msg: T.untyped,
-        block: T.nilable(T.proc.returns(T.untyped))
-      ).void
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   override.params(
+    #     progname_or_msg: T.untyped,
+    #     block: T.nilable(T.proc.returns(T.untyped))
+    #   ).void
+    # }
     def fatal(progname_or_msg = nil, &block)
       if block
         super(progname_or_msg) { ColorizedString[block.call].red }
@@ -61,13 +61,13 @@ module Kuby
     end
 
     # adhere to the "CLI" interface
-    sig {
-      params(
-        out: T.any(IO, StringIO),
-        err: T.any(IO, StringIO),
-        block: T.proc.void
-      ).void
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   params(
+    #     out: T.any(IO, StringIO),
+    #     err: T.any(IO, StringIO),
+    #     block: T.proc.void
+    #   ).void
+    # }
     def with_pipes(out = STDOUT, err = STDERR, &block)
       previous_logdev = @logdev&.dev || STDERR
       reopen(err)
@@ -76,7 +76,7 @@ module Kuby
       reopen(previous_logdev)
     end
 
-    sig { returns(T.nilable(Process::Status)) }
+    # T::Sig::WithoutRuntime.sig { returns(T.nilable(Process::Status)) }
     def last_status
       nil
     end

data/lib/kuby/cli_base.rb

@@ -5,39 +5,39 @@ require 'thread'
 
 module Kuby
   class CLIBase
-    extend T::Sig
+    # extend T::Sig
 
-    BeforeCallback = T.type_alias { T.proc.params(cmd: T::Array[String]).void }
-    AfterCallback = T.type_alias do
-      T.proc.params(cmd: T::Array[String], last_status: T.nilable(Process::Status)).void
-    end
+    # BeforeCallback = T.type_alias { T.proc.params(cmd: T::Array[String]).void }
+    # AfterCallback = T.type_alias do
+    #   T.proc.params(cmd: T::Array[String], last_status: T.nilable(Process::Status)).void
+    # end
 
-    sig { returns(T.nilable(Process::Status)) }
+    # T::Sig::WithoutRuntime.sig { returns(T.nilable(Process::Status)) }
     def last_status
       Thread.current[status_key]
     end
 
-    sig { params(block: BeforeCallback).void }
+    # T::Sig::WithoutRuntime.sig { params(block: BeforeCallback).void }
     def before_execute(&block)
-      @before_execute = T.let(@before_execute, T.nilable(T::Array[BeforeCallback]))
+      # @before_execute = T.let(@before_execute, T.nilable(T::Array[BeforeCallback]))
       @before_execute ||= []
       @before_execute << block
     end
 
-    sig { params(block: AfterCallback).void }
+    # T::Sig::WithoutRuntime.sig { params(block: AfterCallback).void }
     def after_execute(&block)
-      @after_execute = T.let(@after_execute, T.nilable(T::Array[AfterCallback]))
+      # @after_execute = T.let(@after_execute, T.nilable(T::Array[AfterCallback]))
       @after_execute ||= []
       @after_execute << block
     end
 
-    sig {
-      params(
-        out: T.any(IO, StringIO),
-        err: T.any(IO, StringIO),
-        block: T.proc.void
-      ).void
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   params(
+    #     out: T.any(IO, StringIO),
+    #     err: T.any(IO, StringIO),
+    #     block: T.proc.void
+    #   ).void
+    # }
     def with_pipes(out = STDOUT, err = STDERR, &block)
       previous_stdout = self.stdout
       previous_stderr = self.stderr
@@ -49,34 +49,34 @@ module Kuby
       self.stderr = previous_stderr
     end
 
-    sig { returns(T.nilable(T.any(IO, StringIO))) }
+    # T::Sig::WithoutRuntime.sig { returns(T.nilable(T.any(IO, StringIO))) }
     def stdout
       Thread.current[stdout_key] || STDOUT
     end
 
-    sig { params(new_stdout: T.nilable(T.any(IO, StringIO))).void }
+    # T::Sig::WithoutRuntime.sig { params(new_stdout: T.nilable(T.any(IO, StringIO))).void }
     def stdout=(new_stdout)
       Thread.current[stdout_key] = new_stdout
     end
 
-    sig { returns(T.nilable(T.any(IO, StringIO))) }
+    # T::Sig::WithoutRuntime.sig { returns(T.nilable(T.any(IO, StringIO))) }
     def stderr
       Thread.current[stderr_key] || STDERR
     end
 
-    sig { params(new_stderr: T.nilable(T.any(IO, StringIO))).void }
+    # T::Sig::WithoutRuntime.sig { params(new_stderr: T.nilable(T.any(IO, StringIO))).void }
     def stderr=(new_stderr)
       Thread.current[stderr_key] = new_stderr
     end
 
     private
 
-    sig {
-      params(
-        cmd: T::Array[String],
-        block: T.proc.params(stdin: IO).void
-      ).void
-    }
+    # T::Sig::WithoutRuntime.sig {
+    #   params(
+    #     cmd: T::Array[String],
+    #     block: T.proc.params(stdin: IO).void
+    #   ).void
+    # }
     def open3_w(cmd, &block)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -99,20 +99,20 @@ module Kuby
         yield(p_stdin)
 
         p_stdin.close
-        self.last_status = T.cast(wait_thread.value, Process::Status)
+        self.last_status = wait_thread.value
         run_after_callbacks(cmd)
         wait_thread.join
       end
     end
 
-    sig { params(cmd: T::Array[String]).void }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
     def execc(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
       exec(cmd_s)
     end
 
-    sig { params(cmd: T::Array[String]).void }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
     def systemm(cmd)
       if stdout == STDOUT && stderr == STDERR
         systemm_default(cmd)
@@ -121,7 +121,7 @@ module Kuby
       end
     end
 
-    sig { params(cmd: T::Array[String]).void }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
     def systemm_default(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -131,7 +131,7 @@ module Kuby
       end
     end
 
-    sig { params(cmd: T::Array[String]).void }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
     def systemm_open3(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -152,14 +152,14 @@ module Kuby
         end
 
         p_stdin.close
-        self.last_status = T.cast(wait_thread.value, Process::Status)
+        self.last_status = wait_thread.value
         run_after_callbacks(cmd)
         wait_thread.join
       end
     end
 
 
-    sig { params(cmd: T::Array[String]).returns(String) }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).returns(String) }
     def backticks(cmd)
       if stdout == STDOUT && stderr == STDERR
         backticks_default(cmd)
@@ -168,7 +168,7 @@ module Kuby
       end
     end
 
-    sig { params(cmd: T::Array[String]).returns(String) }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).returns(String) }
     def backticks_default(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -178,7 +178,7 @@ module Kuby
       end
     end
 
-    sig { params(cmd: T::Array[String]).returns(String) }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).returns(String) }
     def backticks_open3(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -200,7 +200,7 @@ module Kuby
         end
 
         p_stdin.close
-        self.last_status = T.cast(wait_thread.value, Process::Status)
+        self.last_status = wait_thread.value
         run_after_callbacks(cmd)
         wait_thread.join
       end
@@ -208,32 +208,32 @@ module Kuby
       result.string
     end
 
-    sig { params(cmd: T::Array[String]).void }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
     def run_before_callbacks(cmd)
       (@before_execute || []).each { |cb| cb.call(cmd) }
     end
 
-    sig { params(cmd: T::Array[String]).void }
+    # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
     def run_after_callbacks(cmd)
       (@after_execute || []).each { |cb| cb.call(cmd, last_status) }
     end
 
-    sig { params(status: Process::Status).void }
+    # T::Sig::WithoutRuntime.sig { params(status: Process::Status).void }
     def last_status=(status)
       Thread.current[status_key] = status
     end
 
-    sig { returns(Symbol) }
+    # T::Sig::WithoutRuntime.sig { returns(Symbol) }
     def status_key
       raise NotImplementedError, "#{__method__} must be defined in derived classes"
     end
 
-    sig { returns(Symbol) }
+    # T::Sig::WithoutRuntime.sig { returns(Symbol) }
     def stdout_key
       raise NotImplementedError, "#{__method__} must be defined in derived classes"
     end
 
-    sig { returns(Symbol) }
+    # T::Sig::WithoutRuntime.sig { returns(Symbol) }
     def stderr_key
       raise NotImplementedError, "#{__method__} must be defined in derived classes"
     end