Class: Deltacloud::Drivers::Openstack::OpenstackDriver

Inherits:
BaseDriver
  • Object
show all
Defined in:
lib/deltacloud/drivers/openstack/openstack_driver.rb

Constant Summary

Constants inherited from BaseDriver

BaseDriver::MEMBER_SHOW_METHODS, BaseDriver::STATE_MACHINE_OPTS

Constants included from Deltacloud

API_VERSION, CIMI_API_VERSION

Instance Method Summary collapse

Methods inherited from BaseDriver

#address, #api_provider, #blob, #bucket, #catched_exceptions_list, #configured_providers, constraints, define_hardware_profile, define_instance_states, driver_name, feature, features, #filter_hardware_profiles, #filter_on, #find_hardware_profile, #firewall, #hardware_profile, hardware_profiles, #has_capability?, #has_feature?, has_feature?, #image, #instance, #instance_actions_for, instance_state_machine, #instance_state_machine, #key, #name, #realm, #storage_snapshot, #storage_volume, #valid_credentials?

Methods included from Deltacloud

[], config, configure, connect, database, default_frontend, drivers, enabled_frontends, frontend_required?, frontends, generate_routes, initialize_database, need_database?, new, require_frontend!

Methods included from CollectionMethods

#collection_exists?, #collection_names, #collections

Methods included from Exceptions

exception_from_status, exceptions, included, logger, #safely

Instance Method Details

#attach_storage_volume(credentials, opts = {}) ⇒ Object 



426
427
428
429
430
431
432
433
 
# 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 = {}) ⇒ Object 



283
284
285
286
287
288
289
290
 
# 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 = {}) ⇒ Object 



312
313
314
315
316
317
 
# 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) ⇒ Object 



332
333
334
335
336
337
 
# 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(/(&\w*=\w*)*$/, "").split("/").pop
  "#{blob_name}#{segment_order}"
end

#blob_stream_connection(params) ⇒ Object

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



341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
 
# 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 = {}) ⇒ Object 



269
270
271
272
273
274
275
276
277
278
279
280
281
 
# 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 = {}) ⇒ Object 



240
241
242
243
244
245
246
247
248
249
250
251
 
# 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 = {}) ⇒ Object 



292
293
294
295
296
297
298
299
300
301
302
303
 
# 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 = {}) ⇒ Object 



253
254
255
256
257
258
259
260
 
# 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) ⇒ Object 



112
113
114
115
116
117
118
119
120
 
# 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) ⇒ Object 



185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
 
# 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 = {}) ⇒ Object 



375
376
377
378
379
380
381
 
# 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 = {}) ⇒ Object 



459
460
461
462
463
464
465
466
467
 
# 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) ⇒ Object 



405
406
407
408
409
410
411
412
413
414
415
416
417
 
# 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 = {}) ⇒ Object 



305
306
307
308
309
310
 
# 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 = {}) ⇒ Object 



262
263
264
265
266
267
 
# 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) ⇒ Object 



122
123
124
125
126
127
128
129
130
 
# 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) ⇒ Object Also known as: stop_instance 



221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
 
# 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

#destroy_key(credentials, opts = {}) ⇒ Object 



383
384
385
386
387
388
 
# 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 = {}) ⇒ Object 



469
470
471
472
473
474
 
# 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 = {}) ⇒ Object 



419
420
421
422
423
424
 
# 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 = {}) ⇒ Object 



435
436
437
438
439
440
441
442
 
# 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 = {}) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# 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 =~ /The 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 = {}) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# 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 =~ /Image 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 = {}) ⇒ Object 



328
329
330
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 328

def init_segmented_blob(credentials, opts={})
  opts[:id]
end

#instances(credentials, opts = {}) ⇒ Object 



163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# 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 =~ /The 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 = {}) ⇒ Object 



366
367
368
369
370
371
372
373
 
# 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 = {}) ⇒ Object 



132
133
134
135
136
137
138
139
140
141
 
# 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 = {}) ⇒ Object 



143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
# 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] =~ /servers/
          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) ⇒ Object 



212
213
214
215
216
217
218
219
 
# 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

#storage_snapshots(credentials, opts = {}) ⇒ Object 



444
445
446
447
448
449
450
451
452
453
454
455
456
457
 
# 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 = {}) ⇒ Object 



390
391
392
393
394
395
396
397
398
399
400
401
402
403
 
# 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) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# 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 = {}) ⇒ Object 



319
320
321
322
323
324
325
326
 
# 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