kuby-core 0.9.1 → 0.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8202396d9daaa1ccba46f2b607f90b64e615b9d44a2f87cbfef1682dadd8a8d1
-  data.tar.gz: a6ad5b2436b1aacdc097ffd2ff03a2ad993d62747f6e8a54126239c0c42ac628
+  metadata.gz: a3a59a9d3e923807647da18d834d994cc7b2d149f4c82d6d9966d72748d7bcd5
+  data.tar.gz: 2bbd8e7d1c92ed3d0eb7d6d05420d7119d6f20a249f4401e52191868baeb0996
 SHA512:
-  metadata.gz: 2f1c577697475d726c38a74f20ec881613e03be19de90dc4843cee795fe54ec69cdfd23296e60c56db3611707fc397408ca7bbddf257b8a70c84af65d5cf2edd
-  data.tar.gz: a732245dd7b3a23aa7a0bfeaa8c53b7f057c1a60ac5d4a667b11c966fcc31354df068276624e0c5d8a8c893ef1ea6e779d602087a6ed86ccbdb507664e69abbf
+  metadata.gz: d8bf5fce8051029c8231e915035ec6c704ab361a6008b5335bf8a6747fb106ed55869164bb15eb704ecd72e6366ee320664d23d128a74726b6ca320edcb5c442
+  data.tar.gz: 679ad59207c201fb710e47e69c4682676a6fb12c826b59350a74d98c48f212d358c50fde0f8da0a5804391738d442a839cb4560d2cebd61ec7e7955677bd8e53

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+## 0.11.2
+* Attempt to auto-require the requested provider if it isn't registered.
+* Adjust error message when provider can't be found to include reminder to add a require statement.
+
+## 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.

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,9 +1,30 @@
+# typed: strict
+
 require 'logger'
 require 'colorized_string'
 
 module Kuby
   class BasicLogger < Logger
-    def initialize(*args)
+    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
+    }
+    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))
+
       super
 
       self.formatter = proc do |_severity, _datetime, _progname, msg|
@@ -11,23 +32,51 @@ module Kuby
       end
     end
 
-    def info(msg, *args)
-      super(ColorizedString[msg].yellow, *args)
+    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 }
+      else
+        super(ColorizedString[progname_or_msg].yellow)
+      end
     end
 
-    def fatal(msg, *args)
-      super(ColorizedString[msg].red, *args)
+    sig {
+      override.params(
+        progname_or_msg: T.untyped,
+        block: T.nilable(T.proc.returns(T.untyped))
+      ).void
+    }
+    def fatal(progname_or_msg, &block)
+      if block
+        super(progname_or_msg) { ColorizedString[block.call].red }
+      else
+        super(ColorizedString[progname_or_msg].red)
+      end
     end
 
     # adhere to the "CLI" interface
-    def with_pipes(out = STDOUT, err = STDERR)
-      previous_logdev = @logdev || STDERR
+    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)
       yield
     ensure
       reopen(previous_logdev)
     end
 
+    sig { returns(T.nilable(Process::Status)) }
     def last_status
       nil
     end

data/lib/kuby/cli_base.rb

@@ -1,23 +1,39 @@
+# typed: strict
+
 require 'open3'
 require 'thread'
 
 module Kuby
   class CLIBase
+    extend T::Sig
+
+    sig { returns(T.nilable(Process::Status)) }
     def last_status
       Thread.current[status_key]
     end
 
+    sig { params(block: T.proc.params(cmd: String).void).void }
     def before_execute(&block)
+      @before_execute = T.let(@before_execute, T.nilable(T::Array[T.proc.params(cmd: String).void]))
       @before_execute ||= []
       @before_execute << block
     end
 
+    sig { params(block: T.proc.params(cmd: String).void).void }
     def after_execute(&block)
+      @after_execute = T.let(@after_execute, T.nilable(T::Array[T.proc.params(cmd: String).void]))
       @after_execute ||= []
       @after_execute << block
     end
 
-    def with_pipes(out = STDOUT, err = STDERR)
+    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
       self.stdout = out
@@ -28,29 +44,39 @@ module Kuby
       self.stderr = previous_stderr
     end
 
+    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 }
     def stdout=(new_stdout)
       Thread.current[stdout_key] = new_stdout
     end
 
+    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 }
     def stderr=(new_stderr)
       Thread.current[stderr_key] = new_stderr
     end
 
     private
 
-    def open3_w(env, cmd, opts = {}, &block)
+    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(' ')
 
-      Open3.popen3(env, cmd_s, opts) do |p_stdin, p_stdout, p_stderr, wait_thread|
+      Open3.popen3(cmd_s) do |p_stdin, p_stdout, p_stderr, wait_thread|
         Thread.new(stdout) do |t_stdout|
           begin
             p_stdout.each { |line| t_stdout.puts(line) }
@@ -65,55 +91,111 @@ module Kuby
           end
         end
 
-        yield(p_stdin).tap do
-          p_stdin.close
-          self.last_status = wait_thread.value
-          run_after_callbacks(cmd)
-          wait_thread.join
-        end
+        yield(p_stdin)
+
+        p_stdin.close
+        self.last_status = T.cast(wait_thread.value, Process::Status)
+        run_after_callbacks(cmd)
+        wait_thread.join
       end
     end
 
+    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 }
     def systemm(cmd)
+      if stdout == STDOUT && stderr == STDERR
+        systemm_default(cmd)
+      else
+        systemm_open3(cmd)
+      end
+    end
+
+    sig { params(cmd: T::Array[String]).void }
+    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
+
+    sig { params(cmd: T::Array[String]).void }
+    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
 
-        self.last_status = wait_thread.value
+        p_stdin.close
+        self.last_status = T.cast(wait_thread.value, Process::Status)
         run_after_callbacks(cmd)
         wait_thread.join
       end
     end
 
+
+    sig { params(cmd: T::Array[String]).returns(String) }
     def backticks(cmd)
+      if stdout == STDOUT && stderr == STDERR
+        backticks_default(cmd)
+      else
+        backticks_open3(cmd)
+      end
+    end
+
+    sig { params(cmd: T::Array[String]).returns(String) }
+    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
+
+    sig { params(cmd: T::Array[String]).returns(String) }
+    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
 
-        self.last_status = wait_thread.value
+        p_stdin.close
+        self.last_status = T.cast(wait_thread.value, Process::Status)
         run_after_callbacks(cmd)
         wait_thread.join
       end
@@ -121,26 +203,32 @@ module Kuby
       result.string
     end
 
+    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 }
     def run_after_callbacks(cmd)
       (@after_execute || []).each { |cb| cb.call(cmd, last_status) }
     end
 
+    sig { params(status: Process::Status).void }
     def last_status=(status)
       Thread.current[status_key] = status
     end
 
+    sig { returns(Symbol) }
     def status_key
       raise NotImplementedError, "#{__method__} must be defined in derived classes"
     end
 
+    sig { returns(Symbol) }
     def stdout_key
       raise NotImplementedError, "#{__method__} must be defined in derived classes"
     end
 
+    sig { returns(Symbol) }
     def stderr_key
       raise NotImplementedError, "#{__method__} must be defined in derived classes"
     end