fog-maestrodev 1.14.0.20130806165225 → 1.15.0.20130829165835

data/lib/fog/aws/requests/rds/describe_orderable_db_instance_options.rb

@@ -0,0 +1,76 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+
+        require 'fog/aws/parsers/rds/describe_orderable_db_instance_options'
+
+        # Describe all or specified load db instances
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html
+        # ==== Parameters
+        # * Engine <~String> - The name of the engine to retrieve DB Instance options for. Required.
+        # * Options <~Hash> - Hash of options. Optional. The following keys are used:
+        #   * :db_instance_class <~String> - Filter available offerings matching the specified DB Instance class. Optional.
+        #   * :engine_version <~String> - Filters available offerings matching the specified engine version. Optional.
+        #   * :license_model <~String> - Filters available offerings matching the specified license model. Optional.
+        #   * :marker <~String> - The pagination token provided in the previous request. If this parameter is specified the response includes only records beyond the marker, up to MaxRecords. Optional.
+        #   * :max_records <~Integer> - The maximum number of records to include in the response. If more records exist, a pagination token is included in the response. Optional.
+        #   * :vpc <~Boolean> - Filter to show only the available VPC or non-VPC offerings. Optional.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_orderable_db_instance_options(engine=nil, opts={})
+          params = {}
+          params['Engine'] = engine if engine
+          params['DBInstanceClass'] = opts[:db_instance_class] if opts[:db_instance_class]
+          params['EngineVersion'] = opts[:engine_version] if opts[:engine_version]
+          params['LicenseModel'] = opts[:license_model] if opts[:license_model]
+          params['Marker'] = opts[:marker] if opts[:marker]
+          params['MaxRecords'] = opts[:max_records] if opts[:max_records]
+          params['Vpc'] = opts[:vpc] if opts[:vpc]
+
+          request({
+            'Action'  => 'DescribeOrderableDBInstanceOptions',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeOrderableDBInstanceOptions.new
+          }.merge(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_orderable_db_instance_options(engine=nil, opts={})
+          instance_options = []
+          response = Excon::Response.new
+          if engine
+            (opts[:db_instance_class] || %w(db.m2.xlarge db.m1.large)).each do |size|
+              instance_options << {'MultiAZCapable' => true,
+                                   'Engine' => engine,
+                                   'LicenseModel' => opts[:license_model] || 'general-public-license',
+                                   'ReadReplicaCapable' => true,
+                                   'EngineVersion' => opts[:engine_version] || '5.6.12',
+                                   'AvailabilityZones' => [
+                                      {'Name' => 'us-east-1b', 'ProvisionedIopsCapable' => true},
+                                      {'Name' => 'us-east-1c', 'ProvisionedIopsCapable' => true},
+                                      {'Name' => 'us-east-1d', 'ProvisionedIopsCapable' => false},
+                                      {'Name' => 'us-east-1e', 'ProvisionedIopsCapable' => true}],
+                                   'DBInstanceClass' => size,
+                                   'Vpc' => opts[:vpc].nil? ? true : opts[:vpc]}
+
+            end
+          else
+            raise Fog::AWS::RDS::NotFound.new('An engine must be specified to retrieve orderable instance options')
+          end
+
+          response.status = 200
+          response.body = {
+              'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id },
+              'DescribeOrderableDBInstanceOptionsResult' => { 'OrderableDBInstanceOptions' => instance_options }
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/storage.rb

@@ -335,7 +335,6 @@ module Fog
         end
 
         def initialize(options={})
-          require 'mime/types'
           @use_iam_profile = options[:use_iam_profile]
           setup_credentials(options)
           @region = options[:region] || DEFAULT_REGION
@@ -387,7 +386,6 @@ module Fog
         # * S3 object with connection to aws.
         def initialize(options={})
           require 'fog/core/parser'
-          require 'mime/types'
 
           @use_iam_profile = options[:use_iam_profile]
           setup_credentials(options)

data/lib/fog/brightbox/models/compute/collaboration.rb

@@ -25,14 +25,22 @@ module Fog
             :email => email
           }.delete_if { |k, v| v.nil? || v == "" }
 
-          data = connection.create_collaboration(options)
+          data = service.create_collaboration(options)
+          merge_attributes(data)
+          true
+        end
+
+        def resend
+          requires :identity
+          data = service.resend_collaboration(identity)
           merge_attributes(data)
           true
         end
 
         def destroy
           requires :identity
-          connection.destroy_collaboration(identity)
+          data = service.destroy_collaboration(identity)
+          merge_attributes(data)
           true
         end
 

data/lib/fog/brightbox/models/compute/collaborations.rb

@@ -8,13 +8,37 @@ module Fog
         model Fog::Compute::Brightbox::Collaboration
 
         def all
-          data = connection.list_collaborations
+          data = service.list_collaborations
           load(data)
         end
 
+        def get(identifier)
+          return nil if identifier.nil? || identifier == ""
+          data = service.get_collaboration(identifier)
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        # Invites a user (via an email) to collaborate on the currently scoped
+        # account at the +role+ level.
+        #
+        # @param [String] email The email address to use for the invitation
+        # @param [String] role The role being granted. Only (+admin+ is
+        #   currently supported
+        # @return [Fog::Compute::Brightbox::Collaboration]
+        #
+        def invite(email, role)
+          return nil if email.nil? || email == ""
+          return nil if role.nil? || role == ""
+          options = {:email => email, :role => role}
+          data = service.create_collaboration(options)
+          new(data)
+        end
+
         def destroy
           requires :identity
-          connection.destroy_collaboration(identity)
+          service.destroy_collaboration(identity)
           true
         end
       end

data/lib/fog/brightbox/models/compute/user_collaboration.rb

@@ -17,9 +17,24 @@ module Fog
           account['id'] || account[:id]
         end
 
+        def accept
+          requires :identity
+          data = service.accept_user_collaboration(identity)
+          merge_attributes(data)
+          true
+        end
+
+        def reject
+          requires :identity
+          data = service.reject_user_collaboration(identity)
+          merge_attributes(data)
+          true
+        end
+
         def destroy
           requires :identity
-          connection.destroy_user_collaboration(identity)
+          data = service.destroy_user_collaboration(identity)
+          merge_attributes(data)
           true
         end
 

data/lib/fog/brightbox/models/compute/user_collaborations.rb

@@ -8,13 +8,21 @@ module Fog
         model Fog::Compute::Brightbox::UserCollaboration
 
         def all
-          data = connection.list_user_collaborations
+          data = service.list_user_collaborations
           load(data)
         end
 
+        def get(identifier)
+          return nil if identifier.nil? || identifier == ""
+          data = service.get_user_collaboration(identifier)
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
         def destroy
           requires :identity
-          connection.destroy_user_collaboration(identity)
+          service.destroy_user_collaboration(identity)
           true
         end
       end

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

@@ -34,6 +34,8 @@ module Fog
         attribute :root_device_id,                          :aliases => 'rootdeviceid'
         attribute :root_device_type,                        :aliases => 'rootdevicetype'
         attribute :group
+        attribute :key_name,                                :aliases => 'keypair'
+        attribute :user_data,                                :aliases => 'userdata'
         attribute :security_group_list,    :type => :array, :aliases => 'securitygroup'
         attribute :nics,                   :type => :array, :aliases => 'nic'
 
@@ -92,6 +94,8 @@ module Fog
             'ipaddress'         => ip_address,
             'iptonetworklist'   => ip_to_network_list,
             'projectid'         => project_id,
+            'keypair'           => key_name,
+            'userdata'           => user_data,
           }
 
           options.merge!('networkids' => network_ids) if network_ids

data/lib/fog/core/collection.rb

@@ -142,4 +142,22 @@ module Fog
     end
 
   end
+
+  # Base class for collection classes whose 'all' method returns only a single page of results and passes the
+  # 'Marker' option along as self.filters[:marker]
+  class PagedCollection < Collection
+
+    def each(filters=filters)
+      if block_given?
+        begin
+          page = self.all(filters)
+          # We need to explicitly use the base 'each' method here on the page, otherwise we get infinite recursion
+          base_each = Fog::Collection.instance_method(:each)
+          base_each.bind(page).call { |item| yield item }
+        end while self.filters[:marker]
+      end
+      self
+    end
+
+  end
 end

data/lib/fog/core/credentials.rb

@@ -50,11 +50,16 @@ module Fog
     @credentials = new_credentials
   end
 
+  def self.symbolize_credential?(key)
+    ![:headers].include?(key)
+  end
+
   def self.symbolize_credentials(args)
     if args.is_a? Hash
       copy = Array.new
       args.each do |key, value|
-        copy.push(key.to_sym, self.symbolize_credentials(value))
+        obj = symbolize_credential?(key) ? self.symbolize_credentials(value) : value
+        copy.push(key.to_sym, obj)
       end
       Hash[*copy]
     else

data/lib/fog/google/compute.rb

@@ -19,6 +19,7 @@ module Fog
       request :list_zones
       request :list_global_operations
       request :list_zone_operations
+      request :list_snapshots
 
       request :get_server
       request :get_disk
@@ -27,6 +28,7 @@ module Fog
       request :get_machine_type
       request :get_network
       request :get_zone
+      request :get_snapshot
 
       request :delete_disk
       request :delete_firewall
@@ -56,6 +58,9 @@ module Fog
       model :disk
       collection :disks
 
+      model :snapshot
+      collection :snapshots
+
       class Mock
         include Collections
 
@@ -107,6 +112,18 @@ module Fog
           @default_network = 'default'
         end
 
+        # TODO: Total hack, create zone and zones model.
+        def zones
+          zones = []
+          self.list_zones.data[:body]["items"].each do |z|
+            if z["status"] == "UP"
+              zones.push z["name"]
+            end
+          end
+
+          return zones
+        end
+
         def build_result(api_method, parameters, body_object=nil)
           if body_object
             result = @client.execute(

data/lib/fog/google/examples/get_list_images.rb

@@ -0,0 +1,27 @@
+def test
+  connection = Fog::Compute.new({ :provider => "Google" })
+
+  # puts 'Listing images in all projects...'
+  # puts '---------------------------------'
+  images = connection.images.all
+  raise 'Could not LIST the images' unless images
+  # puts images.inspect
+
+  # puts 'Fetching a single image from a global project...'
+  # puts '------------------------------------------------'
+  img = connection.images.get('debian-6-squeeze-v20130515')
+  raise 'Could not GET the image' unless img
+  # puts img.inspect
+
+  # First, get the name of an image that is in the users 'project' (not global)
+  custom_img_name = images.detect { |img| img.project == img.service.project }
+  # Run the next test only if there is a custom image available
+  if custom_img_name
+    # puts 'Fetching a single image from the custom project'
+    # puts '----------------------------------------------'
+    img = connection.images.get(custom_img_name)
+    raise 'Could not GET the (custom) image' unless img
+    # puts img.inspect
+  end
+
+end

data/lib/fog/google/examples/get_list_snapshots.rb

@@ -0,0 +1,20 @@
+def test
+
+  connection = Fog::Compute.new({ :provider => "Google" })
+
+  # puts 'Listing snapshots...'
+  # puts '---------------------------------'
+  snapshots = connection.snapshots.all
+  raise 'Could not LIST the snapshots' unless snapshots
+  # puts snapshots.inspect
+
+  # puts 'Fetching a single snapshot...'
+  # puts '------------------------------------------------'
+  snap = snapshots.first
+  if !snap.nil?
+    snap = connection.snapshots.get(snap)
+    raise 'Could not GET the snapshot' unless snap
+    # puts snap.inspect
+  end
+
+end

data/lib/fog/google/examples/image_create.rb

@@ -0,0 +1,18 @@
+def test
+  connection = Fog::Compute.new({ :provider => "Google" })
+
+  rawdisk = {
+    :source         => nil, # 'http://some_valid_url_to_rootfs_tarball'
+    :container_type => 'TAR',
+  }
+
+  # Can't test this unless the 'source' points to a valid URL
+  return if rawdisk[:source].nil?
+
+  img = connection.image.create(:name             => 'test-image',
+                                :preferred_kernel => 'gce-v20130603',
+                                :description      => 'Test image (via fog)',
+                                :raw_disk         => rawdisk)
+
+  img.reload # will raise if image was not saved correctly
+end

data/lib/fog/google/examples/launch_micro_instance.rb

@@ -1,16 +1,21 @@
 def test
   connection = Fog::Compute.new({ :provider => "Google" })
   time = Time.now.utc.to_i
-  disk = connection.disks.create({:name => 'foggydisk', :size_gb => 10, :zone_name => 'us-central1-a', :image_name => 'centos-6-v20130522'})
+  disk = connection.disks.create({
+    :name => 'foggydisk',
+    :size_gb => 10,
+    :zone_name => 'us-central1-a',
+    :source_image => 'centos-6-v20130522',
+  })
 
   disk.wait_for { disk.ready? }
   params = {
     :name => "fog-smoke-test-#{Time.now.to_i}",
     :machine_type => "f1-micro",
-      :zone_name => "us-central1-a",
-      :disks => [ disk.get_as_boot_disk(true) ],
-      :kernel => 'gce-v20130522',
-      :user => ENV['USER']
+    :zone_name => "us-central1-a",
+    :disks => [ disk.get_as_boot_disk(true) ],
+    :user => ENV['USER'],
+    :kernel => 'gce-v20130522',
   }
 
   server = connection.servers.bootstrap params

data/lib/fog/google/examples/network.rb

@@ -0,0 +1,21 @@
+def test
+  connection = Fog::Compute.new({ :provider => "Google" })
+
+  # we create a new private network
+  connection.insert_network('my-private-network', '10.240.0.0/16')
+
+  server = connection.servers.create({
+    :name => "fog-smoke-test-#{Time.now.to_i}",
+    :image_name => "debian-7-wheezy-v20130522",
+    :machine_type => "n1-standard-1",
+    :zone_name => "us-central1-a",
+    :private_key_path => File.expand_path("~/.ssh/id_rsa"),
+    :public_key_path => File.expand_path("~/.ssh/id_rsa.pub"),
+    :network => 'my-private-network',
+    :external_ip => false,
+    :user => ENV['USER'],
+  })
+
+  # The network won't have any firewall rules, so we won't be able to ssh in.
+  server.wait_for { ready? }
+end

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

@@ -16,17 +16,28 @@ module Fog
         attribute :description, :aliases => 'description'
         attribute :size_gb, :aliases => 'sizeGb'
         attribute :self_link, :aliases => 'selfLink'
-        attribute :image_name, :aliases => 'image'
+        attribute :source_image, :aliases => 'sourceImage'
+        attribute :source_snapshot, :aliases => 'sourceSnapshot'
+        attribute :source_snapshot_id, :aliases => 'sourceSnapshot'
 
         def save
-          data = service.insert_disk(name, size_gb, zone_name, image_name).body
+          requires :name
+          requires :zone_name
+
+          options = {}
+          if source_image.nil?
+            options['sourceSnapshot'] = source_snapshot
+            options['sizeGb']         = size_gb
+          end
+
+          data = service.insert_disk(name, zone_name, source_image, options).body
           data = service.backoff_if_unfound {service.get_disk(name, zone_name).body}
           service.disks.merge_attributes(data)
         end
 
         def destroy
-          requires :name, :zone
-          service.delete_disk(name, zone)
+          requires :name, :zone_name
+          service.delete_disk(name, zone_name)
         end
 
         def zone
@@ -77,4 +88,4 @@ module Fog
       end
     end
   end
-end
+end

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

@@ -12,28 +12,28 @@ module Fog
         attribute :creation_timestamp, :aliases => 'creationTimestamp'
         attribute :description
         attribute :preferred_kernel, :aliases => 'preferredKernel'
+
+        # This attribute is not available in the representation of an
+        # 'image' returned by the GCE servser (see GCE API). However,
+        # images are a global resource and a user can query for images
+        # across projects. Therefore we try to remember which project
+        # the image belongs to by tracking it in this attribute.
         attribute :project
 
-        def reload
-          requires :name
+        # A RawDisk, e.g. -
+        # {
+        #   :source         => url_to_gcs_file,
+        #   :container_type => 'TAR',
+        #   :sha1Checksum   => ,
+        # }
+        attribute :raw_disk
 
-          data = {}
+        attribute :status
 
-          # Try looking for the image in known projects
-          [
-            self.service.project,
-            'google',
-            'debian-cloud',
-            'centos-cloud',
-          ].each do |owner|
-            begin
-              data = service.get_image(name, owner).body
-              data[:project] = owner
-            rescue
-            end
-          end
+        def reload
+          requires :name
 
-          raise ArgumentError, 'Specified image was not found' if data.empty?
+          data = service.get_image(name, self.project).body
 
           self.merge_attributes(data)
           self
@@ -41,8 +41,26 @@ module Fog
 
         def save
           requires :name
+          requires :preferred_kernel
+          requires :raw_disk
+
+          options = {
+            'preferredKernel' => preferred_kernel,
+            'rawDisk'         => raw_disk,
+            'description'     => description,
+          }
+
+          service.insert_image(name, options)
+
+          data = service.backoff_if_unfound {
+            service.get_image(self.name).body
+          }
+
+          # Track the name of the project in which we insert the image
+          data.merge!('project' => service.project)
+          self.project = self.service.project
 
-          reload
+          service.images.merge_attributes(data)
         end
 
         def resource_url

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

@@ -9,27 +9,53 @@ module Fog
 
         model Fog::Compute::Google::Image
 
+        GLOBAL_PROJECTS = [ 'google',
+                            'debian-cloud',
+                            'centos-cloud',
+                          ]
+
         def all
           data = []
-          [ self.service.project,
-            'google',
-            'debian-cloud',
-            'centos-cloud',
-          ].each do |project|
-            data += service.list_images(project).body["items"]
+          all_projects = GLOBAL_PROJECTS + [ self.service.project ]
+
+          all_projects.each do |project|
+            images = service.list_images(project).body["items"] || []
+
+            # Keep track of the project in which we found the image(s)
+            images.each { |img| img[:project] = project }
+            data += images
           end
+
           load(data)
         end
 
         def get(identity)
-          data = connection.get_image(identity).body
+          # Search own project before global projects
+          all_projects = [ self.service.project ] + GLOBAL_PROJECTS
+
+          data = nil
+          all_projects.each do |project|
+            begin
+              data = service.get_image(identity, project).body
+              data[:project] = project
+            rescue Fog::Errors::Error
+              next
+            else
+              break
+            end
+          end
+
+          # If it wasn't found in any project, raise
+          if data.nil?
+            raise Fog::Errors::Error.new('Unable to find the specified image '\
+                                         'in the following projects: '\
+                                         "#{all_projects.join(', ')}")
+          end
+
           new(data)
-        rescue Excon::Errors::NotFound
-          nil
         end
 
       end
-
     end
   end
 end