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

"""
Manage Glassfish/Payara server
.. versionadded:: 2016.11.0

Management of glassfish using its RESTful API
You can setup connection parameters like this

.. code-block:: yaml

- server:
      - ssl: true
      - url: localhost
      - port: 4848
      - user: admin
      - password: changeit
"""

import salt.utils.json
from salt.exceptions import CommandExecutionError

try:
    import requests

HAS_LIBS = True
except ImportError:
    HAS_LIBS = False

def __virtual__():
    """
    Only load if glassfish module is available
    """
    if "glassfish.enum_connector_c_pool" in __salt__ and HAS_LIBS:
        return True
    return (False, "glassfish module could not be loaded")

def _json_to_unicode(data):
    """
    Encode json values in unicode to match that of the API
    """
    ret = {}
    for key, value in data.items():
        if not isinstance(value, str):
            if isinstance(value, dict):
                ret[key] = _json_to_unicode(value)
            else:
                ret[key] = str(value).lower()
        else:
            ret[key] = value
    return ret

def _is_updated(old_conf, new_conf):
    """
    Compare the API results to the current statefile data
    """
    changed = {}

# Dirty json hacking to get parameters in the same format
    new_conf = _json_to_unicode(
        salt.utils.json.loads(salt.utils.json.dumps(new_conf, ensure_ascii=False))
    )
    old_conf = salt.utils.json.loads(
        salt.utils.json.dumps(old_conf, ensure_ascii=False)
    )

for key, value in old_conf.items():
        oldval = str(value).lower()
        if key in new_conf:
            newval = str(new_conf[key]).lower()
        if oldval == "null" or oldval == "none":
            oldval = ""
        if key in new_conf and newval != oldval:
            changed[key] = {"old": oldval, "new": newval}
    return changed

def _do_element_present(name, elem_type, data, server=None):
    """
    Generic function to create or update an element
    """
    ret = {"changes": {}, "update": False, "create": False, "error": None}
    try:
        elements = __salt__["glassfish.enum_{}".format(elem_type)]()
    except requests.ConnectionError as error:
        if __opts__["test"]:
            ret["changes"] = {"Name": name, "Params": data}
            ret["create"] = True
            return ret
        else:
            ret["error"] = "Can't connect to the server"
            return ret

if not elements or name not in elements:
        ret["changes"] = {"Name": name, "Params": data}
        ret["create"] = True
        if not __opts__["test"]:
            try:
                __salt__["glassfish.create_{}".format(elem_type)](
                    name, server=server, **data
                )
            except CommandExecutionError as error:
                ret["error"] = error
                return ret
    elif elements and any(data):
        current_data = __salt__["glassfish.get_{}".format(elem_type)](
            name, server=server
        )
        data_diff = _is_updated(current_data, data)
        if data_diff:
            ret["update"] = True
            ret["changes"] = data_diff
            if not __opts__["test"]:
                try:
                    __salt__["glassfish.update_{}".format(elem_type)](
                        name, server=server, **data
                    )
                except CommandExecutionError as error:
                    ret["error"] = error
    return ret

def _do_element_absent(name, elem_type, data, server=None):
    """
    Generic function to delete an element
    """
    ret = {"delete": False, "error": None}
    try:
        elements = __salt__["glassfish.enum_{}".format(elem_type)]()
    except requests.ConnectionError as error:
        if __opts__["test"]:
            ret["create"] = True
            return ret
        else:
            ret["error"] = "Can't connect to the server"
            return ret

if elements and name in elements:
        ret["delete"] = True
        if not __opts__["test"]:
            try:
                __salt__["glassfish.delete_{}".format(elem_type)](
                    name, server=server, **data
                )
            except CommandExecutionError as error:
                ret["error"] = error
    return ret

def connection_factory_present(
    name,
    restype="connection_factory",
    description="",
    enabled=True,
    min_size=1,
    max_size=250,
    resize_quantity=2,
    idle_timeout=300,
    wait_timeout=60,
    reconnect_on_failure=False,
    transaction_support="",
    connection_validation=False,
    server=None,
):
    """
    Ensures that the Connection Factory is present

name
        Name of the connection factory

restype
        Type of the connection factory, can be either ``connection_factory``,
        ``queue_connection_factory` or ``topic_connection_factory``,
        defaults to ``connection_factory``

description
        Description of the connection factory

enabled
        Is the connection factory enabled? defaults to ``true``

min_size
        Minimum and initial number of connections in the pool, defaults to ``1``

max_size
        Maximum number of connections that can be created in the pool, defaults to ``250``

resize_quantity
        Number of connections to be removed when idle_timeout expires, defaults to ``2``

idle_timeout
        Maximum time a connection can remain idle in the pool, in seconds, defaults to ``300``

wait_timeout
        Maximum time a caller can wait before timeout, in seconds, defaults to ``60``

reconnect_on_failure
        Close all connections and reconnect on failure (or reconnect only when used), defaults to ``false``
    transaction_support
        Level of transaction support, can be either ``XATransaction``, ``LocalTransaction`` or ``NoTransaction``

connection_validation
        Connection validation is required, defaults to ``false``
    """
    ret = {"name": name, "result": None, "comment": None, "changes": {}}

# Manage parameters
    pool_data = {}
    res_data = {}
    pool_name = "{}-Connection-Pool".format(name)
    if restype == "topic_connection_factory":
        pool_data["connectionDefinitionName"] = "javax.jms.TopicConnectionFactory"
    elif restype == "queue_connection_factory":
        pool_data["connectionDefinitionName"] = "javax.jms.QueueConnectionFactory"
    elif restype == "connection_factory":
        pool_data["connectionDefinitionName"] = "javax.jms.ConnectionFactory"
    else:
        ret["result"] = False
        ret["comment"] = "Invalid restype"
        return ret
    pool_data["description"] = description
    res_data["description"] = description
    res_data["enabled"] = enabled
    res_data["poolName"] = pool_name
    pool_data["steadyPoolSize"] = min_size
    pool_data["maxPoolSize"] = max_size
    pool_data["poolResizeQuantity"] = resize_quantity
    pool_data["idleTimeoutInSeconds"] = idle_timeout
    pool_data["maxWaitTimeInMillis"] = wait_timeout * 1000
    pool_data["failAllConnections"] = reconnect_on_failure
    if transaction_support:
        if transaction_support == "xa_transaction":
            pool_data["transactionSupport"] = "XATransaction"
        elif transaction_support == "local_transaction":
            pool_data["transactionSupport"] = "LocalTransaction"
        elif transaction_support == "no_transaction":
            pool_data["transactionSupport"] = "NoTransaction"
        else:
            ret["result"] = False
            ret["comment"] = "Invalid transaction_support"
            return ret
    pool_data["isConnectionValidationRequired"] = connection_validation

pool_ret = _do_element_present(pool_name, "connector_c_pool", pool_data, server)
    res_ret = _do_element_present(name, "connector_resource", res_data, server)

if not pool_ret["error"] and not res_ret["error"]:
        if not __opts__["test"]:
            ret["result"] = True

if pool_ret["create"] or res_ret["create"]:
            ret["changes"]["pool"] = pool_ret["changes"]
            ret["changes"]["resource"] = res_ret["changes"]
            if __opts__["test"]:
                ret["comment"] = "Connection factory set to be created"
            else:
                ret["comment"] = "Connection factory created"
        elif pool_ret["update"] or res_ret["update"]:
            ret["changes"]["pool"] = pool_ret["changes"]
            ret["changes"]["resource"] = res_ret["changes"]
            if __opts__["test"]:
                ret["comment"] = "Connection factory set to be updated"
            else:
                ret["comment"] = "Connection factory updated"
        else:
            ret["result"] = True
            ret["changes"] = {}
            ret["comment"] = "Connection factory is already up-to-date"
    else:
        ret["result"] = False
        ret["comment"] = "ERROR: {} // {}".format(pool_ret["error"], res_ret["error"])

return ret

def connection_factory_absent(name, both=True, server=None):
    """
    Ensures the transaction factory is absent.

name
        Name of the connection factory

both
        Delete both the pool and the resource, defaults to ``true``
    """
    ret = {"name": name, "result": None, "comment": None, "changes": {}}
    pool_name = "{}-Connection-Pool".format(name)
    pool_ret = _do_element_absent(
        pool_name, "connector_c_pool", {"cascade": both}, server
    )

if not pool_ret["error"]:
        if __opts__["test"] and pool_ret["delete"]:
            ret["comment"] = "Connection Factory set to be deleted"
        elif pool_ret["delete"]:
            ret["result"] = True
            ret["comment"] = "Connection Factory deleted"
        else:
            ret["result"] = True
            ret["comment"] = "Connection Factory doesn't exist"
    else:
        ret["result"] = False
        ret["comment"] = "Error: {}".format(pool_ret["error"])
    return ret

def destination_present(
    name, physical, restype="queue", description="", enabled=True, server=None
):
    """
    Ensures that the JMS Destination Resource (queue or topic) is present

name
        The JMS Queue/Topic name

physical
        The Physical destination name

restype
        The JMS Destination resource type, either ``queue`` or ``topic``, defaults is ``queue``

description
        A description of the resource

enabled
        Defaults to ``True``
    """
    ret = {"name": name, "result": None, "comment": None, "changes": {}}

params = {}
    # Set parameters dict
    if restype == "queue":
        params["resType"] = "javax.jms.Queue"
        params["className"] = "com.sun.messaging.Queue"
    elif restype == "topic":
        params["resType"] = "javax.jms.Topic"
        params["className"] = "com.sun.messaging.Topic"
    else:
        ret["result"] = False
        ret["comment"] = "Invalid restype"
        return ret
    params["properties"] = {"Name": physical}
    params["description"] = description
    params["enabled"] = enabled

jms_ret = _do_element_present(name, "admin_object_resource", params, server)
    if not jms_ret["error"]:
        if not __opts__["test"]:
            ret["result"] = True
        if jms_ret["create"] and __opts__["test"]:
            ret["comment"] = "JMS Queue set to be created"
        elif jms_ret["create"]:
            ret["changes"] = jms_ret["changes"]
            ret["comment"] = "JMS queue created"
        elif jms_ret["update"] and __opts__["test"]:
            ret["comment"] = "JMS Queue set to be updated"
        elif jms_ret["update"]:
            ret["changes"] = jms_ret["changes"]
            ret["comment"] = "JMS Queue updated"
        else:
            ret["result"] = True
            ret["comment"] = "JMS Queue already up-to-date"
    else:
        ret["result"] = False
        ret["comment"] = "Error from API: {}".format(jms_ret["error"])
    return ret

def destination_absent(name, server=None):
    """
    Ensures that the JMS Destination doesn't exists

name
        Name of the JMS Destination
    """
    ret = {"name": name, "result": None, "comment": None, "changes": {}}
    jms_ret = _do_element_absent(name, "admin_object_resource", {}, server)
    if not jms_ret["error"]:
        if __opts__["test"] and jms_ret["delete"]:
            ret["comment"] = "JMS Queue set to be deleted"
        elif jms_ret["delete"]:
            ret["result"] = True
            ret["comment"] = "JMS Queue deleted"
        else:
            ret["result"] = True
            ret["comment"] = "JMS Queue doesn't exist"
    else:
        ret["result"] = False
        ret["comment"] = "Error: {}".format(jms_ret["error"])
    return ret

def jdbc_datasource_present(
    name,
    description="",
    enabled=True,
    restype="datasource",
    vendor="mysql",
    sql_url="",
    sql_user="",
    sql_password="",
    min_size=8,
    max_size=32,
    resize_quantity=2,
    idle_timeout=300,
    wait_timeout=60,
    non_transactional=False,
    transaction_isolation="",
    isolation_guaranteed=True,
    server=None,
):
    """
    Ensures that the JDBC Datasource exists

name
        Name of the datasource

description
        Description of the datasource

enabled
        Is the datasource enabled? defaults to ``true``

restype
        Resource type, can be ``datasource``, ``xa_datasource``,
        ``connection_pool_datasource`` or ``driver``, defaults to ``datasource``

vendor
        SQL Server type, currently supports ``mysql``,
        ``postgresql`` and ``mssql``, defaults to ``mysql``

sql_url
        URL of the server in jdbc form

sql_user
        Username for the server

sql_password
        Password for that username

min_size
        Minimum and initial number of connections in the pool, defaults to ``8``

max_size
        Maximum number of connections that can be created in the pool, defaults to ``32``

resize_quantity
        Number of connections to be removed when idle_timeout expires, defaults to ``2``

idle_timeout
        Maximum time a connection can remain idle in the pool, in seconds, defaults to ``300``

wait_timeout
        Maximum time a caller can wait before timeout, in seconds, defaults to ``60``

non_transactional
        Return non-transactional connections

transaction_isolation
        Defaults to the JDBC driver default

isolation_guaranteed
        All connections use the same isolation level
    """
    ret = {"name": name, "result": None, "comment": None, "changes": {}}

# Manage parameters
    res_name = "jdbc/{}".format(name)
    pool_data = {}
    pool_data_properties = {}
    res_data = {}
    if restype == "datasource":
        pool_data["resType"] = "javax.sql.DataSource"
    elif restype == "xa_datasource":
        pool_data["resType"] = "javax.sql.XADataSource"
    elif restype == "connection_pool_datasource":
        pool_data["resType"] = "javax.sql.ConnectionPoolDataSource"
    elif restype == "driver":
        pool_data["resType"] = "javax.sql.Driver"

datasources = {}
    datasources["mysql"] = {
        "driver": "com.mysql.jdbc.Driver",
        "datasource": "com.mysql.jdbc.jdbc2.optional.MysqlDataSource",
        "xa_datasource": "com.mysql.jdbc.jdbc2.optional.MysqlXADataSource",
        "connection_pool_datasource": (
            "com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource"
        ),
    }
    datasources["postgresql"] = {
        "driver": "org.postgresql.Driver",
        "datasource": "org.postgresql.ds.PGSimpleDataSource",
        "xa_datasource": "org.postgresql.xa.PGXADataSource",
        "connection_pool_datasource": "org.postgresql.ds.PGConnectionPoolDataSource",
    }
    datasources["mssql"] = {
        "driver": "com.microsoft.sqlserver.jdbc.SQLServerDriver",
        "datasource": "com.microsoft.sqlserver.jdbc.SQLServerDataSource",
        "xa_datasource": "com.microsoft.sqlserver.jdbc.SQLServerXADataSource",
        "connection_pool_datasource": (
            "com.microsoft.sqlserver.jdbc.SQLServerConnectionPoolDataSource"
        ),
    }

if restype == "driver":
        pool_data["driverClassname"] = datasources[vendor]["driver"]
    else:
        pool_data["datasourceClassname"] = datasources[vendor][restype]

pool_data_properties["url"] = sql_url
    pool_data_properties["user"] = sql_user
    pool_data_properties["password"] = sql_password
    pool_data["properties"] = pool_data_properties
    pool_data["description"] = description
    res_data["description"] = description
    res_data["poolName"] = name
    res_data["enabled"] = enabled
    pool_data["steadyPoolSize"] = min_size
    pool_data["maxPoolSize"] = max_size
    pool_data["poolResizeQuantity"] = resize_quantity
    pool_data["idleTimeoutInSeconds"] = idle_timeout
    pool_data["maxWaitTimeInMillis"] = wait_timeout * 1000
    pool_data["nonTransactionalConnections"] = non_transactional
    pool_data["transactionIsolationLevel"] = transaction_isolation
    pool_data["isIsolationLevelGuaranteed"] = isolation_guaranteed

pool_ret = _do_element_present(name, "jdbc_connection_pool", pool_data, server)
    res_ret = _do_element_present(res_name, "jdbc_resource", res_data, server)

if not pool_ret["error"] and not res_ret["error"]:
        if not __opts__["test"]:
            ret["result"] = True

if pool_ret["create"] or res_ret["create"]:
            ret["changes"]["pool"] = pool_ret["changes"]
            ret["changes"]["resource"] = res_ret["changes"]
            if __opts__["test"]:
                ret["comment"] = "JDBC Datasource set to be created"
            else:
                ret["comment"] = "JDBC Datasource created"
        elif pool_ret["update"] or res_ret["update"]:
            ret["changes"]["pool"] = pool_ret["changes"]
            ret["changes"]["resource"] = res_ret["changes"]
            if __opts__["test"]:
                ret["comment"] = "JDBC Datasource set to be updated"
            else:
                ret["comment"] = "JDBC Datasource updated"
        else:
            ret["result"] = True
            ret["changes"] = {}
            ret["comment"] = "JDBC Datasource is already up-to-date"
    else:
        ret["result"] = False
        ret["comment"] = "ERROR: {} // {}".format(pool_ret["error"], res_ret["error"])

return ret

def jdbc_datasource_absent(name, both=True, server=None):
    """
    Ensures the JDBC Datasource doesn't exists

name
        Name of the datasource
    both
        Delete both the pool and the resource, defaults to ``true``
    """
    ret = {"name": name, "result": None, "comment": None, "changes": {}}
    pool_ret = _do_element_absent(
        name, "jdbc_connection_pool", {"cascade": both}, server
    )

if not pool_ret["error"]:
        if __opts__["test"] and pool_ret["delete"]:
            ret["comment"] = "JDBC Datasource set to be deleted"
        elif pool_ret["delete"]:
            ret["result"] = True
            ret["comment"] = "JDBC Datasource deleted"
        else:
            ret["result"] = True
            ret["comment"] = "JDBC Datasource doesn't exist"
    else:
        ret["result"] = False
        ret["comment"] = "Error: {}".format(pool_ret["error"])
    return ret

def system_properties_present(server=None, **kwargs):
    """
    Ensures that the system properties are present

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

del kwargs["name"]
    try:
        data = __salt__["glassfish.get_system_properties"](server=server)
    except requests.ConnectionError as error:
        if __opts__["test"]:
            ret["changes"] = kwargs
            ret["result"] = None
            return ret
        else:
            ret["error"] = "Can't connect to the server"
            return ret

ret["changes"] = {"data": data, "kwargs": kwargs}
    if not data == kwargs:
        data.update(kwargs)
        if not __opts__["test"]:
            try:
                __salt__["glassfish.update_system_properties"](data, server=server)
                ret["changes"] = kwargs
                ret["result"] = True
                ret["comment"] = "System properties updated"
            except CommandExecutionError as error:
                ret["comment"] = error
                ret["result"] = False
        else:
            ret["result"] = None
            ret["changes"] = kwargs
            ret["coment"] = "System properties would have been updated"
    else:
        ret["changes"] = {}
        ret["result"] = True
        ret["comment"] = "System properties are already up-to-date"
    return ret

def system_properties_absent(name, server=None):
    """
    Ensures that the system property doesn't exists

name
        Name of the system property
    """
    ret = {"name": "", "result": None, "comment": None, "changes": {}}

try:
        data = __salt__["glassfish.get_system_properties"](server=server)
    except requests.ConnectionError as error:
        if __opts__["test"]:
            ret["changes"] = {"Name": name}
            ret["result"] = None
            return ret
        else:
            ret["error"] = "Can't connect to the server"
            return ret

if name in data:
        if not __opts__["test"]:
            try:
                __salt__["glassfish.delete_system_properties"](name, server=server)
                ret["result"] = True
                ret["comment"] = "System properties deleted"
            except CommandExecutionError as error:
                ret["comment"] = error
                ret["result"] = False
        else:
            ret["result"] = None
            ret["comment"] = "System properties would have been deleted"
        ret["changes"] = {"Name": name}
    else:
        ret["result"] = True
        ret["comment"] = "System properties are already absent"
    return ret