Class: EY::Serverside::CLI

Inherits:

Thor

• Object
• Thor
• EY::Serverside::CLI

Includes:

Dataflow

Defined in:

lib/engineyard-serverside/cli.rb

Constant Summary

Constants included from Dataflow

Dataflow::UnificationError, Dataflow::VERSION

Constants inherited from Thor

Thor::HELP_MAPPINGS, Thor::THOR_RESERVED_WORDS, Thor::VERSION

Instance Attribute Summary

Attributes included from Thor::Base

#options

Class Method Summary

• .start ⇒ Object

Instance Method Summary

• #deploy(default_task = :deploy) ⇒ Object
• #hook(hook_name) ⇒ Object
• #install_bundler(version) ⇒ Object
• #integrate ⇒ Object
• #propagate ⇒ Object
• #restart ⇒ Object

Methods included from Dataflow

#barrier, #by_need, #flow, included, #local, #need_later, #unify

Methods inherited from Thor

default_task, desc, handle_argument_error, #help, help, map, method_option, method_options, printable_tasks, task_help

Methods included from Thor::Base

included, #initialize, register_klass_file, shell, shell=, subclass_files, subclasses

Class Method Details

.start ⇒ Object

# File 'lib/engineyard-serverside/cli.rb', line 9

def self.start(*)
  super
rescue RemoteFailure
  exit(1)
end

Instance Method Details

#deploy(default_task = :deploy) ⇒ Object

# File 'lib/engineyard-serverside/cli.rb', line 59

def deploy(default_task=:deploy)
  config = EY::Serverside::Deploy::Configuration.new(options)
  EY::Serverside::Server.load_all_from_array(assemble_instance_hashes(config))

  EY::Serverside::LoggedOutput.verbose = options[:verbose]
  EY::Serverside::LoggedOutput.logfile = File.join(ENV['HOME'], "#{options[:app]}-deploy.log")

  invoke :propagate

  EY::Serverside::Deploy.new(config).send(default_task)
end

#hook(hook_name) ⇒ Object

# File 'lib/engineyard-serverside/cli.rb', line 95

def hook(hook_name)
  EY::Serverside::DeployHook.new(options).run(hook_name)
end

#install_bundler(version) ⇒ Object

# File 'lib/engineyard-serverside/cli.rb', line 199

def install_bundler(version)
  egrep_escaped_version = version.gsub(/\./, '\.')
  # the grep "bundler " is so that gems like bundler08 don't get
  # their versions considered too
  #
  # 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_bundler_cmd = "gem list bundler | grep \"bundler \" | egrep -q '#{egrep_escaped_version}[,)]'"

  unless system(has_bundler_cmd)
    system("gem install bundler -q --no-rdoc --no-ri -v '#{version}'")
  end
end

#integrate ⇒ Object

# File 'lib/engineyard-serverside/cli.rb', line 129

def integrate
  EY::Serverside::LoggedOutput.verbose = options[:verbose]
  EY::Serverside::LoggedOutput.logfile = File.join(ENV['HOME'], "#{options[:app]}-integrate.log")

  app_dir = Pathname.new "/data/#{options[:app]}"
  current_app_dir = app_dir + "current"

  # so that we deploy to the same place there that we have here
  integrate_options = options.dup
  integrate_options[:release_path] = current_app_dir.realpath.to_s

  # we have to deploy the same SHA there as here
  integrate_options[:branch] = (current_app_dir + 'REVISION').read.strip

  config = EY::Serverside::Deploy::Configuration.new(integrate_options)

  EY::Serverside::Server.load_all_from_array(assemble_instance_hashes(config))

  invoke :propagate

  EY::Serverside::Server.all.each do |server|
    server.sync_directory app_dir
    # we're just about to recreate this, so it has to be gone
    # first. otherwise, non-idempotent deploy hooks could screw
    # things up, and since we don't control deploy hooks, we must
    # assume the worst.
    server.run("rm -rf #{current_app_dir}")
  end

  # deploy local-ref to other instances into /data/$app/local-current
  EY::Serverside::Deploy.new(config).cached_deploy
end

#propagate ⇒ Object

# File 'lib/engineyard-serverside/cli.rb', line 214

def propagate
  config          = EY::Serverside::Deploy::Configuration.new
  gem_filename    = "engineyard-serverside-#{EY::Serverside::VERSION}.gem"
  local_gem_file  = File.join(Gem.dir, 'cache', gem_filename)
  remote_gem_file = File.join(Dir.tmpdir, gem_filename)
  gem_binary      = File.join(Gem.default_bindir, 'gem')

  barrier(*(EY::Serverside::Server.all.find_all do |server|
    !server.local?            # of course this machine has it
  end.map do |server|
    need_later do
      egrep_escaped_version = EY::Serverside::VERSION.gsub(/\./, '\.')
      # 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
      has_gem_cmd = "#{gem_binary} list engineyard-serverside | grep \"engineyard-serverside\" | egrep -q '#{egrep_escaped_version}[,)]'"

      if !server.run(has_gem_cmd)  # doesn't have this exact version
        puts "~> Installing engineyard-serverside on #{server.hostname}"

        system(Escape.shell_command([
          'scp', '-i', "#{ENV['HOME']}/.ssh/internal",
          "-o", "StrictHostKeyChecking=no",
          local_gem_file,
         "#{config.user}@#{server.hostname}:#{remote_gem_file}",
        ]))
        server.run("sudo #{gem_binary} install --no-rdoc --no-ri '#{remote_gem_file}'")
      end
    end
  end))
end

#restart ⇒ Object

# File 'lib/engineyard-serverside/cli.rb', line 186

def restart
  EY::Serverside::LoggedOutput.verbose = options[:verbose]
  EY::Serverside::LoggedOutput.logfile = File.join(ENV['HOME'], "#{options[:app]}-restart.log")

  config = EY::Serverside::Deploy::Configuration.new(options)
  EY::Serverside::Server.load_all_from_array(assemble_instance_hashes(config))

  invoke :propagate

  EY::Serverside::Deploy.new(config).restart_with_maintenance_page
end