kuby-core 0.9.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9367e316dfab7a0210bea18ab630b65a5996ce0622960f3be2a76f8ec4482c1
-  data.tar.gz: d48777e79f11eab678545a2d398d3f60463e7d1209e6d15987c3f3665d571b82
+  metadata.gz: 8664691d15dc7ba054a6986e9b62ef0ad3fc1ff7aa9e80a12595bee3029b7814
+  data.tar.gz: 1a29a74242aa420dbf1c8c50804f85b24716d479f226bd8b411fdb5794031d41
 SHA512:
-  metadata.gz: cbfd215f8b4a7cb2b1a53bc8de8298e4dd85f487f0245da82bd19a390d55500c20e97e155a07fafa09284683ee9c220bb4cdd89194c3e5cb4c6e3c055fbcce74
-  data.tar.gz: 03c15b9ffb8672ef2e45d2d818c3d048e694dae2656db0be6325a1edf6853b1c9c8bc7060b021add66b43d87c9ca3ac46bb71346f2e2a4e68bd89ba6d45635f9
+  metadata.gz: 3fd0f6fc04d728e7122287889c6013a3578b4eb4a7bc0ae8903232bbd42b99265567271a6e171ec26838259e193f042558df583c2f66ac7d90454aa2f53943ef
+  data.tar.gz: e3480ec344cd46ca020cc7f4615028490f721ed21887b1c45efcb0d17f4d2e1739741946768ed52bab8a1fa75f417ff061a5c970a331fa003520044e0cfca508

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+## 0.11.1
+* Use integers for ports instead of strings to appease Kubernetes.
+
+## 0.11.0
+* Defer evaluation of database config until after Kuby has been configured.
+  - The issue that prompted this was that the `database` block was being evaluated before the Rails root had been set via `root`. Kuby couldn't find database.yml in a non-standard location and blew up with an error.
+* Fix tests broken in 0.10.1.
+* Set up Travis CI builds.
+* Add a few tests for custom build phases.
+* Add the `Environment#configured?` method that will return `true` if Kuby has been configured and `false` if configuration hasn't happened or is in progress.
+* Add sorbet typedefs for some classes.
+* Fix issue in Rails generator (hadn't been updated with new `environment` block).
+* Add kuby-core.rb so Bundler setup works for Kuby without having to add a Rails initializer.
+
+## 0.10.1
+* Fix bug causing some `rails` and `rake` commands to not be executed.
+* Fix issue restricting Docker CLI output.
+
+## 0.10.0
+* Set default database user and password in dev environment.
+* Add ability to run rake tasks in dev environment.
+* Disallow running rails and rake tasks in non-dev environments.
+* Don't run database config through ERB.
+  - Rails env often isn't loaded, so ERB rendering can blow up with `NoMethodError`s, etc.
+  - All we really need to know is what database engine to stand up.
+* Require database user/password to be added manually to Kuby config.
+
+## 0.9.1
+* Run dev setup when asked to.
+  - Bug caused dev setup to be skipped even when requested.
+* Deployer should be tolerant of missing namespace.
+
 ## 0.9.0
 * Add support for developing your app using a local Kubernetes cluster.
   - Includes a default `:development` Kuby environment.

data/Gemfile

@@ -5,6 +5,7 @@ gemspec
 group :development, :test do
   gem 'pry-byebug'
   gem 'rake'
+  gem 'sorbet', '~> 0.5'
 end
 
 group :test do

data/README.md

@@ -1,5 +1,7 @@
 ## Kuby
 
+[![Build Status](https://travis-ci.com/getkuby/kuby-core.svg?branch=master)](https://travis-ci.com/getkuby/kuby-core)
+
 Deploy your Rails app the easy way.
 
 ## What is Kuby?
@@ -20,11 +22,11 @@ Kuby embraces the same convention-over-configuration approach that Rails does. I
 
 ## Getting Started
 
-See the [Quick Start Guide](https://github.com/getkuby/kuby-core/wiki/Quick-Start-Guide)
+See the [Quick Start Guide](https://getkuby.io/docs)
 
 ## More Info
 
-See the [wiki](https://github.com/getkuby/kuby-core/wiki).
+Check out [getkuby.io](https://getkuby.io).
 
 ## Running Tests
 

data/kuby-core.gemspec

@@ -20,11 +20,12 @@ Gem::Specification.new do |s|
   # 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.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 'railties', '>= 5.1'
   s.add_dependency 'rouge', '~> 3.0'
+  s.add_dependency 'sorbet-runtime-stub', '~> 0.2'
 
   s.add_development_dependency 'rspec'
 

data/lib/kuby-core.rb

@@ -0,0 +1 @@
+require 'kuby'

data/lib/kuby.rb

@@ -1,3 +1,6 @@
+# typed: false
+
+require 'sorbet-runtime-stub'
 require 'kuby/railtie'
 
 begin
@@ -23,6 +26,8 @@ module Kuby
   autoload :TrailingHash,   'kuby/trailing_hash'
 
   DEFAULT_ENV = 'development'.freeze
+  DEFAULT_DB_USER = 'root'.freeze
+  DEFAULT_DB_PASSWORD = 'password'.freeze
 
   class UndefinedEnvironmentError < StandardError; end
   class MissingConfigError < StandardError; end
@@ -52,6 +57,11 @@ module Kuby
         kubernetes do
           add_plugin(:rails_app) do
             tls_enabled false
+
+            database do
+              user(DEFAULT_DB_USER) if respond_to?(:user)
+              password(DEFAULT_DB_PASSWORD) if respond_to?(:password)
+            end
           end
 
           provider :docker_desktop
@@ -62,6 +72,10 @@ module Kuby
         env.kubernetes.after_configuration
       end
 
+      @definition.environments.each do |_, env|
+        env.configured = true
+      end
+
       @definition
     end
 

data/lib/kuby/basic_logger.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'logger'
 require 'colorized_string'
 

data/lib/kuby/cli_base.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'open3'
 require 'thread'
 
@@ -81,18 +82,42 @@ module Kuby
     end
 
     def systemm(cmd)
+      if stdout == STDOUT && stderr == STDERR
+        systemm_default(cmd)
+      else
+        systemm_open3(cmd)
+      end
+    end
+
+    def systemm_default(cmd)
+      run_before_callbacks(cmd)
+      cmd_s = cmd.join(' ')
+      system(cmd_s).tap do
+        self.last_status = $?
+        run_after_callbacks(cmd)
+      end
+    end
+
+    def systemm_open3(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
 
       Open3.popen3(cmd_s) do |p_stdin, p_stdout, p_stderr, wait_thread|
         Thread.new(stdout) do |t_stdout|
-          p_stdout.each { |line| t_stdout.puts(line) }
+          begin
+            p_stdout.each { |line| t_stdout.puts(line) }
+          rescue IOError
+          end
         end
 
         Thread.new(stderr) do |t_stderr|
-          p_stderr.each { |line| t_stderr.puts(line) }
+          begin
+            p_stderr.each { |line| t_stderr.puts(line) }
+          rescue IOError
+          end
         end
 
+        p_stdin.close
         self.last_status = wait_thread.value
         run_after_callbacks(cmd)
         wait_thread.join
@@ -100,19 +125,43 @@ module Kuby
     end
 
     def backticks(cmd)
+      if stdout == STDOUT && stderr == STDERR
+        backticks_default(cmd)
+      else
+        backticks_open3(cmd)
+      end
+    end
+
+    def backticks_default(cmd)
+      run_before_callbacks(cmd)
+      cmd_s = cmd.join(' ')
+      `#{cmd_s}`.tap do
+        self.last_status = $?
+        run_after_callbacks(cmd)
+      end
+    end
+
+    def backticks_open3(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
       result = StringIO.new
 
       Open3.popen3(cmd_s) do |p_stdin, p_stdout, p_stderr, wait_thread|
         Thread.new do
-          p_stdout.each { |line| result.puts(line) }
+          begin
+            p_stdout.each { |line| result.puts(line) }
+          rescue IOError
+          end
         end
 
         Thread.new(stderr) do |t_stderr|
-          p_stderr.each { |line| t_stderr.puts(line) }
+          begin
+            p_stderr.each { |line| t_stderr.puts(line) }
+          rescue IOError
+          end
         end
 
+        p_stdin.close
         self.last_status = wait_thread.value
         run_after_callbacks(cmd)
         wait_thread.join

data/lib/kuby/commands.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'kuby/version'
 require 'gli'
 
@@ -17,9 +18,9 @@ module Kuby
     # is no singleton class version of #prepend in the Ruby language).
     singleton_class.send(:prepend, Module.new do
       def run(args)
-        if idx = args.index('rails')
-          @rails_options = args[(idx + 1)..-1]
-          super(args[0..(idx + 1)])
+        if idx = args.index('rails') || idx = args.index('rake')
+          @rails_options = args[idx..-1]
+          super(args[0..idx])
         else
           super
         end
@@ -27,7 +28,13 @@ module Kuby
     end)
 
     def self.tasks
-      Kuby::Tasks.new(Kuby.definition.environment)
+      Kuby::Tasks.new(Kuby.environment)
+    end
+
+    def self.must_be_dev_env!
+      unless Kuby.environment.development?
+        fail "Command not supported in the '#{Kuby.environment.name}' environment"
+      end
     end
 
     program_desc 'Kuby command-line interface. Kuby is a convention '\
@@ -57,9 +64,16 @@ module Kuby
     # commands are handled by the RailsCommands class.
     desc 'Runs a Rails command.'
     command :rails do |rc|
+      rc.action do |global_options, options, args|
+        must_be_dev_env!
+        exit 1 unless tasks.dev_deployment_ok
+        Kuby::RailsCommands.run(@rails_options)
+      end
+
       rc.desc 'Runs the rails server (run `rails server --help` for options)'
       rc.command [:server, :s] do |c|
         c.action do |global_options, options, args|
+          must_be_dev_env!
           exit 1 unless tasks.dev_deployment_ok
           Kuby::RailsCommands.run(@rails_options)
         end
@@ -68,6 +82,7 @@ module Kuby
       rc.desc 'Runs a script in the Rails environment (run `rails runner --help` for options)'
       rc.command [:runner, :r] do |c|
         c.action do |global_options, options, args|
+          must_be_dev_env!
           exit 1 unless tasks.dev_deployment_ok
           Kuby::RailsCommands.run(@rails_options)
         end
@@ -77,12 +92,22 @@ module Kuby
         '(run `rails console --help` for options)'
       rc.command [:console, :c] do |c|
         c.action do |global_options, options, args|
+          must_be_dev_env!
           exit 1 unless tasks.dev_deployment_ok
           Kuby::RailsCommands.run(@rails_options)
         end
       end
     end
 
+    desc 'Runs a rake task.'
+    command :rake do |rc|
+      rc.action do |global_options, options, args|
+        must_be_dev_env!
+        exit 1 unless tasks.dev_deployment_ok
+        Kuby::RailsCommands.run(@rails_options)
+      end
+    end
+
     desc 'Builds the Docker image.'
     command :build do |c|
       c.action do |global_options, options, args|

data/lib/kuby/definition.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Kuby
   class Definition
     attr_reader :app_name

data/lib/kuby/dev_setup.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Kuby
   class Spinner
     PIECES = %w(- \\ | /).freeze

data/lib/kuby/docker.rb

@@ -1,3 +1,5 @@
+# typed: strict
+
 require 'kuby/docker/errors'
 
 module Kuby
@@ -10,6 +12,7 @@ module Kuby
     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 :InlineLayer,    'kuby/docker/inline_layer'
     autoload :Layer,          'kuby/docker/layer'

data/lib/kuby/docker/alpine.rb

@@ -1,40 +1,43 @@
+# typed: strict
+
 module Kuby
   module Docker
-    class Alpine
-      SHELL_EXE = '/bin/sh'.freeze
+    class Alpine < Distro
+      SHELL_EXE = T.let('/bin/sh'.freeze, String)
 
-      DEFAULT_PACKAGES = [
-        [:ca_certificates],
+      DEFAULT_PACKAGES = T.let([
+        [:ca_certificates, nil],
         [:nodejs, '12.14.1'],
         [:yarn, '1.21.1'],
-        [:c_toolchain],
-        [:tzdata]
-      ].freeze
+        [:c_toolchain, nil],
+        [:tzdata, nil]
+      ].freeze, T::Array[[Symbol, T.nilable(String)]])
 
+      sig { returns(Layer) }
       attr_reader :phase
 
-      def initialize(phase)
-        @phase = phase
-      end
-
+      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)]]) }
       def default_packages
         DEFAULT_PACKAGES
       end
 
+      sig { override.returns(String) }
       def shell_exe
         SHELL_EXE
       end
 
       private
 
+      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_managed(packages, dockerfile)
-        pkgs = packages.select(&:managed?)
+        pkgs = T.cast(packages.select(&:managed?), T::Array[Distro::ManagedPackageImpl])
 
         unless pkgs.empty?
           package_names = pkgs.map { |pkg| pkg.package_name_for(:alpine) }
@@ -44,6 +47,7 @@ module Kuby
         end
       end
 
+      sig { params(packages: T::Array[Distro::PackageImpl], dockerfile: Dockerfile).void }
       def install_unmanaged(packages, dockerfile)
         packages
           .reject(&:managed?)

data/lib/kuby/docker/assets_phase.rb

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

data/lib/kuby/docker/bundler_phase.rb

@@ -1,12 +1,44 @@
+# typed: strict
+
 require 'pathname'
 
 module Kuby
   module Docker
     class BundlerPhase < Layer
-      DEFAULT_WITHOUT = ['development', 'test', 'deploy'].freeze
+      extend T::Sig
+
+      DEFAULT_WITHOUT = T.let(
+        ['development', 'test', 'deploy'].freeze, T::Array[String]
+      )
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :version
+
+      sig { params(version: String).void }
+      attr_writer :version
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :gemfile
 
-      attr_accessor :version, :gemfile, :without
+      sig { params(gemfile: String).void }
+      attr_writer :gemfile
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :without
+
+      sig { params(without: T::Array[String]).void }
+      attr_writer :without
+
+      sig { params(environment: Environment).void }
+      def initialize(environment)
+        super
+
+        @version = T.let(@version, T.nilable(String))
+        @gemfile = T.let(@gemfile, T.nilable(String))
+        @without = T.let(@without, T.nilable(T::Array[String]))
+      end
 
+      sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         gf = gemfile || default_gemfile
         lf = "#{gf}.lock"
@@ -41,10 +73,12 @@ module Kuby
 
       private
 
+      sig { returns(String) }
       def default_version
         Bundler::VERSION
       end
 
+      sig { returns(String) }
       def default_gemfile
         Bundler
           .definition