class VimService

Attributes

about[R]
apiVersion[R]
isVirtualCenter[R]
serviceInstanceMor[R]
sic[R]
v2[R]
v20[R]
v4[R]
v5[R]
v6[R]

Public Class Methods

new(ep) click to toggle source
Calls superclass method
# File lib/VMwareWebService/VimService.rb, line 13
def initialize(ep)
  super

  setNameSpace('urn:vim25')

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

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

  @sic = retrieveServiceContent

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

Public Instance Methods

acquireCloneTicket(sm) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 37
def acquireCloneTicket(sm)
  response = invoke("n1:AcquireCloneTicket") do |message|
    message.add "n1:_this", sm do |i|
      i.set_attr "type", sm.vimType
    end
  end
  (parse_response(response, 'AcquireCloneTicketResponse')['returnval'])
end
acquireMksTicket(mor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 46
def acquireMksTicket(mor)
  response = invoke("n1:AcquireMksTicket") do |message|
    message.add "n1:_this", mor do |i|
      i.set_attr "type", mor.vimType
    end
  end
  (parse_response(response, 'AcquireMksTicketResponse')['returnval'])
end
acquireTicket(mor, ticketType) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 55
def acquireTicket(mor, ticketType)
  response = invoke("n1:AcquireTicket") do |message|
    message.add "n1:_this", mor do |i|
      i.set_attr "type", mor.vimType
    end
    message.add "n1:ticketType", ticketType
  end
  (parse_response(response, 'AcquireTicketResponse')['returnval'])
end
addHost_Task(clustMor, spec, asConnected, resourcePool = nil, license = nil) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 65
def addHost_Task(clustMor, spec, asConnected, resourcePool = nil, license = nil)
  response = invoke("n1:AddHost_Task") do |message|
    message.add "n1:_this", clustMor do |i|
      i.set_attr "type", clustMor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", spec.xsiType
      marshalObj(i, spec)
    end
    message.add "n1:asConnected", asConnected
    message.add "n1:resourcePool", resourcePool do |i|
      i.set_attr "type", resourcePool.vimType
    end unless resourcePool.nil?
    message.add "n1:license", license unless license.nil?
  end
  (parse_response(response, 'AddHost_TaskResponse')['returnval'])
end
addInternetScsiSendTargets(hssMor, iScsiHbaDevice, targets) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 83
def addInternetScsiSendTargets(hssMor, iScsiHbaDevice, targets)
  response = invoke("n1:AddInternetScsiSendTargets") do |message|
    message.add "n1:_this", hssMor do |i|
      i.set_attr "type", hssMor.vimType
    end
    message.add "n1:iScsiHbaDevice", iScsiHbaDevice
    if targets.kind_of?(Array)
      targets.each do |t|
        message.add "n1:targets" do |i|
          i.set_attr "xsi:type", t.xsiType
          marshalObj(i, t)
        end
      end
    else
      message.add "n1:targets" do |i|
        i.set_attr "xsi:type", targets.xsiType
        marshalObj(i, targets)
      end
    end
  end
  (parse_response(response, 'AddInternetScsiSendTargetsResponse'))
end
addInternetScsiStaticTargets(hssMor, iScsiHbaDevice, targets) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 106
def addInternetScsiStaticTargets(hssMor, iScsiHbaDevice, targets)
  response = invoke("n1:AddInternetScsiStaticTargets") do |message|
    message.add "n1:_this", hssMor do |i|
      i.set_attr "type", hssMor.vimType
    end
    message.add "n1:iScsiHbaDevice", iScsiHbaDevice
    if targets.kind_of?(Array)
      targets.each do |t|
        message.add "n1:targets" do |i|
          i.set_attr "xsi:type", t.xsiType
          marshalObj(i, t)
        end
      end
    else
      message.add "n1:targets" do |i|
        i.set_attr "xsi:type", targets.xsiType
        marshalObj(i, targets)
      end
    end
  end
  (parse_response(response, 'AddInternetScsiStaticTargetsResponse'))
end
addStandaloneHost_Task(folderMor, spec, addConnected, license = nil) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 129
def addStandaloneHost_Task(folderMor, spec, addConnected, license = nil)
  response = invoke("n1:AddStandaloneHost_Task") do |message|
    message.add "n1:_this", folderMor do |i|
      i.set_attr "type", folderMor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", spec.xsiType
      marshalObj(i, spec)
    end
    message.add "n1:addConnected", addConnected
    message.add "n1:license", license unless license.nil?
  end
  (parse_response(response, 'AddStandaloneHost_TaskResponse')['returnval'])
end
browseDiagnosticLog(diagnosticManager, host, key, start, lines) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 144
def browseDiagnosticLog(diagnosticManager, host, key, start, lines)
  response = invoke("n1:BrowseDiagnosticLog") do |message|
    message.add "n1:_this", diagnosticManager do |i|
      i.set_attr "type", diagnosticManager.vimType
    end
    message.add "n1:host", host do |i|
      i.set_attr "type", host.vimType
    end if host
    message.add "n1:key", key
    message.add "n1:start", start if start
    message.add "n1:lines", lines if lines
  end
  (parse_response(response, 'BrowseDiagnosticLogResponse')['returnval'])
end
cancelTask(tmor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 159
def cancelTask(tmor)
  response = invoke("n1:CancelTask") do |message|
    message.add "n1:_this", tmor do |i|
      i.set_attr "type", tmor.vimType
    end
  end
  (parse_response(response, 'CancelTaskResponse'))
end
cancelWaitForUpdates(propCol) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 168
def cancelWaitForUpdates(propCol)
  response = invoke("n1:CancelWaitForUpdates") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end
  end
  (parse_response(response, 'CancelWaitForUpdatesResponse'))
end
cloneVM_Task(vmMor, fmor, name, cspec) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 177
def cloneVM_Task(vmMor, fmor, name, cspec)
  response = invoke("n1:CloneVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
    message.add "n1:folder", fmor do |i|
      i.set_attr "type", fmor.vimType
    end
    message.add "n1:name", name
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", cspec.xsiType
      marshalObj(i, cspec)
    end
  end
  (parse_response(response, 'CloneVM_TaskResponse')['returnval'])
end
continueRetrievePropertiesEx(propCol, token) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 194
def continueRetrievePropertiesEx(propCol, token)
  response = invoke("n1:ContinueRetrievePropertiesEx") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end
    message.add "n1:token", token
  end
  (parse_response(response, 'ContinueRetrievePropertiesExResponse')['returnval'])
end
createAlarm(alarmManager, mor, aSpec) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 204
def createAlarm(alarmManager, mor, aSpec)
  response = invoke("n1:CreateAlarm") do |message|
    message.add "n1:_this", alarmManager do |i|
      i.set_attr "type", alarmManager.vimType
    end
    message.add "n1:entity", mor do |i|
      i.set_attr "type", mor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", aSpec.xsiType
      marshalObj(i, aSpec)
    end
  end
  (parse_response(response, 'CreateAlarmResponse')['returnval'])
end
createCollectorForEvents(eventManager, eventFilterSpec) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 220
def createCollectorForEvents(eventManager, eventFilterSpec)
  response = invoke("n1:CreateCollectorForEvents") do |message|
    message.add "n1:_this", eventManager do |i|
      i.set_attr "type", eventManager.vimType
    end
    message.add "n1:filter" do |i|
      i.set_attr "xsi:type", eventFilterSpec.xsiType
      marshalObj(i, eventFilterSpec)
    end
  end
  (parse_response(response, 'CreateCollectorForEventsResponse')['returnval'])
end
createCustomizationSpec(csmMor, item) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 233
def createCustomizationSpec(csmMor, item)
  response = invoke("n1:CreateCustomizationSpec") do |message|
    message.add "n1:_this", csmMor do |i|
      i.set_attr "type", csmMor.vimType
    end
    message.add "n1:item" do |i|
      i.set_attr "xsi:type", item.xsiType
      marshalObj(i, item)
    end
  end
  (parse_response(response, 'CreateCustomizationSpecResponse')['returnval'])
end
createFilter(propCol, pfSpec, partialUpdates) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 246
def createFilter(propCol, pfSpec, partialUpdates)
  response = invoke("n1:CreateFilter") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", pfSpec.xsiType
      marshalObj(i, pfSpec)
    end
    message.add "n1:partialUpdates", partialUpdates
  end
  (parse_response(response, 'CreateFilterResponse')['returnval'])
end
createFolder(pfMor, fname) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 260
def createFolder(pfMor, fname)
  response = invoke("n1:CreateFolder") do |message|
    message.add "n1:_this", pfMor do |i|
      i.set_attr "type", pfMor.vimType
    end
    message.add "n1:name", fname
  end
  (parse_response(response, 'CreateFolderResponse')['returnval'])
end
createNasDatastore(dssMor, spec) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 270
def createNasDatastore(dssMor, spec)
  response = invoke("n1:CreateNasDatastore") do |message|
    message.add "n1:_this", dssMor do |i|
      i.set_attr "type", dssMor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", spec.xsiType
      marshalObj(i, spec)
    end
  end
  (parse_response(response, 'CreateNasDatastoreResponse')['returnval'])
end
createSnapshot_Task(vmMor, name, desc, memory, quiesce) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 283
def createSnapshot_Task(vmMor, name, desc, memory, quiesce)
  response = invoke("n1:CreateSnapshot_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
    message.add "n1:name", name
    message.add "n1:description", desc  if desc
    message.add "n1:memory", memory.to_s
    message.add "n1:quiesce", quiesce
  end
  (parse_response(response, 'CreateSnapshot_TaskResponse')['returnval'])
end
createVM_Task(fMor, vmcs, pool, hMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 296
def createVM_Task(fMor, vmcs, pool, hMor)
  response = invoke("n1:CreateVM_Task") do |message|
    message.add "n1:_this", fMor do |i|
      i.set_attr "type", fMor.vimType
    end
    message.add "n1:config" do |i|
      i.set_attr "xsi:type", vmcs.xsiType
      marshalObj(i, vmcs)
    end
    message.add "n1:pool", pool do |i|
      i.set_attr "type", "ResourcePool"
    end
    # hMor is not mandatory since it's ok to miss it for DRS clusters or single host clusters
    unless hMor.nil?
      message.add "n1:host", hMor do |i|
        i.set_attr "type", hMor.vimType
      end
    end
  end
  parse_response(response, 'CreateVM_TaskResponse')['returnval']
end
currentTime() click to toggle source
# File lib/VMwareWebService/VimService.rb, line 318
def currentTime
  response = invoke("n1:CurrentTime") do |message|
    message.add "n1:_this", "ServiceInstance" do |i|
      i.set_attr "type", "ServiceInstance"
    end
  end
  (parse_response(response, 'CurrentTimeResponse')['returnval'])
end
customizationSpecItemToXml(csmMor, item) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 327
def customizationSpecItemToXml(csmMor, item)
  response = invoke("n1:CustomizationSpecItemToXml") do |message|
    message.add "n1:_this", csmMor do |i|
      i.set_attr "type", csmMor.vimType
    end
    message.add "n1:item" do |i|
      i.set_attr "xsi:type", item.xsiType
      marshalObj(i, item)
    end
  end
  (parse_response(response, 'CustomizationSpecItemToXmlResponse')['returnval'])
end
deleteCustomizationSpec(csmMor, name) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 340
def deleteCustomizationSpec(csmMor, name)
  response = invoke("n1:DeleteCustomizationSpec") do |message|
    message.add "n1:_this", csmMor do |i|
      i.set_attr "type", csmMor.vimType
    end
    message.add "n1:name", name
  end
  (parse_response(response, 'DeleteCustomizationSpecResponse'))['returnval']
end
deselectVnicForNicType(vnmMor, nicType, device) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 350
def deselectVnicForNicType(vnmMor, nicType, device)
  response = invoke("n1:DeselectVnicForNicType") do |message|
    message.add "n1:_this", vnmMor do |i|
      i.set_attr "type", vnmMor.vimType
    end
    message.add "n1:nicType", nicType
    message.add "n1:device", device
  end
  (parse_response(response, 'DeselectVnicForNicTypeResponse'))
end
destroyCollector(collectorMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 370
def destroyCollector(collectorMor)
  response = invoke("n1:DestroyCollector") do |message|
    message.add "n1:_this", collectorMor do |i|
      i.set_attr "type", collectorMor.vimType
    end
  end
  (parse_response(response, 'DestroyCollectorResponse'))
end
destroyPropertyFilter(filterSpecRef) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 379
def destroyPropertyFilter(filterSpecRef)
  response = invoke("n1:DestroyPropertyFilter") do |message|
    message.add "n1:_this", filterSpecRef do |i|
      i.set_attr "type", filterSpecRef.vimType
    end
  end
  (parse_response(response, 'DestroyPropertyFilterResponse'))
end
destroy_Task(mor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 361
def destroy_Task(mor)
  response = invoke("n1:Destroy_Task") do |message|
    message.add "n1:_this", mor do |i|
      i.set_attr "type", mor.vimType
    end
  end
  (parse_response(response, 'Destroy_TaskResponse')['returnval'])
end
disableRuleset(fwsMor, rskey) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 388
def disableRuleset(fwsMor, rskey)
  response = invoke("n1:DisableRuleset") do |message|
    message.add "n1:_this", fwsMor do |i|
      i.set_attr "type", fwsMor.vimType
    end
    message.add "n1:id", rskey
  end
  (parse_response(response, 'DisableRulesetResponse'))
end
doesCustomizationSpecExist(csmMor, name) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 398
def doesCustomizationSpecExist(csmMor, name)
  response = invoke("n1:DoesCustomizationSpecExist") do |message|
    message.add "n1:_this", csmMor do |i|
      i.set_attr "type", csmMor.vimType
    end
    message.add "n1:name", name
  end
  (parse_response(response, 'DoesCustomizationSpecExistResponse'))['returnval']
end
enableRuleset(fwsMor, rskey) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 408
def enableRuleset(fwsMor, rskey)
  response = invoke("n1:EnableRuleset") do |message|
    message.add "n1:_this", fwsMor do |i|
      i.set_attr "type", fwsMor.vimType
    end
    message.add "n1:id", rskey
  end
  (parse_response(response, 'EnableRulesetResponse'))
end
enterMaintenanceMode_Task(hMor, timeout = 0, evacuatePoweredOffVms = false) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 418
def enterMaintenanceMode_Task(hMor, timeout = 0, evacuatePoweredOffVms = false)
  response = invoke("n1:EnterMaintenanceMode_Task") do |message|
    message.add "n1:_this", hMor do |i|
      i.set_attr "type", hMor.vimType
    end
    message.add "n1:timeout", timeout.to_s
    message.add "n1:evacuatePoweredOffVms", evacuatePoweredOffVms.to_s
  end
  (parse_response(response, 'EnterMaintenanceMode_TaskResponse'))['returnval']
end
exitMaintenanceMode_Task(hMor, timeout = 0) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 429
def exitMaintenanceMode_Task(hMor, timeout = 0)
  response = invoke("n1:ExitMaintenanceMode_Task") do |message|
    message.add "n1:_this", hMor do |i|
      i.set_attr "type", hMor.vimType
    end
    message.add "n1:timeout", timeout.to_s
  end
  (parse_response(response, 'ExitMaintenanceMode_TaskResponse'))['returnval']
end
getAlarm(alarmManager, mor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 439
def getAlarm(alarmManager, mor)
  response = invoke("n1:GetAlarm") do |message|
    message.add "n1:_this", alarmManager do |i|
      i.set_attr "type", alarmManager.vimType
    end
    message.add "n1:entity", mor do |i|
      i.set_attr "type", mor.vimType
    end if mor
  end
  (parse_response(response, 'GetAlarmResponse')['returnval'])
end
getCustomizationSpec(csmMor, name) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 451
def getCustomizationSpec(csmMor, name)
  response = invoke("n1:GetCustomizationSpec") do |message|
    message.add "n1:_this", csmMor do |i|
      i.set_attr "type", csmMor.vimType
    end
    message.add "n1:name", name
  end
  (parse_response(response, 'GetCustomizationSpecResponse'))['returnval']
end
logUserEvent(eventManager, entity, msg) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 482
def logUserEvent(eventManager, entity, msg)
  response = invoke("n1:LogUserEvent") do |message|
    message.add "n1:_this", eventManager do |i|
      i.set_attr "type", eventManager.vimType
    end
    message.add "n1:entity", entity do |i|
      i.set_attr "type", entity.vimType
    end
    message.add "n1:msg", msg
  end
  (parse_response(response, 'LogUserEventResponse'))
end
login(sessionManager, username, password) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 461
def login(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) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 473
def logout(sessionManager)
  response = invoke("n1:Logout") do |message|
    message.add "n1:_this", sessionManager do |i|
      i.set_attr "type", "SessionManager"
    end
  end
  (parse_response(response, 'LogoutResponse'))
end
markAsTemplate(vmMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 495
def markAsTemplate(vmMor)
  response = invoke("n1:MarkAsTemplate") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'MarkAsTemplateResponse'))
end
markAsVirtualMachine(vmMor, pmor, hmor = nil) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 504
def markAsVirtualMachine(vmMor, pmor, hmor = nil)
  response = invoke("n1:MarkAsVirtualMachine") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
    message.add "n1:pool", pmor do |i|
      i.set_attr "type", pmor.vimType
    end
    message.add "n1:host", hmor do |i|
      i.set_attr "type", hmor.vimType
    end if hmor
  end
  (parse_response(response, 'MarkAsVirtualMachineResponse'))
end
migrateVM_Task(vmMor, pmor = nil, hmor = nil, priority = "defaultPriority", state = nil) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 519
def migrateVM_Task(vmMor, pmor = nil, hmor = nil, priority = "defaultPriority", state = nil)
  response = invoke("n1:MigrateVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
    message.add "n1:pool", pmor do |i|
      i.set_attr "type", pmor.vimType
    end if pmor
    message.add "n1:host", hmor do |i|
      i.set_attr "type", hmor.vimType
    end if hmor
    message.add "n1:priority", priority
    message.add "n1:state", state if state
  end
  (parse_response(response, 'MigrateVM_TaskResponse')['returnval'])
end
moveIntoFolder_Task(fMor, oMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 536
def moveIntoFolder_Task(fMor, oMor)
  response = invoke("n1:MoveIntoFolder_Task") do |message|
    message.add "n1:_this", fMor do |i|
      i.set_attr "type", fMor.vimType
    end
    message.add "n1:list", oMor do |i|
      i.set_attr "type", oMor.vimType
    end
  end
  parse_response(response, 'MoveIntoFolder_TaskResponse')['returnval']
end
powerDownHostToStandBy_Task(hMor, timeoutSec = 0, evacuatePoweredOffVms = false) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 562
def powerDownHostToStandBy_Task(hMor, timeoutSec = 0, evacuatePoweredOffVms = false)
  response = invoke("n1:PowerDownHostToStandBy_Task") do |message|
    message.add "n1:_this", hMor do |i|
      i.set_attr "type", hMor.vimType
    end
    message.add "n1:timeoutSec", timeoutSec.to_s
    message.add "n1:evacuatePoweredOffVms", evacuatePoweredOffVms.to_s
  end
  (parse_response(response, 'PowerDownHostToStandBy_TaskResponse'))['returnval']
end
powerOffVM_Task(vmMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 573
def powerOffVM_Task(vmMor)
  response = invoke("n1:PowerOffVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'PowerOffVM_TaskResponse')['returnval'])
end
powerOnVM_Task(vmMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 582
def powerOnVM_Task(vmMor)
  response = invoke("n1:PowerOnVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'PowerOnVM_TaskResponse')['returnval'])
end
powerUpHostFromStandBy_Task(hMor, timeoutSec = 0) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 591
def powerUpHostFromStandBy_Task(hMor, timeoutSec = 0)
  response = invoke("n1:PowerUpHostFromStandBy_Task") do |message|
    message.add "n1:_this", hMor do |i|
      i.set_attr "type", hMor.vimType
    end
    message.add "n1:timeoutSec", timeoutSec.to_s
  end
  (parse_response(response, 'PowerUpHostFromStandBy_TaskResponse'))['returnval']
end
queryAvailablePerfMetric(perfManager, entity, beginTime = nil, endTime = nil, intervalId = nil) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 601
def queryAvailablePerfMetric(perfManager, entity, beginTime = nil, endTime = nil, intervalId = nil)
  response = invoke("n1:QueryAvailablePerfMetric") do |message|
    message.add "n1:_this", perfManager do |i|
      i.set_attr "type", perfManager.vimType
    end
    message.add "n1:entity", entity do |i|
      i.set_attr "type", entity.vimType
    end
    message.add "n1:beginTime", beginTime.to_s  if beginTime
    message.add "n1:endTime", endTime.to_s    if endTime
    message.add "n1:intervalId", intervalId   if intervalId
  end
  (parse_response(response, 'QueryAvailablePerfMetricResponse')['returnval'])
end
queryDescriptions(diagnosticManager, entity) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 616
def queryDescriptions(diagnosticManager, entity)
  response = invoke("n1:QueryDescriptions") do |message|
    message.add "n1:_this", diagnosticManager do |i|
      i.set_attr "type", diagnosticManager.vimType
    end
    message.add "n1:host", entity do |i|
      i.set_attr "type", entity.vimType
    end if entity
  end
  (parse_response(response, 'QueryDescriptionsResponse')['returnval'])
end
queryDvsConfigTarget(dvsManager, hmor, _dvs) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 628
def queryDvsConfigTarget(dvsManager, hmor, _dvs)
  response = invoke("n1:QueryDvsConfigTarget") do |message|
    message.add "n1:_this", dvsManager do |i|
      i.set_attr "type", dvsManager.vimType
    end
    message.add "n1:host", hmor do |i|
      i.set_attr "type", hmor.vimType
    end if hmor
  end
  (parse_response(response, 'QueryDvsConfigTargetResponse')['returnval'])
  # TODO: dvs
end
queryNetConfig(vnmMor, nicType) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 641
def queryNetConfig(vnmMor, nicType)
  response = invoke("n1:QueryNetConfig") do |message|
    message.add "n1:_this", vnmMor do |i|
      i.set_attr "type", vnmMor.vimType
    end
    message.add "n1:nicType", nicType
  end
  (parse_response(response, 'QueryNetConfigResponse')['returnval'])
end
queryOptions(omMor, name) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 651
def queryOptions(omMor, name)
  response = invoke("n1:QueryOptions") do |message|
    message.add "n1:_this", omMor do |i|
      i.set_attr "type", omMor.vimType
    end
    message.add "n1:name", name
  end
  (parse_response(response, 'QueryOptionsResponse')['returnval'])
end
queryPerf(perfManager, querySpec) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 661
def queryPerf(perfManager, querySpec)
  response = invoke("n1:QueryPerf") do |message|
    message.add "n1:_this", perfManager do |i|
      i.set_attr "type", perfManager.vimType
    end
    if querySpec.kind_of?(Array)
      querySpec.each do |qs|
        message.add "n1:querySpec" do |i|
          i.set_attr "xsi:type", qs.xsiType
          marshalObj(i, qs)
        end
      end
    else
      message.add "n1:querySpec" do |i|
        i.set_attr "xsi:type", querySpec.xsiType
        marshalObj(i, querySpec)
      end
    end
  end
  (parse_response(response, 'QueryPerfResponse')['returnval'])
end
queryPerfComposite(perfManager, querySpec) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 683
def queryPerfComposite(perfManager, querySpec)
  response = invoke("n1:QueryPerfComposite") do |message|
    message.add "n1:_this", perfManager do |i|
      i.set_attr "type", perfManager.vimType
    end
    message.add "n1:querySpec" do |i|
      i.set_attr "xsi:type", querySpec.xsiType
      marshalObj(i, querySpec)
    end
  end
  (parse_response(response, 'QueryPerfCompositeResponse')['returnval'])
end
queryPerfProviderSummary(perfManager, entity) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 696
def queryPerfProviderSummary(perfManager, entity)
  response = invoke("n1:QueryPerfProviderSummary") do |message|
    message.add "n1:_this", perfManager do |i|
      i.set_attr "type", perfManager.vimType
    end
    message.add "n1:entity", entity do |i|
      i.set_attr "type", entity.vimType
    end
  end
  (parse_response(response, 'QueryPerfProviderSummaryResponse')['returnval'])
end
readNextEvents(ehcMor, maxCount) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 708
def readNextEvents(ehcMor, maxCount)
  response = invoke("n1:ReadNextEvents") do |message|
    message.add "n1:_this", ehcMor do |i|
      i.set_attr "type", ehcMor.vimType
    end
    message.add "n1:maxCount", maxCount
  end
  (parse_response(response, 'ReadNextEventsResponse')['returnval'])
end
readPreviousEvents(ehcMor, maxCount) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 718
def readPreviousEvents(ehcMor, maxCount)
  response = invoke("n1:ReadPreviousEvents") do |message|
    message.add "n1:_this", ehcMor do |i|
      i.set_attr "type", ehcMor.vimType
    end
    message.add "n1:maxCount", maxCount
  end
  (parse_response(response, 'ReadPreviousEventsResponse')['returnval'])
end
rebootGuest(vmMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 728
def rebootGuest(vmMor)
  response = invoke("n1:RebootGuest") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'RebootGuestResponse'))
end
rebootHost_Task(hMor, force = false) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 737
def rebootHost_Task(hMor, force = false)
  response = invoke("n1:RebootHost_Task") do |message|
    message.add "n1:_this", hMor do |i|
      i.set_attr "type", hMor.vimType
    end
    message.add "n1:force", force.to_s
  end
  (parse_response(response, 'RebootHost_TaskResponse'))['returnval']
end
reconfigVM_Task(vmMor, vmConfigSpec) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 760
def reconfigVM_Task(vmMor, vmConfigSpec)
  response = invoke("n1:ReconfigVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", vmConfigSpec.xsiType
      marshalObj(i, vmConfigSpec)
    end
  end
  (parse_response(response, 'ReconfigVM_TaskResponse')['returnval'])
end
reconfigureAlarm(aMor, aSpec) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 747
def reconfigureAlarm(aMor, aSpec)
  response = invoke("n1:ReconfigureAlarm") do |message|
    message.add "n1:_this", aMor do |i|
      i.set_attr "type", aMor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", aSpec.xsiType
      marshalObj(i, aSpec)
    end
  end
  (parse_response(response, 'ReconfigureAlarmResponse'))
end
refreshFirewall(fwsMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 773
def refreshFirewall(fwsMor)
  response = invoke("n1:RefreshFirewall") do |message|
    message.add "n1:_this", fwsMor do |i|
      i.set_attr "type", fwsMor.vimType
    end
  end
  (parse_response(response, 'RefreshFirewallResponse'))
end
refreshNetworkSystem(nsMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 782
def refreshNetworkSystem(nsMor)
  response = invoke("n1:RefreshNetworkSystem") do |message|
    message.add "n1:_this", nsMor do |i|
      i.set_attr "type", nsMor.vimType
    end
  end
  (parse_response(response, 'RefreshNetworkSystemResponse'))
end
refreshServices(ssMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 791
def refreshServices(ssMor)
  response = invoke("n1:RefreshServices") do |message|
    message.add "n1:_this", ssMor do |i|
      i.set_attr "type", ssMor.vimType
    end
  end
  (parse_response(response, 'RefreshServicesResponse'))
end
registerVM_Task(fMor, path, name, asTemplate, pmor, hmor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 800
def registerVM_Task(fMor, path, name, asTemplate, pmor, hmor)
  response = invoke("n1:RegisterVM_Task") do |message|
    message.add "n1:_this", fMor do |i|
      i.set_attr "type", fMor.vimType
    end
    message.add "n1:path", path
    message.add "n1:name", name if name
    message.add "n1:asTemplate", asTemplate
    message.add "n1:pool", pmor do |i|
      i.set_attr "type", pmor.vimType
    end if pmor
    message.add "n1:host", hmor do |i|
      i.set_attr "type", hmor.vimType
    end if hmor
  end
  (parse_response(response, 'RegisterVM_TaskResponse')['returnval'])
end
relocateVM_Task(vmMor, cspec, priority = "defaultPriority") click to toggle source
# File lib/VMwareWebService/VimService.rb, line 548
def relocateVM_Task(vmMor, cspec, priority = "defaultPriority")
  response = invoke("n1:RelocateVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
    message.add "n1:spec" do |i|
      i.set_attr "xsi:type", cspec.xsiType
      marshalObj(i, cspec)
    end
    message.add "n1:priority", priority
  end
  (parse_response(response, 'RelocateVM_TaskResponse')['returnval'])
end
removeAlarm(aMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 818
def removeAlarm(aMor)
  response = invoke("n1:RemoveAlarm") do |message|
    message.add "n1:_this", aMor do |i|
      i.set_attr "type", aMor.vimType
    end
  end
  (parse_response(response, 'RemoveAlarmResponse'))
end
removeAllSnapshots_Task(vmMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 827
def removeAllSnapshots_Task(vmMor)
  response = invoke("n1:RemoveAllSnapshots_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'RemoveAllSnapshots_TaskResponse')['returnval'])
end
removeSnapshot_Task(snMor, subTree) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 836
def removeSnapshot_Task(snMor, subTree)
  response = invoke("n1:RemoveSnapshot_Task") do |message|
    message.add "n1:_this", snMor do |i|
      i.set_attr "type", snMor.vimType
    end
    message.add "n1:removeChildren", subTree
  end
  (parse_response(response, 'RemoveSnapshot_TaskResponse')['returnval'])
end
renameSnapshot(snMor, name, desc) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 856
def renameSnapshot(snMor, name, desc)
  response = invoke("n1:RenameSnapshot") do |message|
    message.add "n1:_this", snMor do |i|
      i.set_attr "type", snMor.vimType
    end
    message.add "n1:name", name if name
    message.add "n1:description", desc if desc
  end
  (parse_response(response, 'RenameSnapshotResponse'))
end
rename_Task(vmMor, newName) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 846
def rename_Task(vmMor, newName)
  response = invoke("n1:Rename_Task") do |message|
    message.add("n1:_this", vmMor) do |i|
      i.set_attr("type", vmMor.vimType)
    end
    message.add("n1:newName", newName)
  end
  parse_response(response, 'Rename_TaskResponse')['returnval']
end
resetCollector(collectorMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 867
def resetCollector(collectorMor)
  response = invoke("n1:ResetCollector") do |message|
    message.add "n1:_this", collectorMor do |i|
      i.set_attr "type", collectorMor.vimType
    end
  end
  (parse_response(response, 'ResetCollectorResponse'))
end
resetVM_Task(vmMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 876
def resetVM_Task(vmMor)
  response = invoke("n1:ResetVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'ResetVM_TaskResponse')['returnval'])
end
restartService(ssMor, skey) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 885
def restartService(ssMor, skey)
  response = invoke("n1:RestartService") do |message|
    message.add "n1:_this", ssMor do |i|
      i.set_attr "type", ssMor.vimType
    end
    message.add "n1:id", skey
  end
  (parse_response(response, 'RestartServiceResponse'))
end
retrieveProperties(propCol, specSet) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 895
def retrieveProperties(propCol, specSet)
  response = invoke("n1:RetrieveProperties") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end
    message.add "n1:specSet" do |i|
      i.set_attr "xsi:type", "PropertyFilterSpec"
      marshalObj(i, specSet)
    end
  end
  (parse_response(response, 'RetrievePropertiesResponse')['returnval'])
end
retrievePropertiesCompat(propCol, specSet, max_objects = nil) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 950
def retrievePropertiesCompat(propCol, specSet, max_objects = nil)
  objects = VimArray.new('ArrayOfObjectContent')

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

  objects
end
retrievePropertiesEx(propCol, specSet, max_objects = nil) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 908
def retrievePropertiesEx(propCol, specSet, max_objects = nil)
  options = VimHash.new("RetrieveOptions") do |opts|
    opts.maxObjects = max_objects.to_s if max_objects
  end

  response = invoke("n1:RetrievePropertiesEx") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end
    message.add "n1:specSet" do |i|
      i.set_attr "xsi:type", "PropertyFilterSpec"
      marshalObj(i, specSet)
    end
    message.add "n1:options" do |i|
      i.set_attr "xsi:type", "RetrieveOptions"
      marshalObj(i, options)
    end
  end
  (parse_response(response, 'RetrievePropertiesExResponse')['returnval'])
end
retrievePropertiesIter(propCol, specSet, max_objects = nil) { |oc| ... } click to toggle source
# File lib/VMwareWebService/VimService.rb, line 929
def retrievePropertiesIter(propCol, specSet, max_objects = nil)
  result = retrievePropertiesEx(propCol, specSet, max_objects)

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

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

    # there is more than one page of result so continue getting the rest
    result = continueRetrievePropertiesEx(propCol, result['token'])
  end
end
retrieveServiceContent() click to toggle source
# File lib/VMwareWebService/VimService.rb, line 958
def retrieveServiceContent
  response = invoke("n1:RetrieveServiceContent") do |message|
    message.add "n1:_this", @serviceInstanceMor do |i|
      i.set_attr "type", @serviceInstanceMor.vimType
    end
  end
  @session_cookie ||= response.cookie
  (parse_response(response, 'RetrieveServiceContentResponse')['returnval'])
end
revertToCurrentSnapshot_Task(vmMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 968
def revertToCurrentSnapshot_Task(vmMor)
  response = invoke("n1:RevertToCurrentSnapshot_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'RevertToCurrentSnapshot_TaskResponse')['returnval'])
end
revertToSnapshot_Task(snMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 977
def revertToSnapshot_Task(snMor)
  response = invoke("n1:RevertToSnapshot_Task") do |message|
    message.add "n1:_this", snMor do |i|
      i.set_attr "type", snMor.vimType
    end
  end
  (parse_response(response, 'RevertToSnapshot_TaskResponse')['returnval'])
end
rewindCollector(collectorMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 986
def rewindCollector(collectorMor)
  response = invoke("n1:RewindCollector") do |message|
    message.add "n1:_this", collectorMor do |i|
      i.set_attr "type", collectorMor.vimType
    end
  end
  (parse_response(response, 'RewindCollectorResponse'))
end
searchDatastoreSubFolders_Task(browserMor, dsPath, searchSpec) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1009
def searchDatastoreSubFolders_Task(browserMor, dsPath, searchSpec)
  response = invoke("n1:SearchDatastoreSubFolders_Task") do |message|
    message.add "n1:_this", browserMor do |i|
      i.set_attr "type", browserMor.vimType
    end
    message.add "n1:datastorePath", dsPath
    message.add "n1:searchSpec" do |i|
      i.set_attr "xsi:type", searchSpec.xsiType
      marshalObj(i, searchSpec)
    end if searchSpec
  end
  (parse_response(response, 'SearchDatastoreSubFolders_TaskResponse')['returnval'])
end
searchDatastore_Task(browserMor, dsPath, searchSpec) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 995
def searchDatastore_Task(browserMor, dsPath, searchSpec)
  response = invoke("n1:SearchDatastore_Task") do |message|
    message.add "n1:_this", browserMor do |i|
      i.set_attr "type", browserMor.vimType
    end
    message.add "n1:datastorePath", dsPath
    message.add "n1:searchSpec" do |i|
      i.set_attr "xsi:type", searchSpec.xsiType
      marshalObj(i, searchSpec)
    end if searchSpec
  end
  (parse_response(response, 'SearchDatastore_TaskResponse')['returnval'])
end
selectVnicForNicType(vnmMor, nicType, device) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1023
def selectVnicForNicType(vnmMor, nicType, device)
  response = invoke("n1:SelectVnicForNicType") do |message|
    message.add "n1:_this", vnmMor do |i|
      i.set_attr "type", vnmMor.vimType
    end
    message.add "n1:nicType", nicType
    message.add "n1:device", device
  end
  (parse_response(response, 'SelectVnicForNicTypeResponse'))
end
setCollectorPageSize(collector, maxCount) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1034
def setCollectorPageSize(collector, maxCount)
  response = invoke("n1:SetCollectorPageSize") do |message|
    message.add "n1:_this", collector do |i|
      i.set_attr "type", collector.vimType
    end
    message.add "n1:maxCount", maxCount
  end
  (parse_response(response, 'SetCollectorPageSizeResponse'))
end
setField(cfManager, mor, key, value) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1044
def setField(cfManager, mor, key, value)
  response = invoke("n1:SetField") do |message|
    message.add "n1:_this", cfManager do |i|
      i.set_attr "type", cfManager.vimType
    end
    message.add "n1:entity", mor do |i|
      i.set_attr "type", mor.vimType
    end
    message.add "n1:key", key
    message.add "n1:value", value
  end
  (parse_response(response, 'SetFieldResponse'))
end
setTaskDescription(tmor, description) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1058
def setTaskDescription(tmor, description)
  response = invoke("n1:SetTaskDescription") do |message|
    message.add "n1:_this", tmor do |i|
      i.set_attr "type", tmor.vimType
    end
    message.add "n1:description" do |i|
      i.set_attr "xsi:type", description.xsiType
      marshalObj(i, description)
    end
  end
  (parse_response(response, 'SetTaskDescriptionResponse'))
end
setTaskState(tmor, state, result = nil, fault = nil) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1071
def setTaskState(tmor, state, result = nil, fault = nil)
  response = invoke("n1:SetTaskState") do |message|
    message.add "n1:_this", tmor do |i|
      i.set_attr "type", tmor.vimType
    end
    message.add "n1:state", state do |i|
      i.set_attr "xsi:type", "TaskInfoState"
    end
    message.add "n1:result" do |i|
      i.set_attr "xsi:type", result.xsiType
      marshalObj(i, result)
    end if result
    message.add "n1:fault" do |i|
      i.set_attr "xsi:type", fault.xsiType
      marshalObj(i, fault)
    end if fault
  end
  (parse_response(response, 'SetTaskStateResponse'))
end
shutdownGuest(vmMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1091
def shutdownGuest(vmMor)
  response = invoke("n1:ShutdownGuest") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'ShutdownGuestResponse'))
end
shutdownHost_Task(hMor, force = false) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1100
def shutdownHost_Task(hMor, force = false)
  response = invoke("n1:ShutdownHost_Task") do |message|
    message.add "n1:_this", hMor do |i|
      i.set_attr "type", hMor.vimType
    end
    message.add "n1:force", force.to_s
  end
  (parse_response(response, 'ShutdownHost_TaskResponse'))['returnval']
end
standbyGuest(vmMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1110
def standbyGuest(vmMor)
  response = invoke("n1:StandbyGuest") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'StandbyGuestResponse'))
end
startService(ssMor, skey) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1119
def startService(ssMor, skey)
  response = invoke("n1:StartService") do |message|
    message.add "n1:_this", ssMor do |i|
      i.set_attr "type", ssMor.vimType
    end
    message.add "n1:id", skey
  end
  (parse_response(response, 'StartServiceResponse'))
end
stopService(ssMor, skey) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1129
def stopService(ssMor, skey)
  response = invoke("n1:StopService") do |message|
    message.add "n1:_this", ssMor do |i|
      i.set_attr "type", ssMor.vimType
    end
    message.add "n1:id", skey
  end
  (parse_response(response, 'StopServiceResponse'))
end
suspendVM_Task(vmMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1139
def suspendVM_Task(vmMor)
  response = invoke("n1:SuspendVM_Task") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'SuspendVM_TaskResponse')['returnval'])
end
uninstallService(ssMor, skey) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1148
def uninstallService(ssMor, skey)
  response = invoke("n1:UninstallService") do |message|
    message.add "n1:_this", ssMor do |i|
      i.set_attr "type", ssMor.vimType
    end
    message.add "n1:id", skey
  end
  (parse_response(response, 'UninstallServiceResponse'))
end
unregisterVM(vmMor) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1158
def unregisterVM(vmMor)
  response = invoke("n1:UnregisterVM") do |message|
    message.add "n1:_this", vmMor do |i|
      i.set_attr "type", vmMor.vimType
    end
  end
  (parse_response(response, 'UnregisterVMResponse'))
end
updateDefaultPolicy(fwsMor, defaultPolicy) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1167
def updateDefaultPolicy(fwsMor, defaultPolicy)
  response = invoke("n1:UpdateDefaultPolicy") do |message|
    message.add "n1:_this", fwsMor do |i|
      i.set_attr "type", fwsMor.vimType
    end
    message.add "n1:defaultPolicy" do |i|
      i.set_attr "xsi:type", defaultPolicy.xsiType
      marshalObj(i, defaultPolicy)
    end
  end
  (parse_response(response, 'UpdateDefaultPolicyResponse'))
end
updateServicePolicy(sMor, skey, policy) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1180
def updateServicePolicy(sMor, skey, policy)
  response = invoke("n1:UpdateServicePolicy") do |message|
    message.add "n1:_this", sMor do |i|
      i.set_attr "type", sMor.vimType
    end
    message.add "n1:id", skey
    message.add "n1:policy", policy
  end
  (parse_response(response, 'UpdateServicePolicyResponse'))
end
updateSoftwareInternetScsiEnabled(hssMor, enabled) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1191
def updateSoftwareInternetScsiEnabled(hssMor, enabled)
  response = invoke("n1:UpdateSoftwareInternetScsiEnabled") do |message|
    message.add "n1:_this", hssMor do |i|
      i.set_attr "type", hssMor.vimType
    end
    message.add "n1:enabled", enabled.to_s
  end
  (parse_response(response, 'UpdateSoftwareInternetScsiEnabledResponse'))
end
waitForUpdates(propCol, version = nil) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1201
def waitForUpdates(propCol, version = nil)
  response = invoke("n1:WaitForUpdates") do |message|
    message.add "n1:_this", propCol do |i|
      i.set_attr "type", propCol.vimType
    end
    message.add "n1:version", version if version
  end
  (parse_response(response, 'WaitForUpdatesResponse')['returnval'])
end
waitForUpdatesEx(propCol, version = nil, options = {}) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1211
def waitForUpdatesEx(propCol, version = nil, options = {})
  max_wait    = options[:max_wait]
  max_objects = options[:max_objects]

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

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

    message.add "n1:version", version if version
    message.add "n1:options" do |i|
      i.set_attr "type", options.vimType
      marshalObj(i, options)
    end
  end
  (parse_response(response, 'WaitForUpdatesExResponse')['returnval'])
end
xmlToCustomizationSpecItem(csmMor, specItemXml) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1234
def xmlToCustomizationSpecItem(csmMor, specItemXml)
  response = invoke("n1:XmlToCustomizationSpecItem") do |message|
    message.add "n1:_this", csmMor do |i|
      i.set_attr "type", csmMor.vimType
    end
    message.add "n1:specItemXml", specItemXml
  end
  (parse_response(response, 'XmlToCustomizationSpecItemResponse')['returnval'])
end

Private Instance Methods

handle_memory_and_gc(response) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1282
def handle_memory_and_gc(response)
  log_prefix = "#{self.class.name}##{__method__}:"

  xml_len = response.instance_variable_get(:@http_body).length

  # At this point we don't need the internal raw XML content since we
  #   have the parsed XML document, so we can free it for the GC.
  response.instance_variable_set(:@http_body, nil)

  @xml_payload_lock.synchronize do
    @xml_payload_len += xml_len

    if @xml_payload_len > @xml_payload_max
      @xml_payload_len = 0

      logger.debug("#{log_prefix} Running garbage collection")

      # Force a GC, because Ruby's GC is triggered on number of objects without
      #   regard to size.  The object we just freed may not be released right away.
      gc_time = Benchmark.realtime { GC.start }

      gc_log_level = gc_time >= 5 ? :warn : :debug
      logger.send(gc_log_level, "#{log_prefix} Garbage collection took #{gc_time} seconds")
    end
  end
end
marshalObj(node, obj) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1254
def marshalObj(node, obj)
  if obj.kind_of? Array
    obj.each do |v|
      marshalObj(node, v)
    end
  elsif obj.kind_of? VimHash
    obj.each_arg do |k, v|
      if v.kind_of? Array
        v.each do |av|
          node.add "n1:#{k}" do |i|
            marshalObj(i, av)
            i.set_attr "xsi:type", "n1:#{av.xsiType}" if av.respond_to?(:xsiType) && av.xsiType
            i.set_attr "type", v.vimType if v.respond_to?(:vimType) && v.vimType
          end
        end
      else
        node.add "n1:#{k}" do |i|
          marshalObj(i, v)
          i.set_attr "type", v.vimType if v.respond_to?(:vimType) && v.vimType
          i.set_attr "xsi:type", "n1:#{v.xsiType}" if v.respond_to?(:xsiType) && v.xsiType
        end
      end
    end
  else
    node.set_value(obj)
  end
end
parse_response(response, rType) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1309
def parse_response(response, rType)
  doc  = response.document
  raise "Response <#{response.inspect}> has no XML document" if doc.nil?

  # Cleanup the raw XML document from the response and kick a GC
  handle_memory_and_gc(response)

  search_path = "//n1:#{rType}"
  node = doc.xpath(search_path, @ns).first
  raise "Node (search=<#{search_path}> namespace=<#{@ns}>) not found in XML document <#{doc.inspect}>" if node.nil?
  ur   = unmarshal_response(node, rType)
  # puts
  # puts "***** #{rType}"
  # dumpObj(ur)
  # puts
  (ur)
end
setNameSpace(ns) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1246
def setNameSpace(ns)
  @ns = {'n1' => ns}
  on_create_document do |doc|
    doc.alias 'n1', ns
    doc.find("Envelope").set_attr "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"
  end
end
unmarshal_response(node, vType = nil) click to toggle source
# File lib/VMwareWebService/VimService.rb, line 1327
def unmarshal_response(node, vType = nil)
  return(node.text) if node.text?

  vimType = node.attribute_with_ns('type', nil)
  vimType = vimType.value if vimType
  xsiType = node.attribute_with_ns('type', 'http://www.w3.org/2001/XMLSchema-instance')
  xsiType = xsiType.value if xsiType
  xsiType ||= vType.to_s

  if node.children.length == 1 && (c = node.child) && c.text?
    return VimString.new(c.text, vimType, xsiType)
  end
  if xsiType == "SOAP::SOAPString"
    return VimString.new("", vimType, xsiType)
  end

  if xsiType =~ /^ArrayOf(.*)$/
    nextType = $1
    obj = VimArray.new(xsiType)
    node.children.each do |child|
      next if child.blank?
      obj << unmarshal_response(child, nextType)
    end
    return(obj)
  end

  aih = VimMappingRegistry.argInfoMap(xsiType)
  obj = VimHash.new(xsiType)

  node.children.each do |child|
    next if child.blank?
    name = child.name.freeze

    ai = aih[name] if aih

    unless (v = obj[name])
      v = obj[name] = VimArray.new("ArrayOf#{ai[:type]}") if ai && ai[:isArray]
    end

    nextType = (ai ? ai[:type] : nil)

    if v.kind_of?(Array)
      obj[name] << unmarshal_response(child, nextType)
    else
      obj[name] = unmarshal_response(child, nextType)
    end
  end
  (obj)
end