class Fog::Compute::Google::Real

Constants

INSERTABLE_ADDRESS_FIELDS
INSERTABLE_FIREWALL_FIELDS
UPDATABLE_FIREWALL_FIELDS

Attributes

client[RW]
compute[R]
exclude_projects[R]
extra_global_projects[R]

Public Class Methods

new(options) click to toggle source
# File lib/fog/compute/google/real.rb, line 10
def initialize(options)
  shared_initialize(options[:google_project], GOOGLE_COMPUTE_API_VERSION, GOOGLE_COMPUTE_BASE_URL)
  options[:google_api_scope_url] = GOOGLE_COMPUTE_API_SCOPE_URLS.join(" ")

  initialize_google_client(options)
  @compute = ::Google::Apis::ComputeV1::ComputeService.new
  apply_client_options(@compute, options)

  @extra_global_projects = options[:google_extra_global_projects] || []
  @exclude_projects = options[:google_exclude_projects] || []
end

Public Instance Methods

abandon_instances(instance_group_manager, instances) click to toggle source
# File lib/fog/compute/google/requests/abandon_instances.rb, line 13
def abandon_instances(instance_group_manager, instances)
  request = ::Google::Apis::ComputeV1::InstanceGroupManagersAbandonInstancesRequest.new(
    instances: instances.map{ |i| i.class == String ? i : i.self_link }
  )
  if instance_group_manager.zone
    zone = instance_group_manager.zone.split("/")[-1]
    @compute.abandon_instance_group_manager_instances(@project, zone, instance_group_manager.name, request)
  else
    region = instance_group_manager.region.split("/")[-1]
    @compute.abandon_region_instance_group_manager_instances(@project, region, instance_group_manager.name, request)
  end
end
add_backend_service_backends(backend_service, _new_backends) click to toggle source
# File lib/fog/compute/google/requests/add_backend_service_backends.rb, line 13
def add_backend_service_backends(backend_service, _new_backends)
  @compute.patch_backend_service(@project, backend_service.name, backend_service)
end
add_instance_group_instances(group_name, zone, instances) click to toggle source
# File lib/fog/compute/google/requests/add_instance_group_instances.rb, line 13
def add_instance_group_instances(group_name, zone, instances)
  instances.map! do |instance|
    if instance.start_with?("https:")
      ::Google::Apis::ComputeV1::InstanceReference.new(instance: instance)
    else
      ::Google::Apis::ComputeV1::InstanceReference.new(
        instance: "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}/instances/#{instance}\n"
      )
    end
  end

  request = ::Google::Apis::ComputeV1::InstanceGroupsAddInstancesRequest.new(
    instances: instances
  )
  @compute.add_instance_group_instances(
    @project,
    zone,
    group_name,
    request
  )
end
add_server_access_config(identity, zone, network_interface, access_config_name = "External NAT", nat_ip: nil) click to toggle source
# File lib/fog/compute/google/requests/add_server_access_config.rb, line 13
def add_server_access_config(identity, zone,
                             network_interface,
                             access_config_name = "External NAT",
                             nat_ip: nil)
  @compute.add_instance_access_config(
    @project,
    zone.split("/")[-1],
    identity,
    network_interface,
    ::Google::Apis::ComputeV1::AccessConfig.new(
      name: access_config_name,
      nat_ip: nat_ip,
      type: "ONE_TO_ONE_NAT"
    )
  )
end
add_target_pool_health_checks(target_pool, region, health_checks) click to toggle source
# File lib/fog/compute/google/requests/add_target_pool_health_checks.rb, line 13
def add_target_pool_health_checks(target_pool, region, health_checks)
  check_list = health_checks.map do |health_check|
    ::Google::Apis::ComputeV1::HealthCheckReference.new(
      health_check: health_check
    )
  end

  @compute.add_target_pool_health_check(
    @project,
    region.split("/")[-1],
    target_pool,
    ::Google::Apis::ComputeV1::AddTargetPoolsHealthCheckRequest.new(
      health_checks: check_list
    )
  )
end
add_target_pool_instances(target_pool, region, instances) click to toggle source
# File lib/fog/compute/google/requests/add_target_pool_instances.rb, line 13
def add_target_pool_instances(target_pool, region, instances)
  instances_lst = instances.map do |instance|
    ::Google::Apis::ComputeV1::InstanceReference.new(instance: instance)
  end

  @compute.add_target_pool_instance(
    @project,
    region.split("/")[-1],
    target_pool,
    ::Google::Apis::ComputeV1::AddTargetPoolsInstanceRequest.new(
      instances: instances_lst
    )
  )
end
attach_disk(instance, zone, disk = {}) click to toggle source
# File lib/fog/compute/google/requests/attach_disk.rb, line 13
def attach_disk(instance, zone, disk = {})
  @compute.attach_disk(
    @project, zone.split("/")[-1], instance,
    ::Google::Apis::ComputeV1::AttachedDisk.new(**disk)
  )
end
create_disk_snapshot(snapshot_name, disk, zone, snapshot = {}) click to toggle source
# File lib/fog/compute/google/requests/create_disk_snapshot.rb, line 13
def create_disk_snapshot(snapshot_name, disk, zone, snapshot = {})
  @compute.create_disk_snapshot(
    @project, zone, disk,
    ::Google::Apis::ComputeV1::Snapshot.new(
      **snapshot.merge(name: snapshot_name)
    )
  )
end
decrypt_password(enc_password, key) click to toggle source
# File lib/fog/compute/google/requests/reset_windows_password.rb, line 142
def decrypt_password(enc_password, key)
  decoded_password = Base64.strict_decode64(enc_password)
  begin
    return key.private_decrypt(decoded_password, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)
  rescue OpenSSL::PKey::RSAError
    Fog::Logger.warning("Error decrypting password received from Google.
                        Maybe check output on Serial Port 4 and Metadata key: windows-keys?")
  end
end
default_network_interface() click to toggle source
# File lib/fog/compute/google/requests/insert_server.rb, line 13
def default_network_interface
  { :network => "global/networks/#{GOOGLE_COMPUTE_DEFAULT_NETWORK}" }
end
delete_address(address_name, region_name) click to toggle source

Delete an address resource in the specified project cloud.google.com/compute/docs/reference/latest/addresses/delete

@param address_name [String] Project ID for this address @param region_name [String] Region for address

# File lib/fog/compute/google/requests/delete_address.rb, line 18
def delete_address(address_name, region_name)
  @compute.delete_address(@project, region_name, address_name)
end
delete_backend_service(backend_service_name) click to toggle source
# File lib/fog/compute/google/requests/delete_backend_service.rb, line 13
def delete_backend_service(backend_service_name)
  @compute.delete_backend_service(@project, backend_service_name)
end
delete_disk(disk_name, zone_name) click to toggle source

Delete a disk resource cloud.google.com/compute/docs/reference/latest/disks/delete

@param disk_name [String] Name of the disk to delete @param zone_name [String] Zone the disk reside in

# File lib/fog/compute/google/requests/delete_disk.rb, line 18
def delete_disk(disk_name, zone_name)
  zone_name = zone_name.split("/")[-1] if zone_name.start_with? "http"
  @compute.delete_disk(@project, zone_name, disk_name)
end
delete_firewall(firewall_name) click to toggle source
# File lib/fog/compute/google/requests/delete_firewall.rb, line 13
def delete_firewall(firewall_name)
  @compute.delete_firewall(@project, firewall_name)
end
delete_forwarding_rule(rule, region) click to toggle source
# File lib/fog/compute/google/requests/delete_forwarding_rule.rb, line 13
def delete_forwarding_rule(rule, region)
  region = region.split("/")[-1] if region.start_with? "http"
  @compute.delete_forwarding_rule(@project, region, rule)
end
delete_global_address(address_name) click to toggle source
# File lib/fog/compute/google/requests/delete_global_address.rb, line 13
def delete_global_address(address_name)
  @compute.delete_global_address(@project, address_name)
end
delete_global_forwarding_rule(rule) click to toggle source
# File lib/fog/compute/google/requests/delete_global_forwarding_rule.rb, line 13
def delete_global_forwarding_rule(rule)
  @compute.delete_global_forwarding_rule(@project, rule)
end
delete_global_operation(operation) click to toggle source

@see developers.google.com/compute/docs/reference/latest/globalOperations/delete

# File lib/fog/compute/google/requests/delete_global_operation.rb, line 14
def delete_global_operation(operation)
  @compute.delete_global_operation(@project, operation)
end
delete_http_health_check(check_name) click to toggle source
# File lib/fog/compute/google/requests/delete_http_health_check.rb, line 13
def delete_http_health_check(check_name)
  @compute.delete_http_health_check(@project, check_name)
end
delete_image(image_name, project = @project) click to toggle source
# File lib/fog/compute/google/requests/delete_image.rb, line 13
def delete_image(image_name, project = @project)
  @compute.delete_image(project, image_name)
end
delete_instance_group(group_name, zone) click to toggle source
# File lib/fog/compute/google/requests/delete_instance_group.rb, line 13
def delete_instance_group(group_name, zone)
  @compute.delete_instance_group(@project, zone, group_name)
end
delete_instance_group_manager(name, zone) click to toggle source
# File lib/fog/compute/google/requests/delete_instance_group_manager.rb, line 13
def delete_instance_group_manager(name, zone)
  @compute.delete_instance_group_manager(@project, zone, name)
end
delete_instance_template(name) click to toggle source
# File lib/fog/compute/google/requests/delete_instance_template.rb, line 13
def delete_instance_template(name)
  @compute.delete_instance_template(@project, name)
end
delete_network(network_name) click to toggle source
# File lib/fog/compute/google/requests/delete_network.rb, line 13
def delete_network(network_name)
  @compute.delete_network(@project, network_name)
end
delete_region_operation(region, operation) click to toggle source

Deletes the specified region-specific Operations resource. @see developers.google.com/compute/docs/reference/latest/regionOperations/delete

# File lib/fog/compute/google/requests/delete_region_operation.rb, line 15
def delete_region_operation(region, operation)
  region = region.split("/")[-1] if region.start_with? "http"
  @compute.delete_region_operation(@project, region, operation)
end
delete_route(identity) click to toggle source

Deletes the specified Route resource.

@param identity [String] Name of the route to delete @see cloud.google.com/compute/docs/reference/latest/routes/delete

# File lib/fog/compute/google/requests/delete_route.rb, line 17
def delete_route(identity)
  @compute.delete_route(@project, identity)
end
delete_server(server, zone) click to toggle source
# File lib/fog/compute/google/requests/delete_server.rb, line 13
def delete_server(server, zone)
  @compute.delete_instance(@project, zone.split("/")[-1], server)
end
delete_server_access_config(identity, zone, nic, access_config = "External NAT") click to toggle source
# File lib/fog/compute/google/requests/delete_server_access_config.rb, line 13
def delete_server_access_config(identity, zone, nic,
                                access_config = "External NAT")
  @compute.delete_instance_access_config(
    @project, zone.split("/")[-1], identity, access_config, nic
  )
end
delete_snapshot(snapshot_name) click to toggle source
# File lib/fog/compute/google/requests/delete_snapshot.rb, line 13
def delete_snapshot(snapshot_name)
  @compute.delete_snapshot(@project, snapshot_name)
end
delete_ssl_certificate(certificate_name) click to toggle source
# File lib/fog/compute/google/requests/delete_ssl_certificate.rb, line 13
def delete_ssl_certificate(certificate_name)
  @compute.delete_ssl_certificate(project, certificate_name)
end
delete_subnetwork(subnetwork_name, region_name) click to toggle source

Delete a subnetwork.

@param subnetwork_name [String] the name of the subnetwork to delete @param region_name [String] the name of the subnetwork's region

@return [Google::Apis::ComputeV1::Operation] delete operation

@see cloud.google.com/compute/docs/reference/latest/subnetworks/delete

# File lib/fog/compute/google/requests/delete_subnetwork.rb, line 22
def delete_subnetwork(subnetwork_name, region_name)
  if region_name.start_with? "http"
    region_name = region_name.split("/")[-1]
  end
  @compute.delete_subnetwork(@project, region_name, subnetwork_name)
end
delete_target_http_proxy(proxy_name) click to toggle source
# File lib/fog/compute/google/requests/delete_target_http_proxy.rb, line 13
def delete_target_http_proxy(proxy_name)
  @compute.delete_target_http_proxy(@project, proxy_name)
end
delete_target_https_proxy(proxy_name) click to toggle source
# File lib/fog/compute/google/requests/delete_target_https_proxy.rb, line 13
def delete_target_https_proxy(proxy_name)
  @compute.delete_target_https_proxy(@project, proxy_name)
end
delete_target_instance(target_name, zone) click to toggle source
# File lib/fog/compute/google/requests/delete_target_instance.rb, line 13
def delete_target_instance(target_name, zone)
  zone = zone.split("/")[-1] if zone.start_with? "http"
  @compute.delete_target_instance(@project, zone, target_name)
end
delete_target_pool(target_pool, region) click to toggle source
# File lib/fog/compute/google/requests/delete_target_pool.rb, line 13
def delete_target_pool(target_pool, region)
  region = region.split("/")[-1] if region.start_with? "http"
  @compute.delete_target_pool(@project, region, target_pool)
end
delete_url_map(url_map_name) click to toggle source
# File lib/fog/compute/google/requests/delete_url_map.rb, line 13
def delete_url_map(url_map_name)
  @compute.delete_url_map(@project, url_map_name)
end
delete_zone_operation(zone_name, operation) click to toggle source

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

# File lib/fog/compute/google/requests/delete_zone_operation.rb, line 15
def delete_zone_operation(zone_name, operation)
  zone_name = zone_name.split("/")[-1] if zone_name.start_with? "http"
  @compute.delete_zone_operation(@project, zone_name, operation)
end
deprecate_image(image_name, deprecation_status = {}, project = @project) click to toggle source
# File lib/fog/compute/google/requests/deprecate_image.rb, line 13
def deprecate_image(image_name, deprecation_status = {}, project = @project)
  @compute.deprecate_image(
    project, image_name,
    ::Google::Apis::ComputeV1::DeprecationStatus.new(deprecation_status)
  )
end
detach_disk(instance, zone, device_name) click to toggle source
# File lib/fog/compute/google/requests/detach_disk.rb, line 13
def detach_disk(instance, zone, device_name)
  zone = zone.split("/")[-1]
  @compute.detach_disk(@project, zone, instance, device_name)
end
expand_subnetwork_ip_cidr_range(subnetwork, region, ip_cidr_range) click to toggle source

Expands the IP CIDR range of the subnetwork to a specified value.

@param subnetwork [String] the name of the subnetwork @param region [String] the name of the subnetwork's region @param ip_cidr_range [String] The IP of internal addresses that are legal on

this subnetwork

@return [Google::Apis::ComputeV1::SubnetworkList] list result

@see cloud.google.com/compute/docs/reference/latest/subnetworks/expandIpCidrRange

# File lib/fog/compute/google/requests/expand_subnetwork_ip_cidr_range.rb, line 24
def expand_subnetwork_ip_cidr_range(subnetwork, region, ip_cidr_range)
  if region.start_with? "http"
    region = region.split("/")[-1]
  end
  @compute.expand_subnetwork_ip_cidr_range(
    @project, region, subnetwork,
    ::Google::Apis::ComputeV1::SubnetworksExpandIpCidrRangeRequest.new(
      ip_cidr_range: ip_cidr_range
    )
  )
end
get_address(address_name, region_name) click to toggle source

Get an address resource in the specified project cloud.google.com/compute/docs/reference/latest/addresses/get

@param address_name [String] Project ID for this address @param region_name [String] Region for address

# File lib/fog/compute/google/requests/get_address.rb, line 18
def get_address(address_name, region_name)
  @compute.get_address(@project, region_name, address_name)
end
get_backend_service(service_name) click to toggle source
# File lib/fog/compute/google/requests/get_backend_service.rb, line 13
def get_backend_service(service_name)
  @compute.get_backend_service(@project, service_name)
end
get_backend_service_health(backend_service) click to toggle source
# File lib/fog/compute/google/requests/get_backend_service_health.rb, line 13
def get_backend_service_health(backend_service)
  health_results = backend_service.backends.map do |backend|
    group = ::Google::Apis::ComputeV1::ResourceGroupReference.new(group: backend[:group])
    resp = @compute.get_backend_service_health(@project, backend_service.name, group)
    [backend[:group], resp.health_status]
  end
  Hash[health_results]
end
get_disk(disk_name, zone_name) click to toggle source

Get a disk resource by name from the specified zone cloud.google.com/compute/docs/reference/latest/disks/get

@param zone_name [String] Zone the disk resides in

# File lib/fog/compute/google/requests/get_disk.rb, line 17
def get_disk(disk_name, zone_name)
  zone_name = zone_name.split("/")[-1] if zone_name.start_with? "http"
  @compute.get_disk(@project, zone_name, disk_name)
end
get_disk_type(disk, zone) click to toggle source
# File lib/fog/compute/google/requests/get_disk_type.rb, line 13
def get_disk_type(disk, zone)
  @compute.get_disk_type(@project, zone.split("/")[-1], disk)
end
get_encrypted_password_from_serial_port(serial_port_output, modulus) click to toggle source
# File lib/fog/compute/google/requests/reset_windows_password.rb, line 122
def get_encrypted_password_from_serial_port(serial_port_output, modulus)
  output = serial_port_output.split("\n")
  output.reverse_each do |line|
    begin
      if line.include?("modulus") && line.include?("encryptedPassword")
        entry = ::JSON.parse(line)
        if modulus == entry["modulus"]
          return entry["encryptedPassword"]
        end
      else
        next
      end
    rescue ::JSON::ParserError
      Fog::Logger.warning("Parsing encrypted password from serial output
                          failed. Trying to parse next matching line.")
      next
    end
  end
end
get_expiration_time_string() click to toggle source
# File lib/fog/compute/google/requests/reset_windows_password.rb, line 96
def get_expiration_time_string
  utc_now = Time.now.utc
  expire_time = utc_now + 5 * 60
  return expire_time.strftime("%Y-%m-%dT%H:%M:%SZ")
end
get_firewall(firewall_name) click to toggle source
# File lib/fog/compute/google/requests/get_firewall.rb, line 13
def get_firewall(firewall_name)
  @compute.get_firewall(@project, firewall_name)
end
get_forwarding_rule(rule, region) click to toggle source
# File lib/fog/compute/google/requests/get_forwarding_rule.rb, line 13
def get_forwarding_rule(rule, region)
  if region.start_with? "http"
    region = region.split("/")[-1]
  end
  @compute.get_forwarding_rule(@project, region, rule)
end
get_global_address(address_name) click to toggle source
# File lib/fog/compute/google/requests/get_global_address.rb, line 13
def get_global_address(address_name)
  @compute.get_global_address(@project, address_name)
end
get_global_forwarding_rule(rule) click to toggle source
# File lib/fog/compute/google/requests/get_global_forwarding_rule.rb, line 13
def get_global_forwarding_rule(rule)
  @compute.get_global_forwarding_rule(@project, rule)
end
get_global_operation(operation) click to toggle source

Get the updated status of a global operation @see developers.google.com/compute/docs/reference/latest/globalOperations/get

@param operation [Google::Apis::ComputeV1::Operation] Return value from asynchronous act

# File lib/fog/compute/google/requests/get_global_operation.rb, line 17
def get_global_operation(operation)
  @compute.get_global_operation(@project, operation)
end
get_http_health_check(check_name) click to toggle source
# File lib/fog/compute/google/requests/get_http_health_check.rb, line 13
def get_http_health_check(check_name)
  @compute.get_http_health_check(@project, check_name)
end
get_image(image_name, project = @project) click to toggle source
# File lib/fog/compute/google/requests/get_image.rb, line 13
def get_image(image_name, project = @project)
  project = @project if project.nil?
  @compute.get_image(project, image_name)
end
get_image_from_family(family, project = @project) click to toggle source

Returns the latest non-deprecated image that is part of an image family.

@param family [String] Name of the image family @param project [String] Project the image belongs to. @return Google::Apis::ComputeV1::Image

@see cloud.google.com/compute/docs/reference/latest/images/getFromFamily

# File lib/fog/compute/google/requests/get_image_from_family.rb, line 20
def get_image_from_family(family, project = @project)
  @compute.get_image_from_family(project, family)
end
get_instance_group(group_name, zone, project = @project) click to toggle source
# File lib/fog/compute/google/requests/get_instance_group.rb, line 13
def get_instance_group(group_name, zone, project = @project)
  @compute.get_instance_group(project, zone, group_name)
end
get_instance_group_manager(name, zone) click to toggle source
# File lib/fog/compute/google/requests/get_instance_group_manager.rb, line 13
def get_instance_group_manager(name, zone)
  @compute.get_instance_group_manager(@project, zone, name)
end
get_instance_template(name) click to toggle source
# File lib/fog/compute/google/requests/get_instance_template.rb, line 13
def get_instance_template(name)
  @compute.get_instance_template(@project, name)
end
get_json_string(user, modulus, exponent, email) click to toggle source
# File lib/fog/compute/google/requests/reset_windows_password.rb, line 102
def get_json_string(user, modulus, exponent, email)
  expire = get_expiration_time_string
  data = { 'userName': user,
           'modulus': modulus,
           'exponent': exponent,
           'email': email,
           'expireOn': expire }
  return ::JSON.dump(data)
end
get_machine_type(machine_type, zone) click to toggle source
# File lib/fog/compute/google/requests/get_machine_type.rb, line 13
def get_machine_type(machine_type, zone)
  zone = zone.split("/")[-1] if zone.start_with? "http"
  @compute.get_machine_type(@project, zone, machine_type)
end
get_modulus_exponent_in_base64(key) click to toggle source
# File lib/fog/compute/google/requests/reset_windows_password.rb, line 88
def get_modulus_exponent_in_base64(key)
  mod = [key.n.to_s(16)].pack("H*").strip
  exp = [key.e.to_s(16)].pack("H*").strip
  modulus = Base64.strict_encode64(mod).strip
  exponent = Base64.strict_encode64(exp).strip
  return modulus, exponent
end
get_network(network_name) click to toggle source
# File lib/fog/compute/google/requests/get_network.rb, line 13
def get_network(network_name)
  @compute.get_network(@project, network_name)
end
get_project(identity) click to toggle source
# File lib/fog/compute/google/requests/get_project.rb, line 13
def get_project(identity)
  @compute.get_project(identity)
end
get_region(identity) click to toggle source
# File lib/fog/compute/google/requests/get_region.rb, line 13
def get_region(identity)
  @compute.get_region(@project, identity.split("/")[-1])
end
get_region_operation(region, operation) click to toggle source

Retrieves the specified region-specific Operations resource @see developers.google.com/compute/docs/reference/latest/regionOperations/get

# File lib/fog/compute/google/requests/get_region_operation.rb, line 13
def get_region_operation(region, operation)
  region = region.split("/")[-1] if region.start_with? "http"
  @compute.get_region_operation(@project, region, operation)
end
get_route(identity) click to toggle source

List address resources in the specified project

@see cloud.google.com/compute/docs/reference/latest/routes/list

# File lib/fog/compute/google/requests/get_route.rb, line 16
def get_route(identity)
  @compute.get_route(@project, identity)
end
get_server(instance, zone) click to toggle source
# File lib/fog/compute/google/requests/get_server.rb, line 13
def get_server(instance, zone)
  @compute.get_instance(@project, zone.split("/")[-1], instance)
end
get_server_serial_port_output(identity, zone, port: nil, start: nil) click to toggle source

Returns the specified instance's serial port output. @param [String] zone Zone for the given instance @param [String] instance Instance scoping this request. @param [Fixnum] port

Specifies which COM or serial port to retrieve data from.
Acceptable values are 1 to 4, inclusive. (Default: 1)

@param [Fixnum] start

Returns output starting from a specific byte position.
Use this to page through output when the output is too large to
return in a single request. For the initial request,
leave this field unspecified. For subsequent calls, this field
should be set to the next value returned in the previous call.

@see cloud.google.com/compute/docs/reference/latest/instances/getSerialPortOutput

# File lib/fog/compute/google/requests/get_server_serial_port_output.rb, line 26
def get_server_serial_port_output(identity, zone, port: nil, start: nil)
  @compute.get_instance_serial_port_output(
    @project,
    zone.split("/")[-1],
    identity,
    port: port,
    start: start
  )
end
get_snapshot(snap_name, project = @project) click to toggle source
# File lib/fog/compute/google/requests/get_snapshot.rb, line 13
def get_snapshot(snap_name, project = @project)
  raise ArgumentError.new "snap_name must not be nil." if snap_name.nil?
  @compute.get_snapshot(project, snap_name)
end
get_ssl_certificate(certificate_name) click to toggle source
# File lib/fog/compute/google/requests/get_ssl_certificate.rb, line 13
def get_ssl_certificate(certificate_name)
  @compute.get_ssl_certificate(@project, certificate_name)
end
get_subnetwork(subnetwork_name, region_name) click to toggle source

Returns the specified subnetwork.

@param subnetwork_name [String] the name of the subnetwork @param region_name [String] the name of the subnetwork's region @return [Google::Apis::ComputeV1::Operation] an operation response

@see cloud.google.com/compute/docs/reference/latest/subnetworks/get

# File lib/fog/compute/google/requests/get_subnetwork.rb, line 21
def get_subnetwork(subnetwork_name, region_name)
  subnetwork_name = subnetwork_name.split("/")[-1] if subnetwork_name.start_with? "http"
  region_name = region_name.split("/")[-1] if region_name.start_with? "http"
  @compute.get_subnetwork(@project, region_name, subnetwork_name)
end
get_target_http_proxy(proxy_name) click to toggle source
# File lib/fog/compute/google/requests/get_target_http_proxy.rb, line 13
def get_target_http_proxy(proxy_name)
  @compute.get_target_http_proxy(@project, proxy_name)
end
get_target_https_proxy(proxy_name) click to toggle source
# File lib/fog/compute/google/requests/get_target_https_proxy.rb, line 13
def get_target_https_proxy(proxy_name)
  @compute.get_target_https_proxy(@project, proxy_name)
end
get_target_instance(target_name, zone) click to toggle source
# File lib/fog/compute/google/requests/get_target_instance.rb, line 13
def get_target_instance(target_name, zone)
  zone = zone.split("/")[-1] if zone.start_with? "http"
  @compute.get_target_instance(@project, zone, target_name)
end
get_target_pool(target_pool, region) click to toggle source
# File lib/fog/compute/google/requests/get_target_pool.rb, line 13
def get_target_pool(target_pool, region)
  region = region.split("/")[-1] if region.start_with? "http"
  @compute.get_target_pool(@project, region, target_pool)
end
get_target_pool_health(target_pool, region, instance) click to toggle source
# File lib/fog/compute/google/requests/get_target_pool_health.rb, line 13
def get_target_pool_health(target_pool, region, instance)
  @compute.get_target_pool_health(
    @project, region.split("/")[-1], target_pool,
    ::Google::Apis::ComputeV1::InstanceReference.new(
      instance: instance
    )
  )
end
get_url_map(url_map_name) click to toggle source
# File lib/fog/compute/google/requests/get_url_map.rb, line 13
def get_url_map(url_map_name)
  @compute.get_url_map(@project, url_map_name)
end
get_zone(zone_name) click to toggle source
# File lib/fog/compute/google/requests/get_zone.rb, line 13
def get_zone(zone_name)
  @compute.get_zone(@project, zone_name)
end
get_zone_operation(zone_name, operation) click to toggle source

Get the updated status of a zone operation @see developers.google.com/compute/docs/reference/latest/zoneOperations/get

@param zone_name [String] Zone the operation was peformed in @param operation [Google::Apis::ComputeV1::Operation] Return value from asynchronous actions

# File lib/fog/compute/google/requests/get_zone_operation.rb, line 18
def get_zone_operation(zone_name, operation)
  zone_name = zone_name.split("/")[-1] if zone_name.start_with? "http"
  @compute.get_zone_operation(@project, zone_name, operation)
end
insert_address(address_name, region_name, options = {}) click to toggle source

Create an address resource in the specified project cloud.google.com/compute/docs/reference/latest/addresses/insert

@param address_name [String] Project ID for this address @param region_name [String] Region for address @param options [Hash] Optional hash of options @option options [String] :description Description of resource

# File lib/fog/compute/google/requests/insert_address.rb, line 20
def insert_address(address_name, region_name, options = {})
  address = ::Google::Apis::ComputeV1::Address.new(
    name: address_name,
    description: options[:description]
  )
  @compute.insert_address(@project, region_name, address)
end
insert_backend_service(backend_service_name, opts = {}) click to toggle source
# File lib/fog/compute/google/requests/insert_backend_service.rb, line 13
def insert_backend_service(backend_service_name, opts = {})
  options = opts.reject { |_k, v| v.nil? }
                .merge(:name => backend_service_name)

  be_service = ::Google::Apis::ComputeV1::BackendService.new(**options)
  @compute.insert_backend_service(@project, be_service)
end
insert_disk(disk_name, zone, source_image = nil, description: nil, type: nil, size_gb: nil, source_snapshot: nil, labels: nil, **_opts) click to toggle source

Create a disk resource in a specific zone cloud.google.com/compute/docs/reference/latest/disks/insert

@param disk_name [String] Name of the disk to create @param zone_name [String] Zone the disk reside in @param source_image [String] Optional self_link or family formatted url of the image to create the disk from, see cloud.google.com/compute/docs/reference/latest/disks/insert @param opts [Hash] Optional hash of options @option options [String] size_gb Number of GB to allocate to an empty disk @option options [String] source_snapshot Snapshot to create the disk from @option options [String] description Human friendly description of the disk @option options [String] type URL of the disk type resource describing which disk type to use TODO(2.0): change source_image to keyword argument in 2.0 and gracefully deprecate

# File lib/fog/compute/google/requests/insert_disk.rb, line 26
def insert_disk(disk_name, zone, source_image = nil,
                description: nil, type: nil, size_gb: nil,
                source_snapshot: nil, labels: nil, **_opts)

  if source_image && !source_image.include?("projects/")
    raise ArgumentError.new("source_image needs to be self-link formatted or specify a family")
  end
  disk_opts = {
    :name => disk_name,
    :description => description,
    :type => type,
    :size_gb => size_gb,
    :source_snapshot => source_snapshot,
    :source_image => source_image
  }
  disk_opts[:labels] = labels if labels
  disk = ::Google::Apis::ComputeV1::Disk.new(**disk_opts)
  @compute.insert_disk(@project, zone.split("/")[-1], disk)
end
insert_firewall(firewall_name, opts = {}) click to toggle source

Create a Firewall resource

@param [Hash] opts The firewall object to create @option opts [Array<Hash>] allowed @option opts [Array<Hash>] denied @option opts [String] description @option opts [Array<String>] destination_ranges @option opts [String] direction @option opts [String] name @option opts [String] network @option opts [Fixnum] priority @option opts [Array<String>] source_ranges @option opts [Array<String>] source_service_accounts @option opts [Array<String>] source_tags @option opts [Array<String>] target_service_accounts @option opts [Array<String>] target_tags

@see cloud.google.com/compute/docs/reference/latest/firewalls/insert

# File lib/fog/compute/google/requests/insert_firewall.rb, line 48
def insert_firewall(firewall_name, opts = {})
  if opts.key?(:network) && !opts[:network].empty?
    unless opts[:network].start_with?("http://", "https://", "projects/", "global/")
      opts[:network] = "projects/#{@project}/global/networks/#{opts[:network]}"
    end
  end

  opts = opts.select { |k, _| INSERTABLE_FIREWALL_FIELDS.include? k }
             .merge(:name => firewall_name)

  @compute.insert_firewall(
    @project, ::Google::Apis::ComputeV1::Firewall.new(**opts)
  )
end
insert_forwarding_rule(rule_name, region, opts = {}) click to toggle source

Create a forwarding rule.

@see cloud.google.com/compute/docs/reference/latest/forwardingRules/insert

# File lib/fog/compute/google/requests/insert_forwarding_rule.rb, line 17
def insert_forwarding_rule(rule_name, region, opts = {})
  region = region.split("/")[-1] if region.start_with? "http"
  @compute.insert_forwarding_rule(
    @project, region,
    ::Google::Apis::ComputeV1::ForwardingRule.new(
      **opts.merge(:name => rule_name)
    )
  )
end
insert_global_address(address_name, options = {}) click to toggle source
# File lib/fog/compute/google/requests/insert_global_address.rb, line 15
def insert_global_address(address_name, options = {})
  opts = options.select { |k, _| INSERTABLE_ADDRESS_FIELDS.include? k }
                .merge(:name => address_name)
  @compute.insert_global_address(
    @project, ::Google::Apis::ComputeV1::Address.new(**opts)
  )
end
insert_global_forwarding_rule(rule_name, opts = {}) click to toggle source

Create a global forwarding rule.

@see cloud.google.com/compute/docs/reference/latest/globalForwardingRules/insert

# File lib/fog/compute/google/requests/insert_global_forwarding_rule.rb, line 17
def insert_global_forwarding_rule(rule_name, opts = {})
  opts = opts.merge(:name => rule_name)
  @compute.insert_global_forwarding_rule(
    @project, ::Google::Apis::ComputeV1::ForwardingRule.new(**opts)
  )
end
insert_http_health_check(check_name, opts = {}) click to toggle source
# File lib/fog/compute/google/requests/insert_http_health_check.rb, line 13
def insert_http_health_check(check_name, opts = {})
  @compute.insert_http_health_check(
    @project,
    ::Google::Apis::ComputeV1::HttpHealthCheck.new(
      **opts.merge(:name => check_name)
    )
  )
end
insert_image(image_name, image = {}, project = @project) click to toggle source
# File lib/fog/compute/google/requests/insert_image.rb, line 13
def insert_image(image_name, image = {}, project = @project)
  image = image.merge(:name => image_name)
  @compute.insert_image(
    project,
    ::Google::Apis::ComputeV1::Image.new(**image)
  )
end
insert_instance_group(group_name, zone, options = {}) click to toggle source
# File lib/fog/compute/google/requests/insert_instance_group.rb, line 13
def insert_instance_group(group_name, zone, options = {})
  if options["network"]
    network_name = last_url_segment(options["network"])
  else
    network_name = GOOGLE_COMPUTE_DEFAULT_NETWORK
  end

  instance_group = ::Google::Apis::ComputeV1::InstanceGroup.new(
    description: options["description"],
    name: group_name,
    network: "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/networks/#{network_name}"
  )

  @compute.insert_instance_group(@project,
                                 last_url_segment(zone),
                                 instance_group)
end
insert_instance_group_manager(name, zone, instance_template, base_instance_name, target_size, target_pools, named_ports, description) click to toggle source
# File lib/fog/compute/google/requests/insert_instance_group_manager.rb, line 14
def insert_instance_group_manager(name, zone, instance_template, base_instance_name,
                                  target_size, target_pools, named_ports, description)
  instance_group_manager = ::Google::Apis::ComputeV1::InstanceGroupManager.new(
    description: description,
    name: name,
    instance_template: instance_template.self_link,
    base_instance_name: base_instance_name,
    target_size: target_size,
    named_ports: named_ports || [],
    target_pools: target_pools || [],
  )

  @compute.insert_instance_group_manager(@project, zone, instance_group_manager)
end
insert_instance_template(name, properties, description) click to toggle source

Create a new template.

@param name [String]

Name to assign to the created template. Must be unique.

@param descrption [String]

Optional description of the template

@param properties [Hash]

Template attributes. You can use any of the options documented at
https://cloud.google.com/compute/docs/reference/rest/v1/instanceTemplates/insert

@see cloud.google.com/compute/docs/reference/rest/v1/instanceTemplates/insert @return [::Google::Apis::ComputeV1::Operation]

response object that represents the insertion operation.
# File lib/fog/compute/google/requests/insert_instance_template.rb, line 26
def insert_instance_template(name, properties, description)
  instance_template = ::Google::Apis::ComputeV1::InstanceTemplate.new(
    description: description,
    name: name,
    properties: properties,
  )

  @compute.insert_instance_template(@project, instance_template)
end
insert_network(network_name, opts = {}) click to toggle source
# File lib/fog/compute/google/requests/insert_network.rb, line 13
def insert_network(network_name, opts = {})
  opts = opts.merge(:name => network_name)

  @compute.insert_network(
    @project,
    ::Google::Apis::ComputeV1::Network.new(**opts)
  )
end
insert_route(route_name, network, dest_range, priority, options = {}) click to toggle source

Creates a Route resource.

@see cloud.google.com/compute/docs/reference/latest/routes/insert

# File lib/fog/compute/google/requests/insert_route.rb, line 16
def insert_route(route_name, network, dest_range, priority, options = {})
  route = ::Google::Apis::ComputeV1::Route.new(
    name: route_name,
    network: network,
    dest_range: dest_range,
    priority: priority,
    tags: options[:tags] || [],
    next_hop_instance: options[:next_hop_instance],
    next_hop_gateway: options[:next_hop_gateway],
    next_hop_ip: options[:next_hop_ip],
    next_hop_vpn_tunnel: options[:next_hop_vpn_tunnel],
    description: options[:description]
  )

  @compute.insert_route(@project, route)
end
insert_server(instance_name, zone, options = {}) click to toggle source

Create a new instance (virtual machine).

This method allows you to use low-level request options and thus expects instance options similar to API requests. If you don't need to modify low-level request options, consider using the Fog::Compute::Google::Servers collection object instead.

@example minimal server creation

my_operation = client.insert_server(
  "my-server",
  "us-central1-a",
  :machine_type => "f1-micro",
  :disks => [
    {
      :initialize_params => {
        :source_image => "projects/debian-cloud/global/images/family/debian-9"
      }
    }
  ]
)

@param instance_name [String]

Name to assign to the created server. Must be unique within the specified zone.

@param zone [String]

Name or URL of zone containing the created server.

@param options [Hash]

Server attributes. You can use any of the options documented at
https://cloud.google.com/compute/docs/reference/latest/instances/insert.

@see cloud.google.com/compute/docs/reference/latest/instances/insert @return [::Google::Apis::ComputeV1::Operation]

response object that represents the insertion operation.
# File lib/fog/compute/google/requests/insert_server.rb, line 71
def insert_server(instance_name, zone, options = {})
  zone = zone.split("/")[-1]

  data = options.merge(:name => instance_name)
  data[:disks] = process_disks(options[:disks])
  data[:network_interfaces] = process_network_interfaces(options[:network_interfaces])

  machine_type = options[:machine_type]
  unless machine_type
    raise ArgumentError.new("machine type is required")
  end

  unless machine_type.include?("zones/")
    machine_type = "zones/#{zone}/machineTypes/#{data[:machine_type]}"
  end
  data[:machine_type] = machine_type

  # Optional subclassed attributes
  if data[:guest_accelerators]
    data[:guest_accelerators] = data[:guest_accelerators].map do |acc_config|
      ::Google::Apis::ComputeV1::AcceleratorConfig.new(**acc_config)
    end
  end

  if data[:metadata]
    data[:metadata] = ::Google::Apis::ComputeV1::Metadata.new(**options[:metadata])
  end

  if data[:scheduling]
    data[:scheduling] = ::Google::Apis::ComputeV1::Scheduling.new(**options[:scheduling])
  end

  if data[:shielded_instance_config]
    data[:shielded_instance_config] = ::Google::Apis::ComputeV1::ShieldedInstanceConfig.new(**options[:shielded_instance_config])
  end

  if data[:display_device]
    data[:display_device] = ::Google::Apis::ComputeV1::DisplayDevice.new(**options[:display_device])
  end

  if data[:tags]
    if options[:tags].is_a?(Array)
      # Process classic tag notation, i.e. ["fog"]
      data[:tags] = ::Google::Apis::ComputeV1::Tags.new(items: options[:tags])
    else
      data[:tags] = ::Google::Apis::ComputeV1::Tags.new(**options[:tags])
    end
  end

  instance = ::Google::Apis::ComputeV1::Instance.new(**data)
  @compute.insert_instance(@project, zone, instance)
end
insert_ssl_certificate(certificate_name, certificate, private_key, description: nil) click to toggle source
# File lib/fog/compute/google/requests/insert_ssl_certificate.rb, line 13
def insert_ssl_certificate(certificate_name, certificate, private_key, description: nil)
  @compute.insert_ssl_certificate(
    @project,
    ::Google::Apis::ComputeV1::SslCertificate.new(
      certificate: certificate,
      name: certificate_name,
      private_key: private_key,
      description: description
    )
  )
end
insert_subnetwork(subnetwork_name, region_name, network, ip_range, options = {}) click to toggle source

Create a subnetwork.

@param subnetwork_name [String] the name of the subnetwork @param region_name [String] the name of the subnetwork's region @param network [String] URL of the network this subnetwork belongs to @param ip_range [String] The range of internal addresses that are owned

by this subnetwork.

@param options [Hash] Other optional attributes to set on the subnetwork @option options [Boolean] private_ip_google_access Whether the VMs in

this subnet can access Google services without assigned external IP
addresses.

@option options [String] description An optional description of this resource. @option options [Array<Hash>] secondary_ip_ranges An array of configurations

for secondary IP ranges

@option secondary_ip_ranges [String] ip_cidr_range The range of IP

addresses for a secondary range

@option secondary_ip_ranges [String] range_name The name associated

with a secondary range

@return [Google::Apis::ComputeV1::Operation] an operation response

@see cloud.google.com/compute/docs/reference/latest/subnetworks/insert

# File lib/fog/compute/google/requests/insert_subnetwork.rb, line 36
def insert_subnetwork(subnetwork_name, region_name, network, ip_range, options = {})
  region_name = region_name.split("/")[-1] if region_name.start_with? "http"
  unless network.start_with? "http"
    network = "#{@api_url}#{@project}/global/networks/#{network}"
  end

  params = {
    :name => subnetwork_name,
    :ip_cidr_range => ip_range,
    :region => region_name,
    :network => network
  }

  optional_fields = %i{private_ip_google_access description secondary_ip_ranges}
  params = optional_fields.inject(params) do |data, field|
    data[field] = options[field] unless options[field].nil?
    data
  end

  subnetwork = ::Google::Apis::ComputeV1::Subnetwork.new(**params)
  @compute.insert_subnetwork(@project, region_name, subnetwork)
end
insert_target_http_proxy(proxy_name, description: nil, url_map: nil) click to toggle source
# File lib/fog/compute/google/requests/insert_target_http_proxy.rb, line 13
def insert_target_http_proxy(proxy_name, description: nil, url_map: nil)
  @compute.insert_target_http_proxy(
    @project,
    ::Google::Apis::ComputeV1::TargetHttpProxy.new(
      name: proxy_name,
      description: description,
      url_map: url_map
    )
  )
end
insert_target_https_proxy(proxy_name, description: nil, url_map: nil, ssl_certificates: nil) click to toggle source
# File lib/fog/compute/google/requests/insert_target_https_proxy.rb, line 14
def insert_target_https_proxy(proxy_name, description: nil,
                              url_map: nil, ssl_certificates: nil)
  @compute.insert_target_https_proxy(
    @project,
    ::Google::Apis::ComputeV1::TargetHttpsProxy.new(
      name: proxy_name,
      description: description,
      url_map: url_map,
      ssl_certificates: ssl_certificates
    )
  )
end
insert_target_instance(target_name, zone, target_instance = {}) click to toggle source
# File lib/fog/compute/google/requests/insert_target_instance.rb, line 13
def insert_target_instance(target_name, zone, target_instance = {})
  zone = zone.split("/")[-1] if zone.start_with? "http"
  @compute.insert_target_instance(
    @project, zone,
    ::Google::Apis::ComputeV1::TargetInstance.new(
      **target_instance.merge(name: target_name)
    )
  )
end
insert_target_pool(target_pool_name, region, target_pool = {}) click to toggle source
# File lib/fog/compute/google/requests/insert_target_pool.rb, line 13
def insert_target_pool(target_pool_name, region, target_pool = {})
  pool_obj = ::Google::Apis::ComputeV1::TargetPool.new(
    **target_pool.merge(name: target_pool_name)
  )
  @compute.insert_target_pool(@project, region.split("/")[-1], pool_obj)
end
insert_url_map(url_map_name, url_map = {}) click to toggle source
# File lib/fog/compute/google/requests/insert_url_map.rb, line 13
def insert_url_map(url_map_name, url_map = {})
  url_map[:host_rules] = url_map[:host_rules] || []
  url_map[:path_matchers] = url_map[:path_matchers] || []
  url_map[:tests] = url_map[:tests] || []

  url_map_obj = ::Google::Apis::ComputeV1::UrlMap.new(
    **url_map.merge(:name => url_map_name)
  )
  # HACK: Currently URL map insert may fail even though the backend
  # service operation is done. Retriable is not used to not add another
  # runtime dependency.
  # TODO: Remove after that has been corrected.
  begin
    retries ||= 0
    @compute.insert_url_map(@project, url_map_obj)
  rescue ::Google::Apis::ClientError
    Fog::Logger.warning("URL map insert failed, retrying...")
    sleep 10
    retry if (retries += 1) < 2
  end
end
invalidate_url_map_cache(url_map_name, path, host = nil) click to toggle source
# File lib/fog/compute/google/requests/invalidate_url_map_cache.rb, line 13
def invalidate_url_map_cache(url_map_name, path, host = nil)
  @compute.invalidate_url_map_cache(
    @project, url_map_name,
    ::Google::Apis::ComputeV1::CacheInvalidationRule.new(
      path: path, host: host
    )
  )
end
last_url_segment(network) click to toggle source
# File lib/fog/compute/google/requests/insert_instance_group.rb, line 31
def last_url_segment(network)
  network.split("/")[-1]
end
list_addresses(region_name, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source

List address resources in the specified project @see cloud.google.com/compute/docs/reference/latest/addresses/list

# File lib/fog/compute/google/requests/list_addresses.rb, line 15
def list_addresses(region_name, filter: nil, max_results: nil,
                   order_by: nil, page_token: nil)
  @compute.list_addresses(
    @project, region_name,
    filter: filter,
    max_results: max_results,
    order_by: order_by,
    page_token: page_token
  )
end
list_aggregated_addresses(options = {}) click to toggle source

Retrieves an aggregated list of addresses cloud.google.com/compute/docs/reference/latest/addresses/aggregatedList @param options [Hash] Optional hash of options @option options [String] :filter Filter expression for filtering listed resources

# File lib/fog/compute/google/requests/list_aggregated_addresses.rb, line 17
def list_aggregated_addresses(options = {})
  @compute.list_aggregated_addresses(@project, **options)
end
list_aggregated_disk_types(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_aggregated_disk_types.rb, line 13
def list_aggregated_disk_types(filter: nil, max_results: nil,
                               order_by: nil, page_token: nil)
  @compute.list_aggregated_disk_types(
    @project,
    filter: filter, max_results: max_results,
    order_by: order_by, page_token: page_token
  )
end
list_aggregated_disks(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source

Retrieves an aggregated list of disks cloud.google.com/compute/docs/reference/latest/disks/aggregatedList

@param options [Hash] Optional hash of options @option options [String] :filter Filter expression for filtering listed resources @option options [String] :max_results @option options [String] :order_by @option options [String] :page_token

# File lib/fog/compute/google/requests/list_aggregated_disks.rb, line 21
def list_aggregated_disks(filter: nil, max_results: nil,
                          order_by: nil, page_token: nil)
  @compute.list_aggregated_disk(
    @project,
    filter: filter, max_results: max_results,
    order_by: order_by, page_token: page_token
  )
end
list_aggregated_forwarding_rules(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_aggregated_forwarding_rules.rb, line 13
def list_aggregated_forwarding_rules(filter: nil, max_results: nil,
                                     order_by: nil, page_token: nil)
  @compute.list_aggregated_forwarding_rules(
    @project,
    filter: filter, max_results: max_results,
    order_by: order_by, page_token: page_token
  )
end
list_aggregated_instance_group_managers(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_aggregated_instance_group_managers.rb, line 13
def list_aggregated_instance_group_managers(filter: nil, max_results: nil,
                                            order_by: nil, page_token: nil)
  @compute.list_aggregated_instance_group_managers(
    @project,
    filter: filter,
    max_results: max_results,
    order_by: order_by,
    page_token: page_token
  )
end
list_aggregated_instance_groups(options = {}) click to toggle source
# File lib/fog/compute/google/requests/list_aggregated_instance_groups.rb, line 13
def list_aggregated_instance_groups(options = {})
  @compute.list_aggregated_instance_groups(@project, **options)
end
list_aggregated_machine_types(filter: nil, max_results: nil, page_token: nil, order_by: nil) click to toggle source
# File lib/fog/compute/google/requests/list_aggregated_machine_types.rb, line 13
def list_aggregated_machine_types(filter: nil, max_results: nil,
                                  page_token: nil, order_by: nil)
  @compute.list_aggregated_machine_types(
    @project,
    filter: filter, max_results: max_results,
    page_token: page_token, order_by: order_by
  )
end
list_aggregated_servers(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_aggregated_servers.rb, line 13
def list_aggregated_servers(filter: nil, max_results: nil,
                            order_by: nil, page_token: nil)
  @compute.list_aggregated_instances(
    @project,
    filter: filter, max_results: max_results,
    order_by: order_by, page_token: page_token
  )
end
list_aggregated_subnetworks(filter: nil, max_results: nil, page_token: nil, order_by: nil) click to toggle source

Retrieves an aggregated list of subnetworks across a project.

@param filter [String] A filter expression for filtering listed resources. @param max_results [Fixnum] Max number of results to return @param order_by [String] Sorts list results by a certain order @param page_token [String] specifies a page token to use @return [Google::Apis::ComputeV1::SubnetworkAggregatedList] list result

@see cloud.google.com/compute/docs/reference/latest/subnetworks/aggregatedList

# File lib/fog/compute/google/requests/list_aggregated_subnetworks.rb, line 23
def list_aggregated_subnetworks(filter: nil, max_results: nil,
                                page_token: nil, order_by: nil)
  @compute.aggregated_subnetwork_list(
    @project,
    filter: filter,
    max_results: max_results,
    page_token: page_token,
    order_by: order_by
  )
end
list_aggregated_target_instances(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_aggregated_target_instances.rb, line 13
def list_aggregated_target_instances(filter: nil, max_results: nil,
                                     order_by: nil, page_token: nil)
  @compute.list_aggregated_target_instance(
    @project,
    filter: filter,
    max_results: max_results,
    order_by: order_by,
    page_token: page_token
  )
end
list_aggregated_target_pools(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_aggregated_target_pools.rb, line 13
def list_aggregated_target_pools(filter: nil, max_results: nil,
                                 order_by: nil, page_token: nil)
  @compute.list_aggregated_target_pools(
    @project,
    filter: filter,
    max_results: max_results,
    order_by: order_by,
    page_token: page_token
  )
end
list_backend_services() click to toggle source
# File lib/fog/compute/google/requests/list_backend_services.rb, line 16
def list_backend_services
  @compute.list_backend_services(@project)
end
list_disk_types(zone, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_disk_types.rb, line 13
def list_disk_types(zone, filter: nil, max_results: nil,
                    order_by: nil, page_token: nil)
  @compute.list_disk_types(
    @project, zone.split("/")[-1],
    filter: filter, max_results: max_results,
    order_by: order_by, page_token: page_token
  )
end
list_disks(zone_name, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source

List disk resources in the specified zone cloud.google.com/compute/docs/reference/latest/disks/list

@param zone_name [String] Zone to list disks from

# File lib/fog/compute/google/requests/list_disks.rb, line 17
def list_disks(zone_name, filter: nil, max_results: nil,
               order_by: nil, page_token: nil)
  @compute.list_disks(
    @project, zone_name,
    filter: filter, max_results: max_results,
    order_by: order_by, page_token: page_token
  )
end
list_firewalls(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_firewalls.rb, line 13
def list_firewalls(filter: nil, max_results: nil,
                   order_by: nil, page_token: nil)
  @compute.list_firewalls(@project,
                          filter: filter,
                          max_results: max_results,
                          order_by: order_by,
                          page_token: page_token)
end
list_forwarding_rules(region, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_forwarding_rules.rb, line 13
def list_forwarding_rules(region,
                          filter: nil, max_results: nil,
                          order_by: nil, page_token: nil)
  @compute.list_forwarding_rules(
    @project, region,
    filter: filter, max_results: max_results,
    order_by: order_by, page_token: page_token
  )
end
list_global_addresses(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source

List address resources in the specified project @see cloud.google.com/compute/docs/reference/latest/globalAddresses

# File lib/fog/compute/google/requests/list_global_addresses.rb, line 15
  def list_global_addresses(filter: nil, max_results: nil, order_by: nil,
                          page_token: nil)
  @compute.list_global_addresses(@project,
                                 filter: filter,
                                 max_results: max_results,
                                 order_by: order_by,
                                 page_token: page_token)
end
list_global_forwarding_rules(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_global_forwarding_rules.rb, line 13
def list_global_forwarding_rules(filter: nil, max_results: nil,
                                 order_by: nil, page_token: nil)
  @compute.list_global_forwarding_rules(
    @project,
    filter: filter, max_results: max_results,
    order_by: order_by, page_token: page_token
  )
end
list_global_operations(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source

@see developers.google.com/compute/docs/reference/latest/globalOperations/list

# File lib/fog/compute/google/requests/list_global_operations.rb, line 14
def list_global_operations(filter: nil, max_results: nil,
                           order_by: nil, page_token: nil)
  @compute.list_global_operations(
    @project,
    filter: filter,
    max_results: max_results,
    order_by: order_by,
    page_token: page_token
  )
end
list_http_health_checks(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_http_health_checks.rb, line 13
def list_http_health_checks(filter: nil, max_results: nil,
                            order_by: nil, page_token: nil)
  @compute.list_http_health_checks(
    @project,
    filter: filter, max_results: max_results,
    order_by: order_by, page_token: page_token
  )
end
list_images(project = @project, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_images.rb, line 13
def list_images(project = @project,
                filter: nil, max_results: nil,
                order_by: nil, page_token: nil)
  @compute.list_images(
    project,
    filter: filter, max_results: max_results,
    order_by: order_by, page_token: page_token
  )
end
list_instance_group_instances(group_name, zone) click to toggle source
# File lib/fog/compute/google/requests/list_instance_group_instances.rb, line 13
def list_instance_group_instances(group_name, zone)
  @compute.list_instance_group_instances(@project,
                                         zone,
                                         group_name)
end
list_instance_group_managers(zone, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_instance_group_managers.rb, line 13
def list_instance_group_managers(zone, filter: nil, max_results: nil,
                                 order_by: nil, page_token: nil)
  @compute.list_instance_group_managers(
    @project, zone, filter: filter, max_results: max_results,
                    order_by: order_by, page_token: page_token)
end
list_instance_groups(zone) click to toggle source
# File lib/fog/compute/google/requests/list_instance_groups.rb, line 13
def list_instance_groups(zone)
  @compute.list_instance_groups(@project, zone)
end
list_instance_templates(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_instance_templates.rb, line 13
def list_instance_templates(filter: nil, max_results: nil,
                            order_by: nil, page_token: nil)
  @compute.list_instance_templates(
    @project,
    filter: filter,
    max_results: max_results,
    order_by: order_by,
    page_token: page_token
  )
end
list_machine_types(zone, filter: nil, max_results: nil, page_token: nil, order_by: nil) click to toggle source
# File lib/fog/compute/google/requests/list_machine_types.rb, line 13
def list_machine_types(zone, filter: nil, max_results: nil,
                       page_token: nil, order_by: nil)
  zone = zone.split("/")[-1] if zone.start_with? "http"
  @compute.list_machine_types(@project, zone,
                              filter: filter,
                              max_results: max_results,
                              page_token: page_token,
                              order_by: order_by)
end
list_networks(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_networks.rb, line 13
def list_networks(filter: nil, max_results: nil,
                  order_by: nil, page_token: nil)
  @compute.list_networks(@project,
                         filter: filter,
                         max_results: max_results,
                         order_by: order_by,
                         page_token: page_token)
end
list_region_operations(region, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source

Retrieves a list of Operation resources contained within the specified region @see developers.google.com/compute/docs/reference/latest/regionOperations/list

# File lib/fog/compute/google/requests/list_region_operations.rb, line 15
def list_region_operations(region, filter: nil, max_results: nil,
                           order_by: nil, page_token: nil)
  region = region.split("/")[-1] if region.start_with? "http"
  @compute.list_region_operations(
    @project, region,
    :filter => filter,
    :max_results => max_results,
    :order_by => order_by,
    :page_token => page_token
  )
end
list_regions(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_regions.rb, line 13
def list_regions(filter: nil, max_results: nil,
                 order_by: nil, page_token: nil)
  @compute.list_regions(
    @project, :filter => filter, :max_results => max_results,
              :order_by => order_by, :page_token => page_token
  )
end
list_routes(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source

Retrieves the list of Route resources available to the specified project.

@see cloud.google.com/compute/docs/reference/latest/routes/list

# File lib/fog/compute/google/requests/list_routes.rb, line 16
def list_routes(filter: nil, max_results: nil, order_by: nil, page_token: nil)
  @compute.list_routes(
    @project,
    :filter => filter,
    :max_results => max_results,
    :order_by => order_by,
    :page_token => page_token
  )
end
list_servers(zone, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_servers.rb, line 13
def list_servers(zone, filter: nil, max_results: nil,
                 order_by: nil, page_token: nil)
  @compute.list_instances(
    @project, zone.split("/")[-1],
    :filter => filter, :max_results => max_results,
    :order_by => order_by, :page_token => page_token
  )
end
list_snapshots(project = @project, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_snapshots.rb, line 13
def list_snapshots(project = @project, filter: nil, max_results: nil,
                   order_by: nil, page_token: nil)
  @compute.list_snapshots(project,
                          :filter => filter, :max_results => max_results,
                          :order_by => order_by, :page_token => page_token)
end
list_ssl_certificates(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_ssl_certificates.rb, line 13
def list_ssl_certificates(filter: nil, max_results: nil,
                          order_by: nil, page_token: nil)
  @compute.list_ssl_certificates(
    @project,
    :filter => filter,
    :max_results => max_results,
    :order_by => order_by,
    :page_token => page_token
  )
end
list_subnetworks(region_name, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source

Retrieves a list of subnetworks specific to a region and project.

@param region_name [String] the name of the subnetwork's region @param filter [String] A filter expression for filtering listed resources. @param max_results [Fixnum] Max number of results to return @param order_by [String] Sorts list results by a certain order @param page_token [String] specifies a page token to use @return [Google::Apis::ComputeV1::SubnetworkList] list result

@see cloud.google.com/compute/docs/reference/latest/subnetworks/list

# File lib/fog/compute/google/requests/list_subnetworks.rb, line 25
def list_subnetworks(region_name, filter: nil, max_results: nil,
                     order_by: nil, page_token: nil)
  if region_name.start_with? "http"
    region_name = region_name.split("/")[-1]
  end
  @compute.list_subnetworks(@project, region_name,
                            filter: filter,
                            max_results: max_results,
                            order_by: order_by,
                            page_token: page_token)
end
list_target_http_proxies(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_target_http_proxies.rb, line 14
def list_target_http_proxies(filter: nil, max_results: nil,
                             order_by: nil, page_token: nil)
  @compute.list_target_http_proxies(
    @project,
    :filter => filter, :max_results => max_results,
    :order_by => order_by, :page_token => page_token
  )
end
list_target_https_proxies(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_target_https_proxies.rb, line 13
def list_target_https_proxies(filter: nil, max_results: nil,
                              order_by: nil, page_token: nil)
  @compute.list_target_https_proxies(
    @project,
    :filter => filter, :max_results => max_results,
    :order_by => order_by, :page_token => page_token
  )
end
list_target_instances(zone, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_target_instances.rb, line 13
def list_target_instances(zone, filter: nil, max_results: nil,
                          order_by: nil, page_token: nil)
  zone = zone.split("/")[-1] if zone.start_with? "http"
  @compute.list_target_instances(
    @project, zone,
    :filter => filter,
    :max_results => max_results,
    :order_by => order_by,
    :page_token => page_token
  )
end
list_target_pools(region, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_target_pools.rb, line 13
def list_target_pools(region, filter: nil, max_results: nil,
                      order_by: nil, page_token: nil)
  @compute.list_target_pools(
    @project, region.split("/")[-1],
    filter: filter,
    max_results: max_results,
    order_by: order_by,
    page_token: page_token
  )
end
list_url_maps(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_url_maps.rb, line 14
def list_url_maps(filter: nil, max_results: nil,
                  order_by: nil, page_token: nil)
  @compute.list_url_maps(
    @project,
    filter: filter, max_results: max_results,
    order_by: order_by, page_token: page_token
  )
end
list_zone_operations(zone, filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source

@see developers.google.com/compute/docs/reference/latest/zoneOperations/list

# File lib/fog/compute/google/requests/list_zone_operations.rb, line 14
def list_zone_operations(zone, filter: nil, max_results: nil,
                         order_by: nil, page_token: nil)
  zone = zone.split("/")[-1] if zone.start_with? "http"
  @compute.list_zone_operations(
    @project, zone,
    :filter => filter,
    :max_results => max_results,
    :order_by => order_by,
    :page_token => page_token
  )
end
list_zones(filter: nil, max_results: nil, order_by: nil, page_token: nil) click to toggle source
# File lib/fog/compute/google/requests/list_zones.rb, line 13
def list_zones(filter: nil, max_results: nil,
               order_by: nil, page_token: nil)
  @compute.list_zones(
    @project,
    :filter => filter,
    :max_results => max_results,
    :order_by => order_by,
    :page_token => page_token
  )
end
patch_firewall(firewall_name, opts = {}) click to toggle source

Patch a Firewall resource. Supports PATCH semantics.

@see cloud.google.com/compute/docs/reference/latest/firewalls/patch

# File lib/fog/compute/google/requests/patch_firewall.rb, line 17
def patch_firewall(firewall_name, opts = {})
  opts = opts.select { |k, _| UPDATABLE_FIREWALL_FIELDS.include? k }
  @compute.patch_firewall(
    @project, firewall_name,
    ::Google::Apis::ComputeV1::Firewall.new(**opts)
  )
end
patch_url_map(url_map_name, options = {}) click to toggle source
# File lib/fog/compute/google/requests/patch_url_map.rb, line 13
def patch_url_map(url_map_name, options = {})
  @compute.patch_url_map(
    @project, url_map_name, ::Google::Apis::ComputeV1::UrlMap.new(options)
  )
end
process_disks(disks) click to toggle source
# File lib/fog/compute/google/requests/insert_server.rb, line 17
def process_disks(disks)
  unless disks && !disks.empty?
    raise ArgumentError.new("at least one value for disks is required")
  end

  disk_lst = disks.map do |d|
    d = d.attached_disk_obj if d.is_a? Disk
    ::Google::Apis::ComputeV1::AttachedDisk.new(**d)
  end
  disk_lst.first.boot = true
  disk_lst
end
process_network_interfaces(network_interfaces) click to toggle source
# File lib/fog/compute/google/requests/insert_server.rb, line 30
def process_network_interfaces(network_interfaces)
  unless network_interfaces && !network_interfaces.empty?
    network_interfaces = [default_network_interface]
  end
  network_interfaces.map do |network|
    ::Google::Apis::ComputeV1::NetworkInterface.new(**network)
  end
end
recreate_instances(instance_group_manager, instances) click to toggle source
# File lib/fog/compute/google/requests/recreate_instances.rb, line 13
def recreate_instances(instance_group_manager, instances)
  request = ::Google::Apis::ComputeV1::InstanceGroupManagersAbandonInstancesRequest.new(
    :instances => instances.map{ |i| i.class == String ? i : i.self_link }
  )
  if instance_group_manager.zone
    zone = instance_group_manager.zone.split("/")[-1]
    @compute.recreate_instance_group_manager_instances(@project, zone, instance_group_manager.name, request)
  else
    region = instance_group_manager.region.split("/")[-1]
    @compute.recreate_region_instance_group_manager_instances(@project, region, instance_group_manager.name, request)
  end
end
remove_instance_group_instances(group_name, zone, instances) click to toggle source
# File lib/fog/compute/google/requests/remove_instance_group_instances.rb, line 13
def remove_instance_group_instances(group_name, zone, instances)
  instances.map! do |instance|
    if instance.start_with?("https:")
      ::Google::Apis::ComputeV1::InstanceReference.new(instance: instance)
    else
      ::Google::Apis::ComputeV1::InstanceReference.new(
        instance: "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}/instances/#{instance}\n"
      )
    end
  end

  request = ::Google::Apis::ComputeV1::InstanceGroupsRemoveInstancesRequest.new(
    instances: instances
  )
  @compute.remove_instance_group_instances(
    @project,
    zone,
    group_name,
    request
  )
end
remove_target_pool_health_checks(target_pool, region, health_checks) click to toggle source
# File lib/fog/compute/google/requests/remove_target_pool_health_checks.rb, line 13
def remove_target_pool_health_checks(target_pool, region, health_checks)
  health_check_lst = health_checks.map do |hc|
    ::Google::Apis::ComputeV1::HealthCheckReference.new(health_check: hc)
  end

  @compute.remove_target_pool_health_check(
    @project,
    region.split("/")[-1],
    target_pool,
    ::Google::Apis::ComputeV1::RemoveTargetPoolsHealthCheckRequest.new(
      health_checks: health_check_lst
    )
  )
end
remove_target_pool_instances(target_pool, region, instances) click to toggle source
# File lib/fog/compute/google/requests/remove_target_pool_instance.rb, line 13
def remove_target_pool_instances(target_pool, region, instances)
  instance_lst = instances.map do |instance|
    ::Google::Apis::ComputeV1::InstanceReference.new(instance: instance)
  end

  @compute.remove_target_pool_instance(
    @project,
    region.split("/")[-1],
    target_pool,
    ::Google::Apis::ComputeV1::RemoveTargetPoolsInstanceRequest.new(
      instances: instance_lst
    )
  )
end
reset_server(identity, zone) click to toggle source
# File lib/fog/compute/google/requests/reset_server.rb, line 13
def reset_server(identity, zone)
  @compute.reset_instance(@project, zone.split("/")[-1], identity)
end
reset_windows_password(server:, user:) click to toggle source

Resets Windows passwords for users on Google's Windows based images. Code based on Google provided example.

@param instance [String] the name of the instance @param zone [String] the name of the zone of the instance @param user [String] the user whose password should be reset

@return [String] new password

@see cloud.google.com/compute/docs/instances/windows/automate-pw-generation

# File lib/fog/compute/google/requests/reset_windows_password.rb, line 44
def reset_windows_password(server:, user:)
  # Pull the e-mail address of user authenticated to API
  email = @compute.request_options.authorization.issuer

  # Create a new key
  key = OpenSSL::PKey::RSA.new(2048)
  modulus, exponent = get_modulus_exponent_in_base64(key)

  # Get Old Metadata
  old_metadata = server.metadata

  # Create JSON Object with needed information
  metadata_entry = get_json_string(user, modulus, exponent, email)

  # Create new metadata object
  new_metadata = update_windows_keys(old_metadata, metadata_entry)

  # Set metadata on instance
  server.set_metadata(new_metadata, false)

  # Get encrypted password from Serial Port 4 Output

  # If machine is booting for the first time, there appears to be a
  # delay before the password appears on the serial port.
  sleep(1) until server.ready?
  serial_port_output = server.serial_port_output(:port => 4)
  loop_cnt = 0
  while serial_port_output.empty?
    if loop_cnt > 12
      Fog::Logger.warning("Encrypted password never found on Serial Output Port 4")
      raise "Could not reset password."
    end
    sleep(5)
    serial_port_output = server.serial_port_output(:port => 4)
    loop_cnt += 1
  end

  # Parse and decrypt password
  enc_password = get_encrypted_password_from_serial_port(serial_port_output, modulus)
  password = decrypt_password(enc_password, key)

  return password
end
set_common_instance_metadata(project, current_fingerprint, metadata = {}) click to toggle source
# File lib/fog/compute/google/requests/set_common_instance_metadata.rb, line 13
def set_common_instance_metadata(project, current_fingerprint, metadata = {})
  metadata_obj = ::Google::Apis::ComputeV1::Metadata.new(
    fingerprint: current_fingerprint,
    items: metadata.map { |k, v| { :key => k, :value => v } }
  )
  @compute.set_common_instance_metadata(project, metadata_obj)
end
set_forwarding_rule_target(rule_name, region, target_opts) click to toggle source
# File lib/fog/compute/google/requests/set_forwarding_rule_target.rb, line 13
def set_forwarding_rule_target(rule_name, region, target_opts)
  region = region.split("/")[-1] if region.start_with? "http"
  @compute.set_forwarding_rule_target(
    @project, region, rule_name,
    ::Google::Apis::ComputeV1::TargetReference.new(**target_opts)
  )
end
set_global_forwarding_rule_target(rule_name, target_opts) click to toggle source
# File lib/fog/compute/google/requests/set_global_forwarding_rule_target.rb, line 13
def set_global_forwarding_rule_target(rule_name, target_opts)
  @compute.set_global_forwarding_rule_target(
    @project, rule_name,
    ::Google::Apis::ComputeV1::TargetReference.new(**target_opts)
  )
end
set_instance_template(instance_group_manager, instance_template) click to toggle source
# File lib/fog/compute/google/requests/set_instance_template.rb, line 13
def set_instance_template(instance_group_manager, instance_template)
  request = ::Google::Apis::ComputeV1::InstanceGroupManagersSetInstanceTemplateRequest.new(
    :instance_template => instance_template.class == String ? instance_template : instance_template.self_link
  )
  if instance_group_manager.zone
    zone = instance_group_manager.zone.split("/")[-1]
    @compute.set_instance_group_manager_instance_template(@project, zone, instance_group_manager.name, request)
  else
    region = instance_group_manager.region.split("/")[-1]
    @compute.set_region_instance_group_manager_instance_template(@project, region, instance_group_manager.name, request)
  end
end
set_server_disk_auto_delete(identity, zone, auto_delete, device_name) click to toggle source

@see cloud.google.com/compute/docs/reference/latest/instances/setDiskAutoDelete

# File lib/fog/compute/google/requests/set_server_disk_auto_delete.rb, line 14
def set_server_disk_auto_delete(identity, zone, auto_delete, device_name)
  @compute.set_disk_auto_delete(
    @project,
    zone.split("/")[-1],
    identity,
    auto_delete,
    device_name
  )
end
set_server_machine_type(instance, zone, machine_type) click to toggle source
# File lib/fog/compute/google/requests/set_server_machine_type.rb, line 13
def set_server_machine_type(instance, zone, machine_type)
  request = ::Google::Apis::ComputeV1::InstancesSetMachineTypeRequest.new
  zone = zone.split("/")[-1]
  machine_type = machine_type.split("/")[-1]
  request.machine_type = "zones/#{zone}/machineTypes/#{machine_type}"
  @compute.set_instance_machine_type(@project, zone, instance, request)
end
set_server_metadata(instance, zone, fingerprint, metadata_items = []) click to toggle source

Set an instance metadata

@param [String] instance Instance name (identity) @param [String] zone Name of zone @param [String] fingerprint 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']

@param [Hash] metadata A new metadata object

Should have the following structure:
{'foo' => 'bar', 'baz'=>'foo'}

@returns [::Google::Apis::ComputeV1::Operation] set operation

# File lib/fog/compute/google/requests/set_server_metadata.rb, line 27
def set_server_metadata(instance, zone, fingerprint, metadata_items = [])
  items = metadata_items.map { |item| ::Google::Apis::ComputeV1::Metadata::Item.new(**item) }
  @compute.set_instance_metadata(
    @project, zone.split("/")[-1], instance,
    ::Google::Apis::ComputeV1::Metadata.new(
      fingerprint: fingerprint, items: items
    )
  )
end
set_server_scheduling(identity, zone, on_host_maintenance: nil, automatic_restart: nil, preemptible: nil) click to toggle source
# File lib/fog/compute/google/requests/set_server_scheduling.rb, line 13
def set_server_scheduling(identity, zone, on_host_maintenance: nil, automatic_restart: nil, preemptible: nil)
  scheduling = ::Google::Apis::ComputeV1::Scheduling.new
  scheduling.on_host_maintenance = on_host_maintenance unless on_host_maintenance.nil?
  scheduling.automatic_restart = automatic_restart unless automatic_restart.nil?
  scheduling.preemptible = preemptible unless preemptible.nil?
  zone = zone.split("/")[-1]
  @compute.set_instance_scheduling(@project, zone, identity, scheduling)
end
set_server_tags(instance, zone, fingerprint, tags = []) click to toggle source
# File lib/fog/compute/google/requests/set_server_tags.rb, line 13
def set_server_tags(instance, zone, fingerprint, tags = [])
  @compute.set_instance_tags(
    @project, zone.split("/")[-1], instance,
    ::Google::Apis::ComputeV1::Tags.new(
      fingerprint: fingerprint,
      items: tags
    )
  )
end
set_snapshot_labels(snap_name, label_fingerprint, labels) click to toggle source
# File lib/fog/compute/google/requests/set_snapshot_labels.rb, line 13
def set_snapshot_labels(snap_name, label_fingerprint, labels)
  @compute.set_snapshot_labels(
    project, snap_name,
    ::Google::Apis::ComputeV1::GlobalSetLabelsRequest.new(
      label_fingerprint: label_fingerprint,
      labels: labels
    )
  )
end
set_subnetwork_private_ip_google_access(subnetwork_name, region_name, private_ip_google_access) click to toggle source

Set whether VMs in this subnet can access Google services without assigning external IP addresses through Private Google Access.

@param subnetwork_name [String] the name of the subnetwork @param region_name [String] the name of the subnetwork's region @param private_ip_google_access [Boolean] whether

private ip google access should be enforced

@return [Google::Apis::ComputeV1::Operation] an operation response

@see cloud.google.com/compute/docs/reference/latest/subnetworks/setPrivateIpGoogleAccess

# File lib/fog/compute/google/requests/set_subnetwork_private_ip_google_access.rb, line 26
def set_subnetwork_private_ip_google_access(subnetwork_name,
                                            region_name,
                                            private_ip_google_access)
  if region_name.start_with? "http"
    region_name = region_name.split("/")[-1]
  end
  @compute.set_subnetwork_private_ip_google_access(
    @project, region_name, subnetwork_name,
    ::Google::Apis::ComputeV1::SubnetworksSetPrivateIpGoogleAccessRequest.new(
      private_ip_google_access: private_ip_google_access
    )
  )
end
set_target_http_proxy_url_map(proxy_name, url_map) click to toggle source
# File lib/fog/compute/google/requests/set_target_http_proxy_url_map.rb, line 13
def set_target_http_proxy_url_map(proxy_name, url_map)
  @compute.set_target_http_proxy_url_map(
    @project, proxy_name,
    ::Google::Apis::ComputeV1::UrlMapReference.new(
      url_map: url_map.class == String ? url_map : url_map.self_link
    )
  )
end
set_target_https_proxy_ssl_certificates(proxy_name, certs) click to toggle source
# File lib/fog/compute/google/requests/set_target_https_proxy_ssl_certificates.rb, line 13
def set_target_https_proxy_ssl_certificates(proxy_name, certs)
  @compute.set_target_https_proxy_ssl_certificates(
    @project, proxy_name,
    ::Google::Apis::ComputeV1::TargetHttpsProxiesSetSslCertificatesRequest.new(
      ssl_certificates: certs
    )
  )
end
set_target_https_proxy_url_map(proxy_name, url_map) click to toggle source
# File lib/fog/compute/google/requests/set_target_https_proxy_url_map.rb, line 13
def set_target_https_proxy_url_map(proxy_name, url_map)
  @compute.set_target_https_proxy_url_map(
    @project, proxy_name,
    ::Google::Apis::ComputeV1::UrlMapReference.new(
      url_map: url_map.class == String ? url_map : url_map.self_link
    )
  )
end
set_target_pool_backup(target_pool, region, backup_target, failover_ratio: nil) click to toggle source
# File lib/fog/compute/google/requests/set_target_pool_backup.rb, line 14
def set_target_pool_backup(target_pool, region, backup_target,
                           failover_ratio: nil)
  target_ref = ::Google::Apis::ComputeV1::TargetReference.new(
    target: backup_target
  )

  @compute.set_target_pool_backup(
    project,
    region.split("/")[-1],
    target_pool,
    target_ref,
    failover_ratio: failover_ratio
  )
end
start_server(identity, zone) click to toggle source
# File lib/fog/compute/google/requests/start_server.rb, line 13
def start_server(identity, zone)
  @compute.start_instance(@project, zone.split("/")[-1], identity)
end
stop_server(identity, zone) click to toggle source
# File lib/fog/compute/google/requests/stop_server.rb, line 13
def stop_server(identity, zone)
  @compute.stop_instance(@project, zone.split("/")[-1], identity)
end
update_firewall(firewall_name, opts = {}) click to toggle source

Update a Firewall resource.

Only the following fields can/will be changed.

@param [Hash] opts The firewall object to create @option opts [Array<Hash>] allowed @option opts [String] description @option opts [Array<String>] destination_ranges @option opts [Array<String>] source_ranges @option opts [Array<String>] source_service_accounts @option opts [Array<String>] source_tags @option opts [Array<String>] target_service_accounts @option opts [Array<String>] target_tags

@see cloud.google.com/compute/docs/reference/latest/firewalls/insert

# File lib/fog/compute/google/requests/update_firewall.rb, line 39
def update_firewall(firewall_name, opts = {})
  opts = opts.select { |k, _| UPDATABLE_FIREWALL_FIELDS.include? k }
  @compute.update_firewall(
    @project, firewall_name,
    ::Google::Apis::ComputeV1::Firewall.new(**opts)
  )
end
update_http_health_check(check_name, opts = {}) click to toggle source
# File lib/fog/compute/google/requests/update_http_health_check.rb, line 13
def update_http_health_check(check_name, opts = {})
  @compute.update_http_health_check(
    @project,
    check_name,
    ::Google::Apis::ComputeV1::HttpHealthCheck.new(
      **opts.merge(:name => check_name)
    )
  )
end
update_url_map(url_map_name, url_map = {}) click to toggle source
# File lib/fog/compute/google/requests/update_url_map.rb, line 13
def update_url_map(url_map_name, url_map = {})
  url_map[:host_rules] = url_map[:host_rules] || []
  url_map[:path_matchers] = url_map[:path_matchers] || []
  url_map[:tests] = url_map[:tests] || []

  @compute.update_url_map(
    @project, url_map_name,
    ::Google::Apis::ComputeV1::UrlMap.new(
      url_map.merge(name: url_map_name)
    )
  )
end
update_windows_keys(old_metadata, metadata_entry) click to toggle source
# File lib/fog/compute/google/requests/reset_windows_password.rb, line 112
def update_windows_keys(old_metadata, metadata_entry)
  if old_metadata[:items]
    new_metadata = Hash[old_metadata[:items].map { |item| [item[:key], item[:value]] }]
  else
    new_metadata = {}
  end
  new_metadata["windows-keys"] = metadata_entry
  return new_metadata
end
validate_url_map(url_map_name, url_map = {}) click to toggle source
# File lib/fog/compute/google/requests/validate_url_map.rb, line 13
def validate_url_map(url_map_name, url_map = {})
  @compute.validate_url_map(
    @project, url_map_name,
    ::Google::Apis::ComputeV1::ValidateUrlMapsRequest.new(
      url_map: ::Google::Apis::ComputeV1::UrlMap.new(**url_map)
    )
  )
end