kuby-core 0.5.0 → 0.7.2

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

@@ -6,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:
@@ -28,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
@@ -41,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'
+)