fog 1.29.0 → 1.30.0

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

@@ -1,80 +0,0 @@
-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'] || []
-          else
-            data = []
-            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)
-          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') }
-
-            # It can only be 1 server with the same name across all regions
-            response = server.first['instances'].first unless server.empty?
-          end
-          return nil if response.nil?
-          new(response)
-        rescue Fog::Errors::NotFound
-          nil
-        end
-
-        def bootstrap(new_attributes = {})
-          name = "fog-#{Time.now.to_i}"
-          zone = "us-central1-a"
-
-          disks = new_attributes[:disks]
-
-          if disks.nil? or disks.empty?
-            # create the persistent boot disk
-            disk_defaults = {
-              :name => name,
-              :size_gb => 10,
-              :zone_name => zone,
-              :source_image => "debian-7-wheezy-v20140408",
-            }
-
-            # backwards compatibility to pre-v1
-            new_attributes[:source_image] = new_attributes[:image_name] if new_attributes[:image_name]
-
-            disk = service.disks.create(disk_defaults.merge(new_attributes))
-            disk.wait_for { disk.ready? }
-            disks = [disk]
-          end
-
-          defaults = {
-            :name => name,
-            :disks => disks,
-            :machine_type => "n1-standard-1",
-            :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'],
-          }
-
-          server = create(defaults.merge(new_attributes))
-          server.wait_for { sshable? }
-
-          server
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'fog/core/model'
-
-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'])
-          unless async
-            operation.wait_for { ready? }
-          end
-          operation
-        end
-
-        def ready?
-          self.status == READY_STATE
-        end
-
-        def resource_url
-          "#{self.service.project}/global/snapshots/#{name}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/snapshot'
-
-module Fog
-  module Compute
-    class Google
-      class Snapshots < Fog::Collection
-        model Fog::Compute::Google::Snapshot
-
-        def all
-          data = service.list_snapshots
-          snapshots = data.body['items'] || []
-          load(snapshots)
-        end
-
-        def get(snap_id)
-          response = service.get_snapshot(snap_id)
-          return nil if response.nil?
-          new(response.body)
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-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'] || []
-          load(data)
-        end
-
-        def get(identity)
-          response = service.get_target_http_proxy(identity)
-          new(response.body) unless response.nil?
-        end
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-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"
-
-        def save
-          requires :name
-
-          options = {
-            'description' => description,
-            'urlMap'      => urlMap
-          }
-
-          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)
-          requires :name
-          operation = service.delete_target_http_proxy(name)
-          if not async
-            # wait until "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_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
-        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

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

@@ -1,74 +0,0 @@
-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 :zone, :aliases => "zone"
-        attribute :instance, :aliases => "instance"
-        attribute :nat_policy, :aliases => "natPolicy"
-
-        def save
-          requires :name, :zone
-
-          options = {
-            'description' => description,
-            'zone' => zone,
-            'natPolicy' => nat_policy,
-            'instance' => instance,
-          }
-
-          data = service.insert_target_instance(name, zone, options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data['name'])
-          operation.wait_for { !pending? }
-          reload
-        end
-
-        def destroy(async=true)
-          requires :name, :zone
-          operation = service.delete_target_instance(name, zone)
-          if not async
-            # wait until "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 ready?
-          begin
-            service.get_target_instance(self.name, self.zone)
-            true
-          rescue Fog::Errors::NotFound
-            false
-          end
-        end
-
-        def reload
-          requires :name, :zone
-
-          return unless data = begin
-            collection.get(name, zone)
-          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/target_instances.rb

@@ -1,28 +0,0 @@
-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(zone = nil)
-          if zone.nil?
-            data = []
-            data = service.list_target_instances.body['items'] || []
-          
-          else
-            data = service.list_target_instances(zone).body['items'] || []
-          end
-          load(data)
-        end
-
-        def get(identity, zone=nil)
-            response = service.get_target_instance(identity, zone)
-            new(response.body) unless response.nil?
-        end
-      end
-    end
-  end
-end

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

@@ -1,113 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Google
-      class TargetPool < 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 :health_checks, :aliases => "healthChecks"
-        attribute :instances, :aliases => "instances"
-        attribute :session_affinity, :aliases => "sessionAffinity"
-        attribute :failover_ratio, :aliases => "failoverRatio"
-        attribute :backup_pool, :aliases => "backupPool"
-
-        def save
-          requires :name, :region
-
-          options = {
-            'description' => description,
-            'region' => region,
-            'healthChecks' => health_checks,
-            'instances' => instances,
-            'sessionAffinity' => session_affinity,
-            'failoverRatio' => failover_ratio,
-            'backupPool' => backup_pool
-          }
-
-          data = service.insert_target_pool(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 destroy(async=true)
-          requires :name, :region
-          operation = service.delete_target_pool(name, region)
-          if not async
-            # wait until "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 add_instance instance
-          instance = instance.self_link unless instance.class == String
-          service.add_target_pool_instances(self, [instance])
-          reload
-        end
-
-        def remove_instance instance
-          instance = instance.self_link unless instance.class == String
-          service.remove_target_pool_instances(self, [instance])
-          reload
-        end
-
-        def add_health_check health_check
-          health_check = health_check.self_link unless health_check.class == String
-          service.add_target_pool_health_checks(self, [health_check])
-          reload
-        end
-
-        def remove_health_check health_check
-          health_check = health_check.self_link unless health_check.class == String
-          service.remove_target_pool_health_checks(self, [health_check])
-          reload
-        end
-
-        def get_health
-          service.get_target_pool_health self
-        end
-
-        def ready?
-          begin
-            service.get_target_pool(self.name, self.region)
-            true
-          rescue Fog::Errors::NotFound
-            false
-          end
-        end
-
-        def region_name
-          region.nil? ? nil : region.split('/')[-1]
-        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