# File lib/deltacloud/drivers/mock/mock_driver.rb, line 84 def initialize @client = Client.new(MOCK_STORAGE_DIR) end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 182 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_cimi_mock_urls(:address_template, addr_templ, opts[:env])}.flatten else address_template = CIMI::Model::AddressTemplate.from_json(@client.load_cimi(:address_template, opts[:id])) convert_cimi_mock_urls(:address_template, address_template, opts[:env]) end end
# 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
# 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
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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 63 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
# 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
# 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
# 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
# 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
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 85 def delete_network(credentials, id) check_credentials(credentials) @client.destroy_cimi(:network, id) end
# 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
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 162 def destroy_image(credentials, id) check_credentials( credentials ) @client.destroy(:images, id) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 255 def destroy_instance(credentials, id) check_credentials( credentials ) @client.destroy(:instances, id) end
# 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
# 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
# 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
# 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
# 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
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 117 def filter_by_owner(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
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 138 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_cimi_mock_urls(:forwarding_group_template, fg_templ, opts[:env])}.flatten else forwarding_group_template = CIMI::Model::ForwardingGroupTemplate.from_json(@client.load_cimi(:forwarding_group_template, opts[:id])) convert_cimi_mock_urls(:forwarding_group_template, forwarding_group_template, opts[:env]) end end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 127 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_cimi_mock_urls(:forwarding_group, fg, opts[:env])}.flatten else forwarding_group = CIMI::Model::ForwardingGroup.from_json(@client.load_cimi(:forwarding_group, opts[:id])) convert_cimi_mock_urls(:forwarding_group, forwarding_group, opts[:env]) end end
# 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
# 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(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
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
# 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
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 345 def key(credentials, opts={}) keys(credentials, opts).first end
# 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
# 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
# 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
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 105 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_cimi_mock_urls(:network_configuration, net_config, opts[:env])}.flatten else network_config = CIMI::Model::NetworkConfiguration.from_json(@client.load_cimi(:network_configuration, opts[:id])) convert_cimi_mock_urls(:network_configuration, network_config, opts[:env]) end end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 160 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_cimi_mock_urls(:network_port_configuration, network_port_config, opts[:env])}.flatten else network_port_configuration = CIMI::Model::NetworkPortConfiguration.from_json(@client.load_cimi(:network_port_configuration, opts[:id])) convert_cimi_mock_urls(:network_port_configuration, network_port_configuration, opts[:env]) end end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 171 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_cimi_mock_urls(:network_port_template, net_port_templ, opts[:env])}.flatten else network_port_template = CIMI::Model::NetworkPortTemplate.from_json(@client.load_cimi(:network_port_template, opts[:id])) convert_cimi_mock_urls(:network_port_template, network_port_template, opts[:env]) end end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 149 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_cimi_mock_urls(:network_port, net_port, opts[:env])}.flatten else port = CIMI::Model::NetworkPort.from_json(@client.load_cimi(:network_port, opts[:id])) convert_cimi_mock_urls(:network_port, port, opts[:env]) end end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 116 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_cimi_mock_urls(:network_template, net_templ, opts[:env])}.flatten else network_template = CIMI::Model::NetworkTemplate.from_json(@client.load_cimi(:network_template, opts[:id])) convert_cimi_mock_urls(:network_template, network_template, opts[:env]) end end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 52 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_cimi_mock_urls(:network, net ,opts[:env])}.flatten else network = CIMI::Model::Network.from_json(@client.load_cimi(:network, opts[:id])) convert_cimi_mock_urls(:network, network, opts[:env]) end end
# 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
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 247 def reboot_instance(credentials, id) update_instance_state(credentials, id, 'RUNNING') end
# 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
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 243 def start_instance(credentials, id) update_instance_state(credentials, id, 'RUNNING') end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 90 def start_network(credentials, id) check_credentials(credentials) update_object_state(id, "Network", "STARTED") end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 251 def stop_instance(credentials, id) update_instance_state(credentials, id, 'STOPPED') end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 95 def stop_network(credentials, id) check_credentials(credentials) update_object_state(id, "Network", "STOPPED") end
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
# 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
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 100 def suspend_network(credentials, id) check_credentials(credentials) update_object_state(id, "Network", "SUSPENDED") end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 38 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_cimi_mock_urls(:system_template, sys_templ, opts[:env])}.flatten end
# 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_cimi_mock_urls(:system, sys ,opts[:env])}.flatten end
# 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
# 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