Class: Kitchen::Driver::Ec2
- Inherits:
-
Base
- Object
- Base
- Kitchen::Driver::Ec2
- Defined in:
- lib/kitchen/driver/ec2.rb
Overview
Amazon EC2 driver for Test Kitchen.
Constant Summary collapse
- INTERFACE_TYPES =
Ordered mapping from config name to Fog name. Ordered by preference when looking up hostname.
{ "dns" => "public_dns_name", "public" => "public_ip_address", "private" => "private_ip_address", "private_dns" => "private_dns_name", "id" => "id", }.freeze
Class Method Summary collapse
- .validation_error(driver, old_key, new_key) ⇒ Object
- .validation_warn(driver, old_key, new_key) ⇒ Object
Instance Method Summary collapse
-
#actual_platform ⇒ Object
The actual platform is the platform detected from the image.
- #attach_network_interface(state) ⇒ Object
- #config ⇒ Object
- #create(state) ⇒ Object
- #create_ec2_json(state) ⇒ Object
-
#create_key(state) ⇒ void
private
Create a temporary SSH key pair for this instance.
-
#create_security_group(state) ⇒ void
private
Create a temporary security group for this instance.
- #default_ami ⇒ Object
- #default_instance_type ⇒ Object
- #default_windows_user_data ⇒ Object
-
#delete_key(state) ⇒ void
private
Clean up a temporary SSH key pair for this instance.
-
#delete_security_group(state) ⇒ void
private
Clean up a temporary security group for this instance.
- #desired_platform ⇒ Object
- #destroy(state) ⇒ Object
- #ec2 ⇒ Object
-
#expand_config(conf, key) ⇒ Object
Take one config and expand to multiple configs.
- #fetch_windows_admin_password(server, state) ⇒ Object
-
#hostname(server, interface_type = nil) ⇒ Object
Lookup hostname of provided server.
- #image ⇒ Object
- #image_info(image) ⇒ Object
-
#initialize(*args, &block) ⇒ Ec2
constructor
A new instance of Ec2.
- #instance_generator ⇒ Object
- #show_chosen_image ⇒ Object
-
#submit_server ⇒ Object
AWS helper for creating the instance.
- #submit_spot ⇒ Object
- #submit_spots ⇒ Object
-
#sudo_command ⇒ Object
Returns the sudo command to use or empty string if sudo is not configured.
- #update_username(state) ⇒ Object
-
#wait_until_ready(server, state) ⇒ Object
Normally we could use ‘server.wait_until_running` but we actually need to check more than just the instance state.
-
#wait_with_destroy(server, state, status_msg, &block) ⇒ Object
Poll a block, waiting for it to return true.
- #with_request_limit_backoff(state) ⇒ Object
Constructor Details
#initialize(*args, &block) ⇒ Ec2
Returns a new instance of Ec2.
93 94 95 |
# File 'lib/kitchen/driver/ec2.rb', line 93 def initialize(*args, &block) super end |
Class Method Details
.validation_error(driver, old_key, new_key) ⇒ Object
102 103 104 105 106 |
# File 'lib/kitchen/driver/ec2.rb', line 102 def self.validation_error(driver, old_key, new_key) warn "ERROR: The driver[#{driver.class.name}] config key `#{old_key}` " \ "has been removed, please use `#{new_key}`" exit! end |
.validation_warn(driver, old_key, new_key) ⇒ Object
97 98 99 100 |
# File 'lib/kitchen/driver/ec2.rb', line 97 def self.validation_warn(driver, old_key, new_key) driver.warn "WARN: The driver[#{driver.class.name}] config key `#{old_key}` " \ "is deprecated, please use `#{new_key}`" end |
Instance Method Details
#actual_platform ⇒ Object
The actual platform is the platform detected from the image
328 329 330 |
# File 'lib/kitchen/driver/ec2.rb', line 328 def actual_platform @actual_platform ||= Aws::StandardPlatform.from_image(self, image) if image end |
#attach_network_interface(state) ⇒ Object
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 |
# File 'lib/kitchen/driver/ec2.rb', line 846 def attach_network_interface(state) info("Attaching Network interface <#{config[:elastic_network_interface_id]}> with the instance <#{state[:server_id]}> .") client = ::Aws::EC2::Client.new(region: config[:region]) begin check_eni = client.describe_network_interface_attribute({ attribute: "attachment", network_interface_id: config[:elastic_network_interface_id], }) if check_eni..nil? unless state[:server_id].nil? client.attach_network_interface({ device_index: 1, instance_id: state[:server_id], network_interface_id: config[:elastic_network_interface_id], }) info("Attached Network interface <#{config[:elastic_network_interface_id]}> with the instance <#{state[:server_id]}> .") end else puts "ENI #{config[:elastic_network_interface_id]} already attached." end rescue ::Aws::EC2::Errors::InvalidNetworkInterfaceIDNotFound => e warn("#{e}") end end |
#config ⇒ Object
392 393 394 395 396 |
# File 'lib/kitchen/driver/ec2.rb', line 392 def config return super unless @config @config end |
#create(state) ⇒ Object
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 |
# File 'lib/kitchen/driver/ec2.rb', line 197 def create(state) return if state[:server_id] update_username(state) info(Kitchen::Util.outdent!(<<-END)) unless config[:skip_cost_warning] If you are not using an account that qualifies under the AWS free-tier, you may be charged to run these suites. The charge should be minimal, but neither Test Kitchen nor its maintainers are responsible for your incurred costs. END # If no security group IDs are specified, create one automatically. unless config[:security_group_ids] || config[:security_group_filter] create_security_group(state) config[:security_group_ids] = [state[:auto_security_group_id]] end # If no SSH key pair name is specified, create one automatically. # If `_disabled`, nullify the key ID to avoid associating the instance with # an AWS-managed key pair. case config[:aws_ssh_key_id] when nil create_key(state) config[:aws_ssh_key_id] = state[:auto_key_id] when "_disable" info("Disabling AWS-managed SSH key pairs for this EC2 instance.") info("The key pairs for the kitchen transport config and the AMI must match.") config[:aws_ssh_key_id] = nil end if config[:spot_price] # Spot instance when a price is set server = with_request_limit_backoff(state) { submit_spots } else # On-demand instance server = with_request_limit_backoff(state) { submit_server } end info("Instance <#{server.id}> requested.") with_request_limit_backoff(state) do logging_proc = ->(attempts) { info("Polling AWS for existence, attempt #{attempts}...") } server.wait_until_exists(before_attempt: logging_proc) end state[:server_id] = server.id info("EC2 instance <#{state[:server_id]}> created.") # See https://github.com/aws/aws-sdk-ruby/issues/859 # Waiting can fail, so we have to retry on that. Retryable.retryable( tries: 10, sleep: lambda { |n| [2**n, 30].min }, on: ::Aws::EC2::Errors::InvalidInstanceIDNotFound ) do |r, _| wait_until_ready(server, state) end info("EC2 instance <#{state[:server_id]}> ready (hostname: #{state[:hostname]}).") instance.transport.connection(state).wait_until_ready attach_network_interface(state) unless config[:elastic_network_interface_id].nil? create_ec2_json(state) if /chef/i.match?(instance.provisioner.name) debug("ec2:create '#{state[:hostname]}'") rescue Exception => e # Clean up the instance and any auto-created security groups or keys on the way out. destroy(state) raise "#{e.} in the specified region #{config[:region]}. Please check this AMI is available in this region." end |
#create_ec2_json(state) ⇒ Object
646 647 648 649 650 651 652 653 654 |
# File 'lib/kitchen/driver/ec2.rb', line 646 def create_ec2_json(state) if windows_os? cmd = "New-Item -Force C:\\chef\\ohai\\hints\\ec2.json -ItemType File" else debug "Using sudo_command='#{sudo_command}' for ohai hints" cmd = "#{sudo_command} mkdir -p /etc/chef/ohai/hints; #{sudo_command} touch /etc/chef/ohai/hints/ec2.json" end instance.transport.connection(state).execute(cmd) end |
#create_key(state) ⇒ void
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
This method returns an undefined value.
Create a temporary SSH key pair for this instance.
816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 |
# File 'lib/kitchen/driver/ec2.rb', line 816 def create_key(state) return if state[:auto_key_id] # Encode a bunch of metadata into the name because that's all we can # set for a key pair. name_parts = [ instance.name.gsub(/\W/, ""), (Etc.getlogin || "nologin").gsub(/\W/, ""), Socket.gethostname.gsub(/\W/, "")[0..20], Time.now.utc.iso8601, Array.new(8) { rand(36).to_s(36) }.join(""), ] # In a perfect world this would generate the key locally and use ImportKey # instead for better security, but given the use case that is very likely # to rapidly exhaust local entropy by creating a lot of keys. So this is # probably fine. If you want very high security, probably don't use this # feature anyway. resp = ec2.client.create_key_pair(key_name: "kitchen-#{name_parts.join("-")}") state[:auto_key_id] = resp.key_name info("Created automatic key pair #{state[:auto_key_id]}") # Write the key out with safe permissions key_path = "#{config[:kitchen_root]}/.kitchen/#{instance.name}.pem" File.open(key_path, File::WRONLY | File::CREAT | File::EXCL, 00600) do |f| f.write(resp.key_material) end # Inject the key into the state to be used by the SSH transport, or for # the Windows password decrypt above in {#fetch_windows_admin_password}. state[:ssh_key] = key_path end |
#create_security_group(state) ⇒ void
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
This method returns an undefined value.
Create a temporary security group for this instance.
747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 |
# File 'lib/kitchen/driver/ec2.rb', line 747 def create_security_group(state) return if state[:auto_security_group_id] # Work out which VPC, if any, we are creating in. vpc_id = if config[:subnet_id] # Get the VPC ID for the subnet. subnets = ec2.client.describe_subnets(filters: [{ name: "subnet-id", values: [config[:subnet_id]] }]).subnets raise "Subnet #{config[:subnet_id]} not found during security group creation" if subnets.empty? subnets.first.vpc_id elsif config[:subnet_filter] filters = [config[:subnet_filter]].flatten r = { filters: [] } filters.each do |subnet_filter| r[:filters] << { name: "tag:#{subnet_filter[:tag]}", values: [subnet_filter[:value]], } end subnets = ec2.client.describe_subnets(r).subnets raise "Subnets with tags '#{filters}' not found during security group creation" if subnets.empty? subnets.first.vpc_id else # Try to check for a default VPC. vpcs = ec2.client.describe_vpcs(filters: [{ name: "isDefault", values: ["true"] }]).vpcs if vpcs.empty? # No default VPC so assume EC2-Classic ¯\_(ツ)_/¯ nil else # I don't actually know if you can have more than one default VPC? vpcs.first.vpc_id end end # Create the SG. params = { group_name: "kitchen-#{Array.new(8) { rand(36).to_s(36) }.join}", description: "Test Kitchen for #{instance.name} by #{Etc.getlogin || "nologin"} on #{Socket.gethostname}", } params[:vpc_id] = vpc_id if vpc_id resp = ec2.client.create_security_group(params) state[:auto_security_group_id] = resp.group_id info("Created automatic security group #{state[:auto_security_group_id]}") debug(" in VPC #{vpc_id || "none"}") # Set up SG rules. ec2.client.( group_id: state[:auto_security_group_id], # Allow SSH and WinRM (both plain and TLS). ip_permissions: [22, 3389, 5985, 5986].map do |port| { ip_protocol: "tcp", from_port: port, to_port: port, ip_ranges: Array(config[:security_group_cidr_ip]).map do |cidr_ip| { cidr_ip: cidr_ip } end, } end ) end |
#default_ami ⇒ Object
343 344 345 346 347 348 349 350 |
# File 'lib/kitchen/driver/ec2.rb', line 343 def default_ami @default_ami ||= begin search_platform = desired_platform || Aws::StandardPlatform.from_platform_string(self, "ubuntu") image_search = config[:image_search] || search_platform.image_search search_platform.find_image(image_search) end end |
#default_instance_type ⇒ Object
316 317 318 319 320 321 322 323 324 325 |
# File 'lib/kitchen/driver/ec2.rb', line 316 def default_instance_type @instance_type ||= if image && image.virtualization_type == "hvm" info("instance_type not specified. Using free tier t2.micro instance ...") "t2.micro" else info("instance_type not specified. Using free tier t1.micro instance since" \ " image is paravirtual (pick an hvm image to use the superior t2.micro!) ...") "t1.micro" end end |
#default_windows_user_data ⇒ Object
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 |
# File 'lib/kitchen/driver/ec2.rb', line 656 def default_windows_user_data base_script = Kitchen::Util.outdent!(<<-EOH) $OSVersion = (get-itemproperty -Path "HKLM:\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion" -Name ProductName).ProductName If($OSVersion.contains('2016') -Or $OSVersion.contains('2019') -Or $OSVersion -eq 'Windows Server Datacenter') { New-Item -ItemType Directory -Force -Path 'C:\\ProgramData\\Amazon\\EC2-Windows\\Launch\\Log' $logfile='C:\\ProgramData\\Amazon\\EC2-Windows\\Launch\\Log\\kitchen-ec2.log' # EC2Launch doesn't init extra disks by default C:\\ProgramData\\Amazon\\EC2-Windows\\Launch\\Scripts\\InitializeDisks.ps1 } Else { New-Item -ItemType Directory -Force -Path 'C:\\Program Files\\Amazon\\Ec2ConfigService\\Logs' $logfile='C:\\Program Files\\Amazon\\Ec2ConfigService\\Logs\\kitchen-ec2.log' } # Logfile fail-safe in case the directory does not exist New-Item $logfile -Type file -Force # Allow script execution Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Force #PS Remoting and & winrm.cmd basic config $enableArgs=@{Force=$true} $command=Get-Command Enable-PSRemoting if($command.Parameters.Keys -contains "skipnetworkprofilecheck"){ $enableArgs.skipnetworkprofilecheck=$true } Enable-PSRemoting @enableArgs & winrm.cmd set winrm/config '@{MaxTimeoutms="1800000"}' >> $logfile & winrm.cmd set winrm/config/winrs '@{MaxMemoryPerShellMB="1024"}' >> $logfile & winrm.cmd set winrm/config/winrs '@{MaxShellsPerUser="50"}' >> $logfile & winrm.cmd set winrm/config/winrs '@{MaxMemoryPerShellMB="1024"}' >> $logfile #Firewall Config & netsh advfirewall firewall set rule name="Windows Remote Management (HTTP-In)" profile=public protocol=tcp localport=5985 remoteip=localsubnet new remoteip=any >> $logfile Set-ItemProperty -Name LocalAccountTokenFilterPolicy -Path HKLM:\\software\\Microsoft\\Windows\\CurrentVersion\\Policies\\system -Value 1 EOH # Preparing custom static admin user if we defined something other than Administrator custom_admin_script = "" if !(instance.transport[:username] =~ /administrator/i) && instance.transport[:password] custom_admin_script = Kitchen::Util.outdent!(<<-EOH) "Disabling Complex Passwords" >> $logfile $seccfg = [IO.Path]::GetTempFileName() & secedit.exe /export /cfg $seccfg >> $logfile (Get-Content $seccfg) | Foreach-Object {$_ -replace "PasswordComplexity\\s*=\\s*1", "PasswordComplexity = 0"} | Set-Content $seccfg & secedit.exe /configure /db $env:windir\\security\\new.sdb /cfg $seccfg /areas SECURITYPOLICY >> $logfile & cp $seccfg "c:\\" & del $seccfg $username="#{instance.transport[:username]}" $password="#{instance.transport[:password]}" "Creating static user: $username" >> $logfile & net.exe user /y /add $username $password >> $logfile "Adding $username to Administrators" >> $logfile & net.exe localgroup Administrators /add $username >> $logfile EOH end # Returning the fully constructed PowerShell script to user_data Kitchen::Util.outdent!(<<-EOH) <powershell> #{base_script} #{custom_admin_script} </powershell> EOH end |
#delete_key(state) ⇒ void
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
This method returns an undefined value.
Clean up a temporary SSH key pair for this instance.
889 890 891 892 893 894 895 896 |
# File 'lib/kitchen/driver/ec2.rb', line 889 def delete_key(state) return unless state[:auto_key_id] info("Removing automatic key pair #{state[:auto_key_id]}") ec2.client.delete_key_pair(key_name: state[:auto_key_id]) state.delete(:auto_key_id) File.unlink("#{config[:kitchen_root]}/.kitchen/#{instance.name}.pem") end |
#delete_security_group(state) ⇒ void
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
This method returns an undefined value.
Clean up a temporary security group for this instance.
876 877 878 879 880 881 882 |
# File 'lib/kitchen/driver/ec2.rb', line 876 def delete_security_group(state) return unless state[:auto_security_group_id] info("Removing automatic security group #{state[:auto_security_group_id]}") ec2.client.delete_security_group(group_id: state[:auto_security_group_id]) state.delete(:auto_security_group_id) end |
#desired_platform ⇒ Object
332 333 334 335 336 337 338 339 340 341 |
# File 'lib/kitchen/driver/ec2.rb', line 332 def desired_platform @desired_platform ||= begin platform = Aws::StandardPlatform.from_platform_string(self, instance.platform.name) if platform debug("platform name #{instance.platform.name} appears to be a standard platform." \ " Searching for #{platform} ...") end platform end end |
#destroy(state) ⇒ Object
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 |
# File 'lib/kitchen/driver/ec2.rb', line 265 def destroy(state) if state[:server_id] server = ec2.get_instance(state[:server_id]) unless server.nil? instance.transport.connection(state).close begin server.terminate rescue ::Aws::EC2::Errors::InvalidInstanceIDNotFound => e warn("Received #{e}, instance was probably already destroyed. Ignoring") end end # If we are going to clean up an automatic security group, we need # to wait for the instance to shut down. This slightly breaks the # subsystem encapsulation, sorry not sorry. if state[:auto_security_group_id] && server && ec2.instance_exists?(state[:server_id]) wait_log = proc do |attempts| c = attempts * config[:retryable_sleep] t = config[:retryable_tries] * config[:retryable_sleep] info "Waited #{c}/#{t}s for instance <#{server.id}> to terminate." end server.wait_until_terminated( max_attempts: config[:retryable_tries], delay: config[:retryable_sleep], before_attempt: wait_log ) end info("EC2 instance <#{state[:server_id]}> destroyed.") state.delete(:server_id) state.delete(:hostname) end # Clean up any auto-created security groups or keys. delete_security_group(state) delete_key(state) end |
#ec2 ⇒ Object
367 368 369 370 371 372 373 374 375 |
# File 'lib/kitchen/driver/ec2.rb', line 367 def ec2 @ec2 ||= Aws::Client.new( config[:region], config[:shared_credentials_profile], config[:http_proxy], config[:retry_limit], config[:ssl_verify_peer] ) end |
#expand_config(conf, key) ⇒ Object
Take one config and expand to multiple configs
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 |
# File 'lib/kitchen/driver/ec2.rb', line 399 def (conf, key) configs = [] if conf[key] && conf[key].is_a?(Array) values = conf[key] values.each do |value| new_config = conf.clone new_config[key] = value configs.push new_config end else configs.push conf end configs end |
#fetch_windows_admin_password(server, state) ⇒ Object
574 575 576 577 578 579 580 581 582 583 584 585 586 587 |
# File 'lib/kitchen/driver/ec2.rb', line 574 def fetch_windows_admin_password(server, state) wait_with_destroy(server, state, "to fetch windows admin password") do |aws_instance| enc = server.client.get_password_data( instance_id: state[:server_id] ).password_data # Password data is blank until password is available !enc.nil? && !enc.empty? end pass = with_request_limit_backoff(state) do server.decrypt_windows_password(File.(state[:ssh_key] || instance.transport[:ssh_key])) end state[:password] = pass info("Retrieved Windows password for instance <#{state[:server_id]}>.") end |
#hostname(server, interface_type = nil) ⇒ Object
Lookup hostname of provided server. If interface_type is provided use that interface to lookup hostname. Otherwise, try ordered list of options.
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 |
# File 'lib/kitchen/driver/ec2.rb', line 622 def hostname(server, interface_type = nil) if interface_type interface_type = INTERFACE_TYPES.fetch(interface_type) do raise Kitchen::UserError, "Invalid interface [#{interface_type}]" end server.send(interface_type) else potential_hostname = nil INTERFACE_TYPES.values.each do |type| potential_hostname ||= server.send(type) # AWS returns an empty string if the dns name isn't populated yet potential_hostname = nil if potential_hostname == "" end potential_hostname end end |
#image ⇒ Object
301 302 303 304 305 306 307 308 309 310 311 312 313 314 |
# File 'lib/kitchen/driver/ec2.rb', line 301 def image return @image if defined?(@image) if config[:image_id] @image = ec2.resource.image(config[:image_id]) show_chosen_image else raise "Neither image_id nor an image_search specified for instance #{instance.name}!" \ " Please specify one or the other." end @image end |
#image_info(image) ⇒ Object
731 732 733 734 735 736 737 738 739 740 |
# File 'lib/kitchen/driver/ec2.rb', line 731 def image_info(image) root_device = image.block_device_mappings .find { |b| b.device_name == image.root_device_name } volume_type = " #{root_device.ebs.volume_type}" if root_device && root_device.ebs " Architecture: #{image.architecture}," \ " Virtualization: #{image.virtualization_type}," \ " Storage: #{image.root_device_type}#{volume_type}," \ " Created: #{image.creation_date}" end |
#instance_generator ⇒ Object
377 378 379 |
# File 'lib/kitchen/driver/ec2.rb', line 377 def instance_generator @instance_generator = Aws::InstanceGenerator.new(config, ec2, instance.logger) end |
#show_chosen_image ⇒ Object
719 720 721 722 723 724 725 726 727 728 729 |
# File 'lib/kitchen/driver/ec2.rb', line 719 def show_chosen_image # Print some debug stuff debug("Image for #{instance.name}: #{image.name}. #{image_info(image)}") if actual_platform info("Detected platform: #{actual_platform.name} version #{actual_platform.version}" \ " on #{actual_platform.architecture}. Instance Type: #{config[:instance_type]}." \ " Default username: #{actual_platform.username} (default).") else debug("No platform detected for #{image.name}.") end end |
#submit_server ⇒ Object
AWS helper for creating the instance
382 383 384 385 386 387 388 389 390 |
# File 'lib/kitchen/driver/ec2.rb', line 382 def submit_server instance_data = instance_generator.ec2_instance_data debug("Creating EC2 instance in region #{config[:region]} with properties:") instance_data.each do |key, value| debug("- #{key} = #{value.inspect}") end ec2.create_instance(instance_data) end |
#submit_spot ⇒ Object
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 |
# File 'lib/kitchen/driver/ec2.rb', line 469 def submit_spot debug("Creating EC2 Spot Instance..") instance_data = instance_generator.ec2_instance_data config_spot_price = config[:spot_price].to_s if %w{ondemand on-demand}.include?(config_spot_price) spot_price = "" else spot_price = config_spot_price end = { # Must use one-time in order to use instance_interruption_behavior=terminate # spot_instance_type: "one-time", # default # Must use instance_interruption_behavior=terminate in order to use block_duration_minutes # instance_interruption_behavior: "terminate", # default } if config[:block_duration_minutes] [:block_duration_minutes] = config[:block_duration_minutes] end unless spot_price == "" # i.e. on-demand [:max_price] = spot_price end instance_data[:instance_market_options] = { market_type: "spot", spot_options: , } # The preferred way to create a spot instance is via request_spot_instances() # However, it does not allow for tagging to occur at creation time. # create_instances() allows creation of tagged spot instances, but does # not retry if the price could not be satisfied immediately. Retryable.retryable( tries: config[:spot_wait] / config[:retryable_sleep], sleep: lambda { |_n| config[:retryable_sleep] }, on: ::Aws::EC2::Errors::SpotMaxPriceTooLow ) do |retries| c = retries * config[:retryable_sleep] t = config[:spot_wait] info "Waited #{c}/#{t}s for spot request to become fulfilled." ec2.create_instance(instance_data) end end |
#submit_spots ⇒ Object
416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 |
# File 'lib/kitchen/driver/ec2.rb', line 416 def submit_spots configs = [config] = [] keys = %i{instance_type} unless config[:subnet_filter] # => Use explicitly specified subnets keys << :subnet_id else # => Enable cascading through matching subnets client = ::Aws::EC2::Client.new(region: config[:region]) filters = [config[:subnet_filter]].flatten r = { filters: [] } filters.each do |subnet_filter| r[:filters] << { name: "tag:#{subnet_filter[:tag]}", values: [subnet_filter[:value]], } end subnets = client.describe_subnets(r).subnets raise "Subnets with tags '#{filters}' not found!" if subnets.empty? configs = subnets.map do |subnet| new_config = config.clone new_config[:subnet_id] = subnet.subnet_id new_config[:subnet_filter] = nil new_config end end keys.each do |key| configs.each do |conf| .push (conf, key) end configs = .flatten = [] end errs = [] configs.each do |conf| @config = conf return submit_spot rescue => e errs.append(e) end raise ["Could not create a spot instance:", errs].flatten.join("\n") end |
#sudo_command ⇒ Object
Returns the sudo command to use or empty string if sudo is not configured
642 643 644 |
# File 'lib/kitchen/driver/ec2.rb', line 642 def sudo_command instance.provisioner[:sudo] ? instance.provisioner[:sudo_command].to_s : "" end |
#update_username(state) ⇒ Object
352 353 354 355 356 357 358 359 360 361 362 363 364 365 |
# File 'lib/kitchen/driver/ec2.rb', line 352 def update_username(state) # BUG: With the following equality condition on username, if the user specifies 'root' # as the transport's username then we will overwrite that value with one from the standard # platform definitions. This seems difficult to handle here as the default username is # provided by the underlying transport classes, and is often non-nil (eg; 'root'), leaving # us no way to distinguish a user-set value from the transport's default. # See https://github.com/test-kitchen/kitchen-ec2/pull/273 if actual_platform && instance.transport[:username] == instance.transport.class.defaults[:username] debug("No SSH username specified: using default username #{actual_platform.username} " \ "for image #{config[:image_id]}, which we detected as #{actual_platform}.") state[:username] = actual_platform.username end end |
#wait_until_ready(server, state) ⇒ Object
Normally we could use ‘server.wait_until_running` but we actually need to check more than just the instance state
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 |
# File 'lib/kitchen/driver/ec2.rb', line 515 def wait_until_ready(server, state) wait_with_destroy(server, state, "to become ready") do |aws_instance| hostname = hostname(aws_instance, config[:interface]) # We aggressively store the hostname so if the process fails here # we still have it, even if it will change later state[:hostname] = hostname # Euca instances often report ready before they have an IP ready = aws_instance.exists? && aws_instance.state.name == "running" && hostname != "0.0.0.0" if ready && ( hostname.nil? || hostname == "" ) debug("Unable to detect hostname using interface_type #{config[:interface]}. Fallback to ordered mapping") state[:hostname] = hostname(aws_instance, nil) end if ready && windows_os? if instance.transport[:username] =~ /administrator/i && instance.transport[:password].nil? # If we're logging into the administrator user and a password isn't # supplied, try to fetch it from the AWS instance fetch_windows_admin_password(server, state) else output = server.console_output.output unless output.nil? output = Base64.decode64(output) debug "Console output: --- \n#{output}" end ready = !!(output =~ /Windows is Ready to use/) end end ready end end |
#wait_with_destroy(server, state, status_msg, &block) ⇒ Object
Poll a block, waiting for it to return true. If it does not succeed within the configured time we destroy the instance to save people money
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 |
# File 'lib/kitchen/driver/ec2.rb', line 551 def wait_with_destroy(server, state, status_msg, &block) wait_log = proc do |attempts| c = attempts * config[:retryable_sleep] t = config[:retryable_tries] * config[:retryable_sleep] info "Waited #{c}/#{t}s for instance <#{state[:server_id]}> #{status_msg}." end begin with_request_limit_backoff(state) do server.wait_until( max_attempts: config[:retryable_tries], delay: config[:retryable_sleep], before_attempt: wait_log, &block ) end rescue ::Aws::Waiters::Errors::WaiterFailed error("Ran out of time waiting for the server with id [#{state[:server_id]}]" \ " #{status_msg}, attempting to destroy it") destroy(state) raise end end |
#with_request_limit_backoff(state) ⇒ Object
589 590 591 592 593 594 595 596 597 598 599 600 601 602 |
# File 'lib/kitchen/driver/ec2.rb', line 589 def with_request_limit_backoff(state) retries = 0 begin yield rescue ::Aws::EC2::Errors::RequestLimitExceeded, ::Aws::Waiters::Errors::UnexpectedError => e raise unless retries < 5 && e..include?("Request limit exceeded") retries += 1 info("Request limit exceeded for instance <#{state[:server_id]}>." \ " Trying again in #{retries**2} seconds.") sleep(retries**2) retry end end |