kuby-core 0.8.1 → 0.11.0

data/lib/kuby/commands.rb

@@ -0,0 +1,245 @@
+# typed: true
+require 'kuby/version'
+require 'gli'
+
+module Kuby
+  class Commands
+    extend GLI::App
+
+    # GLI doesn't have a wildcard option, so it's impossible to tell it to
+    # slurp up all args after a certain point. In our case, we want to be
+    # able to invoke `rails` commands and pass through all the original
+    # flags, switches, etc. To get around GLI's limitations, we identify
+    # `rails` commands in this hijacked `run` method and only use GLI to
+    # parse global options (like -e). The rest of the Rails options are
+    # captured in an instance variable and thereby made available to the
+    # Rails command handlers defined below. We use Module#prepend here to
+    # avoid the usual series of cryptic alias_method calls (note that there
+    # is no singleton class version of #prepend in the Ruby language).
+    singleton_class.send(:prepend, Module.new do
+      def run(args)
+        if idx = args.index('rails') || idx = args.index('rake')
+          @rails_options = args[idx..-1]
+          super(args[0..idx])
+        else
+          super
+        end
+      end
+    end)
+
+    def self.tasks
+      Kuby::Tasks.new(Kuby.environment)
+    end
+
+    def self.must_be_dev_env!
+      unless Kuby.environment.development?
+        fail "Command not supported in the '#{Kuby.environment.name}' environment"
+      end
+    end
+
+    program_desc 'Kuby command-line interface. Kuby is a convention '\
+      'over configuration approach for running Rails apps in Kubernetes.'
+
+    version Kuby::VERSION
+
+    subcommand_option_handling :normal
+    arguments :loose
+
+    desc 'The Kuby environment to use. Overrides KUBY_ENV.'
+    flag [:e, :environment], type: String, required: false
+
+    desc 'Path to your Kuby config file. Overrides KUBY_CONFIG.'
+    default_value './kuby.rb'
+    flag [:c, :config]
+
+    pre do |global_options, options, args|
+      Kuby.env = global_options[:environment] if global_options[:environment]
+      Kuby.load!(global_options[:config])
+
+      # GLI will abort unless this block returns a truthy value
+      true
+    end
+
+    # These are only stubs included to fill out the help screens. Rails
+    # commands are handled by the RailsCommands class.
+    desc 'Runs a Rails command.'
+    command :rails do |rc|
+      rc.action do |global_options, options, args|
+        must_be_dev_env!
+        exit 1 unless tasks.dev_deployment_ok
+        Kuby::RailsCommands.run(@rails_options)
+      end
+
+      rc.desc 'Runs the rails server (run `rails server --help` for options)'
+      rc.command [:server, :s] do |c|
+        c.action do |global_options, options, args|
+          must_be_dev_env!
+          exit 1 unless tasks.dev_deployment_ok
+          Kuby::RailsCommands.run(@rails_options)
+        end
+      end
+
+      rc.desc 'Runs a script in the Rails environment (run `rails runner --help` for options)'
+      rc.command [:runner, :r] do |c|
+        c.action do |global_options, options, args|
+          must_be_dev_env!
+          exit 1 unless tasks.dev_deployment_ok
+          Kuby::RailsCommands.run(@rails_options)
+        end
+      end
+
+      rc.desc 'Starts an interactive Ruby console with the Rails environment loaded '\
+        '(run `rails console --help` for options)'
+      rc.command [:console, :c] do |c|
+        c.action do |global_options, options, args|
+          must_be_dev_env!
+          exit 1 unless tasks.dev_deployment_ok
+          Kuby::RailsCommands.run(@rails_options)
+        end
+      end
+    end
+
+    desc 'Runs a rake task.'
+    command :rake do |rc|
+      rc.action do |global_options, options, args|
+        must_be_dev_env!
+        exit 1 unless tasks.dev_deployment_ok
+        Kuby::RailsCommands.run(@rails_options)
+      end
+    end
+
+    desc 'Builds the Docker image.'
+    command :build do |c|
+      c.action do |global_options, options, args|
+        tasks.build
+      end
+    end
+
+    desc 'Pushes the Docker image to the configured registry.'
+    command :push do |c|
+      c.action do |global_options, options, args|
+        tasks.push
+      end
+    end
+
+    desc 'Gets your Kubernetes cluster ready to run your Rails app.'
+    command :setup do |c|
+      c.action do |global_options, options, args|
+        tasks.setup
+      end
+    end
+
+    desc 'Prints the effective Dockerfile used to build the Docker image.'
+    command :dockerfile do |c|
+      c.action do |global_options, options, args|
+        tasks.print_dockerfile
+      end
+    end
+
+    desc 'Deploys the application.'
+    command :deploy do |c|
+      c.desc 'The Docker tag to deploy. Defaults to the most recent tag.'
+      c.flag [:t, :tag], required: false
+      c.action do |global_options, options, args|
+        tasks.deploy(options[:tag])
+      end
+    end
+
+    desc 'Rolls back to the previous Docker tag.'
+    command :rollback do |c|
+      c.action do |global_options, options, args|
+        tasks.rollback
+      end
+    end
+
+    desc 'Prints the effective Kubernetes resources that will be applied on deploy.'
+    command :resources do |c|
+      c.action do |global_options, options, args|
+        tasks.print_resources
+      end
+    end
+
+    desc 'Prints out the contents of the kubeconfig Kuby is using to communicate with your cluster.'
+    command :kubeconfig do |c|
+      c.action do |global_options, options, args|
+        tasks.print_kubeconfig
+      end
+    end
+
+    desc 'Runs an arbitrary kubectl command.'
+    command :kubectl do |c|
+      c.desc 'Prefixes the kubectl command with the namespace associated with '\
+        'the current environment. For example, if the Kuby env is "production", '\
+        'this option will prefix the kubectl command with "-n myapp-production".'
+      c.switch [:N, :namespaced], default: false
+      c.action do |global_options, options, args|
+        if options[:namespaced]
+          # sorry Demeter
+          namespace = Kuby.definition.environment.kubernetes.namespace.metadata.name
+          args = ['-n', namespace, *args]
+        end
+
+        tasks.kubectl(*args)
+      end
+    end
+
+    desc 'Runs commands, etc against the Kubernetes cluster.'
+    command :remote do |rc|
+      rc.desc 'Tails (i.e. continuously streams) the Rails log from your running application.'
+      rc.command :logs do |c|
+        c.action do |global_options, options, args|
+          exit 1 unless tasks.dev_deployment_ok
+          tasks.remote_logs
+        end
+      end
+
+      rc.desc 'Lists running Kubernetes pods.'
+      rc.command :status do |c|
+        c.action do |global_options, options, args|
+          exit 1 unless tasks.dev_deployment_ok
+          tasks.remote_status
+        end
+      end
+
+      rc.desc 'Runs an arbitrary command inside a running Rails pod.'
+      rc.command :exec do |c|
+        c.action do |global_options, options, args|
+          exit 1 unless tasks.dev_deployment_ok
+          tasks.remote_exec(args)
+        end
+      end
+
+      rc.desc 'Establishes a shell inside a running Rails pod.'
+      rc.command :shell do |c|
+        c.action do |global_options, options, args|
+          exit 1 unless tasks.dev_deployment_ok
+          tasks.remote_shell
+        end
+      end
+
+      rc.desc 'Establishes a Rails console inside a running Rails pod.'
+      rc.command :console do |c|
+        c.action do |global_options, options, args|
+          exit 1 unless tasks.dev_deployment_ok
+          tasks.remote_console
+        end
+      end
+
+      rc.desc 'Establishes a database console inside a running Rails pod.'
+      rc.command :dbconsole do |c|
+        c.action do |global_options, options, args|
+          exit 1 unless tasks.dev_deployment_ok
+          tasks.remote_dbconsole
+        end
+      end
+
+      rc.desc "Restarts the Rails app's web pods."
+      rc.command :restart do |c|
+        c.action do |global_options, options, args|
+          exit 1 unless tasks.dev_deployment_ok
+          tasks.remote_restart
+        end
+      end
+    end
+  end
+end

data/lib/kuby/definition.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Kuby
   class Definition
     attr_reader :app_name
@@ -9,9 +10,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,256 @@
+# typed: true
+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