fog 1.21.0 → 1.22.0

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

@@ -45,5 +45,5 @@ def test
   end
 
   raise "Could not bootstrap sshable server." unless server.ssh("whoami")
-  raise "Cloud note delete server." unless server.destroy
+  raise "Could not delete server." unless server.destroy
 end

data/lib/fog/google/examples/eric-fail.rb

@@ -2,25 +2,31 @@ def test
   connection = Fog::Compute.new({ :provider => "Google" })
 
   name = "fog-smoke-test-#{Time.now.to_i}"
+  zone = "us-central1-a"
 
   disk = connection.disks.create({
     :name => name,
     :size_gb => 10,
-    :zone_name => 'us-central1-a',
-    :source_image => 'debian-7-wheezy-v20131120',
+    :zone_name => zone,
+    :source_image => 'debian-7-wheezy-v20140318',
   })
 
   disk.wait_for { disk.ready? }
 
+  scopes = [
+    "https://www.googleapis.com/auth/compute",
+    "devstorage.full_control",
+    "userinfo.email"
+  ]
+
   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"),
-    :username => 'root',
-    :metadata => {'foo' => 'bar'}
+    :zone_name => zone,
+    :metadata => {'foo' => 'bar'},
+    :tags => ["t1", "t2", "t3"],
+    :servce_accounts => scopes
   })
   sleep(90)
 

data/lib/fog/google/examples/load-balance.rb

@@ -0,0 +1,100 @@
+
+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/models/compute/address.rb

@@ -0,0 +1,62 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+
+      ##
+      # Represents an Address resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/addresses
+      class Address < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :address
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :description
+        attribute :region
+        attribute :self_link, :aliases => 'selfLink'
+        attribute :status
+        attribute :users
+
+        IN_USE_STATE   = 'IN_USE'
+        RESERVED_STATE = 'RESERVED'
+
+        def save
+          requires :identity, :region
+
+          data = service.insert_address(identity, self.region, self.attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], nil, data.body['region'])
+          operation.wait_for { !pending? }
+          reload
+        end
+
+        def destroy(async=true)
+          requires :identity, :region
+
+          data = service.delete_address(identity, self.region.split('/')[-1])
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], nil, data.body['region'])
+          unless async
+            operation.wait_for { ready? }
+          end
+          operation
+        end
+
+        def reload
+          requires :identity, :region
+
+          data = collection.get(identity, self.region.split('/')[-1])
+          merge_attributes(data.attributes)
+          self
+        end
+
+        def in_use?
+          self.status == IN_USE_STATE
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/google/models/compute/addresses.rb

@@ -0,0 +1,34 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/address'
+
+module Fog
+  module Compute
+    class Google
+
+      class Addresses < Fog::Collection
+        model Fog::Compute::Google::Address
+
+        def all(filters = {})
+          if filters[:region]
+            data = service.list_addresses(filters[:region]).body['items'] || []
+          else
+            data = []
+            service.list_aggregated_addresses.body['items'].each_value do |region|
+              data.concat(region['addresses']) if region['addresses']
+            end
+          end
+          load(data)
+        end
+
+        def get(identity, region)
+          if address = service.get_address(identity, region).body
+            new(address)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/google/models/compute/disk.rb

@@ -25,24 +25,32 @@ module Fog
           requires :zone_name
 
           options = {}
+          my_description = "Created with fog"
+          if !source_image.nil?
+            my_description = "Created from image: #{source_image}"
+          end
           if source_image.nil? && !source_snapshot.nil?
             options['sourceSnapshot'] = source_snapshot
+            my_description = "Created from snapshot: #{source_snapshot}"
           end
 
           options['sizeGb'] = size_gb
+          options['description'] = description || my_description
 
           data = service.insert_disk(name, zone_name, source_image, options).body
           data = service.backoff_if_unfound {service.get_disk(name, zone_name).body}
           service.disks.merge_attributes(data)
         end
 
-        def destroy
+        def destroy(async=true)
           requires :name, :zone_name
           operation = service.delete_disk(name, zone_name)
-          # wait until "RUNNING" or "DONE" to ensure the operation doesn't fail, raises exception on error
-          Fog.wait_for do
-            operation = service.get_zone_operation(zone_name, operation.body["name"])
-            operation.body["status"] != "PENDING"
+          # wait until "DONE" to ensure the operation doesn't fail, raises exception on error
+          if not async
+            Fog.wait_for do
+              operation = service.get_zone_operation(zone_name, operation.body["name"])
+              operation.body["status"] == "DONE"
+            end
           end
           operation
         end

data/lib/fog/google/models/compute/firewall.rb

@@ -0,0 +1,48 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+
+      ##
+      # Represents a Firewall resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/firewalls
+      class Firewall < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :allowed
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :description
+        attribute :network
+        attribute :self_link, :aliases => 'selfLink'
+        attribute :source_ranges, :aliases => 'sourceRanges'
+        attribute :source_tags, :aliases => 'sourceTags'
+        attribute :target_tags, :aliases => 'targetTags'
+
+        def save
+          requires :identity, :allowed, :network
+
+          data = service.insert_firewall(identity, self.allowed, self.network, self.attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'])
+          operation.wait_for { !pending? }
+          reload
+        end
+
+        def destroy(async=true)
+          requires :identity
+
+          data = service.delete_firewall(identity)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'])
+          unless async
+            operation.wait_for { ready? }
+          end
+          operation
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/google/models/compute/firewalls.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/firewall'
+
+module Fog
+  module Compute
+    class Google
+
+      class Firewalls < Fog::Collection
+        model Fog::Compute::Google::Firewall
+
+        def all
+          data = service.list_firewalls.body
+          load(data['items'] || [])
+        end
+
+        def get(identity)
+          if firewall = service.get_firewall(identity).body
+            new(firewall)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/google/models/compute/flavor.rb

@@ -8,16 +8,27 @@ module Fog
 
         identity :name
 
+        attribute :kind
+        attribute :id
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :deprecated
         attribute :description
         attribute :guest_cpus, :aliases => 'guestCpus'
-        attribute :memory_mb, :aliases => 'memoryMb'
         attribute :image_space_gb, :aliases => 'imageSpaceGb'
-        attribute :maximum_persistent_disks,
-          :aliases => 'maximumPersistentDisks'
-        attribute :maximum_persistent_disks_size,
-          :aliases => 'maximumPersistentDisksSizeGb'
+        attribute :maximum_persistent_disks, :aliases => 'maximumPersistentDisks'
+        attribute :maximum_persistent_disks_size, :aliases => 'maximumPersistentDisksSizeGb'
+        attribute :memory_mb, :aliases => 'memoryMb'
+        attribute :scratch_disks, aliases => 'scratchDisks'
         attribute :self_link, :aliases => 'selfLink'
+        attribute :zone
+
+        def reload
+          requires :identity, :zone
 
+          data = collection.get(identity, self.zone)
+          merge_attributes(data.attributes)
+          self
+        end
       end
 
     end

data/lib/fog/google/models/compute/flavors.rb

@@ -9,14 +9,20 @@ module Fog
 
         model Fog::Compute::Google::Flavor
 
-        def all
-          zone = service.list_zones.body['items'].first
-          data = connection.list_machine_types(zone['name']).body["items"]
+        def all(filters = {})
+          if filters[:zone]
+            data = service.list_machine_types(filters[:zone]).body["items"]
+          else
+            data = []
+            service.list_aggregated_machine_types.body['items'].each_value do |zone|
+              data.concat(zone['machineTypes']) if zone['machineTypes']
+            end
+          end
           load(data)
         end
 
         def get(identity, zone_name = nil)
-          data = connection.get_machine_type(identity, zone_name).body
+          data = service.get_machine_type(identity, zone_name).body
           new(data)
         rescue Fog::Errors::NotFound
           nil

data/lib/fog/google/models/compute/forwarding_rule.rb

@@ -0,0 +1,88 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+
+      class ForwardingRule < Fog::Model
+
+        identity :name
+
+        attribute :kind, :aliases => 'kind'
+        attribute :self_link, :aliases => 'selfLink'
+        attribute :id, :aliases => 'id'
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :description, :aliases => 'description'
+        attribute :region, :aliases => 'region'
+        attribute :ip_address, :aliases => 'IPAddress'
+        attribute :ip_protocol, :aliases => 'IPProtocol'
+        attribute :port_range, :aliases => 'portRange'
+        attribute :target, :aliases => 'target'
+
+        def save
+          requires :name, :region, :target
+
+          options = {
+            'description' => description,
+            'region' => region,
+            'IPAddress' => ip_address,
+            'IPProtocol' => ip_protocol || "TCP",
+            'portRange' => port_range,
+            'target' => target
+          }
+
+          service.insert_forwarding_rule(name, region, options).body
+          data = service.backoff_if_unfound {service.get_forwarding_rule(name, region).body}
+          merge_attributes(data)
+          self
+        end
+
+        def set_target new_target
+          new_target = new_target.self_link unless new_target.class == String
+          self.target = new_target
+          service.set_forwarding_rule_target(self, new_target)
+          reload
+        end
+
+        def destroy(async=true)
+          requires :name, :region
+          operation = service.delete_forwarding_rule(name, region)
+          if not async
+            # wait until "RUNNING" or "DONE" to ensure the operation doesn't
+            # fail, raises exception on error
+            Fog.wait_for do
+              operation = service.get_region_operation(region, operation.body["name"])
+              operation.body["status"] == "DONE"
+            end
+          end
+          operation
+        end
+
+        def ready?
+          begin
+            service.get_forwarding_rule(self.name, self.region)
+            true
+          rescue Fog::Errors::NotFound
+            false
+          end
+        end
+
+        def reload
+          requires :name, :region
+
+          return unless data = begin
+            collection.get(name, region)
+          rescue Excon::Errors::SocketError
+            nil
+          end
+
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+
+        RUNNING_STATE = "READY"
+      end
+    end
+  end
+end