Class: HpcloudController

Inherits:
Object
  • Object
show all
Defined in:
lib/process/cloud/providers/hpcloud/hpcloud.rb

Overview

Following class describe how FORJ should handle HP Cloud objects. Except Cloud connection, all HPCloud objects management are described/called in HP* modules.

Instance Method Summary collapse

Instance Method Details

#connect(sObjectType, hParams) ⇒ Object

rubocop: disable Metrics/ClassLength



185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/process/cloud/providers/hpcloud/hpcloud.rb', line 185

def connect(sObjectType, hParams)
  case sObjectType
  when :services
    Fog::HP.authenticate_v2(hParams[:hdata], hParams[:excon_opts])
  when :compute_connection
    Fog::Compute.new hParams[:hdata].merge(:provider => :hp, :version => 'v2')
  when :network_connection
    Fog::HP::Network.new(hParams[:hdata])
  else
    controller_error "'%s' is not a valid object for 'connect'", sObjectType
  end
end

#create(sObjectType, hParams) ⇒ Object

Create controller for Hpcloud



201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
 
# File 'lib/process/cloud/providers/hpcloud/hpcloud.rb', line 201

def create(sObjectType, hParams)
  case sObjectType
  when :public_ip
    required?(hParams, :compute_connection)
    required?(hParams, :server)
    HPCompute.server_assign_address(hParams[:compute_connection],
                                    hParams[:server])
  when :server
    required?(hParams, :compute_connection)
    required?(hParams, :image)
    required?(hParams, :network)
    required?(hParams, :flavor)
    required?(hParams, :keypairs)
    required?(hParams, :security_groups)
    required?(hParams, :server_name)

    options = {
      :name => hParams[:server_name],
      :flavor_id => hParams[:flavor].id,
      :image_id => hParams[:image].id,
      :key_name => hParams[:keypairs].name,
      :security_groups => [hParams[:security_groups].name],
      :networks => [hParams[:network].id]
    }

    HPCompute.create_server(hParams[:compute_connection], options,
                            hParams[:user_data], hParams[:meta_data])
  when :image
    required?(hParams, :compute_connection)
    required?(hParams, 'server#image_name')

    HPCompute.get_image(hParams[:compute_connection],
                        hParams['server#image_name'])
  when :network
    required?(hParams, :network_connection)
    required?(hParams, :network_name)

    HPNetwork.create_network(hParams[:network_connection],
                             hParams[:network_name])
  when :subnetwork
    required?(hParams, :network_connection)
    required?(hParams, :network)
    required?(hParams, :subnetwork_name)

    HPNetwork.create_subnetwork(hParams[:network_connection],
                                hParams[:network],
                                hParams[:subnetwork_name])
  when :security_groups
    required?(hParams, :network_connection)
    required?(hParams, :security_group)

    HPSecurityGroups.create_sg(hParams[:network_connection],
                               hParams[:security_group], hParams[:sg_desc])
  when :keypairs
    required?(hParams, :compute_connection)
    required?(hParams, 'credentials#keypair_name')
    required?(hParams, :public_key)

    HPKeyPairs.create_keypair(hParams[:compute_connection],
                              hParams['credentials#keypair_name'],
                              hParams[:public_key])
  when :router
    required?(hParams, :network_connection)
    required?(hParams, :router_name)

    # Forcelly used admin_status_up to true.
    hParams[:hdata] = hParams[:hdata].merge(:admin_state_up => true)

    HPNetwork.create_router(hParams[:network_connection], hParams[:hdata])
  when :rule
    required?(hParams, :network_connection)
    required?(hParams, :security_groups)
    HPSecurityGroups.create_rule(hParams[:network_connection],
                                 hParams[:hdata])
  when :router_interface
    required?(hParams, :router)
    required?(hParams, :subnetwork)
    HPNetwork.add_interface(hParams[:router], hParams[:subnetwork])
  else
    controller_error "'%s' is not a valid object for 'create'", sObjectType
  end
end

#delete(sObjectType, hParams) ⇒ Object

rubocop: enable CyclomaticComplexity, MethodLength



330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
 
# File 'lib/process/cloud/providers/hpcloud/hpcloud.rb', line 330

def delete(sObjectType, hParams)
  case sObjectType
  when :network
    HPNetwork.delete_network(hParams[:network_connection],
                             hParams[:network])
  when :rule
    HPSecurityGroups.delete_rule(hParams[:network_connection],
                                 hParams[:id])
    obj = hParams[:network_connection]
    obj.security_group_rules.get(hParams[:id]).destroy
  when :server
    required?(hParams, :compute_connection)
    required?(hParams, :server)
    HPCompute.delete_server(hParams[:compute_connection],
                            hParams[:server])
  end
end

#get(sObjectType, sUniqId, hParams) ⇒ Object

rubocop: disable CyclomaticComplexity,



348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
 
# File 'lib/process/cloud/providers/hpcloud/hpcloud.rb', line 348

def get(sObjectType, sUniqId, hParams)
  case sObjectType
  when :server_log
    required?(hParams, :server)

    hParams[:server].console_output(sUniqId)
  when :server
    required?(hParams, :compute_connection)
    HPCompute.get_server(hParams[:compute_connection], sUniqId)
  when :image
    required?(hParams, :compute_connection)
    HPCompute.get_image(hParams[:compute_connection], sUniqId)
  when :network
    required?(hParams, :network_connection)
    HPNetwork.get_network(hParams[:network_connection], sUniqId)
  when :keypairs
    required?(hParams, :compute_connection)
    HPKeyPairs.get_keypair(hParams[:compute_connection], sUniqId)
  when :public_ip
    required?(hParams, :compute_connection)
    required?(hParams, :server)
    HPCompute.get_server_assigned_address(hParams[:compute_connection],
                                          sUniqId)
  else
    forjError "'%s' is not a valid object for 'get'", sObjectType
  end
end

#get_attr(oControlerObject, key) ⇒ Object 



387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
 
# File 'lib/process/cloud/providers/hpcloud/hpcloud.rb', line 387

def get_attr(oControlerObject, key)
  if oControlerObject.is_a?(Excon::Response)
    oControlerObject.data.rh_get(:body, key)
  else
    attributes = oControlerObject.attributes
    def_attributes = oControlerObject.class.attributes
    controller_error "attribute '%s' is unknown in '%s'. "\
                     "Valid one are : '%s'",
                     key[0], oControlerObject.class,
                     def_attributes unless def_attributes.include?(key[0])
    attributes.rh_get(key)
  end
rescue => e
  controller_error "Unable to map '%s'. %s", key, e.message
end

#get_services(sObjectType, oParams) ⇒ Object

This function requires to return an Array of values or nil.



433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
 
# File 'lib/process/cloud/providers/hpcloud/hpcloud.rb', line 433

def get_services(sObjectType, oParams)
  case sObjectType
  when :services
    # oParams[sObjectType] will provide the controller object.
    # This one can be interpreted only by controller code,
    # except if controller declares how to map with this object.
    # Processes can deal only process mapped data.
    # Currently there is no services process function. No need to map.
    services = oParams[:services]
    if !oParams[:list_services].is_a?(Array)
      service_to_find = [oParams[:list_services]]
    else
      service_to_find = oParams[:list_services]
    end
    # Search for service. Ex: Can be :Networking or network. I currently do
    # not know why...
    search_services = services.rh_get(:service_catalog)
    service = nil
    service_to_find.each do |sServiceElem|
      if search_services.key?(sServiceElem)
        service = sServiceElem
        break
      end
    end

    controller_error 'Unable to find services %s',
                     service_to_find if service.nil?
    result = services.rh_get(:service_catalog, service).keys
    result.delete('name')
    result.each_index do |iIndex|
      result[iIndex] = result[iIndex].to_s if result[iIndex].is_a?(Symbol)
    end
    return result
  else
    controller_error "'%s' is not a valid object for 'get_services'",
                     sObjectType
  end
end

#query(sObjectType, sQuery, hParams) ⇒ Object

This function return a collection which have to provide: functions: [], length, each Used by network process.



287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/process/cloud/providers/hpcloud/hpcloud.rb', line 287

def query(sObjectType, sQuery, hParams)
  case sObjectType
  when :public_ip
    required?(hParams, :compute_connection)
    required?(hParams, :server)
    HPCompute.query_server_assigned_addresses(hParams[:compute_connection],
                                              hParams[:server], sQuery)
  when :server
    required?(hParams, :compute_connection)
    HPCompute.query_server(hParams[:compute_connection], sQuery)
  when :image
    required?(hParams, :compute_connection)
    HPCompute.query_image(hParams[:compute_connection], sQuery)
  when :network
    required?(hParams, :network_connection)
    HPNetwork.query_network(hParams[:network_connection], sQuery)
  when :subnetwork
    required?(hParams, :network_connection)
    HPNetwork.query_subnetwork(hParams[:network_connection], sQuery)
  when :router
    required?(hParams, :network_connection)
    HPNetwork.query_router(hParams[:network_connection], sQuery)
  when :port
    required?(hParams, :network_connection)
    HPNetwork.query_port(hParams[:network_connection], sQuery)
  when :security_groups
    required?(hParams, :network_connection)
    HPSecurityGroups.query_sg(hParams[:network_connection], sQuery)
  when :rule
    required?(hParams, :network_connection)
    HPSecurityGroups.query_rule(hParams[:network_connection], sQuery)
  when :keypairs
    required?(hParams, :compute_connection)
    HPKeyPairs.query_keypair(hParams[:compute_connection], sQuery)
  when :flavor
    required?(hParams, :compute_connection)
    HPCompute.query_flavor(hParams[:compute_connection], sQuery)
  else
    controller_error "'%s' is not a valid object for 'query'", sObjectType
  end
end

#query_each(oFogObject) ⇒ Object

rubocop: enable CyclomaticComplexity



377
378
379
380
381
382
383
384
385
 
# File 'lib/process/cloud/providers/hpcloud/hpcloud.rb', line 377

def query_each(oFogObject)
  case oFogObject.class.to_s
  when 'Fog::HP::Network::Networks'
    oFogObject.each { |value| yield(value) }
  else
    controller_error "'%s' is not a valid list for 'each'",
                     oFogObject.class
  end
end

#set_attr(oControlerObject, key, value) ⇒ Object 



403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
 
# File 'lib/process/cloud/providers/hpcloud/hpcloud.rb', line 403

def set_attr(oControlerObject, key, value)
  controller_class = oControlerObject.class

  controller_error "No set feature for '%s'",
                   controller_class if oControlerObject.is_a?(Excon::Response)

  attributes = oControlerObject.attributes
  def_attributes = oControlerObject.class.attributes
  controller_error "attribute '%s' is unknown in '%s'. Valid one are : '%s'",
                   key[0], oControlerObject.class,
                   def_attributes unless def_attributes.include?(key[0])
  attributes.rh_set(value, key)
rescue => e
  controller_error "Unable to map '%s' on '%s'\n%s",
                   key, sObjectType, e.message
end

#update(sObjectType, oObject, _hParams) ⇒ Object 



420
421
422
423
424
425
426
427
428
429
430
 
# File 'lib/process/cloud/providers/hpcloud/hpcloud.rb', line 420

def update(sObjectType, oObject, _hParams)
  case sObjectType
  when :router
    controller_error 'Object to update is nil' if oObject.nil?

    HPNetwork.update_router(oObject[:object])
  else
    controller_error "'%s' is not a valid list for 'update'",
                     oFogObject.class
  end
end