engineyard-serverside 2.7.0.pre → 2.7.8pre2

data/lib/engineyard-serverside/propagator.rb

@@ -1,59 +0,0 @@
-require 'forwardable'
-require 'engineyard-serverside/about'
-
-module EY
-  module Serverside
-
-    # Propagator ensures that a proper version of the engineyard-serverside
-    # gem is installed on a given set of servers
-    class Propagator
-      def self.propagate(servers, shell)
-        new(servers, shell).propagate
-      end
-
-      extend Forwardable
-
-      def_delegators About, :gem_binary, :gem_file, :gem_filename, :gem_name,
-        :name_with_version, :version
-
-      attr_reader :servers, :shell
-
-      def initialize(servers, shell)
-        @servers = servers
-        @shell = shell
-      end
-
-      def propagate
-        shell.status "Verifying and propagating #{name_with_version} to all servers."
-
-        servers.remote.run_for_each! do |server|
-          propagation_command_for(server)
-        end
-      end
-
-      private
-      def propagation_command_for(server)
-        check = server.command_on_server('sh -l -c', check_command)
-        scp = server.scp_command(About.gem_file, remote_gem_file)
-        install = server.command_on_server('sudo sh -l -c', install_command)
-
-        "(#{check}) || ((#{scp}) && (#{install}))"
-      end
-
-      def remote_gem_file
-        @remote_gem_file ||= File.join(Dir.tmpdir, gem_filename)
-      end
-
-      def check_command
-        # the [,)] is to stop us from looking for e.g. 0.5.1, seeing
-        # 0.5.11, and mistakenly thinking 0.5.1 is there
-
-         %{#{gem_binary} list #{gem_name} | grep "#{gem_name}" | egrep -q "#{version.gsub(/\./, '\.')}[,)]"}
-      end
-
-      def install_command
-        "#{gem_binary} install --no-rdoc --no-ri '#{remote_gem_file}'"
-      end
-    end
-  end
-end

data/lib/engineyard-serverside/slug.rb

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

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

@@ -1,58 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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