gitlab-fog-google 1.13.0

data/examples/image_create.rb

@@ -0,0 +1,17 @@
+def test
+  connection = Fog::Compute.new(:provider => "Google")
+
+  rawdisk = {
+    :source         => nil, # Google Cloud Storage URL pointing to the disk image. (e.g. http://storage.googleapis.com/test/test.tar.gz)
+    :container_type => "TAR"
+  }
+
+  # Can't test this unless the 'source' points to a valid URL
+  return if rawdisk[:source].nil?
+
+  img = connection.images.create(:name             => "test-image",
+                                 :description      => "Test image (via fog)",
+                                 :raw_disk         => rawdisk)
+
+  img.reload # will raise if image was not saved correctly
+end

data/examples/l7_load_balance.rb

@@ -0,0 +1,79 @@
+# This example assumes three instances have been created in the project.
+# They should each have Apache installed and distinct index.html files
+# in order to observe the results of the l7 load balancer. A firewall
+# rule should also have been created with a tag shared by the instances.
+# More info on Google's HTTP load balancing:
+# https://developers.google.com/compute/docs/load-balancing/http/
+
+def test
+  connection = Fog::Compute.new(:provider => "google")
+  health = connection.http_health_checks.create(:name => "test-checks")
+  instance1 = connection.servers.get("fog-l7-instance-1")
+  instance2 = connection.servers.get("fog-l7-instance-2")
+  instance3 = connection.servers.get("fog-l7-instance-3")
+
+  resource_view1 = connection.resource_views.create(
+    :name => "fog-l7-resource-view-1",
+    :numMembers => 1,
+    :members => [instance1.self_link],
+    :zone => "us-central1-a"
+  )
+  resource_view1.add_resources(instance1.self_link)
+  resource_view2 = connection.resource_views.create(
+    :name => "fog-l7-resource-view-2",
+    :numMembers => 1,
+    :members => [instance2.self_link],
+    :zone => "us-central1-a"
+  )
+  resource_view2.add_resources(instance2.self_link)
+  resource_view3 = connection.resource_views.create(
+    :name => "fog-l7-resource-view-3",
+    :members => [instance3.self_link],
+    :zone => "us-central1-b"
+  )
+  resource_view3.add_resources(instance3.self_link)
+  backend_service1 = connection.backend_services.create(
+    :name => "fog-l7-backend-service-1",
+    :health_checks => [health.self_link],
+    :backends => [{ "balancingMode" => "RATE", "maxRate" => 100, "group" => resource_view1.self_link }]
+  )
+  backend_service2 = connection.backend_services.create(
+    :name => "fog-l7-backend-service-2",
+    :health_checks => [health.self_link],
+    :backends => [{ "balancingMode" => "RATE", "maxRate" => 100, "group" => resource_view2.self_link }]
+  )
+  backend_service3 = connection.backend_services.create(
+    :name => "fog-l7-backend-service-3",
+    :health_checks => [health.self_link],
+    :backends => [{ "balancingMode" => "RATE", "maxRate" => 100, "group" => resource_view3.self_link }]
+  )
+  url_map = connection.url_maps.create(
+    :name => "fog-l7-url-map",
+    :pathMatchers => [{
+      "name" => "pathmatcher",
+      "defaultService" => backend_service1.self_link,
+      "pathRules" => [
+        {
+          "paths" => ["/one/*"],
+          "service" => backend_service1.self_link
+        },
+        {
+          "paths" => ["/two/*"],
+          "service" => backend_service2.self_link
+        },
+        {
+          "paths" => ["/three/*"],
+          "service" => backend_service3.self_link
+        }
+      ]
+    }],
+    :hostRules => [{ "hosts" => ["*"], "pathMatcher" => "pathmatcher" }],
+    :default_service => backend_service1.self_link
+  )
+  proxy = connection.target_http_proxies.create(
+    :name => "fog-l7-proxy",
+    :url_map => url_map.self_link
+  )
+
+  connection.global_forwarding_rules.create(:name => "fog-l7-fwd-rule", :target => proxy.self_link)
+end

data/examples/load-balance.rb

@@ -0,0 +1,116 @@
+# All examples presume that you have a ~/.fog credentials file set up.
+# More info on it can be found here: http://fog.io/about/getting_started.html
+
+require "bundler"
+Bundler.require(:default, :development)
+# Uncomment this if you want to make real requests to GCE (you _will_ be billed!)
+# WebMock.disable!
+
+def test
+  # Config
+  name = "fog-lb-test-#{Time.now.to_i}"
+  zone = "europe-west1-d"
+  region = "europe-west1"
+
+  # Setup
+  gce = Fog::Compute.new :provider => "Google"
+  servers = []
+
+  puts "Creating instances..."
+  puts "--------------------------------"
+  (1..3).each do |i|
+    begin
+      disk = gce.disks.create(
+        :name => "#{name}-#{i}",
+        :size_gb => 10,
+        :zone_name => zone,
+        :source_image => "debian-9-stretch-v20180611"
+      )
+      disk.wait_for { disk.ready? }
+    rescue
+      puts "Failed to create disk #{name}-#{i}"
+    end
+
+    begin
+      server = gce.servers.create(
+        :name => "#{name}-#{i}",
+        :disks => [disk.get_as_boot_disk(true, true)],
+        :machine_type => "f1-micro",
+        :zone_name => zone
+      )
+      servers << server
+    rescue
+      puts "Failed to create instance #{name}-#{i}"
+    end
+  end
+
+  puts "Creating health checks..."
+  puts "--------------------------------"
+  begin
+    health = gce.http_health_checks.new(:name => name)
+    health.save
+  rescue
+    puts "Failed to create health check #{name}"
+  end
+
+  puts "Creating a target pool..."
+  puts "--------------------------------"
+  begin
+    pool = gce.target_pools.new(
+      :name => name,
+      :region => region,
+      :health_checks => [health.self_link],
+      :instances => servers.map(&:self_link)
+    )
+    pool.save
+  rescue
+    puts "Failed to create target pool #{name}"
+  end
+
+  puts "Creating forwarding rules..."
+  puts "--------------------------------"
+  begin
+    rule = gce.forwarding_rules.new(
+      :name => name,
+      :region => region,
+      :port_range => "1-65535",
+      :ip_protocol => "TCP",
+      :target => pool.self_link
+    )
+    rule.save
+  rescue
+    puts "Failed to create forwarding rule #{name}"
+  end
+
+  # TODO(bensonk): Install apache, create individualized htdocs, and run some
+  #                actual requests through the load balancer.
+
+  # Cleanup
+  puts "Cleaning up..."
+  puts "--------------------------------"
+  begin
+    rule.destroy
+  rescue
+    puts "Failed to clean up forwarding rule."
+  end
+
+  begin
+    pool.destroy
+  rescue
+    puts "Failed to clean up target pool."
+  end
+
+  begin
+    health.destroy
+  rescue
+    puts "Failed to clean up health check."
+  end
+
+  begin
+    servers.each(&:destroy)
+  rescue
+    puts "Failed to clean up instances."
+  end
+end
+
+test

data/examples/metadata.rb

@@ -0,0 +1,40 @@
+# All examples presume that you have a ~/.fog credentials file set up.
+# More info on it can be found here: http://fog.io/about/getting_started.html
+
+require "bundler"
+Bundler.require(:default, :development)
+# Uncomment this if you want to make real requests to GCE (you _will_ be billed!)
+# WebMock.disable!
+
+def test
+  connection = Fog::Compute.new(:provider => "Google")
+
+  name = "fog-smoke-test-#{Time.now.to_i}"
+
+  disk = connection.disks.create(
+    :name => name,
+    :size_gb => 10,
+    :zone_name => "us-central1-f",
+    :source_image => "debian-9-stretch-v20180611"
+  )
+
+  disk.wait_for { disk.ready? }
+
+  server = connection.servers.create(
+    :name => name,
+    :disks => [disk],
+    :machine_type => "n1-standard-1",
+    :zone_name => "us-central1-f",
+    :private_key_path => File.expand_path("~/.ssh/id_rsa"),
+    :public_key_path => File.expand_path("~/.ssh/id_rsa.pub")
+  )
+
+  server.wait_for { ready? }
+
+  server.metadata["test"] = "foo"
+
+  raise "Metadata was not set." unless server.metadata["test"] == "foo"
+  raise "Could not delete server." unless server.destroy
+end
+
+test

data/examples/monitoring/metric_descriptors.rb

@@ -0,0 +1,24 @@
+# All examples presume that you have a ~/.fog credentials file set up.
+# # More info on it can be found here: http://fog.io/about/getting_started.html
+#
+require "bundler"
+Bundler.require(:default, :development)
+# Uncomment this if you want to make real requests to GCE (you _will_ be billed!)
+# WebMock.disable!
+#
+
+def test
+  connection = Fog::Google::Monitoring.new
+
+  puts "Listing all MetricDescriptors..."
+  puts "--------------------------------"
+  md = connection.metric_descriptors
+  puts "Number of all metric descriptors: #{md.length}"
+
+  puts "\nListing all MetricDescriptors related to Google Compute Engine..."
+  puts "-----------------------------------------------------------------"
+  md = connection.metric_descriptors.all(:filter => 'metric.type = starts_with("compute.googleapis.com")')
+  puts "Number of compute metric descriptors: #{md.length}"
+end
+
+test

data/examples/monitoring/monitored_resource_descriptors.rb

@@ -0,0 +1,24 @@
+# All examples presume that you have a ~/.fog credentials file set up.
+# # More info on it can be found here: http://fog.io/about/getting_started.html
+#
+require "bundler"
+Bundler.require(:default, :development)
+# Uncomment this if you want to make real requests to GCE (you _will_ be billed!)
+# WebMock.disable!
+#
+
+def test
+  connection = Fog::Google::Monitoring.new
+
+  puts "Listing all MonitoredResourceDescriptors..."
+  puts "--------------------------------"
+  md = connection.monitored_resource_descriptors
+  puts "Number of all monitored resource descriptors: #{md.length}"
+
+  puts "\nListing MonitoredResourceDescriptors related to Google Compute Engine..."
+  puts "-----------------------------------------------------------------"
+  md = connection.monitored_resource_descriptors.all(:filter => 'resource.type = starts_with("gce_")')
+  puts "Number of compute monitored resource : #{md.length}"
+end
+
+test

data/examples/monitoring/timeseries_collection.rb

@@ -0,0 +1,32 @@
+# All examples presume that you have a ~/.fog credentials file set up.
+# # More info on it can be found here: http://fog.io/about/getting_started.html
+#
+require "bundler"
+Bundler.require(:default, :development)
+# Uncomment this if you want to make real requests to GCE (you _will_ be billed!)
+# WebMock.disable!
+
+def test
+  connection = Fog::Google::Monitoring.new
+  interval = {
+    :start_time => (Time.now - 1).rfc3339,
+    :end_time => Time.now.to_datetime.rfc3339
+  }
+  puts "Listing Timeseries from the last hour for metric compute.googleapis.com/instance/uptime..."
+  puts "-------------------------------------------------------------------------------"
+  tc = connection.timeseries_collection.all(:filter => 'metric.type = "compute.googleapis.com/instance/uptime"',
+                                            :interval => interval)
+  puts "Number of matches: #{tc.length}"
+
+  puts "\nListing all Timeseries for metric compute.googleapis.com/instance/uptime &"
+  puts "the region us-central1..."
+  puts "------------------------------------------------------------------------------"
+  filter = [
+    'metric.type = "compute.googleapis.com/instance/uptime"',
+    'resource.label.zone = "us-central1-c"'
+  ].join(" AND ")
+  tc = connection.timeseries_collection.all(:filter => filter, :interval => interval)
+  puts "Number of matches: #{tc.length}"
+end
+
+test

data/examples/network.rb

@@ -0,0 +1,55 @@
+# All examples presume that you have a ~/.fog credentials file set up.
+# More info on it can be found here: http://fog.io/about/getting_started.html
+
+require "bundler"
+Bundler.require(:default, :development)
+# Uncomment this if you want to make real requests to GCE (you _will_ be billed!)
+# WebMock.disable!
+
+def test
+  connection = Fog::Compute.new(:provider => "Google")
+
+  puts "Creating a new private network..."
+  puts "---------------------------------"
+  network = connection.networks.create(
+    :name => "test-private-network",
+    :ipv4_range => "10.240.0.0/16"
+  )
+
+  name = "fog-smoke-test-#{Time.now.to_i}"
+
+  puts "Creating a disk for an instance..."
+  puts "---------------------------------"
+  disk = connection.disks.create(
+    :name => name,
+    :size_gb => 10,
+    :zone_name => "us-central1-a",
+    :source_image => "debian-9-stretch-v20180611"
+  )
+
+  disk.wait_for { disk.ready? }
+
+  puts "Spinning up an instance with private network config..."
+  puts "------------------------------------------------------"
+  server = connection.servers.create(
+    :name => name,
+    :disks => [disk],
+    :machine_type => "n1-standard-1",
+    :zone_name => "us-central1-a",
+    :private_key_path => File.expand_path("~/.ssh/id_rsa"),
+    :public_key_path => File.expand_path("~/.ssh/id_rsa.pub"),
+    :network => network,
+    :external_ip => false,
+    :username => ENV["USER"]
+  )
+
+  # The network won't have any firewall rules, so we won't be able to ssh in.
+  server.wait_for { ready? }
+
+  raise "Could not delete server." unless server.destroy
+  raise "Could not delete network." unless network.destroy
+rescue StandardError => e
+  p e.message
+end
+
+test

data/examples/precreated_client.rb

@@ -0,0 +1,24 @@
+# All examples presume that you have a ~/.fog credentials file set up.
+# More info on it can be found here: http://fog.io/about/getting_started.html
+
+require "bundler"
+Bundler.require(:default, :development)
+# Uncomment this if you want to make real requests to GCE (you _will_ be billed!)
+# WebMock.disable!
+
+# This example shows how to work with fog using a pre-created Google API client
+# with specific parameters, should you want to for any reason.
+
+def test
+  client = Google::APIClient.new(:application_name => "supress")
+  connection = Fog::Compute.new(:provider => "Google", :google_client => client)
+
+  begin
+    p connection.client.discovered_apis
+    p connection.servers
+  rescue StandardError => e
+    p e.message
+  end
+end
+
+test

data/examples/pubsub/subscriptions.rb

@@ -0,0 +1,54 @@
+# All examples presume that you have a ~/.fog credentials file set up.
+# # More info on it can be found here: http://fog.io/about/getting_started.html
+#
+require "bundler"
+Bundler.require(:default, :development)
+# Uncomment this if you want to make real requests to GCE (you _will_ be billed!)
+# WebMock.disable!
+
+def test
+  connection = Fog::Google::Pubsub.new
+
+  puts "Creating a topic to subscribe to"
+  puts "--------------------------------"
+  topic = connection.topics.create(:name => "projects/#{connection.project}/topics/#{Fog::Mock.random_letters(16)}")
+
+  puts "Creating a subscription"
+  puts "-----------------------"
+  subscription = connection.subscriptions.create(:name => "projects/#{connection.project}/subscriptions/#{Fog::Mock.random_letters(16)}", :topic => topic)
+
+  puts "Getting a subscription"
+  puts "----------------------"
+  connection.subscriptions.get(subscription.name)
+
+  puts "Listing all subscriptions"
+  puts "-------------------------"
+  connection.subscriptions.all
+
+  puts "Publishing to topic"
+  puts "-------------------"
+  topic.publish(["test message"])
+
+  puts "Pulling from subscription"
+  puts "-------------------------"
+
+  msgs = []
+  msgs = subscription.pull while msgs.empty?
+
+  puts "Acknowledging pulled messages"
+  puts "-----------------------------"
+  subscription.acknowledge(msgs)
+
+  # Alternatively, received messages themselves can be acknowledged
+  msgs.each(&:acknowledge)
+
+  puts "Deleting the subscription"
+  puts "-------------------------"
+  subscription.destroy
+
+  puts "Deleting the topic subscribed to"
+  puts "--------------------------------"
+  topic.destroy
+end
+
+test