kuby-core 0.7.2 → 0.10.0

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

@@ -0,0 +1,347 @@
+require 'kube-dsl'
+
+module Kuby
+  module Plugins
+    module RailsApp
+      class Assets < ::Kuby::Plugin
+        extend ::KubeDSL::ValueFields
+
+        ROLE = 'assets'.freeze
+        NGINX_IMAGE = 'nginx:1.9-alpine'.freeze
+        NGINX_PORT = 8082
+        NGINX_MOUNT_PATH = '/usr/share/nginx/assets'.freeze
+        RAILS_MOUNT_PATH = '/usr/share/assets'.freeze
+
+        value_fields :asset_url, :packs_url, :asset_path
+
+        def configure(&block)
+          instance_eval(&block)
+        end
+
+        def configure_ingress(ingress, hostname)
+          spec = self
+
+          ingress.spec.rule do
+            host hostname
+
+            http do
+              path do
+                path spec.asset_url
+
+                backend do
+                  service_name spec.service.metadata.name
+                  service_port spec.service.spec.ports.first.port
+                end
+              end
+
+              path do
+                path spec.packs_url
+
+                backend do
+                  service_name spec.service.metadata.name
+                  service_port spec.service.spec.ports.first.port
+                end
+              end
+            end
+          end
+        end
+
+        def configure_deployment(deployment, docker_image)
+          spec = self
+
+          deployment.spec.template.spec do
+            init_container(:copy_assets) do
+              name "#{spec.selector_app}-copy-assets"
+              command %w(bundle exec rake kuby:rails_app:assets:copy)
+              image docker_image
+
+              volume_mount do
+                name 'assets'
+                mount_path RAILS_MOUNT_PATH
+              end
+            end
+
+            container(:web) do
+              volume_mount do
+                name 'assets'
+                mount_path NGINX_MOUNT_PATH
+              end
+            end
+
+            volume do
+              name 'assets'
+
+              persistent_volume_claim do
+                claim_name spec.volume_claim.metadata.name
+              end
+            end
+          end
+        end
+
+        def copy_task
+          @copy_task ||= AssetCopyTask.new(
+            from: asset_path, to: RAILS_MOUNT_PATH
+          )
+        end
+
+        def service(&block)
+          spec = self
+
+          @service ||= KubeDSL.service do
+            metadata do
+              name "#{spec.selector_app}-#{spec.role}-svc"
+              namespace spec.namespace.metadata.name
+
+              labels do
+                add :app, spec.selector_app
+                add :role, spec.role
+              end
+            end
+
+            spec do
+              type 'NodePort'
+
+              selector do
+                add :app, spec.selector_app
+                add :role, spec.role
+              end
+
+              port do
+                name 'http'
+                port NGINX_PORT
+                protocol 'TCP'
+                target_port 'http'
+              end
+            end
+          end
+
+          @service.instance_eval(&block) if block
+          @service
+        end
+
+        def service_account(&block)
+          spec = self
+
+          @service_account ||= KubeDSL.service_account do
+            metadata do
+              name "#{spec.selector_app}-#{spec.role}-sa"
+              namespace spec.namespace.metadata.name
+
+              labels do
+                add :app, spec.selector_app
+                add :role, spec.role
+              end
+            end
+          end
+
+          @service_account.instance_eval(&block) if block
+          @service_account
+        end
+
+        def nginx_config(&block)
+          spec = self
+
+          @nginx_config ||= KubeDSL.config_map do
+            metadata do
+              name "#{spec.selector_app}-#{spec.role}-nginx-config"
+              namespace spec.namespace.metadata.name
+            end
+
+            data do
+              add 'nginx.conf', <<~END
+                user  nginx;
+                worker_processes  1;
+
+                error_log  /var/log/nginx/error.log warn;
+                pid        /var/run/nginx.pid;
+
+                events {
+                  worker_connections  1024;
+                }
+
+                http {
+                  include       /etc/nginx/mime.types;
+                  default_type  application/octet-stream;
+
+                  log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
+                                    '$status $body_bytes_sent "$http_referer" '
+                                    '"$http_user_agent" "$http_x_forwarded_for"';
+
+                  access_log  /var/log/nginx/access.log  main;
+
+                  sendfile           on;
+                  keepalive_timeout  65;
+                  gzip               on;
+
+                  server {
+                    listen #{NGINX_PORT};
+                    server_name localhost;
+
+                    location / {
+                      root #{File.join(NGINX_MOUNT_PATH, 'current')};
+                    }
+
+                    error_page   500 502 503 504  /500.html;
+                  }
+                }
+              END
+            end
+          end
+
+          @nginx_config.instance_eval(&block) if block
+          @nginx_config
+        end
+
+        def deployment(&block)
+          kube_spec = self
+
+          @deployment ||= KubeDSL.deployment do
+            metadata do
+              name "#{kube_spec.selector_app}-#{kube_spec.role}"
+              namespace kube_spec.namespace.metadata.name
+
+              labels do
+                add :app, kube_spec.selector_app
+                add :role, kube_spec.role
+              end
+            end
+
+            spec do
+              replicas 1
+
+              selector do
+                match_labels do
+                  add :app, kube_spec.selector_app
+                  add :role, kube_spec.role
+                end
+              end
+
+              strategy do
+                type 'RollingUpdate'
+
+                rolling_update do
+                  max_surge '25%'
+                  max_unavailable 0
+                end
+              end
+
+              template do
+                metadata do
+                  labels do
+                    add :app, kube_spec.selector_app
+                    add :role, kube_spec.role
+                  end
+                end
+
+                spec do
+                  container(:nginx) do
+                    name "#{kube_spec.selector_app}-#{kube_spec.role}"
+                    image_pull_policy 'IfNotPresent'
+                    image NGINX_IMAGE
+
+                    port do
+                      container_port NGINX_PORT
+                      name 'http'
+                      protocol 'TCP'
+                    end
+
+                    volume_mount do
+                      name 'nginx-config'
+                      mount_path '/etc/nginx/nginx.conf'
+                      sub_path 'nginx.conf'
+                    end
+
+                    volume_mount do
+                      name 'assets'
+                      mount_path NGINX_MOUNT_PATH
+                    end
+
+                    readiness_probe do
+                      success_threshold 1
+                      failure_threshold 2
+                      initial_delay_seconds 5
+                      period_seconds 3
+                      timeout_seconds 1
+
+                      http_get do
+                        path '/500.html'
+                        port NGINX_PORT
+                        scheme 'HTTP'
+                      end
+                    end
+                  end
+
+                  volume do
+                    name 'nginx-config'
+
+                    config_map do
+                      name kube_spec.nginx_config.metadata.name
+                    end
+                  end
+
+                  volume do
+                    name 'assets'
+
+                    persistent_volume_claim do
+                      claim_name kube_spec.volume_claim.metadata.name
+                    end
+                  end
+
+                  restart_policy 'Always'
+                  service_account_name kube_spec.service_account.metadata.name
+                end
+              end
+            end
+          end
+
+          @deployment.instance_eval(&block) if block
+          @deployment
+        end
+
+        def volume_claim
+          spec = self
+
+          @volume_claim ||= KubeDSL.persistent_volume_claim do
+            metadata do
+              name "#{spec.selector_app}-#{spec.role}"
+              namespace spec.namespace.metadata.name
+            end
+
+            spec do
+              access_modes ['ReadWriteOnce']
+              storage_class_name spec.environment.kubernetes.provider.storage_class_name
+
+              resources do
+                requests do
+                  add :storage, '10Gi'
+                end
+              end
+            end
+          end
+        end
+
+        def resources
+          @resources ||= [
+            service,
+            service_account,
+            nginx_config,
+            deployment,
+            volume_claim
+          ]
+        end
+
+        def namespace
+          environment.kubernetes.namespace
+        end
+
+        def selector_app
+          environment.kubernetes.selector_app
+        end
+
+        def role
+          ROLE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'yaml'
+
+module Kuby
+  module Plugins
+    module RailsApp
+      class UnsupportedDatabaseError < StandardError; end
+
+      class Database
+        ADAPTER_MAP = {
+          sqlite3: Sqlite,
+          mysql2: MySQL,
+          postgresql: Postgres
+        }.freeze
+
+        def self.get(rails_app)
+          if rails_app.manage_database?
+            new(rails_app)
+          end
+        end
+
+        def self.get_adapter(adapter_name)
+          ADAPTER_MAP.fetch(adapter_name) do
+            raise UnsupportedDatabaseError, "Kuby does not support the '#{adapter}' "\
+              'database adapter'
+          end
+        end
+
+        attr_reader :rails_app
+
+        def initialize(rails_app)
+          @rails_app = rails_app
+        end
+
+        def plugin
+          @plugin ||= self.class
+            .get_adapter(adapter_name)
+            .new(rails_app.environment, db_configs)
+        end
+
+        def adapter_name
+          @adapter_name ||= db_config['adapter'].to_sym
+        end
+
+        alias_method :plugin_name, :adapter_name
+
+        private
+
+        def db_config
+          @db_config ||= db_configs[rails_app.environment.name]
+        end
+
+        def db_configs
+          @db_configs ||= YAML.load(File.read(db_config_path))
+        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
+  end
+end

data/lib/kuby/{kubernetes/plugins → plugins}/rails_app/generators/kuby.rb

@@ -2,25 +2,18 @@ require 'rails/generators'
 require 'rails/generators/base'
 
 class KubyGenerator < Rails::Generators::Base
-  def create_initializer_file
-    initializer(
-      'kuby.rb',
-      <<~END
-        require 'kuby'
-
-        Kuby.load!
-      END
-    )
-  end
-
   def create_config_file
     create_file(
       'kuby.rb',
       <<~END
+        require 'active_support/core_ext'
         require 'active_support/encrypted_configuration'
 
         # Define a production Kuby deploy environment
         Kuby.define(:production) do
+          # Because the Rails environment isn't always loaded when
+          # your Kuby config is loaded, provide access to Rails
+          # credentials manually.
           app_creds = ActiveSupport::EncryptedConfiguration.new(
             config_path: File.join('config', 'credentials.yml.enc'),
             key_path: File.join('config', 'master.key'),
@@ -46,17 +39,22 @@ class KubyGenerator < Rails::Generators::Base
 
           kubernetes do
             # Add a plugin that facilitates deploying a Rails app.
-            add_plugin :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
 
-            # Use minikube as the provider, which is the default installed by
-            # Docker Desktop.
-            # See: https://github.com/kubernetes/minikube
+            # Use Docker Desktop as the provider.
+            # See: https://www.docker.com/products/docker-desktop
             #
             # Note: you will likely want to use a different provider when deploying
             # your application into a production environment. To configure a different
             # provider, add the corresponding gem to your gemfile and update the
             # following line according to the provider gem's README.
-            provider :minikube
+            provider :docker_desktop
           end
         end
       END