class DanarchyDeploy::RemoteDeploy

Public Class Methods

new(deployment, options) click to toggle source
# File lib/danarchy_deploy.rb, line 43
def self.new(deployment, options)
  puts "\n" + self.name

  options[:working_dir] = options[:deploy_dir] + '/' + deployment[:hostname]
  connector = { hostname: deployment[:hostname],
                ipv4:     deployment[:ipv4],
                ssh_user: deployment[:ssh_user],
                ssh_key:  deployment[:ssh_key] }

  remote_mkdir(connector, options)

  if options[:dev_gem]
    puts "\nDev Gem mode: Building and pushing gem..."
    gem = dev_gem_build(options)
    dev_gem_install(connector, gem, options)
  else
    gem_install(connector, options)
  end

  gem_clean(connector, options)
  gem_binary = _locate_gem_binary(connector, options) # this should run before any install; check version too
  push_temmplates(connector, options)
  push_deployment(connector, options)
  deploy_result = remote_LocalDeploy(connector, gem_binary, options)

  abort("\n ! Deployment failed to complete!") if !deploy_result

  pull_deployment(connector, options) if !options[:pretend]
  # remote_cleanup(connector, options) if !options[:pretend]

  puts "\nRemote deployment complete!"
  deployment = JSON.parse(File.read(options[:deploy_file]), symbolize_names: true) if options[:deploy_file].end_with?('.json')
  deployment = YAML.load_file(options[:deploy_file]) if options[:deploy_file].end_with?('.yaml')
  deployment
end

Private Class Methods

_locate_gem_binary(connector, options) click to toggle source
# File lib/danarchy_deploy.rb, line 227
def self._locate_gem_binary(connector, options)
  locate_cmd = _ssh_command(connector, 'sudo which danarchy_deploy')
  locate_result = DanarchyDeploy::Helpers.run_command(locate_cmd, options)

  if locate_result[:stderr]
    abort('   ! Could not locate Ruby gem binary!')
  else
    puts '   |+ Gem binary located!'
  end

  locate_result[:stdout].chomp
end
_rsync_pull(connector, remote, local) click to toggle source
# File lib/danarchy_deploy.rb, line 258
def self._rsync_pull(connector, remote, local)
  "rsync --rsh 'ssh -i #{connector[:ssh_key]}' -Havzu --delete #{connector[:ssh_user]}@#{connector[:ipv4]}:#{remote}/ #{local}/"
end
_rsync_push(connector, local, remote) click to toggle source
# File lib/danarchy_deploy.rb, line 254
def self._rsync_push(connector, local, remote)
  "rsync --rsh 'ssh -i #{connector[:ssh_key]}' -Havzu --delete #{local}/ #{connector[:ssh_user]}@#{connector[:ipv4]}:#{remote}/"
end
_scp_pull(connector, remote, local) click to toggle source
# File lib/danarchy_deploy.rb, line 250
def self._scp_pull(connector, remote, local)
  "scp -i #{connector[:ssh_key]} #{connector[:ssh_user]}@#{connector[:ipv4]}:#{remote} #{local}"
end
_scp_push(connector, local, remote) click to toggle source
# File lib/danarchy_deploy.rb, line 246
def self._scp_push(connector, local, remote)
  "scp -i #{connector[:ssh_key]} #{local} #{connector[:ssh_user]}@#{connector[:ipv4]}:#{remote}/"
end
_ssh_command(connector, command) click to toggle source
# File lib/danarchy_deploy.rb, line 240
def self._ssh_command(connector, command)
  "ssh -i #{connector[:ssh_key]} " +
    "#{connector[:ssh_user]}@#{connector[:ipv4]} " +
    "-o ConnectTimeout=30 -o StrictHostKeyChecking=no '#{command}'"
end
dev_gem_build(options) click to toggle source
# File lib/danarchy_deploy.rb, line 115
def self.dev_gem_build(options)
  gem = "danarchy_deploy-#{DanarchyDeploy::VERSION}.gem"
  puts "\n > Building gem: #{gem}"
  gem_dir = File.expand_path('../../', __FILE__)

  abort('ERROR: Need to be in development gem directory for --dev-gem!') if Dir.pwd != gem_dir
  
  gem_path = "#{gem_dir}/pkg/#{gem}"
  build_cmd = "cd #{gem_dir} && git add . && rake build"
  build_result = DanarchyDeploy::Helpers.run_command(build_cmd, options)

  if build_result[:stderr]
    abort('   ! Gem build failed!')
  elsif File.exist?(gem_path)
    puts "   |+ Gem built: #{gem_path}"
  end

  gem_path
end
dev_gem_install(connector, gem, options) click to toggle source
# File lib/danarchy_deploy.rb, line 135
def self.dev_gem_install(connector, gem, options)
  puts "\n > Pushing gem: #{gem} to #{connector[:hostname]}"
  push_cmd = _scp_push(connector, gem, options[:deploy_dir])
  push_result = DanarchyDeploy::Helpers.run_command(push_cmd, options)

  if push_result[:stderr]
    abort('   ! Gem push failed!')
  else
    puts '   |+ Gem pushed!'
  end
  
  puts "\n > Installing gem: #{gem} on #{connector[:hostname]}"
  install_cmd = _ssh_command(connector, "sudo gem install -f #{options[:deploy_dir]}/#{File.basename(gem)}")
  install_result = DanarchyDeploy::Helpers.run_command(install_cmd, options)

  if install_result[:stderr]
    abort('   ! Gem install failed!')
  else
    puts '   |+ Gem installed!'
  end
end
gem_clean(connector, options) click to toggle source
# File lib/danarchy_deploy.rb, line 157
def self.gem_clean(connector, options)
  clean_cmd = _ssh_command(connector, 'sudo gem clean danarchy_deploy 2&>/dev/null')
  system(clean_cmd)
end
gem_install(connector, options) click to toggle source
# File lib/danarchy_deploy.rb, line 103
def self.gem_install(connector, options)
  puts "\n > Installing danarchy_deploy on #{connector[:hostname]}"
  install_cmd = _ssh_command(connector, 'sudo gem install -f danarchy_deploy')
  install_result = DanarchyDeploy::Helpers.run_command(install_cmd, options)

  if install_result[:stderr]
    abort('   ! Gem install failed!')
  else
    puts "   |+ Gem installed!"
  end
end
pull_deployment(connector, options) click to toggle source
# File lib/danarchy_deploy.rb, line 203
def self.pull_deployment(connector, options)
  puts "\n > Pulling deployment: #{options[:deploy_file]}"
  pull_cmd = _scp_pull(connector, options[:deploy_file], options[:deploy_file])
  pull_result = DanarchyDeploy::Helpers.run_command(pull_cmd, options)
  
  if pull_result[:stderr]
    abort('   ! Deployment pull failed!')
  else
    puts "   |+ Deployment pulled!"
  end
end
push_deployment(connector, options) click to toggle source
# File lib/danarchy_deploy.rb, line 175
def self.push_deployment(connector, options)
  puts "\n > Pushing deployment: #{options[:deploy_file]}"
  push_cmd = _rsync_push(connector, options[:working_dir], options[:working_dir])
  push_result = DanarchyDeploy::Helpers.run_command(push_cmd, options)

  if push_result[:stderr]
    abort('   ! Deployment push failed!')
  else
    puts "   |+ Deployment pushed to '#{options[:working_dir]}'!"
  end
end
push_temmplates(connector, options) click to toggle source
# File lib/danarchy_deploy.rb, line 162
def self.push_temmplates(connector, options)
  template_dir = options[:deploy_dir] + '/templates'
  puts "\n > Pushing templates: #{template_dir}"
  push_cmd = _rsync_push(connector, template_dir, template_dir)
  push_result = DanarchyDeploy::Helpers.run_command(push_cmd, options)
  
  if push_result[:stderr]
    abort('   ! Templates push failed!')
  else
    puts "   |+ Templates pushed to '#{options[:working_dir]}'!"
  end
end
remote_LocalDeploy(connector, gem_binary, options) click to toggle source
# File lib/danarchy_deploy.rb, line 187
def self.remote_LocalDeploy(connector, gem_binary, options)
  puts "\n > Running LocalDeploy on #{connector[:hostname]}.\n\n"

  deploy_cmd  = "sudo #{gem_binary} local "
  deploy_cmd += '--first-run '    if options[:first_run]
  deploy_cmd += '--ssh-verbose '  if options[:ssh_verbose]
  deploy_cmd += '--vars-verbose ' if options[:vars_verbose]
  deploy_cmd += '--pretend '      if options[:pretend]
  deploy_cmd += '--json '         if options[:deploy_file].end_with?('.json')
  deploy_cmd += '--yaml '         if options[:deploy_file].end_with?('.yaml')
  deploy_cmd += options[:deploy_file]

  deploy_command = _ssh_command(connector, deploy_cmd)
  system(deploy_command)
end
remote_cleanup(connector, options) click to toggle source
# File lib/danarchy_deploy.rb, line 215
def self.remote_cleanup(connector, options)
  puts "\n > Cleaning up: #{options[:deploy_dir]}"
  cleanup_cmd = _ssh_command(connector, "sudo rm -rfv #{options[:working_dir]}")
  cleanup_result = DanarchyDeploy::Helpers.run_command(cleanup_cmd, options)

  if cleanup_result[:stderr]
    abort('   ! Deployment cleanup failed!')
  else
    puts "   |+ Deployment cleaned up!"
  end
end
remote_mkdir(connector, options) click to toggle source
# File lib/danarchy_deploy.rb, line 80
def self.remote_mkdir(connector, options)
  puts "\n > Creating directory: #{options[:working_dir]}"
  mkdir_cmd = _ssh_command(connector, "test -d #{options[:working_dir]} || sudo mkdir -vp #{options[:working_dir]}")
  mkdir_result = DanarchyDeploy::Helpers.run_command(mkdir_cmd, options)

  if mkdir_result[:stderr]
    abort('   ! Directory creation failed!')
  else
    puts "   |+ Created directory: '#{options[:deploy_dir]}'"
  end

  puts "\n > Setting directory permissions to '0750' for '#{connector[:ssh_user]}' on '#{options[:deploy_dir]}'"
  chown_cmd = _ssh_command(connector, "sudo chown -Rc #{connector[:ssh_user]}:#{connector[:ssh_user]} #{options[:deploy_dir]}; " +
                                      "sudo chmod -c 0750 #{options[:deploy_dir]}")
  chown_result = DanarchyDeploy::Helpers.run_command(chown_cmd, options)

  if chown_result[:stderr]
    abort('   ! Setting directory permissions failed!')
  else
    puts '   |+ Set directory permissions!'
  end
end