fog 1.29.0 → 1.30.0

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

@@ -1,40 +0,0 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/disk_type'
-
-module Fog
-  module Compute
-    class Google
-      class DiskTypes < Fog::Collection
-        model Fog::Compute::Google::DiskType
-
-        def all(filters = {})
-          if filters['zone']
-            data = service.list_disk_types(filters['zone']).body['items'] || []
-          else
-            data = []
-            service.list_aggregated_disk_types.body['items'].each_value do |zone|
-              data.concat(zone['diskTypes']) if zone['diskTypes']
-            end
-          end
-          load(data)
-        end
-
-        def get(identity, zone = nil)
-          response = nil
-          if zone
-            response = service.get_disk_type(identity, zone).body
-          else
-            disk_types = service.list_aggregated_disk_types(:filter => "name eq .*#{identity}").body['items'] || {}
-            disk_type = disk_types.each_value.detect { |zone| zone.key?('diskTypes') } || {}
-
-            response = disk_type['diskTypes'].first unless disk_type.empty?
-          end
-          return nil if response.nil?
-          new(response)
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-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'] || []
-          else
-            data = []
-            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)
-          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') }
-
-            # It can only be 1 disk with the same name across all regions
-            response = disk.first['disks'].first unless disk.empty?
-          end
-          return nil if response.nil?
-          new(response)
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,33 +0,0 @@
-require 'fog/core/model'
-
-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, self.zone)
-          merge_attributes(data.attributes)
-          self
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/flavor'
-
-module Fog
-  module Compute
-    class Google
-      class Flavors < Fog::Collection
-        model Fog::Compute::Google::Flavor
-
-        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 = service.get_machine_type(identity, zone_name).body
-          new(data)
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-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
-          }
-
-          data = service.insert_forwarding_rule(name, region, options).body
-          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
-          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

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

@@ -1,41 +0,0 @@
-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?
-            data = []
-            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'] || []
-          end
-          load(data)
-        end
-
-        def get(identity, region=nil)
-          response = nil
-          if region.nil?
-            service.list_regions.body['items'].each do |region|
-              begin
-                response = service.get_forwarding_rule(identity, region['name'])
-                break if response.status == 200
-              rescue Fog::Errors::Error
-              end
-            end
-          else
-            response = service.get_forwarding_rule(identity, region)
-          end
-          return nil if response.nil?
-          new(response.body)
-        end
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-require 'fog/core/model'
-
-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')
-          if not 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?
-          begin
-            service.get_global_forwarding_rule(self.name, 'global')
-            true
-          rescue Fog::Errors::NotFound
-            false
-          end
-        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/global_forwarding_rules.rb

@@ -1,23 +0,0 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/global_forwarding_rule'
-
-module Fog
-  module Compute
-    class Google
-      class GlobalForwardingRules < Fog::Collection
-        model Fog::Compute::Google::GlobalForwardingRule
-
-        def all
-          data = service.list_global_forwarding_rules.body['items'] || []
-          load(data)
-        end
-
-        def get(identity, region='global')
-          response = service.get_global_forwarding_rule(identity, region)
-          return nil if response.nil?
-          new(response.body)
-        end
-      end
-    end
-  end
-end