Class: Chef::Knife::AzureServerCreate

Inherits:

Chef::Knife

• Object
• Chef::Knife
• Chef::Knife::AzureServerCreate

Includes:

AzureBase, Knife::WinrmBase

Defined in:

lib/chef/knife/azure_server_create.rb

Instance Attribute Summary

• #initial_sleep_delay ⇒ Object

  Returns the value of attribute initial_sleep_delay.

Instance Method Summary

• #bootstrap_common_params(bootstrap, server) ⇒ Object
• #bootstrap_for_node(server, fqdn, port) ⇒ Object
• #bootstrap_for_windows_node(server, fqdn, port) ⇒ Object
• #create_server_def ⇒ Object
• #load_cloud_attributes_in_hints(server) ⇒ Object
• #load_winrm_deps ⇒ Object
• #random_string(len = 10) ⇒ Object
• #run ⇒ Object
• #strip_non_ascii(string) ⇒ Object
• #tcp_test_ssh(fqdn, sshport) ⇒ Object
• #tcp_test_winrm(ip_addr, port) ⇒ Object
• #validate! ⇒ Object

Methods included from AzureBase

#connection, #find_file, included, #is_image_windows?, #locate_config_value, #msg_pair, #parse_publish_settings_file

Instance Attribute Details

#initial_sleep_delay ⇒ Object

Returns the value of attribute initial_sleep_delay.

# File 'lib/chef/knife/azure_server_create.rb', line 48

def initial_sleep_delay
  @initial_sleep_delay
end

Instance Method Details

#bootstrap_common_params(bootstrap, server) ⇒ Object

# File 'lib/chef/knife/azure_server_create.rb', line 333

def bootstrap_common_params(bootstrap, server)

  bootstrap.config[:run_list] = config[:run_list]
  bootstrap.config[:prerelease] = config[:prerelease]
  bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
  bootstrap.config[:distro] = locate_config_value(:distro)
  bootstrap.config[:template_file] = locate_config_value(:template_file)
  load_cloud_attributes_in_hints(server)
  bootstrap
end

#bootstrap_for_node(server, fqdn, port) ⇒ Object

# File 'lib/chef/knife/azure_server_create.rb', line 379

def bootstrap_for_node(server,fqdn,port)
  bootstrap = Chef::Knife::Bootstrap.new
  bootstrap.name_args = [fqdn]
  bootstrap.config[:run_list] = config[:run_list]
  bootstrap.config[:ssh_user] = locate_config_value(:ssh_user)
  bootstrap.config[:ssh_password] = locate_config_value(:ssh_password)
  bootstrap.config[:ssh_port] = port
  bootstrap.config[:identity_file] = locate_config_value(:identity_file)
  bootstrap.config[:chef_node_name] = locate_config_value(:chef_node_name) || server.name
  bootstrap.config[:prerelease] = locate_config_value(:prerelease)
  bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
  bootstrap.config[:distro] = locate_config_value(:distro)
  bootstrap.config[:use_sudo] = true unless locate_config_value(:ssh_user) == 'root'
  bootstrap.config[:use_sudo_password] = true if bootstrap.config[:use_sudo]
  bootstrap.config[:template_file] = config[:template_file]
  bootstrap.config[:environment] = locate_config_value(:environment)
  # may be needed for vpc_mode
  bootstrap.config[:host_key_verify] = config[:host_key_verify]

  # Load cloud attributes.
  load_cloud_attributes_in_hints(server)

  bootstrap
end

#bootstrap_for_windows_node(server, fqdn, port) ⇒ Object

# File 'lib/chef/knife/azure_server_create.rb', line 345

def bootstrap_for_windows_node(server, fqdn, port)
  if locate_config_value(:bootstrap_protocol) == 'winrm'

      load_winrm_deps
      if not Chef::Platform.windows?
        require 'gssapi'
      end

      bootstrap = Chef::Knife::BootstrapWindowsWinrm.new

      bootstrap.config[:winrm_user] = locate_config_value(:winrm_user) || 'Administrator'
      bootstrap.config[:winrm_password] = locate_config_value(:winrm_password)
      bootstrap.config[:winrm_transport] = locate_config_value(:winrm_transport)

      bootstrap.config[:winrm_port] = port

  elsif locate_config_value(:bootstrap_protocol) == 'ssh'
      bootstrap = Chef::Knife::BootstrapWindowsSsh.new
      bootstrap.config[:ssh_user] = locate_config_value(:ssh_user)
      bootstrap.config[:ssh_password] = locate_config_value(:ssh_password)
      bootstrap.config[:ssh_port] = port
      bootstrap.config[:identity_file] = locate_config_value(:identity_file)
      bootstrap.config[:host_key_verify] = locate_config_value(:host_key_verify)
  else
      ui.error("Unsupported Bootstrapping Protocol. Supported : winrm, ssh")
      exit 1
  end
  bootstrap.name_args = [fqdn]
  bootstrap.config[:chef_node_name] = config[:chef_node_name] || server.name
  bootstrap.config[:encrypted_data_bag_secret] = config[:encrypted_data_bag_secret]
  bootstrap.config[:encrypted_data_bag_secret_file] = config[:encrypted_data_bag_secret_file]
  bootstrap_common_params(bootstrap, server)
end

#create_server_def ⇒ Object

# File 'lib/chef/knife/azure_server_create.rb', line 420

def create_server_def
  server_def = {
    :azure_storage_account => locate_config_value(:azure_storage_account),
    :azure_dns_name => locate_config_value(:azure_dns_name),
    :azure_vm_name => locate_config_value(:azure_vm_name),
    :azure_service_location => locate_config_value(:azure_service_location),
    :azure_os_disk_name => locate_config_value(:azure_os_disk_name),
    :azure_source_image => locate_config_value(:azure_source_image),
    :azure_vm_size => locate_config_value(:azure_vm_size),
    :tcp_endpoints => locate_config_value(:tcp_endpoints),
    :udp_endpoints => locate_config_value(:udp_endpoints),
    :bootstrap_proto => locate_config_value(:bootstrap_protocol),
    :azure_connect_to_existing_dns => locate_config_value(:azure_connect_to_existing_dns)
  }
  # If user is connecting a new VM to an existing dns, then
  # the VM needs to have a unique public port. Logic below takes care of this.
  if !is_image_windows? or locate_config_value(:bootstrap_protocol) == 'ssh'
    port = locate_config_value(:ssh_port) || '22'
    if locate_config_value(:azure_connect_to_existing_dns) && (port == '22')
       port = Random.rand(64000) + 1000
    end
  else
    port = locate_config_value(:winrm_port) || '5985'
    if locate_config_value(:azure_connect_to_existing_dns) && (port == '5985')
        port = Random.rand(64000) + 1000
    end
  end
  server_def[:port] = port

  if is_image_windows?
    server_def[:os_type] = 'Windows'
    if not locate_config_value(:winrm_password) or not locate_config_value(:bootstrap_protocol)
      ui.error("WinRM Password and Bootstrapping Protocol are compulsory parameters")
    end
    server_def[:admin_password] = locate_config_value(:winrm_password)
    server_def[:bootstrap_proto] = locate_config_value(:bootstrap_protocol)
  else
    server_def[:os_type] = 'Linux'
    server_def[:bootstrap_proto] = 'ssh'
    if not locate_config_value(:ssh_user)
      ui.error("SSH User is compulsory parameter")
      exit 1
    end
    unless locate_config_value(:ssh_password) or locate_config_value(:identity_file)
        ui.error("Specify either SSH Key or SSH Password")
        exit 1
    end

    server_def[:ssh_user] = locate_config_value(:ssh_user)
    server_def[:ssh_password] = locate_config_value(:ssh_password)
    server_def[:identity_file] = locate_config_value(:identity_file)
    server_def[:identity_file_passphrase] = locate_config_value(:identity_file_passphrase)
  end
  server_def
end

#load_cloud_attributes_in_hints(server) ⇒ Object

# File 'lib/chef/knife/azure_server_create.rb', line 318

def load_cloud_attributes_in_hints(server)
  # Modify global configuration state to ensure hint gets set by knife-bootstrap
  # Query azure and load necessary attributes.
  cloud_attributes = {}
  cloud_attributes["public_ip"] = server.publicipaddress
  cloud_attributes["vm_name"] = server.name
  cloud_attributes["public_fqdn"] = server.hostedservicename.to_s + ".cloudapp.net"
  cloud_attributes["public_ssh_port"] = server.sshport if server.sshport
  cloud_attributes["public_winrm_port"] = server.winrmport if server.winrmport

  Chef::Config[:knife][:hints] ||= {}
  Chef::Config[:knife][:hints]["azure"] ||= cloud_attributes

end

#load_winrm_deps ⇒ Object

# File 'lib/chef/knife/azure_server_create.rb', line 39

def load_winrm_deps
  require 'winrm'
  require 'em-winrm'
  require 'chef/knife/winrm'
  require 'chef/knife/bootstrap_windows_winrm'
end

#random_string(len = 10) ⇒ Object

# File 'lib/chef/knife/azure_server_create.rb', line 194

def random_string(len=10)
  (0...len).map{65.+(rand(25)).chr}.join
end

#run ⇒ Object

# File 'lib/chef/knife/azure_server_create.rb', line 247

def run
  $stdout.sync = true
  storage = nil

  Chef::Log.info("validating...")
  validate!

  Chef::Log.info("creating...")

  if not locate_config_value(:azure_vm_name)
    config[:azure_vm_name] = locate_config_value(:azure_dns_name)
  end

  #If Storage Account is not specified, check if the geographic location has one to re-use
  if not locate_config_value(:azure_storage_account)
    storage_accts = connection.storageaccounts.all
    storage = storage_accts.find { |storage_acct| storage_acct.location.to_s == locate_config_value(:azure_service_location) }
    if not storage
      config[:azure_storage_account] = [strip_non_ascii(locate_config_value(:azure_vm_name)), random_string].join.downcase
    else
      config[:azure_storage_account] = storage.name.to_s
    end
  end

  server = connection.deploys.create(create_server_def)
  fqdn = server.publicipaddress

  puts("\n")
  if is_image_windows?
    if locate_config_value(:bootstrap_protocol) == 'ssh'
      port = server.sshport
      print "\n#{ui.color("Waiting for sshd on #{fqdn}:#{port}", :magenta)}"

      print(".") until tcp_test_ssh(fqdn,port) {
        sleep @initial_sleep_delay ||= 10
        puts("done")
     }

    elsif locate_config_value(:bootstrap_protocol) == 'winrm'
      port = server.winrmport

      print "\n#{ui.color("Waiting for winrm on #{fqdn}:#{port}", :magenta)}"

      print(".") until tcp_test_winrm(fqdn,port) {
        sleep @initial_sleep_delay ||= 10
        puts("done")
     }

    end
    sleep 15
    bootstrap_for_windows_node(server,fqdn, port).run
  else
    unless server && server.publicipaddress && server.sshport
      Chef::Log.fatal("server not created")
    exit 1
  end

  port = server.sshport

  print "\n#{ui.color("Waiting for sshd on #{fqdn}:#{port}", :magenta)}"

  print(".") until tcp_test_ssh(fqdn,port) {
    sleep @initial_sleep_delay ||= 10
    puts("done")
  }

  sleep 15
    bootstrap_for_node(server,fqdn,port).run
  end
end

#strip_non_ascii(string) ⇒ Object

# File 'lib/chef/knife/azure_server_create.rb', line 190

def strip_non_ascii(string)
  string.gsub(/[^0-9a-z ]/i, '')
end

#tcp_test_ssh(fqdn, sshport) ⇒ Object

# File 'lib/chef/knife/azure_server_create.rb', line 220

def tcp_test_ssh(fqdn, sshport)
  tcp_socket = TCPSocket.new(fqdn, sshport)
  readable = IO.select([tcp_socket], nil, nil, 5)
  if readable
    Chef::Log.debug("sshd accepting connections on #{fqdn}, 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

#tcp_test_winrm(ip_addr, port) ⇒ Object

# File 'lib/chef/knife/azure_server_create.rb', line 198

def tcp_test_winrm(ip_addr, port)
	    hostname = ip_addr
  socket = TCPSocket.new(hostname, port)
	    return true
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
rescue Errno::ENETUNREACH
  sleep 2
  false
end

#validate! ⇒ Object

# File 'lib/chef/knife/azure_server_create.rb', line 404

def validate!
  super([
        :azure_subscription_id,
        :azure_mgmt_cert,
        :azure_api_host_name,
        :azure_dns_name,
        :azure_service_location,
        :azure_source_image,
        :azure_vm_size,
  ])
  if locate_config_value(:azure_connect_to_existing_dns) && locate_config_value(:azure_vm_name).nil?
    ui.error("Specify the VM name using --azure-vm-name option, since you are connecting to existing dns")
    exit 1
  end
end