In Files

Parent

Methods

Class/Module Index [+]

Quicksearch

Fog::Compute::Google::Real

Attributes

api_url[R]
client[RW]
compute[R]

Public Class Methods

new(options) click to toggle source
# File lib/fog/google/compute.rb, line 854
def initialize(options)
  # NOTE: loaded here to avoid requiring this as a core Fog dependency
  begin
    require 'google/api_client'
  rescue LoadError => error
    Fog::Logger.warning("Please install the google-api-client gem before using this provider.")
    raise error
  end
  shared_initialize(options)

  if !options[:google_client].nil?
    @client = options[:google_client]
  end

  if @client.nil?
    if !options[:google_key_location].nil?
      google_key = File.expand_path(options[:google_key_location])
    elsif !options[:google_key_string].nil?
      google_key = options[:google_key_string]
    end

    if !options[:google_client_email].nil? and !google_key.nil?
      @client = self.new_pk12_google_client(
        options[:google_client_email],
        google_key,
        options[:app_name],
        options[:app_verion])
    else
      Fog::Logger.debug("Fog::Compute::Google.client has not been initialized nor are the :google_client_email and :google_key_location or :google_key_string options set, so we can not create one for you.")
      raise ArgumentError.new("No Google API Client has been initialized.")
    end
  end

  # We want to always mention we're using Fog.
  if @client.user_agent.nil? or @client.user_agent.empty?
    @client.user_agent = ""
  elsif !@client.user_agent.include? "fog"
    @client.user_agent += "fog/#{Fog::VERSION}"
  end

  @compute = @client.discovered_api('compute', api_version)
end

Public Instance Methods

add_server_access_config(identity, zone, nic, options = {}) click to toggle source
# File lib/fog/google/requests/compute/add_server_access_config.rb, line 11
def add_server_access_config(identity, zone, nic, options = {})
  api_method = @compute.instances.add_access_config
  parameters = {
    'project'  => @project,
    'instance' => identity,
    'zone'     => zone.split('/')[-1],
    'networkInterface' => nic,
  }

  body_object = {
    'type' => 'ONE_TO_ONE_NAT',
  }

  body_object['name'] = options[:name] ? options[:name] : 'External NAT'
  body_object['natIP'] = options[:address] if options[:address]

  result = self.build_result(api_method, parameters, body_object)
  response = self.build_response(result)
end
add_target_pool_health_checks(target_pool, health_checks) click to toggle source
# File lib/fog/google/requests/compute/add_target_pool_health_checks.rb, line 11
def add_target_pool_health_checks(target_pool, health_checks)
  api_method = @compute.target_pools.add_health_check
  parameters = {
    'project' => @project,
    'targetPool' => target_pool.name,
    'region' => target_pool.region.split('/')[-1]
  }
  body = {
    'healthChecks' => health_checks.map { |i| { 'healthCheck' => i } }
  }

  result = self.build_result(api_method, parameters, body_object=body)
  self.build_response(result)
end
add_target_pool_instances(target_pool, instances) click to toggle source
# File lib/fog/google/requests/compute/add_target_pool_instances.rb, line 11
def add_target_pool_instances(target_pool, instances)
  api_method = @compute.target_pools.add_instance
  parameters = {
    'project' => @project,
    'targetPool' => target_pool.name,
    'region' => target_pool.region.split('/')[-1]
  }
  body = {
    'instances' => instances.map { |i| { 'instance' => i } }
  }

  result = self.build_result(api_method, parameters, body_object=body)
  self.build_response(result)
end
attach_disk(instance, zone, source, options = {}) click to toggle source
# File lib/fog/google/requests/compute/attach_disk.rb, line 11
def attach_disk(instance, zone, source, options = {})
  api_method = @compute.instances.attach_disk
  parameters = {
    'project' => @project,
    'instance' => instance,
    'zone' => zone.split('/')[-1],
  }

  writable = options.delete(:writable)
  body_object = {
    'type' =>       'PERSISTENT',
    'source' =>     source,
    'mode' =>       writable ? 'READ_WRITE' : 'READ_ONLY',
    'deviceName' => options.delete(:deviceName),
    'boot' =>       options.delete(:boot),
    'autoDelete' => options.delete(:autoDelete),
  }

  result = self.build_result(api_method, parameters, body_object)
  response = self.build_response(result)
end
build_response(result) click to toggle source

result = Google::APIClient::Result returns Excon::Response

# File lib/fog/google/compute.rb, line 958
def build_response(result)
  build_excon_response(result.body.nil? || result.body.empty? ? nil : Fog::JSON.decode(result.body), result.status)
end
build_result(api_method, parameters, body_object=nil) click to toggle source
# File lib/fog/google/compute.rb, line 941
def build_result(api_method, parameters, body_object=nil)
  if body_object
    result = @client.execute(
      :api_method => api_method,
      :parameters => parameters,
      :body_object => body_object
    )
  else
    result = @client.execute(
      :api_method => api_method,
      :parameters => parameters
    )
  end
end
delete_address(address_name, region_name) click to toggle source
# File lib/fog/google/requests/compute/delete_address.rb, line 11
def delete_address(address_name, region_name)
  api_method = @compute.addresses.delete
  parameters = {
    'project' => @project,
    'address' => address_name,
    'region' => region_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_disk(disk_name, zone_name) click to toggle source
# File lib/fog/google/requests/compute/delete_disk.rb, line 31
def delete_disk(disk_name, zone_name)
  if zone_name.start_with? 'http'
    zone_name = zone_name.split('/')[-1]
  end

  api_method = @compute.disks.delete
  parameters = {
    'project' => @project,
    'disk' => disk_name,
    'zone' => zone_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_firewall(firewall_name) click to toggle source
# File lib/fog/google/requests/compute/delete_firewall.rb, line 11
def delete_firewall(firewall_name)
  api_method = @compute.firewalls.delete
  parameters = {
    'project' => @project,
    'firewall' => firewall_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_forwarding_rule(forwarding_rule_name, region_name) click to toggle source

developers.google.com/compute/docs/reference/latest/regionOperations

# File lib/fog/google/requests/compute/delete_forwarding_rule.rb, line 13
def delete_forwarding_rule(forwarding_rule_name, region_name)
  if region_name.start_with? 'http'
    region_name = region_name.split('/')[-1]
  end

  api_method = @compute.forwarding_rules.delete
  parameters = {
    'project' => @project,
    'forwardingRule' => forwarding_rule_name,
    'region' => region_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_global_operation(operation) click to toggle source

developers.google.com/compute/docs/reference/latest/globalOperations

# File lib/fog/google/requests/compute/delete_global_operation.rb, line 13
def delete_global_operation(operation)
  api_method = @compute.global_operations.delete
  parameters = {
    'project' => @project,
    'operation' => operation
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_http_health_check(name) click to toggle source
# File lib/fog/google/requests/compute/delete_http_health_check.rb, line 11
def delete_http_health_check(name)
  api_method = @compute.http_health_checks.delete
  parameters = {
    'project' => @project,
    'httpHealthCheck' => name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_image(image_name) click to toggle source
# File lib/fog/google/requests/compute/delete_image.rb, line 11
def delete_image(image_name)
  api_method = @compute.images.delete
  parameters = {
    'project' => @project,
    'image' => image_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_network(network_name) click to toggle source
# File lib/fog/google/requests/compute/delete_network.rb, line 11
def delete_network(network_name)
  api_method = @compute.networks.delete
  parameters = {
    'project' => @project,
    'network' => network_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_region_operation(region_name, operation) click to toggle source

developers.google.com/compute/docs/reference/latest/regionOperations

# File lib/fog/google/requests/compute/delete_region_operation.rb, line 13
def delete_region_operation(region_name, operation)
  if region_name.start_with? 'http'
    region_name = region_name.split('/')[-1]
  end
  api_method = @compute.region_operations.delete
  parameters = {
    'project' => @project,
    'region' => region_name,
    'operation' => operation
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_route(identity) click to toggle source
# File lib/fog/google/requests/compute/delete_route.rb, line 11
def delete_route(identity)
  api_method = @compute.routes.delete
  parameters = {
    'project' => @project,
    'route' => identity,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_server(server_name, zone_name=nil) click to toggle source
# File lib/fog/google/requests/compute/delete_server.rb, line 55
def delete_server(server_name, zone_name=nil)
  zone_name = find_zone(zone_name)
  api_method = @compute.instances.delete
  parameters = {
    'project' => @project,
    'zone' => zone_name,
    'instance' => server_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_server_access_config(identity, zone, nic, options = {}) click to toggle source
# File lib/fog/google/requests/compute/delete_server_access_config.rb, line 11
def delete_server_access_config(identity, zone, nic, options = {})
  api_method = @compute.instances.delete_access_config
  parameters = {
    'project'  => @project,
    'instance' => identity,
    'zone'     => zone.split('/')[-1],
    'networkInterface' => nic,
    'accessConfig'     => options[:access_config].nil? ? 'External NAT' : options[:access_config],
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_snapshot(snapshot_name) click to toggle source
# File lib/fog/google/requests/compute/delete_snapshot.rb, line 11
def delete_snapshot(snapshot_name)
  api_method = @compute.snapshots.delete
  parameters = {
    'project' => @project,
    'snapshot' => snapshot_name,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_target_pool(target_pool_name, region_name) click to toggle source

developers.google.com/compute/docs/reference/latest/regionOperations

# File lib/fog/google/requests/compute/delete_target_pool.rb, line 13
def delete_target_pool(target_pool_name, region_name)
  if region_name.start_with? 'http'
    region_name = region_name.split('/')[-1]
  end

  api_method = @compute.target_pools.delete
  parameters = {
    'project' => @project,
    'targetPool' => target_pool_name,
    'region' => region_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
delete_zone_operation(zone_name, operation) click to toggle source

developers.google.com/compute/docs/reference/latest/zoneOperations

# File lib/fog/google/requests/compute/delete_zone_operation.rb, line 13
def delete_zone_operation(zone_name, operation)
  if zone_name.start_with? 'http'
    zone_name = zone_name.split('/')[-1]
  end
  api_method = @compute.zone_operations.delete
  parameters = {
    'project' => @project,
    'zone' => zone_name,
    'operation' => operation
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
detach_disk(instance, zone, deviceName) click to toggle source
# File lib/fog/google/requests/compute/detach_disk.rb, line 11
def detach_disk(instance, zone, deviceName)
  api_method = @compute.instances.detach_disk
  parameters = {
    'project' => @project,
    'instance' => instance,
    'zone' => zone.split('/')[-1],
    'deviceName' => deviceName
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
format_metadata(metadata) click to toggle source
# File lib/fog/google/requests/compute/insert_server.rb, line 113
def format_metadata(metadata)
  { "items" => metadata.map {|k,v| {"key" => k, "value" => v}} }
end
get_address(address_name, region_name) click to toggle source
# File lib/fog/google/requests/compute/get_address.rb, line 11
def get_address(address_name, region_name)
  api_method = @compute.addresses.get
  parameters = {
    'project' => @project,
    'address' => address_name,
    'region' => region_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_disk(disk_name, zone_name) click to toggle source
# File lib/fog/google/requests/compute/get_disk.rb, line 35
def get_disk(disk_name, zone_name)
  if zone_name.start_with? 'http'
    zone_name = zone_name.split('/')[-1]
  end

  api_method = @compute.disks.get
  parameters = {
    'project' => @project,
    'disk' => disk_name,
    'zone' => zone_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_disk_type(identity, zone) click to toggle source
# File lib/fog/google/requests/compute/get_disk_type.rb, line 29
def get_disk_type(identity, zone)
  api_method = @compute.disk_types.get
  parameters = {
    'project'  => @project,
    'zone'     => zone.split('/')[-1],
    'diskType' => identity,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_firewall(firewall_name) click to toggle source
# File lib/fog/google/requests/compute/get_firewall.rb, line 11
def get_firewall(firewall_name)
  api_method = @compute.firewalls.get
  parameters = {
    'project' => @project,
    'firewall' => firewall_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_forwarding_rule(forwarding_rule_name, region_name) click to toggle source
# File lib/fog/google/requests/compute/get_forwarding_rule.rb, line 11
def get_forwarding_rule(forwarding_rule_name, region_name)
  if region_name.start_with? 'http'
    region_name = region_name.split('/')[-1]
  end

  api_method = @compute.forwarding_rules.get
  parameters = {
    'project' => @project,
    'forwardingRule' => forwarding_rule_name,
    'region' => region_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_global_operation(operation) click to toggle source

developers.google.com/compute/docs/reference/latest/globalOperations

# File lib/fog/google/requests/compute/get_global_operation.rb, line 13
def get_global_operation(operation)
  api_method = @compute.global_operations.get
  parameters = {
    'project' => @project,
    'operation' => operation
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_http_health_check(name) click to toggle source
# File lib/fog/google/requests/compute/get_http_health_check.rb, line 11
def get_http_health_check(name)
  api_method = @compute.http_health_checks.get
  parameters = {
    'project' => @project,
    'httpHealthCheck' => name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_image(image_name, project=@project) click to toggle source
# File lib/fog/google/requests/compute/get_image.rb, line 24
def get_image(image_name, project=@project)
  api_method = @compute.images.get
  parameters = {
    'image' => image_name,
    'project' => project,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_machine_type(machine_type_name, zone_name = nil) click to toggle source
# File lib/fog/google/requests/compute/get_machine_type.rb, line 26
def get_machine_type(machine_type_name, zone_name = nil)
  zone_name = list_zones.body['items'].first['name'] if zone_name.nil?
  if zone_name.start_with? 'http'
    zone_name = zone_name.split('/')[-1]
  end
  api_method = @compute.machine_types.get
  parameters = {
    'zone' => zone_name,
    'project' => @project,
    'machineType' => machine_type_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_network(network_name) click to toggle source
# File lib/fog/google/requests/compute/get_network.rb, line 11
def get_network(network_name)
  api_method = @compute.networks.get
  parameters = {
    'project' => @project,
    'network' => network_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_project(identity) click to toggle source
# File lib/fog/google/requests/compute/get_project.rb, line 11
def get_project(identity)
  api_method = @compute.projects.get
  parameters = {
    :project => identity,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_region(identity) click to toggle source
# File lib/fog/google/requests/compute/get_region.rb, line 15
def get_region(identity)
  api_method = @compute.regions.get
  parameters = {
    'project' => @project,
    'region' => identity.split('/')[-1],
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_region_operation(region_name, operation) click to toggle source

developers.google.com/compute/docs/reference/latest/regionOperations

# File lib/fog/google/requests/compute/get_region_operation.rb, line 13
def get_region_operation(region_name, operation)
  if region_name.start_with? 'http'
    region_name = region_name.split('/')[-1]
  end

  api_method = @compute.region_operations.get
  parameters = {
    'project' => @project,
    'region' => region_name,
    'operation' => operation
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_route(identity) click to toggle source
# File lib/fog/google/requests/compute/get_route.rb, line 11
def get_route(identity)
  api_method = @compute.routes.get
  parameters = {
    'project' => @project,
    'route' => identity,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_server(server_name, zone_name) click to toggle source
# File lib/fog/google/requests/compute/get_server.rb, line 56
def get_server(server_name, zone_name)
  if zone_name.is_a? Excon::Response
    zone = zone_name.body["name"]
  else
    zone = zone_name
  end

  api_method = @compute.instances.get
  parameters = {
    'project' => @project,
    'zone' => zone,
    'instance' => server_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_server_serial_port_output(identity, zone) click to toggle source
# File lib/fog/google/requests/compute/get_server_serial_port_output.rb, line 11
def get_server_serial_port_output(identity, zone)
  api_method = @compute.instances.get_serial_port_output
  parameters = {
    'project'  => @project,
    'instance' => identity,
    'zone'     => zone.split('/')[-1],
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_snapshot(snap_name, project=@project) click to toggle source
# File lib/fog/google/requests/compute/get_snapshot.rb, line 11
def get_snapshot(snap_name, project=@project)
  if snap_name.nil?
    raise ArgumentError.new "snap_name must not be nil."
  end

  api_method = @compute.snapshots.get
  parameters = {
    'snapshot' => snap_name,
    'project'  => project,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_target_pool(target_pool_name, region_name) click to toggle source
# File lib/fog/google/requests/compute/get_target_pool.rb, line 11
def get_target_pool(target_pool_name, region_name)
  if region_name.start_with? 'http'
    region_name = region_name.split('/')[-1]
  end

  api_method = @compute.target_pools.get
  parameters = {
    'project' => @project,
    'targetPool' => target_pool_name,
    'region' => region_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_target_pool_health(target_pool) click to toggle source
# File lib/fog/google/requests/compute/get_target_pool_health.rb, line 11
def get_target_pool_health(target_pool)
  api_method = @compute.target_pools.get_health
  parameters = {
    'project' => @project,
    'targetPool' => target_pool.name,
    'region' => target_pool.region.split('/')[-1]
  }

  health_results = target_pool.instances.map do |instance|
    body = { 'instance' => instance }
    resp = build_response(build_result(api_method, parameters, body_object=body))
    [instance, resp.data[:body]['healthStatus']]
  end
  Hash[health_results]
end
get_zone(zone_name) click to toggle source
# File lib/fog/google/requests/compute/get_zone.rb, line 24
def get_zone(zone_name)
  api_method = @compute.zones.get
  parameters = {
    'project' => @project,
    'zone' => zone_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
get_zone_operation(zone_name, operation) click to toggle source

developers.google.com/compute/docs/reference/latest/zoneOperations

# File lib/fog/google/requests/compute/get_zone_operation.rb, line 38
def get_zone_operation(zone_name, operation)
  if zone_name.start_with? 'http'
    zone_name = zone_name.split('/')[-1]
  end

  api_method = @compute.zone_operations.get
  parameters = {
    'project' => @project,
    'zone' => zone_name,
    'operation' => operation
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
handle_disks(options) click to toggle source
# File lib/fog/google/requests/compute/insert_server.rb, line 98
def handle_disks(options)
  disks = []
  # An array of persistent disks. You must supply a boot disk as the first disk in
  # this array and mark it as a boot disk using the disks[].boot property.
  options.delete('disks').each do |disk|
    if disk.is_a? Disk
      disks << disk.get_object
    else
      disks << disk
    end
  end
  disks.first['boot'] = true
  disks
end
insert_address(address_name, region_name, options = {}) click to toggle source
# File lib/fog/google/requests/compute/insert_address.rb, line 11
def insert_address(address_name, region_name, options = {})
  api_method = @compute.addresses.insert
  parameters = {
    'project' => @project,
    'region' => region_name,
  }
  body_object = { 'name' => address_name }
  body_object['description'] = options[:description] if options[:description]

  result = self.build_result(api_method, parameters, body_object)
  response = self.build_response(result)
end
insert_disk(disk_name, zone_name, image_name=nil, opts={}) click to toggle source
# File lib/fog/google/requests/compute/insert_disk.rb, line 68
def insert_disk(disk_name, zone_name, image_name=nil, opts={})
  api_method = @compute.disks.insert
  parameters = {
    'project' => @project,
    'zone' => zone_name
  }

  if image_name
    # New disk from image
    image = images.get(image_name)
    raise ArgumentError.new("Invalid image specified: #{image_name}") unless image
    @image_url = @api_url + image.resource_url
    parameters['sourceImage'] = @image_url
  end

  body_object = { 'name' => disk_name }
  body_object['type'] = opts.delete('type')

  # According to Google docs, if image name is not present, only one of
  # sizeGb or sourceSnapshot need to be present, one will create blank
  # disk of desired size, other will create disk from snapshot
  if image_name.nil?
    if opts.key?('sourceSnapshot')
      # New disk from snapshot
      snap = snapshots.get(opts.delete('sourceSnapshot'))
      raise ArgumentError.new('Invalid source snapshot') unless snap
      body_object['sourceSnapshot'] = @api_url + snap.resource_url
    elsif opts.key?('sizeGb')
      # New blank disk
      body_object['sizeGb'] = opts.delete('sizeGb')
    else
      raise ArgumentError.new('Must specify image OR snapshot OR '                                       'disk size when creating a disk.')
    end

  end

  # Merge in any remaining options (only 'description' should remain)
  body_object.merge!(opts)

  result = self.build_result(api_method, parameters,
                             body_object)
  response = self.build_response(result)
end
insert_firewall(firewall_name, allowed, network = @default_network, options = {}) click to toggle source
# File lib/fog/google/requests/compute/insert_firewall.rb, line 11
def insert_firewall(firewall_name, allowed, network = @default_network, options = {})
  unless network.start_with? 'http'
    network = "#{@api_url}#{@project}/global/networks/#{network}"
  end

  api_method = @compute.firewalls.insert
  parameters = {
    'project' => @project,
  }
  body_object = {
    "name" => firewall_name,
    "network" => network,
    "allowed" => allowed,
  }
  unless options[:description].nil?
    body_object["description"] = options[:description]
  end
  unless options[:source_ranges].nil? || options[:source_ranges].empty?
    body_object["sourceRanges"] = options[:source_ranges]
  end
  unless options[:source_tags].nil? || options[:source_tags].empty?
    body_object["sourceTags"] = options[:source_tags]
  end
  unless options[:target_tags].nil? || options[:target_tags].empty?
    body_object["targetTags"] = options[:target_tags]
  end

  result = self.build_result(api_method, parameters, body_object)
  response = self.build_response(result)
end
insert_forwarding_rule(forwarding_rule_name, region_name, opts = {}) click to toggle source
# File lib/fog/google/requests/compute/insert_forwarding_rule.rb, line 11
def insert_forwarding_rule(forwarding_rule_name, region_name, opts = {})
  api_method = @compute.forwarding_rules.insert
  parameters = {
    'project' => @project,
    'region' => region_name
  }
  body_object = { 'name' => forwarding_rule_name }
  body_object.merge!(opts)

  result = self.build_result(api_method, parameters,
                             body_object=body_object)
  response = self.build_response(result)
end
insert_http_health_check(name, opts={}) click to toggle source
# File lib/fog/google/requests/compute/insert_http_health_check.rb, line 11
def insert_http_health_check(name, opts={})
  api_method = @compute.http_health_checks.insert
  parameters = {
    'project' => @project
  }

  body_object = { 'name' => name }
  body_object.merge!(opts)

  result = self.build_result(api_method, parameters, body_object)
  response = self.build_response(result)
end
insert_image(image_name, options={}) click to toggle source
# File lib/fog/google/requests/compute/insert_image.rb, line 11
def insert_image(image_name, options={})
  api_method = @compute.images.insert

  parameters = {
    'project' => @project,
  }

  body_object = {
    'sourceType'      => 'RAW',
    'name'            => image_name,
    'rawDisk'         => { 'source' => options.delete('rawDisk') }
  }

  # Merge in the remaining params (only 'description' should remain)
  body_object.merge!(options)

  result = self.build_result(api_method,
                             parameters,
                             body_object=body_object)
  response = self.build_response(result)
end
insert_network(network_name, ip_range, options = {}) click to toggle source
# File lib/fog/google/requests/compute/insert_network.rb, line 11
def insert_network(network_name, ip_range, options = {})
  api_method = @compute.networks.insert
  parameters = {
    'project' => @project,
  }
  body_object = {
    'name' => network_name,
    'IPv4Range' => ip_range
  }

  body_object['description'] = options[:description] if options[:description]
  body_object['gatewayIPv4'] = options[:gateway_ipv4] if options[:gateway_ipv4]

  result = self.build_result(api_method, parameters, body_object)
  response = self.build_response(result)
end
insert_route(name, network, dest_range, priority, options = {}) click to toggle source
# File lib/fog/google/requests/compute/insert_route.rb, line 11
def insert_route(name, network, dest_range, priority, options = {})
  api_method = @compute.routes.insert
  parameters = {
    'project' => @project,
  }
  body_object = {
    'name' => name,
    'network' => network,
    'destRange' => dest_range,
    'priority' => priority,
  }
  body_object['description'] = options[:description] if options[:description]
  unless options[:tags].nil? || options[:tags].empty?
    body_object['tags'] = options[:tags]
  end
  body_object['nextHopInstance'] = options[:next_hop_instance] if options[:next_hop_instance]
  body_object['nextHopGateway'] = options[:next_hop_gateway] if options[:next_hop_gateway]
  body_object['nextHopIp'] = options[:next_hop_ip] if options[:next_hop_ip]

  result = self.build_result(api_method, parameters, body_object)
  response = self.build_response(result)
end
insert_server(server_name, zone_name, options={}, *deprecated_args) click to toggle source
# File lib/fog/google/requests/compute/insert_server.rb, line 117
def insert_server(server_name, zone_name, options={}, *deprecated_args)
  if deprecated_args.length > 0 or not options.is_a? Hash
    raise ArgumentError.new 'Too many parameters specified. This may be the cause of code written for an outdated'                 ' version of fog. Usage: server_name, zone_name, [options]'
  end
  api_method = @compute.instances.insert
  parameters = {
      'project' => @project,
      'zone' => zone_name,
  }
  body_object = {:name => server_name}

  body_object['machineType'] = @api_url + @project + "/zones/#{zone_name}/machineTypes/#{options.delete 'machineType'}"
  network = nil
  if options.key? 'network'
    network = options.delete 'network'
  elsif @default_network
    network = @default_network
  end

  # ExternalIP is default value for server creation
  access_config = {'type' => 'ONE_TO_ONE_NAT', 'name' => 'External NAT'}
  # leave natIP undefined to use an IP from a shared ephemeral IP address pool
  if options.key? 'externalIp'
    access_config['natIP'] = options.delete 'externalIp'
    # If set to 'false', that would mean user does no want to allocate an external IP
    access_config = nil if access_config['natIP'] == false
  end

  networkInterfaces = []
  if ! network.nil?
    networkInterface = { 'network' => @api_url + @project + "/global/networks/#{network}" }
    networkInterface['accessConfigs'] = [access_config] if access_config
    networkInterfaces <<  networkInterface
  end

  scheduling = {
    'automaticRestart' => false,
    'onHostMaintenance' => "MIGRATE"
  }
  if options.key? 'auto_restart'
    scheduling['automaticRestart'] = options.delete 'auto_restart'
    scheduling['automaticRestart'] = scheduling['automaticRestart'].class == TrueClass
  end
  if options.key? 'on_host_maintenance'
    ohm = options.delete 'on_host_maintenance'
    scheduling['onHostMaintenance'] = (ohm.respond_to?("upcase") &&
            ohm.upcase == "MIGRATE" && "MIGRATE") || "TERMINATE"
  end
  body_object['scheduling'] = scheduling

  # @see https://developers.google.com/compute/docs/networking#canipforward
  if options.key? 'can_ip_forward'
    body_object['canIpForward'] = options.delete 'can_ip_forward'
  end

  # TODO: add other networks
  body_object['networkInterfaces'] = networkInterfaces

  if options['disks'].nil? or options['disks'].empty?
    raise ArgumentError.new "Empty value for field 'disks'. Boot disk must be specified"
  end
  body_object['disks'] = handle_disks(options)

  options['metadata'] = format_metadata options['metadata'] if options['metadata']

  body_object['tags'] = { 'items' => options.delete('tags') } if options['tags']

  body_object.merge!(options) # Adds in all remaining options that weren't explicitly handled.

  result = self.build_result(api_method, parameters,
                             body_object=body_object)
  response = self.build_response(result)
end
insert_snapshot(disk_name, zone_name, project=@project, opts={}) click to toggle source
# File lib/fog/google/requests/compute/insert_snapshot.rb, line 11
def insert_snapshot(disk_name, zone_name, project=@project, opts={})
  # This is unfortunate, since we might be called from 2 contexts
  # 1. disk.snapshot <-- here validation of disk_name is not needed
  # 2. snapshot.create <-- here we must validate the disk_name
  #
  # Validation would involve 'get'ing the disk by that name. This is
  # redundant (and expensive) for case (1) which is likely the common
  # codepath. So we won't do it.

  api_method = @compute.disks.create_snapshot

  parameters = {
    'disk'    => disk_name,
    'zone'    => zone_name,
    'project' => @project,
  }

  snap_name = opts.delete('name')
  raise ArgumentError.new('Must specify snapshot name') unless snap_name
  body_object = { 'name' => snap_name }

  # Merge in any remaining options (description)
  body_object.merge!(opts)

  result = self.build_result(api_method, parameters,
                             body_object)
  response = self.build_response(result)
end
insert_target_pool(target_pool_name, region_name, opts = {}) click to toggle source
# File lib/fog/google/requests/compute/insert_target_pool.rb, line 11
def insert_target_pool(target_pool_name, region_name, opts = {})
  api_method = @compute.target_pools.insert
  parameters = {
    'project' => @project,
    'region' => region_name
  }
  body_object = { 'name' => target_pool_name }
  body_object.merge!(opts)

  result = self.build_result(api_method, parameters,
                             body_object=body_object)
  response = self.build_response(result)
end
list_addresses(region_name) click to toggle source
# File lib/fog/google/requests/compute/list_addresses.rb, line 11
def list_addresses(region_name)
  api_method = @compute.addresses.list
  parameters = {
    'project' => @project,
    'region' => region_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_aggregated_addresses(options = {}) click to toggle source
# File lib/fog/google/requests/compute/list_aggregated_addresses.rb, line 11
def list_aggregated_addresses(options = {})
  api_method = @compute.addresses.aggregated_list
  parameters = {
    'project' => @project,
  }
  parameters['filter'] = options[:filter] if options[:filter]

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_aggregated_disk_types(options = {}) click to toggle source
# File lib/fog/google/requests/compute/list_aggregated_disk_types.rb, line 28
def list_aggregated_disk_types(options = {})
  api_method = @compute.disk_types.aggregated_list
  parameters = {
    'project' => @project,
  }
  parameters['filter'] = options[:filter] if options[:filter]

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_aggregated_disks(options = {}) click to toggle source
# File lib/fog/google/requests/compute/list_aggregated_disks.rb, line 28
def list_aggregated_disks(options = {})
  api_method = @compute.disks.aggregated_list
  parameters = {
    'project' => @project,
  }
  parameters['filter'] = options[:filter] if options[:filter]

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_aggregated_machine_types() click to toggle source
# File lib/fog/google/requests/compute/list_aggregated_machine_types.rb, line 11
def list_aggregated_machine_types
  api_method = @compute.machine_types.aggregated_list
  parameters = {
    'project' => @project,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_aggregated_servers(options = {}) click to toggle source
# File lib/fog/google/requests/compute/list_aggregated_servers.rb, line 28
def list_aggregated_servers(options = {})
  api_method = @compute.instances.aggregated_list
  parameters = {
    'project' => @project,
  }
  parameters['filter'] = options[:filter] if options[:filter]

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_disk_types(zone) click to toggle source
# File lib/fog/google/requests/compute/list_disk_types.rb, line 34
def list_disk_types(zone)
  api_method = @compute.disk_types.list
  parameters = {
    'project' => @project,
    'zone'    => zone.split('/')[-1],
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_disks(zone_name) click to toggle source
# File lib/fog/google/requests/compute/list_disks.rb, line 17
def list_disks(zone_name)
  api_method = @compute.disks.list
  parameters = {
    'project' => @project,
    'zone' => zone_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_firewalls() click to toggle source
# File lib/fog/google/requests/compute/list_firewalls.rb, line 11
def list_firewalls
  api_method = @compute.firewalls.list
  parameters = {
    'project' => @project
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_forwarding_rules(region_name) click to toggle source
# File lib/fog/google/requests/compute/list_forwarding_rules.rb, line 17
def list_forwarding_rules(region_name)
  api_method = @compute.forwarding_rules.list
  parameters = {
    'project' => @project,
    'region' => region_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_global_operations() click to toggle source

developers.google.com/compute/docs/reference/latest/globalOperations

# File lib/fog/google/requests/compute/list_global_operations.rb, line 13
def list_global_operations
  api_method = @compute.global_operations.list
  parameters = {
    'project' => @project
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_http_health_checks() click to toggle source
# File lib/fog/google/requests/compute/list_http_health_checks.rb, line 11
def list_http_health_checks
  api_method = @compute.http_health_checks.list
  parameters = {
    'project' => @project
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_images(project=nil) click to toggle source
# File lib/fog/google/requests/compute/list_images.rb, line 17
def list_images(project=nil)
  api_method = @compute.images.list
  project=@project if project.nil?
  parameters = {
    'project' => project
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_machine_types(zone_name) click to toggle source
# File lib/fog/google/requests/compute/list_machine_types.rb, line 18
def list_machine_types(zone_name)
  api_method = @compute.machine_types.list
  parameters = {
    'project' => @project,
    'zone' => zone_name,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_networks() click to toggle source
# File lib/fog/google/requests/compute/list_networks.rb, line 11
def list_networks
  api_method = @compute.networks.list
  parameters = {
    'project' => @project
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_region_operations(region) click to toggle source

developers.google.com/compute/docs/reference/latest/regionOperations

# File lib/fog/google/requests/compute/list_region_operations.rb, line 13
def list_region_operations(region)
  api_method = @compute.region_operations.list
  parameters = {
    'region' => region,
    'project' => @project,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_regions() click to toggle source
# File lib/fog/google/requests/compute/list_regions.rb, line 74
def list_regions
  api_method = @compute.regions.list
  parameters = {
    'project' => @project
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_routes() click to toggle source
# File lib/fog/google/requests/compute/list_routes.rb, line 11
def list_routes
  api_method = @compute.routes.list
  parameters = {
    'project' => @project,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_servers(zone_name) click to toggle source
# File lib/fog/google/requests/compute/list_servers.rb, line 19
def list_servers(zone_name)
  api_method = @compute.instances.list
  parameters = {
    'project' => @project,
    'zone' => zone_name,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_snapshots(project=nil) click to toggle source
# File lib/fog/google/requests/compute/list_snapshots.rb, line 11
def list_snapshots(project=nil)
  api_method = @compute.snapshots.list
  project=@project if project.nil?
  parameters = {
    'project' => project
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_target_pools(region_name) click to toggle source
# File lib/fog/google/requests/compute/list_target_pools.rb, line 11
def list_target_pools(region_name)
  api_method = @compute.target_pools.list
  parameters = {
    'project' => @project,
    'region' => region_name
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_zone_operations(zone) click to toggle source

developers.google.com/compute/docs/reference/latest/zoneOperations

# File lib/fog/google/requests/compute/list_zone_operations.rb, line 13
def list_zone_operations(zone)
  api_method = @compute.zone_operations.list
  parameters = {
    'zone' => zone,
    'project' => @project,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
list_zones() click to toggle source
# File lib/fog/google/requests/compute/list_zones.rb, line 17
def list_zones
  api_method = @compute.zones.list
  parameters = {
    'project' => @project
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
new_pk12_google_client(google_client_email, google_key, app_name=nil, app_version=nil) click to toggle source

Public: Create a Google::APIClient with a pkcs12 key and a user email.

google_client_email - an @developer.gserviceaccount.com email address to use. google_key - an absolute location to a pkcs12 key file or the content of the file itself. app_name - an optional string to set as the app name in the user agent. app_version - an optional string to set as the app version in the user agent.

Returns a new Google::APIClient

# File lib/fog/google/compute.rb, line 905
def new_pk12_google_client(google_client_email, google_key, app_name=nil, app_version=nil)
  # The devstorage scope is needed to be able to insert images
  # devstorage.read_only scope is not sufficient like you'd hope
  api_scope_url = 'https://www.googleapis.com/auth/compute https://www.googleapis.com/auth/devstorage.read_write'

  user_agent = ""
  if app_name
    user_agent = "#{app_name}/#{app_version || '0.0.0'} "
  end
  user_agent += "fog/#{Fog::VERSION}"

  api_client_options = {
    # https://github.com/google/google-api-ruby-client/blob/master/lib/google/api_client.rb#L98
    :application_name => "suppress warning",
    # https://github.com/google/google-api-ruby-client/blob/master/lib/google/api_client.rb#L100
    :user_agent => user_agent
  }
  local_client = ::Google::APIClient.new(api_client_options)

  key = ::Google::APIClient::KeyUtils.load_from_pkcs12(google_key, 'notasecret')

  local_client.authorization = Signet::OAuth2::Client.new({
    :audience => 'https://accounts.google.com/o/oauth2/token',
    :auth_provider_x509_cert_url => "https://www.googleapis.com/oauth2/v1/certs",
    :client_x509_cert_url => "https://www.googleapis.com/robot/v1/metadata/x509/#{google_client_email}",
    :issuer => google_client_email,
    :scope => api_scope_url,
    :signing_key => key,
    :token_credential_uri => 'https://accounts.google.com/o/oauth2/token',
  })

  local_client.authorization.fetch_access_token!

  return local_client
end
remove_target_pool_health_checks(target_pool, health_checks) click to toggle source
# File lib/fog/google/requests/compute/remove_target_pool_health_checks.rb, line 11
def remove_target_pool_health_checks(target_pool, health_checks)
  api_method = @compute.target_pools.remove_health_check
  parameters = {
    'project' => @project,
    'targetPool' => target_pool.name,
    'region' => target_pool.region.split('/')[-1]
  }
  body = {
    'healthChecks' => health_checks.map { |i| { 'healthCheck' => i } }
  }

  result = self.build_result(api_method, parameters, body_object=body)
  self.build_response(result)
end
remove_target_pool_instances(target_pool, instances) click to toggle source
# File lib/fog/google/requests/compute/remove_target_pool_instance.rb, line 11
def remove_target_pool_instances(target_pool, instances)
  api_method = @compute.target_pools.remove_instance
  parameters = {
    'project' => @project,
    'targetPool' => target_pool.name,
    'region' => target_pool.region.split('/')[-1]
  }
  body = {
    'instances' => instances.map { |i| { 'instance' => i } }
  }

  result = self.build_result(api_method, parameters, body_object=body)
  self.build_response(result)
end
reset_server(identity, zone) click to toggle source
# File lib/fog/google/requests/compute/reset_server.rb, line 11
def reset_server(identity, zone)
  api_method = @compute.instances.reset
  parameters = {
    'project'  => @project,
    'instance' => identity,
    'zone'     => zone.split('/')[-1],
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
set_common_instance_metadata(identity, current_fingerprint, metadata = {}) click to toggle source
# File lib/fog/google/requests/compute/set_common_instance_metadata.rb, line 11
def set_common_instance_metadata(identity, current_fingerprint, metadata = {})
  api_method = @compute.projects.set_common_instance_metadata
  parameters = {
    :project => identity,
  }
  body_object = {
    :fingerprint => current_fingerprint,
    :items => Array(metadata).map { |pair| { :key => pair[0], :value => pair[1] } },
  }

  result = self.build_result(api_method, parameters, body_object)
  response = self.build_response(result)
end
set_forwarding_rule_target(rule, target) click to toggle source
# File lib/fog/google/requests/compute/set_forwarding_rule_target.rb, line 11
def set_forwarding_rule_target(rule, target)
  api_method = @compute.forwarding_rules.set_target
  parameters = {
    'project' => @project,
    'forwardingRule' => rule.name,
    'region' => rule.region.split('/')[-1]
  }
  body = {
    'target' => target
  }

  result = self.build_result(api_method, parameters, body_object=body)
  self.build_response(result)
end
set_metadata(instance, zone, fingerprint, metadata={}) click to toggle source

Set an instance metadata

Parameters

  • instance<~String> - Instance name (identity)

  • zone<~String> - Zone short name (without the full path)

  • fingerprint<~String> - The fingerprint of the last metadata. Can be retrieved by reloading the compute object, and checking the metadata fingerprint field.

    instance.reload
    fingerprint = instance.metadata['fingerprint']
  • metadata<~Hash> - A new metadata

Returns

  • response<~Excon::Response>

# File lib/fog/google/requests/compute/set_metadata.rb, line 23
def set_metadata(instance, zone, fingerprint, metadata={})
  api_method = @compute.instances.set_metadata
  parameters = {
    'project' => @project,
    'instance' => instance,
    'zone' => zone
  }
  body_object = {
    'fingerprint' => fingerprint,
    "items" => metadata.to_a.map {|pair| { :key => pair[0], :value => pair[1] } }
  }
  result = self.build_result(
    api_method,
    parameters,
    body_object=body_object
  )
  response = self.build_response(result)
end
set_server_disk_auto_delete(identity, zone, auto_delete, device_name) click to toggle source
# File lib/fog/google/requests/compute/set_server_disk_auto_delete.rb, line 11
def set_server_disk_auto_delete(identity, zone, auto_delete, device_name)
  api_method = @compute.instances.set_disk_auto_delete
  parameters = {
    'project'    => @project,
    'instance'   => identity,
    'zone'       => zone.split('/')[-1],
    'autoDelete' => auto_delete,
    'deviceName' => device_name,
  }

  result = self.build_result(api_method, parameters)
  response = self.build_response(result)
end
set_server_scheduling(identity, zone, on_host_maintenance, automatic_restart) click to toggle source
# File lib/fog/google/requests/compute/set_server_scheduling.rb, line 11
def set_server_scheduling(identity, zone, on_host_maintenance, automatic_restart)
  api_method = @compute.instances.set_scheduling
  parameters = {
    'project'  => @project,
    'instance' => identity,
    'zone'     => zone.split('/')[-1],
  }

  body_object = {
    'onHostMaintenance' => on_host_maintenance,
    'automaticRestart'  => automatic_restart,
  }

  result = self.build_result(api_method, parameters, body_object)
  response = self.build_response(result)
end
set_tags(instance, zone, fingerprint, tags=[]) click to toggle source
# File lib/fog/google/requests/compute/set_tags.rb, line 11
def set_tags(instance, zone, fingerprint, tags=[])
  api_method = @compute.instances.set_tags
  parameters = {
    'project' => @project,
    'instance' => instance,
    'zone' => zone
  }
  body_object = { "fingerprint" => fingerprint, "items" => tags }
  result = self.build_result(
    api_method,
    parameters,
    body_object=body_object
  )
  response = self.build_response(result)
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.