kuby-core 0.1.0

data/lib/kuby/kubernetes/provider.rb

@@ -0,0 +1,77 @@
+require 'kubernetes-cli'
+
+module Kuby
+  module Kubernetes
+    class Provider
+      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
+
+      # called after all providers and plugins have been configured
+      def after_configuration
+        # do nothing by default
+      end
+
+      # called before any providers or plugins have been setup
+      def before_setup
+        # do nothing by default
+      end
+
+      # called after all providers and plugins have been setup
+      def after_setup
+        # do nothing by default
+      end
+
+      # called before the deploy is initiated
+      def before_deploy(manifest)
+        # do nothing by default
+      end
+
+      # called after the deploy has completed
+      def after_deploy(manifest)
+        # do nothing by default
+      end
+
+      def deploy
+        deployer.deploy
+      end
+
+      def rollback
+        deployer.rollback
+      end
+
+      def kubernetes_cli
+        @kubernetes_cli ||= ::KubernetesCLI.new(kubeconfig_path)
+      end
+
+      def kubeconfig_path
+        raise NotImplementedError, "please define #{__method__} in #{self.class.name}"
+      end
+
+      private
+
+      def after_initialize
+        # override this in derived classes
+      end
+
+      def deployer
+        @deployer ||= Kuby::Kubernetes::Deployer.new(definition)
+      end
+
+      def spec
+        definition.kubernetes
+      end
+    end
+  end
+end

data/lib/kuby/kubernetes/registry_secret.rb

@@ -0,0 +1,26 @@
+require 'base64'
+
+module Kuby
+  module Kubernetes
+    class RegistrySecret < ::KubeDSL::DSL::V1::Secret
+      array_field(:docker_config) { DockerConfig.new }
+
+      def initialize(&block)
+        instance_eval(&block) if block
+      end
+
+      def serialize
+        super.tap do |result|
+          result[:type] = 'kubernetes.io/dockerconfigjson'
+          result[:data] = {
+            :".dockerconfigjson" => Base64.strict_encode64({
+              auths: docker_configs.each_with_object({}) do |dc, ret|
+                ret.merge!(dc.serialize)
+              end
+            }.to_json)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/kuby/kubernetes/spec.rb

@@ -0,0 +1,152 @@
+require 'kube-dsl'
+
+module Kuby
+  module Kubernetes
+    class Spec
+      extend ::KubeDSL::ValueFields
+
+      attr_reader :definition, :plugins
+
+      def initialize(definition)
+        @definition = definition
+        @plugins = TrailingHash.new
+
+        # default plugins
+        add_plugin(:rails_app)
+      end
+
+      def provider(provider_name = nil, &block)
+        if provider_name
+          if @provider || provider_klass = Kuby.providers[provider_name]
+            @provider ||= provider_klass.new(definition)
+            @provider.configure(&block)
+          else
+            msg = if provider_name
+              "no provider registered with name #{provider_name}, "\
+                'do you need to add a gem to your Gemfile?'
+            else
+              'no provider configured'
+            end
+
+            raise MissingProviderError, msg
+          end
+        end
+
+        @provider
+      end
+
+      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].configure(&block) if block
+        else
+          raise MissingPluginError, "no plugin registered with name #{plugin_name}, "\
+            'do you need to add a gem to your Gemfile?'
+        end
+      end
+
+      alias_method :add_plugin, :configure_plugin
+
+      def plugin(plugin_name)
+        @plugins[plugin_name]
+      end
+
+      def after_configuration
+        @plugins.each { |_, plg| plg.after_configuration }
+        provider.after_configuration
+      end
+
+      def setup
+        provider.before_setup
+        provider.setup
+
+        @plugins.each { |_, plg| plg.before_setup }
+        @plugins.each { |_, plg| plg.setup }
+        @plugins.each { |_, plg| plg.after_setup }
+
+        provider.after_setup
+      end
+
+      def deploy(tag = nil)
+        tag ||= latest_tag
+
+        unless tag
+          raise Kuby::Docker::MissingTagError, 'could not find latest timestamped tag'
+        end
+
+        set_tag(tag)
+
+        provider.before_deploy(resources)
+        @plugins.each { |_, plg| plg.before_deploy(resources) }
+
+        provider.deploy
+
+        @plugins.each { |_, plg| plg.after_deploy(resources) }
+        provider.after_deploy(resources)
+      end
+
+      def rollback
+        depl = provider.kubernetes_cli.get_object(
+          'deployment', namespace.metadata.name, deployment.metadata.name
+        )
+
+        image_url = depl.dig('spec', 'template', 'spec', 'containers', 0, 'image')
+
+        unless image_url
+          raise MissingDeploymentError, "couldn't find an existing deployment"
+        end
+
+        deployed_tag = ::Kuby::Docker::TimestampTag.try_parse(image_url.split(':').last)
+        all_tags = docker.tags.all.timestamp_tags.sort
+        tag_idx = all_tags.index { |tag| tag.time == deployed_tag.time } || 0
+
+        if tag_idx == 0
+          raise Kuby::Docker::MissingTagError, 'could not find previous tag'
+        end
+
+        previous_tag = all_tags[tag_idx - 1]
+        deploy(previous_tag.to_s)
+      end
+
+      def namespace(&block)
+        spec = self
+
+        @namespace ||= KubeDSL.namespace do
+          metadata do
+            name "#{spec.selector_app}-#{spec.definition.environment}"
+          end
+        end
+
+        @namespace.instance_eval(&block) if block
+        @namespace
+      end
+
+      def resources
+        @resources ||= Manifest.new([
+          namespace,
+          *@plugins.flat_map { |_, plugin| plugin.resources }
+        ])
+      end
+
+      def set_tag(tag)
+        plugin(:rails_app).set_image("#{docker.metadata.image_url}:#{tag}")
+      end
+
+      def selector_app
+        @selector_app ||= definition.app_name.downcase
+      end
+
+      def docker
+        definition.docker
+      end
+
+      private
+
+      def latest_tag
+        @latest_tag ||= docker.tags.local.latest_tags.find do |tag|
+          tag != ::Kuby::Docker::Tags::LATEST
+        end
+      end
+    end
+  end
+end

data/lib/kuby/middleware.rb

@@ -0,0 +1,5 @@
+module Kuby
+  module Middleware
+    autoload :HealthCheck, 'kuby/middleware/health_check'
+  end
+end

data/lib/kuby/middleware/health_check.rb

@@ -0,0 +1,16 @@
+module Kuby
+  module Middleware
+    class HealthCheck
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return [204, {}, ['']] if env.fetch('PATH_INFO') == '/healthz'
+        app.call(env)
+      end
+    end
+  end
+end

data/lib/kuby/railtie.rb

@@ -0,0 +1,18 @@
+require 'logger'
+require 'rails/railtie'
+
+module Kuby
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      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
+  end
+end

data/lib/kuby/tasks.rb

@@ -0,0 +1,135 @@
+require 'rouge'
+
+module Kuby
+  class Tasks
+    attr_reader :definition
+
+    def initialize(definition)
+      @definition = definition
+    end
+
+    def print_dockerfile
+      theme = Rouge::Themes::Base16::Solarized.new
+      formatter = Rouge::Formatters::Terminal256.new(theme)
+      lexer = Rouge::Lexers::Docker.new
+      tokens = lexer.lex(Kuby.definition.docker.to_dockerfile.to_s)
+      puts formatter.format(tokens)
+    end
+
+    def build
+      docker.cli.build(
+        dockerfile: docker.to_dockerfile,
+        image_url:  docker.metadata.image_url,
+        tags:       docker.metadata.tags
+      )
+    end
+
+    def run
+      dockerfile = docker.to_dockerfile
+
+      docker.cli.run(
+        image_url: docker.metadata.image_url,
+        tag:       'latest',
+        ports:     dockerfile.exposed_ports
+      )
+    end
+
+    def push
+      image_url = docker.metadata.image_url
+
+      begin
+        docker.tags.local.latest_tags.each do |tag|
+          docker.cli.push(image_url, tag)
+        end
+      rescue Kuby::Docker::MissingTagError => e
+        msg = "#{e.message} Run rake kuby:build to build the"\
+          'Docker image before running this task.'
+
+        Kuby.logger.fatal(msg)
+      end
+    end
+
+    def print_resources
+      kubernetes.resources.each do |res|
+        puts res.to_resource.serialize.to_yaml
+      end
+    end
+
+    def print_kubeconfig
+      path = kubernetes.provider.kubeconfig_path
+      Kuby.logger.info("Printing contents of #{path}")
+      puts File.read(path)
+    end
+
+    def remote_logs
+      kubernetes_cli.logtail(namespace, match_labels.serialize)
+    end
+
+    def remote_status
+      kubernetes_cli.run_cmd(['-n', namespace, 'get', 'pods'])
+    end
+
+    def remote_shell
+      first_pod = get_first_pod
+      shell = docker.distro_spec.shell_exe
+      kubernetes_cli.exec_cmd(shell, namespace, first_pod.dig('metadata', 'name'))
+    end
+
+    def remote_console
+      first_pod = get_first_pod
+
+      kubernetes_cli.exec_cmd(
+        'bundle exec rails console', namespace, first_pod.dig('metadata', 'name')
+      )
+    end
+
+    def remote_dbconsole
+      first_pod = get_first_pod
+
+      kubernetes_cli.exec_cmd(
+        'bundle exec rails dbconsole', namespace, first_pod.dig('metadata', 'name')
+      )
+    end
+
+    private
+
+    def get_first_pod
+      pods = kubernetes_cli.get_objects(
+        'pods', namespace, match_labels.serialize
+      )
+
+      if pods.empty?
+        raise Kuby::Kubernetes::MissingResourceError,
+          "Couldn't find any running pods in namespace '#{namespace}' :("
+
+        exit 1
+      end
+
+      pods.first
+    end
+
+    def namespace
+      kubernetes.namespace.metadata.name
+    end
+
+    def match_labels
+      rails_app.deployment.spec.selector.match_labels
+    end
+
+    def rails_app
+      kubernetes.plugin(:rails_app)
+    end
+
+    def kubernetes_cli
+      kubernetes.provider.kubernetes_cli
+    end
+
+    def kubernetes
+      Kuby.definition.kubernetes
+    end
+
+    def docker
+      Kuby.definition.docker
+    end
+  end
+end

data/lib/kuby/tasks/kuby.rake

@@ -0,0 +1,63 @@
+namespace :kuby do
+  def tasks
+    @tasks ||= Kuby::Tasks.new(Kuby.definition)
+  end
+
+  task dockerfile: :environment do
+    tasks.print_dockerfile
+  end
+
+  task build: :environment do
+    tasks.build
+  end
+
+  task run: :environment do
+    tasks.run
+  end
+
+  task push: :environment do
+    tasks.push
+  end
+
+  task resources: :environment do
+    tasks.print_resources
+  end
+
+  task deploy: :environment do
+    Kuby.definition.kubernetes.deploy
+  end
+
+  task rollback: :environment do
+    Kuby.definition.kubernetes.rollback
+  end
+
+  task kubeconfig: :environment do
+    tasks.print_kubeconfig
+  end
+
+  task setup: :environment do
+    Kuby.definition.kubernetes.setup
+  end
+
+  namespace :remote do
+    task logs: :environment do
+      tasks.remote_logs
+    end
+
+    task status: :environment do
+      tasks.remote_status
+    end
+
+    task shell: :environment do
+      tasks.remote_shell
+    end
+
+    task console: :environment do
+      tasks.remote_console
+    end
+
+    task dbconsole: :environment do
+      tasks.remote_dbconsole
+    end
+  end
+end