kuby-core 0.6.0 → 0.8.0

data/lib/kuby/kubernetes/spec.rb

@@ -5,10 +5,10 @@ module Kuby
     class Spec
       extend ::KubeDSL::ValueFields
 
-      attr_reader :definition, :plugins, :tag
+      attr_reader :environment, :plugins, :tag
 
-      def initialize(definition)
-        @definition = definition
+      def initialize(environment)
+        @environment = environment
         @plugins = TrailingHash.new
 
         # default plugins
@@ -18,7 +18,7 @@ module Kuby
       def provider(provider_name = nil, &block)
         if provider_name
           if @provider || provider_klass = Kuby.providers[provider_name]
-            @provider ||= provider_klass.new(definition)
+            @provider ||= provider_klass.new(environment)
             @provider.configure(&block)
           else
             msg = if provider_name
@@ -37,7 +37,7 @@ module Kuby
 
       def configure_plugin(plugin_name, &block)
         if @plugins[plugin_name] || plugin_klass = Kuby.plugins[plugin_name]
-          @plugins[plugin_name] ||= plugin_klass.new(definition)
+          @plugins[plugin_name] ||= plugin_klass.new(environment)
           @plugins[plugin_name].configure(&block) if block
         else
           raise MissingPluginError, "no plugin registered with name #{plugin_name}, "\
@@ -118,7 +118,7 @@ module Kuby
 
         @namespace ||= KubeDSL.namespace do
           metadata do
-            name "#{spec.selector_app}-#{spec.definition.environment.name}"
+            name "#{spec.selector_app}-#{spec.environment.name}"
           end
         end
 
@@ -156,11 +156,11 @@ module Kuby
       end
 
       def selector_app
-        @selector_app ||= definition.app_name.downcase
+        @selector_app ||= environment.app_name.downcase
       end
 
       def docker
-        definition.docker
+        environment.docker
       end
     end
   end

data/lib/kuby/plugin.rb

@@ -0,0 +1,59 @@
+module Kuby
+  class Plugin
+    attr_reader :environment
+
+    def initialize(environment)
+      @environment = environment
+      after_initialize
+    end
+
+    def configure(&block)
+      # do nothing by default
+    end
+
+    def setup
+      # do nothing by default
+    end
+
+    # additional kubernetes resources that should be deployed
+    def resources
+      []
+    end
+
+    # additional dockerfiles that should be built and pushed
+    def dockerfiles
+      []
+    end
+
+    # called after all plugins have been configured
+    def after_configuration
+      # do nothing by default
+    end
+
+    # called before any plugins have been setup
+    def before_setup
+      # do nothing by default
+    end
+
+    # called after all plugins have been setup
+    def after_setup
+      # do nothing by default
+    end
+
+    # called before deploying any resources
+    def before_deploy(manifest)
+      # do nothing by default
+    end
+
+    # called after deploying all resources
+    def after_deploy(manifest)
+      # do nothing by default
+    end
+
+    private
+
+    def after_initialize
+      # override this in derived classes
+    end
+  end
+end

data/lib/kuby/plugins.rb

@@ -0,0 +1,6 @@
+module Kuby
+  module Plugins
+    autoload :NginxIngress, 'kuby/plugins/nginx_ingress'
+    autoload :RailsApp,     'kuby/plugins/rails_app'
+  end
+end

data/lib/kuby/plugins/nginx_ingress.rb

@@ -0,0 +1,71 @@
+require 'kube-dsl'
+
+module Kuby
+  module Plugins
+    class NginxIngress < ::Kuby::Plugin
+      class Config
+        extend ::KubeDSL::ValueFields
+
+        value_fields :provider
+      end
+
+      VERSION = '0.27.1'.freeze
+      DEFAULT_PROVIDER = 'cloud-generic'.freeze
+      NAMESPACE = 'ingress-nginx'.freeze
+      SERVICE_NAME = 'ingress-nginx'.freeze
+
+      SETUP_RESOURCES = [
+        "https://raw.githubusercontent.com/kubernetes/ingress-nginx/nginx-#{VERSION}/deploy/static/mandatory.yaml",
+        "https://raw.githubusercontent.com/kubernetes/ingress-nginx/nginx-#{VERSION}/deploy/static/provider/%{provider}.yaml"
+      ].freeze
+
+      def configure(&block)
+        @config.instance_eval(&block) if block
+      end
+
+      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)
+        end
+
+        Kuby.logger.info('Nginx ingress resources deployed!')
+      rescue => e
+        Kuby.logger.fatal(e.message)
+        raise
+      end
+
+      def namespace
+        NAMESPACE
+      end
+
+      def service_name
+        SERVICE_NAME
+      end
+
+      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
+
+      def kubernetes_cli
+        environment.kubernetes.provider.kubernetes_cli
+      end
+    end
+  end
+end

data/lib/kuby/plugins/rails_app.rb

@@ -0,0 +1,18 @@
+module Kuby
+  module Plugins
+    module RailsApp
+      autoload :AssetCopyTask,   'kuby/plugins/rails_app/asset_copy_task'
+      autoload :Assets,          'kuby/plugins/rails_app/assets'
+      autoload :Database,        'kuby/plugins/rails_app/database'
+      autoload :MySQL,           'kuby/plugins/rails_app/mysql'
+      autoload :Plugin,          'kuby/plugins/rails_app/plugin'
+      autoload :Postgres,        'kuby/plugins/rails_app/postgres'
+      autoload :RewriteDbConfig, 'kuby/plugins/rails_app/rewrite_db_config'
+      autoload :Sqlite,          'kuby/plugins/rails_app/sqlite'
+    end
+  end
+end
+
+Kuby.register_plugin(:rails_assets, Kuby::Plugins::RailsApp::Assets)
+
+load File.expand_path(File.join('rails_app', 'tasks.rake'), __dir__)

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

@@ -0,0 +1,117 @@
+require 'fileutils'
+require 'pathname'
+
+module Kuby
+  module Plugins
+    module RailsApp
+      # Works by maintaining a directory structure where each deploy creates
+      # a new directory. Each directory is given a timestamped name. Assets
+      # are symlinked into a special 'current' directory from each of the
+      # timestamped directories. Each invocation overrides existing symlinks
+      # if they already exist. This technique ensures assets from the previous
+      # deploy remain available while the web servers are restarting.
+      class AssetCopyTask
+        TIMESTAMP_FORMAT = '%Y%m%d%H%M%S'.freeze
+        KEEP = 5
+
+        attr_reader :dest_path, :source_path
+
+        def initialize(to:, from:)
+          @dest_path = to
+          @source_path = from
+        end
+
+        def run
+          FileUtils.mkdir_p(ts_dir)
+          FileUtils.mkdir_p(current_dir)
+
+          copy_new_assets
+          delete_old_assets
+
+          nil
+        end
+
+        private
+
+        def copy_new_assets
+          # Copy all assets to new timestamp directory
+          #
+          # "source_path/." is special syntax. From the Ruby docs:
+          # cp_r('src', 'dest') makes dest/src, but cp_r('src/.', 'dest') doesn't
+          FileUtils.cp_r(File.join(source_path, '.'), ts_dir)
+
+          relative_source_files = Dir.chdir(ts_dir) do
+            Dir.glob(File.join('**', '*'))
+          end
+
+          relative_source_files.each do |relative_source_file|
+            source_file = Pathname(File.join(current_dir, relative_source_file))
+            source_ts_file = Pathname(File.join(ts_dir, relative_source_file))
+            next unless File.file?(source_ts_file)
+
+            # create individual symlinks for each file in source dir
+            target_file = File.join(current_dir, relative_source_file)
+            FileUtils.mkdir_p(File.dirname(target_file))
+            source_ln_file = source_ts_file.relative_path_from(source_file.dirname)
+            FileUtils.ln_s(source_ln_file, target_file, force: true)
+            Kuby.logger.info("Linked #{source_ln_file} -> #{target_file}")
+          end
+        end
+
+        def delete_old_assets
+          # find all asset directories; directories have timestamp names
+          asset_dirs = (Dir.glob(File.join(dest_path, '*')) - [current_dir])
+            .select { |dir| File.directory?(dir) && try_parse_ts(File.basename(dir)) }
+            .sort_by { |dir| parse_ts(File.basename(dir)) }
+            .reverse
+
+          # only keep the n most recent directories
+          dirs_to_delete = asset_dirs[KEEP..-1] || []
+
+          dirs_to_delete.each do |dir_to_delete|
+            relative_files_to_delete = Dir.chdir(dir_to_delete) do
+              Dir.glob(File.join('**', '*'))
+            end
+
+            relative_files_to_delete.each do |relative_file_to_delete|
+              file_to_delete = File.join(dir_to_delete, relative_file_to_delete)
+              next unless File.file?(file_to_delete)
+
+              link = File.join(current_dir, relative_file_to_delete)
+              next unless File.symlink?(link)
+
+              # Only remove a symlink if it still points to a resource
+              # in the directory we're currently deleting. Othewise, leave
+              # it there - it was added by another deploy.
+              if File.readlink(link) == file_to_delete
+                File.unlink(link)
+              end
+            end
+
+            FileUtils.rm_r(dir_to_delete)
+          end
+        end
+
+        def try_parse_ts(ts)
+          parse_ts(ts)
+        rescue ArgumentError
+          return nil
+        end
+
+        def parse_ts(ts)
+          Time.strptime(ts, TIMESTAMP_FORMAT)
+        end
+
+        def ts_dir
+          @ts_dir ||= File.join(
+            dest_path, Time.now.strftime(TIMESTAMP_FORMAT)
+          )
+        end
+
+        def current_dir
+          @current_dir ||= File.join(dest_path, 'current')
+        end
+      end
+    end
+  end
+end

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