# File lib/deltacloud/drivers/mock/mock_driver.rb, line 85 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
opts: {:id=,:instance_id,:device}
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 284 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 390 def blob_data(credentials, bucket_id, blob_id, opts = {}) check_credentials(credentials) if blob = @client.load(: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 444 def blob_metadata(credentials, opts={}) check_credentials(credentials) if blob = @client.load(:blobs, opts[:id]) blob[:user_metadata] else nil end end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 380 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 339 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 402 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 354 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 130 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 173 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 316 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(: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 263 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 433 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
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 369 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 148 def destroy_image(credentials, id) check_credentials( credentials ) @client.destroy(:images, id) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 237 def destroy_instance(credentials, id) check_credentials( credentials ) @client.destroy(:instances, id) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 331 def destroy_key(credentials, opts={}) key = key(credentials, opts) @client.destroy(:keys, key.id) end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 278 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 289 def detach_storage_volume(credentials, opts) check_credentials(credentials) detach_volume_instance(opts[:id], opts[:instance_id]) end
Images
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 115 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 157 def instance(credentials, opts={}) check_credentials( credentials ) if instance = @client.load(:instances, opts[:id]) Instance.new(instance) end end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 164 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
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 312 def key(credentials, opts={}) keys(credentials, opts).first end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 305 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 491 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 469 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 35 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 46 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 24 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 96 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 228 def reboot_instance(credentials, id) update_instance_state(credentials, id, 'RUNNING') end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 68 def routing_group_templates(credentials, opts={}) check_credentials(credentials) if opts[:id].nil? routing_group_templates = @client.load_all_cimi(:routing_group_template).map{|rg_templ| CIMI::Model::RoutingGroupTemplate.from_json(rg_templ)} routing_group_templates.map{|rg_templ|convert_cimi_mock_urls(:routing_group_template, rg_templ, opts[:env])}.flatten else routing_group_template = CIMI::Model::RoutingGroupTemplate.from_json(@client.load_cimi(:routing_group_template, opts[:id])) convert_cimi_mock_urls(:routing_group_template, routing_group_template, opts[:env]) end end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 57 def routing_groups(credentials, opts={}) check_credentials(credentials) if opts[:id].nil? routing_groups = @client.load_all_cimi(:routing_group).map{|rg| CIMI::Model::RoutingGroup.from_json(rg)} routing_groups.map{|rg|convert_cimi_mock_urls(:routing_group, rg, opts[:env])}.flatten else routing_group = CIMI::Model::RoutingGroup.from_json(@client.load_cimi(:routing_group, opts[:id])) convert_cimi_mock_urls(:routing_group, routing_group, opts[:env]) end end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 247 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 224 def start_instance(credentials, id) update_instance_state(credentials, id, 'RUNNING') end
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 232 def stop_instance(credentials, id) update_instance_state(credentials, id, 'STOPPED') end
Storage Snapshots
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 298 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 256 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 456 def update_blob_metadata(credentials, opts={}) check_credentials(credentials) safely do blob = @client.load(: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 216 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
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 514 def valid_credentials?(credentials) begin check_credentials(credentials) return true rescue end return false end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 90 def vsp_configurations(credentials, opts={}) check_credentials(credentials) if opts[:id].nil? vsp_configurations = @client.load_all_cimi(:vsp_configuration).map{|vsp_config| CIMI::Model::VSPConfiguration.from_json(vsp_config)} vsp_configurations.map{|vsp_config|convert_cimi_mock_urls(:vsp_configuration, vsp_config, opts[:env])}.flatten else vsp_configuration = CIMI::Model::VSPConfiguration.from_json(@client.load_cimi(:vsp_configuration, opts[:id])) convert_cimi_mock_urls(:vsp_configuration, vsp_configuration, opts[:env]) end end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 101 def vsp_templates(credentials, opts={}) check_credentials(credentials) if opts[:id].nil? vsp_templates = @client.load_all_cimi(:vsp_template).map{|vsp_templ| CIMI::Model::VSPTemplate.from_json(vsp_templ)} vsp_templates.map{|vsp_templ|convert_cimi_mock_urls(:vsp_template, vsp_templ, opts[:env])}.flatten else vsp_template = CIMI::Model::VSPTemplate.from_json(@client.load_cimi(:vsp_template, opts[:id])) convert_cimi_mock_urls(:vsp_template, vsp_template, opts[:env]) end end
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 79 def vsps(credentials, opts={}) check_credentials(credentials) if opts[:id].nil? vsps = @client.load_all_cimi(:vsp).map{|vsp| CIMI::Model::VSP.from_json(vsp)} vsps.map{|vsp|convert_cimi_mock_urls(:vsp, vsp, opts[:env])}.flatten else vsp = CIMI::Model::VSP.from_json(@client.load_cimi(:vsp, opts[:id])) convert_cimi_mock_urls(:vsp, vsp, opts[:env]) end end