Class: Deltacloud::Drivers::Fgcp::FgcpClient

Inherits:
Object
  • Object
show all
Defined in:
lib/deltacloud/drivers/fgcp/fgcp_client.rb

Instance Method Summary collapse

Constructor Details

#initialize(cert, key, region = nil, version = '2011-01-31', locale = 'en') ⇒ FgcpClient

Returns a new instance of FgcpClient.



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 32

def initialize(cert, key, region = nil, version = '2011-01-31', locale = 'en')
  @version = version
  @locale = locale
  if region.nil?
    cert.subject.to_s =~ /\b[Cc]=(\w\w)\b/
    region = $1.downcase
  end
  # first 'jp' region is now 'jp-east'
  region = 'jp-east' if region == 'jp'
  endpoint = Deltacloud::Drivers::driver_config[:fgcp][:entrypoints]['default'][region] || region

  #proxy settings:
  http_proxy = ENV['http_proxy']
  proxy_uri = URI.parse(http_proxy) if http_proxy

  if proxy_uri
    proxy_addr = proxy_uri.host
    proxy_port = proxy_uri.port
    proxy_user = proxy_uri.user
    proxy_pass = proxy_uri.password
  end

  @uri = URI.parse(endpoint)
  @headers = {'Accept' => 'text/xml', 'User-Agent' => 'OViSS-API-CLIENT'}

  @service = Net::HTTP::Proxy(proxy_addr, proxy_port, proxy_user, proxy_pass).new(@uri.host, @uri.port)
  @service.set_debug_output $stderr if cert.subject.to_s =~ /diesk/ # TODO: use a proper debug mode flag

  # configure client authentication
  @service.use_ssl = (@uri.scheme == 'https')
  @service.key = key
  @service.cert = cert

  # configure server authentication (peer verification)
  ca_certs = ENV['FGCP_CA_CERTS'] # e.g. '/etc/ssl/certs/ca-bundle.crt'
  @service.ca_file = ca_certs if ca_certs and File.file?(ca_certs)
  @service.ca_path = ca_certs if ca_certs and File.directory?(ca_certs)
  @service.verify_mode = (@service.ca_file or @service.ca_path) ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
end

Instance Method Details

#allocate_public_ip(vsys_id) ⇒ Object 



331
332
333
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 331

def allocate_public_ip(vsys_id)
  request('AllocatePublicIP', {'vsysId' => vsys_id})
end

#attach_public_ip(vsys_id, public_ip) ⇒ Object 



335
336
337
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 335

def attach_public_ip(vsys_id, public_ip)
  request('AttachPublicIP', {'vsysId' => vsys_id, 'publicIp' => public_ip})
end

#attach_vdisk(vserver_id, vdisk_id) ⇒ Object 



265
266
267
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 265

def attach_vdisk(vserver_id, vdisk_id)
  request('AttachVDisk', {'vsysId' => extract_vsys_id(vserver_id), 'vserverId' => vserver_id, 'vdiskId' => vdisk_id})
end

#backup_vdisk(vdisk_id) ⇒ Object 



277
278
279
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 277

def backup_vdisk(vdisk_id)
  request('BackupVDisk', {'vsysId' => extract_vsys_id(vdisk_id), 'vdiskId' => vdisk_id})
end

#create_efm(efm_type, efm_name, network_id) ⇒ Object 



204
205
206
207
208
209
210
211
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 204

def create_efm(efm_type, efm_name, network_id)
  request('CreateEFM', {
    'vsysId'    => extract_vsys_id(network_id),
    'efmType'   => efm_type,
    'efmName'   => efm_name,
    'networkId' => network_id}
  )
end

#create_vdisk(vsys_id, vdisk_name, size) ⇒ Object 



257
258
259
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 257

def create_vdisk(vsys_id, vdisk_name, size)
  request('CreateVDisk', {'vsysId' => vsys_id, 'vdiskName' => vdisk_name, 'size' => size})
end

#create_vserver(vserver_name, vserver_type, disk_image_id, network_id) ⇒ Object 



117
118
119
120
121
122
123
124
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 117

def create_vserver(vserver_name, vserver_type, disk_image_id, network_id)
  request('CreateVServer', {
    'vsysId'      => extract_vsys_id(network_id),
    'vserverName' => vserver_name,
    'vserverType' => vserver_type,
    'diskImageId' => disk_image_id,
    'networkId'   => network_id})
end

#create_vservers(vsys_id, vservers_xml) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 126

def create_vservers(vsys_id, vservers_xml)
  @version = '2012-07-20'
  request('CreateMultipleVServer',
    {
      'vsysId'    => vsys_id,
    },
    vservers_xml,
    'vserversXMLFilePath'
  )
end

#create_vsys(vsys_descriptor_id, vsys_name) ⇒ Object 



347
348
349
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 347

def create_vsys(vsys_descriptor_id, vsys_name)
  request('CreateVSYS', {'vsysDescriptorId' => vsys_descriptor_id, 'vsysName' => vsys_name})
end

#destroy_efm(efm_id) ⇒ Object 



213
214
215
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 213

def destroy_efm(efm_id)
  request('DestroyEFM', {'vsysId' => extract_vsys_id(efm_id), 'efmId' => efm_id})
end

#destroy_vdisk(vdisk_id) ⇒ Object 



261
262
263
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 261

def destroy_vdisk(vdisk_id)
  request('DestroyVDisk', {'vsysId' => extract_vsys_id(vdisk_id), 'vdiskId' => vdisk_id})
end

#destroy_vdisk_backup(vsys_id, backup_id) ⇒ Object 



281
282
283
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 281

def destroy_vdisk_backup(vsys_id, backup_id)
  request('DestroyVDiskBackup', {'vsysId' => vsys_id, 'backupId' => backup_id})
end

#destroy_vserver(vserver_id) ⇒ Object 



137
138
139
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 137

def destroy_vserver(vserver_id)
  request('DestroyVServer', {'vsysId' => extract_vsys_id(vserver_id), 'vserverId' => vserver_id})
end

#destroy_vsys(vsys_id) ⇒ Object 



351
352
353
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 351

def destroy_vsys(vsys_id)
  request('DestroyVSYS', {'vsysId' => vsys_id})
end

#detach_public_ip(vsys_id, public_ip) ⇒ Object 



339
340
341
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 339

def detach_public_ip(vsys_id, public_ip)
  request('DetachPublicIP', {'vsysId' => vsys_id, 'publicIp' => public_ip})
end

#detach_vdisk(vserver_id, vdisk_id) ⇒ Object 



269
270
271
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 269

def detach_vdisk(vserver_id, vdisk_id)
  request('DetachVDisk', {'vsysId' => extract_vsys_id(vserver_id), 'vserverId' => vserver_id, 'vdiskId' => vdisk_id})
end

#external_restore_vdisk(src_vsys_id, src_backup_id, dst_vsys_id, dst_vdisk_id, key) ⇒ Object 



312
313
314
315
316
317
318
319
320
321
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 312

def external_restore_vdisk(src_vsys_id, src_backup_id, dst_vsys_id, dst_vdisk_id, key)
  @version = '2012-07-20'
  request('ExternalRestoreVDisk', {
    'srcVsysId'   => src_vsys_id,
    'srcBackupId' => src_backup_id,
    'dstVsysId'   => dst_vsys_id,
    'dstVdiskId'  => dst_vdisk_id,
    'key'         => key}
  )
end

#extract_contract_id(id) ⇒ Object

extract contract id from vserverId, efmId or networkId



371
372
373
374
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 371

def extract_contract_id(id)
  /^(\w+)-\w+\b.*/ =~ id
  $1
end

#extract_vsys_id(id) ⇒ Object

extract vsysId from vserverId, efmId or networkId



365
366
367
368
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 365

def extract_vsys_id(id)
  /^(\w+-\w+)\b.*/ =~ id
  $1
end

#free_public_ip(vsys_id, public_ip) ⇒ Object 



343
344
345
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 343

def free_public_ip(vsys_id, public_ip)
  request('FreePublicIP', {'vsysId' => vsys_id, 'publicIp' => public_ip})
end

#get_efm_configuration(efm_id, configuration_name, configuration_xml = nil) ⇒ Object 



221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 221

def get_efm_configuration(efm_id, configuration_name, configuration_xml=nil)
  request('GetEFMConfiguration',
    {
      'vsysId'            => extract_vsys_id(efm_id),
      'efmId'             => efm_id,
      'configurationName' => configuration_name
    },
    configuration_xml,
    'configurationXMLFilePath'
  )
end

#get_efm_status(efm_id) ⇒ Object 



217
218
219
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 217

def get_efm_status(efm_id)
  request('GetEFMStatus', {'vsysId' => extract_vsys_id(efm_id), 'efmId' => efm_id})
end

#get_performance_information(vserver_id, interval, data_type = nil) ⇒ Object 



355
356
357
358
359
360
361
362
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 355

def get_performance_information(vserver_id, interval, data_type=nil)
  @version = '2012-02-18'
  if data_type.nil?
    request('GetPerformanceInformation', {'vsysId' => extract_vsys_id(vserver_id), 'serverId' => vserver_id, 'interval' => interval})
  else
    request('GetPerformanceInformation', {'vsysId' => extract_vsys_id(vserver_id), 'serverId' => vserver_id, 'dataType' => data_type, 'interval' => interval})
  end
end

#get_vdisk_attributes(vdisk_id) ⇒ Object 



253
254
255
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 253

def get_vdisk_attributes(vdisk_id)
  request('GetVDiskAttributes', {'vsysId' => extract_vsys_id(vdisk_id), 'vdiskId' => vdisk_id})
end

#get_vdisk_backup_copy_key(vsys_id, backup_id) ⇒ Object 



285
286
287
288
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 285

def get_vdisk_backup_copy_key(vsys_id, backup_id)
  @version = '2012-07-20'
  request('GetVDiskBackupCopyKey', {'vsysId' => vsys_id, 'backupId' => backup_id})
end

#get_vdisk_status(vdisk_id) ⇒ Object 



249
250
251
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 249

def get_vdisk_status(vdisk_id)
  request('GetVDiskStatus', {'vsysId' => extract_vsys_id(vdisk_id), 'vdiskId' => vdisk_id})
end

#get_vserver_attributes(vserver_id) ⇒ Object 



149
150
151
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 149

def get_vserver_attributes(vserver_id)
  request('GetVServerAttributes', {'vsysId' => extract_vsys_id(vserver_id), 'vserverId' => vserver_id})
end

#get_vserver_configuration(vserver_id) ⇒ Object 



153
154
155
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 153

def get_vserver_configuration(vserver_id)
  request('GetVServerConfiguration', {'vsysId' => extract_vsys_id(vserver_id), 'vserverId' => vserver_id})
end

#get_vserver_initial_password(vserver_id) ⇒ Object 



145
146
147
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 145

def get_vserver_initial_password(vserver_id)
  request('GetVServerInitialPassword', {'vsysId' => extract_vsys_id(vserver_id), 'vserverId' => vserver_id})
end

#get_vserver_status(vserver_id) ⇒ Object 



141
142
143
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 141

def get_vserver_status(vserver_id)
  request('GetVServerStatus', {'vsysId' => extract_vsys_id(vserver_id), 'vserverId' => vserver_id})
end

#get_vsys_attributes(vsys_id) ⇒ Object 



89
90
91
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 89

def get_vsys_attributes(vsys_id)
  request('GetVSYSAttributes', {'vsysId' => vsys_id})
end

#get_vsys_configuration(vsys_id) ⇒ Object 



93
94
95
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 93

def get_vsys_configuration(vsys_id)
  request('GetVSYSConfiguration', {'vsysId' => vsys_id})
end

#get_vsys_descriptor_configuration(vsys_descriptor_id) ⇒ Object 



101
102
103
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 101

def get_vsys_descriptor_configuration(vsys_descriptor_id)
  request('GetVSYSDescriptorConfiguration', {'vsysDescriptorId' => vsys_descriptor_id})
end

#get_vsys_status(vsys_id) ⇒ Object 



85
86
87
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 85

def get_vsys_status(vsys_id)
  request('GetVSYSStatus', {'vsysId' => vsys_id})
end

#list_disk_images(server_category = nil, vsys_descriptor_id = nil) ⇒ Object 



157
158
159
160
161
162
163
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 157

def list_disk_images(server_category=nil, vsys_descriptor_id=nil)
  params = {}
  params.merge! 'serverCategory' => server_category if server_category
  params.merge! 'vsysDescriptorId' => vsys_descriptor_id if vsys_descriptor_id

  request('ListDiskImage', params)
end

#list_efm(vsys_id, efm_type) ⇒ Object 



192
193
194
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 192

def list_efm(vsys_id, efm_type)
  request('ListEFM', {'vsysId' => vsys_id, 'efmType' => efm_type})
end

#list_public_ips(vsys_id = nil) ⇒ Object 



323
324
325
326
327
328
329
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 323

def list_public_ips(vsys_id=nil)
  if vsys_id.nil?
    request('ListPublicIP')
  else
    request('ListPublicIP', {'vsysId' => vsys_id})
  end
end

#list_server_types ⇒ Object

API methods



76
77
78
79
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 76

def list_server_types
  #diskImageId is mandatory but value seems to be ignored
  request('ListServerType', {'diskImageId' => 'dummy'})
end

#list_vdisk(vsys_id) ⇒ Object 



245
246
247
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 245

def list_vdisk(vsys_id)
  request('ListVDisk', {'vsysId' => vsys_id})
end

#list_vdisk_backup(vdisk_id) ⇒ Object 



273
274
275
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 273

def list_vdisk_backup(vdisk_id)
  request('ListVDiskBackup', {'vsysId' => extract_vsys_id(vdisk_id), 'vdiskId' => vdisk_id})
end

#list_vservers(vsys_id) ⇒ Object 



105
106
107
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 105

def list_vservers(vsys_id)
  request('ListVServer', {'vsysId' => vsys_id})
end

#list_vsys ⇒ Object 



81
82
83
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 81

def list_vsys
  request('ListVSYS')
end

#list_vsys_descriptor ⇒ Object 



97
98
99
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 97

def list_vsys_descriptor
  request('ListVSYSDescriptor')
end

#register_private_disk_image(vserver_id, name, description) ⇒ Object 



165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 165

def register_private_disk_image(vserver_id, name, description)
  #TODO: support different attributes for different locales?
  image_descriptor = <<-"eoidxml"
<?xml version="1.0" encoding ="UTF-8"?>
<Request>
<vserverId>#{vserver_id}</vserverId>
<locales>
  <locale>
    <lcid>en</lcid>
    <name>#{name}</name>
    <description>#{description}</description>
  </locale>
  <locale>
    <lcid>ja</lcid>
    <name>#{name}</name>
    <description>#{description}</description>
  </locale>
</locales>
</Request>
eoidxml
  request('RegisterPrivateDiskImage', nil, image_descriptor, 'diskImageXMLFilePath')
end

#set_vdisk_backup_copy_key(vsys_id, backup_id, contracts) ⇒ Object 



290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 290

def set_vdisk_backup_copy_key(vsys_id, backup_id, contracts)
  @version = '2012-07-20'
  contracts_xml = <<-"eoctxml"
<?xml version="1.0" encoding ="UTF-8"?>
<Request>
<contracts>
  <contract>
#{contracts.collect { |c| "      <number>#{c}</number>" }.join("\n")}
  </contract>
</contracts>
</Request>
eoctxml
  request('SetVDiskBackupCopyKey',
    {
      'vsysId'   => vsys_id,
      'backupId' => backup_id
    },
    contracts_xml,
    'contractsXMLFilePath'
  )
end

#start_efm(efm_id) ⇒ Object 



196
197
198
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 196

def start_efm(efm_id)
  request('StartEFM', {'vsysId' => extract_vsys_id(efm_id), 'efmId' => efm_id})
end

#start_vserver(vserver_id) ⇒ Object 



109
110
111
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 109

def start_vserver(vserver_id)
  request('StartVServer', {'vsysId' => extract_vsys_id(vserver_id), 'vserverId' => vserver_id})
end

#stop_efm(efm_id) ⇒ Object 



200
201
202
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 200

def stop_efm(efm_id)
  request('StopEFM', {'vsysId' => extract_vsys_id(efm_id), 'efmId' => efm_id})
end

#stop_vserver(vserver_id, force = false) ⇒ Object 



113
114
115
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 113

def stop_vserver(vserver_id, force=false)
  request('StopVServer', {'vsysId' => extract_vsys_id(vserver_id), 'vserverId' => vserver_id, 'force' => force})
end

#unregister_disk_image(disk_image_id) ⇒ Object 



188
189
190
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 188

def unregister_disk_image(disk_image_id)
  request('UnregisterDiskImage', {'diskImageId' => disk_image_id})
end

#update_efm_configuration(efm_id, configuration_name, configuration_xml = nil) ⇒ Object 



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

def update_efm_configuration(efm_id, configuration_name, configuration_xml=nil)
  request('UpdateEFMConfiguration',
    {
      'vsysId'            => extract_vsys_id(efm_id),
      'efmId'             => efm_id,
      'configurationName' => configuration_name
    },
    configuration_xml,
    'configurationXMLFilePath'
  )
end