# File lib/deltacloud/drivers/mock/mock_driver.rb, line 87 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
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 111 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 339 def addresses(credentials, opts={}) check_credentials(credentials) addresses = @client.build_all(Address) addresses = filter_on( addresses, :id, opts ) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 359 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 287 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 435 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 489 def blob_metadata(credentials, opts={}) check_credentials(credentials) if blob = @client.load_collection(:blobs, opts[:id]) blob[:user_metadata] else nil end end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 425 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
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 384 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
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 345 def create_address(credentials, opts={}) check_credentials(credentials) address = {:id => allocate_mock_address.to_s, :instance_id=>nil} @client.store(:addresses, address) Address.new(address) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 447 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 @client.store(:blobs, blob) Blob.new(blob) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 399 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 132 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
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 176 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) hwp ||= find_hardware_profile(credentials, 'm1-small', 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
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 319 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]) @client.store(:keys, key_hash) end return Key.new(key_hash) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 266 def create_storage_volume(credentials, opts={}) check_credentials(credentials) opts[:capacity] ||= "1" id = "Volume#{Time.now.to_i}" volume = { :id => id, :name => opts[:name] ? opts[:name] : id, :created => Time.now.to_s, :state => "AVAILABLE", :capacity => opts[:capacity], } @client.store(:storage_volumes, volume) StorageVolume.new(volume) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 478 def delete_blob(credentials, bucket_id, blob_id, opts={}) check_credentials(credentials) safely do raise "NotExistentBlob" unless @client.load_collection(:blobs, blob_id) @client.destroy(:blobs, blob_id) end end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 414 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.rb, line 352 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 150 def destroy_image(credentials, id) check_credentials( credentials ) @client.destroy(:images, id) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 240 def destroy_instance(credentials, id) check_credentials( credentials ) @client.destroy(:instances, id) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 334 def destroy_key(credentials, opts={}) key = key(credentials, opts) @client.destroy(:keys, key.id) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 281 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 292 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 370 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_cimi_methods.rb, line 67 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 56 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
Images
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 117 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 = 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 159 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 166 def instances(credentials, opts={}) 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 = filter_on( instances, :realm_id, opts) instances end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 315 def key(credentials, opts={}) keys(credentials, opts).first end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 308 def keys(credentials, opts={}) check_credentials(credentials) result = @client.build_all(Key) result = filter_on( result, :id, opts ) result end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 536 def metric(credentials, opts={}) metric = metrics(credentials, opts).first metric.properties.each do |property| property.values = (0..5).collect do |i| unit = metric_unit_for(property.name) average = (property.name == 'cpuUtilization') ? (rand * 1000).to_i / 10.0 : rand(1000) max = (property.name == 'cpuUtilization') ? (1000 + 10 * average).to_i / 20.0 : average * (i + 1) min = (property.name == 'cpuUtilization') ? (2.5 * average).to_i / 10.0 : (average / 4).to_i { :minimum => min, :maximum => max, :average => average, :timestamp => Time.now - i * 60, :unit => unit } end end metric end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 514 def metrics(credentials, opts={}) check_credentials( credentials ) instances = @client.build_all(Instance) instances = filter_on( instances, :id, opts ) metrics_arr = instances.collect do |instance| Metric.new( :id => instance.id, :entity => instance.name ) end # add metric names to metrics metrics_arr.each do |metric| @@METRIC_NAMES.each do |name| metric.add_property(name) end metric.properties.sort! {|a,b| a.name <=> b.name} end metrics_arr end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 34 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 89 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 100 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 78 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 45 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 23 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 98 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 = REALMS end results = filter_on( results, :id, opts ) results end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 231 def reboot_instance(credentials, id) update_instance_state(credentials, id, 'RUNNING') end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 250 def run_on_instance(credentials, opts={}) ssh = Mock_ssh.new ssh.command = opts[:cmd] Deltacloud::Runner::Response.new(ssh, "This is where the output would appear if this were not a mock provider") end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 227 def start_instance(credentials, id) update_instance_state(credentials, id, 'RUNNING') end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 235 def stop_instance(credentials, id) update_instance_state(credentials, id, 'STOPPED') end
Storage Snapshots
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 301 def storage_snapshots(credentials, opts=nil) check_credentials( credentials ) snapshots = @client.build_all(StorageSnapshot) snapshots = filter_on(snapshots, :id, opts ) snapshots end
Storage Volumes
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 259 def storage_volumes(credentials, opts=nil) check_credentials( credentials ) volumes = @client.build_all(StorageVolume) volumes = filter_on( volumes, :id, opts ) volumes end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 501 def update_blob_metadata(credentials, opts={}) check_credentials(credentials) safely do blob = @client.load_collection(:blobs, opts[:id]) return false unless blob blob[:user_metadata] = BlobHelper::rename_metadata_headers(opts['meta_hash'], '') @client.store(:blobs, blob) end end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 219 def update_instance_state(credentials, id, state) instance = @client.load_collection(:instances, id) instance[:state] = state instance[:actions] = instance_actions_for( instance[:state] ) @client.store(:instances, instance) Instance.new( instance ) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 559 def valid_credentials?(credentials) begin check_credentials(credentials) return true rescue end return false end