Class: VimService

Inherits:
Handsoap::Service
  • Object
show all
Includes:
VMwareWebService::Logging
Defined in:
lib/VMwareWebService/VimService.rb

Direct Known Subclasses

MiqVimClientBase

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from VMwareWebService::Logging

#logger

Constructor Details

#initialize(ep) ⇒ VimService

Returns a new instance of VimService.



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/VMwareWebService/VimService.rb', line 13

def initialize(ep)
  super

  setNameSpace('urn:vim25')

  @serviceInstanceMor = VimString.new("ServiceInstance", "ServiceInstance")
  @session_cookie     = nil

  @xml_payload_len  = 0
  @xml_payload_max  = 10.megabytes
  @xml_payload_lock = Mutex.new

  @sic = retrieveServiceContent

  @about           = @sic.about
  @apiVersion      = @about.apiVersion
  @v20             = @apiVersion =~ /2\.0\..*/
  @v2              = @apiVersion =~ /2\..*/
  @v4              = @apiVersion =~ /4\..*/
  @v5              = @apiVersion =~ /5\..*/
  @v6              = @apiVersion =~ /6\..*/
  @isVirtualCenter = @about.apiType == "VirtualCenter"
end

Instance Attribute Details

#about ⇒ Object (readonly)

Returns the value of attribute about.



9
10
11
 
# File 'lib/VMwareWebService/VimService.rb', line 9

def about
  @about
end

#apiVersion ⇒ Object (readonly)

Returns the value of attribute apiVersion.



9
10
11
 
# File 'lib/VMwareWebService/VimService.rb', line 9

def apiVersion
  @apiVersion
end

#isVirtualCenter ⇒ Object (readonly)

Returns the value of attribute isVirtualCenter.



9
10
11
 
# File 'lib/VMwareWebService/VimService.rb', line 9

def isVirtualCenter
  @isVirtualCenter
end

#serviceInstanceMor ⇒ Object (readonly)

Returns the value of attribute serviceInstanceMor.



9
10
11
 
# File 'lib/VMwareWebService/VimService.rb', line 9

def serviceInstanceMor
  @serviceInstanceMor
end

#session_cookie ⇒ Object (readonly)

Returns the value of attribute session_cookie.



9
10
11
 
# File 'lib/VMwareWebService/VimService.rb', line 9

def session_cookie
  @session_cookie
end

#sic ⇒ Object (readonly)

Returns the value of attribute sic.



9
10
11
 
# File 'lib/VMwareWebService/VimService.rb', line 9

def sic
  @sic
end

#v2 ⇒ Object (readonly)

Returns the value of attribute v2.



9
10
11
 
# File 'lib/VMwareWebService/VimService.rb', line 9

def v2
  @v2
end

#v20 ⇒ Object (readonly)

Returns the value of attribute v20.



9
10
11
 
# File 'lib/VMwareWebService/VimService.rb', line 9

def v20
  @v20
end

#v4 ⇒ Object (readonly)

Returns the value of attribute v4.



9
10
11
 
# File 'lib/VMwareWebService/VimService.rb', line 9

def v4
  @v4
end

#v5 ⇒ Object (readonly)

Returns the value of attribute v5.



9
10
11
 
# File 'lib/VMwareWebService/VimService.rb', line 9

def v5
  @v5
end

#v6 ⇒ Object (readonly)

Returns the value of attribute v6.



9
10
11
 
# File 'lib/VMwareWebService/VimService.rb', line 9

def v6
  @v6
end

Instance Method Details

#acquireCloneTicket(sm) ⇒ Object 



37
38
39
40
41
42
43
44
 
# File 'lib/VMwareWebService/VimService.rb', line 37

def acquireCloneTicket(sm)
  response = invoke("n1:AcquireCloneTicket") do |message|
    message.add "n1:_this", sm do |i|
      i.set_attr "type", sm.vimType
    end
  end
  (parse_response(response, 'AcquireCloneTicketResponse')['returnval'])
end

#acquireMksTicket(mor) ⇒ Object 



46
47
48
49
50
51
52
53
 
# File 'lib/VMwareWebService/VimService.rb', line 46

def acquireMksTicket(mor)
  response = invoke("n1:AcquireMksTicket") do |message|
    message.add "n1:_this", mor do |i|
      i.set_attr "type", mor.vimType
    end
  end
  (parse_response(response, 'AcquireMksTicketResponse')['returnval'])
end

#acquireTicket(mor, ticketType) ⇒ Object 



55
56
57
58
59
60
61
62
63
 
# File 'lib/VMwareWebService/VimService.rb', line 55

def acquireTicket(mor, ticketType)
  response = invoke("n1:AcquireTicket") do |message|
    message.add "n1:_this", mor do |i|
      i.set_attr "type", mor.vimType
    end
    message.add "n1:ticketType", ticketType
  end
  (parse_response(response, 'AcquireTicketResponse')['returnval'])
end

#addHost_Task(clustMor, spec, asConnected, resourcePool = nil, license = nil) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/VMwareWebService/VimService.rb', line 65

def addHost_Task(clustMor, spec, asConnected, resourcePool = nil, license = nil)
  response = invoke("n1:AddHost_Task") do |message|
    message.add "n1:_this", clustMor do |i|
      i.set_attr "type", clustMor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", spec.xsiType
      marshalObj(i, spec)
    end
    message.add "n1:asConnected", asConnected
    message.add "n1:resourcePool", resourcePool do |i|
      i.set_attr "type", resourcePool.vimType
    end unless resourcePool.nil?
    message.add "n1:license", license unless license.nil?
  end
  (parse_response(response, 'AddHost_TaskResponse')['returnval'])
end

#addInternetScsiSendTargets(hssMor, iScsiHbaDevice, targets) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/VMwareWebService/VimService.rb', line 83

def addInternetScsiSendTargets(hssMor, iScsiHbaDevice, targets)
  response = invoke("n1:AddInternetScsiSendTargets") do |message|
    message.add "n1:_this", hssMor do |i|
      i.set_attr "type", hssMor.vimType
    end
    message.add "n1:iScsiHbaDevice", iScsiHbaDevice
    if targets.kind_of?(Array)
      targets.each do |t|
        message.add "n1:targets" do |i|
          i.set_attr "xsi:type", t.xsiType
          marshalObj(i, t)
        end
      end
    else
      message.add "n1:targets" do |i|
        i.set_attr "xsi:type", targets.xsiType
        marshalObj(i, targets)
      end
    end
  end
  (parse_response(response, 'AddInternetScsiSendTargetsResponse'))
end

#addInternetScsiStaticTargets(hssMor, iScsiHbaDevice, targets) ⇒ Object 



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/VMwareWebService/VimService.rb', line 106

def addInternetScsiStaticTargets(hssMor, iScsiHbaDevice, targets)
  response = invoke("n1:AddInternetScsiStaticTargets") do |message|
    message.add "n1:_this", hssMor do |i|
      i.set_attr "type", hssMor.vimType
    end
    message.add "n1:iScsiHbaDevice", iScsiHbaDevice
    if targets.kind_of?(Array)
      targets.each do |t|
        message.add "n1:targets" do |i|
          i.set_attr "xsi:type", t.xsiType
          marshalObj(i, t)
        end
      end
    else
      message.add "n1:targets" do |i|
        i.set_attr "xsi:type", targets.xsiType
        marshalObj(i, targets)
      end
    end
  end
  (parse_response(response, 'AddInternetScsiStaticTargetsResponse'))
end

#addStandaloneHost_Task(folderMor, spec, addConnected, license = nil) ⇒ Object 



129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/VMwareWebService/VimService.rb', line 129

def addStandaloneHost_Task(folderMor, spec, addConnected, license = nil)
  response = invoke("n1:AddStandaloneHost_Task") do |message|
    message.add "n1:_this", folderMor do |i|
      i.set_attr "type", folderMor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", spec.xsiType
      marshalObj(i, spec)
    end
    message.add "n1:addConnected", addConnected
    message.add "n1:license", license unless license.nil?
  end
  (parse_response(response, 'AddStandaloneHost_TaskResponse')['returnval'])
end

#browseDiagnosticLog(diagnosticManager, host, key, start, lines) ⇒ Object 



144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/VMwareWebService/VimService.rb', line 144

def browseDiagnosticLog(diagnosticManager, host, key, start, lines)
  response = invoke("n1:BrowseDiagnosticLog") do |message|
    message.add "n1:_this", diagnosticManager do |i|
      i.set_attr "type", diagnosticManager.vimType
    end
    message.add "n1:host", host do |i|
      i.set_attr "type", host.vimType
    end if host
    message.add "n1:key", key
    message.add "n1:start", start if start
    message.add "n1:lines", lines if lines
  end
  (parse_response(response, 'BrowseDiagnosticLogResponse')['returnval'])
end

#cancelTask(tmor) ⇒ Object 



159
160
161
162
163
164
165
166
 
# File 'lib/VMwareWebService/VimService.rb', line 159

def cancelTask(tmor)
  response = invoke("n1:CancelTask") do |message|
    message.add "n1:_this", tmor do |i|
      i.set_attr "type", tmor.vimType
    end
  end
  (parse_response(response, 'CancelTaskResponse'))
end

#cancelWaitForUpdates(propCol) ⇒ Object 



168
169
170
171
172
173
174
175
 
# File 'lib/VMwareWebService/VimService.rb', line 168

def cancelWaitForUpdates(propCol)
  response = invoke("n1:CancelWaitForUpdates") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end
  end
  (parse_response(response, 'CancelWaitForUpdatesResponse'))
end

#cloneVM_Task(vmMor, fmor, name, cspec) ⇒ Object 



177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/VMwareWebService/VimService.rb', line 177

def cloneVM_Task(vmMor, fmor, name, cspec)
  response = invoke("n1:CloneVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
    message.add "n1:folder", fmor do |i|
      i.set_attr "type", fmor.vimType
    end
    message.add "n1:name", name
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", cspec.xsiType
      marshalObj(i, cspec)
    end
  end
  (parse_response(response, 'CloneVM_TaskResponse')['returnval'])
end

#continueRetrievePropertiesEx(propCol, token) ⇒ Object 



194
195
196
197
198
199
200
201
202
 
# File 'lib/VMwareWebService/VimService.rb', line 194

def continueRetrievePropertiesEx(propCol, token)
  response = invoke("n1:ContinueRetrievePropertiesEx") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end
    message.add "n1:token", token
  end
  (parse_response(response, 'ContinueRetrievePropertiesExResponse')['returnval'])
end

#createAlarm(alarmManager, mor, aSpec) ⇒ Object 



204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/VMwareWebService/VimService.rb', line 204

def createAlarm(alarmManager, mor, aSpec)
  response = invoke("n1:CreateAlarm") do |message|
    message.add "n1:_this", alarmManager do |i|
      i.set_attr "type", alarmManager.vimType
    end
    message.add "n1:entity", mor do |i|
      i.set_attr "type", mor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", aSpec.xsiType
      marshalObj(i, aSpec)
    end
  end
  (parse_response(response, 'CreateAlarmResponse')['returnval'])
end

#createCollectorForEvents(eventManager, eventFilterSpec) ⇒ Object 



220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/VMwareWebService/VimService.rb', line 220

def createCollectorForEvents(eventManager, eventFilterSpec)
  response = invoke("n1:CreateCollectorForEvents") do |message|
    message.add "n1:_this", eventManager do |i|
      i.set_attr "type", eventManager.vimType
    end
    message.add "n1:filter" do |i|
      i.set_attr "xsi:type", eventFilterSpec.xsiType
      marshalObj(i, eventFilterSpec)
    end
  end
  (parse_response(response, 'CreateCollectorForEventsResponse')['returnval'])
end

#createCustomizationSpec(csmMor, item) ⇒ Object 



233
234
235
236
237
238
239
240
241
242
243
244
 
# File 'lib/VMwareWebService/VimService.rb', line 233

def createCustomizationSpec(csmMor, item)
  response = invoke("n1:CreateCustomizationSpec") do |message|
    message.add "n1:_this", csmMor do |i|
      i.set_attr "type", csmMor.vimType
    end
    message.add "n1:item" do |i|
      i.set_attr "xsi:type", item.xsiType
      marshalObj(i, item)
    end
  end
  (parse_response(response, 'CreateCustomizationSpecResponse')['returnval'])
end

#createFilter(propCol, pfSpec, partialUpdates) ⇒ Object 



246
247
248
249
250
251
252
253
254
255
256
257
258
 
# File 'lib/VMwareWebService/VimService.rb', line 246

def createFilter(propCol, pfSpec, partialUpdates)
  response = invoke("n1:CreateFilter") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", pfSpec.xsiType
      marshalObj(i, pfSpec)
    end
    message.add "n1:partialUpdates", partialUpdates
  end
  (parse_response(response, 'CreateFilterResponse')['returnval'])
end

#createFolder(pfMor, fname) ⇒ Object 



260
261
262
263
264
265
266
267
268
 
# File 'lib/VMwareWebService/VimService.rb', line 260

def createFolder(pfMor, fname)
  response = invoke("n1:CreateFolder") do |message|
    message.add "n1:_this", pfMor do |i|
      i.set_attr "type", pfMor.vimType
    end
    message.add "n1:name", fname
  end
  (parse_response(response, 'CreateFolderResponse')['returnval'])
end

#createNasDatastore(dssMor, spec) ⇒ Object 



270
271
272
273
274
275
276
277
278
279
280
281
 
# File 'lib/VMwareWebService/VimService.rb', line 270

def createNasDatastore(dssMor, spec)
  response = invoke("n1:CreateNasDatastore") do |message|
    message.add "n1:_this", dssMor do |i|
      i.set_attr "type", dssMor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", spec.xsiType
      marshalObj(i, spec)
    end
  end
  (parse_response(response, 'CreateNasDatastoreResponse')['returnval'])
end

#createSnapshot_Task(vmMor, name, desc, memory, quiesce) ⇒ Object 



283
284
285
286
287
288
289
290
291
292
293
294
 
# File 'lib/VMwareWebService/VimService.rb', line 283

def createSnapshot_Task(vmMor, name, desc, memory, quiesce)
  response = invoke("n1:CreateSnapshot_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
    message.add "n1:name", name
    message.add "n1:description", desc  if desc
    message.add "n1:memory", memory.to_s
    message.add "n1:quiesce", quiesce
  end
  (parse_response(response, 'CreateSnapshot_TaskResponse')['returnval'])
end

#createVM_Task(fMor, vmcs, pool, hMor) ⇒ Object 



296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
 
# File 'lib/VMwareWebService/VimService.rb', line 296

def createVM_Task(fMor, vmcs, pool, hMor)
  response = invoke("n1:CreateVM_Task") do |message|
    message.add "n1:_this", fMor do |i|
      i.set_attr "type", fMor.vimType
    end
    message.add "n1:config" do |i|
      i.set_attr "xsi:type", vmcs.xsiType
      marshalObj(i, vmcs)
    end
    message.add "n1:pool", pool do |i|
      i.set_attr "type", "ResourcePool"
    end
    # hMor is not mandatory since it's ok to miss it for DRS clusters or single host clusters
    unless hMor.nil?
      message.add "n1:host", hMor do |i|
        i.set_attr "type", hMor.vimType
      end
    end
  end
  parse_response(response, 'CreateVM_TaskResponse')['returnval']
end

#currentTime ⇒ Object 



318
319
320
321
322
323
324
325
 
# File 'lib/VMwareWebService/VimService.rb', line 318

def currentTime
  response = invoke("n1:CurrentTime") do |message|
    message.add "n1:_this", "ServiceInstance" do |i|
      i.set_attr "type", "ServiceInstance"
    end
  end
  (parse_response(response, 'CurrentTimeResponse')['returnval'])
end

#customizationSpecItemToXml(csmMor, item) ⇒ Object 



327
328
329
330
331
332
333
334
335
336
337
338
 
# File 'lib/VMwareWebService/VimService.rb', line 327

def customizationSpecItemToXml(csmMor, item)
  response = invoke("n1:CustomizationSpecItemToXml") do |message|
    message.add "n1:_this", csmMor do |i|
      i.set_attr "type", csmMor.vimType
    end
    message.add "n1:item" do |i|
      i.set_attr "xsi:type", item.xsiType
      marshalObj(i, item)
    end
  end
  (parse_response(response, 'CustomizationSpecItemToXmlResponse')['returnval'])
end

#deleteCustomizationSpec(csmMor, name) ⇒ Object 



340
341
342
343
344
345
346
347
348
 
# File 'lib/VMwareWebService/VimService.rb', line 340

def deleteCustomizationSpec(csmMor, name)
  response = invoke("n1:DeleteCustomizationSpec") do |message|
    message.add "n1:_this", csmMor do |i|
      i.set_attr "type", csmMor.vimType
    end
    message.add "n1:name", name
  end
  (parse_response(response, 'DeleteCustomizationSpecResponse'))['returnval']
end

#deselectVnicForNicType(vnmMor, nicType, device) ⇒ Object 



350
351
352
353
354
355
356
357
358
359
 
# File 'lib/VMwareWebService/VimService.rb', line 350

def deselectVnicForNicType(vnmMor, nicType, device)
  response = invoke("n1:DeselectVnicForNicType") do |message|
    message.add "n1:_this", vnmMor do |i|
      i.set_attr "type", vnmMor.vimType
    end
    message.add "n1:nicType", nicType
    message.add "n1:device", device
  end
  (parse_response(response, 'DeselectVnicForNicTypeResponse'))
end

#destroy_Task(mor) ⇒ Object 



361
362
363
364
365
366
367
368
 
# File 'lib/VMwareWebService/VimService.rb', line 361

def destroy_Task(mor)
  response = invoke("n1:Destroy_Task") do |message|
    message.add "n1:_this", mor do |i|
      i.set_attr "type", mor.vimType
    end
  end
  (parse_response(response, 'Destroy_TaskResponse')['returnval'])
end

#destroyCollector(collectorMor) ⇒ Object 



370
371
372
373
374
375
376
377
 
# File 'lib/VMwareWebService/VimService.rb', line 370

def destroyCollector(collectorMor)
  response = invoke("n1:DestroyCollector") do |message|
    message.add "n1:_this", collectorMor do |i|
      i.set_attr "type", collectorMor.vimType
    end
  end
  (parse_response(response, 'DestroyCollectorResponse'))
end

#destroyPropertyFilter(filterSpecRef) ⇒ Object 



379
380
381
382
383
384
385
386
 
# File 'lib/VMwareWebService/VimService.rb', line 379

def destroyPropertyFilter(filterSpecRef)
  response = invoke("n1:DestroyPropertyFilter") do |message|
    message.add "n1:_this", filterSpecRef do |i|
      i.set_attr "type", filterSpecRef.vimType
    end
  end
  (parse_response(response, 'DestroyPropertyFilterResponse'))
end

#disableRuleset(fwsMor, rskey) ⇒ Object 



388
389
390
391
392
393
394
395
396
 
# File 'lib/VMwareWebService/VimService.rb', line 388

def disableRuleset(fwsMor, rskey)
  response = invoke("n1:DisableRuleset") do |message|
    message.add "n1:_this", fwsMor do |i|
      i.set_attr "type", fwsMor.vimType
    end
    message.add "n1:id", rskey
  end
  (parse_response(response, 'DisableRulesetResponse'))
end

#doesCustomizationSpecExist(csmMor, name) ⇒ Object 



398
399
400
401
402
403
404
405
406
 
# File 'lib/VMwareWebService/VimService.rb', line 398

def doesCustomizationSpecExist(csmMor, name)
  response = invoke("n1:DoesCustomizationSpecExist") do |message|
    message.add "n1:_this", csmMor do |i|
      i.set_attr "type", csmMor.vimType
    end
    message.add "n1:name", name
  end
  (parse_response(response, 'DoesCustomizationSpecExistResponse'))['returnval']
end

#enableRuleset(fwsMor, rskey) ⇒ Object 



408
409
410
411
412
413
414
415
416
 
# File 'lib/VMwareWebService/VimService.rb', line 408

def enableRuleset(fwsMor, rskey)
  response = invoke("n1:EnableRuleset") do |message|
    message.add "n1:_this", fwsMor do |i|
      i.set_attr "type", fwsMor.vimType
    end
    message.add "n1:id", rskey
  end
  (parse_response(response, 'EnableRulesetResponse'))
end

#enterMaintenanceMode_Task(hMor, timeout = 0, evacuatePoweredOffVms = false) ⇒ Object 



418
419
420
421
422
423
424
425
426
427
 
# File 'lib/VMwareWebService/VimService.rb', line 418

def enterMaintenanceMode_Task(hMor, timeout = 0, evacuatePoweredOffVms = false)
  response = invoke("n1:EnterMaintenanceMode_Task") do |message|
    message.add "n1:_this", hMor do |i|
      i.set_attr "type", hMor.vimType
    end
    message.add "n1:timeout", timeout.to_s
    message.add "n1:evacuatePoweredOffVms", evacuatePoweredOffVms.to_s
  end
  (parse_response(response, 'EnterMaintenanceMode_TaskResponse'))['returnval']
end

#exitMaintenanceMode_Task(hMor, timeout = 0) ⇒ Object 



429
430
431
432
433
434
435
436
437
 
# File 'lib/VMwareWebService/VimService.rb', line 429

def exitMaintenanceMode_Task(hMor, timeout = 0)
  response = invoke("n1:ExitMaintenanceMode_Task") do |message|
    message.add "n1:_this", hMor do |i|
      i.set_attr "type", hMor.vimType
    end
    message.add "n1:timeout", timeout.to_s
  end
  (parse_response(response, 'ExitMaintenanceMode_TaskResponse'))['returnval']
end

#getAlarm(alarmManager, mor) ⇒ Object 



439
440
441
442
443
444
445
446
447
448
449
 
# File 'lib/VMwareWebService/VimService.rb', line 439

def getAlarm(alarmManager, mor)
  response = invoke("n1:GetAlarm") do |message|
    message.add "n1:_this", alarmManager do |i|
      i.set_attr "type", alarmManager.vimType
    end
    message.add "n1:entity", mor do |i|
      i.set_attr "type", mor.vimType
    end if mor
  end
  (parse_response(response, 'GetAlarmResponse')['returnval'])
end

#getCustomizationSpec(csmMor, name) ⇒ Object 



451
452
453
454
455
456
457
458
459
 
# File 'lib/VMwareWebService/VimService.rb', line 451

def getCustomizationSpec(csmMor, name)
  response = invoke("n1:GetCustomizationSpec") do |message|
    message.add "n1:_this", csmMor do |i|
      i.set_attr "type", csmMor.vimType
    end
    message.add "n1:name", name
  end
  (parse_response(response, 'GetCustomizationSpecResponse'))['returnval']
end

#login(sessionManager, username, password) ⇒ Object 



461
462
463
464
465
466
467
468
469
470
471
 
# File 'lib/VMwareWebService/VimService.rb', line 461

def (sessionManager, username, password)
  response = invoke("n1:Login") do |message|
    message.add "n1:_this", sessionManager do |i|
      i.set_attr "type", "SessionManager"
    end
    message.add "n1:userName", username
    message.add "n1:password", password
  end
  @session_cookie ||= response.cookie
  (parse_response(response, 'LoginResponse')['returnval'])
end

#logout(sessionManager) ⇒ Object 



473
474
475
476
477
478
479
480
 
# File 'lib/VMwareWebService/VimService.rb', line 473

def logout(sessionManager)
  response = invoke("n1:Logout") do |message|
    message.add "n1:_this", sessionManager do |i|
      i.set_attr "type", "SessionManager"
    end
  end
  (parse_response(response, 'LogoutResponse'))
end

#logUserEvent(eventManager, entity, msg) ⇒ Object 



482
483
484
485
486
487
488
489
490
491
492
493
 
# File 'lib/VMwareWebService/VimService.rb', line 482

def logUserEvent(eventManager, entity, msg)
  response = invoke("n1:LogUserEvent") do |message|
    message.add "n1:_this", eventManager do |i|
      i.set_attr "type", eventManager.vimType
    end
    message.add "n1:entity", entity do |i|
      i.set_attr "type", entity.vimType
    end
    message.add "n1:msg", msg
  end
  (parse_response(response, 'LogUserEventResponse'))
end

#markAsTemplate(vmMor) ⇒ Object 



495
496
497
498
499
500
501
502
 
# File 'lib/VMwareWebService/VimService.rb', line 495

def markAsTemplate(vmMor)
  response = invoke("n1:MarkAsTemplate") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'MarkAsTemplateResponse'))
end

#markAsVirtualMachine(vmMor, pmor, hmor = nil) ⇒ Object 



504
505
506
507
508
509
510
511
512
513
514
515
516
517
 
# File 'lib/VMwareWebService/VimService.rb', line 504

def markAsVirtualMachine(vmMor, pmor, hmor = nil)
  response = invoke("n1:MarkAsVirtualMachine") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
    message.add "n1:pool", pmor do |i|
      i.set_attr "type", pmor.vimType
    end
    message.add "n1:host", hmor do |i|
      i.set_attr "type", hmor.vimType
    end if hmor
  end
  (parse_response(response, 'MarkAsVirtualMachineResponse'))
end

#migrateVM_Task(vmMor, pmor = nil, hmor = nil, priority = "defaultPriority", state = nil) ⇒ Object 



519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
 
# File 'lib/VMwareWebService/VimService.rb', line 519

def migrateVM_Task(vmMor, pmor = nil, hmor = nil, priority = "defaultPriority", state = nil)
  response = invoke("n1:MigrateVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
    message.add "n1:pool", pmor do |i|
      i.set_attr "type", pmor.vimType
    end if pmor
    message.add "n1:host", hmor do |i|
      i.set_attr "type", hmor.vimType
    end if hmor
    message.add "n1:priority", priority
    message.add "n1:state", state if state
  end
  (parse_response(response, 'MigrateVM_TaskResponse')['returnval'])
end

#moveIntoFolder_Task(fMor, oMor) ⇒ Object 



536
537
538
539
540
541
542
543
544
545
546
 
# File 'lib/VMwareWebService/VimService.rb', line 536

def moveIntoFolder_Task(fMor, oMor)
  response = invoke("n1:MoveIntoFolder_Task") do |message|
    message.add "n1:_this", fMor do |i|
      i.set_attr "type", fMor.vimType
    end
    message.add "n1:list", oMor do |i|
      i.set_attr "type", oMor.vimType
    end
  end
  parse_response(response, 'MoveIntoFolder_TaskResponse')['returnval']
end

#powerDownHostToStandBy_Task(hMor, timeoutSec = 0, evacuatePoweredOffVms = false) ⇒ Object 



562
563
564
565
566
567
568
569
570
571
 
# File 'lib/VMwareWebService/VimService.rb', line 562

def powerDownHostToStandBy_Task(hMor, timeoutSec = 0, evacuatePoweredOffVms = false)
  response = invoke("n1:PowerDownHostToStandBy_Task") do |message|
    message.add "n1:_this", hMor do |i|
      i.set_attr "type", hMor.vimType
    end
    message.add "n1:timeoutSec", timeoutSec.to_s
    message.add "n1:evacuatePoweredOffVms", evacuatePoweredOffVms.to_s
  end
  (parse_response(response, 'PowerDownHostToStandBy_TaskResponse'))['returnval']
end

#powerOffVM_Task(vmMor) ⇒ Object 



573
574
575
576
577
578
579
580
 
# File 'lib/VMwareWebService/VimService.rb', line 573

def powerOffVM_Task(vmMor)
  response = invoke("n1:PowerOffVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'PowerOffVM_TaskResponse')['returnval'])
end

#powerOnVM_Task(vmMor) ⇒ Object 



582
583
584
585
586
587
588
589
 
# File 'lib/VMwareWebService/VimService.rb', line 582

def powerOnVM_Task(vmMor)
  response = invoke("n1:PowerOnVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'PowerOnVM_TaskResponse')['returnval'])
end

#powerUpHostFromStandBy_Task(hMor, timeoutSec = 0) ⇒ Object 



591
592
593
594
595
596
597
598
599
 
# File 'lib/VMwareWebService/VimService.rb', line 591

def powerUpHostFromStandBy_Task(hMor, timeoutSec = 0)
  response = invoke("n1:PowerUpHostFromStandBy_Task") do |message|
    message.add "n1:_this", hMor do |i|
      i.set_attr "type", hMor.vimType
    end
    message.add "n1:timeoutSec", timeoutSec.to_s
  end
  (parse_response(response, 'PowerUpHostFromStandBy_TaskResponse'))['returnval']
end

#queryAvailablePerfMetric(perfManager, entity, beginTime = nil, endTime = nil, intervalId = nil) ⇒ Object 



601
602
603
604
605
606
607
608
609
610
611
612
613
614
 
# File 'lib/VMwareWebService/VimService.rb', line 601

def queryAvailablePerfMetric(perfManager, entity, beginTime = nil, endTime = nil, intervalId = nil)
  response = invoke("n1:QueryAvailablePerfMetric") do |message|
    message.add "n1:_this", perfManager do |i|
      i.set_attr "type", perfManager.vimType
    end
    message.add "n1:entity", entity do |i|
      i.set_attr "type", entity.vimType
    end
    message.add "n1:beginTime", beginTime.to_s  if beginTime
    message.add "n1:endTime", endTime.to_s    if endTime
    message.add "n1:intervalId", intervalId   if intervalId
  end
  (parse_response(response, 'QueryAvailablePerfMetricResponse')['returnval'])
end

#queryDescriptions(diagnosticManager, entity) ⇒ Object 



616
617
618
619
620
621
622
623
624
625
626
 
# File 'lib/VMwareWebService/VimService.rb', line 616

def queryDescriptions(diagnosticManager, entity)
  response = invoke("n1:QueryDescriptions") do |message|
    message.add "n1:_this", diagnosticManager do |i|
      i.set_attr "type", diagnosticManager.vimType
    end
    message.add "n1:host", entity do |i|
      i.set_attr "type", entity.vimType
    end if entity
  end
  (parse_response(response, 'QueryDescriptionsResponse')['returnval'])
end

#queryDvsConfigTarget(dvsManager, hmor, _dvs) ⇒ Object 



628
629
630
631
632
633
634
635
636
637
638
639
 
# File 'lib/VMwareWebService/VimService.rb', line 628

def queryDvsConfigTarget(dvsManager, hmor, _dvs)
  response = invoke("n1:QueryDvsConfigTarget") do |message|
    message.add "n1:_this", dvsManager do |i|
      i.set_attr "type", dvsManager.vimType
    end
    message.add "n1:host", hmor do |i|
      i.set_attr "type", hmor.vimType
    end if hmor
  end
  (parse_response(response, 'QueryDvsConfigTargetResponse')['returnval'])
  # TODO: dvs
end

#queryNetConfig(vnmMor, nicType) ⇒ Object 



641
642
643
644
645
646
647
648
649
 
# File 'lib/VMwareWebService/VimService.rb', line 641

def queryNetConfig(vnmMor, nicType)
  response = invoke("n1:QueryNetConfig") do |message|
    message.add "n1:_this", vnmMor do |i|
      i.set_attr "type", vnmMor.vimType
    end
    message.add "n1:nicType", nicType
  end
  (parse_response(response, 'QueryNetConfigResponse')['returnval'])
end

#queryOptions(omMor, name) ⇒ Object 



651
652
653
654
655
656
657
658
659
 
# File 'lib/VMwareWebService/VimService.rb', line 651

def queryOptions(omMor, name)
  response = invoke("n1:QueryOptions") do |message|
    message.add "n1:_this", omMor do |i|
      i.set_attr "type", omMor.vimType
    end
    message.add "n1:name", name
  end
  (parse_response(response, 'QueryOptionsResponse')['returnval'])
end

#queryPerf(perfManager, querySpec) ⇒ Object 



661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
 
# File 'lib/VMwareWebService/VimService.rb', line 661

def queryPerf(perfManager, querySpec)
  response = invoke("n1:QueryPerf") do |message|
    message.add "n1:_this", perfManager do |i|
      i.set_attr "type", perfManager.vimType
    end
    if querySpec.kind_of?(Array)
      querySpec.each do |qs|
        message.add "n1:querySpec" do |i|
          i.set_attr "xsi:type", qs.xsiType
          marshalObj(i, qs)
        end
      end
    else
      message.add "n1:querySpec" do |i|
        i.set_attr "xsi:type", querySpec.xsiType
        marshalObj(i, querySpec)
      end
    end
  end
  (parse_response(response, 'QueryPerfResponse')['returnval'])
end

#queryPerfComposite(perfManager, querySpec) ⇒ Object 



683
684
685
686
687
688
689
690
691
692
693
694
 
# File 'lib/VMwareWebService/VimService.rb', line 683

def queryPerfComposite(perfManager, querySpec)
  response = invoke("n1:QueryPerfComposite") do |message|
    message.add "n1:_this", perfManager do |i|
      i.set_attr "type", perfManager.vimType
    end
    message.add "n1:querySpec" do |i|
      i.set_attr "xsi:type", querySpec.xsiType
      marshalObj(i, querySpec)
    end
  end
  (parse_response(response, 'QueryPerfCompositeResponse')['returnval'])
end

#queryPerfProviderSummary(perfManager, entity) ⇒ Object 



696
697
698
699
700
701
702
703
704
705
706
 
# File 'lib/VMwareWebService/VimService.rb', line 696

def queryPerfProviderSummary(perfManager, entity)
  response = invoke("n1:QueryPerfProviderSummary") do |message|
    message.add "n1:_this", perfManager do |i|
      i.set_attr "type", perfManager.vimType
    end
    message.add "n1:entity", entity do |i|
      i.set_attr "type", entity.vimType
    end
  end
  (parse_response(response, 'QueryPerfProviderSummaryResponse')['returnval'])
end

#readNextEvents(ehcMor, maxCount) ⇒ Object 



708
709
710
711
712
713
714
715
716
 
# File 'lib/VMwareWebService/VimService.rb', line 708

def readNextEvents(ehcMor, maxCount)
  response = invoke("n1:ReadNextEvents") do |message|
    message.add "n1:_this", ehcMor do |i|
      i.set_attr "type", ehcMor.vimType
    end
    message.add "n1:maxCount", maxCount
  end
  (parse_response(response, 'ReadNextEventsResponse')['returnval'])
end

#readPreviousEvents(ehcMor, maxCount) ⇒ Object 



718
719
720
721
722
723
724
725
726
 
# File 'lib/VMwareWebService/VimService.rb', line 718

def readPreviousEvents(ehcMor, maxCount)
  response = invoke("n1:ReadPreviousEvents") do |message|
    message.add "n1:_this", ehcMor do |i|
      i.set_attr "type", ehcMor.vimType
    end
    message.add "n1:maxCount", maxCount
  end
  (parse_response(response, 'ReadPreviousEventsResponse')['returnval'])
end

#rebootGuest(vmMor) ⇒ Object 



728
729
730
731
732
733
734
735
 
# File 'lib/VMwareWebService/VimService.rb', line 728

def rebootGuest(vmMor)
  response = invoke("n1:RebootGuest") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'RebootGuestResponse'))
end

#rebootHost_Task(hMor, force = false) ⇒ Object 



737
738
739
740
741
742
743
744
745
 
# File 'lib/VMwareWebService/VimService.rb', line 737

def rebootHost_Task(hMor, force = false)
  response = invoke("n1:RebootHost_Task") do |message|
    message.add "n1:_this", hMor do |i|
      i.set_attr "type", hMor.vimType
    end
    message.add "n1:force", force.to_s
  end
  (parse_response(response, 'RebootHost_TaskResponse'))['returnval']
end

#reconfigureAlarm(aMor, aSpec) ⇒ Object 



747
748
749
750
751
752
753
754
755
756
757
758
 
# File 'lib/VMwareWebService/VimService.rb', line 747

def reconfigureAlarm(aMor, aSpec)
  response = invoke("n1:ReconfigureAlarm") do |message|
    message.add "n1:_this", aMor do |i|
      i.set_attr "type", aMor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", aSpec.xsiType
      marshalObj(i, aSpec)
    end
  end
  (parse_response(response, 'ReconfigureAlarmResponse'))
end

#reconfigVM_Task(vmMor, vmConfigSpec) ⇒ Object 



760
761
762
763
764
765
766
767
768
769
770
771
 
# File 'lib/VMwareWebService/VimService.rb', line 760

def reconfigVM_Task(vmMor, vmConfigSpec)
  response = invoke("n1:ReconfigVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", vmConfigSpec.xsiType
      marshalObj(i, vmConfigSpec)
    end
  end
  (parse_response(response, 'ReconfigVM_TaskResponse')['returnval'])
end

#refreshFirewall(fwsMor) ⇒ Object 



773
774
775
776
777
778
779
780
 
# File 'lib/VMwareWebService/VimService.rb', line 773

def refreshFirewall(fwsMor)
  response = invoke("n1:RefreshFirewall") do |message|
    message.add "n1:_this", fwsMor do |i|
      i.set_attr "type", fwsMor.vimType
    end
  end
  (parse_response(response, 'RefreshFirewallResponse'))
end

#refreshNetworkSystem(nsMor) ⇒ Object 



782
783
784
785
786
787
788
789
 
# File 'lib/VMwareWebService/VimService.rb', line 782

def refreshNetworkSystem(nsMor)
  response = invoke("n1:RefreshNetworkSystem") do |message|
    message.add "n1:_this", nsMor do |i|
      i.set_attr "type", nsMor.vimType
    end
  end
  (parse_response(response, 'RefreshNetworkSystemResponse'))
end

#refreshServices(ssMor) ⇒ Object 



791
792
793
794
795
796
797
798
 
# File 'lib/VMwareWebService/VimService.rb', line 791

def refreshServices(ssMor)
  response = invoke("n1:RefreshServices") do |message|
    message.add "n1:_this", ssMor do |i|
      i.set_attr "type", ssMor.vimType
    end
  end
  (parse_response(response, 'RefreshServicesResponse'))
end

#registerVM_Task(fMor, path, name, asTemplate, pmor, hmor) ⇒ Object 



800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
 
# File 'lib/VMwareWebService/VimService.rb', line 800

def registerVM_Task(fMor, path, name, asTemplate, pmor, hmor)
  response = invoke("n1:RegisterVM_Task") do |message|
    message.add "n1:_this", fMor do |i|
      i.set_attr "type", fMor.vimType
    end
    message.add "n1:path", path
    message.add "n1:name", name if name
    message.add "n1:asTemplate", asTemplate
    message.add "n1:pool", pmor do |i|
      i.set_attr "type", pmor.vimType
    end if pmor
    message.add "n1:host", hmor do |i|
      i.set_attr "type", hmor.vimType
    end if hmor
  end
  (parse_response(response, 'RegisterVM_TaskResponse')['returnval'])
end

#relocateVM_Task(vmMor, cspec, priority = "defaultPriority") ⇒ Object 



548
549
550
551
552
553
554
555
556
557
558
559
560
 
# File 'lib/VMwareWebService/VimService.rb', line 548

def relocateVM_Task(vmMor, cspec, priority = "defaultPriority")
  response = invoke("n1:RelocateVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", cspec.xsiType
      marshalObj(i, cspec)
    end
    message.add "n1:priority", priority
  end
  (parse_response(response, 'RelocateVM_TaskResponse')['returnval'])
end

#removeAlarm(aMor) ⇒ Object 



818
819
820
821
822
823
824
825
 
# File 'lib/VMwareWebService/VimService.rb', line 818

def removeAlarm(aMor)
  response = invoke("n1:RemoveAlarm") do |message|
    message.add "n1:_this", aMor do |i|
      i.set_attr "type", aMor.vimType
    end
  end
  (parse_response(response, 'RemoveAlarmResponse'))
end

#removeAllSnapshots_Task(vmMor) ⇒ Object 



827
828
829
830
831
832
833
834
 
# File 'lib/VMwareWebService/VimService.rb', line 827

def removeAllSnapshots_Task(vmMor)
  response = invoke("n1:RemoveAllSnapshots_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'RemoveAllSnapshots_TaskResponse')['returnval'])
end

#removeSnapshot_Task(snMor, subTree) ⇒ Object 



836
837
838
839
840
841
842
843
844
 
# File 'lib/VMwareWebService/VimService.rb', line 836

def removeSnapshot_Task(snMor, subTree)
  response = invoke("n1:RemoveSnapshot_Task") do |message|
    message.add "n1:_this", snMor do |i|
      i.set_attr "type", snMor.vimType
    end
    message.add "n1:removeChildren", subTree
  end
  (parse_response(response, 'RemoveSnapshot_TaskResponse')['returnval'])
end

#rename_Task(vmMor, newName) ⇒ Object 



846
847
848
849
850
851
852
853
854
 
# File 'lib/VMwareWebService/VimService.rb', line 846

def rename_Task(vmMor, newName)
  response = invoke("n1:Rename_Task") do |message|
    message.add("n1:_this", vmMor) do |i|
      i.set_attr("type", vmMor.vimType)
    end
    message.add("n1:newName", newName)
  end
  parse_response(response, 'Rename_TaskResponse')['returnval']
end

#renameSnapshot(snMor, name, desc) ⇒ Object 



856
857
858
859
860
861
862
863
864
865
 
# File 'lib/VMwareWebService/VimService.rb', line 856

def renameSnapshot(snMor, name, desc)
  response = invoke("n1:RenameSnapshot") do |message|
    message.add "n1:_this", snMor do |i|
      i.set_attr "type", snMor.vimType
    end
    message.add "n1:name", name if name
    message.add "n1:description", desc if desc
  end
  (parse_response(response, 'RenameSnapshotResponse'))
end

#resetCollector(collectorMor) ⇒ Object 



867
868
869
870
871
872
873
874
 
# File 'lib/VMwareWebService/VimService.rb', line 867

def resetCollector(collectorMor)
  response = invoke("n1:ResetCollector") do |message|
    message.add "n1:_this", collectorMor do |i|
      i.set_attr "type", collectorMor.vimType
    end
  end
  (parse_response(response, 'ResetCollectorResponse'))
end

#resetVM_Task(vmMor) ⇒ Object 



876
877
878
879
880
881
882
883
 
# File 'lib/VMwareWebService/VimService.rb', line 876

def resetVM_Task(vmMor)
  response = invoke("n1:ResetVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'ResetVM_TaskResponse')['returnval'])
end

#restartService(ssMor, skey) ⇒ Object 



885
886
887
888
889
890
891
892
893
 
# File 'lib/VMwareWebService/VimService.rb', line 885

def restartService(ssMor, skey)
  response = invoke("n1:RestartService") do |message|
    message.add "n1:_this", ssMor do |i|
      i.set_attr "type", ssMor.vimType
    end
    message.add "n1:id", skey
  end
  (parse_response(response, 'RestartServiceResponse'))
end

#retrieveProperties(propCol, specSet) ⇒ Object 



895
896
897
898
899
900
901
902
903
904
905
906
 
# File 'lib/VMwareWebService/VimService.rb', line 895

def retrieveProperties(propCol, specSet)
  response = invoke("n1:RetrieveProperties") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end
    message.add "n1:specSet" do |i|
      i.set_attr "xsi:type", "PropertyFilterSpec"
      marshalObj(i, specSet)
    end
  end
  (parse_response(response, 'RetrievePropertiesResponse')['returnval'])
end

#retrievePropertiesCompat(propCol, specSet, max_objects = nil) ⇒ Object 



950
951
952
953
954
955
956
 
# File 'lib/VMwareWebService/VimService.rb', line 950

def retrievePropertiesCompat(propCol, specSet, max_objects = nil)
  objects = VimArray.new('ArrayOfObjectContent')

  retrievePropertiesIter(propCol, specSet, max_objects) { |oc| objects << oc }

  objects
end

#retrievePropertiesEx(propCol, specSet, max_objects = nil) ⇒ Object 



908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
 
# File 'lib/VMwareWebService/VimService.rb', line 908

def retrievePropertiesEx(propCol, specSet, max_objects = nil)
  options = VimHash.new("RetrieveOptions") do |opts|
    opts.maxObjects = max_objects.to_s if max_objects
  end

  response = invoke("n1:RetrievePropertiesEx") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end
    message.add "n1:specSet" do |i|
      i.set_attr "xsi:type", "PropertyFilterSpec"
      marshalObj(i, specSet)
    end
    message.add "n1:options" do |i|
      i.set_attr "xsi:type", "RetrieveOptions"
      marshalObj(i, options)
    end
  end
  (parse_response(response, 'RetrievePropertiesExResponse')['returnval'])
end

#retrievePropertiesIter(propCol, specSet, max_objects = nil) ⇒ Object 



929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
 
# File 'lib/VMwareWebService/VimService.rb', line 929

def retrievePropertiesIter(propCol, specSet, max_objects = nil)
  result = retrievePropertiesEx(propCol, specSet, max_objects)

  while result
    begin
      result['objects'].to_a.each { |oc| yield oc }
    rescue
      # if for some reason the caller breaks out of the block let the
      # server know we are going to cancel this retrievePropertiesEx call
      cancelRetrievePropertiesEx(propCol, result['token']) if result['token']
    end

    # if there is no token returned then all results fit in a single page
    # and we are done
    break if result['token'].nil?

    # there is more than one page of result so continue getting the rest
    result = continueRetrievePropertiesEx(propCol, result['token'])
  end
end

#retrieveServiceContent ⇒ Object 



958
959
960
961
962
963
964
965
966
 
# File 'lib/VMwareWebService/VimService.rb', line 958

def retrieveServiceContent
  response = invoke("n1:RetrieveServiceContent") do |message|
    message.add "n1:_this", @serviceInstanceMor do |i|
      i.set_attr "type", @serviceInstanceMor.vimType
    end
  end
  @session_cookie ||= response.cookie
  (parse_response(response, 'RetrieveServiceContentResponse')['returnval'])
end

#revertToCurrentSnapshot_Task(vmMor) ⇒ Object 



968
969
970
971
972
973
974
975
 
# File 'lib/VMwareWebService/VimService.rb', line 968

def revertToCurrentSnapshot_Task(vmMor)
  response = invoke("n1:RevertToCurrentSnapshot_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'RevertToCurrentSnapshot_TaskResponse')['returnval'])
end

#revertToSnapshot_Task(snMor) ⇒ Object 



977
978
979
980
981
982
983
984
 
# File 'lib/VMwareWebService/VimService.rb', line 977

def revertToSnapshot_Task(snMor)
  response = invoke("n1:RevertToSnapshot_Task") do |message|
    message.add "n1:_this", snMor do |i|
      i.set_attr "type", snMor.vimType
    end
  end
  (parse_response(response, 'RevertToSnapshot_TaskResponse')['returnval'])
end

#rewindCollector(collectorMor) ⇒ Object 



986
987
988
989
990
991
992
993
 
# File 'lib/VMwareWebService/VimService.rb', line 986

def rewindCollector(collectorMor)
  response = invoke("n1:RewindCollector") do |message|
    message.add "n1:_this", collectorMor do |i|
      i.set_attr "type", collectorMor.vimType
    end
  end
  (parse_response(response, 'RewindCollectorResponse'))
end

#searchDatastore_Task(browserMor, dsPath, searchSpec) ⇒ Object 



995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
 
# File 'lib/VMwareWebService/VimService.rb', line 995

def searchDatastore_Task(browserMor, dsPath, searchSpec)
  response = invoke("n1:SearchDatastore_Task") do |message|
    message.add "n1:_this", browserMor do |i|
      i.set_attr "type", browserMor.vimType
    end
    message.add "n1:datastorePath", dsPath
    message.add "n1:searchSpec" do |i|
      i.set_attr "xsi:type", searchSpec.xsiType
      marshalObj(i, searchSpec)
    end if searchSpec
  end
  (parse_response(response, 'SearchDatastore_TaskResponse')['returnval'])
end

#searchDatastoreSubFolders_Task(browserMor, dsPath, searchSpec) ⇒ Object 



1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
 
# File 'lib/VMwareWebService/VimService.rb', line 1009

def searchDatastoreSubFolders_Task(browserMor, dsPath, searchSpec)
  response = invoke("n1:SearchDatastoreSubFolders_Task") do |message|
    message.add "n1:_this", browserMor do |i|
      i.set_attr "type", browserMor.vimType
    end
    message.add "n1:datastorePath", dsPath
    message.add "n1:searchSpec" do |i|
      i.set_attr "xsi:type", searchSpec.xsiType
      marshalObj(i, searchSpec)
    end if searchSpec
  end
  (parse_response(response, 'SearchDatastoreSubFolders_TaskResponse')['returnval'])
end

#selectVnicForNicType(vnmMor, nicType, device) ⇒ Object 



1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
 
# File 'lib/VMwareWebService/VimService.rb', line 1023

def selectVnicForNicType(vnmMor, nicType, device)
  response = invoke("n1:SelectVnicForNicType") do |message|
    message.add "n1:_this", vnmMor do |i|
      i.set_attr "type", vnmMor.vimType
    end
    message.add "n1:nicType", nicType
    message.add "n1:device", device
  end
  (parse_response(response, 'SelectVnicForNicTypeResponse'))
end

#setCollectorPageSize(collector, maxCount) ⇒ Object 



1034
1035
1036
1037
1038
1039
1040
1041
1042
 
# File 'lib/VMwareWebService/VimService.rb', line 1034

def setCollectorPageSize(collector, maxCount)
  response = invoke("n1:SetCollectorPageSize") do |message|
    message.add "n1:_this", collector do |i|
      i.set_attr "type", collector.vimType
    end
    message.add "n1:maxCount", maxCount
  end
  (parse_response(response, 'SetCollectorPageSizeResponse'))
end

#setField(cfManager, mor, key, value) ⇒ Object 



1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
 
# File 'lib/VMwareWebService/VimService.rb', line 1044

def setField(cfManager, mor, key, value)
  response = invoke("n1:SetField") do |message|
    message.add "n1:_this", cfManager do |i|
      i.set_attr "type", cfManager.vimType
    end
    message.add "n1:entity", mor do |i|
      i.set_attr "type", mor.vimType
    end
    message.add "n1:key", key
    message.add "n1:value", value
  end
  (parse_response(response, 'SetFieldResponse'))
end

#setTaskDescription(tmor, description) ⇒ Object 



1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
 
# File 'lib/VMwareWebService/VimService.rb', line 1058

def setTaskDescription(tmor, description)
  response = invoke("n1:SetTaskDescription") do |message|
    message.add "n1:_this", tmor do |i|
      i.set_attr "type", tmor.vimType
    end
    message.add "n1:description" do |i|
      i.set_attr "xsi:type", description.xsiType
      marshalObj(i, description)
    end
  end
  (parse_response(response, 'SetTaskDescriptionResponse'))
end

#setTaskState(tmor, state, result = nil, fault = nil) ⇒ Object 



1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
 
# File 'lib/VMwareWebService/VimService.rb', line 1071

def setTaskState(tmor, state, result = nil, fault = nil)
  response = invoke("n1:SetTaskState") do |message|
    message.add "n1:_this", tmor do |i|
      i.set_attr "type", tmor.vimType
    end
    message.add "n1:state", state do |i|
      i.set_attr "xsi:type", "TaskInfoState"
    end
    message.add "n1:result" do |i|
      i.set_attr "xsi:type", result.xsiType
      marshalObj(i, result)
    end if result
    message.add "n1:fault" do |i|
      i.set_attr "xsi:type", fault.xsiType
      marshalObj(i, fault)
    end if fault
  end
  (parse_response(response, 'SetTaskStateResponse'))
end

#shutdownGuest(vmMor) ⇒ Object 



1091
1092
1093
1094
1095
1096
1097
1098
 
# File 'lib/VMwareWebService/VimService.rb', line 1091

def shutdownGuest(vmMor)
  response = invoke("n1:ShutdownGuest") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'ShutdownGuestResponse'))
end

#shutdownHost_Task(hMor, force = false) ⇒ Object 



1100
1101
1102
1103
1104
1105
1106
1107
1108
 
# File 'lib/VMwareWebService/VimService.rb', line 1100

def shutdownHost_Task(hMor, force = false)
  response = invoke("n1:ShutdownHost_Task") do |message|
    message.add "n1:_this", hMor do |i|
      i.set_attr "type", hMor.vimType
    end
    message.add "n1:force", force.to_s
  end
  (parse_response(response, 'ShutdownHost_TaskResponse'))['returnval']
end

#standbyGuest(vmMor) ⇒ Object 



1110
1111
1112
1113
1114
1115
1116
1117
 
# File 'lib/VMwareWebService/VimService.rb', line 1110

def standbyGuest(vmMor)
  response = invoke("n1:StandbyGuest") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'StandbyGuestResponse'))
end

#startService(ssMor, skey) ⇒ Object 



1119
1120
1121
1122
1123
1124
1125
1126
1127
 
# File 'lib/VMwareWebService/VimService.rb', line 1119

def startService(ssMor, skey)
  response = invoke("n1:StartService") do |message|
    message.add "n1:_this", ssMor do |i|
      i.set_attr "type", ssMor.vimType
    end
    message.add "n1:id", skey
  end
  (parse_response(response, 'StartServiceResponse'))
end

#stopService(ssMor, skey) ⇒ Object 



1129
1130
1131
1132
1133
1134
1135
1136
1137
 
# File 'lib/VMwareWebService/VimService.rb', line 1129

def stopService(ssMor, skey)
  response = invoke("n1:StopService") do |message|
    message.add "n1:_this", ssMor do |i|
      i.set_attr "type", ssMor.vimType
    end
    message.add "n1:id", skey
  end
  (parse_response(response, 'StopServiceResponse'))
end

#suspendVM_Task(vmMor) ⇒ Object 



1139
1140
1141
1142
1143
1144
1145
1146
 
# File 'lib/VMwareWebService/VimService.rb', line 1139

def suspendVM_Task(vmMor)
  response = invoke("n1:SuspendVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'SuspendVM_TaskResponse')['returnval'])
end

#uninstallService(ssMor, skey) ⇒ Object 



1148
1149
1150
1151
1152
1153
1154
1155
1156
 
# File 'lib/VMwareWebService/VimService.rb', line 1148

def uninstallService(ssMor, skey)
  response = invoke("n1:UninstallService") do |message|
    message.add "n1:_this", ssMor do |i|
      i.set_attr "type", ssMor.vimType
    end
    message.add "n1:id", skey
  end
  (parse_response(response, 'UninstallServiceResponse'))
end

#unregisterVM(vmMor) ⇒ Object 



1158
1159
1160
1161
1162
1163
1164
1165
 
# File 'lib/VMwareWebService/VimService.rb', line 1158

def unregisterVM(vmMor)
  response = invoke("n1:UnregisterVM") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'UnregisterVMResponse'))
end

#updateDefaultPolicy(fwsMor, defaultPolicy) ⇒ Object 



1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
 
# File 'lib/VMwareWebService/VimService.rb', line 1167

def updateDefaultPolicy(fwsMor, defaultPolicy)
  response = invoke("n1:UpdateDefaultPolicy") do |message|
    message.add "n1:_this", fwsMor do |i|
      i.set_attr "type", fwsMor.vimType
    end
    message.add "n1:defaultPolicy" do |i|
      i.set_attr "xsi:type", defaultPolicy.xsiType
      marshalObj(i, defaultPolicy)
    end
  end
  (parse_response(response, 'UpdateDefaultPolicyResponse'))
end

#updateServicePolicy(sMor, skey, policy) ⇒ Object 



1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
 
# File 'lib/VMwareWebService/VimService.rb', line 1180

def updateServicePolicy(sMor, skey, policy)
  response = invoke("n1:UpdateServicePolicy") do |message|
    message.add "n1:_this", sMor do |i|
      i.set_attr "type", sMor.vimType
    end
    message.add "n1:id", skey
    message.add "n1:policy", policy
  end
  (parse_response(response, 'UpdateServicePolicyResponse'))
end

#updateSoftwareInternetScsiEnabled(hssMor, enabled) ⇒ Object 



1191
1192
1193
1194
1195
1196
1197
1198
1199
 
# File 'lib/VMwareWebService/VimService.rb', line 1191

def updateSoftwareInternetScsiEnabled(hssMor, enabled)
  response = invoke("n1:UpdateSoftwareInternetScsiEnabled") do |message|
    message.add "n1:_this", hssMor do |i|
      i.set_attr "type", hssMor.vimType
    end
    message.add "n1:enabled", enabled.to_s
  end
  (parse_response(response, 'UpdateSoftwareInternetScsiEnabledResponse'))
end

#waitForUpdates(propCol, version = nil) ⇒ Object 



1201
1202
1203
1204
1205
1206
1207
1208
1209
 
# File 'lib/VMwareWebService/VimService.rb', line 1201

def waitForUpdates(propCol, version = nil)
  response = invoke("n1:WaitForUpdates") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end
    message.add "n1:version", version if version
  end
  (parse_response(response, 'WaitForUpdatesResponse')['returnval'])
end

#waitForUpdatesEx(propCol, version = nil, options = {}) ⇒ Object 



1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
 
# File 'lib/VMwareWebService/VimService.rb', line 1211

def waitForUpdatesEx(propCol, version = nil, options = {})
  max_wait    = options[:max_wait]
  max_objects = options[:max_objects]

  options = VimHash.new("WaitOptions") do |opts|
    opts.maxObjectUpdates = max_objects.to_s if max_objects
    opts.maxWaitSeconds   = max_wait.to_s    if max_wait
  end

  response = invoke("n1:WaitForUpdatesEx") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end

    message.add "n1:version", version if version
    message.add "n1:options" do |i|
      i.set_attr "type", options.vimType
      marshalObj(i, options)
    end
  end
  (parse_response(response, 'WaitForUpdatesExResponse')['returnval'])
end

#xmlToCustomizationSpecItem(csmMor, specItemXml) ⇒ Object 



1234
1235
1236
1237
1238
1239
1240
1241
1242
 
# File 'lib/VMwareWebService/VimService.rb', line 1234

def xmlToCustomizationSpecItem(csmMor, specItemXml)
  response = invoke("n1:XmlToCustomizationSpecItem") do |message|
    message.add "n1:_this", csmMor do |i|
      i.set_attr "type", csmMor.vimType
    end
    message.add "n1:specItemXml", specItemXml
  end
  (parse_response(response, 'XmlToCustomizationSpecItemResponse')['returnval'])
end