class Chef::Provisioning::FogDriver::Providers::Scaleway
Public Class Methods
compute_options_for(provider, id, config)
click to toggle source
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 101 def self.compute_options_for(provider, id, config) new_compute_options = {} new_compute_options[:provider] = provider if id && id != "" org, region = id.split(":") new_compute_options[:scaleway_organization] = org new_compute_options[:scaleway_region] = region || "par1" end new_config = { driver_options: { compute_options: new_compute_options } } new_default_compute_options = {} new_defaults = { driver_options: { compute_options: new_default_compute_options }, machine_options: { bootstrap_options: {} } } result = Cheffish::MergedConfig.new(new_config, config, new_defaults) credential = Fog.credentials new_default_compute_options[:scaleway_organization] ||= credential[:scaleway_organization] new_default_compute_options[:scaleway_token] ||= credential[:scaleway_token] id = [result[:driver_options][:compute_options][:scaleway_organization], result[:driver_options][:compute_options][:scaleway_region]].join(":") [result, id] end
Public Instance Methods
attach_ip(server, floating_ip)
click to toggle source
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 156 def attach_ip(server, floating_ip) ip = server.service.ips.get(floating_ip) raise "Requested IP (#{floating_ip}) not found" if ip.nil? if ip.server && (ip.server.identity != server.identity) raise "Requested IP (#{floating_ip}) already attached" end if server.public_ip old_ip = server.public_ip Chef::Log.info "Server #{server.identity} already has IP #{old_ip.address}, removing it" old_ip.server = nil old_ip.save end ip.server = server ip.save server.reload end
attach_ip_from_pool(server, _pool)
click to toggle source
Scaleway
only has one global pool.
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 138 def attach_ip_from_pool(server, _pool) return server if server.public_ip Chef::Log.info "Scaleway has only one IP pool, ignoring pool argument" ip = server.service.ips.all.select { |ip| ip.address.nil? }.first if ip ip.server = server ip.save server.reload else # Allocate a new IP ip = server.service.ips.create ip.server = server ip.save server.reload end end
bootstrap_options_for(action_handler, machine_spec, machine_options)
click to toggle source
Calls superclass method
Chef::Provisioning::FogDriver::Driver#bootstrap_options_for
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 42 def bootstrap_options_for(action_handler, machine_spec, machine_options) opts = super opts[:tags] = opts[:tags].map { |key, value| [key, value].join("=") } # Let's fetch the id of the volumes if the user didn't provide it # Which probably means they were created in chef if opts[:volumes] managed_entry_store = machine_spec.managed_entry_store volumes = Marshal.load(Marshal.dump(opts[:volumes])) volumes.each do |_index, volume| next if volume[:id] volume_spec = managed_entry_store.get(:volume, volume[:name]) unless volume_spec raise "Volume #{volume[:name]} unknown, create it or provide its id" end volume[:id] = volume_spec.reference["id"] end opts[:volumes] = volumes end opts end
converge_floating_ips(action_handler, machine_spec, machine_options, server)
click to toggle source
Calls superclass method
Chef::Provisioning::FogDriver::Driver#converge_floating_ips
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 129 def converge_floating_ips(action_handler, machine_spec, machine_options, server) if server.dynamic_ip_required Chef::Log.info "Dynamic IP allocation has been enabled, not converging IPs" else super end end
convergence_strategy_for(machine_spec, machine_options)
click to toggle source
Calls superclass method
Chef::Provisioning::FogDriver::Driver#convergence_strategy_for
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 36 def convergence_strategy_for(machine_spec, machine_options) machine_options = Cheffish::MergedConfig.new(machine_options, convergence_options: { ohai_hints: { "scaleway" => {} } }) super(machine_spec, machine_options) end
create_volume(action_handler, volume_spec, volume_options)
click to toggle source
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 185 def create_volume(action_handler, volume_spec, volume_options) # Prevent destructive operations on volume_options. clean_volume_options = Marshal.load(Marshal.dump(volume_options)) volume_spec.reference ||= {} volume_spec.reference.update( "driver_url" => driver_url, "driver_version" => FogDriver::VERSION, "creator" => creator, "allocated_at" => Time.now.to_i ) description = ["Creating volume #{volume_spec.name}"] volume_options.each { |k, v| description << " #{k}: #{v.inspect}" } action_handler.report_progress description if action_handler.should_perform_actions clean_volume_options["name"] = volume_spec.name volume = compute.volumes.create(clean_volume_options) volume_spec.reference.update( "id" => volume.id, "volume_type" => volume.volume_type, "size" => volume.size ) volume_spec.save(action_handler) action_handler.performed_action "volume #{volume_spec.name} created as #{volume.id} on #{driver_url}" end end
creator()
click to toggle source
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 32 def creator compute_options[:scaleway_organization] end
destroy_machine(action_handler, machine_spec, machine_options)
click to toggle source
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 65 def destroy_machine(action_handler, machine_spec, machine_options) server = server_for(machine_spec) if server action_handler.perform_action "destroy machine #{machine_spec.name} (#{machine_spec.reference['server_id']} at #{driver_url})" do # Scaleway's API fail if we try to stop/terminate an instance with # certains states if server.state == "running" server.stop server.wait_for { server.state != "running" } end %w{stopping starting}.each do |state| server.wait_for { server.state != state } if server.state == state end if server.state == "stopped" server.destroy else Chef.log.fatal "Server is in an unknown state (#{server.state})" end machine_spec.reference = nil end end strategy = ConvergenceStrategy::NoConverge.new(machine_options[:convergence_options], config) strategy.cleanup_convergence(action_handler, machine_spec) end
destroy_volume(action_handler, volume_spec, _volume_options)
click to toggle source
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 216 def destroy_volume(action_handler, volume_spec, _volume_options) volume = volume_for(volume_spec) if volume && action_handler.should_perform_actions begin msg = "destroyed volume #{volume_spec.name} at #{driver_url}" action_handler.perform_action msg do volume.destroy volume_spec.reference = nil volume_spec.save(action_handler) end rescue Fog::Scaleway::Compute::InvalidRequestError => e Chef::Log.error "Unable to destroy volume #{volume_spec.name} : #{e.message}" end end end
find_floating_ips(server, action_handler)
click to toggle source
Get the public IP if any
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 176 def find_floating_ips(server, action_handler) public_ips = [] Retryable.retryable(RETRYABLE_OPTIONS) do |retries, _exception| action_handler.report_progress "Querying for public IP attached to server #{server.id}, API attempt #{retries + 1}/#{RETRYABLE_OPTIONS[:tries]} ..." public_ips << server.public_ip.address if server.public_ip end public_ips end
stop_machine(action_handler, machine_spec, _machine_options)
click to toggle source
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 91 def stop_machine(action_handler, machine_spec, _machine_options) server = server_for(machine_spec) if server && (server.state == "running") action_handler.perform_action "stop machine #{machine_spec.name} (#{server.id} at #{driver_url})" do server.poweroff(true) server.wait_for { server.state == "stopped" } end end end
volume_for(volume_spec)
click to toggle source
# File lib/chef/provisioning/fog_driver/providers/scaleway.rb, line 233 def volume_for(volume_spec) if volume_spec.reference compute.volumes.get(volume_spec.reference["id"]) end end