kuby-core 0.7.2 → 0.10.0

data/lib/kuby/plugins/rails_app/postgres.rb

@@ -0,0 +1,143 @@
+require 'kube-dsl'
+require 'kuby/kube-db'
+
+module Kuby
+  module Plugins
+    module RailsApp
+      class Postgres < ::Kuby::Plugin
+        ROLE = 'web'.freeze
+
+        attr_reader :environment, :configs
+
+        def initialize(environment, configs)
+          @environment = environment
+          @configs = configs
+
+          user(config['username'])
+          password(config['password'])
+        end
+
+        def name
+          :postgres
+        end
+
+        def resources
+          @resources ||= [secret, database]
+        end
+
+        def after_configuration
+          environment.docker.package_phase.add(:postgres_dev)
+          environment.docker.package_phase.add(:postgres_client)
+        end
+
+        def host
+          # host is the same as the name thanks to k8s DNS
+          @host ||= database.metadata.name
+        end
+
+        def rewritten_configs
+          # deep dup
+          @rewritten_configs ||= Marshal.load(Marshal.dump(configs)).tap do |new_configs|
+            new_configs[environment.name]['host'] = host
+          end
+        end
+
+        def user(user)
+          secret do
+            data do
+              set :POSTGRES_USER, user
+            end
+          end
+        end
+
+        def password(password)
+          secret do
+            data do
+              set :POSTGRES_PASSWORD, password
+            end
+          end
+        end
+
+        def secret(&block)
+          context = self
+
+          @secret ||= KubeDSL.secret do
+            metadata do
+              name "#{context.base_name}-postgres-secret"
+              namespace context.kubernetes.namespace.metadata.name
+            end
+
+            type 'Opaque'
+          end
+
+          @secret.instance_eval(&block) if block
+          @secret
+        end
+
+        def database(&block)
+          context = self
+
+          @database ||= Kuby::KubeDB.postgres do
+            api_version 'kubedb.com/v1alpha1'
+
+            metadata do
+              name "#{context.base_name}-postgres"
+              namespace context.kubernetes.namespace.metadata.name
+            end
+
+            spec do
+              database_secret do
+                secret_name context.secret.metadata.name
+              end
+
+              version '11.2'
+              standby_mode 'Hot'
+              streaming_mode 'asynchronous'
+              storage_type 'Durable'
+
+              storage do
+                storage_class_name context.kubernetes.provider.storage_class_name
+                access_modes ['ReadWriteOnce']
+
+                resources do
+                  requests do
+                    add :storage, '10Gi'
+                  end
+                end
+              end
+
+              termination_policy 'DoNotTerminate'
+            end
+          end
+
+          @database.instance_eval(&block) if block
+          @database
+        end
+
+        def base_name
+          @base_name ||= "#{kubernetes.selector_app}-#{ROLE}"
+        end
+
+        def kubernetes
+          environment.kubernetes
+        end
+
+        private
+
+        def config
+          configs[environment.name]
+        end
+      end
+    end
+  end
+end
+
+Kuby.register_package(:postgres_dev,
+  debian: 'postgresql-client',
+  alpine: 'postgresql-dev'
+)
+
+Kuby.register_package(:postgres_client,
+  debian: 'postgresql-client',
+  alpine: 'postgresql-client'
+)

data/lib/kuby/plugins/rails_app/rewrite_db_config.rb

@@ -0,0 +1,11 @@
+module Kuby
+  module Plugins
+    module RailsApp
+      class RewriteDbConfig
+        def apply_to(dockerfile)
+          dockerfile.run('bundle exec rake kuby:rails_app:db:rewrite_config')
+        end
+      end
+    end
+  end
+end

data/lib/kuby/plugins/rails_app/sqlite.rb

@@ -0,0 +1,32 @@
+module Kuby
+  module Plugins
+    module RailsApp
+      class Sqlite < ::Kuby::Plugin
+        attr_reader :environment
+
+        def initialize(environment, *)
+          @environment = environment
+        end
+
+        def after_configuration
+          environment.docker.package_phase.add(:sqlite_dev)
+          environment.docker.package_phase.add(:sqlite_client)
+        end
+
+        def name
+          :sqlite
+        end
+      end
+    end
+  end
+end
+
+Kuby.register_package(:sqlite_dev,
+  debian: 'libsqlite3-dev',
+  alpine: 'sqlite-dev'
+)
+
+Kuby.register_package(:sqlite_client,
+  debian: 'sqlite3',
+  alpine: 'sqlite'
+)

data/lib/kuby/plugins/rails_app/tasks.rake

@@ -0,0 +1,36 @@
+require 'rake'
+
+namespace :kuby do
+  namespace :rails_app do
+    namespace :db do
+      task :rewrite_config do
+        Kuby.load!
+
+        config_file = File.join(Kuby.environment.kubernetes.plugin(:rails_app).root, 'config', 'database.yml')
+        database = Kuby.environment.kubernetes.plugin(:rails_app).database
+
+        if database.plugin.respond_to?(:rewritten_configs)
+          File.write(config_file, YAML.dump(database.plugin.rewritten_configs))
+          Kuby.logger.info("Wrote #{config_file}")
+        end
+      end
+
+      task :create_unless_exists do
+        begin
+          Rake::Task['environment'].invoke
+          ActiveRecord::Base.connection
+        rescue ActiveRecord::NoDatabaseError => e
+          Rake::Task['db:create'].invoke
+        end
+      end
+    end
+
+    namespace :assets do
+      task :copy do
+        Kuby.load!
+        assets = Kuby.environment.kubernetes.plugin(:rails_assets)
+        assets.copy_task.run
+      end
+    end
+  end
+end

data/lib/kuby/rails_commands.rb

@@ -0,0 +1,89 @@
+module Kuby
+  class Args
+    attr_reader :args, :flag_aliases
+
+    def initialize(args, flag_aliases = [])
+      @args = args
+      @flag_aliases = flag_aliases
+    end
+
+    def [](flag)
+      idx = find_arg_index(flag)
+      idx ? args[idx] : nil
+    end
+
+    def []=(flag, new_value)
+      idx = find_arg_index(flag)
+
+      if idx
+        args[idx] = new_value
+      else
+        @args += [flag, new_value]
+      end
+    end
+
+    private
+
+    def find_arg_index(flag)
+      idx = args.find_index do |arg|
+        flag_aliases.any? { |fas| fas.include?(arg) && fas.include?(flag) }
+      end
+
+      idx ? idx + 1 : nil
+    end
+  end
+
+  class RailsCommands
+    PREFIX = %w(bundle exec).freeze
+    SERVER_ARG_ALIASES = [['--binding', '-b'], ['-p', '--port']].freeze
+
+    class << self
+      def run(args = ARGV)
+        command = args[0]
+
+        if command == 'rails'
+          subcommand = args[1]
+          arglist = nil
+
+          case subcommand
+            when 'server', 's'
+              arglist = Args.new([*PREFIX, *args], SERVER_ARG_ALIASES)
+              arglist['-b'] ||= '0.0.0.0'
+              arglist['-p'] ||= '3000'
+            when 'runner', 'r'
+            when 'console', 'c'
+            else
+              return
+          end
+        elsif command == 'rake'
+          arglist = Args.new([*PREFIX, *args])
+        end
+
+        setup
+
+        arglist ||= Args.new([*PREFIX, *args])
+        tasks = Kuby::Tasks.new(environment)
+        tasks.remote_exec(arglist.args)
+      end
+
+      private
+
+      def setup
+        require 'kuby'
+        Kuby.load!
+      end
+
+      def kubernetes_cli
+        kubernetes.provider.kubernetes.cli
+      end
+
+      def kubernetes
+        environment.kubernetes
+      end
+
+      def environment
+        Kuby.definition.environment
+      end
+    end
+  end
+end

data/lib/kuby/railtie.rb

@@ -3,10 +3,6 @@ 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.health_check_middleware' do |app|
       app.middleware.use Kuby::Middleware::HealthCheck
     end

data/lib/kuby/tasks.rb

@@ -2,43 +2,44 @@ require 'rouge'
 
 module Kuby
   class Tasks
-    attr_reader :definition
+    attr_reader :environment
 
-    def initialize(definition)
-      @definition = definition
+    def initialize(environment)
+      @environment = environment
     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)
+      tokens = lexer.lex(Kuby.environment.docker.to_dockerfile.to_s)
       puts formatter.format(tokens)
     end
 
     def setup
-      definition.kubernetes.setup
+      environment.kubernetes.setup
     end
 
     def build
+      build_args = {}
+
+      unless ENV.fetch('RAILS_MASTER_KEY', '').empty?
+        build_args['RAILS_MASTER_KEY'] = ENV['RAILS_MASTER_KEY']
+      end
+
       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
+        tags:       docker.metadata.tags,
+        build_args: build_args
       )
     end
 
     def push
+      if environment.development?
+        fail 'Cannot push Docker images built for the development environment'
+      end
+
       hostname = docker.metadata.image_hostname
 
       unless docker.cli.auths.include?(hostname)
@@ -72,12 +73,12 @@ module Kuby
       end
     end
 
-    def deploy
-      definition.kubernetes.deploy
+    def deploy(tag = nil)
+      environment.kubernetes.deploy(tag)
     end
 
     def rollback
-      definition.kubernetes.rollback
+      environment.kubernetes.rollback
     end
 
     def print_resources
@@ -106,26 +107,65 @@ module Kuby
       kubernetes_cli.run_cmd(['-n', namespace, 'get', 'pods'])
     end
 
-    def remote_shell
+    def remote_exec(cmd)
       first_pod = get_first_pod
-      shell = docker.distro_spec.shell_exe
-      kubernetes_cli.exec_cmd(shell, namespace, first_pod.dig('metadata', 'name'))
+      kubernetes_cli.exec_cmd(cmd, namespace, first_pod.dig('metadata', 'name'))
     end
 
-    def remote_console
+    def remote_system(cmd)
       first_pod = get_first_pod
+      kubernetes_cli.system_cmd(cmd, namespace, first_pod.dig('metadata', 'name'))
+    end
 
-      kubernetes_cli.exec_cmd(
-        'bundle exec rails console', namespace, first_pod.dig('metadata', 'name')
-      )
+    def remote_shell
+      remote_exec(docker.distro_spec.shell_exe)
+    end
+
+    def remote_console
+      remote_exec('bundle exec rails console')
     end
 
     def remote_dbconsole
-      first_pod = get_first_pod
+      remote_exec('bundle exec rails dbconsole')
+    end
+
+    def remote_restart
+      deployment = rails_app.deployment.metadata.name
+      kubernetes_cli.restart_deployment(namespace, deployment)
+    end
+
+    def dev_deployment_ok
+      return true unless Kuby.environment.development?
 
-      kubernetes_cli.exec_cmd(
-        'bundle exec rails dbconsole', namespace, first_pod.dig('metadata', 'name')
+      deployments = kubernetes_cli.get_objects(
+        'deployments', namespace, match_labels.serialize
       )
+
+      if deployments.empty?
+        puts 'No development environment detected.'
+        STDOUT.write('Set up development environment? (y/n): ')
+        answer = STDIN.gets.strip.downcase
+        return false unless answer =~ /ye?s?/
+        return DevSetup.new(environment).run
+      else
+        depl = deployments.first
+        deployed_checksum = depl.dig('metadata', 'annotations', 'getkuby.io/dockerfile-checksum')
+        current_checksum = docker.to_dockerfile.checksum
+
+        if deployed_checksum != current_checksum
+          puts "Development environment appears to be out-of-date."
+          puts "Environment checksum: #{deployed_checksum}"
+          puts "Current checksum:     #{current_checksum}"
+          STDOUT.write('Update development environment? (y/n): ')
+          answer = STDIN.gets.strip.downcase
+          # return true here to prevent letting an out-of-date deployment
+          # stop us from running commands
+          return true unless answer =~ /ye?s?/
+          return DevSetup.new(environment).run
+        end
+      end
+
+      true
     end
 
     private
@@ -135,6 +175,12 @@ module Kuby
         'pods', namespace, match_labels.serialize
       )
 
+      # consider only "Running" pods that aren't marked for deletion
+      pods.select! do |pod|
+        pod.dig('status', 'phase') == 'Running' &&
+          !pod.dig('metadata', 'deletionTimestamp')
+      end
+
       if pods.empty?
         raise Kuby::Kubernetes::MissingResourceError,
           "Couldn't find any running pods in namespace '#{namespace}' :("
@@ -161,12 +207,20 @@ module Kuby
       kubernetes.provider.kubernetes_cli
     end
 
+    def helm_cli
+      kubernetes.provider.helm_cli
+    end
+
+    def docker_cli
+      docker.cli
+    end
+
     def kubernetes
-      Kuby.definition.kubernetes
+      Kuby.environment.kubernetes
     end
 
     def docker
-      Kuby.definition.docker
+      Kuby.environment.docker
     end
   end
 end