File Manager

003 File Manager

Current Path: /usr/local/lib/python3.8/site-packages/salt/states

usr / local / lib / python3.8 / site-packages / salt / states /

📁 ..
📄 __init__.py(25 B)
📁 __pycache__
📄 acme.py(5.08 KB)
📄 alias.py(2.49 KB)
📄 alternatives.py(6.75 KB)
📄 ansiblegate.py(7.61 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(67.76 KB)
📄 artifactory.py(6.84 KB)
📄 at.py(7.54 KB)
📄 augeas.py(10.57 KB)
📄 aws_sqs.py(2.59 KB)
📄 azurearm_compute.py(10.86 KB)
📄 azurearm_dns.py(25.09 KB)
📄 azurearm_network.py(87.86 KB)
📄 azurearm_resource.py(27.22 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.6 KB)
📄 boto3_route53.py(37.54 KB)
📄 boto3_sns.py(12.69 KB)
📄 boto_apigateway.py(82.78 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.38 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(61.77 KB)
📄 bower.py(8.26 KB)
📄 btrfs.py(10.31 KB)
📄 cabal.py(5.73 KB)
📄 ceph.py(1.9 KB)
📄 chef.py(3.68 KB)
📄 chocolatey.py(17.33 KB)
📄 chronos_job.py(4.6 KB)
📄 cimc.py(14.32 KB)
📄 cisconso.py(3.14 KB)
📄 cloud.py(14.4 KB)
📄 cmd.py(41.24 KB)
📄 composer.py(8.38 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.38 KB)
📄 docker_network.py(36.34 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(21.16 KB)
📄 esxdatacenter.py(3.24 KB)
📄 esxi.py(61.77 KB)
📄 esxvm.py(18.86 KB)
📄 etcd_mod.py(8.36 KB)
📄 ethtool.py(7.84 KB)
📄 event.py(2.48 KB)
📄 file.py(299.79 KB)
📄 firewall.py(1.33 KB)
📄 firewalld.py(26.08 KB)
📄 gem.py(7.13 KB)
📄 git.py(124.23 KB)
📄 github.py(27.25 KB)
📄 glance_image.py(2.26 KB)
📄 glassfish.py(21.47 KB)
📄 glusterfs.py(12.12 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.57 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.43 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.81 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.39 KB)
📄 ipset.py(9.66 KB)
📄 iptables.py(25.96 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.29 KB)
📄 kmod.py(8.38 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.43 KB)
📄 locale.py(2.52 KB)
📄 logadm.py(4.73 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.59 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(17.99 KB)
📄 mongodb_database.py(1.65 KB)
📄 mongodb_user.py(6.26 KB)
📄 monit.py(2.68 KB)
📄 mount.py(49.55 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.48 KB)
📄 netsnmp.py(11.33 KB)
📄 netusers.py(16.1 KB)
📄 network.py(23.7 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.67 KB)
📄 nxos_upgrade.py(3.5 KB)
📄 openstack_config.py(3.26 KB)
📄 openvswitch_bridge.py(3.13 KB)
📄 openvswitch_port.py(17.25 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.48 KB)
📄 pecl.py(3.65 KB)
📄 pip_state.py(37.55 KB)
📄 pkg.py(127.05 KB)
📄 pkgbuild.py(11.37 KB)
📄 pkgng.py(685 B)
📄 pkgrepo.py(23.59 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.58 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)
📄 rsync.py(4.45 KB)
📄 rvm.py(6.56 KB)
📄 salt_proxy.py(1.34 KB)
📄 saltmod.py(30.88 KB)
📄 saltutil.py(8.91 KB)
📄 schedule.py(11.89 KB)
📄 selinux.py(18.61 KB)
📄 serverdensity_device.py(6.41 KB)
📄 service.py(37.06 KB)
📄 slack.py(4.98 KB)
📄 smartos.py(44.89 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.1 KB)
📄 ssh_known_hosts.py(7.87 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(3.82 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(35.43 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.06 KB)
📄 virtualenv_mod.py(11.21 KB)
📄 webutil.py(3.78 KB)
📄 win_certutil.py(2.88 KB)
📄 win_dacl.py(7.96 KB)
📄 win_dism.py(13.02 KB)
📄 win_dns_client.py(8.32 KB)
📄 win_firewall.py(6.87 KB)
📄 win_iis.py(31.56 KB)
📄 win_lgpo.py(25.41 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_smtp_server.py(10.01 KB)
📄 win_snmp.py(6.64 KB)
📄 win_system.py(13.78 KB)
📄 win_wua.py(14.47 KB)
📄 win_wusa.py(3.53 KB)
📄 winrepo.py(2.74 KB)
📄 wordpress.py(4.82 KB)
📄 x509.py(26.98 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(15.76 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.27 KB)
📄 zk_concurrency.py(5.81 KB)
📄 zone.py(46.49 KB)
📄 zookeeper.py(11.53 KB)
📄 zpool.py(13.08 KB)

Editing: 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

003 File Manager

Editing: glassfish.py

Upload File

Create Folder