kuby-core 0.1.0

data/lib/kuby/docker/setup_phase.rb

@@ -0,0 +1,29 @@
+module Kuby
+  module Docker
+    class SetupPhase < Phase
+      DEFAULT_WORKING_DIR = '/usr/src/app'.freeze
+
+      attr_accessor :base_image, :working_dir
+
+      def apply_to(dockerfile)
+        dockerfile.from(base_image || default_base_image)
+        dockerfile.workdir(working_dir || DEFAULT_WORKING_DIR)
+        dockerfile.env("RAILS_ENV=#{Kuby.env}")
+        dockerfile.env("KUBY_ENV=#{Kuby.env}")
+      end
+
+      private
+
+      def default_base_image
+        @default_base_image ||= case metadata.distro
+          when :debian
+            "ruby:#{RUBY_VERSION}"
+          when :alpine
+            "ruby:#{RUBY_VERSION}-alpine"
+          else
+            # ERROR
+        end
+      end
+    end
+  end
+end

data/lib/kuby/docker/spec.rb

@@ -0,0 +1,147 @@
+require 'docker/remote'
+
+module Kuby
+  module Docker
+    class Spec
+      attr_reader :definition
+
+      def initialize(definition)
+        @definition = definition
+      end
+
+      def base_image(image_url)
+        setup_phase.base_image = image_url
+      end
+
+      def working_dir(dir)
+        setup_phase.working_dir = dir
+      end
+
+      def rails_env(env)
+        setup_phase.rails_env = env
+      end
+
+      def bundler_version(version)
+        bundler_phase.bundler_version = version
+      end
+
+      def gemfile(path)
+        bundler_phase.gemfile = path
+      end
+
+      def package(pkg)
+        package_phase << pkg
+      end
+
+      def distro(distro_name)
+        metadata.distro = distro_name
+        @distro_spec = nil
+      end
+
+      def files(path)
+        copy_phase << path
+      end
+
+      def port(port)
+        webserver_phase.port = port
+      end
+
+      def image_url(url)
+        metadata.image_url = url
+      end
+
+      def use(*args)
+        layer_stack.use(*args)
+      end
+
+      def insert(*args)
+        layer_stack.insert(*args)
+      end
+
+      def delete(*args)
+        layer_stack.delete(*args)
+      end
+
+      def credentials(&block)
+        @credentials ||= Credentials.new
+        @credentials.instance_eval(&block) if block
+        @credentials
+      end
+
+      def to_dockerfile
+        Dockerfile.new.tap do |df|
+          layer_stack.each { |layer| layer.apply_to(df) }
+        end
+      end
+
+      def setup_phase
+        @setup_phase ||= SetupPhase.new(definition)
+      end
+
+      def package_phase
+        @package_phase ||= PackagePhase.new(definition)
+      end
+
+      def bundler_phase
+        @bundler_phase ||= BundlerPhase.new(definition)
+      end
+
+      def yarn_phase
+        @yarn_phase ||= YarnPhase.new(definition)
+      end
+
+      def copy_phase
+        @copy_phase ||= CopyPhase.new(definition)
+      end
+
+      def assets_phase
+        @assets_phase ||= AssetsPhase.new(definition)
+      end
+
+      def webserver_phase
+        @webserver_phase ||= WebserverPhase.new(definition)
+      end
+
+      def metadata
+        @metadata ||= Metadata.new(definition)
+      end
+
+      def tags
+        @tags ||= Tags.new(cli, remote_client, metadata)
+      end
+
+      def cli
+        @cli ||= Docker::CLI.new
+      end
+
+      def remote_client
+        @remote_client ||= ::Docker::Remote::Client.new(
+          metadata.image_host, metadata.image_repo,
+          credentials.username, credentials.password,
+        )
+      end
+
+      def distro_spec
+        @distro_spec ||= if distro_klass = Kuby.distros[metadata.distro]
+          distro_klass.new(self)
+        else
+          raise MissingDistroError, "distro '#{metadata.distro}' hasn't been registered"
+        end
+      end
+
+      private
+
+      def layer_stack
+        @layer_stack ||= LayerStack.new.tap do |stack|
+          stack.use(:setup_phase, setup_phase)
+          stack.use(:package_phase, package_phase)
+          stack.use(:bundler_phase, bundler_phase)
+          stack.use(:yarn_phase, yarn_phase)
+          stack.use(:copy_phase, copy_phase)
+          stack.use(:assets_phase, assets_phase)
+          stack.use(:webserver_phase, webserver_phase)
+        end
+      end
+    end
+  end
+end

data/lib/kuby/docker/tags.rb

@@ -0,0 +1,39 @@
+module Kuby
+  module Docker
+    class Tags
+      LATEST = Metadata::LATEST_TAG
+
+      attr_reader :cli, :remote_client, :metadata
+
+      def initialize(cli, remote_client, metadata)
+        @cli = cli
+        @remote_client = remote_client
+        @metadata = metadata
+      end
+
+      def tags
+        (local.tags + remote.tags).uniq
+      end
+
+      def latest_tags
+        (local.latest_tags + remote.latest_tags).uniq
+      end
+
+      def timestamp_tags
+        (local.timestamp_tags + remote.timestamp_tags).uniq
+      end
+
+      def all
+        self
+      end
+
+      def local
+        @local ||= LocalTags.new(cli, metadata)
+      end
+
+      def remote
+        @remote ||= RemoteTags.new(remote_client, metadata)
+      end
+    end
+  end
+end

data/lib/kuby/docker/timestamp_tag.rb

@@ -0,0 +1,36 @@
+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))
+        end
+      end
+
+      attr_reader :time
+
+      def initialize(time)
+        @time = time
+      end
+
+      def to_s
+        time.strftime(FORMAT)
+      end
+
+      def <=>(other)
+        time <=> other.time
+      end
+
+      def hash
+        time.hash
+      end
+
+      def eql?(other)
+        time == other.time
+      end
+    end
+  end
+end

data/lib/kuby/docker/webserver_phase.rb

@@ -0,0 +1,51 @@
+module Kuby
+  module Docker
+    class WebserverPhase < Phase
+      class Puma
+        attr_reader :phase
+
+        def initialize(phase)
+          @phase = phase
+        end
+
+        def apply_to(dockerfile)
+          dockerfile.cmd(
+            'puma',
+            '--workers', '4',
+            '--bind', 'tcp://0.0.0.0',
+            '--port', phase.port,
+            '--pidfile', './server.pid',
+            './config.ru'
+          )
+
+          dockerfile.expose(phase.port)
+        end
+      end
+
+      DEFAULT_PORT = 8080
+      WEBSERVER_MAP = { puma: Puma }.freeze
+
+      attr_accessor :port, :webserver
+
+      def apply_to(dockerfile)
+        ws = webserver || default_webserver
+        ws_class = WEBSERVER_MAP[ws]
+        raise "No webserver named #{ws}" unless ws_class
+
+        ws_class.new(self).apply_to(dockerfile)
+      end
+
+      def port
+        @port || DEFAULT_PORT
+      end
+
+      private
+
+      def default_webserver
+        if Gem.loaded_specs.include?('puma')
+          :puma
+        end
+      end
+    end
+  end
+end

data/lib/kuby/docker/yarn_phase.rb

@@ -0,0 +1,11 @@
+module Kuby
+  module Docker
+    class YarnPhase < Phase
+      def apply_to(dockerfile)
+        dockerfile.copy('package.json', '.')
+        dockerfile.copy('yarn.lock*', '.')
+        dockerfile.run('yarn', 'install')
+      end
+    end
+  end
+end

data/lib/kuby/kubernetes.rb

@@ -0,0 +1,16 @@
+require 'kuby/kubernetes/errors'
+
+module Kuby
+  module Kubernetes
+    autoload :MinikubeProvider, 'kuby/kubernetes/minikube_provider'
+    autoload :Deployer,         'kuby/kubernetes/deployer'
+    autoload :DockerConfig,     'kuby/kubernetes/docker_config'
+    autoload :Manifest,         'kuby/kubernetes/manifest'
+    autoload :Monitors,         'kuby/kubernetes/monitors'
+    autoload :Plugin,           'kuby/kubernetes/plugin'
+    autoload :Plugins,          'kuby/kubernetes/plugins'
+    autoload :Provider,         'kuby/kubernetes/provider'
+    autoload :RegistrySecret,   'kuby/kubernetes/registry_secret'
+    autoload :Spec,             'kuby/kubernetes/spec'
+  end
+end

data/lib/kuby/kubernetes/deployer.rb

@@ -0,0 +1,94 @@
+require 'fileutils'
+require 'krane'
+require 'securerandom'
+require 'yaml'
+
+module Kuby
+  module Kubernetes
+    class Deployer
+      attr_reader :definition
+
+      def initialize(definition)
+        @definition = definition
+      end
+
+      def deploy
+        namespaced, global = all_resources.partition do |resource|
+          # Unfortunately we can't use respond_to here because all KubeDSL
+          # objects use ObjectMeta, which has a namespace field. Not sure
+          # why, since it makes no sense for a namespace to have a namespace.
+          # Instead we just check for nil here.
+          resource.metadata.namespace
+        end
+
+        deploy_global_resources(global)
+        deploy_namespaced_resources(namespaced)
+      end
+
+      private
+
+      def deploy_global_resources(resources)
+        resources.each do |res|
+          Kuby.logger.info(
+            "Validating global resource, #{res.kind_sym.to_s.humanize.downcase} '#{res.metadata.name}'"
+          )
+
+          cli.apply(res, dry_run: true)
+        end
+
+        resources.each do |res|
+          Kuby.logger.info(
+            "Deploying #{res.kind_sym.to_s.humanize.downcase} '#{res.metadata.name}'"
+          )
+
+          cli.apply(res)
+        end
+      rescue InvalidResourceError => e
+        Kuby.logger.fatal(e.message)
+        Kuby.logger.fatal(e.resource.to_resource.to_yaml)
+      end
+
+      def deploy_namespaced_resources(resources)
+        old_kubeconfig = ENV['KUBECONFIG']
+        ENV['KUBECONFIG'] = provider.kubeconfig_path
+
+        tmpdir = Dir.mktmpdir('kuby-deploy-resources')
+
+        resources.each do |resource|
+          resource_path = File.join(
+            tmpdir, "#{SecureRandom.hex(6)}-#{resource.kind_sym.downcase}.yaml"
+          )
+
+          File.write(resource_path, resource.to_resource.to_yaml)
+        end
+
+        task = ::Krane::DeployTask.new(
+          namespace: namespace.metadata.name,
+          context: cli.current_context,
+          filenames: [tmpdir]
+        )
+
+        task.run!(verify_result: true, prune: false)
+      ensure
+        ENV['KUBECONFIG'] = old_kubeconfig
+        FileUtils.rm_rf(tmpdir)
+      end
+
+      def provider
+        definition.kubernetes.provider
+      end
+
+      def namespace
+        definition.kubernetes.namespace
+      end
+
+      def all_resources
+        definition.kubernetes.resources
+      end
+
+      def cli
+        provider.kubernetes_cli
+      end
+    end
+  end
+end

data/lib/kuby/kubernetes/docker_config.rb

@@ -0,0 +1,27 @@
+require 'base64'
+require 'kube-dsl'
+
+module Kuby
+  module Kubernetes
+    class DockerConfig
+      extend ::KubeDSL::ValueFields
+
+      value_fields :registry_host, :username, :password, :email
+
+      def initialize(&block)
+        instance_eval(&block) if block
+      end
+
+      def serialize
+        {
+          registry_host.to_sym => {
+            username: username,
+            password: password,
+            email:    email,
+            auth:     Base64.strict_encode64("#{username}:#{password}")
+          }
+        }
+      end
+    end
+  end
+end