kuby-core 0.8.1 → 0.9.0

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

@@ -21,24 +21,25 @@ module Kuby
     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,8 +73,8 @@ module Kuby
       end
     end
 
-    def deploy
-      environment.kubernetes.deploy
+    def deploy(tag = nil)
+      environment.kubernetes.deploy(tag)
     end
 
     def rollback
@@ -106,26 +107,64 @@ 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?/
+      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?/
+          DevSetup.new(environment).run
+        end
+      end
+
+      true
     end
 
     private
@@ -135,6 +174,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,6 +206,14 @@ module Kuby
       kubernetes.provider.kubernetes_cli
     end
 
+    def helm_cli
+      kubernetes.provider.helm_cli
+    end
+
+    def docker_cli
+      docker.cli
+    end
+
     def kubernetes
       Kuby.environment.kubernetes
     end

data/lib/kuby/version.rb

@@ -1,3 +1,3 @@
 module Kuby
-  VERSION = '0.8.1'
+  VERSION = '0.9.0'
 end

data/spec/docker/metadata_spec.rb

@@ -70,114 +70,6 @@ describe Kuby::Docker::Metadata do
     end
   end
 
-  describe '#tag' do
-    let(:tag) { make_ts_tag(Time.now) }
-
-    subject { metadata.tag }
-
-    context 'with no local or remote tags' do
-      it 'raises an error' do
-        expect { subject }.to raise_error(Kuby::Docker::MissingTagError)
-      end
-    end
-
-    context 'with an available remote tag' do
-      before { docker_remote_client.tags << tag }
-
-      it { is_expected.to eq(tag) }
-    end
-
-    context 'with an available local tag' do
-      before do
-        docker_cli.build(
-          dockerfile: nil,
-          image_url: docker_image_url,
-          tags: [tag]
-        )
-      end
-
-      it { is_expected.to eq(tag) }
-    end
-
-    context 'with multiple remote tags' do
-      let(:time) { Time.now }
-
-      before do
-        docker_remote_client.tags +=
-          [time - 5, time + 10, time - 10, time + 15].map do |t|
-            make_ts_tag(t)
-          end
-      end
-
-      it { is_expected.to eq(make_ts_tag(time + 15)) }
-    end
-
-    context 'with multiple local and remote tags' do
-      let(:time) { Time.now }
-
-      before do
-        docker_remote_client.tags +=
-          [time - 5, time + 10, time - 10, time + 15].map do |t|
-            make_ts_tag(t)
-          end
-
-        docker_cli.build(
-          dockerfile: nil,
-          image_url: docker_image_url,
-          tags: [time - 3, time + 6, time - 6, time + 18].map do |t|
-            make_ts_tag(t)
-          end
-        )
-      end
-
-      it { is_expected.to eq(make_ts_tag(time + 18)) }
-    end
-  end
-
-  describe '#previous_tag' do
-    let(:time) { Time.now }
-    let(:current_tag) { make_ts_tag(time) }
-
-    before do
-      docker_remote_client.tags << current_tag
-      docker_cli.build(
-        dockerfile: nil,
-        image_url: docker_image_url,
-        tags: [current_tag]
-      )
-    end
-
-    subject { metadata.previous_tag(current_tag) }
-
-    context 'with no previous local or remote tag' do
-      it 'raises an error' do
-        expect { subject }.to raise_error(Kuby::Docker::MissingTagError)
-      end
-    end
-
-    context 'with an available previous remote tag' do
-      let(:previous_tag) { make_ts_tag(time - 5) }
-
-      before { docker_remote_client.tags << previous_tag }
-
-      it { is_expected.to eq(previous_tag) }
-    end
-
-    context 'with an available previous local tag' do
-      let(:previous_tag) { make_ts_tag(time - 5) }
-
-      before do
-        docker_cli.build(
-        dockerfile: nil,
-        image_url: docker_image_url,
-        tags: [previous_tag]
-        )
-      end
-
-      it { is_expected.to eq(previous_tag) }
-    end
-  end
-
   describe '#distro' do
     subject { metadata.distro }
 

data/spec/docker/spec_spec.rb

@@ -0,0 +1,266 @@
+require 'spec_helper'
+require 'timecop'
+
+describe Kuby::Docker::Spec do
+  let(:spec) { definition.environment.docker }
+
+  describe '#base_image' do
+    subject { spec.to_dockerfile.to_s }
+
+    it 'uses the default base image for Debian' do
+      expect(subject).to include("FROM ruby:#{RUBY_VERSION}\n")
+    end
+
+    context 'when the distro is set to Alpine' do
+      before { spec.distro(:alpine) }
+
+      it 'uses the Alpine base image' do
+        expect(subject).to include("FROM ruby:#{RUBY_VERSION}-alpine\n")
+      end
+    end
+
+    context 'when the base image is set to something custom' do
+      before { spec.base_image('foo/bar') }
+
+      it 'uses the base image as given' do
+        expect(subject).to include("FROM foo/bar\n")
+      end
+    end
+  end
+
+  describe '#working_dir' do
+    let(:default_working_dir) do
+      Kuby::Docker::SetupPhase::DEFAULT_WORKING_DIR
+    end
+
+    subject { spec.to_dockerfile.to_s }
+
+    it 'uses the default working dir' do
+      expect(subject).to(
+        include("WORKDIR #{default_working_dir}\n")
+      )
+    end
+
+    context 'when the working dir is set to something custom' do
+      before { spec.working_dir('/foo/bar') }
+
+      it 'uses the working dir as given' do
+        expect(subject).to include("WORKDIR /foo/bar\n")
+      end
+    end
+  end
+
+  describe '#rails_env' do
+    subject { spec.to_dockerfile.to_s }
+
+    it 'uses the name of the current Kuby environment' do
+      expect(subject).to include("ENV RAILS_ENV=#{spec.environment.name}\n")
+      expect(subject).to include("ENV KUBY_ENV=#{spec.environment.name}\n")
+    end
+
+    context 'when the environment is set to something custom' do
+      before { spec.rails_env('foobar') }
+
+      it 'uses the environment as given' do
+        expect(subject).to include("ENV RAILS_ENV=foobar\n")
+      end
+
+      it "doesn't change the Kuby env" do
+        expect(subject).to include("ENV KUBY_ENV=#{spec.environment.name}\n")
+      end
+    end
+  end
+
+  describe '#bundler_version' do
+    subject { spec.to_dockerfile.to_s }
+
+    it 'installs the current bundler version' do
+      expect(subject).to(
+        include("RUN gem install bundler -v #{Bundler::VERSION}\n")
+      )
+    end
+
+    context 'when the bundler version is set to something custom' do
+      before { spec.bundler_version('1.17.3') }
+
+      it 'installs the given version' do
+        expect(subject).to include("RUN gem install bundler -v 1.17.3\n")
+      end
+    end
+  end
+
+  describe '#gemfile' do
+    subject { spec.to_dockerfile.to_s }
+
+    it 'uses the default Gemfile' do
+      expect(subject).to include("COPY Gemfile .\n")
+      expect(subject).to include("COPY Gemfile.lock .\n")
+      expect(subject).to match(/RUN bundle install .* --gemfile Gemfile/)
+    end
+
+    context 'when the gemfile path is set to something custom' do
+      before { spec.gemfile('foo/bar/Gemfile') }
+
+      it 'uses the given gemfile' do
+        expect(subject).to include("COPY foo/bar/Gemfile .\n")
+        expect(subject).to include("COPY foo/bar/Gemfile.lock .\n")
+        expect(subject).to match(/RUN bundle install .* --gemfile foo\/bar\/Gemfile/)
+      end
+    end
+  end
+
+  describe '#package' do
+    subject { spec.to_dockerfile.to_s }
+
+    it 'installs the given package' do
+      # configured in spec_helper.rb
+      spec.package(:fake_package)
+
+      expect(subject).to match(/apt-get install .* fake_package/m)
+    end
+  end
+
+  describe '#files' do
+    subject { spec.to_dockerfile.to_s }
+
+    it 'copies the current directory contents by default' do
+      expect(subject).to include("COPY ./ .\n")
+    end
+
+    context 'when given a custom path to copy' do
+      before { spec.files('./foo/bar') }
+
+      it 'copies the given paths only' do
+        expect(subject).to include("COPY ./foo/bar .\n")
+      end
+    end
+  end
+
+  describe '#port' do
+    let(:default_port) do
+      Kuby::Docker::WebserverPhase::DEFAULT_PORT
+    end
+
+    subject { spec.to_dockerfile.to_s }
+
+    it 'exposes the default port' do
+      expect(subject).to include("EXPOSE #{default_port}\n")
+    end
+
+    context 'when given a custom port' do
+      before { spec.port(5555) }
+
+      it 'exposes the given port' do
+        expect(subject).to include("EXPOSE 5555\n")
+      end
+    end
+  end
+
+  describe '#tag' do
+    let(:tag) { make_ts_tag(Time.now) }
+
+    subject { spec.tag }
+
+    context 'with no local or remote tags' do
+      it 'raises an error' do
+        expect { subject }.to raise_error(Kuby::Docker::MissingTagError)
+      end
+    end
+
+    context 'with an available remote tag' do
+      before { docker_remote_client.tags << tag }
+
+      it { is_expected.to eq(tag) }
+    end
+
+    context 'with an available local tag' do
+      before do
+        docker_cli.build(
+          dockerfile: nil,
+          image_url: docker_image_url,
+          tags: [tag]
+        )
+      end
+
+      it { is_expected.to eq(tag) }
+    end
+
+    context 'with multiple remote tags' do
+      let(:time) { Time.now }
+
+      before do
+        docker_remote_client.tags +=
+          [time - 5, time + 10, time - 10, time + 15].map do |t|
+            make_ts_tag(t)
+          end
+      end
+
+      it { is_expected.to eq(make_ts_tag(time + 15)) }
+    end
+
+    context 'with multiple local and remote tags' do
+      let(:time) { Time.now }
+
+      before do
+        docker_remote_client.tags +=
+          [time - 5, time + 10, time - 10, time + 15].map do |t|
+            make_ts_tag(t)
+          end
+
+        docker_cli.build(
+          dockerfile: nil,
+          image_url: docker_image_url,
+          tags: [time - 3, time + 6, time - 6, time + 18].map do |t|
+            make_ts_tag(t)
+          end
+        )
+      end
+
+      it { is_expected.to eq(make_ts_tag(time + 18)) }
+    end
+  end
+
+  describe '#previous_tag' do
+    let(:time) { Time.now }
+    let(:current_tag) { make_ts_tag(time) }
+
+    before do
+      docker_remote_client.tags << current_tag
+      docker_cli.build(
+        dockerfile: nil,
+        image_url: docker_image_url,
+        tags: [current_tag]
+      )
+    end
+
+    subject { spec.previous_tag(current_tag) }
+
+    context 'with no previous local or remote tag' do
+      it 'raises an error' do
+        expect { subject }.to raise_error(Kuby::Docker::MissingTagError)
+      end
+    end
+
+    context 'with an available previous remote tag' do
+      let(:previous_tag) { make_ts_tag(time - 5) }
+
+      before { docker_remote_client.tags << previous_tag }
+
+      it { is_expected.to eq(previous_tag) }
+    end
+
+    context 'with an available previous local tag' do
+      let(:previous_tag) { make_ts_tag(time - 5) }
+
+      before do
+        docker_cli.build(
+        dockerfile: nil,
+        image_url: docker_image_url,
+        tags: [previous_tag]
+        )
+      end
+
+      it { is_expected.to eq(previous_tag) }
+    end
+  end
+end