fog 1.23.0 → 1.42.1

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

@@ -1,75 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Google
-      class Operation < Fog::Model
-        identity :name
-
-        attribute :kind
-        attribute :id
-        attribute :client_operation_id, :aliases => 'clientOperationId'
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
-        attribute :end_time, :aliases => 'endTime'
-        attribute :error
-        attribute :http_error_message, :aliases => 'httpErrorMessage'
-        attribute :http_error_status_code, :aliases => 'httpErrorStatusCode'
-        attribute :insert_time, :aliases => 'insertTime'
-        attribute :operation_type, :aliases => 'operationType'
-        attribute :progress
-        attribute :region
-        attribute :self_link, :aliases => 'selfLink'
-        attribute :start_time, :aliases => 'startTime'
-        attribute :status
-        attribute :status_message, :aliases => 'statusMessage'
-        attribute :target_id, :aliases => 'targetId'
-        attribute :target_link, :aliases => 'targetLink'
-        attribute :user
-        attribute :warnings
-        attribute :zone
-
-        def ready?
-          self.status == DONE_STATE
-        end
-
-        def pending?
-          self.status == PENDING_STATE
-        end
-
-        def region_name
-          region.nil? ? nil : region.split('/')[-1]
-        end
-
-        def zone_name
-          zone.nil? ? nil : zone.split('/')[-1]
-        end
-
-        def destroy
-          requires :identity
-
-          if zone
-            service.delete_zone_operation(zone, identity)
-          elsif region
-            service.delete_region_operation(region, identity)
-          else
-            service.delete_global_operation(identity)
-          end
-          true
-        end
-
-        def reload
-          requires :identity
-
-          data = collection.get(identity, zone, region)
-          new_attributes = data.attributes
-          merge_attributes(new_attributes)
-          self
-        end
-
-        PENDING_STATE = "PENDING"
-        RUNNING_STATE = "RUNNING"
-        DONE_STATE = "DONE"
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/operation'
-
-module Fog
-  module Compute
-    class Google
-      class Operations < Fog::Collection
-        model Fog::Compute::Google::Operation
-
-        def all(filters = {})
-          if filters['zone']
-            data = service.list_zone_operations(filters['zone']).body
-          elsif filters['region']
-            data = service.list_region_operations(filters['region']).body
-          else
-            data = service.list_global_operations.body
-          end
-          load(data['items'] || [])
-        end
-
-        def get(identity, zone=nil, region=nil)
-          if not zone.nil?
-            response = service.get_zone_operation(zone, identity)
-          elsif not region.nil?
-            response = service.get_region_operation(region, identity)
-          else
-            response = service.get_global_operation(identity)
-          end
-          return nil if response.nil?
-          new(response.body)
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Google
-      ##
-      # Represents a Project resource
-      #
-      # @see https://developers.google.com/compute/docs/reference/latest/projects
-      class Project < Fog::Model
-        identity :name
-
-        attribute :kind
-        attribute :id
-        attribute :common_instance_metadata, :aliases => 'commonInstanceMetadata'
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
-        attribute :description
-        attribute :quotas
-        attribute :self_link, :aliases => 'selfLink'
-
-        def set_metadata(metadata = {})
-          requires :identity
-
-          data = service.set_common_instance_metadata(identity, self.common_instance_metadata['fingerprint'], metadata)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'])
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/project'
-
-module Fog
-  module Compute
-    class Google
-      class Projects < Fog::Collection
-        model Fog::Compute::Google::Project
-
-        def get(identity)
-          if project = service.get_project(identity).body
-            new(project)
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Google
-      ##
-      # Represents a Region resource
-      #
-      # @see https://developers.google.com/compute/docs/reference/latest/regions
-      class Region < Fog::Model
-        identity :name
-
-        attribute :kind
-        attribute :id
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
-        attribute :deprecated
-        attribute :description
-        attribute :quotas
-        attribute :self_link, :aliases => 'selfLink'
-        attribute :status
-        attribute :zones
-
-        DOWN_STATE = 'DOWN'
-        UP_STATE   = 'UP'
-
-        def up?
-          self.status == UP_STATE
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/region'
-
-module Fog
-  module Compute
-    class Google
-      class Regions < Fog::Collection
-        model Fog::Compute::Google::Region
-
-        def all
-          data = service.list_regions.body
-          load(data['items'] || [])
-        end
-
-        def get(identity)
-          if region = service.get_region(identity).body
-            new(region)
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Google
-      ##
-      # Represents a Route resource
-      #
-      # @see https://developers.google.com/compute/docs/reference/latest/routes
-      class Route < Fog::Model
-        identity :name
-
-        attribute :kind
-        attribute :id
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
-        attribute :description
-        attribute :dest_range, :aliases => 'destRange'
-        attribute :network
-        attribute :next_hop_gateway, :aliases => 'nextHopGateway'
-        attribute :next_hop_instance, :aliases => 'nextHopInstance'
-        attribute :next_hop_ip, :aliases => 'nextHopIp'
-        attribute :next_hop_network, :aliases => 'nextHopNetwork'
-        attribute :priority
-        attribute :self_link, :aliases => 'selfLink'
-        attribute :tags
-        attribute :warnings
-
-        def save
-          requires :identity, :network, :dest_range, :priority
-
-          data = service.insert_route(identity, self.network, self.dest_range, self.priority, 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_route(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/routes.rb

@@ -1,25 +0,0 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/route'
-
-module Fog
-  module Compute
-    class Google
-      class Routes < Fog::Collection
-        model Fog::Compute::Google::Route
-
-        def all
-          data = service.list_routes.body
-          load(data['items'] || [])
-        end
-
-        def get(identity)
-          if route = service.get_route(identity).body
-            new(route)
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,244 +0,0 @@
-require 'fog/compute/models/server'
-require 'net/ssh/proxy/command'
-
-module Fog
-  module Compute
-    class Google
-      class Server < Fog::Compute::Server
-        identity :name
-
-        attribute :kind
-        attribute :id
-        attribute :can_ip_forward, :aliases => 'canIpForward'
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
-        attribute :description
-        attribute :disks
-        attribute :machine_type, :aliases => 'machineType'
-        attribute :metadata
-        attribute :network_interfaces, :aliases => 'networkInterfaces'
-        attribute :scheduling
-        attribute :self_link, :aliases => 'selfLink'
-        attribute :service_accounts, :aliases => 'serviceAccounts'
-        attribute :state, :aliases => 'status'
-        attribute :status_message, :aliases => 'statusMessage'
-        attribute :tags
-        attribute :zone, :aliases => :zone_name
-
-        # These attributes are not available in the representation of an 'instance' returned by the GCE API.
-        # They are useful only for the create process
-        attribute :network, :aliases => 'network'
-        attribute :external_ip, :aliases => 'externalIP'
-        attribute :auto_restart
-        attribute :on_host_maintenance
-
-        def image_name=(args)
-          Fog::Logger.deprecation("image_name= is no longer used [light_black](#{caller.first})[/]")
-        end
-
-        def image_name
-          boot_disk = disks.first
-          unless boot_disk.is_a?(Disk)
-            source = boot_disk['source']
-            match = source.match(%r{/zones/(.*)/disks/(.*)$})
-            boot_disk = service.disks.get match[2], match[1]
-          end
-          boot_disk.source_image.nil? ? nil : boot_disk.source_image
-        end
-
-        def kernel=(args)
-          Fog::Logger.deprecation("kernel= is no longer used [light_black](#{caller.first})[/]")
-        end
-
-        def kernel
-          Fog::Logger.deprecation("kernel is no longer used [light_black](#{caller.first})[/]")
-          nil
-        end
-
-        def flavor_id
-          machine_type
-        end
-
-        def flavor_id=(flavor_id)
-          machine_type=flavor_id
-        end
-
-        def destroy(async=true)
-          requires :name, :zone
-
-          data = service.delete_server(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
-
-        # not used since v1
-        def image
-          Fog::Logger.deprecation("Server.image is deprecated, get source_image from boot disk")
-          service.get_image(self.image_name.split('/')[-1])
-        end
-
-        def public_ip_address
-          ip = nil
-          if self.network_interfaces.respond_to? :each
-            self.network_interfaces.each do |netif|
-              if netif["accessConfigs"].respond_to? :each
-                netif["accessConfigs"].each do |access_config|
-                  if access_config["name"] == "External NAT"
-                    ip = access_config['natIP']
-                  end
-                end
-              end
-            end
-          end
-
-          ip
-        end
-
-        def private_ip_address
-          ip = nil
-          if self.network_interfaces.respond_to? :first
-            ip = self.network_interfaces.first['networkIP']
-          end
-          ip
-        end
-
-        def addresses
-          [private_ip_address, public_ip_address]
-        end
-
-        def attach_disk(disk, options = {})
-          requires :identity, :zone
-
-          data = service.attach_disk(identity, zone_name, disk, options)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-        end
-
-        def detach_disk(device_name)
-          requires :identity, :zone
-
-          data = service.detach_disk(identity, zone, device_name)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-        end
-
-        def reboot
-          requires :identity, :zone
-
-          data = service.reset_server(identity, zone_name)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-        end
-
-        def serial_port_output
-          requires :identity, :zone
-
-          data = service.get_server_serial_port_output(identity, zone_name)
-          data.body['contents']
-        end
-
-        def set_disk_auto_delete(auto_delete, device_name)
-          requires :identity, :zone
-
-          data = service.set_server_disk_auto_delete(identity, zone_name, auto_delete, device_name)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-        end
-
-        def set_scheduling(on_host_maintenance, automatic_restart)
-          requires :identity, :zone
-
-          data = service.set_server_scheduling(identity, zone_name, on_host_maintenance, automatic_restart)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-        end
-
-        def set_metadata(metadata = {})
-          requires :identity, :zone
-
-          data = service.set_metadata(identity, zone_name, self.metadata['fingerprint'], metadata)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-        end
-
-        def set_tags(tags = [])
-          requires :identity, :zone
-
-          data = service.set_tags(identity, zone_name, self.tags['fingerprint'], tags)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-        end
-
-        def ready?
-          self.state == RUNNING
-        end
-
-        def zone_name
-          zone.nil? ? nil : zone.split('/')[-1]
-        end
-
-        def add_ssh_key username, key
-          if self.metadata.nil?
-            self.metadata = Hash.new("")
-          end
-
-          # You can have multiple SSH keys, seperated by newlines.
-          # https://developers.google.com/compute/docs/console?hl=en#sshkeys
-          if !self.metadata["sshKeys"]
-            self.metadata["sshKeys"] = ""
-          end
-
-          if !self.metadata["sshKeys"].empty?
-            self.metadata["sshKeys"] += "\n"
-          end
-
-          self.metadata["sshKeys"] += "#{username}:#{key.strip}"
-
-          return self.metadata
-        end
-
-        def reload
-          data = service.get_server(self.name, zone_name).body
-          self.merge_attributes(data)
-        end
-
-        def save
-          requires :name
-          requires :machine_type
-          requires :zone_name
-          requires :disks
-
-          if not service.zones.find{ |zone| zone.name == self.zone_name }
-            raise ArgumentError.new "#{self.zone_name.inspect} is either down or you don't have permission to use it."
-          end
-
-          self.add_ssh_key(self.username, self.public_key) if self.public_key
-
-          options = {
-              'machineType' => machine_type,
-              'networkInterfaces' => network_interfaces,
-              'network' => network,
-              'externalIp' => external_ip,
-              'disks' => disks,
-              'metadata' => metadata,
-              'serviceAccounts' => service_accounts,
-              'tags' => tags,
-              'auto_restart' => auto_restart,
-              'on_host_maintenance' => on_host_maintenance,
-              'can_ip_forward' => can_ip_forward
-          }.delete_if {|key, value| value.nil?}
-
-          if service_accounts
-            options['serviceAccounts'] = [{
-              "kind" => "compute#serviceAccount",
-              "email" => "default",
-              "scopes" => service_accounts.map {
-                |w| w.start_with?("https://") ? w : "https://www.googleapis.com/auth/#{w}"
-              }
-            }]
-          end
-
-          data = service.insert_server(name, zone_name, options)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-          operation.wait_for { !pending? }
-          reload
-        end
-      end
-    end
-  end
-end

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