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
31
32
 
# 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\..*/
  @v5              = @apiVersion =~ /5\..*/
  @v6              = @apiVersion =~ /6\..*/
  @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

#v5 ⇒ Object (readonly)

Returns the value of attribute v5.



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

def v5
  @v5
end

#v6 ⇒ Object (readonly)

Returns the value of attribute v6.



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

def v6
  @v6
end

Instance Method Details

#acquireCloneTicket(sm) ⇒ Object 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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