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

"""
Management of SQLite3 databases
===============================

.. versionadded:: 2016.3.0

:depends:   - SQLite3 Python Module
:configuration: See :py:mod:`salt.modules.sqlite3` for setup instructions

The sqlite3 module is used to create and manage sqlite3 databases
and execute queries

Here is an example of creating a table using sql statements:

.. code-block:: yaml

users:
      sqlite3.table_present:
        - db: /var/www/data/app.sqlite
        - schema: CREATE TABLE `users` (`username` TEXT COLLATE NOCASE UNIQUE NOT NULL, `password` BLOB NOT NULL, `salt` BLOB NOT NULL, `last_login` INT)

Here is an example of creating a table using yaml/jinja instead of sql:

.. code-block:: yaml

users:
      sqlite3.table_present:
        - db: /var/www/app.sqlite
        - schema:
          - email TEXT COLLATE NOCASE UNIQUE NOT NULL
          - firstname TEXT NOT NULL
          - lastname TEXT NOT NULL
          - company TEXT NOT NULL
          - password BLOB NOT NULL
          - salt BLOB NOT NULL

Here is an example of making sure a table is absent:

.. code-block:: yaml

badservers:
      sqlite3.table_absent:
        - db: /var/www/data/users.sqlite

Sometimes you would to have specific data in tables to be used by other services
Here is an example of making sure rows with specific data exist:

.. code-block:: yaml

user_john_doe_xyz:
      sqlite3.row_present:
        - db: /var/www/app.sqlite
        - table: users
        - where_sql: email='john.doe@companyxyz.com'
        - data:
            email: john.doe@companyxyz.com
            lastname: doe
            firstname: john
            company: companyxyz.com
            password: abcdef012934125
            salt: abcdef012934125
        - require:
          - sqlite3: users

Here is an example of removing a row from a table:

.. code-block:: yaml

user_john_doe_abc:
      sqlite3.row_absent:
        - db: /var/www/app.sqlite
        - table: users
        - where_sql: email="john.doe@companyabc.com"
        - require:
          - sqlite3: users

Note that there is no explicit state to perform random queries, however, this
can be approximated with sqlite3's module functions and module.run:

.. code-block:: yaml

zone-delete:
      module.run:
        - name: sqlite3.modify
        - db: {{ db }}
        - sql: "DELETE FROM records WHERE id > {{ count[0] }} AND domain_id = {{ domain_id }}"
        - watch:
          - sqlite3: zone-insert-12
"""

try:
    import sqlite3

HAS_SQLITE3 = True
except ImportError:
    HAS_SQLITE3 = False

def __virtual__():
    """
    Only load if the sqlite3 module is available
    """
    if HAS_SQLITE3:
        return True
    return (False, "Unable to import sqlite3")

def row_absent(name, db, table, where_sql, where_args=None):
    """
    Makes sure the specified row is absent in db.  If multiple rows
    match where_sql, then the state will fail.

name
        Only used as the unique ID

db
        The database file name

table
        The table name to check

where_sql
        The sql to select the row to check

where_args
        The list parameters to substitute in where_sql
    """
    changes = {"name": name, "changes": {}, "result": None, "comment": ""}
    conn = None
    try:
        conn = sqlite3.connect(db, detect_types=sqlite3.PARSE_DECLTYPES)
        conn.row_factory = _dict_factory
        rows = None
        if where_args is None:
            rows = _query(conn, "SELECT * FROM `" + table + "` WHERE " + where_sql)
        else:
            rows = _query(
                conn, "SELECT * FROM `" + table + "` WHERE " + where_sql, where_args
            )

if len(rows) > 1:
            changes["result"] = False
            changes["comment"] = "More than one row matched the specified query"
        elif len(rows) == 1:
            if __opts__["test"]:
                changes["result"] = True
                changes["comment"] = "Row will be removed in " + table
                changes["changes"]["old"] = rows[0]

else:
                if where_args is None:
                    cursor = conn.execute(
                        "DELETE FROM `" + table + "` WHERE " + where_sql
                    )
                else:
                    cursor = conn.execute(
                        "DELETE FROM `" + table + "` WHERE " + where_sql, where_args
                    )
                conn.commit()
                if cursor.rowcount == 1:
                    changes["result"] = True
                    changes["comment"] = "Row removed"
                    changes["changes"]["old"] = rows[0]
                else:
                    changes["result"] = False
                    changes["comment"] = "Unable to remove row"
        else:
            changes["result"] = True
            changes["comment"] = "Row is absent"

except Exception as e:  # pylint: disable=broad-except
        changes["result"] = False
        changes["comment"] = str(e)

finally:
        if conn:
            conn.close()

return changes

def row_present(name, db, table, data, where_sql, where_args=None, update=False):
    """
    Checks to make sure the given row exists. If row exists and update is True
    then row will be updated with data. Otherwise it will leave existing
    row unmodified and check it against data. If the existing data
    doesn't match data_check the state will fail.  If the row doesn't
    exist then it will insert data into the table. If more than one
    row matches, then the state will fail.

name
        Only used as the unique ID

db
        The database file name

table
        The table name to check the data

data
        The dictionary of key/value pairs to check against if
        row exists, insert into the table if it doesn't

where_sql
        The sql to select the row to check

where_args
        The list parameters to substitute in where_sql

update
        True will replace the existing row with data
        When False and the row exists and data does not equal
        the row data then the state will fail
    """
    changes = {"name": name, "changes": {}, "result": None, "comment": ""}
    conn = None
    try:
        conn = sqlite3.connect(db, detect_types=sqlite3.PARSE_DECLTYPES)
        conn.row_factory = _dict_factory
        rows = None
        if where_args is None:
            rows = _query(conn, "SELECT * FROM `" + table + "` WHERE " + where_sql)
        else:
            rows = _query(
                conn, "SELECT * FROM `" + table + "` WHERE " + where_sql, where_args
            )

if len(rows) > 1:
            changes["result"] = False
            changes["comment"] = "More than one row matched the specified query"
        elif len(rows) == 1:
            for key, value in data.items():
                if key in rows[0] and rows[0][key] != value:
                    if update:
                        if __opts__["test"]:
                            changes["result"] = True
                            changes["comment"] = "Row will be update in " + table

else:
                            columns = []
                            params = []
                            for key, value in data.items():
                                columns.append("`" + key + "`=?")
                                params.append(value)

if where_args is not None:
                                params += where_args

sql = "UPDATE `" + table + "` SET "
                            sql += ",".join(columns)
                            sql += " WHERE "
                            sql += where_sql
                            cursor = conn.execute(sql, params)
                            conn.commit()
                            if cursor.rowcount == 1:
                                changes["result"] = True
                                changes["comment"] = "Row updated"
                                changes["changes"]["old"] = rows[0]
                                changes["changes"]["new"] = data
                            else:
                                changes["result"] = False
                                changes["comment"] = "Row update failed"
                    else:
                        changes["result"] = False
                        changes["comment"] = (
                            "Existing data does" + "not match desired state"
                        )
                        break

if changes["result"] is None:
                changes["result"] = True
                changes["comment"] = "Row exists"
        else:
            if __opts__["test"]:
                changes["result"] = True
                changes["changes"]["new"] = data
                changes["comment"] = "Row will be inserted into " + table
            else:
                columns = []
                value_stmt = []
                values = []
                for key, value in data.items():
                    value_stmt.append("?")
                    values.append(value)
                    columns.append("`" + key + "`")

sql = "INSERT INTO `" + table + "` ("
                sql += ",".join(columns)
                sql += ") VALUES ("
                sql += ",".join(value_stmt)
                sql += ")"
                cursor = conn.execute(sql, values)
                conn.commit()
                if cursor.rowcount == 1:
                    changes["result"] = True
                    changes["changes"]["new"] = data
                    changes["comment"] = "Inserted row"
                else:
                    changes["result"] = False
                    changes["comment"] = "Unable to insert data"

except Exception as e:  # pylint: disable=broad-except
        changes["result"] = False
        changes["comment"] = str(e)

finally:
        if conn:
            conn.close()

return changes

def table_absent(name, db):
    """
    Make sure the specified table does not exist

name
        The name of the table

db
        The name of the database file
    """
    changes = {"name": name, "changes": {}, "result": None, "comment": ""}
    conn = None
    try:
        conn = sqlite3.connect(db, detect_types=sqlite3.PARSE_DECLTYPES)
        tables = _query(
            conn,
            "SELECT sql FROM sqlite_master " + " WHERE type='table' AND name=?",
            [name],
        )

if len(tables) == 1:
            if __opts__["test"]:
                changes["result"] = True
                changes["comment"] = "'" + name + "' will be dropped"
            else:
                conn.execute("DROP TABLE " + name)
                conn.commit()
                changes["changes"]["old"] = tables[0][0]
                changes["result"] = True
                changes["comment"] = "'" + name + "' was dropped"
        elif len(tables) == 0:
            changes["result"] = True
            changes["comment"] = "'" + name + "' is already absent"
        else:
            changes["result"] = False
            changes["comment"] = "Multiple tables with the same name='" + name + "'"

except Exception as e:  # pylint: disable=broad-except
        changes["result"] = False
        changes["comment"] = str(e)

finally:
        if conn:
            conn.close()

return changes

def table_present(name, db, schema, force=False):
    """
    Make sure the specified table exists with the specified schema

name
        The name of the table

db
        The name of the database file

schema
        The dictionary containing the schema information

force
        If the name of the table exists and force is set to False,
        the state will fail.  If force is set to True, the existing
        table will be replaced with the new table
    """
    changes = {"name": name, "changes": {}, "result": None, "comment": ""}
    conn = None
    try:
        conn = sqlite3.connect(db, detect_types=sqlite3.PARSE_DECLTYPES)
        tables = _query(
            conn,
            "SELECT sql FROM sqlite_master " + "WHERE type='table' AND name=?",
            [name],
        )

if len(tables) == 1:
            sql = None
            if isinstance(schema, str):
                sql = schema.strip()
            else:
                sql = _get_sql_from_schema(name, schema)

if sql != tables[0][0]:
                if force:
                    if __opts__["test"]:
                        changes["result"] = True
                        changes["changes"]["old"] = tables[0][0]
                        changes["changes"]["new"] = sql
                        changes["comment"] = "'" + name + "' will be replaced"
                    else:
                        conn.execute("DROP TABLE `" + name + "`")
                        conn.execute(sql)
                        conn.commit()
                        changes["result"] = True
                        changes["changes"]["old"] = tables[0][0]
                        changes["changes"]["new"] = sql
                        changes["comment"] = "Replaced '" + name + "'"
                else:
                    changes["result"] = False
                    changes["comment"] = (
                        "Expected schema=" + sql + "\nactual schema=" + tables[0][0]
                    )
            else:
                changes["result"] = True
                changes["comment"] = "'" + name + "' exists with matching schema"
        elif len(tables) == 0:
            # Create the table
            sql = None
            if isinstance(schema, str):
                sql = schema
            else:
                sql = _get_sql_from_schema(name, schema)
            if __opts__["test"]:
                changes["result"] = True
                changes["changes"]["new"] = sql
                changes["comment"] = "'" + name + "' will be created"
            else:
                conn.execute(sql)
                conn.commit()
                changes["result"] = True
                changes["changes"]["new"] = sql
                changes["comment"] = "Created table '" + name + "'"
        else:
            changes["result"] = False
            changes["comment"] = "Multiple tables with the same name=" + name

except Exception as e:  # pylint: disable=broad-except
        changes["result"] = False
        changes["comment"] = str(e)

finally:
        if conn:
            conn.close()

return changes

def _query(conn, sql, parameters=None):
    cursor = None
    if parameters is None:
        cursor = conn.execute(sql)
    else:
        cursor = conn.execute(sql, parameters)
    return cursor.fetchall()

def _get_sql_from_schema(name, schema):
    return "CREATE TABLE `" + name + "` (" + ",".join(schema) + ")"

def _dict_factory(cursor, row):
    d = {}
    for idx, col in enumerate(cursor.description):
        d[col[0]] = row[idx]
    return d