kuby-core 0.11.16 → 0.12.0

data/lib/kuby/dev_setup.rb

@@ -1,346 +0,0 @@
-# typed: strict
-
-module Kuby
-  class Spinner
-    extend T::Sig
-
-    PIECES = T.let(%w(- \\ | /).freeze, T::Array[String])
-    INTERVAL = T.let(0.2, Float)  # seconds
-
-    sig {
-      params(
-        message: String,
-        block: T.proc.params(spinner: Spinner).void
-      )
-      .void
-    }
-    def self.spin(message, &block)
-      yield new(message)
-    end
-
-    sig { returns(String) }
-    attr_reader :message
-
-    sig { returns(Symbol) }
-    attr_reader :status
-
-    sig { params(message: String).void }
-    def initialize(message)
-      @message = T.let(message, String)
-      @status = T.let(:running, Symbol)
-      @thread = T.let(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, Thread)
-    end
-
-    sig { void }
-    def success
-      @status = :success
-      @thread.join
-    end
-
-    sig { void }
-    def failure
-      @status = :failure
-      @thread.join
-    end
-  end
-
-  class SetupTask
-    extend T::Sig
-
-    sig { returns(String) }
-    attr_reader :message
-
-    sig { returns(T.proc.void) }
-    attr_reader :callable
-
-    sig { params(message: String, callable: T.proc.void).void }
-    def initialize(message, callable)
-      @message = message
-      @callable = callable
-    end
-
-    sig { void }
-    def run
-      callable.call
-    end
-  end
-
-  class Pipe
-    extend T::Sig
-
-    sig { returns(Symbol) }
-    attr_reader :name
-
-    sig { returns(T.untyped) }
-    attr_reader :cli
-
-    sig { returns(StringIO) }
-    attr_reader :out
-
-    sig { returns(StringIO) }
-    attr_reader :err
-
-    sig { params(name: Symbol, cli: T.untyped).void }
-    def initialize(name, cli)
-      @name = T.let(name, Symbol)
-      @cli = T.let(cli, T.untyped)
-      @out = T.let(StringIO.new, StringIO)
-      @err = T.let(StringIO.new, StringIO)
-    end
-
-    sig { params(block: T.proc.void).void }
-    def wrap(&block)
-      cli.with_pipes(out, err) do
-        block.call
-      end
-    end
-
-    sig { returns(T::Boolean) }
-    def success?
-      cli.last_status.nil? || cli.last_status.success?
-    end
-  end
-
-  class Pipes
-    extend T::Sig
-    extend T::Generic
-
-    include Enumerable
-
-    Elem = type_member(fixed: Pipe)
-
-    sig { returns(T::Array[Pipe]) }
-    attr_reader :pipes
-
-    sig { returns(T.nilable(StandardError)) }
-    attr_reader :ex
-
-    sig { params(clis: T::Hash[Symbol, T.untyped]).returns(Pipes) }
-    def self.build(clis)
-      new(clis.map { |name, cli| Pipe.new(name, cli) })
-    end
-
-    sig { params(pipes: T::Array[Pipe]).void }
-    def initialize(pipes)
-      @ex = T.let(@ex, T.nilable(StandardError))
-      @pipes = T.let(pipes, T::Array[Pipe])
-    end
-
-    sig {
-      override.params(
-        block: T.proc.params(package: Pipe).void
-      )
-      .void
-    }
-    def each(&block)
-      pipes.each(&block)
-    end
-
-    sig { params(block: T.proc.void).void }
-    def wrap(&block)
-      do_wrap(pipes, &block)
-    end
-
-    sig { returns(T::Boolean) }
-    def success?
-      pipes.all?(&:success?) && !ex
-    end
-
-    private
-
-    sig {
-      params(
-        remaining_pipes: T::Array[Pipe],
-        block: T.proc.void
-      )
-      .void
-    }
-    def do_wrap(remaining_pipes, &block)
-      if remaining_pipes.empty?
-        begin
-          yield
-        rescue => e
-          @ex = e
-        end
-
-        return
-      end
-
-      T.must(remaining_pipes[0]).wrap do
-        do_wrap(T.must(remaining_pipes[1..-1]), &block)
-      end
-    end
-  end
-
-  class SetupTaskList
-    extend T::Sig
-
-    sig { returns(T::Array[SetupTask]) }
-    attr_reader :tasks
-
-    sig { returns T::Hash[Symbol, T.untyped] }
-    attr_reader :clis
-
-    sig { params(tasks: T::Array[SetupTask], clis: T::Hash[Symbol, T.untyped]).void }
-    def initialize(tasks, clis)
-      @tasks = tasks
-      @clis = clis
-    end
-
-    sig { void }
-    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
-
-    sig { params(pipe: Pipe).void }
-    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
-
-    sig { params(ex: T.nilable(StandardError)).void }
-    def print_error(ex)
-      return unless ex
-      puts("========= RUBY ERROR ========")
-      puts(ex.message)
-      puts(T.must(ex.backtrace).join("\n"))
-    end
-  end
-
-  class DevSetup
-    extend T::Sig
-
-    sig { returns(Environment) }
-    attr_reader :environment
-
-    sig { params(environment: Environment).void }
-    def initialize(environment)
-      @environment = T.let(environment, Environment)
-      @setup_tasks = T.let(@setup_tasks, T.nilable(T::Array[SetupTask]))
-      @clis = T.let(@clis, T.nilable(T::Hash[Symbol, T.untyped]))
-      @tasks = T.let(@tasks, T.nilable(Tasks))
-    end
-
-    sig { void }
-    def run
-      SetupTaskList.new(setup_tasks, clis).run
-    end
-
-    private
-
-    sig { returns(T::Array[SetupTask]) }
-    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
-
-    sig { returns(Kubernetes::Spec) }
-    def kubernetes
-      environment.kubernetes
-    end
-
-    sig { returns(Docker::Spec) }
-    def docker
-      environment.docker
-    end
-
-    sig { returns T::Hash[Symbol, T.untyped] }
-    def clis
-      @clis ||= {
-        kubectl: kubernetes.provider.kubernetes_cli,
-        helm: kubernetes.provider.helm_cli,
-        krane: kubernetes.provider.deployer,
-        docker: docker.cli,
-        kuby: Kuby.logger
-      }
-    end
-
-    sig { returns(Tasks) }
-    def tasks
-      @tasks ||= Kuby::Tasks.new(environment)
-    end
-  end
-end

data/lib/kuby/docker/dev_spec.rb

@@ -1,202 +0,0 @@
-# typed: strict
-
-module Kuby
-  module Docker
-    class WebserverDevPhase < Layer
-      extend T::Sig
-
-      DEFAULT_PORT = T.let(3000, Integer)
-
-      sig { params(port: Integer).void }
-      attr_writer :port
-
-      sig { params(environment: Environment).void }
-      def initialize(environment)
-        super
-
-        @port = T.let(@port, T.nilable(Integer))
-      end
-
-      sig { override.params(dockerfile: Dockerfile).void }
-      def apply_to(dockerfile)
-        dockerfile.expose(port)
-      end
-
-      sig { returns(Integer) }
-      def port
-        @port || DEFAULT_PORT
-      end
-    end
-
-    class DevSpec
-      extend T::Sig
-
-      sig { returns(Environment) }
-      attr_reader :environment
-
-      sig { params(environment: Environment).void }
-      def initialize(environment)
-        @environment = environment
-
-        @setup_phase = T.let(@setup_phase, T.nilable(SetupPhase))
-        @package_phase = T.let(@package_phase, T.nilable(PackagePhase))
-        @webserver_phase = T.let(@webserver_phase, T.nilable(WebserverDevPhase))
-        @metadata = T.let(@metadata, T.nilable(Metadata))
-        @distro_spec = T.let(@distro_spec, T.nilable(Distro))
-        @cli = T.let(@cli, T.nilable(CLI))
-        @tags = T.let(@tags, T.nilable(LocalTags))
-        @layer_stack = T.let(@layer_stack, T.nilable(Docker::LayerStack))
-      end
-
-      sig { params(dir: String).void }
-      def working_dir(dir)
-        setup_phase.working_dir = dir
-      end
-
-      sig { params(env: String).void }
-      def rails_env(env)
-        setup_phase.rails_env = env
-      end
-
-      sig {
-        params(
-          package_name: Symbol,
-          version: T.nilable(String)
-        )
-        .void
-      }
-      def package(package_name, version = nil)
-        package_phase.add(package_name, version)
-      end
-
-      sig { params(distro_name: Symbol).void }
-      def distro(distro_name)
-        metadata.distro = distro_name
-        @distro_spec = nil
-      end
-
-      sig { params(port: Integer).void }
-      def port(port)
-        webserver_phase.port = port
-      end
-
-      sig {
-        params(
-          name: Symbol,
-          layer: T.nilable(Layer),
-          block: T.nilable(T.proc.params(df: Dockerfile).void)
-        )
-        .void
-      }
-      def use(name, layer = nil, &block)
-        layer_stack.use(name, layer, &block)
-      end
-
-      sig {
-        params(
-          name: Symbol,
-          layer: T.nilable(T.any(Layer, T::Hash[Symbol, T.untyped])),
-          options: T::Hash[Symbol, T.untyped],
-          block: T.nilable(T.proc.params(df: Dockerfile).void)
-        )
-        .void
-      }
-      def insert(name, layer = nil, options = {}, &block)
-        layer_stack.insert(name, layer, options, &block)
-      end
-
-      sig { params(name: Symbol).void }
-      def delete(name)
-        layer_stack.delete(name)
-      end
-
-      sig { params(name: Symbol).returns(T::Boolean) }
-      def exists?(name)
-        layer_stack.includes?(name)
-      end
-
-      sig {
-        params(block: T.nilable(T.proc.void)).returns(Credentials)
-      }
-      def credentials(&block)
-        raise 'Docker credentials are not supported in the development environment'
-      end
-
-      sig { returns(Dockerfile) }
-      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
-
-      sig { returns(SetupPhase) }
-      def setup_phase
-        @setup_phase ||= SetupPhase.new(environment)
-      end
-
-      sig { returns(PackagePhase) }
-      def package_phase
-        @package_phase ||= PackagePhase.new(environment)
-      end
-
-      sig { returns(WebserverDevPhase) }
-      def webserver_phase
-        @webserver_phase ||= WebserverDevPhase.new(environment)
-      end
-
-      sig { returns(Metadata) }
-      def metadata
-        @metadata ||= Metadata.new(environment)
-      end
-
-      sig { returns(Distro) }
-      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
-
-      sig { returns(String) }
-      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
-
-      sig { params(current_tag: String).returns(String) }
-      def previous_tag(current_tag)
-        raise MissingTagError, 'cannot roll back in the development environment'
-      end
-
-      sig { returns(CLI) }
-      def cli
-        @cli ||= Docker::CLI.new
-      end
-
-      private
-
-      sig { returns(LocalTags) }
-      def tags
-        @tags ||= LocalTags.new(cli, metadata)
-      end
-
-      sig { returns(Docker::LayerStack) }
-      def layer_stack
-        @layer_stack ||= Docker::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