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

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

Methods included from Exceptions

exception_from_status, exceptions, included, logger, #safely

Instance Method Details

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



418
419
420
421
422
423
424
425
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 418

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 



275
276
277
278
279
280
281
282
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 275

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 



304
305
306
307
308
309
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 304

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 



324
325
326
327
328
329
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 324

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



333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 333

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 



261
262
263
264
265
266
267
268
269
270
271
272
273
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 261

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 



232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 232

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 



284
285
286
287
288
289
290
291
292
293
294
295
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 284

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 



245
246
247
248
249
250
251
252
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 245

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 



108
109
110
111
112
113
114
115
116
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 108

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 



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 169

def create_instance(credentials, image_id, opts)
  os = new_client( credentials )
  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]=Base64.encode64(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 



367
368
369
370
371
372
373
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 367

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 



442
443
444
445
446
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 442

def create_storage_snapshot(credentials, opts={})
  vs = new_client(credentials, "volume")
  safely do
  end
end

#create_storage_volume(credentials, opts = nil) ⇒ Object 



397
398
399
400
401
402
403
404
405
406
407
408
409
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 397

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 



297
298
299
300
301
302
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 297

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 



254
255
256
257
258
259
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 254

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 



118
119
120
121
122
123
124
125
126
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 118

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 



204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 204

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 



375
376
377
378
379
380
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 375

def destroy_key(credentials, opts={})
  os = new_client(credentials)
  safely do
    os.delete_keypair(opts[:id])
  end
end

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



448
449
450
451
452
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 448

def destroy_storage_snapshot(credentials, opts={})
  vs = new_client(credentials, "volume")
  safely do
  end
end

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



411
412
413
414
415
416
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 411

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 



427
428
429
430
431
432
433
434
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 427

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 



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 64

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 



85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 85

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 



320
321
322
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 320

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

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



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 147

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 



358
359
360
361
362
363
364
365
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 358

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

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



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 128

def realms(credentials, opts={})
  os = new_client(credentials)
  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 



195
196
197
198
199
200
201
202
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 195

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 



436
437
438
439
440
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 436

def storage_snapshots(credentials, opts={})
  vs = new_client(credentials, "volume")
  safely do
  end
end

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



382
383
384
385
386
387
388
389
390
391
392
393
394
395
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 382

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 



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 48

def supported_collections(credentials)
  #get the collections as defined by 'capability' and 'respond_to?' blocks
  super_collections = super
  begin
     new_client(credentials, "object-store")
  rescue Deltacloud::Exceptions::NotImplemented #OpenStack::Exception::NotImplemented...
     super_collections = super_collections - [Sinatra::Rabbit::BucketsCollection]
  end
  begin
      new_client(credentials, "volume")
  rescue Deltacloud::Exceptions::NotImplemented
      super_collections = super_collections - [Sinatra::Rabbit::StorageVolumesCollection]
  end
  super_collections
end

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



311
312
313
314
315
316
317
318
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 311

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

#valid_credentials?(credentials) ⇒ Boolean

Returns:

  • (Boolean) 


223
224
225
226
227
228
229
230
 
# File 'lib/deltacloud/drivers/openstack/openstack_driver.rb', line 223

def valid_credentials?(credentials)
  begin
    new_client(credentials)
  rescue
    return false
  end
  true
end