fog-google 0.0.2

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

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

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

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

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

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

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

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

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