fog 1.8.0 → 1.9.0

data/lib/fog/rackspace/models/load_balancers/nodes.rb

@@ -11,13 +11,13 @@ module Fog
 
         def all
           requires :load_balancer
-          data = connection.list_nodes(load_balancer.id).body['nodes']
+          data = service.list_nodes(load_balancer.id).body['nodes']
           load(data)
         end
 
         def get(node_id)
           requires :load_balancer
-          if node = connection.get_node(load_balancer.id, node_id).body['node']
+          if node = service.get_node(load_balancer.id, node_id).body['node']
             new(node)
           end
         rescue Fog::Rackspace::LoadBalancers::NotFound

data/lib/fog/rackspace/models/load_balancers/virtual_ip.rb

@@ -13,14 +13,14 @@ module Fog
 
         def destroy
           requires :identity, :load_balancer
-          connection.delete_virtual_ip(load_balancer.identity, identity)
+          service.delete_virtual_ip(load_balancer.identity, identity)
           true
         end
 
         def save
-          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
           requires :load_balancer, :type
-          data = connection.create_virtual_ip(load_balancer.id, type)
+          data = service.create_virtual_ip(load_balancer.id, type)
           merge_attributes(data.body)
           true
         end

data/lib/fog/rackspace/models/load_balancers/virtual_ips.rb

@@ -24,7 +24,7 @@ module Fog
         private
         def all_raw
           requires :load_balancer
-          connection.list_virtual_ips(load_balancer.id).body['virtualIps']
+          service.list_virtual_ips(load_balancer.id).body['virtualIps']
         end
       end
     end

data/lib/fog/rackspace/models/storage/directories.rb

@@ -10,7 +10,7 @@ module Fog
         model Fog::Storage::Rackspace::Directory
 
         def all
-          data = connection.get_containers.body
+          data = service.get_containers.body
           load(data)
         end
 
@@ -19,7 +19,7 @@ module Fog
         # > fog.directories.get('video', :cdn_cname => 'http://cdn.lunenburg.org').files.first.public_url
         # => 'http://cdn.lunenburg.org/hayley-dancing.mov'
         def get(key, options = {})
-          data = connection.get_container(key, options)
+          data = service.get_container(key, options)
           directory = new(:key => key, :cdn_cname => options[:cdn_cname])
           for key, value in data.headers
             if ['X-Container-Bytes-Used', 'X-Container-Object-Count'].include?(key)

data/lib/fog/rackspace/models/storage/directory.rb

@@ -15,8 +15,8 @@ module Fog
 
         def destroy
           requires :key
-          connection.delete_container(key)
-          connection.cdn.post_container(key, 'X-CDN-Enabled' => 'False')
+          service.delete_container(key)
+          service.cdn.post_container(key, 'X-CDN-Enabled' => 'False')
           true
         rescue Excon::Errors::NotFound
           false
@@ -26,7 +26,7 @@ module Fog
           @files ||= begin
             Fog::Storage::Rackspace::Files.new(
               :directory    => self,
-              :connection   => connection
+              :service   => service
             )
           end
         end
@@ -38,9 +38,9 @@ module Fog
         def public_url
           requires :key
           @public_url ||= begin
-            begin response = connection.cdn.head_container(key)
+            begin response = service.cdn.head_container(key)
               if response.headers['X-Cdn-Enabled'] == 'True'
-                if connection.rackspace_cdn_ssl == true
+                if service.rackspace_cdn_ssl == true
                   response.headers['X-Cdn-Ssl-Uri']
                 else
                   cdn_cname || response.headers['X-Cdn-Uri']
@@ -54,19 +54,19 @@ module Fog
 
         def save
           requires :key
-          connection.put_container(key)
+          service.put_container(key)
 
-          if @connection.cdn && @public
+          if service.cdn && @public
             # if public and CDN connection then update cdn to public
             uri_header = 'X-CDN-URI'
-            if connection.rackspace_cdn_ssl == true
+            if service.rackspace_cdn_ssl == true
               uri_header = 'X-CDN-SSL-URI'
             end
-            @public_url = connection.cdn.put_container(key, 'X-CDN-Enabled' => 'True').headers[uri_header]
-          elsif @connection.cdn && !@public
-            connection.cdn.put_container(key, 'X-CDN-Enabled' => 'False')
+            @public_url = service.cdn.put_container(key, 'X-CDN-Enabled' => 'True').headers[uri_header]
+          elsif service.cdn && !@public
+            service.cdn.put_container(key, 'X-CDN-Enabled' => 'False')
             @public_url = nil
-          elsif !@connection.cdn && @public
+          elsif !service.cdn && @public
             # if public but no CDN connection then error
             raise(Fog::Storage::Rackspace::Error.new("Directory can not be set as :public without a CDN provided"))
           end

data/lib/fog/rackspace/models/storage/file.rb

@@ -36,14 +36,14 @@ module Fog
           options['Content-Type'] ||= content_type if content_type
           options['Access-Control-Allow-Origin'] ||= access_control_allow_origin if access_control_allow_origin
           options['Origin'] ||= origin if origin
-          connection.copy_object(directory.key, key, target_directory_key, target_file_key, options)
-          target_directory = connection.directories.new(:key => target_directory_key)
+          service.copy_object(directory.key, key, target_directory_key, target_file_key, options)
+          target_directory = service.directories.new(:key => target_directory_key)
           target_directory.files.get(target_file_key)
         end
 
         def destroy
           requires :directory, :key
-          connection.delete_object(directory.key, key)
+          service.delete_object(directory.key, key)
           true
         end
 
@@ -76,7 +76,7 @@ module Fog
           options['Origin'] = origin if origin
           options.merge!(metadata_to_headers)
 
-          data = connection.put_object(directory.key, key, body, options)          
+          data = service.put_object(directory.key, key, body, options)
           update_attributes_from(data)
           refresh_metadata
 
@@ -124,8 +124,8 @@ module Fog
         end
 
         def metadata_attributes
-          if etag
-            headers = connection.head_object(directory.key, self.key).headers
+          if last_modified
+            headers = service.head_object(directory.key, self.key).headers
             headers.reject! {|k, v| !metadata_attribute?(k)}
           else
             {}

data/lib/fog/rackspace/models/storage/files.rb

@@ -54,7 +54,7 @@ module Fog
 
         def get(key, &block)
           requires :directory
-          data = connection.get_object(directory.key, key, &block)
+          data = service.get_object(directory.key, key, &block)
           file_data = data.headers.merge({
             :body => data.body,
             :key  => key
@@ -73,7 +73,7 @@ module Fog
 
         def head(key, options = {})
           requires :directory
-          data = connection.head_object(directory.key, key)
+          data = service.head_object(directory.key, key)
           file_data = data.headers.merge({
             :key => key
           })

data/lib/fog/rackspace/requests/block_storage/create_snapshot.rb

@@ -21,6 +21,34 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def create_snapshot(volume_id, options = {})
+          volume = self.data[:volumes][volume_id]
+          if volume.nil?
+            raise Fog::Rackspace::BlockStorage::NotFound
+          else
+            snapshot_id         = Fog::Rackspace::MockData.uuid
+            display_name        = options[:display_name] || "test snapshot"
+            display_description = options[:display_description] || "test snapshot description"
+
+            snapshot = {
+              "id"                  => snapshot_id,
+              "display_name"        => display_name,
+              "display_description" => display_description,
+              "volume_id"           => volume_id,
+              "status"              => "available",
+              "size"                => volume["size"],
+              "created_at"          => Fog::Rackspace::MockData.zulu_time,
+              "availability_zone"   => "nova",
+            }
+
+            self.data[:snapshots][snapshot_id] = snapshot
+
+            response(:body => {"snapshot" => snapshot})
+          end
+        end
+      end
     end
   end
 end

data/lib/fog/rackspace/requests/block_storage/create_volume.rb

@@ -22,6 +22,43 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def create_volume(size, options = {})
+          if size < 1 && !options[:snapshot_id]
+            raise Fog::Rackspace::BlockStorage::BadRequest
+          elsif size < 100 || size > 1024
+            raise Fog::Rackspace::BlockStorage::BadRequest.new("'size' parameter must be between 100 and 1024")
+          else
+            volume_id         = Fog::Rackspace::MockData.uuid
+            name              = options[:display_name] || "test volume"
+            description       = options[:display_description] || "description goes here"
+            volume_type       = options[:volume_type] || "SATA"
+
+            volume = {
+              "id"                  => volume_id,
+              "display_name"        => name,
+              "display_description" => description,
+              "size"                => size,
+              "status"              => "available",
+              "volume_type"         => volume_type,
+              "snapshot_id"         => nil,
+              "attachments"         => [],
+              "created_at"          => Fog::Rackspace::MockData.zulu_time,
+              "availability_zone"   => "nova",
+              "metadata"            => {},
+            }
+            if options[:snapshot_id]
+              snapshot = self.data[:snapshots][snapshot_id]
+              volume.merge!("size" => snapshot["size"])
+            end
+
+            self.data[:volumes][volume_id] = volume
+
+            response(:body => {"volume" => volume})
+          end
+        end
+      end
     end
   end
 end

data/lib/fog/rackspace/requests/block_storage/delete_snapshot.rb

@@ -10,6 +10,13 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def delete_snapshot(snapshot_id)
+          self.data[:snapshots].delete(snapshot_id)
+          response(:status => 202)
+        end
+      end
     end
   end
 end

data/lib/fog/rackspace/requests/block_storage/delete_volume.rb

@@ -10,6 +10,23 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def delete_volume(volume_id)
+          volume = self.data[:volumes][volume_id]
+          snapshots = self.data[:snapshots].values.select { |s| s["volume_id"] == volume_id }
+          raise Fog::Rackspace::BlockStorage::BadRequest.new("Volume still has #{snapshots.count} dependent snapshots") if !snapshots.empty?
+          unless volume.nil?
+            unless volume["attachments"].empty?
+              raise Fog::Rackspace::BlockStorage::BadRequest.new("Volume status must be available or error")
+            end
+            self.data[:volumes].delete(volume_id)
+            response(:status => 202)
+          else
+            raise Fog::Rackspace::BlockStorage::NotFound
+          end
+        end
+      end
     end
   end
 end

data/lib/fog/rackspace/requests/block_storage/get_snapshot.rb

@@ -10,6 +10,17 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def get_snapshot(snapshot_id)
+          snapshot = self.data[:snapshots][snapshot_id]
+          if snapshot.nil?
+            raise Fog::Rackspace::BlockStorage::NotFound
+          else
+            response(:body => {"snapshot" => snapshot})
+          end
+        end
+      end
     end
   end
 end

data/lib/fog/rackspace/requests/block_storage/get_volume.rb

@@ -10,6 +10,23 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def get_volume(volume_id)
+          possible_states = ["available", "in-use"]
+          volume = self.data[:volumes][volume_id]
+          if volume.nil?
+            raise Fog::Rackspace::BlockStorage::NotFound
+          else
+            volume["status"] = possible_states[rand(possible_states.length)]
+            if volume.nil?
+              raise Fog::Rackspace::BlockStorage::NotFound
+            else
+              response(:body => {"volume" => volume})
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/fog/rackspace/requests/block_storage/get_volume_type.rb

@@ -10,6 +10,19 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def get_volume_type(volume_type_id)
+          type = self.data[:volume_types][volume_type_id]
+          if type.nil?
+            raise Fog::Rackspace::BlockStorage::NotFound
+          else
+            type = type.dup
+            type["id"] = type["id"].to_s
+            response(:body => {"volume_type" => type})
+          end
+        end
+      end
     end
   end
 end

data/lib/fog/rackspace/requests/block_storage/list_snapshots.rb

@@ -10,6 +10,14 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def list_snapshots
+          snapshots = self.data[:snapshots].values
+
+          response(:body => {"snapshots" => snapshots})
+        end
+      end
     end
   end
 end

data/lib/fog/rackspace/requests/block_storage/list_volume_types.rb

@@ -10,6 +10,13 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def list_volume_types
+          types = self.data[:volume_types].values
+          response(:body => {"volume_types" => types})
+        end
+      end
     end
   end
 end

data/lib/fog/rackspace/requests/block_storage/list_volumes.rb

@@ -10,6 +10,13 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def list_volumes
+          volumes = self.data[:volumes].values
+          response(:body => {"volumes" => volumes})
+        end
+      end
     end
   end
 end

data/lib/fog/rackspace/requests/compute_v2/attach_volume.rb

@@ -5,11 +5,12 @@ module Fog
         def attach_volume(server_id, volume_id, device)
           data = {
             'volumeAttachment' => {
-              'volumeId' => volume_id,
-              'device' => device
+              'volumeId' => volume_id
             }
           }
 
+          data['volumeAttachment']['device'] = device if device
+          
           request(
             :body => Fog::JSON.encode(data),
             :expects => [200],
@@ -18,6 +19,44 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def attach_volume(server_id, volume_id, device)
+          volume = self.data[:volumes][volume_id]
+          server = self.data[:servers][server_id]
+
+          if server.nil? || volume.nil?
+            raise Fog::Compute::RackspaceV2::NotFound
+          else
+            self.data[:volume_attachments] << {
+              "device"   => device,
+              "serverId" => server_id,
+              "volumeId" => volume_id,
+              "id"       => volume_id,
+            }
+
+            volume["attachments"] << {
+              "volumeId" => volume_id,
+              "serverId" => server_id,
+              "device"   => device,
+              "id"       => volume_id,
+            }
+
+            body = {
+              "volumeAttachment" => {
+                "serverId" => server_id,
+                "volumeId" => volume_id,
+                "device"   => device,
+                "id"       => volume_id,
+              }
+            }
+
+            volume["status"] = "in-use"
+
+            response(:body => body)
+          end
+        end
+      end
     end
   end
 end