kuby-core 0.1.0

data/lib/kuby/kubernetes/errors.rb

@@ -0,0 +1,22 @@
+module Kuby
+  module Kubernetes
+    class KubernetesCLIError < StandardError; end
+
+    class InvalidResourceError < KubernetesCLIError
+      attr_accessor :resource
+    end
+
+    class InvalidResourceUriError < KubernetesCLIError
+      attr_accessor :resource_uri
+    end
+
+    class GetResourceError < KubernetesCLIError; end
+
+    class MissingDeploymentError < StandardError; end
+    class MissingProviderError < StandardError; end
+    class MissingPluginError < StandardError; end
+
+    class MissingResourceError < StandardError; end
+    class DuplicateResourceError < StandardError; end
+  end
+end

data/lib/kuby/kubernetes/manifest.rb

@@ -0,0 +1,56 @@
+require 'set'
+
+module Kuby
+  module Kubernetes
+    class Manifest
+      include Enumerable
+
+      def initialize(resources)
+        @resources = resources
+
+        ensure_all_resources_unique!
+      end
+
+      def each(&block)
+        @resources.each(&block)
+      end
+
+      def find(kind, name)
+        @resources.find do |resource|
+          matches?(resource, kind, name)
+        end
+      end
+
+      def delete(kind, name)
+        idx = @resources.index do |resource|
+          matches?(resource, kind, name)
+        end
+
+        resources.delete(idx) if idx
+      end
+
+      def <<(resource)
+        @resources << resource
+      end
+
+      private
+
+      def matches?(resource, kind, name)
+        resource.kind_sym == kind && resource.metadata.name == name
+      end
+
+      def ensure_all_resources_unique!
+        seen = Set.new
+
+        @resources.each do |resource|
+          key = "#{resource.kind_sym}-#{resource.metadata.name}"
+
+          if seen.include?(key)
+            raise DuplicateResourceError, "found more than one #{resource.kind.downcase} "\
+              "resource named '#{resource.metadata.name}'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/kubernetes/minikube_provider.rb

@@ -0,0 +1,51 @@
+require 'kube-dsl'
+
+module Kuby
+  module Kubernetes
+    class MinikubeProvider < Provider
+      STORAGE_CLASS_NAME = 'hostpath'.freeze
+
+      class Config
+        extend ::KubeDSL::ValueFields
+
+        value_fields :kubeconfig
+      end
+
+      attr_reader :config
+
+      def configure(&block)
+        config.instance_eval(&block) if block
+      end
+
+      def after_configuration
+        if rails_app = spec.plugin(:rails_app)
+          # Remove ingress and change service type from ClusterIP to
+          # LoadBalancer. No need to set up ingress for minikube since
+          # it handles all the localhost mapping, etc if you set up a
+          # service LB.
+          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
+        config.kubeconfig
+      end
+
+      def storage_class_name
+        STORAGE_CLASS_NAME
+      end
+
+      private
+
+      def after_initialize
+        @config = Config.new
+      end
+    end
+  end
+end

data/lib/kuby/kubernetes/plugin.rb

@@ -0,0 +1,55 @@
+module Kuby
+  module Kubernetes
+    class Plugin
+      attr_reader :definition
+
+      def initialize(definition)
+        @definition = definition
+        after_initialize
+      end
+
+      def configure(&block)
+        # do nothing by default
+      end
+
+      def setup
+        # do nothing by default
+      end
+
+      def resources
+        []
+      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
+end

data/lib/kuby/kubernetes/plugins.rb

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

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

@@ -0,0 +1,61 @@
+require 'kube-dsl'
+
+module Kuby
+  module Kubernetes
+    module Plugins
+      class NginxIngress < 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')
+
+          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 after_initialize
+          @config = Config.new
+        end
+
+        def kubernetes_cli
+          definition.kubernetes.provider.kubernetes_cli
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,58 @@
+module Kuby
+  module Kubernetes
+    module Plugins
+      module RailsApp
+        class UnsupportedDatabaseError < StandardError; end
+
+        class Database
+          ADAPTER_MAP = {
+            'sqlite3' => Sqlite,
+            'mysql2' => MySQL,
+            'postgresql' => Postgres
+          }.freeze
+
+          def self.get(definition)
+            new(definition).database
+          end
+
+          def self.get_adapter(adapter)
+            ADAPTER_MAP.fetch(adapter) do
+              raise UnsupportedDatabaseError, "Kuby does not support the '#{adapter}'"\
+                'database adapter'
+            end
+          end
+
+          attr_reader :definition
+
+          def initialize(definition)
+            @definition = definition
+          end
+
+          def database
+            @database ||= self.class
+              .get_adapter(adapter)
+              .new(definition, environment, db_configs)
+          end
+
+          private
+
+          def adapter
+            db_config['adapter']
+          end
+
+          def db_config
+            @db_config ||= db_configs[environment]
+          end
+
+          def environment
+            @environment ||= definition.environment
+          end
+
+          def db_configs
+            @db_configs ||= definition.app.config.database_configuration
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+require 'kube-dsl'
+require 'kuby/kube-db'
+
+module Kuby
+  module Kubernetes
+    module Plugins
+      module RailsApp
+        class MySQL < Kuby::Kubernetes::Plugin
+          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(:mysql_dev)
+            definition.docker.package_phase.add(:mysql_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 :user, user
+              end
+            end
+          end
+
+          def password(password)
+            secret do
+              data do
+                set :password, password
+              end
+            end
+          end
+
+          def secret(&block)
+            context = self
+
+            @secret ||= KubeDSL.secret do
+              metadata do
+                name "#{context.base_name}-mysql-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.my_sql do
+              api_version 'kubedb.com/v1alpha1'
+
+              metadata do
+                name "#{context.base_name}-mysql"
+                namespace context.kubernetes.namespace.metadata.name
+              end
+
+              spec do
+                database_secret do
+                  secret_name context.secret.metadata.name
+                end
+
+                version '5.7-v2'
+                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}-#{environment}"
+          end
+
+          def kubernetes
+            definition.kubernetes
+          end
+
+          def app
+            definition.app
+          end
+
+          private
+
+          def config
+            configs[environment]
+          end
+        end
+      end
+    end
+  end
+end
+
+Kuby.register_package(:mysql_client,
+  debian: 'default-mysql-client',
+  alpine: 'mariadb-client'
+)
+
+Kuby.register_package(:mysql_dev,
+  debian: 'default-libmysqlclient-dev',
+  alpine: 'mariadb-dev'
+)