engineyard-serverside 2.7.8pre2 → 2.8.0.pre

data/lib/engineyard-serverside/cli/helpers.rb

@@ -0,0 +1,58 @@
+module EY
+  module Serverside
+    module CLI
+
+      # Helpers is a set of methods that define options and such for an App
+      # task
+      module Helpers
+        def account_app_env_options
+          method_option :app,              :type     => :string,
+                                           :required => true,
+                                           :desc     => "Application to deploy",
+                                           :aliases  => %w[-a --app-name]
+          method_option :environment_name, :type     => :string,
+                                           :required => true,
+                                           :desc     => "Environment name"
+          method_option :account_name,     :type     => :string,
+                                           :required => true,
+                                           :desc     => "Account name"
+        end
+
+        def framework_env_option
+          method_option :framework_env,    :type     => :string,
+                                           :required => true,
+                                           :desc     => "Ruby web framework environment",
+                                           :aliases  => ["-e"]
+        end
+
+        def stack_option
+          method_option :stack,            :type     => :string,
+                                           :desc     => "Web stack (so we can restart it correctly)"
+        end
+
+
+        def config_option
+          method_option :config,           :type     => :string,
+                                           :desc     => "Additional configuration"
+        end
+
+        def instances_options
+          method_option :instances,        :type     => :array,
+                                           :desc     => "Hostnames of instances to deploy to, e.g. --instances localhost app1 app2"
+          method_option :instance_roles,   :type     => :hash,
+                                           :default  => {},
+                                           :desc     => "Roles of instances, keyed on hostname, comma-separated. e.g. instance1:app_master,etc instance2:db,memcached ..."
+          method_option :instance_names,   :type     => :hash,
+                                           :default  => {},
+                                           :desc     => "Instance names, keyed on hostname. e.g. instance1:name1 instance2:name2"
+        end
+
+        def verbose_option
+          method_option :verbose,          :type     => :boolean,
+                                           :desc     => "Verbose output",
+                                           :aliases  => ["-v"]
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/cli/server_hash_extractor.rb

@@ -0,0 +1,49 @@
+module EY
+  module Serverside
+    module CLI
+
+      # ServerHashExtractor, given an options hash and a deploy configuration,
+      # generates an array of hashes that can be used to instantiate Server
+      # objects
+      class ServerHashExtractor
+        def self.hashes(options, config)
+          new(options, config).hashes
+        end
+
+        attr_reader :options, :config
+
+        def initialize(options, config)
+          @options = options
+          @config = config
+        end
+
+        def hashes
+          return [] unless instances
+
+          instances.collect {|hostname|
+            {
+              :hostname => hostname,
+              :roles => instance_roles[hostname].to_s.split(','),
+              :name => instance_names[hostname],
+              :user => config.user
+            }
+          }
+        end
+
+        private
+        def instances
+          options[:instances]
+        end
+
+        def instance_roles
+          options[:instance_roles]
+        end
+
+        def instance_names
+          options[:instance_names]
+        end
+
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/cli/workflows.rb

@@ -0,0 +1,45 @@
+require 'engineyard-serverside/cli/workflows/calling_deploy_hooks'
+require 'engineyard-serverside/cli/workflows/deploying_applications'
+require 'engineyard-serverside/cli/workflows/disabling_maintenance'
+require 'engineyard-serverside/cli/workflows/enabling_maintenance'
+require 'engineyard-serverside/cli/workflows/integrating_servers'
+require 'engineyard-serverside/cli/workflows/restarting_applications'
+require 'engineyard-serverside/cli/workflows/rolling_back_applications'
+require 'engineyard-serverside/cli/workflows/showing_maintenance_status'
+
+module EY
+  module Serverside
+    module CLI
+
+      # Workflows is a collection of reified procedures that handle the
+      # various requirements of our CLI app
+      module Workflows
+        DEFINED = {
+          :deploy => DeployingApplications,
+          :disable_maintenance => DisablingMaintenance,
+          :enable_maintenance => EnablingMaintenance,
+          :hook => CallingDeployHooks,
+          :integrate => IntegratingServers,
+          :maintenance_status => ShowingMaintenanceStatus,
+          :restart => RestartingApplications,
+          :rollback => RollingBackApplications
+        }
+
+        def self.perform(workflow, options = {})
+          resolve(workflow).
+            perform(options)
+        end
+
+        def self.resolve(workflow)
+          (DEFINED[normalized(workflow)] || Base)
+        end
+
+        def self.normalized(workflow)
+          return nil if workflow.nil?
+
+          workflow.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/cli/workflows/base.rb

@@ -0,0 +1,78 @@
+require 'engineyard-serverside/about'
+require 'engineyard-serverside/cli/server_hash_extractor'
+require 'engineyard-serverside/cli/workflows/errors'
+require 'engineyard-serverside/configuration'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+
+        # Base is the template from which all Workflows are derived
+        class Base
+          attr_reader :options
+
+          def initialize(options = {})
+            @options = options
+          end
+
+          def perform
+            shell.debug "Initializing #{About.name_with_version}."
+
+            begin
+              procedure
+            rescue EY::Serverside::RemoteFailure => remote_error
+              shell.fatal(remote_error.message)
+              raise
+            rescue Exception => error
+              shell.fatal("#{error.backtrace[0]}: #{error.message} (#{error.class})")
+              raise
+            end
+          end
+
+          def self.perform(options = {})
+            new(options).perform
+          end
+
+          private
+          def config
+            @config ||= EY::Serverside::Deploy::Configuration.new(options)
+          end
+
+          def shell
+            @shell ||= EY::Serverside::Shell.new(
+              :verbose => config.verbose,
+              :log_path => File.join(
+                ENV['HOME'],
+                "#{config.app}-#{task_name}.log"
+              )
+            )
+          end
+
+          def servers
+            @servers ||= EY::Serverside::Servers.from_hashes(
+              EY::Serverside::CLI::ServerHashExtractor.hashes(options, config),
+              shell
+            )
+          end
+
+          def task_name
+            raise Undefined.new(
+              "You must define the private task_name method for your workflow."
+            )
+          end
+
+          def procedure
+            raise Undefined.new(
+              "You must define the private procedure method for your workflow."
+            )
+          end
+
+          def propagate_serverside
+            EY::Serverside::Propagator.propagate(servers, shell)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/cli/workflows/calling_deploy_hooks.rb

@@ -0,0 +1,31 @@
+require 'engineyard-serverside/cli/workflows/base'
+require 'engineyard-serverside/callbacks'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+
+        # CallingDeployHooks is a Workflow that, given a hook_name option,
+        # executes the requested deploy hook
+        class CallingDeployHooks < Base
+          private
+          def procedure
+            Callbacks.
+              load(config.paths).
+              execute(config, shell, hook_name)
+          end
+
+          def task_name
+            "hook-#{hook_name}"
+          end
+
+          def hook_name
+            options[:hook_name]
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/cli/workflows/deploying_applications.rb

@@ -0,0 +1,28 @@
+require 'engineyard-serverside/cli/workflows/base'
+require 'engineyard-serverside/cli/workflows/helpers'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+
+        # DeployingApplications is a Workflow that deploys the application
+        # specified by the incoming options
+        class DeployingApplications < Base
+          include Helpers
+
+          private
+          def procedure
+            propagate_serverside
+
+            deployer.deploy
+          end
+
+          def task_name
+            'deploy'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/cli/workflows/disabling_maintenance.rb

@@ -0,0 +1,29 @@
+require 'engineyard-serverside/cli/workflows/base'
+require 'engineyard-serverside/cli/workflows/helpers'
+require 'engineyard-serverside/maintenance'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+
+        # DisablingMaintenance is a Workflow that removes the maintenance page
+        # for the application specified in the options
+        class DisablingMaintenance < Base
+          include Helpers
+
+          private
+          def procedure
+            propagate_serverside
+
+            maintenance.manually_disable
+          end
+
+          def task_name
+            'disable_maintenance'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/cli/workflows/enabling_maintenance.rb

@@ -0,0 +1,29 @@
+require 'engineyard-serverside/cli/workflows/base'
+require 'engineyard-serverside/cli/workflows/helpers'
+require 'engineyard-serverside/maintenance'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+
+        # EnablingMaintenance is a Workflow that puts a maintenance page in
+        # place for the application specified in the options
+        class EnablingMaintenance < Base
+          include Helpers
+
+          private
+          def procedure
+            propagate_serverside
+
+            maintenance.manually_enable
+          end
+
+          def task_name
+            'enable_maintenance'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/cli/workflows/errors.rb

@@ -0,0 +1,13 @@
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+        # Undefined is an error that is raised when one attemps to perform
+        # a Workflow that is not fully defined
+        class Undefined < StandardError
+        end
+
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/cli/workflows/helpers.rb

@@ -0,0 +1,21 @@
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+
+        # Helpers is a collection of methods that can be mixed into a Workflow
+        # to provide easy access to some of the underlying concepts for
+        # procedures like deploying, managing maintenance state, etc
+        module Helpers
+          def deployer
+            EY::Serverside::Deploy.new(servers, config, shell)
+          end
+
+          def maintenance
+            EY::Serverside::Maintenance.new(servers, config, shell)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/cli/workflows/integrating_servers.rb

@@ -0,0 +1,71 @@
+require 'engineyard-serverside/cli/workflows/base'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+
+        # IntegratingServers is a Workflow that attempts to integrate new
+        # servers into an existing environment
+        class IntegratingServers < Base
+          def initialize(options = {})
+            super
+
+            # We need to set some extra options, but options is frozen by
+            # the time we get here, so dupe it!
+            @options = options.dup
+
+            # so that we deploy to the same place there that we have here
+            @options[:release_path] = current_app_dir.realpath.to_s
+
+            # we have to deploy the same SHA there as here
+            @options[:branch] = current_app_dir.join('REVISION').read.strip
+
+            # always rebundle gems on integrate to make sure the instance comes up correctly.
+            @options[:clean] = true
+          end
+
+          private
+          def procedure
+            propagate_serverside
+
+            # We have to rsync the entire app dir, so we need all the permissions to be correct!
+            owner_user = config.user
+            owner_group = config.group
+
+            chown_command = %|find #{app_dir} \\( -not -user #{owner_user} -or -not -group #{owner_group} \\) -exec chown -h #{owner_user}:#{owner_group} "{}" +|
+            
+            shell.logged_system("sudo sh -l -c '#{chown_command}'", servers.detect {|server| server.local?})
+
+            servers.run_for_each! do |server|
+              chown = server.command_on_server('sudo sh -l -c', chown_command)
+              sync  = server.sync_directory_command(app_dir, options[:ignore_existing])
+              clean = server.command_on_server('sh -l -c', "rm -rf #{current_app_dir}")
+              "(#{chown}) && (#{sync}) && (#{clean})"
+            end
+
+            # deploy local-ref to other instances into /data/$app/local-current
+            EY::Serverside::Deploy.new(servers, config, shell).cached_deploy
+          end
+
+          def task_name
+            "integrate-#{options[:instances].join('-')}".gsub(/[^-.\w]/,'')
+          end
+
+          def integrate_options
+            @integrate_options ||= options.dup
+          end
+
+          def app_dir
+            @app_dir ||= Pathname.new "/data/#{options[:app]}"
+          end
+
+          def current_app_dir
+            @current_app_dir ||= app_dir.join("current")
+          end
+
+        end
+      end
+    end
+  end
+end