kuby-core 0.4.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8199a0db99884940e43a0711cb6ec706d0828a6e553bb327f04d3370ee4c724
-  data.tar.gz: 4a07cf9105716b0d230a3935b33205321818e414d458e99058dcd23b9abbbf99
+  metadata.gz: 12ac1ceff123c3a6e81a967ab7cba85c0900799720c7a448dbb947d6fdd88094
+  data.tar.gz: 665f61381cf4857eeac7f079e6439865660ed4daccc7fe7879d4682e362dc4c4
 SHA512:
-  metadata.gz: 5e4a38749d22b3dc559296aeaa15cff01d4b51a2bcfd754ec1f780a8a62a849dc85723bb8ee7e2a92f24eaa16c19b5e27e2c238682da2805077507441b87bae6
-  data.tar.gz: 6070a9a67c1aab75c1e7d1f0b7684bb6fbd899312df57aed642c5c7012d98e886a2880dfca21fec00d38646ba8cbef426fcf56e9a96ba4d4c0dc604b2aa61aa9
+  metadata.gz: 2e944f3569d137a187aefd64f72449733b5ed550d5455a17cf860c3b140906c94de7f1e7dce831f534f76ecd7175f2df14d7f62aeef6735d402ab248afbfa770
+  data.tar.gz: ae7a508aabf9efcd9d44a53abb42f3b05f9e3f6d4e7fb3635236b9cfe83eda71b71eebfef2f606fac82422bb0844be9873c279a9d69e2c2d377b69999e771a48

data/CHANGELOG.md

@@ -1,3 +1,53 @@
+## 0.7.1
+* Fix timestamp tag parsing regression caused by adding anchor tags to the regex.
+  - Instead, let's rely on `strptime` and return `nil` if it throws an `ArgumentError`.
+
+## 0.7.0
+* Automatically perform `docker login` if not already logged into the Docker registry.
+* Fix timestamp tag parsing issue causing deploy to fail with no available tags.
+  - Issue turned out to be ignoring the month of October in the validation regex.
+
+## 0.6.1
+* Fix issue causing database.yml to not be rewritten to point at correct database host.
+
+## 0.6.0
+* Don't load the Rails environment when running Kuby's rake tasks.
+  - Kuby's gems are still part of the bundle, but config has been moved out of the initializer and into kuby.rb in the Rails root directory.
+  - Internal classes no longer retain a reference to `Rails.application`.
+  - Kuby config now requires `environment` blocks:
+      ```ruby
+      Kuby.define('my-app') do
+        environment(:production) do
+          ...
+        end
+
+        environment(:staging) do
+          ...
+        end
+      end
+      ```
+* Fix `MissingDistroError` caused by not setting a default distro.
+* Create a .dockerignore file when running the Rails generator.
+* Add ability to insert inline Docker layers without having to create a separate class, eg:
+    ```ruby
+    insert :hello, before: :bundler_phase do |dockerfile|
+      dockerfile.run('echo "hello, world"')
+    end
+    ```
+* Add Postgres database support.
+* Don't install sqlite libs by default.
+* Modify Rails generator
+  - Require kuby and load config safely.
+  - Provide manual access to credentials via `ActiveSupport::EncryptedConfiguration`, which is necessary now that our rake tasks don't load the Rails environment.
+* Add a convenience method for requesting the amount of block storage for the database.
+* Add the ability to entirely disable database management via `manage_database false`.
+* Avoid deploying nginx-ingress if it's already deployed.
+* Add rake task for running arbitrary `kubectl` commands.
+
+## 0.5.0
+* Fix Rails generators issue causing crash at startup.
+* Add rake task to run arbitrary kubectl commands.
+
 ## 0.4.0
 * Introduce simple managed package.
 * Refactor deploy task into its own class.

data/kuby-core.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'colorize', '~> 0.8'
   s.add_dependency 'docker-remote', '~> 0.1'
   s.add_dependency 'krane', '~> 1.0'
-  s.add_dependency 'kuby-cert-manager', '~> 0.1'
+  s.add_dependency 'kuby-cert-manager', '~> 0.2'
   s.add_dependency 'kube-dsl', '~> 0.3'
   s.add_dependency 'kuby-kube-db', '~> 0.4'
   s.add_dependency 'kubernetes-cli', '~> 0.2'
@@ -23,5 +23,6 @@ Gem::Specification.new do |s|
   s.add_dependency 'rouge', '~> 3.0'
 
   s.require_path = 'lib'
+
   s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'kuby-core.gemspec']
 end

data/lib/kuby.rb

@@ -10,6 +10,7 @@ module Kuby
   autoload :CLIBase,      'kuby/cli_base'
   autoload :Definition,   'kuby/definition'
   autoload :Docker,       'kuby/docker'
+  autoload :Environment,  'kuby/environment'
   autoload :Kubernetes,   'kuby/kubernetes'
   autoload :Middleware,   'kuby/middleware'
   autoload :Tasks,        'kuby/tasks'
@@ -19,19 +20,25 @@ module Kuby
 
   class << self
     attr_reader :definition
-    attr_accessor :logger
+    attr_writer :logger
 
-    def define(environment, app = Rails.application, &block)
-      environment = environment.to_s
-      definitions[environment] ||= Definition.new(environment, app, &block)
+    def load!
+      require ENV['KUBY_CONFIG'] || File.join('.', 'kuby.rb')
     end
 
-    def definitions
-      @definitions ||= {}
+    def define(name, &block)
+      raise 'Kuby is already configured' if @definition
+
+      @definition = Definition.new(name.to_s)
+      @definition.instance_eval(&block)
+
+      @definition.environments.each do |_, env|
+        env.kubernetes.after_configuration
+      end
     end
 
-    def definition(environment = env)
-      definitions.fetch(environment.to_s) do
+    def environment(name = env)
+      definition.environment(name.to_s) do
         raise UndefinedEnvironmentError, "couldn't find a Kuby environment named "\
           "'#{environment}'"
       end
@@ -61,6 +68,10 @@ module Kuby
       @plugins ||= {}
     end
 
+    def logger
+      @logger ||= BasicLogger.new(STDERR)
+    end
+
     def register_package(package_name, package_def = nil)
       packages[package_name] = case package_def
         when NilClass
@@ -86,7 +97,7 @@ module Kuby
 
     def env
       ENV.fetch('KUBY_ENV') do
-        (definitions.keys.first || Rails.env).to_s
+        (definition.environments.keys.first || Rails.env).to_s
       end
     end
   end
@@ -114,8 +125,3 @@ Kuby.register_package(:c_toolchain,
   debian: 'build-essential',
   alpine: 'build-base'
 )
-
-Kuby.register_package(:sqlite_dev,
-  debian: 'libsqlite3-dev',
-  alpine: 'sqlite-dev'
-)

data/lib/kuby/definition.rb

@@ -1,29 +1,35 @@
 module Kuby
   class Definition
-    attr_reader :environment, :app
+    attr_reader :app_name
 
-    def initialize(environment, app, &block)
-      @environment = environment
-      @app = app
+    def initialize(app_name, &block)
+      @app_name = app_name
+    end
+
+    def environment(name = Kuby.env, &block)
+      name = name.to_s
+
+      if name
+        environments[name] ||= Environment.new(name, self)
+      end
+
+      if block_given?
+        environments[name].instance_eval(&block)
+      end
 
-      instance_eval(&block) if block
-      kubernetes.after_configuration
+      environments[name]
     end
 
     def docker(&block)
-      @docker ||= Docker::Spec.new(self)
-      @docker.instance_eval(&block) if block
-      @docker
+      environment.docker(&block)
     end
 
     def kubernetes(&block)
-      @kubernetes ||= Kubernetes::Spec.new(self)
-      @kubernetes.instance_eval(&block) if block
-      @kubernetes
+      environment.kubernetes(&block)
     end
 
-    def app_name
-      @app_name ||= app.class.module_parent.name
+    def environments
+      @environments ||= {}
     end
   end
 end

data/lib/kuby/docker.rb

@@ -10,12 +10,13 @@ module Kuby
     autoload :Credentials,    'kuby/docker/credentials'
     autoload :Debian,         'kuby/docker/debian'
     autoload :Dockerfile,     'kuby/docker/dockerfile'
+    autoload :InlineLayer,    'kuby/docker/inline_layer'
+    autoload :Layer,          'kuby/docker/layer'
     autoload :LayerStack,     'kuby/docker/layer_stack'
     autoload :LocalTags,      'kuby/docker/local_tags'
     autoload :Metadata,       'kuby/docker/metadata'
     autoload :Packages,       'kuby/docker/packages'
     autoload :PackagePhase,   'kuby/docker/package_phase'
-    autoload :Phase,          'kuby/docker/phase'
     autoload :RemoteTags,     'kuby/docker/remote_tags'
     autoload :SetupPhase,     'kuby/docker/setup_phase'
     autoload :Spec,           'kuby/docker/spec'

data/lib/kuby/docker/alpine.rb

@@ -8,7 +8,6 @@ module Kuby
         [:nodejs, '12.14.1'],
         [:yarn, '1.21.1'],
         [:c_toolchain],
-        [:sqlite_dev],
         [:tzdata]
       ].freeze
 

data/lib/kuby/docker/assets_phase.rb

@@ -1,6 +1,6 @@
 module Kuby
   module Docker
-    class AssetsPhase < Phase
+    class AssetsPhase < Layer
       def apply_to(dockerfile)
         dockerfile.run(
           'bundle', 'exec', 'rake', 'assets:precompile'

data/lib/kuby/docker/bundler_phase.rb

@@ -1,6 +1,8 @@
+require 'pathname'
+
 module Kuby
   module Docker
-    class BundlerPhase < Phase
+    class BundlerPhase < Layer
       DEFAULT_WITHOUT = ['development', 'test', 'deploy'].freeze
 
       attr_accessor :version, :gemfile, :without
@@ -48,7 +50,7 @@ module Kuby
           .definition
           .gemfiles
           .first
-          .relative_path_from(app.root)
+          .relative_path_from(Pathname(Dir.getwd))
           .to_s
       end
     end

data/lib/kuby/docker/cli.rb

@@ -10,6 +10,38 @@ module Kuby
         @executable = executable || `which docker`.strip
       end
 
+      def config_file
+        if File.exist?(default_config_file)
+          default_config_file
+        end
+      end
+
+      def default_config_file
+        File.join(Dir.home, '.docker', 'config.json')
+      end
+
+      def login(url:, username:, password:)
+        cmd = [
+          executable, 'login', url, '--username', username, '--password-stdin'
+        ]
+
+        open3_w({}, cmd) do |stdin, _wait_threads|
+          stdin.puts(password)
+        end
+
+        unless last_status.success?
+          raise LoginError, 'build failed: docker command exited with '\
+            "status code #{last_status.exitstatus}"
+        end
+      end
+
+      def auths
+        return [] unless config_file
+
+        config = JSON.parse(File.read(config_file))
+        config.fetch('auths', {}).keys
+      end
+
       def build(dockerfile:, image_url:, tags:)
         cmd = [
           executable, 'build',

data/lib/kuby/docker/copy_phase.rb

@@ -1,6 +1,6 @@
 module Kuby
   module Docker
-    class CopyPhase < Phase
+    class CopyPhase < Layer
       DEFAULT_PATHS = ['./'].freeze
 
       attr_reader :paths

data/lib/kuby/docker/errors.rb

@@ -2,6 +2,7 @@ module Kuby
   module Docker
     class BuildError < StandardError; end
     class PushError < StandardError; end
+    class LoginError < StandardError; end
 
     class MissingTagError < StandardError
       attr_reader :tag

data/lib/kuby/docker/inline_layer.rb

@@ -0,0 +1,15 @@
+module Kuby
+  module Docker
+    class InlineLayer < Layer
+      attr_reader :block
+
+      def initialize(block)
+        @block = block
+      end
+
+      def apply_to(dockerfile)
+        block.call(dockerfile)
+      end
+    end
+  end
+end

data/lib/kuby/docker/{phase.rb → layer.rb}

@@ -1,18 +1,19 @@
 module Kuby
   module Docker
-    class Phase
+    class Layer
       attr_reader :definition
 
       def initialize(definition)
         @definition = definition
       end
 
-      private
-
-      def app
-        definition.app
+      def apply_to(dockerfile)
+        raise NotImplementedError,
+          "#{__method__} must be defined in derived classes"
       end
 
+      private
+
       def metadata
         definition.docker.metadata
       end

data/lib/kuby/docker/layer_stack.rb

@@ -15,12 +15,31 @@ module Kuby
         @stack.each { |name| yield layers[name] }
       end
 
-      def use(name, layer)
+      def use(name, layer = nil, &block)
         stack << name
-        layers[name] = layer
+
+        if layer
+          layers[name] = layer
+        elsif block_given?
+          layers[name] = InlineLayer.new(block)
+        else
+          raise "Must either pass a layer object or a block to `#{__method__}'"
+        end
       end
 
-      def insert(name, layer, options = {})
+      def insert(name, layer = nil, options = {}, &block)
+        # this is truly gross but it's the only way I can think of to be able
+        # to call insert these two ways:
+        #
+        # insert :foo, FooLayer.new, before: :bundler_phase
+        # insert :foo, before: :bundler_phase do
+        #   ...
+        # end
+        if layer.is_a?(Hash)
+          insert(name, nil, options.merge(layer), &block)
+          return
+        end
+
         existing_name = options[:before] || options[:after]
         idx = stack.index(existing_name)
 
@@ -30,7 +49,14 @@ module Kuby
 
         idx += 1 if options[:after]
         stack.insert(idx, name)
-        layers[name] = layer
+
+        if layer
+          layers[name] = layer
+        elsif block_given?
+          layers[name] = InlineLayer.new(block)
+        else
+          raise "Must either pass a layer object or a block to `#{__method__}'"
+        end
       end
 
       def delete(name)

data/lib/kuby/docker/metadata.rb

@@ -8,7 +8,7 @@ module Kuby
       LATEST_TAG = 'latest'
 
       attr_accessor :image_url
-      attr_reader :definition, :distro
+      attr_reader :definition
 
       def initialize(definition)
         @definition = definition
@@ -28,6 +28,10 @@ module Kuby
         end
       end
 
+      def image_hostname
+        @image_hostname ||= URI(image_host).host
+      end
+
       def image_repo
         @image_repo ||= if image_url.include?('/')
           parse_url(image_url).path.sub(/\A\//, '')
@@ -62,6 +66,10 @@ module Kuby
         t.to_s
       end
 
+      def distro
+        @distro || DEFAULT_DISTRO
+      end
+
       def distro=(distro_name)
         @distro = distro_name
       end

data/lib/kuby/docker/package_phase.rb

@@ -1,6 +1,6 @@
 module Kuby
   module Docker
-    class PackagePhase < Phase
+    class PackagePhase < Layer
       attr_reader :operations
 
       def initialize(*args)

data/lib/kuby/docker/setup_phase.rb

@@ -1,6 +1,6 @@
 module Kuby
   module Docker
-    class SetupPhase < Phase
+    class SetupPhase < Layer
       DEFAULT_WORKING_DIR = '/usr/src/app'.freeze
 
       attr_accessor :base_image, :working_dir

data/lib/kuby/docker/spec.rb

@@ -50,12 +50,12 @@ module Kuby
         metadata.image_url = url
       end
 
-      def use(*args)
-        layer_stack.use(*args)
+      def use(*args, &block)
+        layer_stack.use(*args, &block)
       end
 
-      def insert(*args)
-        layer_stack.insert(*args)
+      def insert(*args, &block)
+        layer_stack.insert(*args, &block)
       end
 
       def delete(*args)

data/lib/kuby/docker/timestamp_tag.rb

@@ -1,13 +1,16 @@
 module Kuby
   module Docker
     class TimestampTag
-      RE = /20[\d]{2}(?:0[1-9]|11|12)(?:0[1-9]|1[1-9]|2[1-9]|3[01])/.freeze
       FORMAT = '%Y%m%d%H%M%S'.freeze
 
       def self.try_parse(str)
-        if str =~ RE
-          new(Time.strptime(str, FORMAT))
+        time = begin
+          Time.strptime(str, FORMAT)
+        rescue ArgumentError
+          return nil
         end
+
+        new(time)
       end
 
       attr_reader :time

data/lib/kuby/docker/webserver_phase.rb

@@ -1,6 +1,6 @@
 module Kuby
   module Docker
-    class WebserverPhase < Phase
+    class WebserverPhase < Layer
       class Puma
         attr_reader :phase
 

data/lib/kuby/docker/yarn_phase.rb

@@ -1,6 +1,6 @@
 module Kuby
   module Docker
-    class YarnPhase < Phase
+    class YarnPhase < Layer
       def apply_to(dockerfile)
         dockerfile.copy('package.json', '.')
         dockerfile.copy('yarn.lock*', '.')

data/lib/kuby/environment.rb

@@ -0,0 +1,22 @@
+module Kuby
+  class Environment
+    attr_reader :name, :definition
+
+    def initialize(name, definition, &block)
+      @name = name
+      @definition = definition
+    end
+
+    def docker(&block)
+      @docker ||= Docker::Spec.new(definition)
+      @docker.instance_eval(&block) if block
+      @docker
+    end
+
+    def kubernetes(&block)
+      @kubernetes ||= Kubernetes::Spec.new(definition)
+      @kubernetes.instance_eval(&block) if block
+      @kubernetes
+    end
+  end
+end

data/lib/kuby/kubernetes/minikube_provider.rb

@@ -26,11 +26,6 @@ module Kuby
           rails_app.resources.delete(rails_app.ingress)
           rails_app.service.spec { type 'LoadBalancer' }
         end
-
-        configure do
-          # default kubeconfig path
-          kubeconfig File.join(ENV['HOME'], '.kube', 'config')
-        end
       end
 
       def kubeconfig_path
@@ -45,6 +40,11 @@ module Kuby
 
       def after_initialize
         @config = Config.new
+
+        configure do
+          # default kubeconfig path
+          kubeconfig File.join(ENV['HOME'], '.kube', 'config')
+        end
       end
     end
   end

data/lib/kuby/kubernetes/plugins/nginx_ingress.rb

@@ -27,6 +27,11 @@ module Kuby
         def setup
           Kuby.logger.info('Deploying nginx ingress resources')
 
+          if already_deployed?
+            Kuby.logger.info('Nginx ingress already deployed, skipping')
+            return
+          end
+
           SETUP_RESOURCES.each do |uri|
             uri = uri % { provider: @config.provider || DEFAULT_PROVIDER }
             kubernetes_cli.apply_uri(uri)
@@ -48,6 +53,13 @@ module Kuby
 
         private
 
+        def already_deployed?
+          kubernetes_cli.get_object('Service', 'ingress-nginx', 'ingress-nginx')
+          true
+        rescue KubernetesCLI::GetResourceError
+          return false
+        end
+
         def after_initialize
           @config = Config.new
         end

data/lib/kuby/kubernetes/plugins/rails_app/database.rb

@@ -1,3 +1,6 @@
+require 'erb'
+require 'yaml'
+
 module Kuby
   module Kubernetes
     module Plugins
@@ -11,27 +14,29 @@ module Kuby
             'postgresql' => Postgres
           }.freeze
 
-          def self.get(definition)
-            new(definition).database
+          def self.get(rails_app)
+            if rails_app.manage_database?
+              new(rails_app).database
+            end
           end
 
           def self.get_adapter(adapter)
             ADAPTER_MAP.fetch(adapter) do
-              raise UnsupportedDatabaseError, "Kuby does not support the '#{adapter}'"\
+              raise UnsupportedDatabaseError, "Kuby does not support the '#{adapter}' "\
                 'database adapter'
             end
           end
 
-          attr_reader :definition
+          attr_reader :rails_app
 
-          def initialize(definition)
-            @definition = definition
+          def initialize(rails_app)
+            @rails_app = rails_app
           end
 
           def database
             @database ||= self.class
               .get_adapter(adapter)
-              .new(definition, environment, db_configs)
+              .new(rails_app, environment, db_configs)
           end
 
           private
@@ -45,11 +50,27 @@ module Kuby
           end
 
           def environment
-            @environment ||= definition.environment
+            @environment ||= rails_app.definition.environment.name
           end
 
           def db_configs
-            @db_configs ||= definition.app.config.database_configuration
+            @db_configs ||= YAML.load(ERB.new(File.read(db_config_path)).result)
+          end
+
+          def db_config_path
+            @db_config_path ||= begin
+              db_config_paths.first or
+                raise "Couldn't find database config at #{rails_app.root}"
+            end
+          end
+
+          def db_config_paths
+            @db_config_paths ||=
+              Dir.glob(
+                File.join(
+                  rails_app.root, 'config', 'database.{yml,erb,yml.erb,yaml,yaml.erb}'
+                )
+              )
           end
         end
       end

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

@@ -1,3 +1,4 @@
+require 'rails/generators'
 require 'rails/generators/base'
 
 class KubyGenerator < Rails::Generators::Base
@@ -5,15 +6,35 @@ class KubyGenerator < Rails::Generators::Base
     initializer(
       'kuby.rb',
       <<~END
+        require 'kuby'
+
+        Kuby.load!
+      END
+    )
+  end
+
+  def create_config_file
+    create_file(
+      'kuby.rb',
+      <<~END
+        require 'active_support/encrypted_configuration'
+
         # Define a production Kuby deploy environment
         Kuby.define(:production) do
+          app_creds = ActiveSupport::EncryptedConfiguration.new(
+            config_path: File.join('config', 'credentials.yml.enc'),
+            key_path: File.join('config', 'master.key'),
+            env_key: 'RAILS_MASTER_KEY',
+            raise_if_missing_key: true
+          )
+
           docker do
             # Configure your Docker registry credentials here. Add them to your
             # Rails credentials file by running `bundle exec rake credentials:edit`.
             credentials do
-              username Rails.application.credentials[:KUBY_DOCKER_USERNAME]
-              password Rails.application.credentials[:KUBY_DOCKER_PASSWORD]
-              email Rails.application.credentials[:KUBY_DOCKER_EMAIL]
+              username app_creds[:KUBY_DOCKER_USERNAME]
+              password app_creds[:KUBY_DOCKER_PASSWORD]
+              email app_creds[:KUBY_DOCKER_EMAIL]
             end
 
             # Configure the URL to your Docker image here, eg:
@@ -27,7 +48,8 @@ class KubyGenerator < Rails::Generators::Base
             # Add a plugin that facilitates deploying a Rails app.
             add_plugin :rails_app
 
-            # Use minikube as the default provider.
+            # Use minikube as the provider, which is the default installed by
+            # Docker Desktop.
             # See: https://github.com/kubernetes/minikube
             #
             # Note: you will likely want to use a different provider when deploying
@@ -40,4 +62,22 @@ class KubyGenerator < Rails::Generators::Base
       END
     )
   end
+
+  def create_dockerignore
+    create_file(
+      '.dockerignore',
+      <<~END
+        .bundle/
+        vendor/bundle
+        node_modules/
+        .node_modules/
+        **/.git*
+        tmp/
+        log/
+        engines/**/log/
+        engines/**/tmp/
+        public/assets
+      END
+    )
+  end
 end

data/lib/kuby/kubernetes/plugins/rails_app/mysql.rb

@@ -56,6 +56,20 @@ module Kuby
             end
           end
 
+          def storage(amount)
+            database do
+              spec do
+                storage do
+                  resources do
+                    requests do
+                      set :storage, amount
+                    end
+                  end
+                end
+              end
+            end
+          end
+
           def secret(&block)
             context = self
 
@@ -118,10 +132,6 @@ module Kuby
             definition.kubernetes
           end
 
-          def app
-            definition.app
-          end
-
           private
 
           def config

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

@@ -13,12 +13,17 @@ module Kuby
           ENV_SECRETS = [MASTER_KEY_VAR].freeze
           ENV_EXCLUDE = ['RAILS_ENV'].freeze
 
-          value_fields :hostname, :tls_enabled, :database, :replicas
+          value_field :root, default: '.'
+          value_fields :hostname, :tls_enabled
+          value_fields :manage_database, :database, :replicas
+
+          alias_method :manage_database?, :manage_database
 
           def initialize(definition)
             @definition = definition
             @tls_enabled = true
             @replicas = 1
+            @manage_database = true
           end
 
           def configure(&block)
@@ -26,11 +31,7 @@ module Kuby
           end
 
           def after_configuration
-            # currently Database.get doesn't return nil, but this if statement
-            # is here as a placeholder to indicate we'd like to be able to
-            # handle Rails apps that don't use a database, i.e. don't have
-            # activerecord configured
-            if @database = Database.get(definition)
+            if @database = Database.get(self)
               definition.kubernetes.plugins[database] = @database
               definition.kubernetes.add_plugin(:kube_db)
 
@@ -43,7 +44,11 @@ module Kuby
             definition.kubernetes.add_plugin(:nginx_ingress)
 
             if @tls_enabled
-              definition.kubernetes.add_plugin(:cert_manager)
+              context = self
+
+              definition.kubernetes.add_plugin(:cert_manager) do
+                email context.definition.docker.credentials.email
+              end
             end
           end
 
@@ -178,9 +183,9 @@ module Kuby
                 if master_key = ENV[MASTER_KEY_VAR]
                   add MASTER_KEY_VAR.to_sym, master_key
                 else
-                  master_key_path = spec.app.root.join('config', 'master.key')
+                  master_key_path = File.join(spec.root, 'config', 'master.key')
 
-                  if master_key_path.exist?
+                  if File.exist?(master_key_path)
                     add MASTER_KEY_VAR.to_sym, File.read(master_key_path).strip
                   end
                 end
@@ -344,7 +349,7 @@ module Kuby
               app_secrets,
               deployment,
               ingress,
-              *database.resources
+              *database&.resources
             ]
           end
 
@@ -364,10 +369,6 @@ module Kuby
             definition.kubernetes
           end
 
-          def app
-            definition.app
-          end
-
           def namespace
             definition.kubernetes.namespace
           end

data/lib/kuby/kubernetes/plugins/rails_app/postgres.rb

@@ -1,10 +1,142 @@
+require 'kube-dsl'
+require 'kuby/kube-db'
+
 module Kuby
   module Kubernetes
     module Plugins
       module RailsApp
         class Postgres < Kuby::Kubernetes::Plugin
+          ROLE = 'web'.freeze
+
+          attr_reader :definition, :environment, :configs
+
+          def initialize(definition, environment, configs)
+            @definition = definition
+            @environment = environment
+            @configs = configs
+
+            user(config['username'])
+            password(config['password'])
+          end
+
+          def resources
+            @resources ||= [secret, database]
+          end
+
+          def after_configuration
+            definition.docker.package_phase.add(:postgres_dev)
+            definition.docker.package_phase.add(:postgres_client)
+          end
+
+          def host
+            # host is the same as the name thanks to k8s DNS
+            @host ||= database.metadata.name
+          end
+
+          def rewritten_configs
+            # deep dup
+            @rewritten_configs ||= Marshal.load(Marshal.dump(configs)).tap do |new_configs|
+              new_configs[environment]['host'] = host
+            end
+          end
+
+          def user(user)
+            secret do
+              data do
+                set :POSTGRES_USER, user
+              end
+            end
+          end
+
+          def password(password)
+            secret do
+              data do
+                set :POSTGRES_PASSWORD, password
+              end
+            end
+          end
+
+          def secret(&block)
+            context = self
+
+            @secret ||= KubeDSL.secret do
+              metadata do
+                name "#{context.base_name}-postgres-secret"
+                namespace context.kubernetes.namespace.metadata.name
+              end
+
+              type 'Opaque'
+            end
+
+            @secret.instance_eval(&block) if block
+            @secret
+          end
+
+          def database(&block)
+            context = self
+
+            @database ||= Kuby::KubeDB.postgres do
+              api_version 'kubedb.com/v1alpha1'
+
+              metadata do
+                name "#{context.base_name}-postgres"
+                namespace context.kubernetes.namespace.metadata.name
+              end
+
+              spec do
+                database_secret do
+                  secret_name context.secret.metadata.name
+                end
+
+                version '11.2'
+                standby_mode 'Hot'
+                streaming_mode 'asynchronous'
+                storage_type 'Durable'
+
+                storage do
+                  storage_class_name context.kubernetes.provider.storage_class_name
+                  access_modes ['ReadWriteOnce']
+
+                  resources do
+                    requests do
+                      add :storage, '10Gi'
+                    end
+                  end
+                end
+
+                termination_policy 'DoNotTerminate'
+              end
+            end
+
+            @database.instance_eval(&block) if block
+            @database
+          end
+
+          def base_name
+            @base_name ||= "#{kubernetes.selector_app}-#{ROLE}"
+          end
+
+          def kubernetes
+            definition.kubernetes
+          end
+
+          private
+
+          def config
+            configs[environment]
+          end
         end
       end
     end
   end
 end
+
+Kuby.register_package(:postgres_dev,
+  debian: 'postgresql-client',
+  alpine: 'postgresql-dev'
+)
+
+Kuby.register_package(:postgres_client,
+  debian: 'postgresql-client',
+  alpine: 'postgresql-client'
+)

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

@@ -3,8 +3,28 @@ module Kuby
     module Plugins
       module RailsApp
         class Sqlite < Kuby::Kubernetes::Plugin
+          attr_reader :definition
+
+          def initialize(definition, *)
+            @definition = definition
+          end
+
+          def after_configuration
+            definition.docker.package_phase.add(:sqlite_dev)
+            definition.docker.package_phase.add(:sqlite_client)
+          end
         end
       end
     end
   end
 end
+
+Kuby.register_package(:sqlite_dev,
+  debian: 'libsqlite3-dev',
+  alpine: 'sqlite-dev'
+)
+
+Kuby.register_package(:sqlite_client,
+  debian: 'sqlite3',
+  alpine: 'sqlite'
+)

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

@@ -3,11 +3,16 @@ require 'rake'
 namespace :kuby do
   namespace :rails_app do
     namespace :db do
-      task rewrite_config: :environment do
-        config_file = Kuby.definition.app.root.join('config', 'database.yml')
+      task :rewrite_config do
+        Kuby.load!
+
+        config_file = File.join(Kuby.definition.kubernetes.plugin(:rails_app).root, 'config', 'database.yml')
         database = Kuby.definition.kubernetes.plugin(:rails_app).database
-        File.write(config_file, YAML.dump(database.rewritten_configs))
-        Kuby.logger.info("Wrote #{config_file}")
+
+        if database.respond_to?(:rewritten_configs)
+          File.write(config_file, YAML.dump(database.rewritten_configs))
+          Kuby.logger.info("Wrote #{config_file}")
+        end
       end
 
       task :create_unless_exists do

data/lib/kuby/kubernetes/spec.rb

@@ -118,7 +118,7 @@ module Kuby
 
         @namespace ||= KubeDSL.namespace do
           metadata do
-            name "#{spec.selector_app}-#{spec.definition.environment}"
+            name "#{spec.selector_app}-#{spec.definition.environment.name}"
           end
         end
 

data/lib/kuby/railtie.rb

@@ -7,10 +7,6 @@ module Kuby
       load File.expand_path(File.join('tasks', 'kuby.rake'), __dir__)
     end
 
-    initializer 'kuby.startup' do |_app|
-      Kuby.logger = Kuby::BasicLogger.new(STDERR)
-    end
-
     initializer 'kuby.health_check_middleware' do |app|
       app.middleware.use Kuby::Middleware::HealthCheck
     end

data/lib/kuby/tasks.rb

@@ -16,6 +16,10 @@ module Kuby
       puts formatter.format(tokens)
     end
 
+    def setup
+      definition.kubernetes.setup
+    end
+
     def build
       docker.cli.build(
         dockerfile: docker.to_dockerfile,
@@ -35,6 +39,24 @@ module Kuby
     end
 
     def push
+      hostname = docker.metadata.image_hostname
+
+      unless docker.cli.auths.include?(hostname)
+        Kuby.logger.info("Attempting to log in to registry at #{hostname}")
+
+        begin
+          docker.cli.login(
+            url: docker.metadata.image_host,
+            username: docker.credentials.username,
+            password: docker.credentials.password
+          )
+        rescue Kuby::Docker::LoginError => e
+          Kuby.logger.fatal("Couldn't log in to the registry at #{hostname}")
+          Kuby.logger.fatal(e.message)
+          return
+        end
+      end
+
       image_url = docker.metadata.image_url
 
       begin
@@ -46,9 +68,18 @@ module Kuby
           'Docker image before running this task.'
 
         Kuby.logger.fatal(msg)
+        Kuby.logger.fatal(e.message)
       end
     end
 
+    def deploy
+      definition.kubernetes.deploy
+    end
+
+    def rollback
+      definition.kubernetes.rollback
+    end
+
     def print_resources
       kubernetes.before_deploy
 
@@ -63,6 +94,10 @@ module Kuby
       puts File.read(path)
     end
 
+    def kubectl(*cmd)
+      kubernetes_cli.run_cmd(cmd)
+    end
+
     def remote_logs
       kubernetes_cli.logtail(namespace, match_labels.serialize)
     end

data/lib/kuby/tasks/kuby.rake

@@ -1,62 +1,69 @@
+require 'shellwords'
+
 namespace :kuby do
   def tasks
+    Kuby.load!
     @tasks ||= Kuby::Tasks.new(Kuby.definition)
   end
 
-  task dockerfile: :environment do
+  task :dockerfile do
     tasks.print_dockerfile
   end
 
-  task build: :environment do
+  task :build do
     tasks.build
   end
 
-  task run: :environment do
+  task :run do
     tasks.run
   end
 
-  task push: :environment do
+  task :push do
     tasks.push
   end
 
-  task resources: :environment do
+  task :resources do
     tasks.print_resources
   end
 
-  task deploy: :environment do
-    Kuby.definition.kubernetes.deploy
+  task :kubectl, [:cmd] do |_, args|
+    tasks.kubectl(Shellwords.shellsplit(args[:cmd]))
+  end
+
+  task :deploy do
+    tasks.deploy
   end
 
-  task rollback: :environment do
-    Kuby.definition.kubernetes.rollback
+  task :rollback do
+    tasks.rollback
   end
 
-  task kubeconfig: :environment do
+  task :kubeconfig do
     tasks.print_kubeconfig
   end
 
-  task setup: :environment do
-    Kuby.definition.kubernetes.setup
+  task :setup do
+    tasks.setup
   end
 
   namespace :remote do
-    task logs: :environment do
+    task :logs do
       tasks.remote_logs
     end
 
-    task status: :environment do
+    task :status do
       tasks.remote_status
     end
 
-    task shell: :environment do
+    task :shell do
       tasks.remote_shell
     end
 
-    task console: :environment do
+    task :console do
       tasks.remote_console
     end
 
-    task dbconsole: :environment do
+    task :dbconsole do
       tasks.remote_dbconsole
     end
   end

data/lib/kuby/version.rb

@@ -1,3 +1,3 @@
 module Kuby
-  VERSION = '0.4.0'
+  VERSION = '0.7.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kuby-core
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-27 00:00:00.000000000 Z
+date: 2020-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: kube-dsl
   requirement: !ruby/object:Gem::Requirement
@@ -164,6 +164,8 @@ files:
 - lib/kuby/docker/debian.rb
 - lib/kuby/docker/dockerfile.rb
 - lib/kuby/docker/errors.rb
+- lib/kuby/docker/inline_layer.rb
+- lib/kuby/docker/layer.rb
 - lib/kuby/docker/layer_stack.rb
 - lib/kuby/docker/local_tags.rb
 - lib/kuby/docker/metadata.rb
@@ -175,7 +177,6 @@ files:
 - lib/kuby/docker/packages/package.rb
 - lib/kuby/docker/packages/simple_managed_package.rb
 - lib/kuby/docker/packages/yarn.rb
-- lib/kuby/docker/phase.rb
 - lib/kuby/docker/remote_tags.rb
 - lib/kuby/docker/setup_phase.rb
 - lib/kuby/docker/spec.rb
@@ -183,6 +184,7 @@ files:
 - lib/kuby/docker/timestamp_tag.rb
 - lib/kuby/docker/webserver_phase.rb
 - lib/kuby/docker/yarn_phase.rb
+- lib/kuby/environment.rb
 - lib/kuby/kubernetes.rb
 - lib/kuby/kubernetes/deploy_task.rb
 - lib/kuby/kubernetes/deployer.rb