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: keystone.py

"""
Management of Keystone users
============================

:depends:   - keystoneclient Python module
:configuration: See :py:mod:`salt.modules.keystone` for setup instructions.

.. code-block:: yaml

Keystone tenants:
      keystone.tenant_present:
        - names:
          - admin
          - demo
          - service

Keystone roles:
      keystone.role_present:
        - names:
          - admin
          - Member

admin:
      keystone.user_present:
        - password: R00T_4CC3SS
        - email: admin@domain.com
        - roles:
            admin:   # tenants
              - admin  # roles
            service:
              - admin
              - Member
        - require:
          - keystone: Keystone tenants
          - keystone: Keystone roles

nova:
      keystone.user_present:
        - password: '$up3rn0v4'
        - email: nova@domain.com
        - tenant: service
        - roles:
            service:
              - admin
        - require:
          - keystone: Keystone tenants
          - keystone: Keystone roles

demo:
      keystone.user_present:
        - password: 'd3m0n$trati0n'
        - email: demo@domain.com
        - tenant: demo
        - roles:
            demo:
              - Member
        - require:
          - keystone: Keystone tenants
          - keystone: Keystone roles

nova service:
      keystone.service_present:
        - name: nova
        - service_type: compute
        - description: OpenStack Compute Service

"""

def __virtual__():
    """
    Only load if the keystone module is in __salt__
    """
    if "keystone.auth" in __salt__:
        return "keystone"
    return (False, "keystone module could not be loaded")

_OS_IDENTITY_API_VERSION = 2
_TENANT_ID = "tenant_id"

def _api_version(profile=None, **connection_args):
    """
    Sets global variables _OS_IDENTITY_API_VERSION and _TENANT_ID
    depending on API version.
    """
    global _TENANT_ID
    global _OS_IDENTITY_API_VERSION
    try:
        if (
            float(
                __salt__["keystone.api_version"](
                    profile=profile, **connection_args
                ).strip("v")
            )
            >= 3
        ):
            _TENANT_ID = "project_id"
            _OS_IDENTITY_API_VERSION = 3
    except KeyError:
        pass

def user_present(
    name,
    password,
    email,
    tenant=None,
    enabled=True,
    roles=None,
    profile=None,
    password_reset=True,
    project=None,
    **connection_args
):
    """
    Ensure that the keystone user is present with the specified properties.

name
        The name of the user to manage

password
        The password to use for this user.

.. note::

If the user already exists and a different password was set for
            the user than the one specified here, the password for the user
            will be updated. Please set the ``password_reset`` option to
            ``False`` if this is not the desired behavior.

password_reset
        Whether or not to reset password after initial set. Defaults to
        ``True``.

email
        The email address for this user

tenant
        The tenant (name) for this user

project
        The project (name) for this user (overrides tenant in api v3)

enabled
        Availability state for this user

roles
        The roles the user should have under given tenants.
        Passed as a dictionary mapping tenant names to a list
        of roles in this tenant, i.e.::

roles:
                admin:   # tenant
                  - admin  # role
                service:
                  - admin
                  - Member
    """
    ret = {
        "name": name,
        "changes": {},
        "result": True,
        "comment": 'User "{}" will be updated'.format(name),
    }

_api_version(profile=profile, **connection_args)

if project and not tenant:
        tenant = project

# Validate tenant if set
    if tenant is not None:
        tenantdata = __salt__["keystone.tenant_get"](
            name=tenant, profile=profile, **connection_args
        )
        if "Error" in tenantdata:
            ret["result"] = False
            ret["comment"] = 'Tenant / project "{}" does not exist'.format(tenant)
            return ret
        tenant_id = tenantdata[tenant]["id"]
    else:
        tenant_id = None

# Check if user is already present
    user = __salt__["keystone.user_get"](name=name, profile=profile, **connection_args)
    if "Error" not in user:

change_email = False
        change_enabled = False
        change_tenant = False
        change_password = False

if user[name].get("email", None) != email:
            change_email = True

if user[name].get("enabled", None) != enabled:
            change_enabled = True

if tenant and (
            _TENANT_ID not in user[name]
            or user[name].get(_TENANT_ID, None) != tenant_id
        ):
            change_tenant = True

if password_reset is True and not __salt__["keystone.user_verify_password"](
            name=name, password=password, profile=profile, **connection_args
        ):
            change_password = True

if __opts__.get("test") and (
            change_email or change_enabled or change_tenant or change_password
        ):
            ret["result"] = None
            ret["comment"] = 'User "{}" will be updated'.format(name)
            if change_email is True:
                ret["changes"]["Email"] = "Will be updated"
            if change_enabled is True:
                ret["changes"]["Enabled"] = "Will be True"
            if change_tenant is True:
                ret["changes"]["Tenant"] = 'Will be added to "{}" tenant'.format(tenant)
            if change_password is True:
                ret["changes"]["Password"] = "Will be updated"
            return ret

ret["comment"] = 'User "{}" is already present'.format(name)

if change_email:
            __salt__["keystone.user_update"](
                name=name, email=email, profile=profile, **connection_args
            )
            ret["comment"] = 'User "{}" has been updated'.format(name)
            ret["changes"]["Email"] = "Updated"

if change_enabled:
            __salt__["keystone.user_update"](
                name=name, enabled=enabled, profile=profile, **connection_args
            )
            ret["comment"] = 'User "{}" has been updated'.format(name)
            ret["changes"]["Enabled"] = "Now {}".format(enabled)

if change_tenant:
            __salt__["keystone.user_update"](
                name=name, tenant=tenant, profile=profile, **connection_args
            )
            ret["comment"] = 'User "{}" has been updated'.format(name)
            ret["changes"]["Tenant"] = 'Added to "{}" tenant'.format(tenant)

if change_password:
            __salt__["keystone.user_password_update"](
                name=name, password=password, profile=profile, **connection_args
            )
            ret["comment"] = 'User "{}" has been updated'.format(name)
            ret["changes"]["Password"] = "Updated"

if roles:
            for tenant in roles:
                args = dict(
                    {"user_name": name, "tenant_name": tenant, "profile": profile},
                    **connection_args
                )
                tenant_roles = __salt__["keystone.user_role_list"](**args)
                for role in roles[tenant]:
                    if role not in tenant_roles:
                        if __opts__.get("test"):
                            ret["result"] = None
                            ret["comment"] = 'User roles "{}" will been updated'.format(
                                name
                            )
                            return ret
                        addargs = dict(
                            {
                                "user": name,
                                "role": role,
                                "tenant": tenant,
                                "profile": profile,
                            },
                            **connection_args
                        )
                        newrole = __salt__["keystone.user_role_add"](**addargs)
                        if "roles" in ret["changes"]:
                            ret["changes"]["roles"].append(newrole)
                        else:
                            ret["changes"]["roles"] = [newrole]
                roles_to_remove = list(set(tenant_roles) - set(roles[tenant]))
                for role in roles_to_remove:
                    if __opts__.get("test"):
                        ret["result"] = None
                        ret["comment"] = 'User roles "{}" will been updated'.format(
                            name
                        )
                        return ret
                    addargs = dict(
                        {
                            "user": name,
                            "role": role,
                            "tenant": tenant,
                            "profile": profile,
                        },
                        **connection_args
                    )
                    oldrole = __salt__["keystone.user_role_remove"](**addargs)
                    if "roles" in ret["changes"]:
                        ret["changes"]["roles"].append(oldrole)
                    else:
                        ret["changes"]["roles"] = [oldrole]
    else:
        # Create that user!
        if __opts__.get("test"):
            ret["result"] = None
            ret["comment"] = 'Keystone user "{}" will be added'.format(name)
            ret["changes"]["User"] = "Will be created"
            return ret
        __salt__["keystone.user_create"](
            name=name,
            password=password,
            email=email,
            tenant_id=tenant_id,
            enabled=enabled,
            profile=profile,
            **connection_args
        )
        if roles:
            for tenant in roles:
                for role in roles[tenant]:
                    __salt__["keystone.user_role_add"](
                        user=name,
                        role=role,
                        tenant=tenant,
                        profile=profile,
                        **connection_args
                    )
        ret["comment"] = "Keystone user {} has been added".format(name)
        ret["changes"]["User"] = "Created"

return ret

def user_absent(name, profile=None, **connection_args):
    """
    Ensure that the keystone user is absent.

name
        The name of the user that should not exist
    """
    ret = {
        "name": name,
        "changes": {},
        "result": True,
        "comment": 'User "{}" is already absent'.format(name),
    }

# Check if user is present
    user = __salt__["keystone.user_get"](name=name, profile=profile, **connection_args)
    if "Error" not in user:
        if __opts__.get("test"):
            ret["result"] = None
            ret["comment"] = 'User "{}" will be deleted'.format(name)
            return ret
        # Delete that user!
        __salt__["keystone.user_delete"](name=name, profile=profile, **connection_args)
        ret["comment"] = 'User "{}" has been deleted'.format(name)
        ret["changes"]["User"] = "Deleted"

return ret

def tenant_present(
    name, description=None, enabled=True, profile=None, **connection_args
):
    """
    Ensures that the keystone tenant exists

name
        The name of the tenant to manage

description
        The description to use for this tenant

enabled
        Availability state for this tenant
    """
    ret = {
        "name": name,
        "changes": {},
        "result": True,
        "comment": 'Tenant / project "{}" already exists'.format(name),
    }

_api_version(profile=profile, **connection_args)

# Check if tenant is already present
    tenant = __salt__["keystone.tenant_get"](
        name=name, profile=profile, **connection_args
    )

if "Error" not in tenant:
        if tenant[name].get("description", None) != description:
            if __opts__.get("test"):
                ret["result"] = None
                ret["comment"] = 'Tenant / project "{}" will be updated'.format(name)
                ret["changes"]["Description"] = "Will be updated"
                return ret
            __salt__["keystone.tenant_update"](
                name=name,
                description=description,
                enabled=enabled,
                profile=profile,
                **connection_args
            )
            ret["comment"] = 'Tenant / project "{}" has been updated'.format(name)
            ret["changes"]["Description"] = "Updated"
        if tenant[name].get("enabled", None) != enabled:
            if __opts__.get("test"):
                ret["result"] = None
                ret["comment"] = 'Tenant / project "{}" will be updated'.format(name)
                ret["changes"]["Enabled"] = "Will be {}".format(enabled)
                return ret
            __salt__["keystone.tenant_update"](
                name=name,
                description=description,
                enabled=enabled,
                profile=profile,
                **connection_args
            )
            ret["comment"] = 'Tenant / project "{}" has been updated'.format(name)
            ret["changes"]["Enabled"] = "Now {}".format(enabled)
    else:
        if __opts__.get("test"):
            ret["result"] = None
            ret["comment"] = 'Tenant / project "{}" will be added'.format(name)
            ret["changes"]["Tenant"] = "Will be created"
            return ret
        # Create tenant
        if _OS_IDENTITY_API_VERSION > 2:
            created = __salt__["keystone.project_create"](
                name=name,
                domain="default",
                description=description,
                enabled=enabled,
                profile=profile,
                **connection_args
            )
        else:
            created = __salt__["keystone.tenant_create"](
                name=name,
                description=description,
                enabled=enabled,
                profile=profile,
                **connection_args
            )
        ret["changes"]["Tenant"] = "Created" if created is True else "Failed"
        ret["result"] = created
        ret["comment"] = 'Tenant / project "{}" has been added'.format(name)
    return ret

def tenant_absent(name, profile=None, **connection_args):
    """
    Ensure that the keystone tenant is absent.

name
        The name of the tenant that should not exist
    """
    ret = {
        "name": name,
        "changes": {},
        "result": True,
        "comment": 'Tenant / project "{}" is already absent'.format(name),
    }

# Check if tenant is present
    tenant = __salt__["keystone.tenant_get"](
        name=name, profile=profile, **connection_args
    )
    if "Error" not in tenant:
        if __opts__.get("test"):
            ret["result"] = None
            ret["comment"] = 'Tenant / project "{}" will be deleted'.format(name)
            return ret
        # Delete tenant
        __salt__["keystone.tenant_delete"](
            name=name, profile=profile, **connection_args
        )
        ret["comment"] = 'Tenant / project "{}" has been deleted'.format(name)
        ret["changes"]["Tenant/Project"] = "Deleted"

return ret

def project_present(
    name, description=None, enabled=True, profile=None, **connection_args
):
    """
    Ensures that the keystone project exists
    Alias for tenant_present from V2 API to fulfill
    V3 API naming convention.

.. versionadded:: 2016.11.0

name
        The name of the project to manage

description
        The description to use for this project

enabled
        Availability state for this project

.. code-block:: yaml

nova:
            keystone.project_present:
                - enabled: True
                - description: 'Nova Compute Service'

"""

return tenant_present(
        name,
        description=description,
        enabled=enabled,
        profile=profile,
        **connection_args
    )

def project_absent(name, profile=None, **connection_args):
    """
    Ensure that the keystone project is absent.
    Alias for tenant_absent from V2 API to fulfill
    V3 API naming convention.

.. versionadded:: 2016.11.0

name
        The name of the project that should not exist

.. code-block:: yaml

delete_nova:
            keystone.project_absent:
                - name: nova
    """

return tenant_absent(name, profile=profile, **connection_args)

def role_present(name, profile=None, **connection_args):
    """'
    Ensures that the keystone role exists

name
        The name of the role that should be present
    """
    ret = {
        "name": name,
        "changes": {},
        "result": True,
        "comment": 'Role "{}" already exists'.format(name),
    }

# Check if role is already present
    role = __salt__["keystone.role_get"](name=name, profile=profile, **connection_args)

if "Error" not in role:
        return ret
    else:
        if __opts__.get("test"):
            ret["result"] = None
            ret["comment"] = 'Role "{}" will be added'.format(name)
            return ret
        # Create role
        __salt__["keystone.role_create"](name, profile=profile, **connection_args)
        ret["comment"] = 'Role "{}" has been added'.format(name)
        ret["changes"]["Role"] = "Created"
    return ret

def role_absent(name, profile=None, **connection_args):
    """
    Ensure that the keystone role is absent.

name
        The name of the role that should not exist
    """
    ret = {
        "name": name,
        "changes": {},
        "result": True,
        "comment": 'Role "{}" is already absent'.format(name),
    }

# Check if role is present
    role = __salt__["keystone.role_get"](name=name, profile=profile, **connection_args)
    if "Error" not in role:
        if __opts__.get("test"):
            ret["result"] = None
            ret["comment"] = 'Role "{}" will be deleted'.format(name)
            return ret
        # Delete role
        __salt__["keystone.role_delete"](name=name, profile=profile, **connection_args)
        ret["comment"] = 'Role "{}" has been deleted'.format(name)
        ret["changes"]["Role"] = "Deleted"

return ret

def service_present(
    name, service_type, description=None, profile=None, **connection_args
):
    """
    Ensure service present in Keystone catalog

name
        The name of the service

service_type
        The type of Openstack Service

description (optional)
        Description of the service
    """
    ret = {
        "name": name,
        "changes": {},
        "result": True,
        "comment": 'Service "{}" already exists'.format(name),
    }

# Check if service is already present
    role = __salt__["keystone.service_get"](
        name=name, profile=profile, **connection_args
    )

if "Error" not in role:
        return ret
    else:
        if __opts__.get("test"):
            ret["result"] = None
            ret["comment"] = 'Service "{}" will be added'.format(name)
            return ret
        # Create service
        __salt__["keystone.service_create"](
            name, service_type, description, profile=profile, **connection_args
        )
        ret["comment"] = 'Service "{}" has been added'.format(name)
        ret["changes"]["Service"] = "Created"

return ret

def service_absent(name, profile=None, **connection_args):
    """
    Ensure that the service doesn't exist in Keystone catalog

name
        The name of the service that should not exist
    """
    ret = {
        "name": name,
        "changes": {},
        "result": True,
        "comment": 'Service "{}" is already absent'.format(name),
    }

# Check if service is present
    role = __salt__["keystone.service_get"](
        name=name, profile=profile, **connection_args
    )
    if "Error" not in role:
        if __opts__.get("test"):
            ret["result"] = None
            ret["comment"] = 'Service "{}" will be deleted'.format(name)
            return ret
        # Delete service
        __salt__["keystone.service_delete"](
            name=name, profile=profile, **connection_args
        )
        ret["comment"] = 'Service "{}" has been deleted'.format(name)
        ret["changes"]["Service"] = "Deleted"

return ret

def endpoint_present(
    name,
    publicurl=None,
    internalurl=None,
    adminurl=None,
    region=None,
    profile=None,
    url=None,
    interface=None,
    **connection_args
):
    """
    Ensure the specified endpoints exists for service

name
        The Service name

publicurl
        The public url of service endpoint (for V2 API)

internalurl
        The internal url of service endpoint (for V2 API)

adminurl
        The admin url of the service endpoint (for V2 API)

region
        The region of the endpoint

url
        The endpoint URL (for V3 API)

interface
        The interface type, which describes the visibility
        of the endpoint. (for V3 API)

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

_api_version(profile=profile, **connection_args)

endpoint = __salt__["keystone.endpoint_get"](
        name, region, profile=profile, interface=interface, **connection_args
    )

def _changes(desc):
        return ret.get("comment", "") + desc + "\n"

def _create_endpoint():
        if _OS_IDENTITY_API_VERSION > 2:
            ret["changes"] = __salt__["keystone.endpoint_create"](
                name,
                region=region,
                url=url,
                interface=interface,
                profile=profile,
                **connection_args
            )
        else:
            ret["changes"] = __salt__["keystone.endpoint_create"](
                name,
                region=region,
                publicurl=publicurl,
                adminurl=adminurl,
                internalurl=internalurl,
                profile=profile,
                **connection_args
            )

if endpoint and "Error" not in endpoint and endpoint.get("region") == region:

if _OS_IDENTITY_API_VERSION > 2:

change_url = False
            change_interface = False

if endpoint.get("url", None) != url:
                ret["comment"] = _changes(
                    'URL changes from "{}" to "{}"'.format(
                        endpoint.get("url", None), url
                    )
                )
                change_url = True

if endpoint.get("interface", None) != interface:
                ret["comment"] = _changes(
                    'Interface changes from "{}" to "{}"'.format(
                        endpoint.get("interface", None), interface
                    )
                )
                change_interface = True

if __opts__.get("test") and (change_url or change_interface):
                ret["result"] = None
                ret["changes"]["Endpoint"] = "Will be updated"
                ret["comment"] += 'Endpoint for service "{}" will be updated'.format(
                    name
                )
                return ret

if change_url:
                ret["changes"]["url"] = url

if change_interface:
                ret["changes"]["interface"] = interface

else:
            change_publicurl = False
            change_adminurl = False
            change_internalurl = False

if endpoint.get("publicurl", None) != publicurl:
                change_publicurl = True

ret["comment"] = _changes(
                    'Public URL changes from "{}" to "{}"'.format(
                        endpoint.get("publicurl", None), publicurl
                    )
                )

if endpoint.get("adminurl", None) != adminurl:
                change_adminurl = True
                ret["comment"] = _changes(
                    'Admin URL changes from "{}" to "{}"'.format(
                        endpoint.get("adminurl", None), adminurl
                    )
                )

if endpoint.get("internalurl", None) != internalurl:
                change_internalurl = True
                ret["comment"] = _changes(
                    'Internal URL changes from "{}" to "{}"'.format(
                        endpoint.get("internalurl", None), internalurl
                    )
                )

if __opts__.get("test") and (
                change_publicurl or change_adminurl or change_internalurl
            ):
                ret["result"] = None
                ret["comment"] += 'Endpoint for service "{}" will be updated'.format(
                    name
                )
                ret["changes"]["Endpoint"] = "Will be updated"
                return ret

if change_publicurl:
                ret["changes"]["publicurl"] = publicurl

if change_adminurl:
                ret["changes"]["adminurl"] = adminurl

if change_internalurl:
                ret["changes"]["internalurl"] = internalurl

if ret["comment"]:  # changed
            __salt__["keystone.endpoint_delete"](
                name, region, profile=profile, interface=interface, **connection_args
            )
            _create_endpoint()
            ret["comment"] += 'Endpoint for service "{}" has been updated'.format(name)

else:
        # Add new endpoint
        if __opts__.get("test"):
            ret["result"] = None
            ret["changes"]["Endpoint"] = "Will be created"
            ret["comment"] = 'Endpoint for service "{}" will be added'.format(name)
            return ret
        _create_endpoint()
        ret["comment"] = 'Endpoint for service "{}" has been added'.format(name)

if ret["comment"] == "":  # => no changes
        ret["comment"] = 'Endpoint for service "{}" already exists'.format(name)
    return ret

def endpoint_absent(name, region=None, profile=None, interface=None, **connection_args):
    """
    Ensure that the endpoint for a service doesn't exist in Keystone catalog

name
        The name of the service whose endpoints should not exist

region (optional)
        The region of the endpoint.  Defaults to ``RegionOne``.

interface
        The interface type, which describes the visibility
        of the endpoint. (for V3 API)
    """
    ret = {
        "name": name,
        "changes": {},
        "result": True,
        "comment": 'Endpoint for service "{}"{} is already absent'.format(
            name,
            ', interface "{}",'.format(interface) if interface is not None else "",
        ),
    }

# Check if service is present
    endpoint = __salt__["keystone.endpoint_get"](
        name, region, profile=profile, interface=interface, **connection_args
    )
    if not endpoint:
        return ret
    else:
        if __opts__.get("test"):
            ret["result"] = None
            ret["comment"] = 'Endpoint for service "{}" will be deleted'.format(name)
            return ret
        # Delete service
        __salt__["keystone.endpoint_delete"](
            name, region, profile=profile, interface=interface, **connection_args
        )
        ret["comment"] = 'Endpoint for service "{}"{} has been deleted'.format(
            name,
            ', interface "{}",'.format(interface) if interface is not None else "",
        )
        ret["changes"]["endpoint"] = "Deleted"
    return ret