docs: def destroy(name, conn=None, call=None, kwargs=None):
      '''
      Destroy a VM
  
      CLI Examples:
  
      .. code-block:: bash
  
          salt-cloud -d myminion
          salt-cloud -a destroy myminion service_name=myservice
      '''
      if call == 'function':
          raise SaltCloudSystemExit(
              'The destroy action must be called with -d, --destroy, '
              '-a or --action.'
          )
  
      if not conn:
          conn = get_conn()
  
      if kwargs is None:
          kwargs = {}
  
      instance_data = show_instance(name, call='action')
      service_name = instance_data['deployment']['name']
      disk_name = instance_data['role_info']['os_virtual_hard_disk']['disk_name']
  
      ret = {}
      # TODO: Add the ability to delete or not delete a hosted service when
      # deleting a VM
      try:
          log.debug('Deleting role')
          result = conn.delete_role(service_name, service_name, name)
          delete_type = 'delete_role'
      except AzureException:
          log.debug('Failed to delete role, deleting deployment')
          try:
              result = conn.delete_deployment(service_name, service_name)
          except AzureConflictHttpError as exc:
              log.error(exc.message)
              raise SaltCloudSystemExit('{0}: {1}'.format(name, exc.message))
          delete_type = 'delete_deployment'
      _wait_for_async(conn, result.request_id)
      ret[name] = {
          delete_type: {'request_id': result.request_id},
      }
      if __opts__.get('update_cachedir', False) is True:
          __utils__['cloud.delete_minion_cachedir'](name, __active_provider_name__.split(':')[0], __opts__)
  
      cleanup_disks = config.get_cloud_config_value(
          'cleanup_disks',
          get_configured_provider(), __opts__, search_global=False, default=False,
      )
      if cleanup_disks:
          cleanup_vhds = kwargs.get('delete_vhd', config.get_cloud_config_value(
              'cleanup_vhds',
              get_configured_provider(), __opts__, search_global=False, default=False,
          ))
          log.debug('Deleting disk %s', disk_name)
          if cleanup_vhds:
              log.debug('Deleting vhd')
  
          def wait_for_destroy():
              '''
              Wait for the VM to be deleted
              '''
              try:
                  data = delete_disk(kwargs={'name': disk_name, 'delete_vhd': cleanup_vhds}, call='function')
                  return data
              except AzureConflictHttpError:
                  log.debug('Waiting for VM to be destroyed...')
              time.sleep(5)
              return False
  
          data = salt.utils.cloud.wait_for_fun(
              wait_for_destroy,
              timeout=config.get_cloud_config_value(
                  'wait_for_fun_timeout', {}, __opts__, default=15 * 60),
          )
          ret[name]['delete_disk'] = {
              'name': disk_name,
              'delete_vhd': cleanup_vhds,
              'data': data
          }
  
          # Services can't be cleaned up unless disks are too
          cleanup_services = config.get_cloud_config_value(
              'cleanup_services',
              get_configured_provider(), __opts__, search_global=False, default=False
          )
          if cleanup_services:
              log.debug('Deleting service %s', service_name)
  
              def wait_for_disk_delete():
                  '''
                  Wait for the disk to be deleted
                  '''
                  try:
                      data = delete_service(kwargs={'name': service_name}, call='function')
                      return data
                  except AzureConflictHttpError:
                      log.debug('Waiting for disk to be deleted...')
                  time.sleep(5)
                  return False
  
              data = salt.utils.cloud.wait_for_fun(
                  wait_for_disk_delete,
                  timeout=config.get_cloud_config_value(
                      'wait_for_fun_timeout', {}, __opts__, default=15 * 60),
              )
              ret[name]['delete_services'] = {
                  'name': service_name,
                  'data': data
              }
  
      return ret