fog-google 0.1.3 → 0.2.0

data/lib/fog/{google/models/compute → compute/google/models}/disks.rb

@@ -1,34 +1,31 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/disk'
-
 module Fog
   module Compute
     class Google
       class Disks < Fog::Collection
         model Fog::Compute::Google::Disk
 
-        def all(filters={})
-          if filters['zone']
-            data = service.list_disks(filters['zone']).body['items'] || []
+        def all(filters = {})
+          if filters["zone"]
+            data = service.list_disks(filters["zone"]).body["items"] || []
           else
             data = []
-            service.list_aggregated_disks.body['items'].each_value do |zone|
-              data.concat(zone['disks']) if zone['disks']
+            service.list_aggregated_disks.body["items"].each_value do |zone|
+              data.concat(zone["disks"]) if zone["disks"]
             end
           end
           load(data)
         end
 
-        def get(identity, zone=nil)
+        def get(identity, zone = nil)
           response = nil
           if zone
             response = service.get_disk(identity, zone).body
           else
-            disks = service.list_aggregated_disks(:filter => "name eq .*#{identity}").body['items']
-            disk = disks.each_value.select { |zone| zone.key?('disks') }
+            disks = service.list_aggregated_disks(:filter => "name eq .*#{identity}").body["items"]
+            disk = disks.each_value.select { |zone| zone.key?("disks") }
 
             # It can only be 1 disk with the same name across all regions
-            response = disk.first['disks'].first unless disk.empty?
+            response = disk.first["disks"].first unless disk.empty?
           end
           return nil if response.nil?
           new(response)

data/lib/fog/{google/models/compute → compute/google/models}/firewall.rb

@@ -1,5 +1,3 @@
-require 'fog/core/model'
-
 module Fog
   module Compute
     class Google
@@ -13,31 +11,29 @@ module Fog
         attribute :kind
         attribute :id
         attribute :allowed
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        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'
+        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'])
+          data = service.insert_firewall(identity, allowed, network, attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
           operation.wait_for { !pending? }
           reload
         end
 
-        def destroy(async=true)
+        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 = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          operation.wait_for { ready? } unless async
           operation
         end
       end

data/lib/fog/{google/models/compute → compute/google/models}/firewalls.rb

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/firewall'
-
 module Fog
   module Compute
     class Google
@@ -9,7 +6,7 @@ module Fog
 
         def all
           data = service.list_firewalls.body
-          load(data['items'] || [])
+          load(data["items"] || [])
         end
 
         def get(identity)

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

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Google
+      class Flavor < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :deprecated
+        attribute :description
+        attribute :guest_cpus, :aliases => "guestCpus"
+        attribute :image_space_gb, :aliases => "imageSpaceGb"
+        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, zone)
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/fog/{google/models/compute → compute/google/models}/flavors.rb

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/flavor'
-
 module Fog
   module Compute
     class Google
@@ -12,8 +9,8 @@ module Fog
             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']
+            service.list_aggregated_machine_types.body["items"].each_value do |zone|
+              data.concat(zone["machineTypes"]) if zone["machineTypes"]
             end
           end
           load(data)

data/lib/fog/{google/models/compute → compute/google/models}/forwarding_rule.rb

@@ -1,51 +1,49 @@
-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'
+        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
+            "description" => description,
+            "region" => region,
+            "IPAddress" => ip_address,
+            "IPProtocol" => ip_protocol || "TCP",
+            "portRange" => port_range,
+            "target" => target
           }
 
           data = service.insert_forwarding_rule(name, region, options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data['name'], nil, data['region'])
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data["name"], nil, data["region"])
           operation.wait_for { !pending? }
           reload
         end
 
-        def set_target new_target
+        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)
+        def destroy(async = true)
           requires :name, :region
           operation = service.delete_forwarding_rule(name, region)
-          if not async
+          unless async
             # wait until "RUNNING" or "DONE" to ensure the operation doesn't
             # fail, raises exception on error
             Fog.wait_for do
@@ -57,12 +55,10 @@ module Fog
         end
 
         def ready?
-          begin
-            service.get_forwarding_rule(self.name, self.region)
-            true
-          rescue Fog::Errors::NotFound
-            false
-          end
+          service.get_forwarding_rule(name, region)
+          true
+        rescue Fog::Errors::NotFound
+          false
         end
 
         def reload

data/lib/fog/{google/models/compute → compute/google/models}/forwarding_rules.rb

@@ -1,30 +1,27 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/forwarding_rule'
-
 module Fog
   module Compute
     class Google
       class ForwardingRules < Fog::Collection
         model Fog::Compute::Google::ForwardingRule
 
-        def all(filters={})
-          if filters['region'].nil?
+        def all(filters = {})
+          if filters["region"].nil?
             data = []
-            service.list_regions.body['items'].each do |region|
-              data += service.list_forwarding_rules(region['name']).body['items'] || []
+            service.list_regions.body["items"].each do |region|
+              data += service.list_forwarding_rules(region["name"]).body["items"] || []
             end
           else
-            data = service.list_forwarding_rules(filters['region']).body['items'] || []
+            data = service.list_forwarding_rules(filters["region"]).body["items"] || []
           end
           load(data)
         end
 
-        def get(identity, region=nil)
+        def get(identity, region = nil)
           response = nil
           if region.nil?
-            service.list_regions.body['items'].each do |region|
+            service.list_regions.body["items"].each do |region|
               begin
-                response = service.get_forwarding_rule(identity, region['name'])
+                response = service.get_forwarding_rule(identity, region["name"])
                 break if response.status == 200
               rescue Fog::Errors::Error
               end

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

@@ -0,0 +1,82 @@
+module Fog
+  module Compute
+    class Google
+      class GlobalForwardingRule < 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" # should always be 'global'
+        attribute :ip_address, :aliases => "IPAddress" # string
+        attribute :ip_protocol, :aliases => "IPProtocol" # string
+        attribute :port_range, :aliases => "portRange" # string
+        attribute :target, :aliases => "target" # string, URL of global target http proxy
+
+        def save
+          requires :name
+
+          options = {
+            "description" => description,
+            "region" => "global",
+            "IPAddress" => ip_address,
+            "IPProtocol" => ip_protocol || "TCP",
+            "portRange" => port_range || 80,
+            "target" => target
+          }
+
+          data = service.insert_global_forwarding_rule(name, options).body
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data["name"], nil, data["region"])
+          operation.wait_for { !pending? }
+          reload
+        end
+
+        def destroy(async = true)
+          requires :name
+
+          operation = service.delete_global_forwarding_rule(name, "global")
+          unless async
+            # wait until "RUNNING" or "DONE" to ensure the operation doesn't
+            # fail, raises exception on error
+            Fog.wait_for do
+              operation.body["status"] == "DONE"
+            end
+          end
+          operation
+        end
+
+        def set_target(new_target)
+          new_target = new_target.self_link unless new_target.class == String
+          self.target = new_target
+          service.set_global_forwarding_rule_target(self, new_target)
+          reload
+        end
+
+        def ready?
+          service.get_global_forwarding_rule(name, "global")
+          true
+        rescue Fog::Errors::NotFound
+          false
+        end
+
+        def reload
+          requires :name
+
+          return unless data = begin
+            collection.get(name, "global")
+          rescue Excon::Errors::SocketError
+            nil
+          end
+
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+
+        RUNNING_STATE = "READY"
+      end
+    end
+  end
+end

data/lib/fog/{google/models/compute → compute/google/models}/global_forwarding_rules.rb

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/global_forwarding_rule'
-
 module Fog
   module Compute
     class Google
@@ -8,11 +5,11 @@ module Fog
         model Fog::Compute::Google::GlobalForwardingRule
 
         def all
-          data = service.list_global_forwarding_rules.body['items'] || []
+          data = service.list_global_forwarding_rules.body["items"] || []
           load(data)
         end
 
-        def get(identity, region='global')
+        def get(identity, region = "global")
           if global_forwarding_rule = service.get_global_forwarding_rule(identity, region).body
             new(global_forwarding_rule)
           end

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

@@ -0,0 +1,80 @@
+module Fog
+  module Compute
+    class Google
+      class HttpHealthCheck < 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 :host, :aliases => "host"
+        attribute :request_path, :aliases => "requestPath"
+        attribute :port, :aliases => "port"
+        attribute :check_interval_sec, :aliases => "checkIntervalSec"
+        attribute :timeout_sec, :aliases => "timeoutSec"
+        attribute :unhealthy_threshold, :aliases => "unhealthyThreshold"
+        attribute :healthy_threshold, :aliases => "healthyThreshold"
+
+        def save
+          requires :name
+
+          options = {
+            "description" => description,
+            "host" => host,
+            "requestPath" => request_path || "/",
+            "port" => port || 80,
+            "checkIntervalSec" => check_interval_sec || 5,
+            "timeoutSec" => timeout_sec || 5,
+            "unhealthyThreshold" => unhealthy_threshold || 2,
+            "healthyThreshold" => healthy_threshold || 2
+          }
+
+          data = service.insert_http_health_check(name, options).body
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data["name"], data["zone"])
+          operation.wait_for { !pending? }
+          reload
+        end
+
+        def destroy(async = true)
+          requires :name
+          operation = service.delete_http_health_check(name)
+
+          unless async
+            # wait until "DONE" to ensure the operation doesn't fail, raises
+            # exception on error
+            Fog.wait_for do
+              operation = service.get_global_operation(operation.body["name"])
+              operation.body["status"] == "DONE"
+            end
+          end
+          operation
+        end
+
+        def ready?
+          service.get_http_health_check(name)
+          true
+        rescue Fog::Errors::NotFound
+          false
+        end
+
+        def reload
+          requires :name
+
+          return unless data = begin
+            collection.get(name)
+          rescue Excon::Errors::SocketError
+            nil
+          end
+
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+
+        RUNNING_STATE = "READY"
+      end
+    end
+  end
+end