engineyard-serverside 2.6.17 → 2.6.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc8524f480f3b28b00ec3696240dc84f69b048ddcb3c8048daa3fa0870ca74bd
-  data.tar.gz: 465b40842bb42ff53233590f9d52f4b1526875f590bac33cb9b39dd988309a2d
+  metadata.gz: cf8aba371f49c2c647e8bc5aabde90beb0151fd533997d863e5e5d61966d68b4
+  data.tar.gz: f8889817020595bcc1c55425c676aa7aa856862a1d8397b4ab85189a17f2a6ee
 SHA512:
-  metadata.gz: b0729fb3d4bdfef8fd15d394ae6096b4b370e03576562bc97e8099d2413142d41ab487cb9940b9d2ccb1e1b6ccd698b4fd9ef97261a71b6fa1c62ae1bbea09f6
-  data.tar.gz: 49d69442d91d472b0f9c6855bd41b92e2858621c781085a98e6b1f5188b421cb0708ede2f1e85b12db33668cdc013a77bba84150850c1dd47c484e69454b7f3e
+  metadata.gz: 90c63aad8219f0dc9b33e55588c87cbc80d0d94ef40da1dc10e48f646548f6ebc953247f158c6bbf641930b74ccc8895f6bd1f391926be722c102c47e354b65c
+  data.tar.gz: ae839c8c4feed22c8b5fb67e4a30f7209b4a79df7bd08a190cd25e421f7efec811c41c7b6059c9960e06c97a2aca3c97b44fe9570b688114703fb2048a0ef36d

data/lib/engineyard-serverside/dependency_manager/bundler.rb

@@ -94,7 +94,7 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
           # the [,)] is to stop us from looking for e.g. 0.9.2, seeing
           # 0.9.22, and mistakenly thinking 0.9.2 is there
           has_gem_cmd = %{gem list bundler | grep "bundler " | egrep -q "#{egrep_escaped_version}[,)]"}
-          install_cmd = %{gem install bundler -q --no-rdoc --no-ri -v "#{bundler_version}"}
+          install_cmd = %{gem install bundler -q -v "#{bundler_version}"}
           sudo "#{clean_environment} && #{has_gem_cmd} || #{install_cmd}"
         end
 

data/lib/engineyard-serverside/slug.rb

@@ -0,0 +1,7 @@
+module EY
+  module Serverside
+    module Slug
+
+    end
+  end
+end

data/lib/engineyard-serverside/slug/distributor.rb

@@ -0,0 +1,58 @@
+require 'railway'
+require 'runner'
+
+module EY
+  module Serverside
+    module Slug
+      class Distributor
+        include Railway
+        include Runner
+
+        step :find_remotes
+        step :distribute_to_remotes
+
+        def self.distribute(data = {})
+          new(data[:config], data[:shell], data[:servers]).call(data)
+        end
+
+        attr_reader :config, :shell, :servers
+
+        def initialize(config, shell, servers)
+          @config = config
+          @shell = shell
+          @servers = servers
+        end
+
+        private
+        def find_remotes(input = {})
+          remotes = servers.
+            to_a.
+            reject {|server| server.role.to_sym == :app_master}
+
+          Success(input.merge(:remotes => remotes))
+        end
+
+        def distribute_to_remotes(input = {})
+          remotes = input[:remotes]
+          releases_path = "/data/#{input[:app_name]}/releases"
+          package = "#{releases_path}/#{input[:release_name]}.tgz"
+          internal_key = config.paths.internal_key
+
+          remotes.each do |remote|
+            cmd = "scp -i #{internal_key} #{package} #{remote.user}@#{remote.hostname}:#{releases_path}"
+
+            unless run_and_success?(cmd)
+              return Failure(
+                input.merge(
+                  :error => "Could not copy #{package} to #{remote.hostname}"
+                )
+              )
+            end
+          end
+
+          Success(input)
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/slug/enabler.rb

@@ -0,0 +1,100 @@
+require 'railway'
+require 'runner'
+
+module EY
+  module Serverside
+    module Slug
+
+      class Enabler
+        include Railway
+        include Runner
+
+        step :enable_remotes
+        step :enable_local
+
+        attr_reader :config, :shell, :servers
+
+        def initialize(config, shell, servers)
+          @config = config
+          @shell = shell
+          @servers = servers
+        end
+
+        private
+        def enable_remotes(data)
+          enabled = []
+
+          remotes.each do |remote|
+            if run_and_success?(remote_command(remote, data))
+              enabled.push(remote)
+            else
+              return Failure(
+                data.merge(
+                  :enabled => enabled,
+                  :error => "Could not enable #{data[:release_name]} on #{remote.hostname}"
+                )
+              )
+            end
+          end
+
+          Success(data.merge(:enabled => enabled))
+        end
+
+        def enable_local(data = {})
+          unless run_and_success?(local_command(data))
+            return Failure(data.merge(:error => "Could not enable #{data[:release_name]} on the app master"))
+          end
+
+          data[:enabled].push(servers.first {|server| server.role == :app_master || server.role == :solo})
+
+          Success(data)
+        end
+
+        def remotes
+          servers.reject {|server| server.role == :app_master}
+        end
+
+        def remote_command(remote, data)
+          "ssh -i #{config.paths.internal_key} #{remote.user}@#{remote.hostname} '#{create_release(data)} && #{unarchive(data)} && #{link_current(data)}'"
+        end
+
+        def local_command(data)
+          "#{unarchive(data)} && #{link_current(data)}"
+        end
+
+        def create_release(data)
+          "mkdir -p #{release_path(data)}"
+        end
+
+        def unarchive(data)
+          "tar -C #{release_path(data)} -z -x -f #{package(data)}"
+        end
+
+        def link_current(data)
+          "ln -nsf #{release_path(data)} #{current_path(data)}"
+        end
+
+        def package(data)
+          "#{release_path(data)}.tgz"
+        end
+
+        def release_path(data)
+          "#{all_releases(data)}/#{data[:release_name]}"
+        end
+
+        def all_releases(data)
+          "#{app_path(data)}/releases"
+        end
+
+        def current_path(data)
+          "#{app_path(data)}/current"
+        end
+
+        def app_path(data)
+          "/data/#{data[:app_name]}"
+        end
+      end
+
+    end
+  end
+end

data/lib/engineyard-serverside/slug/failure_handler.rb

@@ -0,0 +1,24 @@
+require 'result'
+
+module EY
+  module Serverside
+    module Slug
+
+      class FailureHandler
+        def self.handle(data = {})
+          new(data[:config], data[:shell], data[:servers]).call(data)
+        end
+
+        def initialize(config, shell, servers)
+          @config = config
+          @shell = shell
+          @servers = servers
+        end
+
+        def call(data = {})
+          Result::Failure.new(data)
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/slug/finalizer.rb

@@ -0,0 +1,86 @@
+require 'railway'
+require 'runner'
+
+module EY
+  module Serverside
+    module Slug
+
+      class Finalizer
+        include Railway
+        include Runner
+
+        step :finalize_remotes
+        step :finalize_local
+
+        attr_reader :config, :shell, :servers
+
+        def initialize(config, shell, servers)
+          @config = config
+          @shell = shell
+          @servers = servers
+        end
+
+        private
+        def finalize_remotes(data)
+          finalized = []
+
+          remotes.each do |remote|
+            if run_and_success?(remote_command(remote, data))
+              finalized.push(remote)
+            else
+              return Failure(
+                data.merge(
+                  :finalized => finalized,
+                  :error => "Could not finalize #{data[:release_name]} on #{remote.hostname}"
+                )
+              )
+            end
+          end
+
+          Success(data.merge(:finalized => finalized))
+        end
+
+        def finalize_local(data = {})
+          unless run_and_success?(finalize_command(data))
+            return Failure(data.merge(:error => "Could not finalize #{data[:release_name]} on the app master"))
+          end
+
+          data[:finalized].push(servers.first {|server| server.role == :app_master || server.role == :solo})
+
+          Success(data)
+        end
+
+        def remotes
+          servers.reject {|server| server.role == :app_master}
+        end
+
+        def remote_command(remote, data)
+          "ssh -i #{config.paths.internal_key} #{remote.user}@#{remote.hostname} '#{finalize_command(data)}'"
+        end
+
+        def finalize_command(data)
+          [
+            "for release in #{all_releases(data)}/*",
+            %{do if [ -d "${release}" ] && [ "$(basename "${release}")" != "#{data[:release_name]}"]},
+            'then rm -rf "${release}"',
+            'fi',
+            'done'
+          ].join(' ; ')
+        end
+
+        def old_release_path(data)
+          "#{all_releases(data)}/#{data[:current_release_name]}"
+        end
+
+        def all_releases(data)
+          "#{app_path(data)}/releases"
+        end
+
+        def app_path(data)
+          "/data/#{data[:app_name]}"
+        end
+      end
+
+    end
+  end
+end

data/lib/engineyard-serverside/slug/generator.rb

@@ -0,0 +1,29 @@
+require 'result'
+
+module EY
+  module Serverside
+    module Slug
+
+      module Generator
+        extend Result::DSL
+
+        def self.generate(data = {})
+          data[:shell].logged_system(ogun(data)).success? ?
+            Success(data.merge(:generated => true)) :
+            Failure(data.merge(:error => "Ogun build failed"))
+        end
+
+        def self.ogun(data = {})
+          [
+            "/engineyard/bin/ogun",
+            "build",
+            data[:app_name],
+            "--release",
+            data[:release_name]
+          ].join(' ')
+        end
+      end
+
+    end
+  end
+end

data/lib/engineyard-serverside/slug/migrator.rb

@@ -0,0 +1,41 @@
+require 'result'
+require 'runner'
+
+module EY
+  module Serverside
+    module Slug
+      class Migrator
+        include Result::DSL
+        include Runner
+
+        attr_reader :config, :shell
+
+        def initialize(config, shell)
+          @config = config
+          @shell = shell
+        end
+
+        def call(data = {})
+          return Success(data) unless config.migrate?
+
+          cmd = "PATH=#{paths.binstubs}:$PATH #{config.framework_envs} #{config.migration_command}"
+
+          return Failure(
+            data.merge(:error => "Could not migrate database")
+          ) unless Dir.chdir(paths.active_release) {run_and_success?(cmd)}
+
+          Success(data.merge(:migrated => true))
+        end
+
+        private
+        def paths
+          config.paths
+        end
+
+        def self.migrate(data = {})
+          new(data[:config], data[:shell]).call(data)
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/slug/restarter.rb

@@ -0,0 +1,103 @@
+require 'railway'
+require 'runner'
+
+module EY
+  module Serverside
+    module Slug
+
+      class Restarter
+        include Railway
+        include Runner
+
+        step :restart_remote_apps
+        step :restart_local
+
+        attr_reader :config, :shell, :servers
+
+        def self.restart(data = {})
+          new(data[:config], data[:shell], data[:servers]).call(data)
+        end
+
+        def initialize(config, shell, servers)
+          @config = config
+          @shell = shell
+          @servers = servers
+        end
+
+        private
+        def restart_remote_apps(data = {})
+          restarted = []
+
+          remote_apps.each do |remote|
+            if run_and_success?(remote_command(remote, data))
+              restarted.push(remote)
+            else
+              return Failure(
+                data.merge(
+                  :restarted => restarted,
+                  :error => "Could not restart #{data[:release_name]} on #{remote.hostname}"
+                )
+              )
+            end
+          end
+
+          Success(data.merge(:restarted => restarted))
+        end
+
+        def restart_local(data = {})
+          unless run_and_success?(restart_command(data))
+            return Failure(data.merge(:error => "Could not restart #{data[:release_name]} on the app master"))
+          end
+
+          data[:restarted].push(master)
+
+          Success(data)
+        end
+
+        def remotes
+          server_array.reject {|server|
+            master?(server)
+          }
+        end
+
+        def remote_apps
+          remotes.select {|server| server.role == :app}
+        end
+
+        def master?(server)
+          server == master
+        end
+
+        def util?(server)
+          server.role == :util
+        end
+
+        def master
+          @master ||= server_array.find {|server|
+            master_roles.include?(server.role)
+          }
+        end
+
+        def master_roles
+          [:app_master, :solo]
+        end
+
+        def server_array
+          @server_array ||= servers.to_a
+        end
+
+        def remote_command(remote, data)
+          "ssh -i #{internal_key} #{remote.user}@#{remote.hostname} '#{restart_command(data)}'"
+        end
+
+        def restart_command(data)
+          %{LANG="en_US.UTF-8" /engineyard/bin/app_#{data[:app_name]} deploy}
+        end
+
+        def internal_key
+          config.paths.internal_key
+        end
+      end
+    end
+  end
+end