Class: Chef::Knife::NcServerCreate

Inherits:

Chef::Knife

• Object
• Chef::Knife
• Chef::Knife::NcServerCreate

Includes:

NcBase

Defined in:

lib/chef/knife/nc_server_create.rb

Instance Attribute Summary

• #initial_sleep_delay ⇒ Object

  Returns the value of attribute initial_sleep_delay.

Instance Method Summary

• #bootstrap_for_node(server, fqdn) ⇒ Object
• #create_server_def ⇒ Object
• #image ⇒ Object
• #run ⇒ Object
• #tcp_test_ssh(hostname) ⇒ Object
• #validate! ⇒ Object

Methods included from NcBase

#connection, included, #locate_config_value, #msg_pair

Instance Attribute Details

#initial_sleep_delay ⇒ Object

Returns the value of attribute initial_sleep_delay.

# File 'lib/chef/knife/nc_server_create.rb', line 37

def initial_sleep_delay
  @initial_sleep_delay
end

Instance Method Details

#bootstrap_for_node(server, fqdn) ⇒ Object

# File 'lib/chef/knife/nc_server_create.rb', line 221

def bootstrap_for_node(server,fqdn)
  bootstrap = Chef::Knife::Bootstrap.new
  bootstrap.name_args = [fqdn]
  bootstrap.config[:run_list] = config[:run_list]
  bootstrap.config[:ssh_user] = config[:ssh_user]
  bootstrap.config[:ssh_password] = config[:ssh_password]
  bootstrap.config[:ssh_passphrase] = config[:ssh_passphrase]
  bootstrap.config[:identity_file] = config[:identity_file]
  bootstrap.config[:chef_node_name] = config[:chef_node_name] || server.instanceId
  bootstrap.config[:prerelease] = config[:prerelease]
  bootstrap.config[:bootstrap_version] = locate_config_value(:nc_bootstrap_version)

  image_id = locate_config_value(:nc_image_id)
	if locate_config_value(:nc_distro)
    bootstrap.config[:distro] = locate_config_value(:nc_distro)
  elsif %w(1 2 6 7 13 14).include?(image_id)
    bootstrap.config[:distro] = 'nc-centos5-gems'
  elsif image_id == '17'
    bootstrap.config[:distro] = 'ubuntu10.04-gems'
  elsif image_id == '21'
    bootstrap.config[:distro] = 'nc-centos6-gems'
	else
    bootstrap.config[:distro] = 'nc-centos5-gems'
  end

  bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
  bootstrap.config[:template_file] = locate_config_value(:nc_template_file)
  bootstrap.config[:environment] = config[:environment]
  bootstrap
end

#create_server_def ⇒ Object

# File 'lib/chef/knife/nc_server_create.rb', line 280

def create_server_def
  server_def = {
    :instance_id => @name_args.first,
    :image_id => locate_config_value(:nc_image_id),
    :instance_type => locate_config_value(:nc_instance_type),
    :security_group => config[:security_group],
    :key_name => Chef::Config[:knife][:nc_ssh_key_id],
    :disable_api_termination => false # for 'knife nc server delete' command
  }

  if Chef::Config[:knife][:nc_user_data]
    begin
      server_def.merge!(:user_data => File.read(locate_config_value(:nc_user_data)))
    rescue
      ui.warn("Cannot read #{Chef::Config[:knife][:nc_user_data]}: #{$!.inspect}. Ignoring option.")
    end
  end

  server_def
end

#image ⇒ Object

# File 'lib/chef/knife/nc_server_create.rb', line 252

def image
  @image ||= connection.describe_images(:image_id => locate_config_value(:nc_image_id)).imagesSet.item.first
end

#run ⇒ Object

# File 'lib/chef/knife/nc_server_create.rb', line 163

def run
  $stdout.sync = true
  NIFTY::LOG.level = Logger::DEBUG

  validate!

  msg_pair("Instance ID", @name_args.first)
  msg_pair("Instance Type", locate_config_value(:nc_instance_type))
  msg_pair("Image", locate_config_value(:nc_image_id))
  msg_pair("SSH Key", locate_config_value(:nc_ssh_key_id))
  msg_pair("Security Group", config[:security_group])

  puts "\n"
  confirm("Do you really want to create this server")

  server = connection.run_instances(create_server_def).instancesSet.item.first

  msg_pair("Instance ID", server.instanceId)
  msg_pair("Instance Type", server.instanceType)
  msg_pair("Image", server.imageId)
  msg_pair("SSH Key", server.keyName)

  print "\n#{ui.color("Waiting for server", :magenta)}"

  # wait for it to be ready to do stuff
  while server.instanceState.name != 'running'
    print "."
    server = connection.describe_instances(:instance_id => server.instanceId).reservationSet.item.first.instancesSet.item.first
    sleep 5
  end

  puts("done\n")
  
  msg_pair("Public IP Address", server.ipAddress)
  msg_pair("Private IP Address", server.privateIpAddress)

  ssh_ip_address = config[:ssh_locally] ? server.privateIpAddress : server.ipAddress
  print "\n#{ui.color("Waiting for sshd", :magenta)} (using #{ssh_ip_address})"
  
  print(".") until tcp_test_ssh(ssh_ip_address) {
    sleep @initial_sleep_delay ||= 10
    puts("done")
  }

  bootstrap_for_node(server, ssh_ip_address).run

  puts "\n"
  msg_pair("Instance ID", server.instanceId)
  msg_pair("Instance Type", server.instanceType)
  msg_pair("Image ID", server.imageId)
  msg_pair("Security Group", config[:security_group])
  msg_pair("SSH Key", server.keyName)
  msg_pair("Public IP Address", server.ipAddress)
  msg_pair("Private IP Address", server.privateIpAddress)
  msg_pair("Environment", config[:environment] || '_default')
  msg_pair("Run List", config[:run_list].join(', '))
end

#tcp_test_ssh(hostname) ⇒ Object

# File 'lib/chef/knife/nc_server_create.rb', line 136

def tcp_test_ssh(hostname)
  tcp_socket = TCPSocket.new(hostname, 22)
  readable = IO.select([tcp_socket], nil, nil, 5)
  if readable
    Chef::Log.debug("sshd accepting connections on #{hostname}, banner is #{tcp_socket.gets}")
    yield
    true
  else
    false
  end
rescue SocketError
  sleep 2
  false
rescue Errno::ETIMEDOUT
  false
rescue Errno::EPERM
  false
rescue Errno::ECONNREFUSED
  sleep 2
  false
rescue Errno::EHOSTUNREACH
  sleep 2
  false
ensure
  tcp_socket && tcp_socket.close
end

#validate! ⇒ Object

# File 'lib/chef/knife/nc_server_create.rb', line 256

def validate!
  super([:nc_image_id, :nc_ssh_key_id, :nc_access_key, :nc_secret_key])

  errors = []

  if @name_args.empty?
    errors << "You have not provided a valid instance ID."
  end

  if config[:security_group].nil?
    errors << "You have not provided a valid Security Group."
  end

  [:identity_file, :nc_template_file, :nc_user_data].each do |x|
    if (path = locate_config_value(x)) && !File.exists?(path)
      errors << "File does not exist: #{path}"
    end
  end

  if errors.each{|e| ui.error(e)}.any?
    exit 1
  end
end