golden hour

/opt/saltstack/salt/lib/python3.10/site-packages/salt/states

File/Folder	Size	Actions
__init__.py	25 B
__pycache__	-
acme.py	5.08 KB
alias.py	2.49 KB
alternatives.py	6.75 KB
ansiblegate.py	7.93 KB
apache.py	3.95 KB
apache_conf.py	2.72 KB
apache_module.py	2.73 KB
apache_site.py	2.66 KB
aptpkg.py	1.42 KB
archive.py	68.24 KB
artifactory.py	6.84 KB
at.py	7.48 KB
augeas.py	10.57 KB
aws_sqs.py	2.59 KB
azurearm_compute.py	11.78 KB
azurearm_dns.py	26.05 KB
azurearm_network.py	89.12 KB
azurearm_resource.py	28.23 KB
beacon.py	7.58 KB
bigip.py	96.63 KB
blockdev.py	5.13 KB
boto3_elasticache.py	48.01 KB
boto3_elasticsearch.py	32.58 KB
boto3_route53.py	37.54 KB
boto3_sns.py	12.69 KB
boto_apigateway.py	82.83 KB
boto_asg.py	31.93 KB
boto_cfn.py	11.53 KB
boto_cloudfront.py	6.01 KB
boto_cloudtrail.py	13.18 KB
boto_cloudwatch_alarm.py	6.4 KB
boto_cloudwatch_event.py	12.33 KB
boto_cognitoidentity.py	13.69 KB
boto_datapipeline.py	18.5 KB
boto_dynamodb.py	29.32 KB
boto_ec2.py	71.98 KB
boto_elasticache.py	16.75 KB
boto_elasticsearch_domain.py	12.27 KB
boto_elb.py	55.1 KB
boto_elbv2.py	12.19 KB
boto_iam.py	69.16 KB
boto_iam_role.py	27.12 KB
boto_iot.py	25.33 KB
boto_kinesis.py	16.69 KB
boto_kms.py	12.11 KB
boto_lambda.py	35.52 KB
boto_lc.py	11.04 KB
boto_rds.py	26 KB
boto_route53.py	19.49 KB
boto_s3.py	9.32 KB
boto_s3_bucket.py	24.67 KB
boto_secgroup.py	32.62 KB
boto_sns.py	8.92 KB
boto_sqs.py	7.97 KB
boto_vpc.py	62.23 KB
bower.py	8.26 KB
btrfs.py	10.34 KB
cabal.py	5.73 KB
ceph.py	1.9 KB
chef.py	3.76 KB
chocolatey.py	16.15 KB
chronos_job.py	4.6 KB
cimc.py	14.32 KB
cisconso.py	3.14 KB
cloud.py	14.4 KB
cmd.py	40.92 KB
composer.py	8.38 KB
consul.py	5.4 KB
cron.py	23.39 KB
cryptdev.py	6.17 KB
csf.py	9.98 KB
cyg.py	7.05 KB
ddns.py	4.2 KB
debconfmod.py	6.33 KB
dellchassis.py	24.49 KB
disk.py	6.49 KB
docker_container.py	85.27 KB
docker_image.py	16.7 KB
docker_network.py	36.78 KB
docker_volume.py	6.72 KB
drac.py	4.17 KB
dvs.py	26.29 KB
elasticsearch.py	20.38 KB
elasticsearch_index.py	3.25 KB
elasticsearch_index_template.py	3.67 KB
environ.py	5.81 KB
eselect.py	2.27 KB
esxcluster.py	22.4 KB
esxdatacenter.py	4.44 KB
esxi.py	63.07 KB
esxvm.py	20.11 KB
etcd_mod.py	11 KB
ethtool.py	9.88 KB
event.py	2.48 KB
file.py	316.7 KB
firewall.py	1.33 KB
firewalld.py	26.08 KB
gem.py	7.13 KB
git.py	123.85 KB
github.py	27.25 KB
glance_image.py	2.26 KB
glassfish.py	21.47 KB
glusterfs.py	12.21 KB
gnomedesktop.py	7.47 KB
gpg.py	5.28 KB
grafana.py	12.11 KB
grafana4_dashboard.py	17.31 KB
grafana4_datasource.py	6.15 KB
grafana4_org.py	7.73 KB
grafana4_user.py	5.52 KB
grafana_dashboard.py	17.74 KB
grafana_datasource.py	5.31 KB
grains.py	15.57 KB
group.py	9.84 KB
heat.py	9.69 KB
helm.py	10.39 KB
hg.py	6.33 KB
highstate_doc.py	1.41 KB
host.py	8.64 KB
http.py	7.46 KB
icinga2.py	9.07 KB
idem.py	3.91 KB
ifttt.py	2.12 KB
incron.py	5.71 KB
influxdb08_database.py	2.85 KB
influxdb08_user.py	3.39 KB
influxdb_continuous_query.py	2.83 KB
influxdb_database.py	2.11 KB
influxdb_retention_policy.py	4.82 KB
influxdb_user.py	4.84 KB
infoblox_a.py	4.24 KB
infoblox_cname.py	4.19 KB
infoblox_host_record.py	6.59 KB
infoblox_range.py	6.85 KB
ini_manage.py	12.67 KB
ipmi.py	8.42 KB
ipset.py	9.66 KB
iptables.py	27.65 KB
jboss7.py	23.95 KB
jenkins.py	3.36 KB
junos.py	17.78 KB
kapacitor.py	6.46 KB
kernelpkg.py	6.42 KB
keyboard.py	2.01 KB
keystone.py	27.12 KB
keystone_domain.py	2.81 KB
keystone_endpoint.py	4.69 KB
keystone_group.py	3.25 KB
keystone_project.py	3.36 KB
keystone_role.py	2.33 KB
keystone_role_grant.py	4.08 KB
keystone_service.py	2.89 KB
keystone_user.py	3.47 KB
keystore.py	5.67 KB
kmod.py	8.59 KB
kubernetes.py	24.87 KB
layman.py	2.44 KB
ldap.py	19.78 KB
libcloud_dns.py	5.7 KB
libcloud_loadbalancer.py	5.66 KB
libcloud_storage.py	5.13 KB
linux_acl.py	24.42 KB
locale.py	2.52 KB
logadm.py	4.67 KB
logrotate.py	3.86 KB
loop.py	7.74 KB
lvm.py	13.33 KB
lvs_server.py	6.28 KB
lvs_service.py	4.38 KB
lxc.py	22.17 KB
lxd.py	7.88 KB
lxd_container.py	22.25 KB
lxd_image.py	10.59 KB
lxd_profile.py	7.11 KB
mac_assistive.py	1.55 KB
mac_keychain.py	5.59 KB
mac_xattr.py	3.15 KB
macdefaults.py	2.65 KB
macpackage.py	6.76 KB
makeconf.py	6.87 KB
marathon_app.py	4.45 KB
mdadm_raid.py	6.41 KB
memcached.py	3.95 KB
modjk.py	2.84 KB
modjk_worker.py	6.49 KB
module.py	18.64 KB
mongodb_database.py	1.65 KB
mongodb_user.py	6.26 KB
monit.py	2.68 KB
mount.py	50.32 KB
mssql_database.py	3 KB
mssql_login.py	3.64 KB
mssql_role.py	2.37 KB
mssql_user.py	3.51 KB
msteams.py	2.53 KB
mysql_database.py	6.05 KB
mysql_grants.py	8.49 KB
mysql_query.py	13.07 KB
mysql_user.py	9.51 KB
net_napalm_yang.py	9.15 KB
netacl.py	31.92 KB
netconfig.py	33.42 KB
netntp.py	12.51 KB
netsnmp.py	11.33 KB
netusers.py	16.1 KB
network.py	23.97 KB
neutron_network.py	3.96 KB
neutron_secgroup.py	4 KB
neutron_secgroup_rule.py	4.75 KB
neutron_subnet.py	4.29 KB
nexus.py	4.97 KB
nfs_export.py	4.92 KB
nftables.py	19.5 KB
npm.py	11.21 KB
ntp.py	2.12 KB
nxos.py	10.37 KB
nxos_upgrade.py	3.5 KB
openstack_config.py	3.26 KB
openvswitch_bridge.py	4.36 KB
openvswitch_db.py	2.24 KB
openvswitch_port.py	17.24 KB
opsgenie.py	4.07 KB
pagerduty.py	1.89 KB
pagerduty_escalation_policy.py	5.42 KB
pagerduty_schedule.py	6.09 KB
pagerduty_service.py	3.93 KB
pagerduty_user.py	1.18 KB
panos.py	48.13 KB
pbm.py	20.46 KB
pcs.py	36.46 KB
pdbedit.py	3.43 KB
pecl.py	3.65 KB
pip_state.py	38.55 KB
pkg.py	138.08 KB
pkgbuild.py	11.37 KB
pkgng.py	685 B
pkgrepo.py	27.53 KB
portage_config.py	5.01 KB
ports.py	5.65 KB
postgres_cluster.py	4.19 KB
postgres_database.py	6.08 KB
postgres_extension.py	5.68 KB
postgres_group.py	8.52 KB
postgres_initdb.py	2.84 KB
postgres_language.py	3.94 KB
postgres_privileges.py	7.86 KB
postgres_schema.py	4.34 KB
postgres_tablespace.py	6.62 KB
postgres_user.py	9.49 KB
powerpath.py	2.34 KB
probes.py	15.06 KB
process.py	1.32 KB
proxy.py	4.94 KB
pushover.py	3.13 KB
pyenv.py	6.07 KB
pyrax_queues.py	2.97 KB
quota.py	1.4 KB
rabbitmq_cluster.py	1.84 KB
rabbitmq_plugin.py	2.77 KB
rabbitmq_policy.py	4.59 KB
rabbitmq_upstream.py	7.9 KB
rabbitmq_user.py	8.89 KB
rabbitmq_vhost.py	3.04 KB
rbac_solaris.py	6.67 KB
rbenv.py	7.36 KB
rdp.py	1.28 KB
redismod.py	4.76 KB
reg.py	19.22 KB
restconf.py	6.41 KB
rsync.py	4.45 KB
rvm.py	6.56 KB
salt_proxy.py	1.34 KB
saltmod.py	33.12 KB
saltutil.py	8.91 KB
schedule.py	12.47 KB
selinux.py	18.61 KB
serverdensity_device.py	6.41 KB
service.py	37.89 KB
slack.py	4.98 KB
smartos.py	44.83 KB
smtp.py	2.3 KB
snapper.py	7.24 KB
solrcloud.py	4.48 KB
splunk.py	4.32 KB
splunk_search.py	3.17 KB
sqlite3.py	14.7 KB
ssh_auth.py	19.57 KB
ssh_known_hosts.py	7.92 KB
stateconf.py	494 B
status.py	2.21 KB
statuspage.py	17.29 KB
supervisord.py	10.48 KB
svn.py	8.14 KB
sysctl.py	4.11 KB
sysfs.py	2.13 KB
syslog_ng.py	2.97 KB
sysrc.py	2.82 KB
telemetry_alert.py	7.04 KB
test.py	13.09 KB
testinframod.py	1.35 KB
timezone.py	3.42 KB
tls.py	1.81 KB
tomcat.py	9.72 KB
trafficserver.py	8.82 KB
tuned.py	3.32 KB
uptime.py	1.87 KB
user.py	38.63 KB
vagrant.py	11.4 KB
vault.py	3.28 KB
vbox_guest.py	4.05 KB
victorops.py	3.32 KB
virt.py	80.41 KB
virtualenv_mod.py	11.21 KB
webutil.py	3.89 KB
win_certutil.py	4.8 KB
win_dacl.py	7.96 KB
win_dism.py	14.97 KB
win_dns_client.py	8.32 KB
win_firewall.py	6.87 KB
win_iis.py	31.56 KB
win_lgpo.py	24.99 KB
win_lgpo_reg.py	10.96 KB
win_license.py	1.6 KB
win_network.py	14.18 KB
win_path.py	6.39 KB
win_pki.py	5.56 KB
win_powercfg.py	3.79 KB
win_servermanager.py	10.4 KB
win_shortcut.py	7.81 KB
win_smtp_server.py	10.01 KB
win_snmp.py	6.64 KB
win_system.py	13.78 KB
win_wua.py	16.27 KB
win_wusa.py	3.53 KB
winrepo.py	2.74 KB
wordpress.py	4.82 KB
x509.py	27.86 KB
x509_v2.py	64.78 KB
xml.py	1.75 KB
xmpp.py	2.61 KB
zabbix_action.py	9.35 KB
zabbix_host.py	27.25 KB
zabbix_hostgroup.py	5.64 KB
zabbix_mediatype.py	16.89 KB
zabbix_template.py	35.14 KB
zabbix_user.py	17.6 KB
zabbix_usergroup.py	9.64 KB
zabbix_usermacro.py	9.69 KB
zabbix_valuemap.py	8.11 KB
zcbuildout.py	5.16 KB
zenoss.py	2.89 KB
zfs.py	34.48 KB
zk_concurrency.py	5.81 KB
zone.py	46.48 KB
zookeeper.py	11.55 KB
zpool.py	13.4 KB

Edit: nftables.py

"""
Management of nftables
======================

This is an nftables-specific module designed to manage Linux firewalls. It is
expected that this state module, and other system-specific firewall states, may
at some point be deprecated in favor of a more generic `firewall` state.

.. code-block:: yaml

httpd:
      nftables.append:
        - table: filter
        - chain: input
        - jump: accept
        - match: state
        - connstate: new
        - dport: 80
        - proto: tcp
        - sport: 1025:65535
        - save: True

httpd:
      nftables.append:
        - table: filter
        - family: ipv6
        - chain: INPUT
        - jump: ACCEPT
        - match: state
        - connstate: NEW
        - dport: 80
        - proto: tcp
        - sport: 1025:65535
        - save: True

httpd:
      nftables.insert:
        - position: 1
        - table: filter
        - chain: INPUT
        - jump: ACCEPT
        - match: state
        - connstate: NEW
        - dport: 80
        - proto: tcp
        - sport: 1025:65535
        - save: True

httpd:
      nftables.insert:
        - position: 1
        - table: filter
        - family: ipv6
        - chain: INPUT
        - jump: ACCEPT
        - match: state
        - connstate: NEW
        - dport: 80
        - proto: tcp
        - sport: 1025:65535
        - save: True

httpd:
      nftables.delete:
        - table: filter
        - chain: INPUT
        - jump: ACCEPT
        - match: state
        - connstate: NEW
        - dport: 80
        - proto: tcp
        - sport: 1025:65535
        - save: True

httpd:
      nftables.delete:
        - position: 1
        - table: filter
        - chain: INPUT
        - jump: ACCEPT
        - match: state
        - connstate: NEW
        - dport: 80
        - proto: tcp
        - sport: 1025:65535
        - save: True

httpd:
      nftables.delete:
        - table: filter
        - family: ipv6
        - chain: INPUT
        - jump: ACCEPT
        - match: state
        - connstate: NEW
        - dport: 80
        - proto: tcp
        - sport: 1025:65535
        - save: True

output:
      nftables.chain_present:
        - family: ip
        - table: filter

output:
      nftables.chain_absent:
        - family: ip
        - table: filter

"""

import logging

from salt.state import STATE_INTERNAL_KEYWORDS as _STATE_INTERNAL_KEYWORDS

log = logging.getLogger(__name__)

def __virtual__():
    """
    Only load if the locale module is available in __salt__
    """
    if "nftables.version" in __salt__:
        return "nftables"
    return (False, "nftables module could not be loaded")

def chain_present(
    name, table="filter", table_type=None, hook=None, priority=None, family="ipv4"
):
    """
    .. versionadded:: 2014.7.0

.. versionchanged:: 3002

Verify a chain exists in a table.

name
        A user-defined chain name.

table
        The table to own the chain.

family
        Networking family, either ipv4 or ipv6
    """

ret = {"name": name, "changes": {}, "result": None, "comment": ""}

chain_check = __salt__["nftables.check_chain"](table, name, family=family)
    if chain_check["result"] is True:
        ret["result"] = True
        ret["comment"] = "nftables {} chain is already exist in {} table for {}".format(
            name, table, family
        )
        return ret

if __opts__["test"]:
        ret[
            "comment"
        ] = "nftables chain {} would be created in table {} for family {}".format(
            name, table, family
        )
        return ret

res = __salt__["nftables.new_chain"](
        table, name, table_type=table_type, hook=hook, priority=priority, family=family
    )

if res["result"] is True:
        ret["changes"] = {"locale": name}
        ret["result"] = True
        ret["comment"] = "nftables {} chain in {} table create success for {}".format(
            name, table, family
        )
        return ret
    else:
        ret["result"] = False
        ret["comment"] = "Failed to create {} chain in {} table: {} for {}".format(
            name, table, res["comment"].strip(), family
        )
        return ret

def chain_absent(name, table="filter", family="ipv4"):
    """
    .. versionadded:: 2014.7.0

Verify the chain is absent.

family
        Networking family, either ipv4 or ipv6
    """

ret = {"name": name, "changes": {}, "result": None, "comment": ""}

chain_check = __salt__["nftables.check_chain"](table, name, family)
    if not chain_check:
        ret["result"] = True
        ret[
            "comment"
        ] = "nftables {} chain is already absent in {} table for {}".format(
            name, table, family
        )
        return ret

flush_chain = __salt__["nftables.flush"](table, name, family)
    if flush_chain:
        command = __salt__["nftables.delete_chain"](table, name, family)
        if command is True:
            ret["changes"] = {"locale": name}
            ret["result"] = True
            ret[
                "comment"
            ] = "nftables {} chain in {} table delete success for {}".format(
                name, table, family
            )
        else:
            ret["result"] = False
            ret["comment"] = "Failed to delete {} chain in {} table: {} for {}".format(
                name, table, command.strip(), family
            )
    else:
        ret["result"] = False
        ret["comment"] = "Failed to flush {} chain in {} table: {} for {}".format(
            name, table, flush_chain.strip(), family
        )
    return ret

def append(name, family="ipv4", **kwargs):
    """
    .. versionadded:: 0.17.0

Append a rule to a chain

name
        A user-defined name to call this rule by in another part of a state or
        formula. This should not be an actual rule.

family
        Network family, ipv4 or ipv6.

All other arguments are passed in with the same name as the long option
    that would normally be used for nftables, with one exception: `--state` is
    specified as `connstate` instead of `state` (not to be confused with
    `ctstate`).
    """
    ret = {"name": name, "changes": {}, "result": None, "comment": ""}

for ignore in _STATE_INTERNAL_KEYWORDS:
        if ignore in kwargs:
            del kwargs[ignore]
    res = __salt__["nftables.build_rule"](family=family, **kwargs)
    if not res["result"]:
        return res
    rule = res["rule"]

res = __salt__["nftables.build_rule"](
        full=True, family=family, command="add", **kwargs
    )
    if not res["result"]:
        return res
    command = res["rule"]

res = __salt__["nftables.check"](kwargs["table"], kwargs["chain"], rule, family)
    if res["result"]:
        ret["result"] = True
        ret["comment"] = "nftables rule for {} already set ({}) for {}".format(
            name, command.strip(), family
        )
        return ret
    if "test" in __opts__ and __opts__["test"]:
        ret["comment"] = "nftables rule for {} needs to be set ({}) for {}".format(
            name, command.strip(), family
        )
        return ret
    res = __salt__["nftables.append"](kwargs["table"], kwargs["chain"], rule, family)
    if res["result"]:
        ret["changes"] = {"locale": name}
        ret["result"] = True
        ret["comment"] = "Set nftables rule for {} to: {} for {}".format(
            name, command.strip(), family
        )
        if "save" in kwargs:
            if kwargs["save"]:
                __salt__["nftables.save"](filename=None, family=family)
                ret[
                    "comment"
                ] = "Set and Saved nftables rule for {} to: {} for {}".format(
                    name, command.strip(), family
                )
        return ret
    else:
        ret["result"] = False
        ret[
            "comment"
        ] = "Failed to set nftables rule for {}.\nAttempted rule was {} for {}.\n{}".format(
            name, command.strip(), family, res["comment"]
        )
        return ret

def insert(name, family="ipv4", **kwargs):
    """
    .. versionadded:: 2014.7.0

Insert a rule into a chain

name
        A user-defined name to call this rule by in another part of a state or
        formula. This should not be an actual rule.

family
        Networking family, either ipv4 or ipv6

res = __salt__["nftables.build_rule"](
        full=True, family=family, command="insert", **kwargs
    )
    if not res["result"]:
        return res
    command = res["rule"]

res = __salt__["nftables.check"](kwargs["table"], kwargs["chain"], rule, family)
    if res["result"]:
        ret["result"] = True
        ret["comment"] = "nftables rule for {} already set for {} ({})".format(
            name, family, command.strip()
        )
        return ret
    if "test" in __opts__ and __opts__["test"]:
        ret["comment"] = "nftables rule for {} needs to be set for {} ({})".format(
            name, family, command.strip()
        )
        return ret
    res = __salt__["nftables.insert"](
        kwargs["table"], kwargs["chain"], kwargs["position"], rule, family
    )
    if res["result"]:
        ret["changes"] = {"locale": name}
        ret["result"] = True
        ret["comment"] = "Set nftables rule for {} to: {} for {}".format(
            name, command.strip(), family
        )
        if "save" in kwargs:
            if kwargs["save"]:
                __salt__["nftables.save"](filename=None, family=family)
                ret[
                    "comment"
                ] = "Set and Saved nftables rule for {} to: {} for {}".format(
                    name, command.strip(), family
                )
        return ret
    else:
        ret["result"] = False
        ret[
            "comment"
        ] = "Failed to set nftables rule for {}.\nAttempted rule was {}".format(
            name, command.strip()
        )
        return ret

def delete(name, family="ipv4", **kwargs):
    """
    .. versionadded:: 2014.7.0

Delete a rule to a chain

name
        A user-defined name to call this rule by in another part of a state or
        formula. This should not be an actual rule.

family
        Networking family, either ipv4 or ipv6

res = __salt__["nftables.build_rule"](
        full=True, family=family, command="D", **kwargs
    )
    if not res["result"]:
        return res
    command = res["rule"]

res = __salt__["nftables.check"](kwargs["table"], kwargs["chain"], rule, family)

if not res["result"]:
        ret["result"] = True
        ret["comment"] = "nftables rule for {} already absent for {} ({})".format(
            name, family, command.strip()
        )
        return ret
    if "test" in __opts__ and __opts__["test"]:
        ret["comment"] = "nftables rule for {} needs to be deleted for {} ({})".format(
            name, family, command.strip()
        )
        return ret

if "position" in kwargs:
        res = __salt__["nftables.delete"](
            kwargs["table"], kwargs["chain"], family=family, position=kwargs["position"]
        )
    else:
        res = __salt__["nftables.delete"](
            kwargs["table"], kwargs["chain"], family=family, rule=rule
        )

if res["result"]:
        ret["changes"] = {"locale": name}
        ret["result"] = True
        ret["comment"] = "Delete nftables rule for {} {}".format(name, command.strip())
        if "save" in kwargs:
            if kwargs["save"]:
                __salt__["nftables.save"](filename=None, family=family)
                ret[
                    "comment"
                ] = "Deleted and Saved nftables rule for {} for {}{}".format(
                    name, command.strip(), family
                )
        return ret
    else:
        ret["result"] = False
        ret[
            "comment"
        ] = "Failed to delete nftables rule for {}.\nAttempted rule was {}".format(
            name, command.strip()
        )
        return ret

def flush(name, family="ipv4", ignore_absence=False, **kwargs):
    """
    .. versionadded:: 2014.7.0

.. versionchanged:: 3002

Flush current nftables state

family
        Networking family, either ipv4 or ipv6

ignore_absence
        If set to True, attempts to flush a non-existent table will not
        result in a failed state.

.. versionadded:: 3002

"""
    ret = {"name": name, "changes": {}, "result": None, "comment": ""}

if __opts__["test"]:
        ret["comment"] = "nftables flush not performed in test mode."
        return ret

for ignore in _STATE_INTERNAL_KEYWORDS:
        if ignore in kwargs:
            del kwargs[ignore]

if "table" not in kwargs:
        kwargs["table"] = "filter"

check_table = __salt__["nftables.check_table"](kwargs["table"], family=family)
    if not ignore_absence and not check_table["result"]:
        ret["result"] = False
        ret[
            "comment"
        ] = "Failed to flush table {} in family {}, table does not exist.".format(
            kwargs["table"], family
        )
        return ret

if "chain" not in kwargs:
        kwargs["chain"] = ""
    else:
        check_chain = __salt__["nftables.check_chain"](
            kwargs["table"], kwargs["chain"], family=family
        )
        if not ignore_absence and not check_chain["result"]:
            ret["result"] = False
            ret["comment"] = (
                "Failed to flush chain {} in table {} in family {}, chain does not"
                " exist.".format(kwargs["chain"], kwargs["table"], family)
            )
            return ret

res = __salt__["nftables.flush"](kwargs["table"], kwargs["chain"], family)
    if res["result"] or (
        ignore_absence and (not check_table["result"] or not check_chain["result"])
    ):
        ret["changes"] = {"locale": name}
        ret["result"] = True
        ret["comment"] = "Flush nftables rules in {} table {} chain {} family".format(
            kwargs["table"], kwargs["chain"], family
        )
        return ret
    else:
        ret["result"] = False
        ret["comment"] = "Failed to flush nftables rules"
        return ret

def set_policy(name, table="filter", family="ipv4", **kwargs):
    """
    .. versionadded:: 3002

Sets the default policy for nftables chains

table
        The table that owns the chain that should be modified

family
        Networking family, either ipv4 or ipv6

policy
        The requested table policy (accept or drop)

save
        Boolean to save the in-memory nftables settings to a file.

save_filename
        The filename to save the nftables settings (default: /etc/nftables
        or /etc/nftables/salt-all-in-one.nft if the former is a directory)

"""
    ret = {"name": name, "changes": {}, "result": None, "comment": ""}

for ignore in _STATE_INTERNAL_KEYWORDS:
        if ignore in kwargs:
            del kwargs[ignore]

policy = __salt__["nftables.get_policy"](table, kwargs["chain"], family)

if (policy or "").lower() == kwargs["policy"].lower():
        ret["result"] = True
        ret[
            "comment"
        ] = "nftables default policy for chain {} on table {} for {} already set to {}".format(
            kwargs["chain"], table, family, kwargs["policy"]
        )
        return ret

if __opts__["test"]:
        ret["comment"] = (
            "nftables default policy for chain {} on table {} for {} needs to be set"
            " to {}".format(kwargs["chain"], table, family, kwargs["policy"])
        )
        return ret

if __salt__["nftables.set_policy"](
        table, kwargs["chain"], kwargs["policy"].lower(), family
    ):
        ret["changes"] = {"locale": name}
        ret["result"] = True
        ret["comment"] = "Set default policy for {} to {} family {}".format(
            kwargs["chain"], kwargs["policy"], family
        )

if "save" in kwargs:
            if kwargs["save"]:
                __salt__["nftables.save"](
                    filename=kwargs.get("save_filename"), family=family
                )
                ret[
                    "comment"
                ] = "Set and saved default policy for {} to {} family {}".format(
                    kwargs["chain"], kwargs["policy"], family
                )
    else:
        ret["result"] = False
        ret["comment"] = "Failed to set nftables default policy"

return ret

def table_present(name, family="ipv4", **kwargs):
    """
    .. versionadded:: 3002

Ensure an nftables table is present

name
        A user-defined table name.

family
        Networking family, either ipv4 or ipv6
    """

ret = {"name": name, "changes": {}, "result": None, "comment": ""}

table_check = __salt__["nftables.check_table"](name, family=family)

if table_check["result"] is True:
        ret["result"] = True
        ret["comment"] = "nftables table {} already exists in family {}".format(
            name, family
        )
        return ret

if __opts__["test"]:
        ret["comment"] = "nftables table {} would be created in family {}".format(
            name, family
        )
        return ret

res = __salt__["nftables.new_table"](name, family=family)

if res["result"] is True:
        ret["changes"] = {"locale": name}
        ret["result"] = True
        ret["comment"] = "nftables table {} successfully created in family {}".format(
            name, family
        )
    else:
        ret["result"] = False
        ret["comment"] = "Failed to create table {} for family {}".format(name, family)

return ret

def table_absent(name, family="ipv4", **kwargs):
    """
    .. versionadded:: 3002

Ensure an nftables table is absent

name
        Name of the table to ensure is absent

family
        Networking family, either ipv4 or ipv6
    """

ret = {"name": name, "changes": {}, "result": None, "comment": ""}

table_check = __salt__["nftables.check_table"](name, family)

if table_check["result"] is False:
        ret["result"] = True
        ret["comment"] = "nftables table {} is already absent from family {}".format(
            name, family
        )
        return ret

if __opts__["test"]:
        ret["comment"] = "nftables table {} would be deleted from family {}".format(
            name, family
        )
        return ret

res = __salt__["nftables.delete_table"](name, family=family)

if res["result"] is True:
        ret["changes"] = {"locale": name}
        ret["result"] = True
        ret["comment"] = "nftables table {} successfully deleted from family {}".format(
            name, family
        )
    else:
        ret["result"] = False
        ret["comment"] = "Failed to delete table {} from family {}".format(name, family)

return ret