fog-google 0.1.3 → 0.2.0

data/examples/backend_services.rb

@@ -1,21 +1,22 @@
-require 'rubygems'
-require 'fog'
+require "rubygems"
+require "fog"
 
 def test
-  connection = Fog::Compute.new({:provider => "google"})
-  health = connection.http_health_checks.create({
-    :name => 'test-checks'
-  })
+  connection = Fog::Compute.new(:provider => "google")
+  health = connection.http_health_checks.create(:name => "test-checks")
   health.wait_for { health.ready? }
-  backend= connection.backend_services.create({
-    :name => 'backend-test',
+  backend = connection.backend_services.create(
+    :name => "backend-test",
     :health_checks => [health.self_link],
     :port => 8080,
     :timeout_sec => 40,
-    :backends => [{'group' => 'resource_view self_link'}]
-  })
+    :backends => [{ "group" => "resource_view self_link" }]
+  )
+  backend.get_health
+
   puts connection.backend_services.all
-  backend= connection.backend_services.get('backend-test')
+
+  backend = connection.backend_services.get("backend-test")
   backend.get_health
 end
 

data/examples/bootstrap.rb

@@ -1,5 +1,13 @@
+# 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" })
+  connection = Fog::Compute.new(:provider => "Google")
 
   server = connection.servers.bootstrap
   server.wait_for { sshable? }
@@ -7,3 +15,5 @@ def test
   raise "Could not bootstrap sshable server." unless server.ssh("whoami")
   raise "Could not delete server." unless server.destroy
 end
+
+test

data/examples/{create.rb → create_instance.rb}

@@ -1,29 +1,36 @@
+# 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" })
+  connection = Fog::Compute.new(:provider => "Google")
 
   name = "fog-smoke-test-#{Time.now.to_i}"
 
-  disk = connection.disks.create({
+  disk = connection.disks.create(
     :name => name,
     :size_gb => 10,
-    :zone_name => 'us-central1-a',
-    :source_image => 'debian-7-wheezy-v20131120',
-  })
+    :zone_name => "us-central1-f",
+    :source_image => "debian-7-wheezy-v20151104")
 
   disk.wait_for { disk.ready? }
 
-  server = connection.servers.create(defaults = {
+  server = connection.servers.create(
     :name => "fog-smoke-test-#{Time.now.to_i}",
     :disks => [disk],
     :machine_type => "n1-standard-1",
     :private_key_path => File.expand_path("~/.ssh/id_rsa"),
     :public_key_path => File.expand_path("~/.ssh/id_rsa.pub"),
-    :zone_name => "us-central1-a",
-    :user => ENV['USER'],
-    :tags => ["fog"]
-  })
+    :zone_name => "us-central1-f",
+    :user => ENV["USER"],
+    :tags => ["fog"],
+    :service_accounts => %w(sql-admin bigquery https://www.googleapis.com/auth/compute))
 
-  # My own wait_for because it hides errors
+  # Wait_for routine copied here to show errors, if necessary.
   duration = 0
   interval = 5
   timeout = 600
@@ -47,3 +54,5 @@ def test
   raise "Could not bootstrap sshable server." unless server.ssh("whoami")
   raise "Could not delete server." unless server.destroy
 end
+
+test

data/examples/dns/project.rb

@@ -1,8 +1,7 @@
 def test
   connection = Fog::DNS::Google.new
 
-  puts 'Get the Project limits...'
-  puts '-------------------------'
+  puts "Get the Project limits..."
+  puts "-------------------------"
   connection.projects.get(Fog::DNS[:google].project)
-
 end

data/examples/dns/zones.rb

@@ -1,43 +1,43 @@
 def test
   connection = Fog::DNS::Google.new
 
-  puts 'Create a Zone...'
-  puts '----------------'
-  zone = connection.zones.create(name: 'mytestdomain', domain: 'example.org.', description: 'This is my test domain')
+  puts "Create a Zone..."
+  puts "----------------"
+  zone = connection.zones.create(:name => "mytestdomain", :domain => "example.org.", :description => "This is my test domain")
 
-  puts 'List all Zones...'
-  puts '-----------------'
+  puts "List all Zones..."
+  puts "-----------------"
   connection.zones.all
 
-  puts 'Get the Zone...'
-  puts '---------------'
+  puts "Get the Zone..."
+  puts "---------------"
   zone = connection.zones.get(zone.id)
 
   puts 'Create an "A" Record...'
-  puts '-----------------------'
-  record = zone.records.create(name: 'test.example.org.', type: 'A', ttl: 3600, rrdatas: ['192.168.1.1'])
+  puts "-----------------------"
+  zone.records.create(:name => "test.example.org.", :type => "A", :ttl => 3600, :rrdatas => ["192.168.1.1"])
 
-  puts 'Get the Zone Resource Record Sets...'
-  puts '------------------------------------'
+  puts "Get the Zone Resource Record Sets..."
+  puts "------------------------------------"
   zone.records
 
-  puts 'Get the Record...'
-  puts '-----------------'
-  record = connection.records(zone: zone).get(name: 'test.example.org.', type: 'A')
+  puts "Get the Record..."
+  puts "-----------------"
+  record = connection.records(:zone => zone).get("test.example.org.", "A")
 
   puts 'Modify the "A" Record...'
-  puts '------------------------'
-  record.modify(ttl: 2600)
+  puts "------------------------"
+  record.modify(:ttl => 2600)
 
   puts 'Delete the "A" Record...'
-  puts '------------------------'
+  puts "------------------------"
   record.destroy
 
-  puts 'Get the Zone Changes...'
-  puts '-----------------------'
+  puts "Get the Zone Changes..."
+  puts "-----------------------"
   zone.changes
 
-  puts 'Delete the Zone...'
-  puts '------------------'
+  puts "Delete the Zone..."
+  puts "------------------"
   zone.destroy
 end

data/examples/get_list_images.rb

@@ -1,26 +1,42 @@
+# 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" })
+  connection = Fog::Compute.new(:provider => "Google")
 
-  # puts 'Listing images in all projects...'
-  # puts '---------------------------------'
+  puts "Listing images in all projects..."
+  puts "---------------------------------"
   images = connection.images.all
-  raise 'Could not LIST the images' unless images
-  # puts images.inspect
+  raise "Could not LIST the images" unless images
+  puts images.inspect
 
-  # puts 'Fetching a single image from a global project...'
-  # puts '------------------------------------------------'
-  img = connection.images.get('debian-6-squeeze-v20130515')
-  raise 'Could not GET the image' unless img
-  # puts img.inspect
+  puts "Listing current (non-deprecated) images in all projects..."
+  puts "----------------------------------------------------------"
+  images = connection.images.current
+  raise "Could not LIST current images" unless images
+  puts images.inspect
+
+  puts "Fetching a single image from a global project..."
+  puts "------------------------------------------------"
+  img = connection.images.get("debian-7-wheezy-v20151104")
+  raise "Could not GET the image" unless img
+  puts img.inspect
 
   # First, get the name of an image that is in the users 'project' (not global)
-  custom_img_name = images.find { |img| img.project == img.service.project }
+  custom_img_name = images.detect { |i| i.project.eql? i.service.project }
   # Run the next test only if there is a custom image available
   if custom_img_name
-    # puts 'Fetching a single image from the custom project'
-    # puts '----------------------------------------------'
+    puts "Fetching a single image from the custom project"
+    puts "----------------------------------------------"
     img = connection.images.get(custom_img_name.name)
-    raise 'Could not GET the (custom) image' unless img
-    # puts img.inspect
+    raise "Could not GET the (custom) image" unless img
+    puts img.inspect
   end
 end
+
+test

data/examples/get_list_snapshots.rb

@@ -1,18 +1,28 @@
+# 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" })
+  connection = Fog::Compute.new(:provider => "Google")
 
-  # puts 'Listing snapshots...'
-  # puts '---------------------------------'
+  puts "Listing snapshots..."
+  puts "---------------------------------"
   snapshots = connection.snapshots.all
-  raise 'Could not LIST the snapshots' unless snapshots
-  # puts snapshots.inspect
+  raise "Could not LIST the snapshots" unless snapshots
+  puts snapshots.inspect
 
-  # puts 'Fetching a single snapshot...'
-  # puts '------------------------------------------------'
+  puts "Fetching a single snapshot..."
+  puts "------------------------------------------------"
   snap = snapshots.first
-  if !snap.nil?
+  unless snap.nil?
     snap = connection.snapshots.get(snap)
-    raise 'Could not GET the snapshot' unless snap
-    # puts snap.inspect
+    raise "Could not GET the snapshot" unless snap
+    puts snap.inspect
   end
 end
+
+test

data/examples/image_create.rb

@@ -1,17 +1,17 @@
 def test
-  connection = Fog::Compute.new({ :provider => "Google" })
+  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',
+    :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 = 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

@@ -2,72 +2,70 @@
 # 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: 
+# 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')
+  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 = 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 = 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 = 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',
+  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',
+    :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',
+    :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'}],
-    :defaultService => backend_service1.self_link,
-  })
-  proxy = connection.target_http_proxies.create({
-    :name => 'fog-l7-proxy',
-    :urlMap => url_map.self_link
-  }) 
-  fwd_rle = connection.global_forwarding_rules.create({:name => 'fog-l7-fwd-rule', :target => proxy.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

@@ -2,20 +2,20 @@
 def test
   # Config
   name = "fog-lb-test-#{Time.now.to_i}"
-  zone = 'us-central1-b'
-  region = 'us-central1'
+  zone = "us-central1-b"
+  region = "us-central1"
 
   # Setup
-  gce = Fog::Compute.new provider: 'Google'
+  gce = Fog::Compute.new :provider => "Google"
   servers = []
 
   (1..3).each do |i|
     begin
       disk = gce.disks.create(
-        name: "#{name}-#{i}",
-        size_gb: 10,
-          zone_name: zone,
-          source_image: 'debian-7-wheezy-v20131120'
+        :name => "#{name}-#{i}",
+        :size_gb => 10,
+        :zone_name => zone,
+        :source_image => "debian-7-wheezy-v20131120"
       )
       disk.wait_for { disk.ready? }
     rescue
@@ -24,10 +24,10 @@ def test
 
     begin
       server = gce.servers.create(
-        name: "#{name}-#{i}",
-        disks: [ disk.get_as_boot_disk(true, true) ],
-          machine_type: 'f1-micro',
-          zone_name: zone
+        :name => "#{name}-#{i}",
+        :disks => [disk.get_as_boot_disk(true, true)],
+        :machine_type => "f1-micro",
+        :zone_name => zone
       )
       servers << server
     rescue
@@ -36,7 +36,7 @@ def test
   end
 
   begin
-    health = gce.http_health_checks.new(name: name)
+    health = gce.http_health_checks.new(:name => name)
     health.save
   rescue
     puts "Failed to create health check #{name}"
@@ -44,10 +44,10 @@ def test
 
   begin
     pool = gce.target_pools.new(
-      name: name,
-      region: region,
-      health_checks: health.self_link,
-      instances: servers.map(&:self_link)
+      :name => name,
+      :region => region,
+      :health_checks => health.self_link,
+      :instances => servers.map(&:self_link)
     )
     pool.save
   rescue
@@ -56,18 +56,17 @@ def test
 
   begin
     rule = gce.forwarding_rules.new(
-      name: name,
-      region: region,
-      port_range: '1-65535',
-      ip_protocol: 'TCP',
-      target: pool.self_link
+      :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.
 
@@ -91,7 +90,7 @@ def test
   end
 
   begin
-    servers.each &:destroy
+    servers.each(&:destroy)
   rescue
     puts "Failed to clean up instances."
   end