engineyard-serverside 2.7.8pre2 → 2.8.0.pre

data/lib/engineyard-serverside/rails_assets.rb

@@ -58,7 +58,8 @@ module EY
           # This is a hack right now, but I haven't iterated over it enough for a good solution yet.
           if config.experimental_sync_assets?
             shell.status "Compiling assets once on localhost (experimental_sync_assets: true)"
-            shell.logged_system("sh -l -c '#{cd} && #{task}'")
+            compilation_result = shell.logged_system("sh -l -c '#{cd} && #{task}'")
+            raise "Assets compilation error" unless compilation_result.success?
 
             shell.status "Syncing assets to other remote servers (experimental_sync_assets: true)"
             runner.servers.remote.run_for_each do |server|

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