fog-google 0.0.2

data/lib/fog/google/dns.rb

@@ -0,0 +1,96 @@
+module Fog
+  module DNS
+    class Google < Fog::Service
+      requires :google_project
+      recognizes :app_name, :app_version, :google_client_email, :google_key_location, :google_key_string,
+                 :google_client, :google_json_key_location, :google_json_key_string
+
+      GOOGLE_DNS_API_VERSION     = 'v1beta1'
+      GOOGLE_DNS_BASE_URL        = 'https://www.googleapis.com/dns/'
+      GOOGLE_DNS_API_SCOPE_URLS  = %w(https://www.googleapis.com/auth/ndev.clouddns.readwrite)
+
+      ##
+      # MODELS
+      model_path 'fog/google/models/dns'
+
+      # Zone
+      model :zone
+      collection :zones
+
+      # Record
+      model :record
+      collection :records
+
+      # Change
+      model :change
+      collection :changes
+
+      # Project
+      model :project
+      collection :projects
+
+      ##
+      # REQUESTS
+      request_path 'fog/google/requests/dns'
+
+      # Zone
+      request :create_managed_zone
+      request :delete_managed_zone
+      request :get_managed_zone
+      request :list_managed_zones
+
+      # Record
+      request :list_resource_record_sets
+
+      # Change
+      request :create_change
+      request :get_change
+      request :list_changes
+
+      # Project
+      request :get_project
+
+      class Mock
+        include Fog::Google::Shared
+
+        def initialize(options)
+          shared_initialize(options[:google_project], GOOGLE_DNS_API_VERSION, GOOGLE_DNS_BASE_URL)
+        end
+
+        def self.data(api_version)
+          @data ||= {}
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def data(project=@project)
+          self.class.data(api_version)[project] ||= {
+            :managed_zones => {},
+            :resource_record_sets => {},
+            :changes => {},
+          }
+        end
+
+        def reset_data
+          self.class.data(api_version).delete(@project)
+        end
+      end
+
+      class Real
+        include Fog::Google::Shared
+
+        attr_accessor :client
+        attr_reader :dns
+
+        def initialize(options)
+          shared_initialize(options[:google_project], GOOGLE_DNS_API_VERSION, GOOGLE_DNS_BASE_URL)
+          options.merge!(:google_api_scope_url => GOOGLE_DNS_API_SCOPE_URLS.join(' '))
+          @client = initialize_google_client(options)
+          @dns = @client.discovered_api('dns', api_version)
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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