Class/Module Index [+]

Quicksearch

Deltacloud::Drivers::Mock::MockDriver

Constants

REALMS

Public Class Methods

new() click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 91
def initialize
  if ENV["DELTACLOUD_MOCK_STORAGE"]
    storage_root = ENV["DELTACLOUD_MOCK_STORAGE"]
  elsif Etc.getlogin
    storage_root = File::join("/var/tmp", "deltacloud-mock-#{ENV["USER"]}")
  else
    raise "Please set either the DELTACLOUD_MOCK_STORAGE or USER environment variable"
  end
  @client = Client.new(storage_root)
end

Public Instance Methods

attach_storage_volume(credentials, opts) click to toggle source

opts: {:id=,:instance_id,:device}

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 268
def attach_storage_volume(credentials, opts)
  check_credentials(credentials)
  attach_volume_instance(opts[:id], opts[:device], opts[:instance_id])
end
blob_data(credentials, bucket_id, blob_id, opts = {}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 372
def blob_data(credentials, bucket_id, blob_id, opts = {})
  check_credentials(credentials)
  if blob = @client.load(:blobs, blob_id)
    blob[:content].each {|part| yield part}
  end
end
blob_metadata(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 413
def blob_metadata(credentials, opts={})
  check_credentials(credentials)
  if blob = @client.load(:blobs, params[:id])
    blob[:user_metadata]
  else
    nil
  end
end
blobs(credentials, opts = {}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 362
def blobs(credentials, opts = {})
  check_credentials(credentials)
  blobs = @client.build_all(Blob)
  filter_on( blobs, :bucket, :bucket => opts['bucket'] )
  filter_on( blobs, :id, opts )
end
buckets(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 322
def buckets(credentials, opts={})
  check_credentials(credentials)
  buckets = @client.build_all(Bucket)
  blob_map = @client.load_all(:blobs).inject({}) do |map, blob|
    map[blob[:bucket]] ||= []
    map[blob[:bucket]] << blob[:id]
    map
  end
  buckets.each { |bucket| bucket.blob_list = blob_map[bucket.id] }
  filter_on( buckets, :id, opts )
end
create_blob(credentials, bucket_id, blob_id, blob_data, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 382
def create_blob(credentials, bucket_id, blob_id, blob_data, opts={})
  check_credentials(credentials)
  blob_meta = BlobHelper::extract_blob_metadata_hash(opts)
  blob = {
    :id => blob_id,
    :name => blob_id,
    :bucket => bucket_id,
    :content_length => blob_data[:tempfile].length,
    :content_type => blob_data[:type],
    :last_modified => Time.now,
    :user_metadata => BlobHelper::rename_metadata_headers(blob_meta, ''),
    :content => blob_data[:tempfile].read
  }
  @client.store(:blobs, blob)
  Blob.new(blob)
end
create_bucket(credentials, name, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 337
def create_bucket(credentials, name, opts={})
  check_credentials(credentials)
  bucket = {
    :id => name,
    :name=>name,
    :size=>'0',
    :blob_list=>[]
  }
  @client.store(:buckets, bucket)
  Bucket.new(bucket)
end
create_image(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 126
def create_image(credentials, opts={})
  check_credentials(credentials)
  instance = instance(credentials, :id => opts[:id])
  safely do
    raise 'CreateImageNotSupported' unless instance and instance.can_create_image?
    image = {
      :id => opts[:name],
      :name => opts[:name],
      :owner_id => 'root',
      :state => "AVAILABLE",
      :description => opts[:description],
      :architecture => 'i386'
    }
    @client.store(:images, image)
    Image.new(image)
  end
end
create_instance(credentials, image_id, opts) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 169
def create_instance(credentials, image_id, opts)
  check_credentials( credentials )
  ids = @client.members(:instances)

  count = 0
  while true
    next_id = "inst" + count.to_s
    if not ids.include?(next_id)
      break
    end
    count = count + 1
  end

  realm_id = opts[:realm_id]
  if ( realm_id.nil? )
    realm = realms(credentials).first
    ( realm_id = realm.id ) if realm
  end

  hwp = find_hardware_profile(credentials, opts[:hwp_id], image_id)

  name = opts[:name] || "i-#{Time.now.to_i}"

  instance = {
    :id => next_id,
    :name=>name,
    :state=>'RUNNING',
    :keyname => opts[:keyname],
    :image_id=>image_id,
    :owner_id=>credentials.user,
    :public_addresses=>[ InstanceAddress.new("#{image_id}.#{next_id}.public.com", :type => :hostname) ],
    :private_addresses=>[ InstanceAddress.new("#{image_id}.#{next_id}.private.com", :type => :hostname) ],
    :instance_profile => InstanceProfile.new(hwp.name, opts),
    :realm_id=>realm_id,
    :create_image=>true,
    :actions=>instance_actions_for( 'RUNNING' ),
    :user_data => opts[:user_data] ? Base64::decode64(opts[:user_data]) : nil
  }
  @client.store(:instances, instance)
  Instance.new( instance )
end
create_key(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 300
def create_key(credentials, opts={})
  check_credentials(credentials)
  key_hash = {
    :id => opts[:key_name],
    :credential_type => :key,
    :fingerprint => Key::generate_mock_fingerprint,
    :pem_rsa_key => Key::generate_mock_pem
  }

  raise "KeyExist" if @client.load(:keys, key_hash[:id])
  @client.store(:keys, key_hash)
  return Key.new(key_hash)
end
create_storage_volume(credentials, opts=nil) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 248
def create_storage_volume(credentials, opts=nil)
  check_credentials(credentials)
  opts ||= {}
  opts[:capacity] ||= "1"
  volume = {
        :id => "Volume#{Time.now.to_i}",
        :created => Time.now.to_s,
        :state => "AVAILABLE",
        :capacity => opts[:capacity],
  }
  @client.store(:storage_volumes, volume)
  StorageVolume.new(volume)
end
delete_blob(credentials, bucket_id, blob_id, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 402
def delete_blob(credentials, bucket_id, blob_id, opts={})
  check_credentials(credentials)
  safely do
    raise "NotExistentBlob" unless @client.load(:blobs, blob_id)
    @client.destroy(:blobs, blob_id)
  end
end
delete_bucket(credentials, name, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 352
def delete_bucket(credentials, name, opts={})
  check_credentials(credentials)
  bucket = bucket(credentials, {:id => name})
  raise "BucketNotEmpty" unless (bucket.size == "0")
  @client.destroy(:buckets, bucket.id)
end
destroy_image(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 144
def destroy_image(credentials, id)
  check_credentials( credentials )
  @client.destroy(:images, id)
end
destroy_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 232
def destroy_instance(credentials, id)
  check_credentials( credentials )
  @client.destroy(:instances, id)
end
destroy_key(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 314
def destroy_key(credentials, opts={})
  key = key(credentials, opts)
  @client.destroy(:keys, key.id)
end
destroy_storage_volume(credentials, opts=nil) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 262
def destroy_storage_volume(credentials, opts=nil)
  check_credentials(credentials)
  @client.destroy(:storage_volumes, opts[:id])
end
detach_storage_volume(credentials, opts) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 273
def detach_storage_volume(credentials, opts)
  check_credentials(credentials)
  detach_volume_instance(opts[:id], opts[:instance_id])
end
images(credentials, opts=nil ) click to toggle source

Images

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 112
def images(credentials, opts=nil )
  check_credentials( credentials )
  images = []
  images = @client.build_all(Image)
  images = filter_on( images, :id, opts )
  images = filter_on( images, :architecture, opts )
  if ( opts && opts[:owner_id] == 'self' )
    images = images.select{|e| e.owner_id == credentials.user }
  else
    images = filter_on( images, :owner_id, opts )
  end
  images.sort_by{|e| [e.owner_id,e.description]}
end
instance(credentials, opts={}) click to toggle source

Instances

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 153
def instance(credentials, opts={})
  check_credentials( credentials )
  if instance = @client.load(:instances, opts[:id])
    Instance.new(instance)
  end
end
instances(credentials, opts=nil) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 160
def instances(credentials, opts=nil)
  check_credentials( credentials )
  instances = @client.build_all(Instance)
  instances = filter_on( instances, :owner_id, :owner_id => credentials.user )
  instances = filter_on( instances, :id, opts )
  instances = filter_on( instances, :state, opts )
  instances
end
key(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 296
def key(credentials, opts={})
  keys(credentials, opts).first
end
keys(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 289
def keys(credentials, opts={})
  check_credentials(credentials)
  result = @client.build_all(Key)
  result = filter_on( result, :id, opts )
  result
end
realms(credentials, opts=nil) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 102
def realms(credentials, opts=nil)
  return REALMS if ( opts.nil? )
  results = REALMS
  results = filter_on( results, :id, opts )
  results
end
reboot_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 223
def reboot_instance(credentials, id)
  update_instance_state(credentials, id, 'RUNNING')
end
start_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 219
def start_instance(credentials, id)
  update_instance_state(credentials, id, 'RUNNING')
end
stop_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 227
def stop_instance(credentials, id)
  update_instance_state(credentials, id, 'STOPPED')
end
storage_snapshots(credentials, opts=nil) click to toggle source

Storage Snapshots

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 282
def storage_snapshots(credentials, opts=nil)
  check_credentials( credentials )
  snapshots = @client.build_all(StorageSnapshot)
  snapshots = filter_on(snapshots, :id, opts )
  snapshots
end
storage_volumes(credentials, opts=nil) click to toggle source

Storage Volumes

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 241
def storage_volumes(credentials, opts=nil)
  check_credentials( credentials )
  volumes = @client.build_all(StorageVolume)
  volumes = filter_on( volumes, :id, opts )
  volumes
end
supported_collections() click to toggle source

If the provider is set to storage, pretend to be a storage-only driver

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 30
def supported_collections
  if api_provider == 'storage'
    [:buckets]
  else
    DEFAULT_COLLECTIONS + [:buckets, :keys]
  end
end
update_blob_metadata(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 425
def update_blob_metadata(credentials, opts={})
  check_credentials(credentials)
  safely do
    blob = @client.load(:blobs, params[:id])
    return false unless blob
    blob[:user_metadata] = BlobHelper::rename_metadata_headers(opts['meta_hash'], '')
    @client.store(:blobs, blob)
  end
end
update_instance_state(credentials, id, state) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 211
def update_instance_state(credentials, id, state)
  instance  = @client.load(:instances, id)
  instance[:state] = state
  instance[:actions] = instance_actions_for( instance[:state] )
  @client.store(:instances, instance)
  Instance.new( instance )
end
valid_credentials?(credentials) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 435
def valid_credentials?(credentials)
  begin
    check_credentials(credentials)
    return true
  rescue
  end
  return false
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.