fog 1.29.0 → 1.30.0

data/lib/fog/google/examples/sql/operations.rb

@@ -1,20 +0,0 @@
-def test
-  connection = Fog::Google::SQL.new
-
-  puts 'Create a Instance...'
-  puts '--------------------'
-  instance = connection.instances.create(:instance => Fog::Mock.random_letters(16), :tier => 'D1')
-  instance.wait_for { ready? }
-
-  puts 'Delete the Instance...'
-  puts '----------------------'
-  operation = instance.destroy
-
-  puts 'Get the Operation...'
-  puts '--------------------'
-  connection.operations.get(instance.identity, operation.identity)
-
-  puts 'Listing all Operations...'
-  puts '-------------------------'
-  connection.operations.all(instance.identity)
-end

data/lib/fog/google/examples/sql/ssl_certs.rb

@@ -1,28 +0,0 @@
-def test
-  connection = Fog::Google::SQL.new
-
-  puts 'Create a Instance...'
-  puts '--------------------'
-  instance = connection.instances.create(:instance => Fog::Mock.random_letters(16), :tier => 'D1')
-  instance.wait_for { ready? }
-
-  puts 'Create a SSL certificate...'
-  puts '---------------------------'
-  ssl_cert = connection.ssl_certs.create(:instance => instance.instance, :common_name => Fog::Mock.random_letters(16))
-
-  puts 'Get the SSL certificate...'
-  puts '--------------------------'
-  connection.ssl_certs.get(instance.instance, ssl_cert.sha1_fingerprint)
-
-  puts 'List all SSL certificate...'
-  puts '---------------------------'
-  connection.ssl_certs.all(instance.instance)
-
-  puts 'Delete the SSL certificate...'
-  puts '-----------------------------'
-  ssl_cert.destroy
-
-  puts 'Delete the Instance...'
-  puts '----------------------'
-  instance.destroy
-end

data/lib/fog/google/examples/sql/tiers.rb

@@ -1,7 +0,0 @@
-def test
-  connection = Fog::Google::SQL.new
-
-  puts 'Listing all Tiers...'
-  puts '--------------------'
-  connection.tiers
-end

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

@@ -1,94 +0,0 @@
-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 server
-          return nil if !in_use? || self.users.nil? || self.users.empty?
-
-          service.servers.get(self.users.first.split('/')[-1])
-        end
-
-        def server=(server)
-          requires :identity, :region
-          server ? associate(server) : disassociate
-        end
-
-        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
-
-        private
-
-        def associate(server)
-          nic = server.network_interfaces.first['name']
-          data = service.add_server_access_config(server.name, server.zone_name, nic, :address => self.address)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-        end
-
-        def disassociate
-          return nil if !in_use? || self.users.nil? || self.users.empty?
-
-          # An address can only be associated with one server at a time
-          server = service.servers.get(self.users.first.split('/')[-1])
-          nic = server.network_interfaces.first['name']
-          unless server.network_interfaces.first['accessConfigs'].nil? ||
-                 server.network_interfaces.first['accessConfigs'].empty?
-            access_config = server.network_interfaces.first['accessConfigs'].first['name']
-            data = service.delete_server_access_config(server.name, server.zone_name, nic,
-                                                       :access_config => access_config)
-            Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-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
-
-        def get_by_ip_address(ip_address)
-          addresses = service.list_aggregated_addresses(:filter => "address eq .*#{ip_address}").body['items']
-          address = addresses.each_value.select { |region| region.key?('addresses') }
-
-          return nil if address.empty?
-          new(address.first['addresses'].first)
-        end
-      end
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Google
-      class BackendService < Fog::Model
-        identity :name
-
-        attribute :backends, :aliases => 'backends'
-        attribute :creation_timestamp, :aliases => 'kind'
-        attribute :description, :aliases => 'description'
-        attribute :fingerprint, :aliases => 'fingerprint'
-        attribute :health_checks, :aliases => 'healthChecks'
-        attribute :id, :aliases => 'id'
-        attribute :kind, :aliases => 'kind'
-        attribute :port, :aliases => 'port'
-        attribute :protocol, :aliases => 'protocol'
-        attribute :self_link, :aliases => 'selfLink'
-        attribute :timeout_sec, :aliases => 'timeoutSec'
-
-        def save
-          requires :name, :health_checks
-
-          options = {
-            'description' => description,
-            'backends' => backends,
-            'fingerprint' => fingerprint,
-            'healthChecks' => health_checks,
-            'port' => port,
-            'protocol' => protocol,
-            'timeoutSec' => timeout_sec
-          }
-
-          data = service.insert_backend_service(name, options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data['name'])
-          operation.wait_for { !pending? }
-          reload
-        end
-
-        def destroy(async=false)
-          requires :name
-
-          operation = service.delete_backend_service(name)
-          unless async
-            Fog.wait_for do
-              operation.body["status"] == "DONE"
-            end
-          end
-          operation
-        end
-
-        def get_health
-          service.get_backend_service_health self
-        end
-
-        def add_backend backend
-          # ensure backend is an array of hashes
-          backend = [backend] unless backend.class == Array
-          backend.map! { |resource| resource.class == String ? { 'group' => resource }: resource }
-          service.add_backend_service_backends(self, backend)
-          reload
-        end
-
-        def ready?
-          begin
-            service.get_backend_service(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/backend_services.rb

@@ -1,22 +0,0 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/backend_service'
-
-module Fog
-  module Compute
-    class Google
-      class BackendServices < Fog::Collection
-        model Fog::Compute::Google::BackendService
-
-        def all(filters={})
-          data = service.list_backend_services.body['items'] || []
-          load(data)
-        end
-
-        def get(identity)
-          response = service.get_backend_service(identity)
-          new(response.body) unless response.nil?
-        end
-      end
-    end
-  end
-end

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

@@ -1,120 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Google
-      class Disk < Fog::Model
-        identity :name
-
-        attribute :kind
-        attribute :id
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
-        attribute :zone, :aliases => :zone_name
-        attribute :status
-        attribute :description
-        attribute :size_gb, :aliases => 'sizeGb'
-        attribute :self_link, :aliases => 'selfLink'
-        attribute :source_image, :aliases => 'sourceImage'
-        attribute :source_image_id, :aliases => 'sourceImageId'
-        attribute :source_snapshot, :aliases => 'sourceSnapshot'
-        attribute :source_snapshot_id, :aliases => 'sourceSnapshotId'
-        attribute :type
-
-        def save
-          requires :name, :zone, :size_gb
-
-          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
-          options['type'] = type
-
-          data = service.insert_disk(name, zone, source_image, options)
-          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)
-          requires :name, :zone
-
-          data = service.delete_disk(name, zone_name)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-          unless async
-            operation.wait_for { ready? }
-          end
-          operation
-        end
-
-        def zone_name
-          zone.nil? ? nil : zone.split('/')[-1]
-        end
-
-        # auto_delete can only be applied to disks created before instance creation.
-        # auto_delete = true will automatically delete disk upon instance termination.
-        def get_object(writable=true, boot=false, device_name=nil, auto_delete=false)
-          mode = writable ? 'READ_WRITE' : 'READ_ONLY'
-          value = {
-            'autoDelete' => auto_delete,
-            'boot' => boot,
-            'source' => self_link,
-            'mode' => mode,
-            'deviceName' => device_name,
-            'type' => 'PERSISTENT'
-          }.select { |k, v| !v.nil? }
-          return Hash[value]
-        end
-
-        def get_as_boot_disk(writable=true, auto_delete=false)
-          get_object(writable, true, nil, auto_delete)
-        end
-
-        def ready?
-          self.status == RUNNING_STATE
-        end
-
-        def reload
-          requires :identity, :zone
-
-          return unless data = begin
-            collection.get(identity, zone_name)
-          rescue Excon::Errors::SocketError
-            nil
-          end
-
-          new_attributes = data.attributes
-          merge_attributes(new_attributes)
-          self
-        end
-
-        def create_snapshot(snapshot_name, snapshot_description="")
-          requires :name, :zone
-
-          if snapshot_name.nil? or snapshot_name.empty?
-            raise ArgumentError, 'Invalid snapshot name'
-          end
-
-          options = {
-            'name'        => snapshot_name,
-            'description' => snapshot_description,
-          }
-
-          data = service.insert_snapshot(name, zone_name, service.project, options)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-          operation.wait_for { !pending? }
-          service.snapshots.get(snapshot_name)
-        end
-
-        RUNNING_STATE = "READY"
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Google
-      class DiskType < Fog::Model
-        identity :name
-
-        attribute :kind
-        attribute :id
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
-        attribute :deprecated
-        attribute :description
-        attribute :self_link, :aliases => 'selfLink'
-        attribute :valid_disk_size, :aliases => 'validDiskSize'
-        attribute :zone
-
-        def reload
-          requires :identity, :zone
-
-          data = collection.get(identity, self.zone)
-          merge_attributes(data.attributes)
-          self
-        end
-      end
-    end
-  end
-end