class Fog::Compute::Google::Server

Constants

GCE_SCOPE_ALIASES

Public Instance Methods

add_ssh_key(username, key, async = true) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 387
def add_ssh_key(username, key, async = true)
  metadata = generate_ssh_key_metadata(username, key)

  data = service.set_server_metadata(
    identity, zone_name, metadata[:fingerprint], metadata[:items]
  )

  operation = Fog::Compute::Google::Operations
              .new(:service => service)
              .get(data.name, data.zone)
  operation.wait_for { ready? } unless async
  reload
end
addresses() click to toggle source
# File lib/fog/compute/google/models/server.rb, line 226
def addresses
  private_ip_addresses + public_ip_addresses
end
attach_disk(disk, async = true, options = {}) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 230
def attach_disk(disk, async = true, options = {})
  requires :identity, :zone

  if disk.is_a? Disk
    disk_obj = disk.get_attached_disk
  elsif disk.is_a? String
    disk_obj = service.disks.attached_disk_obj(disk, options)
  end

  data = service.attach_disk(identity, zone_name, disk_obj)
  operation = Fog::Compute::Google::Operations
              .new(:service => service)
              .get(data.name, data.zone)
  operation.wait_for { ready? } unless async
  reload
end
destroy(async = true) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 192
def destroy(async = true)
  requires :name, :zone

  data = service.delete_server(name, zone_name)
  operation = Fog::Compute::Google::Operations
              .new(:service => service)
              .get(data.name, data.zone)
  operation.wait_for { ready? } unless async
  operation
end
detach_disk(device_name, async = true) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 247
def detach_disk(device_name, async = true)
  requires :identity, :zone

  data = service.detach_disk(identity, zone, device_name)
  operation = Fog::Compute::Google::Operations
              .new(:service => service)
              .get(data.name, data.zone)
  operation.wait_for { ready? } unless async
  reload
end
generate_ssh_key_metadata(username, key) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 461
def generate_ssh_key_metadata(username, key)
  if metadata.nil?
    self.metadata = Hash.new
  end
  metadata[:items] = [] if metadata[:items].nil?
  metadata_map = Hash[metadata[:items].map { |item| [item[:key], item[:value]] }]

  ssh_keys = metadata_map["ssh-keys"] || metadata_map["sshKeys"] || ""
  ssh_keys += "\n" unless ssh_keys.empty?
  ssh_keys += "#{username}:#{key.strip}"

  metadata_map["ssh-keys"] = ssh_keys
  metadata[:items] = metadata_to_item_list(metadata_map)
  metadata
end
image_name() click to toggle source
# File lib/fog/compute/google/models/server.rb, line 182
def image_name
  boot_disk = disks.first
  unless boot_disk.is_a?(Disk)
    source = boot_disk[:source]
    match = source.match(%r{/zones/(.*)/disks/(.*)$})
    boot_disk = service.disks.get(match[2], match[1])
  end
  boot_disk.source_image.nil? ? nil : boot_disk.source_image
end
map_scopes(scopes) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 406
def map_scopes(scopes)
  return [] if scopes.nil?
  scopes.flat_map do |scope|
    if GCE_SCOPE_ALIASES.key? scope
      # Expand scope alias to list of related scopes
      GCE_SCOPE_ALIASES[scope]
    else
      [scope_url(scope)]
    end
  end
end
metadata_as_h() click to toggle source

Returns metadata items as a Hash. @return [Hash<String, String>] items

# File lib/fog/compute/google/models/server.rb, line 260
def metadata_as_h
  if metadata.nil? || metadata[:items].nil? || metadata[:items].empty?
    return {}
  end

  Hash[metadata[:items].map { |item| [item[:key], item[:value]] }]
end
private_ip_addresses() click to toggle source
# File lib/fog/compute/google/models/server.rb, line 218
def private_ip_addresses
  addresses = []
  if network_interfaces.respond_to? :map
    addresses = network_interfaces.map { |nic| nic[:network_ip] }
  end
  addresses
end
provisioning?() click to toggle source
# File lib/fog/compute/google/models/server.rb, line 375
def provisioning?
  status == PROVISIONING
end
public_ip_addresses() click to toggle source
# File lib/fog/compute/google/models/server.rb, line 203
def public_ip_addresses
  addresses = []
  if network_interfaces.respond_to? :flat_map
    addresses = network_interfaces.flat_map do |nic|
      if nic[:access_configs].respond_to? :each
        nic[:access_configs].select { |config| config[:name] == "External NAT" }
                            .map { |config| config[:nat_ip] }
      else
        []
      end
    end
  end
  addresses
end
ready?() click to toggle source
# File lib/fog/compute/google/models/server.rb, line 379
def ready?
  status == RUNNING
end
reboot(async = true) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 268
def reboot(async = true)
  requires :identity, :zone

  data = service.reset_server(identity, zone_name)
  operation = Fog::Compute::Google::Operations
              .new(:service => service)
              .get(data.name, data.zone)
  operation.wait_for { ready? } unless async
  operation
end
reload() click to toggle source
# File lib/fog/compute/google/models/server.rb, line 401
def reload
  data = service.get_server(name, zone_name).to_h
  merge_attributes(data)
end
save(username: nil, public_key: nil) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 418
def save(username: nil, public_key: nil)
  requires :name
  requires :machine_type
  requires :disks
  requires :zone

  generate_ssh_key_metadata(username, public_key) if public_key

  options = attributes.reject { |_, v| v.nil? }

  if service_accounts && service_accounts[0]
    service_accounts[0][:scopes] = map_scopes(service_accounts[0][:scopes])
    options[:service_accounts] = service_accounts
  end

  if attributes[:external_ip]
    if options[:network_interfaces].nil? || options[:network_interfaces].empty?
      options[:network_interfaces] = [
        {
          :network => "global/networks/#{GOOGLE_COMPUTE_DEFAULT_NETWORK}"
        }
      ]
    end

    # Add external IP as default access config if given
    options[:network_interfaces][0][:access_configs] = [
      {
        :name => "External NAT",
        :type => "ONE_TO_ONE_NAT",
        :nat_ip => attributes[:external_ip]
      }
    ]
  end

  data = service.insert_server(name, zone_name, options)

  operation = Fog::Compute::Google::Operations
              .new(:service => service)
              .get(data.name, data.zone)
  operation.wait_for { !pending? }
  reload
end
serial_port_output() click to toggle source
# File lib/fog/compute/google/models/server.rb, line 301
def serial_port_output
  requires :identity, :zone

  service.get_server_serial_port_output(identity, zone_name).to_h[:contents]
end
set_disk_auto_delete(auto_delete, device_name = nil, async = true) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 307
def set_disk_auto_delete(auto_delete, device_name = nil, async = true)
  requires :identity, :zone

  if device_name.nil? && disks.count > 1
    raise ArgumentError.new("Device name is required if multiple disks are attached")
  end

  device_name ||= disks.first[:device_name]
  data = service.set_server_disk_auto_delete(
    identity, zone_name, auto_delete, device_name
  )

  operation = Fog::Compute::Google::Operations
              .new(:service => service)
              .get(data.name, data.zone)
  operation.wait_for { ready? } unless async
  reload
end
set_metadata(new_metadata = {}, async = true) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 345
def set_metadata(new_metadata = {}, async = true)
  requires :identity, :zone

  if new_metadata[:items] && new_metadata[:items].is_a?(Hash)
    new_metadata[:items] = new_metadata[:items].map { |k, v| { :key => k, :value => v } }
  end

  data = service.set_server_metadata(
    identity, zone_name, metadata[:fingerprint], new_metadata
  )
  operation = Fog::Compute::Google::Operations
              .new(:service => service)
              .get(data.name, data.zone)
  operation.wait_for { ready? } unless async
  reload
end
set_scheduling(async = true, on_host_maintenance: nil, automatic_restart: nil, preemptible: nil) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 326
def set_scheduling(async = true,
                   on_host_maintenance: nil,
                   automatic_restart: nil,
                   preemptible: nil)
  requires :identity, :zone
  data = service.set_server_scheduling(
    identity, zone_name,
    :on_host_maintenance => on_host_maintenance,
    :automatic_restart => automatic_restart,
    :preemptible => preemptible
  )

  operation = Fog::Compute::Google::Operations
              .new(:service => service)
              .get(data.name, data.zone)
  operation.wait_for { ready? } unless async
  reload
end
set_tags(new_tags = [], async = true) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 362
def set_tags(new_tags = [], async = true)
  requires :identity, :zone

  data = service.set_server_tags(
    identity, zone_name, tags[:fingerprint], new_tags
  )
  operation = Fog::Compute::Google::Operations
              .new(:service => service)
              .get(data.name, data.zone)
  operation.wait_for { ready? } unless async
  reload
end
start(async = true) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 279
def start(async = true)
  requires :identity, :zone

  data = service.start_server(identity, zone_name)
  operation = Fog::Compute::Google::Operations
              .new(:service => service)
              .get(data.name, data.zone)
  operation.wait_for { ready? } unless async
  operation
end
stop(async = true) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 290
def stop(async = true)
  requires :identity, :zone

  data = service.stop_server(identity, zone_name)
  operation = Fog::Compute::Google::Operations
              .new(:service => service)
              .get(data.name, data.zone)
  operation.wait_for { ready? } unless async
  operation
end
zone_name() click to toggle source
# File lib/fog/compute/google/models/server.rb, line 383
def zone_name
  zone.nil? ? nil : zone.split("/")[-1]
end

Private Instance Methods

metadata_to_item_list(metadata) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 479
def metadata_to_item_list(metadata)
  metadata.map { |k, v| { :key => k, :value => v } }
end
scope_url(scope) click to toggle source
# File lib/fog/compute/google/models/server.rb, line 483
def scope_url(scope)
  if scope.start_with?("https://")
    scope
  else
    "https://www.googleapis.com/auth/#{scope}"
  end
end