fog-google 0.1.3 → 0.2.0

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

@@ -1,34 +1,31 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/server'
-
 module Fog
   module Compute
     class Google
       class Servers < Fog::Collection
         model Fog::Compute::Google::Server
 
-        def all(filters={})
-          if filters['zone']
-            data = service.list_servers(filters['zone']).body['items'] || []
+        def all(filters = {})
+          if filters["zone"]
+            data = service.list_servers(filters["zone"]).body["items"] || []
           else
             data = []
-            service.list_aggregated_servers.body['items'].each_value do |zone|
-              data.concat(zone['instances']) if zone['instances']
+            service.list_aggregated_servers.body["items"].each_value do |zone|
+              data.concat(zone["instances"]) if zone["instances"]
             end
           end
           load(data)
         end
 
-        def get(identity, zone=nil)
+        def get(identity, zone = nil)
           response = nil
           if zone
             response = service.get_server(identity, zone).body
           else
-            servers = service.list_aggregated_servers(:filter => "name eq .*#{identity}").body['items']
-            server = servers.each_value.select { |zone| zone.key?('instances') }
+            servers = service.list_aggregated_servers(:filter => "name eq .*#{identity}").body["items"]
+            server = servers.each_value.select { |zone| zone.key?("instances") }
 
             # It can only be 1 server with the same name across all regions
-            response = server.first['instances'].first unless server.empty?
+            response = server.first["instances"].first unless server.empty?
           end
           return nil if response.nil?
           new(response)
@@ -38,17 +35,17 @@ module Fog
 
         def bootstrap(new_attributes = {})
           name = "fog-#{Time.now.to_i}"
-          zone = "us-central1-a"
+          zone = "us-central1-f"
 
           disks = new_attributes[:disks]
 
-          if disks.nil? or disks.empty?
+          if disks.nil? || disks.empty?
             # create the persistent boot disk
             disk_defaults = {
               :name => name,
               :size_gb => 10,
               :zone_name => zone,
-              :source_image => "debian-7-wheezy-v20140408",
+              :source_image => "debian-7-wheezy-v20151104"
             }
 
             # backwards compatibility to pre-v1
@@ -66,7 +63,7 @@ module Fog
             :zone_name => zone,
             :private_key_path => File.expand_path("~/.ssh/id_rsa"),
             :public_key_path => File.expand_path("~/.ssh/id_rsa.pub"),
-            :username => ENV['USER'],
+            :username => ENV["USER"]
           }
 
           server = create(defaults.merge(new_attributes))

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

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class Google
+      class Snapshot < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :self_link, :aliases => "selfLink"
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :disk_size_gb, :aliases => "diskSizeGb"
+        attribute :source_disk, :aliases => "sourceDisk"
+        attribute :source_disk_id, :aliases => "sourceDiskId"
+        attribute :description
+        attribute :status
+        attribute :id
+        attribute :storage_bytes, :aliases => "storageBytes"
+        attribute :storage_bytes_status, :aliases => "storageBytesStatus"
+
+        CREATING_STATE  = "CREATING"
+        DELETING_STATE  = "DELETING"
+        FAILED_STATE    = "FAILED"
+        READY_STATE     = "READY"
+        UPLOADING_STATE = "UPLOADING"
+
+        def destroy(async = true)
+          requires :identity
+
+          data = service.delete_snapshot(identity)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        def ready?
+          status == READY_STATE
+        end
+
+        def resource_url
+          "#{service.project}/global/snapshots/#{name}"
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,49 @@
+module Fog
+  module Compute
+    class Google
+      ##
+      # Represents a Subnetwork resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/subnetworks
+      class Subnetwork < Fog::Model
+        identity :name
+
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :description
+        attribute :gateway_address, :aliases => "gatewayAddress"
+        attribute :id
+        attribute :ip_cidr_range, :aliases => "ipCidrRange"
+        attribute :kind
+        attribute :network
+        attribute :region
+        attribute :self_link, :aliases => "selfLink"
+
+        def save
+          requires :identity, :network, :region, :ip_cidr_range
+
+          data = service.insert_subnetwork(identity, region, network, ip_cidr_range, 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_subnetwork(identity, region)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], nil, data.body["region"])
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        def reload
+          requires :identity, :region
+
+          data = collection.get(identity, region.split("/")[-1])
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    class Google
+      class Subnetworks < Fog::Collection
+        model Fog::Compute::Google::Subnetwork
+
+        def all(filters = {})
+          if filters[:region]
+            data = service.list_subnetworks(filters[:region]).body["items"] || []
+          else
+            data = []
+            service.list_aggregated_subnetworks(filters).body["items"].each_value do |region|
+              data.concat(region["subnetworks"]) if region["subnetworks"]
+            end
+          end
+          load(data || [])
+        end
+
+        def get(identity, region)
+          if subnetwork = service.get_subnetwork(identity, region).body
+            new(subnetwork)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -1,14 +1,11 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/target_http_proxy'
-
 module Fog
   module Compute
     class Google
       class TargetHttpProxies < Fog::Collection
         model Fog::Compute::Google::TargetHttpProxy
 
-        def all(filters={})
-          data = service.list_target_http_proxies.body['items'] || []
+        def all(_filters = {})
+          data = service.list_target_http_proxies.body["items"] || []
           load(data)
         end
 

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

@@ -1,36 +1,34 @@
-require 'fog/core/model'
-
 module Fog
   module Compute
     class Google
       class TargetHttpProxy < 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 :urlMap, :aliases => ["urlMap", :url_map]
+        attribute :kind, :aliases => "kind"
+        attribute :self_link, :aliases => "selfLink"
+        attribute :id, :aliases => "id"
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :description, :aliases => "description"
+        attribute :url_map, :aliases => "urlMap"
 
         def save
           requires :name
 
           options = {
-            'description' => description,
-            'urlMap'      => urlMap
+            "description" => description,
+            "urlMap"      => url_map
           }
 
-          data = service.insert_target_http_proxy(name,  options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data['name'], data['zone'])
+          data = service.insert_target_http_proxy(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)
+        def destroy(async = true)
           requires :name
           operation = service.delete_target_http_proxy(name)
-          if not async
+          unless async
             # wait until "DONE" to ensure the operation doesn't fail, raises
             # exception on error
             Fog.wait_for do
@@ -39,19 +37,17 @@ module Fog
           end
           operation
         end
-        
-        def set_url_map urlMap
+
+        def set_url_map(urlMap)
           operation = service.set_target_http_proxy_url_map(self, urlMap)
           reload
         end
 
         def ready?
-          begin
-            service.get_target_http_proxy(self.name)
-            true
-          rescue Fog::Errors::NotFound
-            false
-          end
+          service.get_target_http_proxy(name)
+          true
+        rescue Fog::Errors::NotFound
+          false
         end
 
         def reload

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

@@ -1,16 +1,14 @@
-require 'fog/core/model'
-
 module Fog
   module Compute
     class Google
       class TargetInstance < 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 :kind, :aliases => "kind"
+        attribute :self_link, :aliases => "selfLink"
+        attribute :id, :aliases => "id"
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :description, :aliases => "description"
         attribute :zone, :aliases => "zone"
         attribute :instance, :aliases => "instance"
         attribute :nat_policy, :aliases => "natPolicy"
@@ -19,22 +17,22 @@ module Fog
           requires :name, :zone
 
           options = {
-            'description' => description,
-            'zone' => zone,
-            'natPolicy' => nat_policy,
-            'instance' => instance,
+            "description" => description,
+            "zone" => zone,
+            "natPolicy" => nat_policy,
+            "instance" => instance
           }
 
           data = service.insert_target_instance(name, zone, options)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
           operation.wait_for { !pending? }
           reload
         end
 
-        def destroy(async=true)
+        def destroy(async = true)
           requires :name, :zone
           operation = service.delete_target_instance(name, zone)
-          if not async
+          unless async
             # wait until "DONE" to ensure the operation doesn't fail, raises
             # exception on error
             Fog.wait_for do
@@ -45,30 +43,27 @@ module Fog
         end
 
         def ready?
-          begin
-            service.get_target_instance(self.name, self.zone)
-            true
-          rescue Fog::Errors::NotFound
-            false
-          end
+          service.get_target_instance(name, zone)
+          true
+        rescue Fog::Errors::NotFound
+          false
         end
 
         def reload
           requires :name, :zone
 
-          return unless data = begin
-            collection.get(name, zone)
+          begin
+            data = collection.get(name, zone)
+            new_attributes = data.attributes
+            merge_attributes(new_attributes)
+            return self
           rescue Excon::Errors::SocketError
-            nil
+            return nil
           end
-
-          new_attributes = data.attributes
-          merge_attributes(new_attributes)
-          self
         end
 
         RUNNING_STATE = "READY"
       end
     end
-   end
   end
+end

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

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