fog 1.29.0 → 1.30.0

data/lib/fog/google/examples/get_list_images.rb

@@ -1,26 +0,0 @@
-def test
-  connection = Fog::Compute.new({ :provider => "Google" })
-
-  # puts 'Listing images in all projects...'
-  # puts '---------------------------------'
-  images = connection.images.all
-  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
-
-  # 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 }
-  # 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 '----------------------------------------------'
-    img = connection.images.get(custom_img_name.name)
-    raise 'Could not GET the (custom) image' unless img
-    # puts img.inspect
-  end
-end

data/lib/fog/google/examples/get_list_snapshots.rb

@@ -1,18 +0,0 @@
-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/lib/fog/google/examples/image_all.rb

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

data/lib/fog/google/examples/image_create.rb

@@ -1,17 +0,0 @@
-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/lib/fog/google/examples/l7_load_balance.rb

@@ -1,73 +0,0 @@
-# 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/lib/fog/google/examples/launch_micro_instance.rb

@@ -1,29 +0,0 @@
-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/lib/fog/google/examples/load-balance.rb

@@ -1,98 +0,0 @@
-
-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/lib/fog/google/examples/metadata.rb

@@ -1,30 +0,0 @@
-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/lib/fog/google/examples/monitoring/metric_descriptors.rb

@@ -1,11 +0,0 @@
-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/lib/fog/google/examples/monitoring/timeseries_collection.rb

@@ -1,15 +0,0 @@
-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/lib/fog/google/examples/monitoring/timeseries_descriptors.rb

@@ -1,15 +0,0 @@
-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/lib/fog/google/examples/network.rb

@@ -1,38 +0,0 @@
-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/lib/fog/google/examples/precreated_client.rb

@@ -1,14 +0,0 @@
-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/lib/fog/google/examples/sql/flags.rb

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

data/lib/fog/google/examples/sql/instances.rb

@@ -1,38 +0,0 @@
-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