class XenApi

# File xenapi.rb, line 32
def initialize(server_path, server_port = 443, use_ssl = true, username = 'root', password)
  # This is where the connection is made
  # https://stelfox.net/blog/2012/02/rubys-xmlrpc-client-and-ssl/
  connection_param = {
    host: server_path,
    port: server_port,
    use_ssl: use_ssl,
    path: '/'
  }
  @connect = XMLRPC::Client.new_from_hash(connection_param)
  # This is the SSL Check Bypassing Mechanism
  @connect.http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless use_ssl == false
  @session = @connect.call('session.login_with_password', username, password)['Value']
end

# File xenapi.rb, line 58
def logout
  session_logout
end

# File xenapi.rb, line 1010
def network_add_tag(network_uuid, tag)
  network_opaqueref = network_get_ref(network_uuid)
  network_opaqueref.key?('Value') ? @connect.call('network.add_tags', @session, network_opaqueref['Value'], tag) : network_opaqueref
end

# File xenapi.rb, line 987
def network_create(name)
  vbd_object = {
    name_label: name,
    MTU: 1500,
    other_config: {}
  }
  result = @connect.call('network.create', @session, vbd_object)
  result['Value'] = network_get_uuid(result['Value'])['Value']
  result
end

# File xenapi.rb, line 1001
def network_destroy(network_uuid)
  network_opaqueref = network_get_ref(network_uuid)
  network_opaqueref.key?('Value') ? @connect.call('network.destroy', @session, network_opaqueref['Value']) : network_opaqueref
end

# File xenapi.rb, line 979
def network_get_detail(network_uuid)
  network_opaqueref = network_get_ref(network_uuid)
  network_opaqueref.key?('Value') ? @connect.call('network.get_record', @session, network_opaqueref['Value']) : network_opaqueref
end

# File xenapi.rb, line 1054
def network_get_ref(network_uuid)
  @connect.call('network.get_by_uuid', @session, network_uuid)
end

# File xenapi.rb, line 1027
def network_get_tags(network_uuid)
  network_opaqueref = network_get_ref(network_uuid)
  network_opaqueref.key?('Value') ? @connect.call('network.get_tags', @session, network_opaqueref['Value']) : network_opaqueref
end

# File xenapi.rb, line 1048
def network_get_uuid(network_opaqueref)
  @connect.call('network.get_uuid', @session, network_opaqueref)
end

# File xenapi.rb, line 969
def network_list
  result = @connect.call('network.get_all', @session)
  result['Value'].map! do |ref|
    network_get_uuid(ref)['Value']
  end
  result
end

# File xenapi.rb, line 1019
def network_rm_tag(network_uuid, tag)
  network_opaqueref = network_get_ref(network_uuid)
  network_opaqueref.key?('Value') ? @connect.call('network.remove_tags', @session, network_opaqueref['Value'], tag) : network_opaqueref
end

# File xenapi.rb, line 1035
def network_search_by_tag(tag)
  networks = network_list['Value']
  networks.select! do |network_opaqueref|
    network_get_tags(network_opaqueref)['Value'].include?(tag)
  end
  networks.map! do |ref|
    network_get_uuid(ref)['Value']
  end
  Messages.success_nodesc_with_payload(networks)
end

# File xenapi.rb, line 50
def session_logout
  @connect.call('session.logout', @session)
end

# File xenapi.rb, line 1109
def sr_add_tag(sr_uuid, tag)
  sr_opaqueref = sr_get_ref(sr_uuid)
  sr_opaqueref.key?('Value') ? @connect.call('VDI.add_tags', @session, vdi_get_ref(vdi_uuid)['Value'], tag) : sr_opaqueref
end

# File xenapi.rb, line 1126
def sr_get_default
  default_pool = @connect.call('pool.get_all', @session)
  default_sr = @connect.call('pool.get_default_SR', @session, default_pool['Value'][0]) if default_pool['Status'] == 'Success'
  res_hash = { 'UUID' => sr_get_uuid(default_sr['Value'])['Value'], 'REF' => default_sr['Value'] }
  Messages.success_nodesc_with_payload(res_hash)
end

# File xenapi.rb, line 1086
def sr_get_record(sr_uuid)
  sr_opaqueref = sr_get_ref(sr_uuid)
  sr_opaqueref.key?('Value') ? @connect.call('SR.get_record', @session, sr_opaqueref['Value']) : sr_opaqueref
end

# File xenapi.rb, line 1167
def sr_get_ref(sr_uuid)
  @connect.call('SR.get_by_uuid', @session, sr_uuid)
end

# File xenapi.rb, line 1139
def sr_get_tags(sr_uuid)
  sr_opaqueref = sr_get_ref(sr_uuid)
  sr_opaqueref.key?('Value') ? @connect.call('SR.get_tags', @session, vdi_get_ref(vdi_uuid)['Value']) : sr_opaqueref
end

# File xenapi.rb, line 1093
def sr_get_type(sr_uuid)
  sr_opaqueref = sr_get_ref(sr_uuid)
  sr_opaqueref.key?('Value') ? @connect.call('SR.get_type', @session, sr_opaqueref['Value']) : sr_opaqueref
end

# File xenapi.rb, line 1100
def sr_get_type2(sr_opaqueref)
  @connect.call('SR.get_type', @session, sr_opaqueref)
end

# File xenapi.rb, line 1161
def sr_get_uuid(sr_opaqueref)
  @connect.call('SR.get_uuid', @session, sr_opaqueref)
end

# File xenapi.rb, line 1066
def sr_list(iso_sr, uuid_mode)
  all_sr = @connect.call('SR.get_all', @session)
  if iso_sr == 'exclude'
    all_sr['Value'].select! do |opaqueref|
      check_sr_is_vdisr_by_ref(opaqueref) if iso_sr == 'exclude'
      check_sr_is_iso(opaqueref) if iso_sr == 'only'
      true if iso_sr == 'include'
    end
  end
  if uuid_mode == true
    all_sr['Value'].map! do |ref|
      sr_get_uuid(ref)['Value']
    end
  end
  all_sr
end

# File xenapi.rb, line 1119
def sr_rm_tag(sr_uuid, tag)
  sr_opaqueref = sr_get_ref(sr_uuid)
  sr_opaqueref.key?('Value') ? @connect.call('SR.remove_tags', @session, vdi_get_ref(vdi_uuid)['Value'], tag) : sr_opaqueref
end

# File xenapi.rb, line 1148
def sr_search_by_tag(tag)
  all_sr = sr_list('include', false)['Value']
  result = all_sr.select do |sr_ref|
    sr_get_tags(sr_ref)['Value'].include?(tag)
  end
  result.map! do |ref|
    vdi_get_uuid(ref)['Value']
  end
  Messages.success_nodesc_with_payload(result)
end

# File xenapi.rb, line 623
def task_cancel(task_opaqueref)
  @connect.call('task.cancel', @session, task_opaqueref)
end

# File xenapi.rb, line 615
def task_destroy(task_opaqueref)
  @connect.call('task.destroy', @session, task_opaqueref)
end

# File xenapi.rb, line 607
def task_get_error(task_opaqueref)
  @connect.call('task.get_error_info', @session, task_opaqueref)
end

# File xenapi.rb, line 583
def task_get_record(task_opaqueref)
  @connect.call('task.get_record', @session, task_opaqueref)
end

# File xenapi.rb, line 599
def task_get_result(task_opaqueref)
  @connect.call('task.get_result', @session, task_opaqueref)
end

# File xenapi.rb, line 591
def task_get_status(task_opaqueref)
  @connect.call('task.get_status', @session, task_opaqueref)
end

# File xenapi.rb, line 575
def task_list_all_records
  @connect.call('task.get_all_records', @session)
end

# File xenapi.rb, line 846
def vbd_create(vm_uuid, vdi_uuid, device_slot)
  if check_vm_entity_validity(vm_uuid) || check_vdi_entity_validity(vdi_uuid)
    Messages.error_not_permitted
  else
    vbd_object = {
      VM: vm_get_ref(vm_uuid)['Value'],
      VDI: vdi_get_ref(vdi_uuid)['Value'],
      userdevice: device_slot,
      bootable: false,
      mode: 'RW',
      type: 'Disk',
      empty: false,
      qos_algorithm_type: '',
      qos_algorithm_params: {}
    }
    result = @connect.call('VBD.create', @session, vbd_object)
    result['Value'] = vbd_get_uuid(result['Value'])['Value']
    result
  end
end

# File xenapi.rb, line 829
def vbd_get_detail(vbd_opaqueref)
  @connect.call('VBD.get_record', @session, vbd_opaqueref)
end

# File xenapi.rb, line 835
def vbd_get_detail2(vbd_uuid)
  vbd_opaqueref = vbd_get_ref(vbd_uuid)
  vbd_opaqueref.key?('Value') ? @connect.call('VBD.get_record', @session, vbd_opaqueref['Value']) : vbd_opaqueref
end

# File xenapi.rb, line 875
def vbd_get_ref(vbd_uuid)
  @connect.call('VBD.get_by_uuid', @session, vbd_uuid)
end

# File xenapi.rb, line 869
def vbd_get_uuid(vbd_opaqueref)
  @connect.call('VBD.get_uuid', @session, vbd_opaqueref)
end

# File xenapi.rb, line 819
def vbd_list
  result = @connect.call('VBD.get_all', @session)
  result['Value'].map! do |ref|
    vbd_get_uuid(ref)['Value']
  end
  result
end

# File xenapi.rb, line 747
def vdi_add_tag(vdi_uuid, tag)
  if check_vdi_entity_validity(vdi_uuid)
    Messages.error_not_permitted
  else
    @connect.call('VDI.add_tags', @session, vdi_get_ref(vdi_uuid)['Value'], tag)
  end
end

# File xenapi.rb, line 724
def vdi_destroy(vdi_uuid)
  if check_vdi_entity_validity(vdi_uuid)
    Messages.error_not_permitted
  else
    vdi_task_token = @connect.call('Async.VDI.destroy', @session, vdi_get_ref(vdi_uuid)['Value'])
    async_task_manager(vdi_task_token, false)
  end
end

# File xenapi.rb, line 737
def vdi_destroy2(vdi_opaqueref)
  vdi_task_token = @connect.call('Async.VDI.destroy', @session, vdi_opaqueref)
  async_task_manager(vdi_task_token, false)
end

# File xenapi.rb, line 687
def vdi_get_record(vdi_uuid)
  if check_vdi_entity_validity(vdi_uuid)
    Messages.error_not_permitted
  else
    vdi_opaqueref = vdi_get_ref(vdi_uuid)['Value']
    record = @connect.call('VDI.get_record', @session, vdi_opaqueref)
    begin
      record['Value']['snapshot_time'] = record['Value']['snapshot_time'].to_time.to_s
    rescue NoMethodError
      true
    end
    record
  end
end

# File xenapi.rb, line 807
def vdi_get_ref(vbd_uuid)
  @connect.call('VDI.get_by_uuid', @session, vbd_uuid)
end

# File xenapi.rb, line 775
def vdi_get_tags(vdi_uuid)
  if check_vdi_entity_validity(vdi_uuid)
    Messages.error_not_permitted
  else
    @connect.call('VDI.get_tags', @session, vdi_get_ref(vdi_uuid)['Value'])
  end
end

# File xenapi.rb, line 801
def vdi_get_uuid(vbd_opaqueref)
  @connect.call('VDI.get_uuid', @session, vbd_opaqueref)
end

# File xenapi.rb, line 634
def vdi_list(iso_cd)
  all_records = @connect.call('VDI.get_all', @session)
  # Filter Away Snapshots
  all_records['Value'].select! do |vdi_opaqueref|
    !check_vdi_is_a_snapshot(vdi_opaqueref)
  end
  # Filter Away XS-Tools
  all_records['Value'].select! do |vdi_opaqueref|
    !check_vdi_is_xs_iso(vdi_opaqueref)
  end
  all_records['Value'].select! do |vdi_opaqueref|
    !check_vdi_is_iso(vdi_opaqueref) if iso_cd == 'exclude'
    check_vdi_is_iso(vdi_opaqueref) if iso_cd == 'only'
    true if iso_cd == 'include'
  end
  all_records['Value'].map! do |ref|
    vdi_get_uuid(ref)['Value']
  end
  all_records
end

# File xenapi.rb, line 657
def vdi_list_snapshot
  all_records = @connect.call('VDI.get_all', @session)
  # Filter Away Snapshots
  all_records['Value'].select! do |vdi_opaqueref|
    check_vdi_is_a_snapshot(vdi_opaqueref)
  end
  all_records['Value'].map! do |ref|
    vdi_get_uuid(ref)['Value']
  end
  all_records
end

# File xenapi.rb, line 671
def vdi_list_tools
  all_records = @connect.call('VDI.get_all', @session)
  # Filter Away all butXS-Tools
  all_records['Value'].select! do |vdi_opaqueref|
    check_vdi_is_xs_iso(vdi_opaqueref)
  end
  all_records['Value'].map! do |ref|
    vdi_get_uuid(ref)['Value']
  end
  all_records
end

# File xenapi.rb, line 707
def vdi_resize(vdi_uuid, new_vdi_size)
  if check_vdi_entity_validity(vdi_uuid)
    Messages.error_not_permitted
  else
    begin
      vdi_opaqueref = vdi_get_ref(vdi_uuid)['Value']
      @connect.call('VDI.resize_online', @session, vdi_opaqueref, new_vdi_size)
    rescue RuntimeError
      Messages.error_unsupported
    end
  end
end

# File xenapi.rb, line 760
def vdi_rm_tag(vdi_uuid, tag)
  if check_vdi_entity_validity(vdi_uuid)
    Messages.error_not_permitted
  else
    @connect.call('VDI.remove_tags', @session, vdi_get_ref(vdi_uuid)['Value'], tag)
  end
end

# File xenapi.rb, line 787
def vdi_search_by_tag(tag)
  all_vdi = vdi_list('include')['Value']
  result = all_vdi.select do |vdi_uuid|
    vdi_opaqueref = vdi_get_ref(vdi_uuid)['Value']
    vdi_get_tags(vdi_opaqueref)['Value'].include?(tag)
  end
  result.map! do |ref|
    vdi_get_uuid(ref)['Value']
  end
  Messages.success_nodesc_with_payload(result)
end

# File xenapi.rb, line 906
def vif_create(vm_uuid, net_uuid, slot)
  net_opaqueref = network_get_ref(net_uuid)
  if check_vm_entity_validity(vm_uuid) || net_opaqueref['Status'] != 'Success'
    Messages.error_not_permitted
  else
    vbd_object = {
      device: slot.to_s,
      network: net_opaqueref['Value'],
      VM: vm_get_ref(vm_uuid)['Value'],
      MAC: '',
      MTU: '1500',
      other_config: {},
      qos_algorithm_type: '',
      qos_algorithm_params: {}
    }
    result = @connect.call('VIF.create', @session, vbd_object)
    result.key?('Value') ? result['Value'] = vif_get_uuid(result['Value'])['Value'] : nil
    result
  end
end

# File xenapi.rb, line 930
def vif_destroy(vif_uuid)
  vif_opaqueref = vif_get_ref(vif_uuid)
  vif_opaqueref.key?('Value') ? @connect.call('VIF.destroy', @session, vif_opaqueref['Value']) : vif_opaqueref
end

# File xenapi.rb, line 896
def vif_get_detail(vif_uuid)
  vif_opaqueref = vif_get_ref(vif_uuid)
  vif_opaqueref.key?('Value') ? @connect.call('VIF.get_record', @session, vif_opaqueref['Value']) : vif_opaqueref
end

# File xenapi.rb, line 959
def vif_get_ref(vif_uuid)
  @connect.call('VIF.get_by_uuid', @session, vif_uuid)
end

# File xenapi.rb, line 953
def vif_get_uuid(vif_opaqueref)
  @connect.call('VIF.get_uuid', @session, vif_opaqueref)
end

# File xenapi.rb, line 885
def vif_list
  result = @connect.call('VIF.get_all', @session)
  result['Value'].map! do |ref|
    vif_get_uuid(ref)['Value']
  end
  result
end

# File xenapi.rb, line 938
def vif_plug(vif_uuid)
  vif_opaqueref = vif_get_ref(vif_uuid)
  vif_opaqueref.key?('Value') ? @connect.call('VIF.plug', @session, vif_opaqueref['Value']) : vif_opaqueref
end

# File xenapi.rb, line 946
def vif_unplug(vif_uuid)
  vif_opaqueref = vif_get_ref(vif_uuid)
  vif_opaqueref.key?('Value') ? @connect.call('VIF.unplug', @session, vif_opaqueref['Value']) : vif_opaqueref
end

# File xenapi.rb, line 433
def vm_add_other_config(vm_uuid, key, value)
  vm_opaqueref = vm_get_ref(vm_uuid)
  vm_opaqueref.key?('Value') ? @connect.call('VM.add_to_other_config', @session, vm_opaqueref['Value'], key, value) : vm_opaqueref
end

# File xenapi.rb, line 473
def vm_add_tag(vm_uuid, tag)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    @connect.call('VM.add_tags', @session, vm_opaqueref, tag)
  end
end

# File xenapi.rb, line 328
def vm_clone(old_vm_uuid, new_vm_name)
  if check_vm_entity_validity(old_vm_uuid) || new_vm_name.nil? || new_vm_name == ''
    Messages.error_not_permitted
  else
    old_vm_opaqueref = vm_get_ref(old_vm_uuid)['Value']
    # The NULL Reference is required to fulfill the requirement.
    task_token = @connect.call('Async.VM.copy', @session, old_vm_opaqueref, new_vm_name, 'OpaqueRef:NULL')
    result = async_task_manager(task_token, true)
    if result.key?('Status') && result['Status'] == 'Error'
      result
    else
      Messages.success_nodesc_with_payload(vm_get_uuid(result['value'])['Value'])
    end
  end
end

# File xenapi.rb, line 354
def vm_clone_from_template(vm_tpl_uuid, new_vm_name, pv_boot_param, repo_url, distro, distro_release, network_uuid, dsk_size)
  if check_vm_template_validity(vm_tpl_uuid) || new_vm_name.nil? || new_vm_name == '' || repo_url.start_with?('https://')
    Messages.error_not_permitted
  else
    vm_tpl_opaqueref = vm_get_ref(vm_tpl_uuid)['Value']
    # Step0.1: Copy from template.
    # The NULL Reference is required to fulfill the params requirement.
    default_sr = sr_get_default['Value']
    task_token = @connect.call('Async.VM.copy', @session, vm_tpl_opaqueref, new_vm_name, default_sr['REF'])
    # Step0.2: get new vm reference point
    result = async_task_manager(task_token, true)['value']
    vmuuid = vm_get_uuid(result)['Value']
    disk = '<provision><disk device=\0\ size=\' + dsk_size.to_s + '\ sr=\' + default_sr['UUID'] + '\ bootable=\true\ type=\system\/></provision>'
    vm_set_other_config(vmuuid, 'disks', disk)
    # Step 1 : Set boot paramaters, For configuring the kickstart definition
    @connect.call('VM.provision', @session, result)
    @connect.call('VM.set_PV_args', @session, result, pv_boot_param)
    # Step 2 : Set repository URL, important for install. Always skip step if previous step has error
    #     2.1: Handling Debian-based
    if distro == 'debianlike' || distro == 'rhlike' || distro == 'sleslike'
      # Set New Value
      s = vm_set_other_config(vmuuid, 'install-repository', repo_url)
      unless s['Status'] != 'Success'
        s = vm_set_other_config(vmuuid, 'debian-release', distro_release) if distro == 'debianlike'
      end
    # Other distro is HVM so we ignore it.
    else
      Messages.error_unsupported
    end
    if s['Status'] == 'Error'
      Messages.error_unknown(s)
    else
      s = vif_create(vmuuid, network_uuid, 0)
      if s['Status'] == 'Error'
        Messages.error_unknown(s)
      else
        # callback the new vm OpaqueRef
        Messages.success_nodesc_with_payload(vm_get_uuid(result)['Value'])
      end
    end
  end
end

# File xenapi.rb, line 401
def vm_destroy(old_vm_uuid)
  if check_vm_entity_validity(old_vm_uuid)
    Messages.error_not_permitted
  else
    old_vm_opaqueref = vm_get_ref(old_vm_uuid)['Value']
    # Get /dev/xvda VDI Reference Code First.
    vbd_sets = vm_get_vbds(old_vm_uuid, false)['Value']
    xvda_id = ''
    vbd_sets.each do |vbd_opaqueref|
      record = vbd_get_detail(vbd_opaqueref)['Value']
      next if record['type'] != 'Disk' || record['device'] != 'xvda'
      xvda_id = record['VDI']
    end
    # Delete VM
    task_token = @connect.call('Async.VM.destroy', @session, old_vm_opaqueref)
    result = async_task_manager(task_token, false)
    if result['Status'] == 'Success'
      # Delete VM OK => Cleanup residue: /dev/xvda VDI
      vdi_destroy2(xvda_id)
    else
      # Prompt Error on Deleting VM
      result
    end
  end
end

# File xenapi.rb, line 173
def vm_get_guest_metrics(vm_uuid)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    ref = @connect.call('VM.get_guest_metrics', @session, vm_opaqueref)['Value']
    dat = @connect.call('VM_guest_metrics.get_record', @session, ref)
    # convert mess stuffs to Human-readable
    begin
      dat['Value']['last_updated'] = dat['last_updated'].to_time.to_s
    rescue NoMethodError
      dat['Value']['last_updated'] = nil
    end
    # Output. return is redundant in Ruby World.
    dat
  end
end

# File xenapi.rb, line 195
def vm_get_guest_metrics_network(vm_uuid)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    ref = @connect.call('VM.get_guest_metrics', @session, vm_opaqueref)['Value']
    @connect.call('VM_guest_metrics.get_networks', @session, ref)
  end
end

# File xenapi.rb, line 147
def vm_get_metrics(vm_uuid)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    ref = @connect.call('VM.get_metrics', @session, vm_opaqueref)['Value']
    dat = @connect.call('VM_metrics.get_record', @session, ref)
    # convert mess stuffs to Human-readable
    begin
      dat['Value']['start_time']   = dat['Value']['last_updated'].to_time.to_s
      dat['Value']['install_time'] = dat['Value']['last_updated'].to_time.to_s
      dat['Value']['last_updated'] = dat['Value']['last_updated'].to_time.to_s
    rescue NoMethodError
      dat['Value']['start_time']   = nil
      dat['Value']['install_time'] = nil
      dat['Value']['last_updated'] = nil
    end
    # Output. return is redundant in Ruby World.
    dat
  end
end

# File xenapi.rb, line 452
def vm_get_other_config(vm_uuid)
  vm_opaqueref = vm_get_ref(vm_uuid)
  vm_opaqueref.key?('Value') ? @connect.call('VM.get_other_config', @session, vm_opaqueref['Value']) : vm_opaqueref
end

# File xenapi.rb, line 102
def vm_get_record(vm_uuid)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    record = @connect.call('VM.get_record', @session, vm_opaqueref)['Value']
    # Post processing
    # 1. Decode Time Object to Human-readable
    begin
      record['snapshot_time'] = record['snapshot_time'].to_time.to_s
    rescue NoMethodError
      true
    end
    # 2. Last Boot Record is JSON, decode to Ruby Hash so that it won't clash
    #    the JSON generator
    record['last_booted_record'] = parse_last_boot_record(record['last_booted_record'])
    # Output. return is redundant in Ruby World.
    Messages.success_nodesc_with_payload(record)
  end
end

# File xenapi.rb, line 564
def vm_get_ref(vm_uuid)
  @connect.call('VM.get_by_uuid', @session, vm_uuid)
end

# File xenapi.rb, line 502
def vm_get_tags(vm_uuid)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    @connect.call('VM.get_tags', @session, vm_opaqueref)
  end
end

# File xenapi.rb, line 127
def vm_get_template_record(vm_uuid)
  if check_vm_template_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    record = @connect.call('VM.get_record', @session, vm_opaqueref)['Value']
    begin
      record['snapshot_time'] = record['snapshot_time'].to_time.to_s
    rescue NoMethodError
      record['snapshot_time'] = nil
    end
    # Output. return is redundant in Ruby World.
    Messages.success_nodesc_with_payload(record)
  end
end

# File xenapi.rb, line 558
def vm_get_uuid(vm_opaqueref)
  @connect.call('VM.get_uuid', @session, vm_opaqueref)
end

# File xenapi.rb, line 210
def vm_get_vbds(vm_uuid, uuid_mode)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    vbds = @connect.call('VM.get_VBDs', @session, vm_opaqueref)
  end
  if uuid_mode == true && vbds['Status'] == 'Success' && vbds['Value'].empty? == false
    vbds['Value'].map! do |ref|
      vbd_get_uuid(ref)['Value']
    end
  end
  vbds
end

# File xenapi.rb, line 230
def vm_get_vifs(vm_uuid, uuid_mode)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    vifs = @connect.call('VM.get_VIFs', @session, vm_opaqueref)
  end
  if uuid_mode == true && vifs['Status'] == 'Success' && vifs['Value'].empty? == false
    vifs['Value'].map! do |ref|
      vif_get_uuid(ref)['Value']
    end
  end
  vifs
end

# File xenapi.rb, line 65
def vm_list_all
  all_records = @connect.call('VM.get_all', @session)
  # Filter Away Control Domain
  all_records['Value'].select! do |vm_opaqueref|
    !check_vm_entity_is_dom0(vm_opaqueref)
  end
  # Filter Away Template
  all_records['Value'].select! do |vm_opaqueref|
    !check_vm_entity_is_template(vm_opaqueref)
  end
  all_records['Value'].map! do |ref|
    vm_get_uuid(ref)['Value']
  end
  all_records
end

# File xenapi.rb, line 83
def vm_list_all_templates
  all_records = @connect.call('VM.get_all', @session)
  # Filter Away non-template (VM Instances + dom0)
  all_records['Value'].select! do |tpl_opaqueref|
    check_vm_entity_is_template(tpl_opaqueref)
  end
  all_records['Value'].select! do |tpl_opaqueref|
    check_vm_entity_is_paravirtual(tpl_opaqueref)
  end
  all_records['Value'].map! do |ref|
    vm_get_uuid(ref)['Value']
  end
  all_records
end

# File xenapi.rb, line 263
def vm_power_off(vm_uuid)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    task_token = @connect.call('Async.VM.shutdown', @session, vm_opaqueref)
    async_task_manager(task_token, false)
  end
end

# File xenapi.rb, line 249
def vm_power_on(vm_uuid)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    task_token = @connect.call('Async.VM.start', @session, vm_opaqueref, false, false)
    async_task_manager(task_token, false)
  end
end

# File xenapi.rb, line 291
def vm_power_pause(vm_uuid)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    # API Manual P116
    # void suspend (session_id s, VM ref vm)
    task_token = @connect.call('Async.VM.suspend', @session, vm_opaqueref)
    async_task_manager(task_token, false)
  end
end

# File xenapi.rb, line 277
def vm_power_reboot(vm_uuid)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    task_token = @connect.call('Async.VM.hard_reboot', @session, vm_opaqueref)
    async_task_manager(task_token, false)
  end
end

# File xenapi.rb, line 307
def vm_power_unpause(vm_uuid)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    # API Manual P116-117
    # void resume (session_id s, VM ref vm, bool start_paused, bool force)
    task_token = @connect.call('Async.VM.resume', @session, vm_opaqueref, false, false)
    async_task_manager(task_token, false)
  end
end

# File xenapi.rb, line 443
def vm_rm_other_config(vm_uuid, key)
  vm_opaqueref = vm_get_ref(vm_uuid)
  vm_opaqueref.key?('Value') ? @connect.call('VM.remove_from_other_config', @session, vm_opaqueref['Value'], key) : vm_opaqueref
end

# File xenapi.rb, line 487
def vm_rm_tag(vm_uuid, tag)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    @connect.call('VM.remove_tags', @session, vm_opaqueref, tag)
  end
end

# File xenapi.rb, line 516
def vm_search_by_tag(tag)
  all_vm = vm_list_all
  all_vm['Value'].select do |vm_uuid|
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    vm_get_tags(vm_opaqueref)['Value'].include?(tag)
  end
end

# File xenapi.rb, line 542
def vm_set_max_ram(vm_uuid, max_size)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    begin
      @connect.call('VM.set_memory_static_max', @session, vm_opaqueref, max_size.to_i)
      @connect.call('VM.set_memory_dynamic_max', @session, vm_opaqueref, max_size.to_i)
    rescue RuntimeError
      Messages.error_unsupported
    end
  end
end

# File xenapi.rb, line 529
def vm_set_name(vm_uuid, vm_name)
  if check_vm_entity_validity(vm_uuid)
    Messages.error_not_permitted
  else
    vm_opaqueref = vm_get_ref(vm_uuid)['Value']
    @connect.call('VM.set_name_label', @session, vm_opaqueref, vm_name)
  end
end

# File xenapi.rb, line 463
def vm_set_other_config(vm_uuid, key, value)
  s = vm_rm_other_config(vm_uuid, key)
  s.key?('Value') ? vm_add_other_config(vm_uuid, key, value) : s
end

# File xenapi.rb, line 1310
def async_task_manager(task_opaqueref, has_payload)
  if task_opaqueref['Status'] != 'Success'
    Messages.error_switch(task_opaqueref['ErrorDescription'][0][0])
  else
    task_status = task_get_status(task_opaqueref['Value'])['Value']
    while task_status == 'pending'
      task_status = task_get_status(task_opaqueref['Value'])['Value']
      sleep(5)
    end
    if task_status == 'success' && has_payload == false
      task_destroy(task_opaqueref['Value'])
      Messages.success_nodesc
    elsif task_status == 'success' && has_payload == true
      result = task_get_result(task_opaqueref['Value'])
      task_destroy(task_opaqueref['Value'])
      result['Value'] = xml_parse(result['Value'])
      result['Value']
    else
      error_info = task_get_error(task_opaqueref['Value'])['Value']
      task_destroy(task_opaqueref['Value'])
      Messages.error_unknown(error_info)
    end
  end
end

# File xenapi.rb, line 1233
def check_sr_is_iso(sr_opaqueref)
  type = sr_get_type2(sr_opaqueref)['Value']
  type != 'iso' ? true : false
end

# File xenapi.rb, line 1240
def check_sr_is_udev(sr_opaqueref)
  type = sr_get_type2(sr_opaqueref)['Value']
  type != 'udev' ? true : false
end

# File xenapi.rb, line 1284
def check_sr_is_vdisr_by_ref(sr_ref)
  if sr_ref.nil? || sr_ref == ''
    false
  else
    !(check_sr_is_iso(sr_ref) && check_sr_is_udev(sr_ref))
  end
end

# File xenapi.rb, line 1294
def check_sr_is_vdisr_by_uuid(sr_uuid)
  if sr_uuid.nil? || sr_uuid == ''
    false
  else
    sr_ref = sr_get_ref(sr_uuid)
    sr_ref.key?('Value') ? !(check_sr_is_iso(sr_ref['Value']) && check_sr_is_udev(sr_ref['Value'])) : false
  end
end

# File xenapi.rb, line 1273
def check_vdi_entity_validity(vdi_uuid)
  if vdi_uuid == '' || vdi_uuid.nil?
    true
  else
    vdi_opaqueref = vdi_get_ref(vdi_uuid)
    vdi_opaqueref['Status'] == 'Success' ? check_vdi_is_a_snapshot(vdi_opaqueref['Value']) || check_vdi_is_xs_iso(vdi_opaqueref['Value']) : true
  end
end

# File xenapi.rb, line 1227
def check_vdi_is_a_snapshot(vdi_opaqueref)
  @connect.call('VDI.get_is_a_snapshot', @session, vdi_opaqueref)['Value']
end

# File xenapi.rb, line 1219
def check_vdi_is_iso(vdi_opaqueref)
  result = @connect.call('VDI.get_allowed_operations', @session, vdi_opaqueref)['Value']
  read_only = @connect.call('VDI.get_read_only', @session, vdi_opaqueref)['Value']
  result.include?('clone') && read_only == false ? false : true
end

# File xenapi.rb, line 1212
def check_vdi_is_xs_iso(vdi_opaqueref)
  @connect.call('VDI.get_is_tools_iso', @session, vdi_opaqueref)['Value']
end

# File xenapi.rb, line 1183
def check_vm_entity_is_dom0(vm_opaqueref)
  @connect.call('VM.get_is_control_domain', @session, vm_opaqueref)['Value']
end

# File xenapi.rb, line 1195
def check_vm_entity_is_nonexist(vm_opaqueref)
  result = @connect.call('VM.get_uuid', @session, vm_opaqueref)['Status']
  result == 'Success' ? false : true
end

# File xenapi.rb, line 1202
def check_vm_entity_is_paravirtual(vm_opaqueref)
  result = @connect.call('VM.get_PV_bootloader', @session, vm_opaqueref)['Value']
  # PV Templates always have pygrub in PV_bootloader field
  # https://wiki.xenproject.org/wiki/XCP_PV_templates_start
  # pygrub will be used after install finished
  result == 'eliloader' ? true : false
end

# File xenapi.rb, line 1189
def check_vm_entity_is_template(vm_opaqueref)
  @connect.call('VM.get_is_a_template', @session, vm_opaqueref)['Value']
end

# File xenapi.rb, line 1251
def check_vm_entity_validity(vm_uuid)
  if vm_uuid == '' || vm_uuid.nil?
    true
  else
    vm_opaqueref = vm_get_ref(vm_uuid)
    vm_opaqueref['Status'] == 'Success' ? check_vm_entity_is_dom0(vm_opaqueref['Value']) || check_vm_entity_is_template(vm_opaqueref['Value']) : true
  end
end

# File xenapi.rb, line 1262
def check_vm_template_validity(vm_tpl_uuid)
  if vm_tpl_uuid == '' || vm_tpl_uuid.nil?
    true
  else
    vm_tpl_opaqueref = vm_get_ref(vm_tpl_uuid)
    vm_tpl_opaqueref['Status'] == 'Success' ? !check_vm_entity_is_template(vm_tpl_opaqueref['Value']) || !check_vm_entity_is_paravirtual(vm_tpl_opaqueref['Value']) : true
  end
end

# File xenapi.rb, line 1364
def number?(string)
  true if Integer(string)
rescue Integer::ArgumentError
  false
end

# File xenapi.rb, line 1339
def parse_last_boot_record(raw_last_boot_record)
  parsed = JSON.parse(raw_last_boot_record)
  # Also need to convert mess stuffs to Human-readable
  begin
    parsed['last_start_time'] = Time.at(parsed['last_start_time']).to_s
  rescue NoMethodError
    parsed['last_start_time'] = ''
  end
  parsed
rescue JSON::ParserError
  # Ruby rescue is catch in other languages
  # Parsing struct is farrrrrrr too difficult
  Messages.error_unsupported
end

# File xenapi.rb, line 1357
def xml_parse(raw_xml)
  xml_parser = Nori.new(convert_tags_to: ->(tag) { tag.snakecase })
  xml_parser.parse(raw_xml)
end