kuby-core 0.17.0 → 0.19.0

data/lib/kuby/plugins/rails_app/sqlite.rb

@@ -6,7 +6,7 @@ module Kuby
       class Sqlite < ::Kuby::Plugin
         attr_reader :environment
 
-        def initialize(environment, *)
+        def initialize(environment, *_)
           @environment = environment
         end
 
@@ -15,8 +15,12 @@ module Kuby
           environment.docker.package_phase.add(:sqlite_client)
         end
 
-        def requires_credentials?
-          false
+        def configure_pod_spec(_pod_spec)
+          # no configuration steps necessary
+        end
+
+        def bootstrap
+          # no boostrap steps necessary
         end
 
         def user(_user)

data/lib/kuby/plugins/rails_app/tasks.rake

@@ -7,29 +7,42 @@ namespace :kuby do
         Kuby.load!
 
         config_file = File.join(Kuby.environment.kubernetes.plugin(:rails_app).root, 'config', 'database.yml')
-        database = Kuby.environment.kubernetes.plugin(:rails_app).database
 
-        if database.plugin.respond_to?(:rewritten_configs)
-          File.write(config_file, YAML.dump(database.plugin.rewritten_configs))
-          Kuby.logger.info("Wrote #{config_file}")
+        if rails_app = Kuby.environment.kubernetes.plugin(:rails_app)
+          database = rails_app.database
+
+          if database.plugin.respond_to?(:rewritten_configs)
+            File.write(config_file, YAML.dump(database.plugin.rewritten_configs))
+            Kuby.logger.info("Wrote #{config_file}")
+          end
         end
       end
 
-      task :create_unless_exists do
-        begin
-          Rake::Task['environment'].invoke
-          ActiveRecord::Base.connection
-        rescue ActiveRecord::NoDatabaseError => e
-          Rake::Task['db:create'].invoke
+      task :bootstrap do
+        Kuby.load!
+
+        if rails_app = Kuby.environment.kubernetes.plugin(:rails_app)
+          if database = rails_app.database
+            database.plugin.bootstrap
+          end
         end
       end
+
+      task :migrate do
+        next unless Kernel.const_defined?('::ActiveRecord')
+
+        Rake::Task['environment'].invoke
+        Rake::Task['db:migrate'].invoke
+      end
     end
 
     namespace :assets do
       task :copy do
         Kuby.load!
-        assets = Kuby.environment.kubernetes.plugin(:rails_assets)
-        assets.copy_task.run
+
+        if assets = Kuby.environment.kubernetes.plugin(:rails_assets)
+          assets.copy_task.run
+        end
       end
     end
   end

data/lib/kuby/plugins/rails_app.rb

@@ -5,6 +5,7 @@ module Kuby
       autoload :AssetCopyTask,   'kuby/plugins/rails_app/asset_copy_task'
       autoload :AssetsImage,     'kuby/plugins/rails_app/assets_image'
       autoload :Assets,          'kuby/plugins/rails_app/assets'
+      autoload :CRDB,            'kuby/plugins/rails_app/crdb'
       autoload :Database,        'kuby/plugins/rails_app/database'
       autoload :MySQL,           'kuby/plugins/rails_app/mysql'
       autoload :Plugin,          'kuby/plugins/rails_app/plugin'

data/lib/kuby/plugins/system.rb

@@ -0,0 +1,16 @@
+# typed: true
+
+require 'kube-dsl'
+
+module Kuby
+  module Plugins
+    class System < ::Kuby::Plugin
+      # Kubernetes maintains backwards compatibility for the three most recent
+      # minor versions. In other words, everything that works in v1.23 also works
+      # in v1.22 and v1.21. Kuby tries to do the same. As of the time of this
+      # writing, the most recent k8s release is v1.23, so Kuby supports v1.21 and up.
+      depends_on :kubernetes, '~> 1.21'
+      depends_on :kubectl, '~> 1.21'
+    end
+  end
+end

data/lib/kuby/plugins.rb

@@ -3,5 +3,6 @@ module Kuby
   module Plugins
     autoload :NginxIngress, 'kuby/plugins/nginx_ingress'
     autoload :RailsApp,     'kuby/plugins/rails_app'
+    autoload :System,       'kuby/plugins/system'
   end
 end

data/lib/kuby/railtie.rb

@@ -1,11 +1,41 @@
-# typed: strict
+# typed: ignore
+
 require 'logger'
 require 'rails/railtie'
+require 'rails/command'
+require 'rails/commands/dbconsole/dbconsole_command'
 
 module Kuby
+  module CockroachConsoleMonkeypatch
+    def start
+      config_hash = if respond_to?(:config)
+        config_hash = config
+      else
+        config_hash = db_config.configuration_hash.stringify_keys
+      end
+
+      return super unless config_hash['adapter'] == 'cockroachdb'
+
+      ENV['PGUSER']         = config_hash['username'] if config_hash['username']
+      ENV['PGHOST']         = config_hash['host'] if config_hash['host']
+      ENV['PGPORT']         = config_hash['port'].to_s if config_hash['port']
+      ENV['PGPASSWORD']     = config_hash['password'].to_s if config_hash['password'] && @options['include_password']
+      ENV['PGSSLMODE']      = config_hash['sslmode'].to_s if config_hash['sslmode']
+      ENV['PGSSLCERT']      = config_hash['sslcert'].to_s if config_hash['sslcert']
+      ENV['PGSSLKEY']       = config_hash['sslkey'].to_s if config_hash['sslkey']
+      ENV['PGSSLROOTCERT']  = config_hash['sslrootcert'].to_s if config_hash['sslrootcert']
+
+      find_cmd_and_exec('psql', config_hash['database'])
+    end
+  end
+
   class Railtie < ::Rails::Railtie
     initializer 'kuby.health_check_middleware' do |app|
       app.middleware.use Kuby::Middleware::HealthCheck
     end
+
+    initializer 'kuby.cockroachdb_console_support' do
+      Rails::DBConsole.prepend(CockroachConsoleMonkeypatch)
+    end
   end
 end

data/lib/kuby/tasks.rb

@@ -1,4 +1,5 @@
 # typed: false
+require 'rake'
 require 'rouge'
 
 module Kuby
@@ -9,9 +10,9 @@ module Kuby
       @environment = environment
     end
 
-    def print_dockerfiles(only: nil)
+    def print_dockerfiles(only: [])
       kubernetes.docker_images.each do |image|
-        next if only && image.identifier != only
+        next unless only.empty? || only.include?(image.identifier)
 
         image = image.current_version
         identifier = image.identifier ? " ##{image.identifier}" : ""
@@ -28,10 +29,63 @@ module Kuby
       environment.kubernetes.setup(only: only.map(&:to_sym))
     end
 
-    def build(build_args = {}, docker_args = [], only: [], ignore_missing_args: false, context: nil)
+    def remove_plugin(name)
+      plugin = environment.kubernetes.plugin(name)
+
+      # Allow running uninstallation procedures for plugins that are no longer part
+      # of the environment. This is especially useful for plugins Kuby adds by default
+      # in one version and removes in another, like KubeDB.
+      plugin ||= if plugin_class = Kuby.plugins.find(name.to_sym)
+        plugin_class.new(environment)
+      end
+
+      unless plugin
+        Kuby.logger.fatal(
+          "No plugin found named '#{name}'. Run `kuby plugin list -a` to show a list of all available plugins."
+        )
+
+        exit 1
+      end
+
+      plugin.remove
+    end
+
+    def list_plugins(all: false)
+      Kuby.plugins.each do |name, _|
+        if environment.kubernetes.plugins.include?(name)
+          Kuby.logger.info("* #{name}")
+        elsif all
+          Kuby.logger.info("  #{name}")
+        end
+      end
+    end
+
+    def run_rake_tasks(tasks)
+      if tasks.empty?
+        Kuby.logger.fatal('Please specify at least one task to run.')
+        exit 1
+      end
+
+      Kuby.load_rake_tasks!
+      Rake::Task[tasks.join(' ')].invoke
+    end
+
+    def list_rake_tasks
+      Kuby.load_rake_tasks!
+
+      rows = Rake::Task.tasks.map do |task|
+        [task.name, task.full_comment || '']
+      end
+
+      puts Kuby::Utils::Table.new(%w(NAME DESCRIPTION), rows).to_s
+    end
+
+    def build(build_args = {}, docker_args = [], only: [], ignore_missing_args: false, context: nil, cache_from_latest: true)
       check_platform(docker_args)
 
-      build_args['RAILS_MASTER_KEY'] ||= rails_app.master_key
+      if master_key = rails_app.master_key
+        build_args['RAILS_MASTER_KEY'] = master_key
+      end
 
       check_build_args(build_args) unless ignore_missing_args
 
@@ -39,9 +93,22 @@ module Kuby
         next unless only.empty? || only.include?(image.identifier)
         return unless perform_docker_login_if_necessary(image)
 
+        build_kwargs = {}
+
+        if cache_from_latest
+          latest_image_url = "#{image.image_url}:#{Kuby::Docker::LATEST_TAG}"
+          Kuby.logger.info("Pulling image #{latest_image_url}")
+
+          begin
+            image.pull(Kuby::Docker::LATEST_TAG)
+            build_kwargs[:cache_from] = latest_image_url
+          rescue Kuby::Docker::PullError
+          end
+        end
+
         image = image.new_version
         Kuby.logger.info("Building image #{image.image_url} with tags #{image.tags.join(', ')}")
-        image.build(build_args, docker_args, context: context)
+        image.build(build_args, docker_args, context: context, **build_kwargs)
       end
     end
 

data/lib/kuby/trailing_hash.rb

@@ -3,14 +3,14 @@
 module Kuby
   class TrailingHash < Hash
     def each(&block)
-      return to_enum(T.must(__method__)) unless block_given?
+      return to_enum(__method__) unless block_given?
 
       seen_keys = []
       keys_before = keys
 
       until keys_before.empty?
         keys_before.each do |k|
-          yield k, T.must(self[k])
+          yield k, self[k]
           seen_keys << k
         end
 

data/lib/kuby/utils/sem_ver/constraint.rb

@@ -0,0 +1,68 @@
+module Kuby
+  module Utils
+    module SemVer
+      class Constraint
+        OPERATOR_MAP = {
+          '='  => :eq,
+          '>'  => :gt,
+          '>=' => :gteq,
+          '<'  => :lt,
+          '<=' => :lteq,
+          '~>' => :waka
+        }
+
+        OPERATOR_MAP.freeze
+
+        OPERATOR_INVERSE = OPERATOR_MAP.invert.freeze
+
+        attr_reader :operator, :version
+
+        def self.parse(str)
+          op, ver = str.split(' ')
+          new(OPERATOR_MAP.fetch(op), Version.parse(ver, default: nil))
+        end
+
+        def initialize(operator, version)
+          @operator = operator
+          @version = version
+        end
+
+        def to_s
+          @str ||= "#{OPERATOR_INVERSE[operator]} #{version}"
+        end
+
+        def satisfied_by?(other_version)
+          case operator
+            when :waka
+              arr = version.to_a
+              other_arr = other_version.to_a
+
+              arr.each_with_index do |digit, idx|
+                break unless digit
+
+                next_digit = arr[idx + 1]
+
+                if next_digit
+                  return false if other_arr[idx] != digit
+                else
+                  return false if other_arr[idx] < digit
+                end
+              end
+
+              true
+            when :eq
+              other_version == version
+            when :gt
+              other_version > version
+            when :gteq
+              other_version >= version
+            when :lt
+              other_version < version
+            when :lteq
+              other_version <= version
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/utils/sem_ver/constraint_set.rb

@@ -0,0 +1,25 @@
+module Kuby
+  module Utils
+    module SemVer
+      class ConstraintSet
+        attr_reader :constraints
+
+        def self.parse(*arr)
+          new(arr.map { |c| Constraint.parse(c) })
+        end
+
+        def initialize(constraints)
+          @constraints = constraints
+        end
+
+        def satisfied_by?(version)
+          constraints.all? { |c| c.satisfied_by?(version) }
+        end
+
+        def to_s
+          @str ||= constraints.map(&:to_s).join(', ')
+        end
+      end
+    end
+  end
+end

data/lib/kuby/utils/sem_ver/version.rb

@@ -0,0 +1,49 @@
+module Kuby
+  module Utils
+    module SemVer
+      class Version
+        include Comparable
+
+        attr_reader :major, :minor, :patch
+
+        def self.parse(str, default: 0)
+          major, minor, patch = str.split('.')
+
+          new(
+            major ? major.to_i : default,
+            minor ? minor.to_i : default,
+            patch ? patch.to_i : default
+          )
+        end
+
+        def initialize(major, minor, patch)
+          @major = major
+          @minor = minor
+          @patch = patch
+        end
+
+        def to_s
+          @str ||= [major, minor, patch].compact.join('.')
+        end
+
+        def to_a
+          @arr ||= [major, minor, patch]
+        end
+
+        def <=>(other)
+          other_arr = other.to_a
+
+          to_a.each_with_index do |digit, idx|
+            other_digit = other_arr[idx] || 0
+
+            if digit != other_digit
+              return digit <=> other_digit
+            end
+          end
+
+          0
+        end
+      end
+    end
+  end
+end

data/lib/kuby/utils/sem_ver.rb

@@ -0,0 +1,17 @@
+module Kuby
+  module Utils
+    module SemVer
+      autoload :Constraint,    'kuby/utils/sem_ver/constraint'
+      autoload :ConstraintSet, 'kuby/utils/sem_ver/constraint_set'
+      autoload :Version,       'kuby/utils/sem_ver/version'
+
+      def self.parse_version(str)
+        Version.parse(str)
+      end
+
+      def self.parse_constraints(*strs)
+        ConstraintSet.parse(*strs)
+      end
+    end
+  end
+end

data/lib/kuby/utils/which.rb

@@ -0,0 +1,65 @@
+module Kuby
+  module Utils
+    # This code was copied from the ptools gem, licensed under the Artistic v2 license:
+    # https://github.com/djberg96/ptools/blob/4ef26adc870cf02b8342df58da53c61bcd4af6c4/lib/ptools.rb
+    #
+    # Only the #which function and dependent constants have been copied. None of the copied code
+    # has been modified.
+    #
+    module Which
+      if File::ALT_SEPARATOR
+        MSWINDOWS = true
+        if ENV['PATHEXT']
+          WIN32EXTS = ".{#{ENV['PATHEXT'].tr(';', ',').tr('.', '')}}".downcase
+        else
+          WIN32EXTS = '.{exe,com,bat}'.freeze
+        end
+      else
+        MSWINDOWS = false
+      end
+
+      def which(program, path = ENV['PATH'])
+        raise ArgumentError, 'path cannot be empty' if path.nil? || path.empty?
+
+        # Bail out early if an absolute path is provided.
+        if program =~ /^\/|^[a-z]:[\\\/]/i
+          program += WIN32EXTS if MSWINDOWS && File.extname(program).empty?
+          found = Dir[program].first
+          if found && File.executable?(found) && !File.directory?(found)
+            return found
+          else
+            return nil
+          end
+        end
+
+        # Iterate over each path glob the dir + program.
+        path.split(File::PATH_SEPARATOR).each do |dir|
+          dir = File.expand_path(dir)
+
+          next unless File.exist?(dir) # In case of bogus second argument
+
+          file = File.join(dir, program)
+
+          # Dir[] doesn't handle backslashes properly, so convert them. Also, if
+          # the program name doesn't have an extension, try them all.
+          if MSWINDOWS
+            file = file.tr(File::ALT_SEPARATOR, File::SEPARATOR)
+            file += WIN32EXTS if File.extname(program).empty?
+          end
+
+          found = Dir[file].first
+
+          # Convert all forward slashes to backslashes if supported
+          if found && File.executable?(found) && !File.directory?(found)
+            found.tr!(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
+            return found
+          end
+        end
+
+        nil
+      end
+
+      extend(self)
+    end
+  end
+end

data/lib/kuby/utils.rb

@@ -1,5 +1,11 @@
 module Kuby
   module Utils
-    autoload :Table, 'kuby/utils/table'
+    autoload :SemVer, 'kuby/utils/sem_ver'
+    autoload :Table,  'kuby/utils/table'
+    autoload :Which,  'kuby/utils/which'
+
+    def self.which(*args)
+      Which.which(*args)
+    end
   end
 end

data/lib/kuby/version.rb

@@ -1,5 +1,5 @@
 # typed: true
 
 module Kuby
-  VERSION = '0.17.0'.freeze
+  VERSION = '0.19.0'.freeze
 end

data/lib/kuby.rb

@@ -1,7 +1,9 @@
-# typed: false
+# typed: ignore
 
-require 'sorbet-runtime-stub'
 require 'kuby/railtie'
+require 'kubectl-rb/version'
+require 'helm-rb/version'
+require 'yaml'
 
 begin
   require 'kuby/plugins/rails_app/generators/kuby'
@@ -13,6 +15,8 @@ module Kuby
   autoload :CLIBase,        'kuby/cli_base'
   autoload :Commands,       'kuby/commands'
   autoload :Definition,     'kuby/definition'
+  autoload :Dependable,     'kuby/dependable'
+  autoload :Dependency,     'kuby/dependency'
   autoload :Docker,         'kuby/docker'
   autoload :Environment,    'kuby/environment'
   autoload :Kubernetes,     'kuby/kubernetes'
@@ -22,6 +26,7 @@ module Kuby
   autoload :Plugins,        'kuby/plugins'
   autoload :Tasks,          'kuby/tasks'
   autoload :TrailingHash,   'kuby/trailing_hash'
+  autoload :Utils,          'kuby/utils'
 
   DEFAULT_ENV = 'development'.freeze
   DEFAULT_DB_USER = 'root'.freeze
@@ -119,6 +124,14 @@ module Kuby
       @packages ||= {}
     end
 
+    def register_dependable(name, version_or_callable)
+      dependables[name] = Dependable.new(name, version_or_callable)
+    end
+
+    def dependables
+      @dependables ||= {}
+    end
+
     def env=(env_name)
       @env = env_name.to_s
     end
@@ -128,6 +141,18 @@ module Kuby
         (@env || Rails.env rescue nil || DEFAULT_ENV).to_s
       end
     end
+
+    def load_rake_tasks!
+      Rake::TaskManager.record_task_metadata = true
+
+      Kuby.plugins.each do |_, plugin_klass|
+        plugin_klass.task_dirs.each do |task_dir|
+          Dir.glob(File.join(task_dir, '*.rake')).each do |path|
+            Rake.load_rakefile(path)
+          end
+        end
+      end
+    end
   end
 end
 
@@ -136,6 +161,7 @@ Kuby.register_provider(:docker_desktop, Kuby::Kubernetes::DockerDesktopProvider)
 Kuby.register_provider(:bare_metal, Kuby::Kubernetes::BareMetalProvider)
 
 # plugins
+Kuby.register_plugin(:system, Kuby::Plugins::System)
 Kuby.register_plugin(:rails_app, Kuby::Plugins::RailsApp::Plugin)
 Kuby.register_plugin(:nginx_ingress, Kuby::Plugins::NginxIngress)
 
@@ -156,3 +182,12 @@ Kuby.register_package(:c_toolchain,
 )
 
 Kuby.register_package(:git, 'git')
+
+# dependables
+Kuby.register_dependable(:kubectl, KubectlRb::KUBECTL_VERSION)
+Kuby.register_dependable(:helm, HelmRb::HELM_VERSION)
+Kuby.register_dependable(:kubernetes, -> {
+  version_info = Kuby.environment.kubernetes.provider.kubernetes_cli.version
+  version = version_info.dig('serverVersion', 'gitVersion')
+  version.sub(/\Av/, '')
+})