class Deltacloud::Drivers::Mock::MockDriver

Public Class Methods

new() click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 84
def initialize
  @client = Client.new(MOCK_STORAGE_DIR)
end

Public Instance Methods

address_templates(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 285
def address_templates(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    address_templates = @client.load_all_cimi(:address_template).map{|addr_templ| CIMI::Model::AddressTemplate.from_json(addr_templ)}
    address_templates.map{|addr_templ| convert_urls(addr_templ, opts[:env])}.flatten
  else
    address_template = CIMI::Model::AddressTemplate.from_json(@client.load_cimi(:address_template, opts[:id]))
    convert_urls(address_template, opts[:env])
  end
end
addresses(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 368
def addresses(credentials, opts={})
  check_credentials(credentials)
  filter_on(@client.build_all(Address), opts, :id)
end
associate_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 388
def associate_address(credentials, opts={})
  check_credentials(credentials)
  address = @client.load_collection(:addresses, opts[:id])
  raise "AddressInUse" unless address[:instance_id].nil?
  instance = @client.load_collection(:instances, opts[:instance_id])
  address[:instance_id] = instance[:id]
  instance[:public_addresses] = [InstanceAddress.new(address[:id])]
  @client.store(:addresses, address)
  @client.store(:instances, instance)
end
attach_storage_volume(credentials, opts={}) click to toggle source

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

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 302
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 = {}) { |part| ... } click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 466
def blob_data(credentials, bucket_id, blob_id, opts = {})
  check_credentials(credentials)
  if blob = @client.load_collection(:blobs, blob_id)
    #give event machine a chance
    sleep 1
    blob[:content].split('').each {|part| yield part}
  end
end
blob_metadata(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 521
def blob_metadata(credentials, opts={})
  check_credentials(credentials)
  (blob = @client.load_collection(:blobs, opts[:id])) ? blob[:user_metadata] : nil
end
blobs(credentials, opts = {}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 456
def blobs(credentials, opts = {})
  check_credentials(credentials)
  blobs = @client.build_all(Blob)
  opts.merge!( :bucket => opts.delete('bucket') )
  filter_on(blobs, opts, :id, :bucket)
end
buckets(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 415
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, opts, :id)
end
create_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 373
def create_address(credentials, opts={})
  check_credentials(credentials)
  Address.new(@client.store(:addresses, {
    :id => allocate_mock_address.to_s,
    :instance_id => nil
  }))
end
create_blob(credentials, bucket_id, blob_id, blob_data, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 478
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,
    :last_modified => Time.now,
    :user_metadata => BlobHelper::rename_metadata_headers(blob_meta, ''),
  }
  if blob_data.kind_of? Hash
    blob_data[:tempfile].rewind
    blob.merge!({
      :content_length => blob_data[:tempfile].length,
      :content_type => blob_data[:type],
      :content => blob_data[:tempfile].read
    })
  elsif blob_data.kind_of? String
    blob.merge!({
      :content_length => blob_data.size,
      :content_type => 'text/plain',
      :content => blob_data
    })
  end
  update_bucket_size(bucket_id, :plus)
  Blob.new(@client.store(:blobs, blob))
end
create_bucket(credentials, name, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 430
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 142
def create_image(credentials, opts={})
  check_credentials(credentials)

  instance = instance(credentials, opts)

  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 195
def create_instance(credentials, image_id, opts={})
  check_credentials( credentials )

  instance_id = generate_instance_id
  realm_id = opts[:realm_id] || realms(credentials).first.id

  if opts[:hwp_id]
    hwp = find_hardware_profile(credentials, opts[:hwp_id], image_id)
  else
    hwp = find_hardware_profile(credentials, 'm1-small', image_id)
  end

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

  initial_state = opts[:initial_state] || "RUNNING"

  instance = {
    :id => instance_id,
    :name => name,
    :state => (initial_state == "STARTED" ? "RUNNING" : initial_state),
    :keyname => opts[:keyname],
    :image_id => image_id,
    :owner_id => credentials.user,
    :public_addresses => [
      InstanceAddress.new("#{image_id}.#{instance_id}.public.com", :type => :hostname)
    ],
    :private_addresses =>[
      InstanceAddress.new("#{image_id}.#{instance_id}.private.com", :type => :hostname)
    ],
    :instance_profile => InstanceProfile.new(hwp.name, opts),
    :realm_id => realm_id,
    :create_image => true,
    :actions => instance_actions_for((initial_state == "STARTED" ? "RUNNING" : initial_state)),
    :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 349
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
  }
  safely do
    raise "KeyExist" if @client.load_collection(:keys, key_hash[:id])
    Key.new(@client.store(:keys, key_hash))
  end
end
create_network(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 166
def create_network(credentials, opts={})
  check_credentials(credentials)
  id = "#{opts[:env].send("networks_url")}/#{opts[:name]}"
  net_hsh = { "id"=> id,
              "name" => opts[:name],
              "description" => opts[:description],
              "created" => Time.now,
              "state" => "STARTED",
              "networkType" => opts[:network_config].network_type,
              "mtu" =>  opts[:network_config].mtu,
              "classOfService" => opts[:network_config].class_of_service,


              "forwardingGroup"=> { "href" => opts[:forwarding_group].id },
              "operations" => [{"rel"=>"edit", "href"=> id},
                               {"rel"=>"delete", "href"=> id}]    }
  network = CIMI::Model::Network.from_json(JSON.generate(net_hsh))

  @client.store_cimi(:network, network)
  network
end
create_storage_snapshot(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 321
def create_storage_snapshot(credentials, opts={})
  check_credentials(credentials)
  id = "store_snapshot_#{Time.now.to_i}"
  snapshot = {
        :id => id,
        :created => Time.now.to_s,
        :state => "COMPLETED",
        :storage_volume_id => opts[:volume_id],
  }
  snapshot.merge!({:name => opts[:name]}) if opts[:name]
  snapshot.merge!({:description => opts[:description]}) if opts[:description]
  StorageSnapshot.new(@client.store(:storage_snapshots, snapshot))
end
create_storage_volume(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 282
def create_storage_volume(credentials, opts={})
  check_credentials(credentials)
  opts[:capacity] ||= "1"
  volume_id = "volume_#{Time.now.to_i}"
  volume = @client.store(:storage_volumes, {
    :id => volume_id,
    :name => opts[:name] ? opts[:name] : "Volume#{volume_id}",
    :created => Time.now.to_s,
    :state => "AVAILABLE",
    :capacity => opts[:capacity],
  })
  StorageVolume.new(volume)
end
create_system(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 38
def create_system(credentials, opts={})
  check_credentials(credentials)
  id = "#{opts[:env].send("systems_url")}/#{opts[:name]}"
  sys_hsh = { "id"=> id,
              "name" => opts[:name],
              "description" => opts[:description],
              "created" => Time.now,
              "state" => "STOPPED",
              "systemTemplate"=> { "href" => opts[:system_template].id },
              "operations" => [{"rel"=>"http://schemas.dmtf.org/cimi/1/action/start", "href"=> "#{id}/start"},
                               {"rel"=>"edit", "href"=> id},
                               {"rel"=>"delete", "href"=> id}]    }
  system = CIMI::Model::System.from_json(JSON.generate(sys_hsh))

  @client.store_cimi(:system, system)
  system
end
delete_blob(credentials, bucket_id, blob_id, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 509
def delete_blob(credentials, bucket_id, blob_id, opts={})
  check_credentials(credentials)
  safely do
    raise "NotExistentBlob" unless @client.load_collection(:blobs, blob_id)
    update_bucket_size(bucket_id, :minus)
    @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 445
def delete_bucket(credentials, name, opts={})
  check_credentials(credentials)
  bucket = bucket(credentials, {:id => name})
  raise 'BucketNotExist' if bucket.nil?
  raise "BucketNotEmpty" unless bucket.blob_list.empty?
  @client.destroy(:buckets, bucket.id)
end
delete_network(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 188
def delete_network(credentials, id)
  check_credentials(credentials)
  @client.destroy_cimi(:network, id)
end
destroy_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 381
def destroy_address(credentials, opts={})
  check_credentials(credentials)
  address = @client.load_collection(:addresses, opts[:id])
  raise "AddressInUse" unless address[:instance_id].nil?
  @client.destroy(:addresses, opts[:id])
end
destroy_image(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 162
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 255
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 363
def destroy_key(credentials, opts={})
  key = key(credentials, opts)
  @client.destroy(:keys, key.id)
end
destroy_storage_snapshot(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 335
def destroy_storage_snapshot(credentials, opts={})
  check_credentials(credentials)
  @client.destroy(:storage_snapshots, opts[:id])
end
destroy_storage_volume(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 296
def destroy_storage_volume(credentials, opts={})
  check_credentials(credentials)
  @client.destroy(:storage_volumes, opts[:id])
end
destroy_system(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 56
def destroy_system(credentials, id)
  check_credentials(credentials)
  @client.destroy_cimi(:system, id)
end
detach_storage_volume(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 307
def detach_storage_volume(credentials, opts={})
  check_credentials(credentials)
  detach_volume_instance(opts[:id], opts[:instance_id])
end
disassociate_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 399
def disassociate_address(credentials, opts={})
  check_credentials(credentials)
  address = @client.load_collection(:addresses, opts[:id])
  raise "AddressNotInUse" unless address[:instance_id]
  instance = @client.load_collection(:instances, address[:instance_id])
  address[:instance_id] = nil
  instance[:public_addresses] = [
    InstanceAddress.new("#{instance[:image_id]}.#{instance[:id]}.public.com", :type => :hostname)
  ]
  @client.store(:addresses, address)
  @client.store(:instances, instance)
end
filter_by_owner(credentials, images, owner_id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 117
def filter_by_owner(credentials, images, owner_id)
  return images unless owner_id
  if owner_id == 'self'
    images.select { |e| e.owner_id == credentials.user }
  else
    filter_on(images, { :owner_id => owner_id}, :owner_id )
  end
end
forwarding_group_templates(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 241
def forwarding_group_templates(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    forwarding_group_templates = @client.load_all_cimi(:forwarding_group_template).map{|fg_templ| CIMI::Model::ForwardingGroupTemplate.from_json(fg_templ)}
    forwarding_group_templates.map{|fg_templ| convert_urls(fg_templ, opts[:env])}.flatten
  else
    forwarding_group_template = CIMI::Model::ForwardingGroupTemplate.from_json(@client.load_cimi(:forwarding_group_template, opts[:id]))
    convert_urls(forwarding_group_template, opts[:env])
  end
end
forwarding_groups(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 230
def forwarding_groups(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    forwarding_groups = @client.load_all_cimi(:forwarding_group).map{|fg| CIMI::Model::ForwardingGroup.from_json(fg)}
    forwarding_groups.map{|fg| convert_urls(fg, opts[:env])}.flatten
  else
    forwarding_group = CIMI::Model::ForwardingGroup.from_json(@client.load_cimi(:forwarding_group, opts[:id]))
    convert_urls(forwarding_group, opts[:env])
  end
end
generate_instance_id() click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 185
def generate_instance_id
  ids = @client.members(:instances)
  count, next_id = 0, ''
  loop do
    break unless ids.include?(next_id = "inst#{count}")
    count = count + 1
  end
  next_id
end
images(credentials, opts={}) click to toggle source

Images

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 129
def images(credentials, opts={})
  check_credentials(credentials)
  images = @client.build_all(Image)

  images = filter_on(images, opts, :id, :architecture)
  images = filter_by_owner(credentials, images, opts[:owner_id])

  # Add hardware profiles to each image
  images = images.map { |i| (i.hardware_profiles = hardware_profiles(nil)) && i }

  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 171
def instance(credentials, opts={})
  check_credentials( credentials )
  if instance = @client.load_collection(:instances, opts[:id])
    Instance.new(instance)
  end
end
instances(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 178
def instances(credentials, opts={})
  check_credentials( credentials )
  instances = @client.build_all(Instance)
  opts.merge!( :owner_id => credentials.user ) unless opts.has_key?(:owner_id)
  filter_on(instances, opts, :owner_id, :id, :state, :realm_id)
end
key(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 345
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 340
def keys(credentials, opts={})
  check_credentials(credentials)
  filter_on(@client.build_all(Key), opts, :id)
end
metric(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 558
def metric(credentials, opts={})
  metric = metrics(credentials).first
  metric.properties.each { |p| p.generate_mock_values! }
  metric
end
metrics(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 545
def metrics(credentials, opts={})
  check_credentials(credentials)
  instances(credentials).map do |inst|
    metric = Metric.new(
      :id     => inst.id,
      :entity => inst.name
    )
    Metric::MOCK_METRICS_NAMES.each { |metric_name| metric.add_property(metric_name) }
    metric.properties.sort! { |a,b| a.name <=> b.name }
    metric
  end
end
network_configurations(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 208
def network_configurations(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    network_configs = @client.load_all_cimi(:network_configuration).map{|net_config| CIMI::Model::NetworkConfiguration.from_json(net_config)}
    network_configs.map{|net_config| convert_urls(net_config, opts[:env])}.flatten
  else
    network_config = CIMI::Model::NetworkConfiguration.from_json(@client.load_cimi(:network_configuration, opts[:id]))
    convert_urls(network_config, opts[:env])
  end
end
network_port_configurations(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 263
def network_port_configurations(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    network_port_configurations = @client.load_all_cimi(:network_port_configuration).map{|network_port_config| CIMI::Model::NetworkPortConfiguration.from_json(network_port_config)}
    network_port_configurations.map{|network_port_config| convert_urls(network_port_config, opts[:env])}.flatten
  else
    network_port_configuration = CIMI::Model::NetworkPortConfiguration.from_json(@client.load_cimi(:network_port_configuration, opts[:id]))
    convert_urls(network_port_configuration, opts[:env])
  end
end
network_port_templates(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 274
def network_port_templates(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    network_port_templates = @client.load_all_cimi(:network_port_template).map{|net_port_templ| CIMI::Model::NetworkPortTemplate.from_json(net_port_templ)}
    network_port_templates.map{|net_port_templ| convert_urls(net_port_templ, opts[:env])}.flatten
  else
    network_port_template = CIMI::Model::NetworkPortTemplate.from_json(@client.load_cimi(:network_port_template, opts[:id]))
    convert_urls(network_port_template, opts[:env])
  end
end
network_ports(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 252
def network_ports(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    ports = @client.load_all_cimi(:network_port).map{|net_port| CIMI::Model::NetworkPort.from_json(net_port)}
    ports.map{|net_port| convert_urls(net_port, opts[:env])}.flatten
  else
    port = CIMI::Model::NetworkPort.from_json(@client.load_cimi(:network_port, opts[:id]))
    convert_urls(port, opts[:env])
  end
end
network_templates(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 219
def network_templates(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    network_templates = @client.load_all_cimi(:network_template).map{|net_templ| CIMI::Model::NetworkTemplate.from_json(net_templ)}
    network_templates.map{|net_templ| convert_urls(net_templ, opts[:env])}.flatten
  else
    network_template = CIMI::Model::NetworkTemplate.from_json(@client.load_cimi(:network_template, opts[:id]))
    convert_urls(network_template, opts[:env])
  end
end
networks(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 155
def networks(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    networks = @client.load_all_cimi(:network).map{|net| CIMI::Model::Network.from_json(net)}
    networks.map{|net| convert_urls(net, opts[:env])}.flatten
  else
    network = CIMI::Model::Network.from_json(@client.load_cimi(:network, opts[:id]))
    convert_urls(network, opts[:env])
  end
end
realms(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 88
def realms(credentials, opts={})
  check_credentials( credentials )
  results = []
  safely do
    # This hack is used to test if client capture exceptions correctly
    # To raise an exception do GET /api/realms/50[0-2]
    raise "DeltacloudErrorTest" if opts and opts[:id] == "500"
    raise "NotImplementedTest" if opts and opts[:id] == "501"
    raise "ProviderErrorTest" if opts and opts[:id] == "502"
    raise "ProviderTimeoutTest" if opts and opts[:id] == "504"
    results = [
      Realm.new(
        :id=>'us',
        :name=>'United States',
        :limit=>:unlimited,
        :state=>'AVAILABLE'
      ),
      Realm.new(
        :id=>'eu',
        :name=>'Europe',
        :limit=>:unlimited,
        :state=>'AVAILABLE'
      ),
    ]
  end
  results = filter_on( results, opts, :id )
  results
end
reboot_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 247
def reboot_instance(credentials, id)
  update_instance_state(credentials, id, 'RUNNING')
end
run_on_instance(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 265
def run_on_instance(credentials, opts={})
  ssh = MockSSH.new
  ssh.command = opts[:cmd]
  Deltacloud::Runner::Response.new(
    ssh,
    "This is where the output from '#{ssh.command}' would appear if this were not a mock provider"
  )
end
start_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 243
def start_instance(credentials, id)
  update_instance_state(credentials, id, 'RUNNING')
end
start_network(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 193
def start_network(credentials, id)
  check_credentials(credentials)
  update_object_state(id, "Network", "STARTED")
end
start_system(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 61
def start_system(credentials, id)
  check_credentials(credentials)
  update_object_state(id, "System", "STARTED")
end
stop_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 251
def stop_instance(credentials, id)
  update_instance_state(credentials, id, 'STOPPED')
end
stop_network(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 198
def stop_network(credentials, id)
  check_credentials(credentials)
  update_object_state(id, "Network", "STOPPED")
end
stop_system(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 66
def stop_system(credentials, id)
  check_credentials(credentials)
  update_object_state(id, "System", "STOPPED")
end
storage_snapshots(credentials, opts={}) click to toggle source

Storage Snapshots

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

Storage Volumes

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 277
def storage_volumes(credentials, opts={})
  check_credentials(credentials)
  filter_on(@client.build_all(StorageVolume), opts, :id)
end
suspend_network(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 203
def suspend_network(credentials, id)
  check_credentials(credentials)
  update_object_state(id, "Network", "SUSPENDED")
end
system_addresses(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 113
def system_addresses(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    addresses = @client.load_all_cimi(:system_address).map{|a| CIMI::Model::SystemAddress.from_json(a)}
  else
    begin
      addresses = [CIMI::Model::SystemVolume.from_json(@client.load_cimi(:system_address, opts[:id]))]
    rescue Errno::ENOENT
      return []
    end
  end
  addresses.map{|a|convert_urls(a, opts[:env])}.flatten
end
system_forwarding_groups(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 127
def system_forwarding_groups(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    groups = @client.load_all_cimi(:system_forwarding_group).map{|group| CIMI::Model::SystemForwardingGroup.from_json(group)}
  else
    begin
      groups = [CIMI::Model::SystemForwardingGroup.from_json(@client.load_cimi(:system_forwarding_group, opts[:id]))]
    rescue Errno::ENOENT
      return []
    end
  end
  groups.map{|g|convert_urls(g, opts[:env])}.flatten
end
system_machines(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 71
def system_machines(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    machines = @client.load_all_cimi(:system_machine).map{|mach| CIMI::Model::SystemMachine.from_json(mach)}
  else
    begin
      machines = [CIMI::Model::SystemMachine.from_json(@client.load_cimi(:system_machine, opts[:id]))]
    rescue Errno::ENOENT
      return []
    end
  end
  machines.map{|m|convert_urls(m, opts[:env])}.flatten
end
system_networks(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 99
def system_networks(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    networks = @client.load_all_cimi(:system_network).map{|net| CIMI::Model::SystemNetwork.from_json(net)}
  else
    begin
      networks = [CIMI::Model::SystemNetwork.from_json(@client.load_cimi(:system_network, opts[:id]))]
    rescue Errno::ENOENT
      return []
    end
  end
  networks.map{|n|convert_urls(n, opts[:env])}.flatten
end
system_templates(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 141
def system_templates(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    system_templates = @client.load_all_cimi(:system_template).map{|sys_templ| CIMI::Model::SystemTemplate.from_json(sys_templ)}
  else
    begin
      system_templates = [CIMI::Model::SystemTemplate.from_json(@client.load_cimi(:system_template, opts[:id]))]
    rescue Errno::ENOENT
      return []
    end
  end
  system_templates.map{|sys_templ| convert_urls(sys_templ, opts[:env])}.flatten
end
system_volumes(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 85
def system_volumes(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    volumes = @client.load_all_cimi(:system_volume).map{|vol| CIMI::Model::SystemVolume.from_json(vol)}
  else
    begin
      volumes = [CIMI::Model::SystemVolume.from_json(@client.load_cimi(:system_volume, opts[:id]))]
    rescue Errno::ENOENT
      return []
    end
  end
  volumes.map{|vol|convert_urls(vol, opts[:env])}.flatten
end
systems(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 24
def systems(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    systems = @client.load_all_cimi(:system).map{|sys| CIMI::Model::System.from_json(sys)}
  else
    begin
      systems = [CIMI::Model::System.from_json(@client.load_cimi(:system, opts[:id]))]
    rescue Errno::ENOENT
      return []
    end
  end
  systems.map{|sys| convert_urls(sys, opts[:env])}.flatten
end
update_blob_metadata(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 529
def update_blob_metadata(credentials, opts={})
  check_credentials(credentials)
  safely do
    if blob = @client.load_collection(:blobs, opts[:id])
      @client.store(:blobs, blob.merge(
        :user_metadata => BlobHelper::rename_metadata_headers(opts['meta_hash'], '')
      ))
    else
      false
    end
  end
end
update_instance_state(credentials, id, state) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 235
def update_instance_state(credentials, id, state)
  instance  = @client.load_collection(:instances, id)
  Instance.new(@client.store(:instances, instance.merge(
    :state => state,
    :actions => instance_actions_for(state)
  )))
end