Class/Module Index [+]

Quicksearch

Deltacloud::Drivers::Rackspace::RackspaceDriver

Public Instance Methods

blob_data(credentials, bucket_id, blob_id, opts = {}) click to toggle source

-

Blob data

-

# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 262
def blob_data(credentials, bucket_id, blob_id, opts = {})
  cf = cloudfiles_client(credentials)
  cf.container(bucket_id).object(blob_id).data_stream do |chunk|
    yield chunk
  end
end
blob_metadata(credentials, opts = {}) click to toggle source

-

Blob Metadada

-

# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 308
def blob_metadata(credentials, opts = {})
  cf = cloudfiles_client(credentials)
  meta = {}
  safely do
    meta = cf.container(opts['bucket']).object(opts[:id]).metadata
  end
  meta
end
blob_stream_connection(params) click to toggle source

params: {:user,:password,:bucket,:blob,:content_type,:content_length,:metadata}

# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 332
def blob_stream_connection(params)
  #create a cloudfiles connection object to get the authtoken
  cf, cf_host, cf_path, cf_authtoken = nil
  safely do
    cf = CloudFiles::Connection.new(:username => params[:user],
                              :api_key => params[:password])
    cf_authtoken = cf.authtoken
    cf_host = cf.storagehost
    cf_path = cf.storagepath
  end
  provider = "https://#{cf_host}"
  uri = URI.parse(provider)
  http = Net::HTTP.new(uri.host, uri.port )
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_NONE
  request = Net::HTTP::Put.new("#{cf_path}/#{params[:bucket]}/#{params[:blob]}")
  request['Host'] = "#{cf_host}"
  request['X-Auth-Token'] = "#{cf_authtoken}"
  request['Content-Type'] = params[:content_type]
  request['Content-Length'] = params[:content_length]
  request['Expect'] = "100-continue"
  metadata = params[:metadata] || {}
  BlobHelper::rename_metadata_headers(metadata, 'X-Object-Meta-')
  metadata.each{|k,v| request[k] = v}
  return http, request
end
blobs(credentials, opts = {}) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 246
def blobs(credentials, opts = {})
  cf = cloudfiles_client(credentials)
  blobs = []
  safely do
    cf_container = cf.container(opts['bucket'])
    cf_container.objects.each do |object_name|
      blobs << convert_object(cf_container.object(object_name))
    end
  end
  blobs = filter_on(blobs, :id, opts)
  blobs
end
buckets(credentials, opts = {}) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 204
def buckets(credentials, opts = {})
  bucket_list = []
  cf = cloudfiles_client(credentials)
  safely do
    unless (opts[:id].nil?)
      bucket = cf.container(opts[:id])
      bucket_list << convert_container(bucket)
    else
      cf.containers.each do |container_name|
        bucket_list << Bucket.new({:id => container_name, :name => container_name})
      end #containers.each
    end #unless
  end #safely
  filter_on(bucket_list, :id, opts)
end
create_blob(credentials, bucket_id, blob_id, blob_data, opts={}) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 272
def create_blob(credentials, bucket_id, blob_id, blob_data, opts={})
  cf = cloudfiles_client(credentials)
  #insert ec2-specific header for user metadata ... X-Object-Meta-KEY = VALUE
  BlobHelper::rename_metadata_headers(opts, "X-Object-Meta-")
  opts['Content-Type'] = blob_data[:type]
  object = nil
  safely do
    #must first create the object using cloudfiles_client.create_object
    #then can write using object.write(data)
    object = cf.container(bucket_id).create_object(blob_id)
    #blob_data is a construct with data in .tempfile and content-type in {:type}
    res = object.write(blob_data[:tempfile], opts)
  end
  Blob.new( { :id => object.name,
              :bucket => object.container.name,
              :content_length => blob_data[:tempfile].length,
              :content_type => blob_data[:type],
              :last_modified => '',
              :user_metadata => opts.select{|k,v| k.match(/^X-Object-Meta-/)}
            }
          )
end
create_bucket(credentials, name, opts = {}) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 223
def create_bucket(credentials, name, opts = {})
  bucket = nil
  cf = cloudfiles_client(credentials)
  safely do
    new_bucket = cf.create_container(name)
    bucket = convert_container(new_bucket)
  end
  bucket
end
create_image(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 96
def create_image(credentials, opts={})
  rs = new_client(credentials)
  safely do
    server = rs.get_server(opts[:id].to_i)
    image = server.create_image(opts[:name])
    Image.new(
      :id => image.id.to_s,
      :name => image.name,
      :description => image.name,
      :owner_id => credentials.user,
      :state => image.status,
      :architecture => 'x86_64'
    )
  end
end
create_instance(credentials, image_id, opts) click to toggle source

create instance. Default to flavor 1 - really need a name though... In rackspace, all flavors work with all images.

# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 82
def create_instance(credentials, image_id, opts)
  rs = new_client( credentials )
  result = nil
  params = extract_personality(opts)
  params[:name] = opts[:name] || Time.now.to_s
  params[:imageId] = image_id.to_i
  params[:flavorId] = (opts[:hwp_id] && opts[:hwp_id].length>0) ? opts[:hwp_id].to_i : 1
  safely do
    server = rs.create_server(params)
    result = convert_instance_after_create(server, credentials.user, server.adminPass)
  end
  result
end
delete_blob(credentials, bucket_id, blob_id, opts={}) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 298
def delete_blob(credentials, bucket_id, blob_id, opts={})
  cf = cloudfiles_client(credentials)
  safely do
    cf.container(bucket_id).delete_object(blob_id)
  end
end
delete_bucket(credentials, name, opts = {}) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 236
def delete_bucket(credentials, name, opts = {})
  cf = cloudfiles_client(credentials)
  safely do
    cf.delete_container(name)
  end
end
destroy_image(credentials, image_id) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 112
def destroy_image(credentials, image_id)
  rax_client = new_client(credentials)
  safely do
    image = rax_client.get_image(image_id.to_i)
    unless image.delete!
      raise "ERROR: Cannot delete image with ID:#{image_id}"
    end
  end
end
destroy_instance(credentials, instance_id) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 145
def destroy_instance(credentials, instance_id)
  rs = new_client(credentials)
  safely do
    server = rs.get_server(instance_id.to_i)
    server.delete!
    convert_instance_after_create(server, credentials.user)
  end
end
Also aliased as: stop_instance
hardware_profiles(credentials, opts = {}) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 36
def hardware_profiles(credentials, opts = {})
  rs = new_client( credentials )
  results = []
  safely do
    results = rs.list_flavors.collect do |f|
      HardwareProfile.new(f[:id].to_s) do
        architecture 'x86_64'
        memory f[:ram].to_i
        storage f[:disk].to_i
      end
    end
  end
  filter_hardware_profiles(results, opts)
end
images(credentials, opts=nil) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 51
def images(credentials, opts=nil)
  rs = new_client(credentials)
  results = []
  safely do
    results = rs.list_images.collect do |img|
      Image.new(
        :id => img[:id].to_s,
        :name => img[:name],
        :description => img[:name],
        :owner_id => credentials.user,
        :state => img[:status],
        :architecture => 'x86_64'
      )
    end
  end
  filter_on( results, :id, opts )
end
instances(credentials, opts={}) click to toggle source

Instances

# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 159
def instances(credentials, opts={})

  rs = new_client(credentials)
  insts = []

  safely do
    begin
      if opts[:id]
        server = rs.get_server(opts[:id].to_i)
        insts << convert_instance_after_create(server, credentials.user)
      else
        insts = rs.list_servers_detail.collect do |server|
          convert_instance(server, credentials.user)
        end
      end
    rescue CloudServers::Exception::ItemNotFound
    end
  end

  insts = filter_on( insts, :id, opts )
  insts = filter_on( insts, :state, opts )
  insts
end
realms(credentials, opts=nil) click to toggle source

rackspace does not at this stage have realms... its all US/TX, all the time (at least at time of writing)

# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 70
def realms(credentials, opts=nil)
  [Realm.new( {
    :id=>"us",
    :name=>"United States",
    :state=> "AVAILABLE"
  } )]
end
reboot_instance(credentials, instance_id) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 136
def reboot_instance(credentials, instance_id)
  rs = new_client(credentials)
  safely do
    server = rs.get_server(instance_id.to_i)
    server.reboot!
    convert_instance_after_create(server, credentials.user)
  end
end
run_on_instance(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 122
def run_on_instance(credentials, opts={})
  target = instance(credentials, :id => opts[:id])
  param = {}
  param[:credentials] = {
    :username => 'root',
    :password => opts[:password]
  }
  param[:port] = opts[:port] || '22'
  param[:ip] = target.public_addresses.first
  safely do
    Deltacloud::Runner.execute(opts[:cmd], param)
  end
end
stop_instance(credentials, instance_id) click to toggle source
Alias for: destroy_instance
supported_collections() click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 32
def supported_collections
  DEFAULT_COLLECTIONS + [ :buckets ] - [ :storage_snapshots, :storage_volumes ]
end
update_blob_metadata(credentials, opts={}) click to toggle source

-

Update Blob Metahash

-

# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 320
def update_blob_metadata(credentials, opts={})
  cf = cloudfiles_client(credentials)
  meta_hash = opts['meta_hash']
  #the set_metadata method actually places the 'X-Object-Meta-' prefix for us:
  BlobHelper::rename_metadata_headers(meta_hash, '')
  safely do
    blob = cf.container(opts['bucket']).object(opts[:id])
    blob.set_metadata(meta_hash)
  end
end
valid_credentials?(credentials) click to toggle source
# File lib/deltacloud/drivers/rackspace/rackspace_driver.rb, line 183
def valid_credentials?(credentials)
  begin
    new_client(credentials)
  rescue
    return false
  end
  true
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.