class Deltacloud::Drivers::Openstack::OpenstackDriver

Public Instance Methods

attach_storage_volume(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 426
def attach_storage_volume(credentials, opts={})
  vs = new_client(credentials, "volume")
  cs = new_client(credentials, "compute")
  safely do
    cs.attach_volume(opts[:instance_id], opts[:id], opts[:device])
    volume = convert_volume(vs.get_volume(opts[:id]))
  end
end
blob_data(credentials, bucket, blob, opts={}) { |chunk| ... } click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 283
def blob_data(credentials, bucket, blob, opts={})
  os = new_client(credentials, "object-store")
  safely do
    os.container(bucket).object(blob).data_stream do |chunk|
      yield chunk
    end
  end
end
blob_metadata(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 312
def blob_metadata(credentials, opts={})
  os = new_client(credentials, "object-store")
  safely do
    os.container(opts['bucket']).object(opts[:id]).metadata
  end
end
blob_segment_id(request, response) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 332
def blob_segment_id(request, response)
  #could be in http header OR query string:
  segment_order = BlobHelper.segment_order(request)
  blob_name = request.env["PATH_INFO"].gsub(%r(&\w*=\w*)*$/, "").split("/").pop
  "#{blob_name}#{segment_order}"
end
blob_stream_connection(params) click to toggle source

params: {:user,:password,:bucket,:blob,:content_type,:content_length,:metadata} params holds the request object - for getting to blob segment params

# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 341
def blob_stream_connection(params)
  if BlobHelper.segmented_blob_op_type(params[:context]) == "segment"
    params[:blob] = "#{params[:blob]}#{BlobHelper.segment_order(params[:context])}"
  end
  tokens = params[:user].split("+")
  user_name, tenant_name = tokens.first, tokens.last
  #need a client for the auth_token and endpoints
  os = OpenStack::Connection.create(:username => user_name, :api_key => params[:password], :authtenant => tenant_name, :auth_url => api_provider, :service_type => "object-store")
  http = Net::HTTP.new(os.connection.service_host, os.connection.service_port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_NONE
  path = os.connection.service_path + URI.encode("/#{params[:bucket]}/#{params[:blob]}")
  request = Net::HTTP::Put.new(path)
  request['X-Auth-Token'] = os.connection.authtoken
  request['X-Storage-Token'] = os.connection.authtoken
  request['Connection'] = "Keep-Alive"
  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/openstack/openstack_driver.rb, line 269
def blobs(credentials, opts={})
  os = new_client(credentials, "object-store")
  blobs = []
  safely do
    bucket = os.container(opts['bucket'])
    if(opts[:id])
      blobs << convert_blob(bucket.object(opts[:id]), opts['bucket'])
    else
      bucket.objects_detail.each{|blob| blobs << convert_blob(blob, opts['bucket'])}
    end
  end
  blobs
end
buckets(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 240
def buckets(credentials, opts={})
  os = new_client(credentials, "object-store")
  buckets = []
  safely do
    if opts[:id]
      buckets << convert_bucket(os.container(opts[:id]))
    else
      os.containers.each{|bucket_name| buckets << convert_bucket(os.container(bucket_name))}
    end
  end
  buckets
end
create_blob(credentials, bucket, blob, data, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 292
def create_blob(credentials, bucket, blob, data, opts={})
  os = new_client(credentials, "object-store")
  safely do
    if(opts[:segment_manifest]) # finalize a segmented blob upload
      os_blob = os.container(bucket).create_object(blob, {:manifest=>"#{bucket}/#{opts[:segmented_blob_id]}"})
    else
      BlobHelper.rename_metadata_headers(opts, "X-Object-Meta-")
      os_blob = os.container(bucket).create_object(blob, {:content_type=> data[:type], :metadata=>opts}, data[:tempfile])
    end
    convert_blob(os_blob, bucket)
  end
end
create_bucket(credentials, name, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 253
def create_bucket(credentials, name, opts={})
  os = new_client(credentials, "object-store")
  bucket = nil
  safely do
    bucket = os.create_container(name)
  end
  convert_bucket(bucket)
end
create_image(credentials, opts) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 112
def create_image(credentials, opts)
  os = new_client(credentials)
  safely do
    server = os.get_server(opts[:id])
    image_name = opts[:name] || "#{server.name}_#{Time.now}"
    img = server.create_image(:name=>image_name)
    convert_from_image(img, os.connection.authuser)
  end
end
create_instance(credentials, image_id, opts) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 185
        def create_instance(credentials, image_id, opts)
          os = new_client( credentials, "compute")
          result = nil
#opts[:personality]: path1='server_path1'. content1='contents1', path2='server_path2', content2='contents2' etc
          params = {}
          params[:personality] = extract_personality(opts)
          params[:name] = (opts[:name] && opts[:name].length>0)? opts[:name] : "server#{Time.now.to_s}"
          params[:imageRef] = image_id
          params[:flavorRef] =  (opts[:hwp_id] && opts[:hwp_id].length>0) ?
                          opts[:hwp_id] : hardware_profiles(credentials).first.id
          if opts[:password] && opts[:password].length > 0
            params[:adminPass]=opts[:password]
          end
          if opts[:keyname] && opts[:keyname].length > 0
            params[:key_name]=opts[:keyname]
          end
          if opts[:user_data] && opts[:user_data].length > 0
            params[:user_data]=opts[:user_data]
          end
          safely do
            server = os.create_server(params)
            result = convert_from_server(server, os.connection.authuser, get_attachments(server.id, os))
          end
          result
        end
create_key(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 375
def create_key(credentials, opts={})
  os = new_client(credentials)
  safely do
    params = (opts[:public_key] and opts[:public_key].length > 0)? {:name=>opts[:key_name], :public_key=> opts[:public_key]} : {:name=>opts[:key_name]}
    convert_key(os.create_keypair(params))
  end
end
create_storage_snapshot(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 459
def create_storage_snapshot(credentials, opts={})
  vs = new_client(credentials, "volume")
  safely do
    name = opts[:name] || "snapshot_#{Time.now.to_i}"
    description = opts[:description] || "snapshot from volume #{opts[:volume_id]}"
    params = {:volume_id => opts[:volume_id], :display_name=>name, :display_description=>description}
    convert_snapshot(vs.create_snapshot(params))
  end
end
create_storage_volume(credentials, opts=nil) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 405
def create_storage_volume(credentials, opts=nil)
  vs = new_client(credentials, "volume")
  params = {}
  safely do
    params[:size] = opts.delete("capacity") || 1
    params[:display_name] = opts.delete("name") || "Volume#{Time.now}"
    params[:display_description] = opts.delete("description") || params[:display_name]
    params[:availability_zone] = opts.delete("realm_id") unless (opts["realm_id"].nil? || opts["realm_id"].empty?)
    opts.delete("commit")
    opts.delete("snapshot_id") #FIXME AFTER ADDING SNAPSHOTS TO OPENSTACK GEM
    volume = convert_volume(vs.create_volume(opts.merge(params)))
  end
end
delete_blob(credentials, bucket, blob, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 305
def delete_blob(credentials, bucket, blob, opts={})
  os = new_client(credentials, "object-store")
  safely do
    os.container(bucket).delete_object(blob)
  end
end
delete_bucket(credentials, name, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 262
def delete_bucket(credentials, name, opts={})
  os = new_client(credentials, "object-store")
  safely do
    os.delete_container(name)
  end
end
destroy_image(credentials, image_id) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 122
def destroy_image(credentials, image_id)
  os = new_client(credentials)
  begin
    image = os.get_image(image_id)
    image.delete!
  rescue
    raise Deltacloud::Exceptions.exception_from_status(500, "Cannot delete image with id #{image_id}")
  end
end
destroy_instance(credentials, instance_id) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 221
def destroy_instance(credentials, instance_id)
  os = new_client(credentials)
  server = instance = nil
  safely do
    server = os.get_server(instance_id)
    server.delete!
  end
  begin
    server.populate
    instance = convert_from_server(server, os.connection.authuser)
  rescue OpenStack::Exception::ItemNotFound
    instance = convert_from_server(server, os.connection.authuser)
    instance.state = "STOPPED"
  end
  instance
end
Also aliased as: stop_instance
destroy_key(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 383
def destroy_key(credentials, opts={})
  os = new_client(credentials)
  safely do
    os.delete_keypair(opts[:id])
  end
end
destroy_storage_snapshot(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 469
def destroy_storage_snapshot(credentials, opts={})
  vs = new_client(credentials, "volume")
  safely do
    vs.delete_snapshot(opts[:id])
  end
end
destroy_storage_volume(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 419
def destroy_storage_volume(credentials, opts={})
  vs = new_client(credentials, "volume")
  safely do
    vs.delete_volume(opts[:id])
  end
end
detach_storage_volume(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 435
def detach_storage_volume(credentials, opts={})
  vs = new_client(credentials, "volume")
  cs = new_client(credentials, "compute")
  safely do
    cs.detach_volume(opts[:instance_id], opts[:id])
    volume = convert_volume(vs.get_volume(opts[:id]))
  end
end
hardware_profiles(credentials, opts = {}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 68
def hardware_profiles(credentials, opts = {})
  os = new_client(credentials)
  results = []
  safely do
    if opts[:id]
      begin
        flavor = os.flavor(opts[:id])
        results << convert_from_flavor(flavor)
      rescue => e
        raise e unless e.message =~ %rThe resource could not be found/
        results = []
      end
    else
      results = os.flavors.collect do |f|
        convert_from_flavor(f)
      end
    end
    filter_hardware_profiles(results, opts)
  end
end
images(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 89
def images(credentials, opts={})
  os = new_client(credentials)
  results = []
  profiles = hardware_profiles(credentials)
  safely do
    if(opts[:id])
      begin
        img = os.get_image(opts[:id])
        results << convert_from_image(img, os.connection.authuser)
      rescue => e
        raise e unless e.message =~ %rImage not found/
        results = []
      end
    else
      results = os.list_images.collect do |i|
        convert_from_image(i, os.connection.authuser)
      end
    end
  end
  results.each { |img| img.hardware_profiles = profiles }
  filter_on(results, :owner_id, opts)
end
init_segmented_blob(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 328
def init_segmented_blob(credentials, opts={})
  opts[:id]
end
instances(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 163
def instances(credentials, opts={})
  os = new_client(credentials)
  insts = attachments = []
  safely do
    if opts[:id]
      begin
        server = os.get_server(opts[:id])
        insts << convert_from_server(server, os.connection.authuser, get_attachments(opts[:id], os))
      rescue => e
        raise e unless e.message =~ %rThe resource could not be found/
        insts = []
      end
    else
      insts = os.list_servers_detail.collect do |s|
        convert_from_server(s, os.connection.authuser,get_attachments(s[:id], os))
      end
    end
  end
  insts = filter_on( insts, :state, opts )
  insts
end
keys(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 366
def keys(credentials, opts={})
  os = new_client(credentials)
  keys = []
  safely do
    os.keypairs.values.each{|key| keys << convert_key(key)}
  end
  filter_on(keys, :id, opts)
end
providers(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 132
def providers(credentials, opts={})
  os = new_client(credentials, "compute", true)
  providers = []
  os.connection.regions_list.each_pair do |region, services|
    resource_types = services.inject([]){|res, cur| res << cur[:service] if ["compute", "volume", "object-store"].include?(cur[:service]); res }
    next if resource_types.empty? #nothing here deltacloud manages
    providers << convert_provider(region)
  end
  providers
end
realms(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 143
def realms(credentials, opts={})
  os = new_client(credentials)
  realms = []
  limits = ""
  safely do
    lim = os.limits
      limits << "ABSOLUTE >> Max. Instances: #{lim[:absolute][:maxTotalInstances]} Max. RAM: #{lim[:absolute][:maxTotalRAMSize]}   ||   "
      lim[:rate].each do |rate|
        if rate[:regex] =~ %rservers/
          limits << "SERVERS >> Total: #{rate[:limit].first[:value]}  Remaining: #{rate[:limit].first[:remaining]} Time Unit: per #{rate[:limit].first[:unit]}"
        end
      end
  end
  return [] if opts[:id] and opts[:id] != 'default'
  [ Realm.new( { :id=>'default',
                :name=>'default',
                :limit => limits,
                :state=>'AVAILABLE' })]
end
reboot_instance(credentials, instance_id) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 212
def reboot_instance(credentials, instance_id)
  os = new_client(credentials)
  safely do
    server = os.get_server(instance_id)
    server.reboot! # sends a hard reboot (power cycle) - could instead server.reboot("SOFT")
    convert_from_server(server, os.connection.authuser, get_attachments(instance_id, os))
  end
end
stop_instance(credentials, instance_id) click to toggle source
Alias for: destroy_instance
storage_snapshots(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 444
def storage_snapshots(credentials, opts={})
  vs = new_client(credentials, "volume")
  snapshots = []
  safely do
    if opts[:id]
      snapshots <<  convert_snapshot(vs.get_snapshot(opts[:id]))
    else
      vs.snapshots.each do |snap|
        snapshots << convert_snapshot(snap)
      end
    end
  end
  snapshots
end
storage_volumes(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 390
def storage_volumes(credentials, opts={})
  vs = new_client(credentials, "volume")
  volumes = []
  safely do
    if opts[:id]
      volumes <<  convert_volume(vs.get_volume(opts[:id]))
    else
      vs.volumes.each do |vol|
        volumes << convert_volume(vol)
      end
    end
  end
  volumes
end
supported_collections(credentials) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 47
def supported_collections(credentials)
  #get the collections as defined by 'capability' and 'respond_to?' blocks
  super_collections = super
  begin
    new_client(credentials, "compute")
  rescue Deltacloud::Exceptions::NotImplemented
    super_collections = super_collections - [Deltacloud::Rabbit::ImagesCollection, Deltacloud::Rabbit::InstancesCollection, Deltacloud::Rabbit::InstanceStatesCollection,Deltacloud::Rabbit::KeysCollection,Deltacloud::Rabbit::RealmsCollection, Deltacloud::Rabbit::HardwareProfilesCollection]
  end
  begin
     new_client(credentials, "object-store")
  rescue Deltacloud::Exceptions::NotImplemented #OpenStack::Exception::NotImplemented...
     super_collections = super_collections - [Deltacloud::Rabbit::BucketsCollection]
  end
  begin
      new_client(credentials, "volume")
  rescue Deltacloud::Exceptions::NotImplemented
      super_collections = super_collections - [Deltacloud::Rabbit::StorageVolumesCollection, Deltacloud::Rabbit::StorageSnapshotsCollection]
  end
  super_collections
end
update_blob_metadata(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/openstack/openstack_driver.rb, line 319
def update_blob_metadata(credentials, opts={})
  os = new_client(credentials, "object-store")
  safely do
    BlobHelper.rename_metadata_headers(opts["meta_hash"], "")
    blob = os.container(opts['bucket']).object(opts[:id])
    blob.set_metadata(opts['meta_hash'])
  end
end