docs: def eni_present(
          name,
          subnet_id=None,
          subnet_name=None,
          private_ip_address=None,
          description=None,
          groups=None,
          source_dest_check=True,
          allocate_eip=None,
          arecords=None,
          region=None,
          key=None,
          keyid=None,
          profile=None):
      '''
      Ensure the EC2 ENI exists.
  
      .. versionadded:: 2016.3.0
  
      name
          Name tag associated with the ENI.
  
      subnet_id
          The VPC subnet ID the ENI will exist within.
  
      subnet_name
          The VPC subnet name the ENI will exist within.
  
      private_ip_address
          The private ip address to use for this ENI. If this is not specified
          AWS will automatically assign a private IP address to the ENI. Must be
          specified at creation time; will be ignored afterward.
  
      description
          Description of the key.
  
      groups
          A list of security groups to apply to the ENI.
  
      source_dest_check
          Boolean specifying whether source/destination checking is enabled on
          the ENI.
  
      allocate_eip
          allocate and associate an EIP to the ENI. Could be 'standard' to
          allocate Elastic IP to EC2 region or 'vpc' to get it for a
          particular VPC
  
          .. versionchanged:: 2016.11.0
  
      arecords
          A list of arecord dicts with attributes needed for the DNS add_record state.
          By default the boto_route53.add_record state will be used, which requires: name, zone, ttl, and identifier.
          See the boto_route53 state for information about these attributes.
          Other DNS modules can be called by specifying the provider keyword.
          By default, the private ENI IP address will be used, set 'public: True' in the arecord dict to use the ENI's public IP address
  
          .. versionadded:: 2016.3.0
  
      region
          Region to connect to.
  
      key
          Secret key to be used.
  
      keyid
          Access key to be used.
  
      profile
          A dict with region, key and keyid, or a pillar key (string)
          that contains a dict with region, key and keyid.
      '''
      if not salt.utils.data.exactly_one((subnet_id, subnet_name)):
          raise SaltInvocationError('One (but not both) of subnet_id or '
                                    'subnet_name must be provided.')
      if not groups:
          raise SaltInvocationError('groups is a required argument.')
      if not isinstance(groups, list):
          raise SaltInvocationError('groups must be a list.')
      if not isinstance(source_dest_check, bool):
          raise SaltInvocationError('source_dest_check must be a bool.')
      ret = {'name': name, 'result': True, 'comment': '', 'changes': {}}
      r = __salt__['boto_ec2.get_network_interface'](
          name=name, region=region, key=key, keyid=keyid, profile=profile
      )
      if 'error' in r:
          ret['result'] = False
          ret['comment'] = 'Error when attempting to find eni: {0}.'.format(
              r['error']['message']
          )
          return ret
      if not r['result']:
          if __opts__['test']:
              ret['comment'] = 'ENI is set to be created.'
              if allocate_eip:
                  ret['comment'] = ' '.join([ret['comment'], 'An EIP is set to be allocated/assocaited to the ENI.'])
              if arecords:
                  ret['comment'] = ' '.join([ret['comment'], 'A records are set to be created.'])
              ret['result'] = None
              return ret
          result_create = __salt__['boto_ec2.create_network_interface'](
              name, subnet_id=subnet_id, subnet_name=subnet_name, private_ip_address=private_ip_address,
              description=description, groups=groups, region=region, key=key,
              keyid=keyid, profile=profile
          )
          if 'error' in result_create:
              ret['result'] = False
              ret['comment'] = 'Failed to create ENI: {0}'.format(
                  result_create['error']['message']
              )
              return ret
          r['result'] = result_create['result']
          ret['comment'] = 'Created ENI {0}'.format(name)
          ret['changes']['id'] = r['result']['id']
      else:
          _ret = _eni_attribute(
              r['result'], 'description', description, region, key, keyid,
              profile
          )
          ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
          ret['comment'] = _ret['comment']
          if not _ret['result']:
              ret['result'] = _ret['result']
              if ret['result'] is False:
                  return ret
          _ret = _eni_groups(
              r['result'], groups, region, key, keyid, profile
          )
          ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
          ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
          if not _ret['result']:
              ret['result'] = _ret['result']
              if ret['result'] is False:
                  return ret
      # Actions that need to occur whether creating or updating
      _ret = _eni_attribute(
          r['result'], 'source_dest_check', source_dest_check, region, key,
          keyid, profile
      )
      ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
      ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
      if not _ret['result']:
          ret['result'] = _ret['result']
          return ret
      if allocate_eip:
          if 'allocationId' not in r['result']:
              if __opts__['test']:
                  ret['comment'] = ' '.join([ret['comment'], 'An EIP is set to be allocated and assocaited to the ENI.'])
              else:
                  domain = 'vpc' if allocate_eip == 'vpc' else None
                  eip_alloc = __salt__['boto_ec2.allocate_eip_address'](domain=domain,
                                                                        region=region,
                                                                        key=key,
                                                                        keyid=keyid,
                                                                        profile=profile)
                  if eip_alloc:
                      _ret = __salt__['boto_ec2.associate_eip_address'](instance_id=None,
                                                                        instance_name=None,
                                                                        public_ip=None,
                                                                        allocation_id=eip_alloc['allocation_id'],
                                                                        network_interface_id=r['result']['id'],
                                                                        private_ip_address=None,
                                                                        allow_reassociation=False,
                                                                        region=region,
                                                                        key=key,
                                                                        keyid=keyid,
                                                                        profile=profile)
                      if not _ret:
                          _ret = __salt__['boto_ec2.release_eip_address'](public_ip=None,
                                                                          allocation_id=eip_alloc['allocation_id'],
                                                                          region=region,
                                                                          key=key,
                                                                          keyid=keyid,
                                                                          profile=profile)
                          ret['result'] = False
                          msg = 'Failed to assocaite the allocated EIP address with the ENI.  The EIP {0}'.format('was successfully released.' if _ret else 'was NOT RELEASED.')
                          ret['comment'] = ' '.join([ret['comment'], msg])
                          return ret
                  else:
                      ret['result'] = False
                      ret['comment'] = ' '.join([ret['comment'], 'Failed to allocate an EIP address'])
                      return ret
          else:
              ret['comment'] = ' '.join([ret['comment'], 'An EIP is already allocated/assocaited to the ENI'])
      if arecords:
          for arecord in arecords:
              if 'name' not in arecord:
                  msg = 'The arecord must contain a "name" property.'
                  raise SaltInvocationError(msg)
              log.debug('processing arecord %s', arecord)
              _ret = None
              dns_provider = 'boto_route53'
              arecord['record_type'] = 'A'
              public_ip_arecord = False
              if 'public' in arecord:
                  public_ip_arecord = arecord.pop('public')
              if public_ip_arecord:
                  if 'publicIp' in r['result']:
                      arecord['value'] = r['result']['publicIp']
                  elif 'public_ip' in eip_alloc:
                      arecord['value'] = eip_alloc['public_ip']
                  else:
                      msg = 'Unable to add an A record for the public IP address, a public IP address does not seem to be allocated to this ENI.'
                      raise CommandExecutionError(msg)
              else:
                  arecord['value'] = r['result']['private_ip_address']
              if 'provider' in arecord:
                  dns_provider = arecord.pop('provider')
              if dns_provider == 'boto_route53':
                  if 'profile' not in arecord:
                      arecord['profile'] = profile
                  if 'key' not in arecord:
                      arecord['key'] = key
                  if 'keyid' not in arecord:
                      arecord['keyid'] = keyid
                  if 'region' not in arecord:
                      arecord['region'] = region
              _ret = __states__['.'.join([dns_provider, 'present'])](**arecord)
              log.debug('ret from dns_provider.present = %s', _ret)
              ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
              ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
              if not _ret['result']:
                  ret['result'] = _ret['result']
                  if ret['result'] is False:
                      return ret
      return ret