fog-google 0.0.2

data/examples/get_list_snapshots.rb

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

data/examples/image_all.rb

@@ -0,0 +1,6 @@
+def test
+  connection = Fog::Compute.new({ :provider => "Google" })
+
+  # If this doesn't raise an exception, everything is good.
+  connection.images.all
+end

data/examples/image_create.rb

@@ -0,0 +1,17 @@
+def test
+  connection = Fog::Compute.new({ :provider => "Google" })
+
+  rawdisk = {
+    :source         => nil, # 'http://some_valid_url_to_rootfs_tarball'
+    :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,73 @@
+# 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'}],
+    :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 })
+end

data/examples/launch_micro_instance.rb

@@ -0,0 +1,29 @@
+def test
+  connection = Fog::Compute.new({ :provider => "Google" })
+  time = Time.now.utc.to_i
+  disk = connection.disks.create({
+    :name => "foggydisk-#{time}",
+    :size_gb => 10,
+    :zone_name => 'us-central1-a',
+    :source_image => 'centos-6-v20131120',
+  })
+
+  disk.wait_for { disk.ready? }
+  params = {
+    :name => "fog-smoke-test-#{Time.now.to_i}",
+    :machine_type => "f1-micro",
+    :zone_name => "us-central1-a",
+    :disks => [ disk.get_as_boot_disk(true) ],
+    :user => ENV['USER']
+  }
+
+  server = connection.servers.bootstrap params
+
+  begin
+    raise "Could not bootstrap sshable server." unless server.ssh("whoami")
+    raise "Could not delete server." unless server.destroy
+    raise "Could not delete disk." unless disk.destroy
+  rescue Exception => e
+    p e.message
+  end
+end

data/examples/load-balance.rb

@@ -0,0 +1,98 @@
+
+def test
+  # Config
+  name = "fog-lb-test-#{Time.now.to_i}"
+  zone = 'us-central1-b'
+  region = 'us-central1'
+
+  # Setup
+  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'
+      )
+      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
+
+  begin
+    health = gce.http_health_checks.new(name: name)
+    health.save
+  rescue
+    puts "Failed to create health check #{name}"
+  end
+
+  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
+
+  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
+  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

data/examples/metadata.rb

@@ -0,0 +1,30 @@
+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-a',
+    :source_image => 'debian-7-wheezy-v20131120',
+  })
+
+  disk.wait_for { disk.ready? }
+
+  server = connection.servers.create(defaults = {
+    :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"),
+  })
+
+  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

data/examples/monitoring/metric_descriptors.rb

@@ -0,0 +1,11 @@
+def test
+  connection = Fog::Google::Monitoring.new
+
+  puts 'Listing all MetricDescriptors...'
+  puts '--------------------------------'
+  connection.metric_descriptors
+
+  puts 'Listing all MetricDescriptors related to Google Compute Engine...'
+  puts '-----------------------------------------------------------------'
+  connection.metric_descriptors.all(:query => 'compute')
+end

data/examples/monitoring/timeseries_collection.rb

@@ -0,0 +1,15 @@
+def test
+  connection = Fog::Google::Monitoring.new
+
+  puts 'Listing all Timeseries for the metric compute.googleapis.com/instance/uptime...'
+  puts '-------------------------------------------------------------------------------'
+  connection.timeseries_collection.all('compute.googleapis.com/instance/uptime',
+                                       DateTime.now.rfc3339)
+
+  puts 'Listing all Timeseries for the metric compute.googleapis.com/instance/uptime &'
+  puts 'the region us-central1...'
+  puts '------------------------------------------------------------------------------'
+  connection.timeseries_collection.all('compute.googleapis.com/instance/uptime',
+                                       DateTime.now.rfc3339,
+                                       :labels => 'cloud.googleapis.com/location=~us-central1.*')
+end

data/examples/monitoring/timeseries_descriptors.rb

@@ -0,0 +1,15 @@
+def test
+  connection = Fog::Google::Monitoring.new
+
+  puts 'Listing all TimeseriesDescriptors for the metric compute.googleapis.com/instance/uptime...'
+  puts '------------------------------------------------------------------------------------------'
+  connection.timeseries_descriptors.all('compute.googleapis.com/instance/uptime',
+                                        DateTime.now.rfc3339)
+
+  puts 'Listing all TimeseriesDescriptors for the metric compute.googleapis.com/instance/uptime &'
+  puts 'the region us-central1...'
+  puts '-----------------------------------------------------------------------------------------'
+  connection.timeseries_descriptors.all('compute.googleapis.com/instance/uptime',
+                                        DateTime.now.rfc3339,
+                                        :labels => 'cloud.googleapis.com/location=~us-central1.*')
+end

data/examples/network.rb

@@ -0,0 +1,38 @@
+def test
+  begin
+    connection = Fog::Compute.new({ :provider => "Google" })
+
+    # we create a new private network
+    connection.insert_network('my-private-network', '10.240.0.0/16')
+
+    name = "fog-smoke-test-#{Time.now.to_i}"
+
+    disk = connection.disks.create({
+      :name => name,
+      :size_gb => 10,
+      :zone_name => 'us-central1-a',
+      :source_image => 'debian-7-wheezy-v20131120',
+    })
+
+    disk.wait_for { disk.ready? }
+
+    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 => 'my-private-network',
+      :external_ip => false,
+      :user => 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
+  rescue Exception => e
+    p e.message
+  end
+end

data/examples/precreated_client.rb

@@ -0,0 +1,14 @@
+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 Exception => e
+    p e.message
+  end
+end

data/examples/sql/flags.rb

@@ -0,0 +1,7 @@
+def test
+  connection = Fog::Google::SQL.new
+
+  puts 'Listing all Flags...'
+  puts '--------------------'
+  connection.flags
+end

data/examples/sql/instances.rb

@@ -0,0 +1,38 @@
+def test
+  connection = Fog::Google::SQL.new
+
+  puts 'Create a Instance...'
+  puts '--------------------'
+  instance = connection.instances.create(:instance => Fog::Mock.random_letters(16), :tier => 'D1')
+  instance.wait_for { ready? }
+
+  puts 'Get the Instance...'
+  puts '----------------------'
+  connection.instances.get(instance.instance)
+
+  puts 'List all Instances...'
+  puts '---------------------'
+  connection.instances.all
+
+  puts 'Update the Instance...'
+  puts '----------------------'
+  instance.activation_policy = 'ALWAYS'
+  instance.update
+  instance.wait_for { ready? }
+
+  puts 'Reset the Instance SSL configuration...'
+  puts '---------------------------------------'
+  instance.reset_ssl_config
+
+  puts 'Restart the Instance...'
+  puts '-----------------------'
+  instance.restart
+
+  puts 'Set the Instance root password...'
+  puts '---------------------------------'
+  instance.set_root_password(Fog::Mock.random_letters_and_numbers(8))
+
+  puts 'Delete the Instance...'
+  puts '----------------------'
+  instance.destroy
+end

data/examples/sql/operations.rb

@@ -0,0 +1,20 @@
+def test
+  connection = Fog::Google::SQL.new
+
+  puts 'Create a Instance...'
+  puts '--------------------'
+  instance = connection.instances.create(:instance => Fog::Mock.random_letters(16), :tier => 'D1')
+  instance.wait_for { ready? }
+
+  puts 'Delete the Instance...'
+  puts '----------------------'
+  operation = instance.destroy
+
+  puts 'Get the Operation...'
+  puts '--------------------'
+  connection.operations.get(instance.identity, operation.identity)
+
+  puts 'Listing all Operations...'
+  puts '-------------------------'
+  connection.operations.all(instance.identity)
+end