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 



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

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

#attach_public_ip(vsys_id, public_ip) ⇒ Object 



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

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

#attach_vdisk(vserver_id, vdisk_id) ⇒ Object 



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

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 



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

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 



196
197
198
199
200
201
202
203
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 196

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 



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

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 



109
110
111
112
113
114
115
116
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 109

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 



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

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 



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

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

#destroy_efm(efm_id) ⇒ Object 



205
206
207
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 205

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

#destroy_vdisk(vdisk_id) ⇒ Object 



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

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 



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

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

#destroy_vserver(vserver_id) ⇒ Object 



129
130
131
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 129

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

#destroy_vsys(vsys_id) ⇒ Object 



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

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

#detach_public_ip(vsys_id, public_ip) ⇒ Object 



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

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

#detach_vdisk(vserver_id, vdisk_id) ⇒ Object 



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

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 



304
305
306
307
308
309
310
311
312
313
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 304

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



363
364
365
366
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 363

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

#extract_vsys_id(id) ⇒ Object

extract vsysId from vserverId, efmId or networkId



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

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

#free_public_ip(vsys_id, public_ip) ⇒ Object 



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

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 



213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 213

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 



209
210
211
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 209

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 



347
348
349
350
351
352
353
354
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 347

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 



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

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 



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

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 



241
242
243
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 241

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

#get_vserver_attributes(vserver_id) ⇒ Object 



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

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

#get_vserver_configuration(vserver_id) ⇒ Object 



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

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 



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

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 



133
134
135
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 133

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

#get_vsys_attributes(vsys_id) ⇒ Object 



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

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

#get_vsys_configuration(vsys_id) ⇒ Object 



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

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

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



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

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 



184
185
186
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 184

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

#list_public_ips(vsys_id = nil) ⇒ Object 



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

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 



237
238
239
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 237

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

#list_vdisk_backup(vdisk_id) ⇒ Object 



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

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

#list_vservers(vsys_id) ⇒ Object 



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

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 



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

def list_vsys_descriptor
  request('ListVSYSDescriptor')
end

#register_private_disk_image(vserver_id, name, description) ⇒ Object 



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 157

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 



282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 282

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 



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

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

#start_vserver(vserver_id) ⇒ Object 



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

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

#stop_efm(efm_id) ⇒ Object 



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

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

#stop_vserver(vserver_id, force = false) ⇒ Object 



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

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 



180
181
182
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 180

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 



225
226
227
228
229
230
231
232
233
234
235
 
# File 'lib/deltacloud/drivers/fgcp/fgcp_client.rb', line 225

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