kuby-core 0.16.0 → 0.18.0

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

@@ -1,4 +1,5 @@
-# typed: true
+# typed: false
+
 require 'rails/generators'
 require 'rails/generators/base'
 
@@ -14,14 +15,6 @@ class KubyGenerator < Rails::Generators::Base
   end
 
   def create_config_file
-    app_class = Rails.application.class
-
-    app_name = if app_class.respond_to?(:module_parent_name)
-      app_class.module_parent_name
-    else
-      app_class.parent_name
-    end
-
     create_file(
       'kuby.rb',
       <<~END
@@ -59,13 +52,7 @@ class KubyGenerator < Rails::Generators::Base
 
             kubernetes do
               # Add a plugin that facilitates deploying a Rails app.
-              add_plugin :rails_app do
-                # configure database credentials
-                database do
-                  user app_creds[:KUBY_DB_USER]
-                  password app_creds[:KUBY_DB_PASSWORD]
-                end
-              end
+              add_plugin :rails_app
 
               # Use Docker Desktop as the provider.
               # See: https://www.docker.com/products/docker-desktop
@@ -121,4 +108,18 @@ class KubyGenerator < Rails::Generators::Base
       END
     )
   end
+
+  private
+
+  def app_name
+    @app_name ||= begin
+      app_class = Rails.application.class
+
+      if app_class.respond_to?(:module_parent_name)
+        app_class.module_parent_name
+      else
+        app_class.parent_name
+      end
+    end
+  end
 end

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

@@ -1,4 +1,5 @@
-# typed: false
+# typed: ignore
+
 require 'kube-dsl'
 require 'kuby/cert-manager'
 
@@ -6,6 +7,8 @@ module Kuby
   module Plugins
     module RailsApp
       class Plugin < ::Kuby::Plugin
+        depends_on :kubernetes, '>= 1.20'
+
         extend ::KubeDSL::ValueFields
 
         WEB_ROLE = 'web'.freeze
@@ -18,8 +21,7 @@ module Kuby
         DEFAULT_ASSET_PATH = './public'.freeze
 
         value_field :root, default: '.'
-        value_fields :hostname, :tls_enabled
-        value_fields :manage_database, :database, :replicas
+        value_fields :hostname, :tls_enabled, :manage_database, :replicas
         value_fields :asset_url, :packs_url, :asset_path
 
         alias_method :manage_database?, :manage_database
@@ -45,11 +47,12 @@ module Kuby
           if manage_database? && @database = Database.get(self)
             @database.plugin.instance_eval(&@database_block) if @database_block
             environment.kubernetes.plugins[@database.plugin_name] = @database.plugin
-            environment.kubernetes.add_plugin(:kube_db)
 
             environment.docker do
               insert :rewrite_db_config, RewriteDbConfig.new, after: :copy_phase
             end
+
+            @database.plugin.configure_pod_spec(deployment.spec.template.spec)
           end
 
           environment.kubernetes.add_plugin(:nginx_ingress)
@@ -87,6 +90,15 @@ module Kuby
           spec = self
 
           deployment do
+            metadata do
+              annotations do
+                add(
+                  'getkuby.io/dockerfile-checksum',
+                  spec.environment.docker.image.dockerfile.checksum
+                )
+              end
+            end
+
             spec do
               template do
                 spec do
@@ -209,15 +221,7 @@ module Kuby
             type 'Opaque'
 
             data do
-              if master_key = ENV[MASTER_KEY_VAR]
-                add MASTER_KEY_VAR.to_sym, master_key
-              else
-                master_key_path = File.join(spec.root, 'config', 'master.key')
-
-                if File.exist?(master_key_path)
-                  add MASTER_KEY_VAR.to_sym, File.read(master_key_path).strip
-                end
-              end
+              add MASTER_KEY_VAR.to_sym, spec.master_key
             end
           end
 
@@ -237,13 +241,6 @@ module Kuby
                 add :app, kube_spec.selector_app
                 add :role, kube_spec.role
               end
-
-              annotations do
-                add(
-                  'getkuby.io/dockerfile-checksum',
-                  kube_spec.environment.docker.image.dockerfile.checksum
-                )
-              end
             end
 
             spec do
@@ -313,7 +310,7 @@ module Kuby
 
                   init_container(:create_db) do
                     name "#{kube_spec.selector_app}-create-db"
-                    command %w(bundle exec rake kuby:rails_app:db:create_unless_exists)
+                    command %w(bundle exec rake kuby:rails_app:db:bootstrap)
 
                     env_from do
                       config_map_ref do
@@ -330,7 +327,7 @@ module Kuby
 
                   init_container(:migrate_db) do
                     name "#{kube_spec.selector_app}-migrate-db"
-                    command %w(bundle exec rake db:migrate)
+                    command %w(bundle exec rake kuby:rails_app:db:migrate)
 
                     env_from do
                       config_map_ref do
@@ -364,7 +361,7 @@ module Kuby
           spec = self
           tls_enabled = @tls_enabled
 
-          @ingress ||= KubeDSL::DSL::Extensions::V1beta1::Ingress.new do
+          @ingress ||= KubeDSL::DSL::Networking::V1::Ingress.new do
             metadata do
               name "#{spec.selector_app}-ingress"
               namespace spec.namespace.metadata.name
@@ -381,10 +378,16 @@ module Kuby
                 http do
                   path do
                     path '/'
+                    path_type 'Prefix'
 
                     backend do
-                      service_name spec.service.metadata.name
-                      service_port spec.service.spec.ports.first.port
+                      service do
+                        name spec.service.metadata.name
+
+                        port do
+                          name spec.service.spec.ports.first.name
+                        end
+                      end
                     end
                   end
                 end
@@ -410,8 +413,8 @@ module Kuby
             config_map,
             app_secrets,
             deployment,
-            ingress,
-            *database&.plugin&.resources
+            *database&.plugin&.resources,
+            ingress
           ]
         end
 
@@ -434,6 +437,13 @@ module Kuby
         def namespace
           environment.kubernetes.namespace
         end
+
+        def master_key
+          @master_key ||= ENV[MASTER_KEY_VAR] || begin
+            master_key_path = File.join(root, 'config', 'master.key')
+            File.read(master_key_path).strip if File.exist?(master_key_path)
+          end
+        end
       end
     end
   end

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}" : ""
@@ -24,28 +25,96 @@ module Kuby
       end
     end
 
-    def setup
-      environment.kubernetes.setup
+    def setup(only: [])
+      environment.kubernetes.setup(only: only.map(&:to_sym))
     end
 
-    def build(build_args = {}, docker_args = [], only: nil, ignore_missing_args: false)
+    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)
+
+      if master_key = rails_app.master_key
+        build_args['RAILS_MASTER_KEY'] = master_key
+      end
+
       check_build_args(build_args) unless ignore_missing_args
 
       kubernetes.docker_images.each do |image|
-        next if only && image.identifier != only
-
+        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)
+        image.build(build_args, docker_args, context: context, **build_kwargs)
       end
     end
 
-    def push(only: nil)
+    def push(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
         Kuby.logger.info("Pushing image #{image.image_url} with tags #{image.tags.join(', ')}")
@@ -95,6 +164,18 @@ module Kuby
       puts File.read(path)
     end
 
+    def print_images
+      rows = kubernetes.docker_images.flat_map do |image|
+        image = image.current_version
+
+        image.tags.map do |tag|
+          [image.identifier, "#{image.image_url}:#{tag}"]
+        end
+      end
+
+      puts Kuby::Utils::Table.new(%w(IDENTIFIER URL), rows).to_s
+    end
+
     def kubectl(*cmd)
       kubernetes_cli.run_cmd(cmd)
     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