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

"""
Management of Zabbix hosts.

:codeauthor: Jiri Kotlin <jiri.kotlin@ultimum.io>

"""

from collections.abc import Mapping
from copy import deepcopy

import salt.utils.dictdiffer
import salt.utils.json

def __virtual__():
    """
    Only make these states available if Zabbix module is available.
    """
    if "zabbix.host_create" in __salt__:
        return True
    return (False, "zabbix module could not be loaded")

def present(host, groups, interfaces, **kwargs):
    """
    Ensures that the host exists, eventually creates new host.
    NOTE: please use argument visible_name instead of name to not mess with name from salt sls. This function accepts
    all standard host properties: keyword argument names differ depending on your zabbix version, see:
    https://www.zabbix.com/documentation/2.4/manual/api/reference/host/object#host

.. versionadded:: 2016.3.0

:param host: technical name of the host
    :param groups: groupids of host groups to add the host to
    :param interfaces: interfaces to be created for the host
    :param proxy_host: Optional proxy name or proxyid to monitor host
    :param inventory: Optional list or dictionary of inventory names and values
    :param _connection_user: Optional - zabbix user (can also be set in opts or pillar, see module's docstring)
    :param _connection_password: Optional - zabbix password (can also be set in opts or pillar, see module's docstring)
    :param _connection_url: Optional - url of zabbix frontend (can also be set in opts, pillar, see module's docstring)
    :param visible_name: Optional - string with visible name of the host, use 'visible_name' instead of 'name'
        parameter to not mess with value supplied from Salt sls file.
    :param inventory_clean: Optional - Boolean value that selects if the current inventory will be cleaned and
        overwritten by the declared inventory list (True); or if the inventory will be kept and only updated with
        inventory list contents (False). Defaults to True

.. code-block:: yaml

create_test_host:
            zabbix_host.present:
                - host: TestHostWithInterfaces
                - proxy_host: 12345
                - groups:
                    - 5
                    - 6
                    - 7
                - interfaces:
                    - test1.example.com:
                        - ip: '192.168.1.8'
                        - type: 'Agent'
                        - port: 92
                    - testing2_create:
                        - ip: '192.168.1.9'
                        - dns: 'test2.example.com'
                        - type: 'agent'
                        - main: false
                    - testovaci1_ipmi:
                        - ip: '192.168.100.111'
                        - type: 'ipmi'
                - inventory:
                    - alias: some alias
                    - asset_tag: jlm3937

"""
    connection_args = {}
    if "_connection_user" in kwargs:
        connection_args["_connection_user"] = kwargs.pop("_connection_user")
    if "_connection_password" in kwargs:
        connection_args["_connection_password"] = kwargs.pop("_connection_password")
    if "_connection_url" in kwargs:
        connection_args["_connection_url"] = kwargs.pop("_connection_url")

ret = {"name": host, "changes": {}, "result": False, "comment": ""}

# Comment and change messages
    comment_host_created = "Host {} created.".format(host)
    comment_host_updated = "Host {} updated.".format(host)
    comment_host_notcreated = "Unable to create host: {}. ".format(host)
    comment_host_exists = "Host {} already exists.".format(host)
    changes_host_created = {
        host: {
            "old": "Host {} does not exist.".format(host),
            "new": "Host {} created.".format(host),
        }
    }

def _interface_format(interfaces_data):
        """
        Formats interfaces from SLS file into valid JSON usable for zabbix API.
        Completes JSON with default values.

:param interfaces_data: list of interfaces data from SLS file

"""

if not interfaces_data:
            return list()

interface_attrs = ("ip", "dns", "main", "type", "useip", "port", "details")
        interfaces_json = salt.utils.json.loads(salt.utils.json.dumps(interfaces_data))
        interfaces_dict = dict()

for interface in interfaces_json:
            for intf in interface:
                intf_name = intf
                interfaces_dict[intf_name] = dict()
                for intf_val in interface[intf]:
                    for key, value in intf_val.items():
                        if key in interface_attrs:
                            interfaces_dict[intf_name][key] = value

interfaces_list = list()
        interface_ports = {
            "agent": ["1", "10050"],
            "snmp": ["2", "161"],
            "ipmi": ["3", "623"],
            "jmx": ["4", "12345"],
        }

for key, value in interfaces_dict.items():
            # Load interface values or default values
            interface_type = interface_ports[value["type"].lower()][0]
            main = "1" if str(value.get("main", "true")).lower() == "true" else "0"
            useip = "1" if str(value.get("useip", "true")).lower() == "true" else "0"
            interface_ip = value.get("ip", "")
            dns = value.get("dns", key)
            port = str(value.get("port", interface_ports[value["type"].lower()][1]))
            if interface_type == "2":
                if not value.get("details", False):
                    details_version = "2"
                    details_bulk = "1"
                    details_community = "{$SNMP_COMMUNITY}"
                else:
                    val_details = {}
                    for detail in value.get("details"):
                        val_details.update(detail)
                    details_version = val_details.get("version", "2")
                    details_bulk = val_details.get("bulk", "1")
                    details_community = val_details.get(
                        "community", "{$SNMP_COMMUNITY}"
                    )
                details = {
                    "version": details_version,
                    "bulk": details_bulk,
                    "community": details_community,
                }
                if details_version == "3":
                    details_securitylevel = val_details.get("securitylevel", "0")
                    details_securityname = val_details.get("securityname", "")
                    details_contextname = val_details.get("contextname", "")
                    details["securitylevel"] = details_securitylevel
                    details["securityname"] = details_securityname
                    details["contextname"] = details_contextname
                    if int(details_securitylevel) > 0:
                        details_authpassphrase = val_details.get("authpassphrase", "")
                        details_authprotocol = val_details.get("authprotocol", "0")
                        details["authpassphrase"] = details_authpassphrase
                        details["authprotocol"] = details_authprotocol
                        if int(details_securitylevel) > 1:
                            details_privpassphrase = val_details.get(
                                "privpassphrase", ""
                            )
                            details_privprotocol = val_details.get("privprotocol", "0")
                            details["privpassphrase"] = details_privpassphrase
                            details["privprotocol"] = details_privprotocol
            else:
                details = []

interfaces_list.append(
                {
                    "type": interface_type,
                    "main": main,
                    "useip": useip,
                    "ip": interface_ip,
                    "dns": dns,
                    "port": port,
                    "details": details,
                }
            )

interfaces_list_sorted = sorted(
            interfaces_list, key=lambda k: k["main"], reverse=True
        )

return interfaces_list_sorted

interfaces_formated = _interface_format(interfaces)

# Ensure groups are all groupid
    groupids = []
    for group in groups:
        if isinstance(group, str):
            groupid = __salt__["zabbix.hostgroup_get"](name=group, **connection_args)
            try:
                groupids.append(int(groupid[0]["groupid"]))
            except TypeError:
                ret["comment"] = "Invalid group {}".format(group)
                return ret
        else:
            groupids.append(group)
    groups = groupids

# Get and validate proxyid
    proxy_hostid = "0"
    if "proxy_host" in kwargs:
        proxy_host = kwargs.pop("proxy_host")
        # Test if proxy_host given as name
        if isinstance(proxy_host, str):
            try:
                proxy_hostid = __salt__["zabbix.run_query"](
                    "proxy.get",
                    {
                        "output": "proxyid",
                        "selectInterface": "extend",
                        "filter": {"host": "{}".format(proxy_host)},
                    },
                    **connection_args
                )[0]["proxyid"]
            except TypeError:
                ret["comment"] = "Invalid proxy_host {}".format(proxy_host)
                return ret
        # Otherwise lookup proxy_host as proxyid
        else:
            try:
                proxy_hostid = __salt__["zabbix.run_query"](
                    "proxy.get",
                    {"proxyids": "{}".format(proxy_host), "output": "proxyid"},
                    **connection_args
                )[0]["proxyid"]
            except TypeError:
                ret["comment"] = "Invalid proxy_host {}".format(proxy_host)
                return ret

# Selects if the current inventory should be substituted by the new one
    inventory_clean = kwargs.pop("inventory_clean", True)

inventory = kwargs.pop("inventory", None)
    new_inventory = {}
    if isinstance(inventory, Mapping):
        new_inventory = dict(inventory)
    elif inventory is not None:
        # Create dict of requested inventory items
        for inv_item in inventory:
            for k, v in inv_item.items():
                new_inventory[k] = str(v)

visible_name = kwargs.pop("visible_name", None)

host_extra_properties = {}
    if kwargs:
        host_properties_definition = [
            "description",
            "inventory_mode",
            "ipmi_authtype",
            "ipmi_password",
            "ipmi_privilege",
            "ipmi_username",
            "status",
            "tls_connect",
            "tls_accept",
            "tls_issuer",
            "tls_subject",
            "tls_psk_identity",
            "tls_psk",
        ]
        for param in host_properties_definition:
            if param in kwargs:
                host_extra_properties[param] = kwargs.pop(param)

host_exists = __salt__["zabbix.host_exists"](host, **connection_args)

if host_exists:
        host = __salt__["zabbix.host_get"](host=host, **connection_args)[0]
        hostid = host["hostid"]

update_host = False
        update_proxy = False
        update_hostgroups = False
        update_interfaces = False
        update_inventory = False

host_updated_params = {}
        for param in host_extra_properties:
            if param in host:
                if host[param] == host_extra_properties[param]:
                    continue
            host_updated_params[param] = host_extra_properties[param]
        if host_updated_params:
            update_host = True

host_inventory_mode = host["inventory_mode"]
        inventory_mode = host_extra_properties.get(
            "inventory_mode",
            "0" if host_inventory_mode == "-1" else host_inventory_mode,
        )

cur_proxy_hostid = host["proxy_hostid"]
        if proxy_hostid != cur_proxy_hostid:
            update_proxy = True

hostgroups = __salt__["zabbix.hostgroup_get"](hostids=hostid, **connection_args)
        cur_hostgroups = list()

for hostgroup in hostgroups:
            cur_hostgroups.append(int(hostgroup["groupid"]))

if set(groups) != set(cur_hostgroups):
            update_hostgroups = True

hostinterfaces = __salt__["zabbix.hostinterface_get"](
            hostids=hostid, **connection_args
        )

if hostinterfaces:
            hostinterfaces = sorted(hostinterfaces, key=lambda k: k["main"])
            hostinterfaces_copy = deepcopy(hostinterfaces)
            for hostintf in hostinterfaces_copy:
                hostintf.pop("interfaceid")
                hostintf.pop("hostid")
                # "bulk" is present only in snmp interfaces with Zabbix < 5.0
                if "bulk" in hostintf:
                    hostintf.pop("bulk")
                    # as we always sent the "details" it needs to be
                    # populated in Zabbix < 5.0 response:
                    if hostintf["type"] == "2":
                        hostintf["details"] = {
                            "version": "2",
                            "bulk": "1",
                            "community": "{$SNMP_COMMUNITY}",
                        }
                    else:
                        hostintf["details"] = []
            interface_diff = [
                x for x in interfaces_formated if x not in hostinterfaces_copy
            ] + [y for y in hostinterfaces_copy if y not in interfaces_formated]
            if interface_diff:
                update_interfaces = True

elif not hostinterfaces and interfaces:
            update_interfaces = True

# if inventory param is empty leave inventory as is don't compare it
        # if inventory_mode is '-1', the inventory will be erased, why compare it?
        if inventory is not None and inventory_mode != "-1":
            cur_inventory = __salt__["zabbix.host_inventory_get"](
                hostids=hostid, **connection_args
            )

inventory_diff = salt.utils.dictdiffer.diff(cur_inventory, new_inventory)
            if inventory_diff.changed():
                update_inventory = True

# Dry run, test=true mode
    if __opts__["test"]:
        if host_exists:
            if (
                update_host
                or update_hostgroups
                or update_interfaces
                or update_proxy
                or update_inventory
            ):
                ret["result"] = None
                ret["comment"] = comment_host_updated
            else:
                ret["result"] = True
                ret["comment"] = comment_host_exists
        else:
            ret["result"] = None
            ret["comment"] = comment_host_created
            ret["changes"] = changes_host_created
        return ret

error = []

if host_exists:
        ret["result"] = True
        if (
            update_host
            or update_hostgroups
            or update_interfaces
            or update_proxy
            or update_inventory
        ):

if update_host:
                # combine connection_args and host_updated_params
                sum_kwargs = deepcopy(host_updated_params)
                sum_kwargs.update(connection_args)
                hostupdate = __salt__["zabbix.host_update"](hostid, **sum_kwargs)
                ret["changes"]["host"] = str(host_updated_params)
                if "error" in hostupdate:
                    error.append(hostupdate["error"])
            if update_inventory:
                # combine connection_args, inventory, and clear_old
                sum_kwargs = deepcopy(new_inventory)
                sum_kwargs.update(connection_args)
                sum_kwargs["clear_old"] = inventory_clean
                sum_kwargs["inventory_mode"] = inventory_mode

hostupdate = __salt__["zabbix.host_inventory_set"](hostid, **sum_kwargs)
                ret["changes"]["inventory"] = str(new_inventory)
                if "error" in hostupdate:
                    error.append(hostupdate["error"])
            if update_proxy:
                hostupdate = __salt__["zabbix.host_update"](
                    hostid, proxy_hostid=proxy_hostid, **connection_args
                )
                ret["changes"]["proxy_hostid"] = str(proxy_hostid)
                if "error" in hostupdate:
                    error.append(hostupdate["error"])
            if update_hostgroups:
                hostupdate = __salt__["zabbix.host_update"](
                    hostid, groups=groups, **connection_args
                )
                ret["changes"]["groups"] = str(groups)
                if "error" in hostupdate:
                    error.append(hostupdate["error"])
            if update_interfaces:
                interfaceid_by_type = {
                    "1": [],  # agent
                    "2": [],  # snmp
                    "3": [],  # ipmi
                    "4": [],  # jmx
                }
                other_interfaces = []

if hostinterfaces:
                    for interface in hostinterfaces:
                        if interface["main"]:
                            interfaceid_by_type[interface["type"]].insert(
                                0, interface["interfaceid"]
                            )
                        else:
                            interfaceid_by_type[interface["type"]].append(
                                interface["interfaceid"]
                            )

def _update_interfaces(interface):
                    if not interfaceid_by_type[interface["type"]]:
                        ret = __salt__["zabbix.hostinterface_create"](
                            hostid,
                            interface["ip"],
                            dns=interface["dns"],
                            main=interface["main"],
                            if_type=interface["type"],
                            useip=interface["useip"],
                            port=interface["port"],
                            details=interface["details"],
                            **connection_args
                        )
                    else:
                        interfaceid = interfaceid_by_type[interface["type"]].pop(0)
                        ret = __salt__["zabbix.hostinterface_update"](
                            interfaceid=interfaceid,
                            ip=interface["ip"],
                            dns=interface["dns"],
                            main=interface["main"],
                            type=interface["type"],
                            useip=interface["useip"],
                            port=interface["port"],
                            details=interface["details"],
                            **connection_args
                        )
                    return ret

# First we try to update the "default" interfaces every host
                # needs at least one "default" interface
                for interface in interfaces_formated:
                    if interface["main"]:
                        updatedint = _update_interfaces(interface)
                        if "error" in updatedint:
                            error.append(updatedint["error"])
                    else:
                        other_interfaces.append(interface)

# Second we update the other interfaces
                for interface in other_interfaces:
                    updatedint = _update_interfaces(interface)
                    if "error" in updatedint:
                        error.append(updatedint["error"])

# And finally remove the ones that isn't in the host state
                for interface_type in interfaceid_by_type:
                    for interfaceid in interfaceid_by_type[interface_type]:
                        __salt__["zabbix.hostinterface_delete"](
                            interfaceids=interfaceid, **connection_args
                        )

ret["changes"]["interfaces"] = str(interfaces_formated)

ret["comment"] = comment_host_updated

else:
            ret["comment"] = comment_host_exists
    else:
        # combine connection_args and host_properties
        sum_kwargs = host_extra_properties
        sum_kwargs.update(connection_args)
        host_create = __salt__["zabbix.host_create"](
            host,
            groups,
            interfaces_formated,
            proxy_hostid=proxy_hostid,
            inventory=new_inventory,
            visible_name=visible_name,
            **sum_kwargs
        )

if "error" not in host_create:
            ret["result"] = True
            ret["comment"] = comment_host_created
            ret["changes"] = changes_host_created
        else:
            ret["result"] = False
            ret["comment"] = comment_host_notcreated + str(host_create["error"])

# error detected
    if error:
        ret["changes"] = {}
        ret["result"] = False
        ret["comment"] = str(error)

return ret

def absent(name, **kwargs):
    """
    Ensures that the host does not exists, eventually deletes host.

.. versionadded:: 2016.3.0

:param: name: technical name of the host
    :param _connection_user: Optional - zabbix user (can also be set in opts or pillar, see module's docstring)
    :param _connection_password: Optional - zabbix password (can also be set in opts or pillar, see module's docstring)
    :param _connection_url: Optional - url of zabbix frontend (can also be set in opts, pillar, see module's docstring)

.. code-block:: yaml

TestHostWithInterfaces:
            zabbix_host.absent

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

# Comment and change messages
    comment_host_deleted = "Host {} deleted.".format(name)
    comment_host_notdeleted = "Unable to delete host: {}. ".format(name)
    comment_host_notexists = "Host {} does not exist.".format(name)
    changes_host_deleted = {
        name: {
            "old": "Host {} exists.".format(name),
            "new": "Host {} deleted.".format(name),
        }
    }
    connection_args = {}
    if "_connection_user" in kwargs:
        connection_args["_connection_user"] = kwargs["_connection_user"]
    if "_connection_password" in kwargs:
        connection_args["_connection_password"] = kwargs["_connection_password"]
    if "_connection_url" in kwargs:
        connection_args["_connection_url"] = kwargs["_connection_url"]

host_exists = __salt__["zabbix.host_exists"](name, **connection_args)

# Dry run, test=true mode
    if __opts__["test"]:
        if not host_exists:
            ret["result"] = True
            ret["comment"] = comment_host_notexists
        else:
            ret["result"] = None
            ret["comment"] = comment_host_deleted
        return ret

host_get = __salt__["zabbix.host_get"](name, **connection_args)

if not host_get:
        ret["result"] = True
        ret["comment"] = comment_host_notexists
    else:
        try:
            hostid = host_get[0]["hostid"]
            host_delete = __salt__["zabbix.host_delete"](hostid, **connection_args)
        except KeyError:
            host_delete = False

if host_delete and "error" not in host_delete:
            ret["result"] = True
            ret["comment"] = comment_host_deleted
            ret["changes"] = changes_host_deleted
        else:
            ret["result"] = False
            ret["comment"] = comment_host_notdeleted + str(host_delete["error"])

return ret

def assign_templates(host, templates, **kwargs):
    """
    Ensures that templates are assigned to the host.

.. versionadded:: 2017.7.0

:param host: technical name of the host
    :param _connection_user: Optional - zabbix user (can also be set in opts or pillar, see module's docstring)
    :param _connection_password: Optional - zabbix password (can also be set in opts or pillar, see module's docstring)
    :param _connection_url: Optional - url of zabbix frontend (can also be set in opts, pillar, see module's docstring)

.. code-block:: yaml

add_zabbix_templates_to_host:
            zabbix_host.assign_templates:
                - host: TestHost
                - templates:
                    - "Template OS Linux"
                    - "Template App MySQL"

"""
    connection_args = {}
    if "_connection_user" in kwargs:
        connection_args["_connection_user"] = kwargs["_connection_user"]
    if "_connection_password" in kwargs:
        connection_args["_connection_password"] = kwargs["_connection_password"]
    if "_connection_url" in kwargs:
        connection_args["_connection_url"] = kwargs["_connection_url"]

ret = {"name": host, "changes": {}, "result": False, "comment": ""}

# Set comments
    comment_host_templates_updated = "Templates updated."
    comment_host_templ_notupdated = "Unable to update templates on host: {}.".format(
        host
    )
    comment_host_templates_in_sync = "Templates already synced."

update_host_templates = False
    curr_template_ids = list()
    requested_template_ids = list()
    hostid = ""

host_exists = __salt__["zabbix.host_exists"](host, **connection_args)

# Fail out if host does not exist
    if not host_exists:
        ret["result"] = False
        ret["comment"] = comment_host_templ_notupdated
        return ret

host_info = __salt__["zabbix.host_get"](host=host, **connection_args)[0]
    hostid = host_info["hostid"]

if not templates:
        templates = list()

# Get current templateids for host
    host_templates = __salt__["zabbix.host_get"](
        hostids=hostid,
        output='[{"hostid"}]',
        selectParentTemplates='["templateid"]',
        **connection_args
    )
    for template_id in host_templates[0]["parentTemplates"]:
        curr_template_ids.append(template_id["templateid"])

# Get requested templateids
    for template in templates:
        try:
            template_id = __salt__["zabbix.template_get"](
                host=template, **connection_args
            )[0]["templateid"]
            requested_template_ids.append(template_id)
        except TypeError:
            ret["result"] = False
            ret["comment"] = "Unable to find template: {}.".format(template)
            return ret

# remove any duplications
    requested_template_ids = list(set(requested_template_ids))

if set(curr_template_ids) != set(requested_template_ids):
        update_host_templates = True

# Set change output
    changes_host_templates_modified = {
        host: {
            "old": "Host templates: " + ", ".join(curr_template_ids),
            "new": "Host templates: " + ", ".join(requested_template_ids),
        }
    }

# Dry run, test=true mode
    if __opts__["test"]:
        if update_host_templates:
            ret["result"] = None
            ret["comment"] = comment_host_templates_updated
        else:
            ret["result"] = True
            ret["comment"] = comment_host_templates_in_sync
        return ret

# Attempt to perform update
    ret["result"] = True
    if update_host_templates:
        update_output = __salt__["zabbix.host_update"](
            hostid, templates=(requested_template_ids), **connection_args
        )
        if update_output is False:
            ret["result"] = False
            ret["comment"] = comment_host_templ_notupdated
            return ret
        ret["comment"] = comment_host_templates_updated
        ret["changes"] = changes_host_templates_modified
    else:
        ret["comment"] = comment_host_templates_in_sync

return ret