Included Modules

Class/Module Index [+]

Quicksearch

Fog::Rackspace::BlockStorage::Mock

Public Class Methods

new(options = {}) click to toggle source
# File lib/fog/rackspace/block_storage.rb, line 52
def initialize(options = {})
  @rackspace_api_key = options[:rackspace_api_key]
end

Public Instance Methods

create_snapshot(volume_id, options = {}) click to toggle source
# File lib/fog/rackspace/requests/block_storage/create_snapshot.rb, line 50
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
create_volume(size, options = {}) click to toggle source
# File lib/fog/rackspace/requests/block_storage/create_volume.rb, line 56
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
delete_snapshot(snapshot_id) click to toggle source
# File lib/fog/rackspace/requests/block_storage/delete_snapshot.rb, line 25
def delete_snapshot(snapshot_id)
  self.data[:snapshots].delete(snapshot_id)
  response(:status => 202)
end
delete_volume(volume_id) click to toggle source
# File lib/fog/rackspace/requests/block_storage/delete_volume.rb, line 26
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
get_snapshot(snapshot_id) click to toggle source
# File lib/fog/rackspace/requests/block_storage/get_snapshot.rb, line 35
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
get_volume(volume_id) click to toggle source
# File lib/fog/rackspace/requests/block_storage/get_volume.rb, line 39
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
get_volume_type(volume_type_id) click to toggle source
# File lib/fog/rackspace/requests/block_storage/get_volume_type.rb, line 29
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
list_snapshots() click to toggle source
# File lib/fog/rackspace/requests/block_storage/list_snapshots.rb, line 32
def list_snapshots
  snapshots = self.data[:snapshots].values

  response(:body => {"snapshots" => snapshots})
end
list_volume_types() click to toggle source
# File lib/fog/rackspace/requests/block_storage/list_volume_types.rb, line 28
def list_volume_types
  types = self.data[:volume_types].values
  response(:body => {"volume_types" => types})
end
list_volumes() click to toggle source
# File lib/fog/rackspace/requests/block_storage/list_volumes.rb, line 36
def list_volumes
  volumes = self.data[:volumes].values
  response(:body => {"volumes" => volumes})
end
request(params) click to toggle source
# File lib/fog/rackspace/block_storage.rb, line 56
def request(params)
  Fog::Mock.not_implemented
end
response(params={}) click to toggle source
# File lib/fog/rackspace/block_storage.rb, line 60
def response(params={})
  body    = params[:body] || {}
  status  = params[:status] || 200
  headers = params[:headers] || {}

  response = Excon::Response.new(:body => body, :headers => headers, :status => status)
  if params.has_key?(:expects) && ![*params[:expects]].include?(response.status)
    raise(Excon::Errors.status_error(params, response))
  else response
  end
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.