kuby-core 0.8.1 → 0.9.0

data/lib/kuby/definition.rb

@@ -9,9 +9,7 @@ module Kuby
     def environment(name = Kuby.env, &block)
       name = name.to_s
 
-      if name
-        environments[name] ||= Environment.new(name, self)
-      end
+      environments[name] ||= Environment.new(name, self)
 
       if block_given?
         environments[name].instance_eval(&block)

data/lib/kuby/dev_setup.rb

@@ -0,0 +1,255 @@
+module Kuby
+  class Spinner
+    PIECES = %w(- \\ | /).freeze
+    INTERVAL = 0.2  # seconds
+
+    def self.spin(message)
+      yield new(message)
+    end
+
+    attr_reader :message, :status
+
+    def initialize(message)
+      @message = message
+      @status = :running
+      @thread = Thread.new do
+        counter = 0
+
+        while true
+          case status
+            when :running
+              piece = PIECES[counter % PIECES.size]
+              STDOUT.write "\r[#{piece}] #{message}"
+              sleep INTERVAL
+              counter += 1
+            when :success
+              STDOUT.write("\r[+] #{message}")
+              break
+            when :failure
+              STDOUT.write("\r[×] #{message}")
+              break
+          end
+        end
+
+        puts
+      end
+    end
+
+    def success
+      @status = :success
+      @thread.join
+    end
+
+    def failure
+      @status = :failure
+      @thread.join
+    end
+  end
+
+  class SetupTask
+    attr_reader :message, :callable
+
+    def initialize(message, callable)
+      @message = message
+      @callable = callable
+    end
+
+    def run
+      callable.call
+    end
+  end
+
+  class Pipe
+    attr_reader :name, :cli, :out, :err
+
+    def initialize(name, cli)
+      @name = name
+      @cli = cli
+      @out = StringIO.new
+      @err = StringIO.new
+    end
+
+    def wrap(&block)
+      cli.with_pipes(out, err) do
+        block.call
+      end
+    end
+
+    def success?
+      cli.last_status.nil? || cli.last_status.success?
+    end
+  end
+
+  class Pipes
+    include Enumerable
+
+    attr_reader :pipes, :ex
+
+    def self.build(clis)
+      new(clis.map { |name, cli| Pipe.new(name, cli) })
+    end
+
+    def initialize(pipes)
+      @pipes = pipes
+    end
+
+    def each(&block)
+      pipes.each(&block)
+    end
+
+    def wrap(&block)
+      do_wrap(pipes, &block)
+    end
+
+    def success?
+      pipes.all?(&:success?) && !ex
+    end
+
+    private
+
+    def do_wrap(remaining_pipes, &block)
+      if remaining_pipes.empty?
+        begin
+          yield
+        rescue => e
+          @ex = e
+        end
+
+        return
+      end
+
+      remaining_pipes[0].wrap do
+        do_wrap(remaining_pipes[1..-1], &block)
+      end
+    end
+  end
+
+  class SetupTaskList
+    attr_reader :tasks, :clis
+
+    def initialize(tasks, clis)
+      @tasks = tasks
+      @clis = clis
+    end
+
+    def run
+      tasks.each do |task|
+        pipes = Pipes.build(clis)
+
+        Spinner.spin(task.message) do |spinner|
+          pipes.wrap { task.run }
+
+          if pipes.success?
+            spinner.success
+          else
+            spinner.failure
+            print_error(pipes.ex)
+
+            pipes.each do |pipe|
+              print_streams(pipe)
+            end
+
+            return false
+          end
+        end
+      end
+
+      true
+    end
+
+    private
+
+    def print_streams(pipe)
+      unless pipe.out.string.strip.empty?
+        puts("========= #{pipe.name.upcase} STDOUT ========")
+        puts pipe.out.string
+      end
+
+      unless pipe.err.string.strip.empty?
+        puts("========= #{pipe.name.upcase} STDERR ========")
+        puts pipe.err.string
+      end
+    end
+
+    def print_error(ex)
+      return unless ex
+      puts("========= RUBY ERROR ========")
+      puts(ex.message)
+      puts(ex.backtrace.join("\n"))
+    end
+  end
+
+  class DevSetup
+    attr_reader :environment
+
+    def initialize(environment)
+      @environment = environment
+    end
+
+    def run
+      SetupTaskList.new(setup_tasks, clis).run
+    end
+
+    private
+
+    def setup_tasks
+      @setup_tasks ||= [
+        SetupTask.new(
+          'Building dev Docker image', -> { tasks.build }
+        ),
+
+        SetupTask.new(
+          'Setting up local Kubernetes cluster', -> { tasks.setup }
+        ),
+
+        SetupTask.new(
+          'Deploying dev environment', -> { tasks.deploy }
+        ),
+
+        SetupTask.new(
+          'Installing bundler', -> {
+            tasks.remote_system("gem install bundler -v #{Bundler::VERSION}")
+          }
+        ),
+
+        SetupTask.new(
+          'Installing bundled gems', -> { tasks.remote_system('bundle install') }
+        ),
+
+        SetupTask.new(
+          'Installing Javascript packages', -> { tasks.remote_system('yarn install') }
+        ),
+
+        SetupTask.new(
+          'Creating database', -> { tasks.remote_system('bundle exec rake db:create') }
+        ),
+
+        SetupTask.new(
+          'Migrating database', -> { tasks.remote_system('bundle exec rake db:migrate') }
+        )
+      ]
+    end
+
+    def kubernetes
+      environment.kubernetes
+    end
+
+    def docker
+      environment.docker
+    end
+
+    def clis
+      @clis ||= {
+        kubectl: kubernetes.provider.kubernetes_cli,
+        helm: kubernetes.provider.helm_cli,
+        krane: kubernetes.provider.deployer,
+        docker: docker.cli,
+        kuby: Kuby.logger
+      }
+    end
+
+    def tasks
+      @tasks ||= Kuby::Tasks.new(environment)
+    end
+  end
+end

data/lib/kuby/docker.rb

@@ -9,6 +9,7 @@ module Kuby
     autoload :CopyPhase,      'kuby/docker/copy_phase'
     autoload :Credentials,    'kuby/docker/credentials'
     autoload :Debian,         'kuby/docker/debian'
+    autoload :DevSpec,        'kuby/docker/dev_spec'
     autoload :Dockerfile,     'kuby/docker/dockerfile'
     autoload :InlineLayer,    'kuby/docker/inline_layer'
     autoload :Layer,          'kuby/docker/layer'

data/lib/kuby/docker/bundler_phase.rb

@@ -13,14 +13,14 @@ module Kuby
         v = version || default_version
         wo = without || DEFAULT_WITHOUT
 
-        dockerfile.run("gem install bundler -v #{v}")
+        dockerfile.run('gem', 'install', 'bundler', '-v', v)
 
         # bundle install
         dockerfile.copy(gf, '.')
         dockerfile.copy(lf, '.')
 
         # set bundle path so docker will cache the bundle
-        dockerfile.run('mkdir ./bundle')
+        dockerfile.run('mkdir', './bundle')
         dockerfile.env('BUNDLE_PATH=./bundle')
 
         unless wo.empty?
@@ -35,7 +35,7 @@ module Kuby
         )
 
         # generate binstubs and add the bin directory to our path
-        dockerfile.run('bundle binstubs --all')
+        dockerfile.run('bundle', 'binstubs', '--all')
         dockerfile.env("PATH=./bin:$PATH")
       end
 

data/lib/kuby/docker/cli.rb

@@ -1,5 +1,6 @@
 require 'json'
 require 'open3'
+require 'shellwords'
 
 module Kuby
   module Docker
@@ -42,10 +43,13 @@ module Kuby
         config.fetch('auths', {}).keys
       end
 
-      def build(dockerfile:, image_url:, tags:)
+      def build(dockerfile:, image_url:, tags:, build_args: {})
         cmd = [
           executable, 'build',
           *tags.flat_map { |tag| ['-t', "#{image_url}:#{tag}"] },
+          *build_args.flat_map do |arg, val|
+            ['--build-arg', Shellwords.shellescape("#{arg}=#{val}")]
+          end,
           '-f-', '.'
         ]
 
@@ -99,6 +103,14 @@ module Kuby
       def status_key
         :kuby_docker_cli_last_status
       end
+
+      def stdout_key
+        :kuby_docker_stdout
+      end
+
+      def stderr_key
+        :kuby_docker_stderr
+      end
     end
   end
 end

data/lib/kuby/docker/dev_spec.rb

@@ -0,0 +1,131 @@
+module Kuby
+  module Docker
+    class WebserverDevPhase < Layer
+      DEFAULT_PORT = 3000
+
+      attr_accessor :port
+
+      def apply_to(dockerfile)
+        dockerfile.expose(port)
+      end
+
+      def port
+        @port || DEFAULT_PORT
+      end
+    end
+
+    class DevSpec
+      attr_reader :environment
+
+      def initialize(environment)
+        @environment = environment
+      end
+
+      def working_dir(dir)
+        setup_phase.working_dir = dir
+      end
+
+      def rails_env(env)
+        setup_phase.rails_env = env
+      end
+
+      def package(*args)
+        package_phase.add(*args)
+      end
+
+      def distro(distro_name)
+        metadata.distro = distro_name
+        @distro_spec = nil
+      end
+
+      def port(port)
+        webserver_phase.port = port
+      end
+
+      def use(*args, &block)
+        layer_stack.use(*args, &block)
+      end
+
+      def insert(*args, &block)
+        layer_stack.insert(*args, &block)
+      end
+
+      def delete(*args)
+        layer_stack.delete(*args)
+      end
+
+      def exists?(*args)
+        layer_stack.includes?(*args)
+      end
+
+      def to_dockerfile
+        Dockerfile.new.tap do |df|
+          layer_stack.each { |layer| layer.apply_to(df) }
+          df.cmd("#{distro_spec.shell_exe} -c 'while test 1; do sleep 5; done'")
+        end
+      end
+
+      def setup_phase
+        @setup_phase ||= SetupPhase.new(environment)
+      end
+
+      def package_phase
+        @package_phase ||= PackagePhase.new(environment)
+      end
+
+      def webserver_phase
+        @webserver_phase ||= WebserverDevPhase.new(environment)
+      end
+
+      def metadata
+        @metadata ||= Metadata.new(environment)
+      end
+
+      def cli
+        @cli ||= Docker::CLI.new
+      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
+
+      def tag
+        t = ENV.fetch('KUBY_DOCKER_TAG') do
+          tags.latest_timestamp_tag
+        end
+
+        unless t
+          raise MissingTagError, 'could not find latest timestamped tag'
+        end
+
+        t.to_s
+      end
+
+      def previous_tag(*)
+        raise MissingTagError, 'cannot roll back in the development environment'
+      end
+
+      def cli
+        @cli ||= Docker::CLI.new
+      end
+
+      private
+
+      def tags
+        @tags ||= LocalTags.new(cli, metadata)
+      end
+
+      def layer_stack
+        @layer_stack ||= LayerStack.new.tap do |stack|
+          stack.use(:setup_phase, setup_phase)
+          stack.use(:package_phase, package_phase)
+          stack.use(:webserver_phase, webserver_phase)
+        end
+      end
+    end
+  end
+end