fog-rackspace 0.1.0

data/lib/fog/rackspace/requests/auto_scale/list_groups.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Rackspace
+    class AutoScale
+      class Real
+        # Retrieves a list of images
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * images [Array]:
+        #       * [Hash]:
+        #         * id [String] - flavor id
+        #         * links [Array] - image links
+        #         * name [String] - image name
+        # @raise [Fog::Compute::RackspaceV2::NotFound] - HTTP 404
+        # @raise [Fog::Compute::RackspaceV2::BadRequest] - HTTP 400
+        # @raise [Fog::Compute::RackspaceV2::InternalServerError] - HTTP 500
+        # @raise [Fog::Compute::RackspaceV2::ServiceError]
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/List_Flavors-d1e4188.html
+        def list_groups
+          request(
+            :expects => [200],
+            :method => 'GET',
+            :path => 'groups'
+          )
+        end
+      end
+
+      class Mock
+        def list_groups
+          response(:body => {"groups" => self.data[:autoscale_groups]})
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/auto_scale/list_policies.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Rackspace
+    class AutoScale
+      class Real
+        def list_policies(group_id)
+          request(
+            :expects => [200],
+            :method => 'GET',
+            :path => "groups/#{group_id}/policies"
+          )
+        end
+      end
+
+      class Mock
+        def list_policies(group_id)
+          group = self.data[:autoscale_groups][group_id]
+          response(:body => {'policies' => group['scalingPolicies']})
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/auto_scale/list_webhooks.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Rackspace
+    class AutoScale
+      class Real
+        def list_webhooks(group_id, policy_id)
+          request(
+            :expects => [200],
+            :method => 'GET',
+            :path => "groups/#{group_id}/policies/#{policy_id}/webhooks"
+          )
+        end
+      end
+
+      class Mock
+        def list_webhooks(group_id, policy_id)
+          group = self.data[:autoscale_groups][group_id]
+          if group.nil?
+            raise Fog::Rackspace::AutoScale::NotFound
+          end
+
+          policy = group['scalingPolicies'].find { |p| p["id"] == policy_id }
+          if policy.nil?
+            raise Fog::Rackspace::AutoScale::NotFound
+          end
+
+          response(:body => {'webhooks' => policy['webhooks']})
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/auto_scale/pause_group_state.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Rackspace
+    class AutoScale
+      class Real
+        def pause_group_state(group_id)
+          Fog::Real.not_implemented
+          # request(
+          #   :expects => [204],
+          #   :method => 'POST',
+          #   :path => 'groups/#{group_id}/pause'
+          # )
+        end
+      end
+
+      class Mock
+        def pause_group_state(group_id)
+           Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/auto_scale/resume_group_state.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Rackspace
+    class AutoScale
+      class Real
+        def resume_group_state(group_id)
+          request(
+            :expects => [204],
+            :method => 'POST',
+            :path => "groups/#{group_id}/resume"
+          )
+        end
+      end
+
+      class Mock
+        def resume_group_state(group_id)
+           Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/auto_scale/update_group_config.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Rackspace
+    class AutoScale
+      class Real
+        def update_group_config(group_id, options)
+          body = options
+
+          request(
+            :expects => [204],
+            :method => 'PUT',
+            :path => "groups/#{group_id}/config",
+            :body => Fog::JSON.encode(body)
+          )
+        end
+      end
+
+      class Mock
+        def update_group_config(group_id, options)
+          group = self.data[:autoscale_groups][group_id]
+          if group.nil?
+            raise Fog::Rackspace::AutoScale::NotFound
+          end
+
+          config = group['groupConfiguration']
+
+          config['name'] = options['name'] if options['name']
+          config['cooldown'] = options['cooldown'] if options['cooldown']
+          config['minEntities'] = options['minEntities'] if options['minEntities']
+          config['maxEntities'] = options['maxEntities'] if options['maxEntities']
+          config['metadata'] = options['metadata'] if options['metadata']
+
+          request(:body => config)
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/auto_scale/update_launch_config.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Rackspace
+    class AutoScale
+      class Real
+        def update_launch_config(group_id, options)
+          body = options
+
+          request(
+            :expects => [204],
+            :method => 'PUT',
+            :path => "groups/#{group_id}/launch",
+            :body => Fog::JSON.encode(body)
+          )
+        end
+      end
+
+      class Mock
+        def update_launch_config(group_id, options)
+          group = self.data[:autoscale_groups][group_id]
+          if group.nil?
+            raise Fog::Rackspace::AutoScale::NotFound
+          end
+
+          config = group['launchConfiguration']
+
+          config['args'] = options['args'] if options['args']
+          config['type'] = options['type'] if options['type']
+
+          request(:body => config)
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/auto_scale/update_policy.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Rackspace
+    class AutoScale
+      class Real
+        def update_policy(group_id, policy_id, options)
+          request(
+            :expects => [204],
+            :method => 'PUT',
+            :path => "groups/#{group_id}/policies/#{policy_id}",
+            :body => Fog::JSON.encode(options)
+          )
+        end
+      end
+
+      class Mock
+        def update_policy(group_id, policy_id, options)
+          group = self.data[:autoscale_groups][group_id]
+          if group.nil?
+            raise Fog::Rackspace::AutoScale::NotFound
+          end
+
+          policy = group['scalingPolicies'].find { |p| p["id"] == policy_id }
+
+          policy.merge(options)
+
+          request(:body => policy)
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/auto_scale/update_webhook.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Rackspace
+    class AutoScale
+      class Real
+        def update_webhook(group_id, policy_id, webhook_id, options)
+          body = options
+
+          request(
+            :expects => [204],
+            :method => 'PUT',
+            :path => "groups/#{group_id}/policies/#{policy_id}/webhooks/#{webhook_id}",
+            :body => Fog::JSON.encode(body)
+          )
+        end
+      end
+
+      class Mock
+        def update_webhook(group_id, policy_id, webhook_id, options)
+          group = self.data[:autoscale_groups][group_id]
+          if group.nil?
+            raise Fog::Rackspace::AutoScale::NotFound
+          end
+
+          policy = group['scalingPolicies'].find { |p| p["id"] == policy_id }
+          if policy.nil?
+            raise Fog::Rackspace::AutoScale::NotFound
+          end
+
+          webhook = policy['webhooks'].find { |w| w['id'] == webhook_id }
+          if webhook.nil?
+            raise Fog::Rackspace::AutoScale::NotFound
+          end
+
+          webhook.merge(options)
+
+          response(:body => webhook)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module Fog
+  module Rackspace
+    class BlockStorage
+      class Real
+        # Create a snapshot from a volume
+        #
+        # @param [String] volume_id Id of server to create image from
+        # @param [Hash] options
+        # @option options [String] :display_name display name for snapshot
+        # @option options [String] :display_description display description for snapshot
+        # @option options [Boolean] :force Set to true to force service to create snapshot
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * 'snapshot' [Hash]:
+        #       * 'volume_id' [String]: - the volume_id of the snapshot
+        #         * 'display_description' [String]: - display description of snapshot
+        #         * 'status' [String]: - status of snapshot
+        #         * 'id' [String]: - id of snapshot
+        #         * 'size' [Fixnum]: - size of the snapshot in GB
+        #         * 'display_name' [String]: - display name of snapshot
+        #         * 'created_at' [String]: - creation time of snapshot
+        # @raise [Fog::Rackspace::BlockStorage::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::BlockStorage::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::BlockStorage::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::BlockStorage::ServiceError]
+        # @note All writes to the volume should be flushed before creating the snapshot, either by un-mounting any file systems on the volume or by detaching the volume.
+        # @see http://docs.rackspace.com/cbs/api/v1.0/cbs-devguide/content/POST_createSnapshot__v1__tenant_id__snapshots.html
+        def create_snapshot(volume_id, options = {})
+          data = {
+            'snapshot' => {
+              'volume_id' => volume_id
+            }
+          }
+
+          data['snapshot']['display_name'] = options[:display_name] unless options[:display_name].nil?
+          data['snapshot']['display_description'] = options[:display_description] unless options[:display_description].nil?
+          data['snapshot']['force'] = options[:force] unless options[:force].nil?
+
+          request(
+            :body => Fog::JSON.encode(data),
+            :expects => [200],
+            :method => 'POST',
+            :path => "snapshots"
+          )
+        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

@@ -0,0 +1,96 @@
+module Fog
+  module Rackspace
+    class BlockStorage
+      class Real
+        # Create volume
+        #
+        # @param [Integer] size size of volume in GB. Minimum size is 100
+        # @param [Hash] options
+        # @option options [String] :display_name display name for volume
+        # @option options [String] :display_description display description for volume
+        # @option options [String] :volume_type type of volume
+        # @option options [String] :snapshot_id The optional snapshot from which to create a volume.
+        # @option options [String] :image_id The ID of an image from the compute service. If provided, a bootable volume will be
+        #    created.
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * 'volume' [Hash]:
+        #       * 'volume_type' [String]: - type of volume
+        #       * 'display_description' [String]: - volume description
+        #       * 'metadata' [Hash]: - volume metadata
+        #       * 'availability_zone'[String]: - region of the volume
+        #       * 'status' [String]: - status of volume
+        #       * 'id' [String]: - id of volume
+        #       * 'attachments' [Array<Hash]: - array of hashes containing attachment information
+        #       * 'size' [Fixnum]: - size of volume in GB (100 GB minimum)
+        #       * 'snapshot_id' [String]: - The optional snapshot from which to create a volume.
+        #       * 'display_name' [String]: - display name of volume
+        #       * 'created_at' [String]: - the volume creation time
+        # @raise [Fog::Rackspace::BlockStorage::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::BlockStorage::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::BlockStorage::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::BlockStorage::ServiceError]
+        # @see http://docs.rackspace.com/cbs/api/v1.0/cbs-devguide/content/POST_createVolume__v1__tenant_id__volumes.html
+        def create_volume(size, options = {})
+          data = {
+            'volume' => {
+              'size' => size
+            }
+          }
+
+          data['volume']['display_name'] = options[:display_name] unless options[:display_name].nil?
+          data['volume']['display_description'] = options[:display_description] unless options[:display_description].nil?
+          data['volume']['volume_type'] = options[:volume_type] unless options[:volume_type].nil?
+          data['volume']['availability_zone'] = options[:availability_zone] unless options[:availability_zone].nil?
+          data['volume']['snapshot_id'] = options[:snapshot_id] unless options[:snapshot_id].nil?
+          data['volume']['imageRef'] = options[:image_id] unless options[:image_id].nil?
+
+          request(
+            :body => Fog::JSON.encode(data),
+            :expects => [200],
+            :method => 'POST',
+            :path => "volumes"
+          )
+        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 snapshot_id = options[:snapshot_id]
+              snapshot = self.data[:snapshots][snapshot_id]
+              volume.merge!("size" => snapshot["size"])
+            end
+            volume["image_id"] = options[:image_id] if options[:image_id]
+
+            self.data[:volumes][volume_id] = volume
+
+            response(:body => {"volume" => volume})
+          end
+        end
+      end
+    end
+  end
+end