Class: VimService

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

Direct Known Subclasses

MiqVimClientBase

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(ep) ⇒ VimService

Returns a new instance of VimService.



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/VMwareWebService/VimService.rb', line 10

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\..*/
  @isVirtualCenter = @about.apiType == "VirtualCenter"
end

Instance Attribute Details

#about ⇒ Object (readonly)

Returns the value of attribute about.



6
7
8
 
# File 'lib/VMwareWebService/VimService.rb', line 6

def about
  @about
end

#apiVersion ⇒ Object (readonly)

Returns the value of attribute apiVersion.



6
7
8
 
# File 'lib/VMwareWebService/VimService.rb', line 6

def apiVersion
  @apiVersion
end

#isVirtualCenter ⇒ Object (readonly)

Returns the value of attribute isVirtualCenter.



6
7
8
 
# File 'lib/VMwareWebService/VimService.rb', line 6

def isVirtualCenter
  @isVirtualCenter
end

#serviceInstanceMor ⇒ Object (readonly)

Returns the value of attribute serviceInstanceMor.



6
7
8
 
# File 'lib/VMwareWebService/VimService.rb', line 6

def serviceInstanceMor
  @serviceInstanceMor
end

#session_cookie ⇒ Object (readonly)

Returns the value of attribute session_cookie.



6
7
8
 
# File 'lib/VMwareWebService/VimService.rb', line 6

def session_cookie
  @session_cookie
end

#sic ⇒ Object (readonly)

Returns the value of attribute sic.



6
7
8
 
# File 'lib/VMwareWebService/VimService.rb', line 6

def sic
  @sic
end

#v2 ⇒ Object (readonly)

Returns the value of attribute v2.



6
7
8
 
# File 'lib/VMwareWebService/VimService.rb', line 6

def v2
  @v2
end

#v20 ⇒ Object (readonly)

Returns the value of attribute v20.



6
7
8
 
# File 'lib/VMwareWebService/VimService.rb', line 6

def v20
  @v20
end

#v4 ⇒ Object (readonly)

Returns the value of attribute v4.



6
7
8
 
# File 'lib/VMwareWebService/VimService.rb', line 6

def v4
  @v4
end

Instance Method Details

#acquireCloneTicket(sm) ⇒ Object 



32
33
34
35
36
37
38
39
 
# File 'lib/VMwareWebService/VimService.rb', line 32

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 



41
42
43
44
45
46
47
48
 
# File 'lib/VMwareWebService/VimService.rb', line 41

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 



50
51
52
53
54
55
56
57
58
 
# File 'lib/VMwareWebService/VimService.rb', line 50

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 



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/VMwareWebService/VimService.rb', line 60

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 



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/VMwareWebService/VimService.rb', line 78

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 



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/VMwareWebService/VimService.rb', line 101

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 



124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/VMwareWebService/VimService.rb', line 124

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 



139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/VMwareWebService/VimService.rb', line 139

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 



154
155
156
157
158
159
160
161
 
# File 'lib/VMwareWebService/VimService.rb', line 154

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 



163
164
165
166
167
168
169
170
 
# File 'lib/VMwareWebService/VimService.rb', line 163

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 



172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/VMwareWebService/VimService.rb', line 172

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 



189
190
191
192
193
194
195
196
197
 
# File 'lib/VMwareWebService/VimService.rb', line 189

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 



199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/VMwareWebService/VimService.rb', line 199

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 



215
216
217
218
219
220
221
222
223
224
225
226
 
# File 'lib/VMwareWebService/VimService.rb', line 215

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 



228
229
230
231
232
233
234
235
236
237
238
239
 
# File 'lib/VMwareWebService/VimService.rb', line 228

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 



241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'lib/VMwareWebService/VimService.rb', line 241

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 



255
256
257
258
259
260
261
262
263
 
# File 'lib/VMwareWebService/VimService.rb', line 255

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 



265
266
267
268
269
270
271
272
273
274
275
276
 
# File 'lib/VMwareWebService/VimService.rb', line 265

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 



278
279
280
281
282
283
284
285
286
287
288
289
 
# File 'lib/VMwareWebService/VimService.rb', line 278

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 



291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
 
# File 'lib/VMwareWebService/VimService.rb', line 291

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 



313
314
315
316
317
318
319
320
 
# File 'lib/VMwareWebService/VimService.rb', line 313

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 



322
323
324
325
326
327
328
329
330
331
332
333
 
# File 'lib/VMwareWebService/VimService.rb', line 322

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 



335
336
337
338
339
340
341
342
343
 
# File 'lib/VMwareWebService/VimService.rb', line 335

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 



345
346
347
348
349
350
351
352
353
354
 
# File 'lib/VMwareWebService/VimService.rb', line 345

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 



356
357
358
359
360
361
362
363
 
# File 'lib/VMwareWebService/VimService.rb', line 356

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 



365
366
367
368
369
370
371
372
 
# File 'lib/VMwareWebService/VimService.rb', line 365

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 



374
375
376
377
378
379
380
381
 
# File 'lib/VMwareWebService/VimService.rb', line 374

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 



383
384
385
386
387
388
389
390
391
 
# File 'lib/VMwareWebService/VimService.rb', line 383

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 



393
394
395
396
397
398
399
400
401
 
# File 'lib/VMwareWebService/VimService.rb', line 393

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 



403
404
405
406
407
408
409
410
411
 
# File 'lib/VMwareWebService/VimService.rb', line 403

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 



413
414
415
416
417
418
419
420
421
422
 
# File 'lib/VMwareWebService/VimService.rb', line 413

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 



424
425
426
427
428
429
430
431
432
 
# File 'lib/VMwareWebService/VimService.rb', line 424

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 



434
435
436
437
438
439
440
441
442
443
444
 
# File 'lib/VMwareWebService/VimService.rb', line 434

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 



446
447
448
449
450
451
452
453
454
 
# File 'lib/VMwareWebService/VimService.rb', line 446

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 



456
457
458
459
460
461
462
463
464
465
466
 
# File 'lib/VMwareWebService/VimService.rb', line 456

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 



468
469
470
471
472
473
474
475
 
# File 'lib/VMwareWebService/VimService.rb', line 468

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 



477
478
479
480
481
482
483
484
485
486
487
488
 
# File 'lib/VMwareWebService/VimService.rb', line 477

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 



490
491
492
493
494
495
496
497
 
# File 'lib/VMwareWebService/VimService.rb', line 490

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 



499
500
501
502
503
504
505
506
507
508
509
510
511
512
 
# File 'lib/VMwareWebService/VimService.rb', line 499

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 



514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
 
# File 'lib/VMwareWebService/VimService.rb', line 514

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 



531
532
533
534
535
536
537
538
539
540
541
 
# File 'lib/VMwareWebService/VimService.rb', line 531

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 



557
558
559
560
561
562
563
564
565
566
 
# File 'lib/VMwareWebService/VimService.rb', line 557

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 



568
569
570
571
572
573
574
575
 
# File 'lib/VMwareWebService/VimService.rb', line 568

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 



577
578
579
580
581
582
583
584
 
# File 'lib/VMwareWebService/VimService.rb', line 577

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 



586
587
588
589
590
591
592
593
594
 
# File 'lib/VMwareWebService/VimService.rb', line 586

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 



596
597
598
599
600
601
602
603
604
605
606
607
608
609
 
# File 'lib/VMwareWebService/VimService.rb', line 596

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 



611
612
613
614
615
616
617
618
619
620
621
 
# File 'lib/VMwareWebService/VimService.rb', line 611

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 



623
624
625
626
627
628
629
630
631
632
633
634
 
# File 'lib/VMwareWebService/VimService.rb', line 623

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 



636
637
638
639
640
641
642
643
644
 
# File 'lib/VMwareWebService/VimService.rb', line 636

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 



646
647
648
649
650
651
652
653
654
 
# File 'lib/VMwareWebService/VimService.rb', line 646

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 



656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
 
# File 'lib/VMwareWebService/VimService.rb', line 656

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 



678
679
680
681
682
683
684
685
686
687
688
689
 
# File 'lib/VMwareWebService/VimService.rb', line 678

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 



691
692
693
694
695
696
697
698
699
700
701
 
# File 'lib/VMwareWebService/VimService.rb', line 691

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 



703
704
705
706
707
708
709
710
711
 
# File 'lib/VMwareWebService/VimService.rb', line 703

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 



713
714
715
716
717
718
719
720
721
 
# File 'lib/VMwareWebService/VimService.rb', line 713

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 



723
724
725
726
727
728
729
730
 
# File 'lib/VMwareWebService/VimService.rb', line 723

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 



732
733
734
735
736
737
738
739
740
 
# File 'lib/VMwareWebService/VimService.rb', line 732

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 



742
743
744
745
746
747
748
749
750
751
752
753
 
# File 'lib/VMwareWebService/VimService.rb', line 742

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 



755
756
757
758
759
760
761
762
763
764
765
766
 
# File 'lib/VMwareWebService/VimService.rb', line 755

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 



768
769
770
771
772
773
774
775
 
# File 'lib/VMwareWebService/VimService.rb', line 768

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 



777
778
779
780
781
782
783
784
 
# File 'lib/VMwareWebService/VimService.rb', line 777

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 



786
787
788
789
790
791
792
793
 
# File 'lib/VMwareWebService/VimService.rb', line 786

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 



795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
 
# File 'lib/VMwareWebService/VimService.rb', line 795

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 



543
544
545
546
547
548
549
550
551
552
553
554
555
 
# File 'lib/VMwareWebService/VimService.rb', line 543

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 



813
814
815
816
817
818
819
820
 
# File 'lib/VMwareWebService/VimService.rb', line 813

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 



822
823
824
825
826
827
828
829
 
# File 'lib/VMwareWebService/VimService.rb', line 822

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 



831
832
833
834
835
836
837
838
839
 
# File 'lib/VMwareWebService/VimService.rb', line 831

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 



841
842
843
844
845
846
847
848
849
 
# File 'lib/VMwareWebService/VimService.rb', line 841

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 



851
852
853
854
855
856
857
858
859
860
 
# File 'lib/VMwareWebService/VimService.rb', line 851

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 



862
863
864
865
866
867
868
869
 
# File 'lib/VMwareWebService/VimService.rb', line 862

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 



871
872
873
874
875
876
877
878
 
# File 'lib/VMwareWebService/VimService.rb', line 871

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 



880
881
882
883
884
885
886
887
888
 
# File 'lib/VMwareWebService/VimService.rb', line 880

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 



890
891
892
893
894
895
896
897
898
899
900
901
 
# File 'lib/VMwareWebService/VimService.rb', line 890

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 



945
946
947
948
949
950
951
 
# File 'lib/VMwareWebService/VimService.rb', line 945

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 



903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
 
# File 'lib/VMwareWebService/VimService.rb', line 903

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 



924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
 
# File 'lib/VMwareWebService/VimService.rb', line 924

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 



953
954
955
956
957
958
959
960
961
 
# File 'lib/VMwareWebService/VimService.rb', line 953

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 



963
964
965
966
967
968
969
970
 
# File 'lib/VMwareWebService/VimService.rb', line 963

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 



972
973
974
975
976
977
978
979
 
# File 'lib/VMwareWebService/VimService.rb', line 972

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 



981
982
983
984
985
986
987
988
 
# File 'lib/VMwareWebService/VimService.rb', line 981

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 



990
991
992
993
994
995
996
997
998
999
1000
1001
1002
 
# File 'lib/VMwareWebService/VimService.rb', line 990

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 



1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
 
# File 'lib/VMwareWebService/VimService.rb', line 1004

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 



1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
 
# File 'lib/VMwareWebService/VimService.rb', line 1018

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 



1029
1030
1031
1032
1033
1034
1035
1036
1037
 
# File 'lib/VMwareWebService/VimService.rb', line 1029

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 



1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
 
# File 'lib/VMwareWebService/VimService.rb', line 1039

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 



1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
 
# File 'lib/VMwareWebService/VimService.rb', line 1053

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 



1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
 
# File 'lib/VMwareWebService/VimService.rb', line 1066

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 



1086
1087
1088
1089
1090
1091
1092
1093
 
# File 'lib/VMwareWebService/VimService.rb', line 1086

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 



1095
1096
1097
1098
1099
1100
1101
1102
1103
 
# File 'lib/VMwareWebService/VimService.rb', line 1095

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 



1105
1106
1107
1108
1109
1110
1111
1112
 
# File 'lib/VMwareWebService/VimService.rb', line 1105

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 



1114
1115
1116
1117
1118
1119
1120
1121
1122
 
# File 'lib/VMwareWebService/VimService.rb', line 1114

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 



1124
1125
1126
1127
1128
1129
1130
1131
1132
 
# File 'lib/VMwareWebService/VimService.rb', line 1124

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 



1134
1135
1136
1137
1138
1139
1140
1141
 
# File 'lib/VMwareWebService/VimService.rb', line 1134

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 



1143
1144
1145
1146
1147
1148
1149
1150
1151
 
# File 'lib/VMwareWebService/VimService.rb', line 1143

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 



1153
1154
1155
1156
1157
1158
1159
1160
 
# File 'lib/VMwareWebService/VimService.rb', line 1153

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 



1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
 
# File 'lib/VMwareWebService/VimService.rb', line 1162

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 



1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
 
# File 'lib/VMwareWebService/VimService.rb', line 1175

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 



1186
1187
1188
1189
1190
1191
1192
1193
1194
 
# File 'lib/VMwareWebService/VimService.rb', line 1186

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 



1196
1197
1198
1199
1200
1201
1202
1203
1204
 
# File 'lib/VMwareWebService/VimService.rb', line 1196

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 



1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
 
# File 'lib/VMwareWebService/VimService.rb', line 1206

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 



1229
1230
1231
1232
1233
1234
1235
1236
1237
 
# File 'lib/VMwareWebService/VimService.rb', line 1229

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