File Manager

003 File Manager

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

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

📁 ..
📄 __init__.py(35 B)
📁 __pycache__
📄 acme.py(12.74 KB)
📄 aix_group.py(4.11 KB)
📄 aix_shadow.py(1.93 KB)
📄 aixpkg.py(10.91 KB)
📄 aliases.py(5.07 KB)
📄 alternatives.py(5.1 KB)
📄 ansiblegate.py(11.38 KB)
📄 apache.py(12.47 KB)
📄 apcups.py(2.21 KB)
📄 apf.py(3.09 KB)
📄 apkpkg.py(16 KB)
📄 aptly.py(15.28 KB)
📄 aptpkg.py(102.35 KB)
📄 archive.py(46.97 KB)
📄 arista_pyeapi.py(22.06 KB)
📄 artifactory.py(24.78 KB)
📄 at.py(10.65 KB)
📄 at_solaris.py(8.56 KB)
📄 augeas_cfg.py(13.93 KB)
📄 aws_sqs.py(6.55 KB)
📄 azurearm_compute.py(19.55 KB)
📄 azurearm_dns.py(14.7 KB)
📄 azurearm_network.py(80.8 KB)
📄 azurearm_resource.py(34.27 KB)
📄 bamboohr.py(7.36 KB)
📄 baredoc.py(11.13 KB)
📄 bcache.py(28.97 KB)
📄 beacons.py(27.89 KB)
📄 bigip.py(69.11 KB)
📄 bluez_bluetooth.py(6.76 KB)
📄 boto3_elasticache.py(37.34 KB)
📄 boto3_elasticsearch.py(53.17 KB)
📄 boto3_route53.py(39.75 KB)
📄 boto3_sns.py(12.93 KB)
📄 boto_apigateway.py(61.86 KB)
📄 boto_asg.py(35.7 KB)
📄 boto_cfn.py(7.95 KB)
📄 boto_cloudfront.py(12.75 KB)
📄 boto_cloudtrail.py(14.45 KB)
📄 boto_cloudwatch.py(10.99 KB)
📄 boto_cloudwatch_event.py(9.48 KB)
📄 boto_cognitoidentity.py(14.63 KB)
📄 boto_datapipeline.py(6.94 KB)
📄 boto_dynamodb.py(10.54 KB)
📄 boto_ec2.py(79.29 KB)
📄 boto_efs.py(14.05 KB)
📄 boto_elasticache.py(23.69 KB)
📄 boto_elasticsearch_domain.py(15.85 KB)
📄 boto_elb.py(35.4 KB)
📄 boto_elbv2.py(10.81 KB)
📄 boto_iam.py(75.62 KB)
📄 boto_iot.py(26.2 KB)
📄 boto_kinesis.py(19.63 KB)
📄 boto_kms.py(17.29 KB)
📄 boto_lambda.py(35.05 KB)
📄 boto_rds.py(34.92 KB)
📄 boto_route53.py(32.55 KB)
📄 boto_s3.py(4.24 KB)
📄 boto_s3_bucket.py(31.8 KB)
📄 boto_secgroup.py(25.22 KB)
📄 boto_sns.py(7.22 KB)
📄 boto_sqs.py(6.43 KB)
📄 boto_ssm.py(3.65 KB)
📄 boto_vpc.py(112.81 KB)
📄 bower.py(5.89 KB)
📄 bridge.py(10.86 KB)
📄 bsd_shadow.py(6.92 KB)
📄 btrfs.py(33.64 KB)
📄 cabal.py(3.79 KB)
📄 capirca_acl.py(40.04 KB)
📄 cassandra_cql.py(39 KB)
📄 cassandra_mod.py(3.97 KB)
📄 celery.py(3.33 KB)
📄 ceph.py(15.82 KB)
📄 chassis.py(1.52 KB)
📄 chef.py(4.66 KB)
📄 chocolatey.py(39.34 KB)
📄 chronos.py(2.89 KB)
📄 chroot.py(11.51 KB)
📄 cimc.py(23.02 KB)
📄 ciscoconfparse_mod.py(14.79 KB)
📄 cisconso.py(3.83 KB)
📄 cloud.py(9.39 KB)
📄 cmdmod.py(162.16 KB)
📄 composer.py(10.31 KB)
📄 config.py(16.85 KB)
📄 consul.py(68.93 KB)
📄 container_resource.py(13.36 KB)
📄 cp.py(27.98 KB)
📄 cpan.py(5.54 KB)
📄 cron.py(26.8 KB)
📄 cryptdev.py(10.08 KB)
📄 csf.py(16.04 KB)
📄 cyg.py(8.32 KB)
📄 daemontools.py(5.41 KB)
📄 data.py(3.83 KB)
📄 datadog_api.py(7.64 KB)
📄 ddns.py(7.04 KB)
📄 deb_apache.py(7.41 KB)
📄 deb_postgres.py(4.22 KB)
📄 debconfmod.py(4.06 KB)
📄 debian_ip.py(64.78 KB)
📄 debian_service.py(6.6 KB)
📄 debuild_pkgbuild.py(34.69 KB)
📄 defaults.py(5.42 KB)
📄 devinfo.py(9.05 KB)
📄 devmap.py(627 B)
📄 dig.py(7.45 KB)
📄 disk.py(30.44 KB)
📄 djangomod.py(7.53 KB)
📄 dnsmasq.py(5.71 KB)
📄 dnsutil.py(11.51 KB)
📄 dockercompose.py(32.62 KB)
📄 dockermod.py(224.97 KB)
📄 dpkg_lowpkg.py(12.9 KB)
📄 drac.py(10.97 KB)
📄 dracr.py(38.53 KB)
📄 drbd.py(7.19 KB)
📄 dummyproxy_pkg.py(2.46 KB)
📄 dummyproxy_service.py(2.91 KB)
📄 ebuildpkg.py(38.74 KB)
📄 eix.py(1.58 KB)
📄 elasticsearch.py(51.44 KB)
📄 environ.py(8.96 KB)
📄 eselect.py(4.99 KB)
📄 esxcluster.py(502 B)
📄 esxdatacenter.py(514 B)
📄 esxi.py(1.64 KB)
📄 esxvm.py(481 B)
📄 etcd_mod.py(7.02 KB)
📄 ethtool.py(7.65 KB)
📄 event.py(8.23 KB)
📄 extfs.py(8.78 KB)
📄 file.py(224.74 KB)
📄 firewalld.py(20.51 KB)
📄 freebsd_sysctl.py(4.76 KB)
📄 freebsd_update.py(6.19 KB)
📄 freebsdjail.py(7.16 KB)
📄 freebsdkmod.py(6.17 KB)
📄 freebsdpkg.py(17.04 KB)
📄 freebsdports.py(13.13 KB)
📄 freebsdservice.py(12.53 KB)
📄 freezer.py(8.91 KB)
📄 gcp_addon.py(4.07 KB)
📄 gem.py(10.6 KB)
📄 genesis.py(21.75 KB)
📄 gentoo_service.py(9.18 KB)
📄 gentoolkitmod.py(8.33 KB)
📄 git.py(171.44 KB)
📄 github.py(53.19 KB)
📄 glanceng.py(4.69 KB)
📄 glassfish.py(19.49 KB)
📄 glusterfs.py(19.55 KB)
📄 gnomedesktop.py(6.85 KB)
📄 google_chat.py(1.52 KB)
📄 gpg.py(39.99 KB)
📄 grafana4.py(30.27 KB)
📄 grains.py(23.67 KB)
📄 groupadd.py(10.85 KB)
📄 grub_legacy.py(3.08 KB)
📄 guestfs.py(2.32 KB)
📄 hadoop.py(3.76 KB)
📄 haproxyconn.py(10.17 KB)
📄 hashutil.py(6.77 KB)
📄 heat.py(25.26 KB)
📄 helm.py(39.27 KB)
📄 hg.py(7.16 KB)
📄 highstate_doc.py(22.76 KB)
📄 hosts.py(10.47 KB)
📄 http.py(3.75 KB)
📄 icinga2.py(4.46 KB)
📄 idem.py(1.75 KB)
📄 ifttt.py(2.28 KB)
📄 ilo.py(15.98 KB)
📄 incron.py(7.68 KB)
📄 influxdb08mod.py(15.07 KB)
📄 influxdbmod.py(16.13 KB)
📄 infoblox.py(17.53 KB)
📄 ini_manage.py(14.63 KB)
📁 inspectlib
📄 inspector.py(8.19 KB)
📄 introspect.py(4.02 KB)
📄 iosconfig.py(14.78 KB)
📄 ipmi.py(25.45 KB)
📄 ipset.py(17.97 KB)
📄 iptables.py(57.33 KB)
📄 iwtools.py(3.99 KB)
📄 jboss7.py(20.51 KB)
📄 jboss7_cli.py(15.23 KB)
📄 jenkinsmod.py(11.9 KB)
📄 jinja.py(2.66 KB)
📄 jira_mod.py(7.07 KB)
📄 junos.py(73.9 KB)
📄 k8s.py(24.87 KB)
📄 kapacitor.py(5.37 KB)
📄 kerberos.py(5.42 KB)
📄 kernelpkg_linux_apt.py(6.91 KB)
📄 kernelpkg_linux_yum.py(7.46 KB)
📄 key.py(1007 B)
📄 keyboard.py(2.64 KB)
📄 keystone.py(43.16 KB)
📄 keystoneng.py(21.82 KB)
📄 keystore.py(6.69 KB)
📄 kmod.py(7.29 KB)
📄 kubeadm.py(34.01 KB)
📄 kubernetesmod.py(46.66 KB)
📄 launchctl_service.py(9.73 KB)
📄 layman.py(4.22 KB)
📄 ldap3.py(18.81 KB)
📄 ldapmod.py(5.9 KB)
📄 libcloud_compute.py(23.51 KB)
📄 libcloud_dns.py(9.76 KB)
📄 libcloud_loadbalancer.py(13.17 KB)
📄 libcloud_storage.py(12.19 KB)
📄 linux_acl.py(7.7 KB)
📄 linux_ip.py(5.44 KB)
📄 linux_lvm.py(17.86 KB)
📄 linux_service.py(4.64 KB)
📄 linux_shadow.py(13.37 KB)
📄 linux_sysctl.py(7.39 KB)
📄 localemod.py(11.84 KB)
📄 locate.py(2.58 KB)
📄 logadm.py(9.57 KB)
📄 logmod.py(1.24 KB)
📄 logrotate.py(7.72 KB)
📄 lvs.py(11.54 KB)
📄 lxc.py(148.61 KB)
📄 lxd.py(90.2 KB)
📄 mac_assistive.py(6.36 KB)
📄 mac_brew_pkg.py(19.82 KB)
📄 mac_desktop.py(2.77 KB)
📄 mac_group.py(6.34 KB)
📄 mac_keychain.py(6.68 KB)
📄 mac_pkgutil.py(2.84 KB)
📄 mac_portspkg.py(11.36 KB)
📄 mac_power.py(13.29 KB)
📄 mac_service.py(19.64 KB)
📄 mac_shadow.py(14.23 KB)
📄 mac_softwareupdate.py(14.52 KB)
📄 mac_sysctl.py(5.13 KB)
📄 mac_system.py(15.2 KB)
📄 mac_timezone.py(8.34 KB)
📄 mac_user.py(16.36 KB)
📄 mac_xattr.py(6.11 KB)
📄 macdefaults.py(2.33 KB)
📄 macpackage.py(6.94 KB)
📄 makeconf.py(17.31 KB)
📄 mandrill.py(6.31 KB)
📄 marathon.py(5.36 KB)
📄 match.py(10.28 KB)
📄 mattermost.py(3.4 KB)
📄 mdadm_raid.py(9.86 KB)
📄 mdata.py(3.44 KB)
📄 memcached.py(6.13 KB)
📄 mine.py(18.79 KB)
📄 minion.py(7.68 KB)
📄 mod_random.py(6.72 KB)
📄 modjk.py(12.48 KB)
📄 mongodb.py(17.3 KB)
📄 monit.py(5.51 KB)
📄 moosefs.py(3.87 KB)
📄 mount.py(56.18 KB)
📄 mssql.py(14.64 KB)
📄 msteams.py(2 KB)
📄 munin.py(2.4 KB)
📄 mysql.py(87.86 KB)
📄 nacl.py(9.73 KB)
📄 nagios.py(6.53 KB)
📄 nagios_rpc.py(5.09 KB)
📄 namecheap_domains.py(12.84 KB)
📄 namecheap_domains_dns.py(5.93 KB)
📄 namecheap_domains_ns.py(4.51 KB)
📄 namecheap_ssl.py(25.72 KB)
📄 namecheap_users.py(2.4 KB)
📄 napalm_bgp.py(9.72 KB)
📄 napalm_formula.py(11.33 KB)
📄 napalm_mod.py(59.3 KB)
📄 napalm_netacl.py(28.59 KB)
📄 napalm_network.py(93.24 KB)
📄 napalm_ntp.py(10.22 KB)
📄 napalm_probes.py(13.25 KB)
📄 napalm_route.py(5.09 KB)
📄 napalm_snmp.py(7.05 KB)
📄 napalm_users.py(6.49 KB)
📄 napalm_yang_mod.py(20.28 KB)
📄 netaddress.py(1.6 KB)
📄 netbox.py(32.22 KB)
📄 netbsd_sysctl.py(3.97 KB)
📄 netbsdservice.py(6.49 KB)
📄 netmiko_mod.py(19.63 KB)
📄 netscaler.py(27.02 KB)
📄 network.py(62.75 KB)
📄 neutron.py(44.93 KB)
📄 neutronng.py(15.02 KB)
📄 nexus.py(22.95 KB)
📄 nfs3.py(3.9 KB)
📄 nftables.py(33.58 KB)
📄 nginx.py(3.83 KB)
📄 nilrt_ip.py(36.18 KB)
📄 nix.py(8.03 KB)
📄 nova.py(19.61 KB)
📄 npm.py(10.35 KB)
📄 nspawn.py(41.35 KB)
📄 nxos.py(24.67 KB)
📄 nxos_api.py(14.66 KB)
📄 nxos_upgrade.py(14.74 KB)
📄 omapi.py(3.6 KB)
📄 openbsd_sysctl.py(3.74 KB)
📄 openbsdpkg.py(11 KB)
📄 openbsdrcctl_service.py(6.25 KB)
📄 openbsdservice.py(8.31 KB)
📄 openscap.py(2.81 KB)
📄 openstack_config.py(3.5 KB)
📄 openstack_mng.py(2.71 KB)
📄 openvswitch.py(11.75 KB)
📄 opkg.py(49.72 KB)
📄 opsgenie.py(3.29 KB)
📄 oracle.py(5.83 KB)
📄 osquery.py(24.93 KB)
📄 out.py(2.53 KB)
📄 pacmanpkg.py(31.99 KB)
📄 pagerduty.py(4.7 KB)
📄 pagerduty_util.py(13.49 KB)
📄 pam.py(2.01 KB)
📄 panos.py(61.05 KB)
📄 parallels.py(19.85 KB)
📄 parted_partition.py(21.53 KB)
📄 pcs.py(14.11 KB)
📄 pdbedit.py(10.72 KB)
📄 pecl.py(3.79 KB)
📄 peeringdb.py(8.39 KB)
📄 pf.py(9.51 KB)
📄 philips_hue.py(1.55 KB)
📄 pillar.py(21.29 KB)
📄 pip.py(51.76 KB)
📄 pkg_resource.py(11.89 KB)
📄 pkgin.py(17.35 KB)
📄 pkgng.py(61.1 KB)
📄 pkgutil.py(9.88 KB)
📄 portage_config.py(22.77 KB)
📄 postfix.py(16.24 KB)
📄 postgres.py(88.31 KB)
📄 poudriere.py(7.85 KB)
📄 powerpath.py(2.57 KB)
📄 proxy.py(11.49 KB)
📄 ps.py(19.45 KB)
📄 publish.py(10.22 KB)
📄 puppet.py(11.69 KB)
📄 purefa.py(33.03 KB)
📄 purefb.py(13.65 KB)
📄 pushbullet.py(1.88 KB)
📄 pushover_notify.py(3.48 KB)
📄 pw_group.py(4.4 KB)
📄 pw_user.py(12.47 KB)
📄 pyenv.py(6.93 KB)
📄 qemu_img.py(1.53 KB)
📄 qemu_nbd.py(3.28 KB)
📄 quota.py(6.43 KB)
📄 rabbitmq.py(38.44 KB)
📄 rallydev.py(6.09 KB)
📄 random_org.py(23.76 KB)
📄 rbac_solaris.py(16.15 KB)
📄 rbenv.py(10.75 KB)
📄 rdp.py(6.08 KB)
📄 rebootmgr.py(7.66 KB)
📄 redismod.py(16.36 KB)
📄 reg.py(16.36 KB)
📄 rest_pkg.py(2.26 KB)
📄 rest_sample_utils.py(558 B)
📄 rest_service.py(3.63 KB)
📄 restartcheck.py(24.1 KB)
📄 ret.py(1.27 KB)
📄 rh_ip.py(38.01 KB)
📄 rh_service.py(16.61 KB)
📄 riak.py(5.19 KB)
📄 rpm_lowpkg.py(27.61 KB)
📄 rpmbuild_pkgbuild.py(24.53 KB)
📄 rsync.py(8.04 KB)
📄 runit.py(17.14 KB)
📄 rvm.py(11.1 KB)
📄 s3.py(9.93 KB)
📄 s6.py(3.62 KB)
📄 salt_proxy.py(4.48 KB)
📄 salt_version.py(4.29 KB)
📄 saltcheck.py(46.11 KB)
📄 saltcloudmod.py(954 B)
📄 saltutil.py(56.5 KB)
📄 schedule.py(43.35 KB)
📄 scp_mod.py(6.22 KB)
📄 scsi.py(2.66 KB)
📄 sdb.py(2.45 KB)
📄 seed.py(8.87 KB)
📄 selinux.py(23.83 KB)
📄 sensehat.py(7.79 KB)
📄 sensors.py(1.3 KB)
📄 serverdensity_device.py(8.1 KB)
📄 servicenow.py(4.38 KB)
📄 slack_notify.py(7.83 KB)
📄 slackware_service.py(6.89 KB)
📄 slsutil.py(19.05 KB)
📄 smartos_imgadm.py(12.09 KB)
📄 smartos_nictagadm.py(6.51 KB)
📄 smartos_virt.py(5.21 KB)
📄 smartos_vmadm.py(26.37 KB)
📄 smbios.py(10.06 KB)
📄 smf_service.py(8.52 KB)
📄 smtp.py(5.41 KB)
📄 snapper.py(27.14 KB)
📄 solaris_fmadm.py(11.27 KB)
📄 solaris_group.py(2.8 KB)
📄 solaris_shadow.py(7.98 KB)
📄 solaris_system.py(3.72 KB)
📄 solaris_user.py(11.06 KB)
📄 solarisipspkg.py(18.7 KB)
📄 solarispkg.py(15.42 KB)
📄 solr.py(45.54 KB)
📄 solrcloud.py(14.63 KB)
📄 splunk.py(8.15 KB)
📄 splunk_search.py(8.76 KB)
📄 sqlite3.py(2.54 KB)
📄 ssh.py(43.15 KB)
📄 ssh_pkg.py(1.08 KB)
📄 ssh_service.py(3.39 KB)
📄 state.py(78.55 KB)
📄 status.py(57.34 KB)
📄 statuspage.py(14.67 KB)
📄 supervisord.py(11.15 KB)
📄 suse_apache.py(2.45 KB)
📄 svn.py(10.75 KB)
📄 swarm.py(13.5 KB)
📄 swift.py(5.55 KB)
📄 sysbench.py(6.62 KB)
📄 sysfs.py(6.61 KB)
📄 syslog_ng.py(31.55 KB)
📄 sysmod.py(22.59 KB)
📄 sysrc.py(3.38 KB)
📄 system.py(19.28 KB)
📄 system_profiler.py(3.54 KB)
📄 systemd_service.py(46.19 KB)
📄 telegram.py(3.28 KB)
📄 telemetry.py(12.9 KB)
📄 temp.py(831 B)
📄 test.py(14.71 KB)
📄 test_virtual.py(194 B)
📄 testinframod.py(9.92 KB)
📄 textfsm_mod.py(16.22 KB)
📄 timezone.py(19.89 KB)
📄 tls.py(58.68 KB)
📄 tomcat.py(18.59 KB)
📄 trafficserver.py(10.44 KB)
📄 transactional_update.py(42 KB)
📄 travisci.py(2.08 KB)
📄 tuned.py(2.34 KB)
📄 twilio_notify.py(2.95 KB)
📄 udev.py(3.72 KB)
📄 upstart_service.py(16.92 KB)
📄 uptime.py(3.23 KB)
📄 useradd.py(22.3 KB)
📄 uwsgi.py(996 B)
📄 vagrant.py(20.4 KB)
📄 varnish.py(3.08 KB)
📄 vault.py(13.48 KB)
📄 vbox_guest.py(10.55 KB)
📄 vboxmanage.py(14.72 KB)
📄 vcenter.py(455 B)
📄 victorops.py(6.54 KB)
📄 virt.py(290.11 KB)
📄 virtualenv_mod.py(15.08 KB)
📄 vmctl.py(9.6 KB)
📄 vsphere.py(376.7 KB)
📄 webutil.py(3.66 KB)
📄 win_auditpol.py(4.74 KB)
📄 win_autoruns.py(2.29 KB)
📄 win_certutil.py(3.27 KB)
📄 win_dacl.py(32.27 KB)
📄 win_disk.py(1.8 KB)
📄 win_dism.py(18.26 KB)
📄 win_dns_client.py(4.19 KB)
📄 win_dsc.py(26.56 KB)
📄 win_file.py(59.46 KB)
📄 win_firewall.py(20.15 KB)
📄 win_groupadd.py(11.27 KB)
📄 win_iis.py(68.76 KB)
📄 win_ip.py(11.43 KB)
📄 win_lgpo.py(491.78 KB)
📄 win_license.py(2.72 KB)
📄 win_network.py(14.02 KB)
📄 win_ntp.py(1.8 KB)
📄 win_path.py(11.12 KB)
📄 win_pkg.py(84.64 KB)
📄 win_pki.py(15.8 KB)
📄 win_powercfg.py(9.85 KB)
📄 win_psget.py(8.97 KB)
📄 win_servermanager.py(14.33 KB)
📄 win_service.py(32.7 KB)
📄 win_shadow.py(3.03 KB)
📄 win_smtp_server.py(17.67 KB)
📄 win_snmp.py(13.38 KB)
📄 win_status.py(17.04 KB)
📄 win_system.py(40.62 KB)
📄 win_task.py(78.46 KB)
📄 win_timezone.py(13.27 KB)
📄 win_useradd.py(27.53 KB)
📄 win_wua.py(38.29 KB)
📄 win_wusa.py(5.88 KB)
📄 winrepo.py(6.3 KB)
📄 wordpress.py(4.71 KB)
📄 x509.py(62.22 KB)
📄 xapi_virt.py(24.08 KB)
📄 xbpspkg.py(15.89 KB)
📄 xfs.py(15.33 KB)
📄 xml.py(2.14 KB)
📄 xmpp.py(5.28 KB)
📄 yumpkg.py(112.71 KB)
📄 zabbix.py(94.11 KB)
📄 zcbuildout.py(28.19 KB)
📄 zenoss.py(5.64 KB)
📄 zfs.py(34.49 KB)
📄 zk_concurrency.py(11.19 KB)
📄 znc.py(2.26 KB)
📄 zoneadm.py(15.11 KB)
📄 zonecfg.py(21.91 KB)
📄 zookeeper.py(14.72 KB)
📄 zpool.py(44.02 KB)
📄 zypperpkg.py(90.34 KB)

Editing: zabbix.py

"""
Support for Zabbix

:optdepends:    - zabbix server

:configuration: This module is not usable until the zabbix user and zabbix password are specified either in a pillar
    or in the minion's config file. Zabbix url should be also specified.

.. code-block:: yaml

zabbix.user: Admin
        zabbix.password: mypassword
        zabbix.url: http://127.0.0.1/zabbix/api_jsonrpc.php

Connection arguments from the minion config file can be overridden on the CLI by using arguments with
    ``_connection_`` prefix.

.. code-block:: bash

zabbix.apiinfo_version _connection_user=Admin _connection_password=zabbix _connection_url=http://host/zabbix/

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

import logging
import os
import socket
import urllib.error

import salt.utils.data
import salt.utils.files
import salt.utils.http
import salt.utils.json
from salt.exceptions import SaltException
from salt.utils.versions import LooseVersion as _LooseVersion

log = logging.getLogger(__name__)

INTERFACE_DEFAULT_PORTS = [10050, 161, 623, 12345]

ZABBIX_TOP_LEVEL_OBJECTS = (
    "hostgroup",
    "template",
    "host",
    "maintenance",
    "action",
    "drule",
    "service",
    "proxy",
    "screen",
    "usergroup",
    "mediatype",
    "script",
    "valuemap",
)

# Zabbix object and its ID name mapping
ZABBIX_ID_MAPPER = {
    "action": "actionid",
    "alert": "alertid",
    "application": "applicationid",
    "dhost": "dhostid",
    "dservice": "dserviceid",
    "dcheck": "dcheckid",
    "drule": "druleid",
    "event": "eventid",
    "graph": "graphid",
    "graphitem": "gitemid",
    "graphprototype": "graphid",
    "history": "itemid",
    "host": "hostid",
    "hostgroup": "groupid",
    "hostinterface": "interfaceid",
    "hostprototype": "hostid",
    "iconmap": "iconmapid",
    "image": "imageid",
    "item": "itemid",
    "itemprototype": "itemid",
    "service": "serviceid",
    "discoveryrule": "itemid",
    "maintenance": "maintenanceid",
    "map": "sysmapid",
    "usermedia": "mediaid",
    "mediatype": "mediatypeid",
    "proxy": "proxyid",
    "screen": "screenid",
    "screenitem": "screenitemid",
    "script": "scriptid",
    "template": "templateid",
    "templatescreen": "screenid",
    "templatescreenitem": "screenitemid",
    "trend": "itemid",
    "trigger": "triggerid",
    "triggerprototype": "triggerid",
    "user": "userid",
    "usergroup": "usrgrpid",
    "usermacro": "globalmacroid",
    "valuemap": "valuemapid",
    "httptest": "httptestid",
}

# Define the module's virtual name
__virtualname__ = "zabbix"

def __virtual__():
    """
    Only load the module if all modules are imported correctly.
    """
    return __virtualname__

def _frontend_url():
    """
    Tries to guess the url of zabbix frontend.

.. versionadded:: 2016.3.0
    """
    hostname = socket.gethostname()
    frontend_url = "http://" + hostname + "/zabbix/api_jsonrpc.php"
    try:
        try:
            response = salt.utils.http.query(frontend_url)
            error = response["error"]
        except urllib.error.HTTPError as http_e:
            error = str(http_e)
        if error.find("412: Precondition Failed"):
            return frontend_url
        else:
            raise KeyError
    except (ValueError, KeyError):
        return False

def _query(method, params, url, auth=None):
    """
    JSON request to Zabbix API.

.. versionadded:: 2016.3.0

:param method: actual operation to perform via the API
    :param params: parameters required for specific method
    :param url: url of zabbix api
    :param auth: auth token for zabbix api (only for methods with required authentication)

:return: Response from API with desired data in JSON format. In case of error returns more specific description.

.. versionchanged:: 2017.7
    """

unauthenticated_methods = [
        "user.login",
        "apiinfo.version",
    ]

header_dict = {"Content-type": "application/json"}
    data = {"jsonrpc": "2.0", "id": 0, "method": method, "params": params}

if method not in unauthenticated_methods:
        data["auth"] = auth

data = salt.utils.json.dumps(data)

log.info("_QUERY input:\nurl: %s\ndata: %s", str(url), str(data))

try:
        result = salt.utils.http.query(
            url,
            method="POST",
            data=data,
            header_dict=header_dict,
            decode_type="json",
            decode=True,
            status=True,
            headers=True,
        )
        log.info("_QUERY result: %s", str(result))
        if "error" in result:
            raise SaltException(
                "Zabbix API: Status: {} ({})".format(result["status"], result["error"])
            )
        ret = result.get("dict", {})
        if "error" in ret:
            raise SaltException(
                "Zabbix API: {} ({})".format(
                    ret["error"]["message"], ret["error"]["data"]
                )
            )
        return ret
    except ValueError as err:
        raise SaltException(
            "URL or HTTP headers are probably not correct! ({})".format(err)
        )
    except OSError as err:
        raise SaltException("Check hostname in URL! ({})".format(err))

def _login(**kwargs):
    """
    Log in to the API and generate the authentication token.

.. versionadded:: 2016.3.0

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

:return: On success connargs dictionary with auth token and frontend url, False on failure.

"""
    connargs = dict()

def _connarg(name, key=None):
        """
        Add key to connargs, only if name exists in our kwargs or, as zabbix.<name> in __opts__ or __pillar__

Evaluate in said order - kwargs, opts, then pillar. To avoid collision with other functions,
        kwargs-based connection arguments are prefixed with 'connection_' (i.e. '_connection_user', etc.).

Inspired by mysql salt module.
        """
        if key is None:
            key = name

if name in kwargs:
            connargs[key] = kwargs[name]
        else:
            prefix = "_connection_"
            if name.startswith(prefix):
                try:
                    name = name[len(prefix) :]
                except IndexError:
                    return
            val = __salt__["config.get"]("zabbix.{}".format(name), None) or __salt__[
                "config.get"
            ]("zabbix:{}".format(name), None)
            if val is not None:
                connargs[key] = val

_connarg("_connection_user", "user")
    _connarg("_connection_password", "password")
    _connarg("_connection_url", "url")

if "url" not in connargs:
        connargs["url"] = _frontend_url()

try:
        if connargs["user"] and connargs["password"] and connargs["url"]:
            params = {"user": connargs["user"], "password": connargs["password"]}
            method = "user.login"
            ret = _query(method, params, connargs["url"])
            auth = ret["result"]
            connargs["auth"] = auth
            connargs.pop("user", None)
            connargs.pop("password", None)
            return connargs
        else:
            raise KeyError
    except KeyError as err:
        raise SaltException("URL is probably not correct! ({})".format(err))

def _params_extend(params, _ignore_name=False, **kwargs):
    """
    Extends the params dictionary by values from keyword arguments.

.. versionadded:: 2016.3.0

:param params: Dictionary with parameters for zabbix API.
    :param _ignore_name: Salt State module is passing first line as 'name' parameter. If API uses optional parameter
    'name' (for ex. host_create, user_create method), please use 'visible_name' or 'firstname' instead of 'name' to
    not mess these 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)

:return: Extended params dictionary with parameters.

"""
    # extend params value by optional zabbix API parameters
    for key in kwargs:
        if not key.startswith("_"):
            params.setdefault(key, kwargs[key])

# ignore name parameter passed from Salt state module, use firstname or visible_name instead
    if _ignore_name:
        params.pop("name", None)
        if "firstname" in params:
            params["name"] = params.pop("firstname")
        elif "visible_name" in params:
            params["name"] = params.pop("visible_name")

return params

def get_zabbix_id_mapper():
    """
    .. versionadded:: 2017.7

Make ZABBIX_ID_MAPPER constant available to state modules.

:return: ZABBIX_ID_MAPPER
    """
    return ZABBIX_ID_MAPPER

def substitute_params(input_object, extend_params=None, filter_key="name", **kwargs):
    """
    .. versionadded:: 2017.7

Go through Zabbix object params specification and if needed get given object ID from Zabbix API and put it back
    as a value. Definition of the object is done via dict with keys "query_object" and "query_name".

:param input_object: Zabbix object type specified in state file
    :param extend_params: Specify query with params
    :param filter_key: Custom filtering key (default: name)
    :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)

:return: Params structure with values converted to string for further comparison purposes
    """
    if extend_params is None:
        extend_params = {}
    if isinstance(input_object, list):
        return [
            substitute_params(oitem, extend_params, filter_key, **kwargs)
            for oitem in input_object
        ]
    elif isinstance(input_object, dict):
        if "query_object" in input_object:
            query_params = {}
            if input_object["query_object"] not in ZABBIX_TOP_LEVEL_OBJECTS:
                query_params.update(extend_params)
            try:
                query_params.update(
                    {"filter": {filter_key: input_object["query_name"]}}
                )
                return get_object_id_by_params(
                    input_object["query_object"], query_params, **kwargs
                )
            except KeyError:
                raise SaltException(
                    "Qyerying object ID requested "
                    "but object name not provided: {}".format(input_object)
                )
        else:
            return {
                key: substitute_params(val, extend_params, filter_key, **kwargs)
                for key, val in input_object.items()
            }
    else:
        # Zabbix response is always str, return everything in str as well
        return str(input_object)

# pylint: disable=too-many-return-statements,too-many-nested-blocks
def compare_params(defined, existing, return_old_value=False):
    """
    .. versionadded:: 2017.7

Compares Zabbix object definition against existing Zabbix object.

:param defined: Zabbix object definition taken from sls file.
    :param existing: Existing Zabbix object taken from result of an API call.
    :param return_old_value: Default False. If True, returns dict("old"=old_val, "new"=new_val) for rollback purpose.
    :return: Params that are different from existing object. Result extended by
        object ID can be passed directly to Zabbix API update method.
    """
    # Comparison of data types
    if not isinstance(defined, type(existing)):
        raise SaltException(
            "Zabbix object comparison failed (data type mismatch). Expecting {}, got"
            ' {}. Existing value: "{}", defined value: "{}").'.format(
                type(existing), type(defined), existing, defined
            )
        )

# Comparison of values
    if not salt.utils.data.is_iter(defined):
        if str(defined) != str(existing) and return_old_value:
            return {"new": str(defined), "old": str(existing)}
        elif str(defined) != str(existing) and not return_old_value:
            return str(defined)

# Comparison of lists of values or lists of dicts
    if isinstance(defined, list):
        if len(defined) != len(existing):
            log.info("Different list length!")
            return {"new": defined, "old": existing} if return_old_value else defined
        else:
            difflist = []
            for ditem in defined:
                d_in_e = []
                for eitem in existing:
                    comp = compare_params(ditem, eitem, return_old_value)
                    if return_old_value:
                        d_in_e.append(comp["new"])
                    else:
                        d_in_e.append(comp)
                if all(d_in_e):
                    difflist.append(ditem)
            # If there is any difference in a list then whole defined list must be returned and provided for update
            if any(difflist) and return_old_value:
                return {"new": defined, "old": existing}
            elif any(difflist) and not return_old_value:
                return defined

# Comparison of dicts
    if isinstance(defined, dict):
        try:
            # defined must be a subset of existing to be compared
            if set(defined) <= set(existing):
                intersection = set(defined) & set(existing)
                diffdict = {"new": {}, "old": {}} if return_old_value else {}
                for i in intersection:
                    comp = compare_params(defined[i], existing[i], return_old_value)
                    if return_old_value:
                        if comp or (not comp and isinstance(comp, list)):
                            diffdict["new"].update({i: defined[i]})
                            diffdict["old"].update({i: existing[i]})
                    else:
                        if comp or (not comp and isinstance(comp, list)):
                            diffdict.update({i: defined[i]})
                return diffdict

return {"new": defined, "old": existing} if return_old_value else defined

except TypeError:
            raise SaltException(
                "Zabbix object comparison failed (data type mismatch). Expecting {},"
                ' got {}. Existing value: "{}", defined value: "{}").'.format(
                    type(existing), type(defined), existing, defined
                )
            )

def get_object_id_by_params(obj, params=None, **connection_args):
    """
    .. versionadded:: 2017.7

Get ID of single Zabbix object specified by its name.

:param obj: Zabbix object type
    :param params: Parameters by which object is uniquely identified
    :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)

:return: object ID
    """
    if params is None:
        params = {}
    res = run_query(obj + ".get", params, **connection_args)
    if res and len(res) == 1:
        return str(res[0][ZABBIX_ID_MAPPER[obj]])
    else:
        raise SaltException(
            "Zabbix API: Object does not exist or bad Zabbix user permissions or other"
            " unexpected result. Called method {} with params {}. Result: {}".format(
                obj + ".get", params, res
            )
        )

def apiinfo_version(**connection_args):
    """
    Retrieve the version of the Zabbix API.

.. versionadded:: 2016.3.0

:return: On success string with Zabbix API version, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.apiinfo_version
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "apiinfo.version"
            params = {}
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]
        else:
            raise KeyError
    except KeyError:
        return False

def user_create(alias, passwd, usrgrps, **connection_args):
    """
    .. versionadded:: 2016.3.0

Create new zabbix user

.. note::
        This function accepts all standard user properties: keyword argument
        names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/2.0/manual/appendix/api/user/definitions#user

:param alias: user alias
    :param passwd: user's password
    :param usrgrps: user groups to add the user to

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

:param firstname: string with firstname of the user, use 'firstname' instead of 'name' parameter to not mess
                      with value supplied from Salt sls file.

:return: On success string with id of the created user.

CLI Example:

.. code-block:: bash

salt '*' zabbix.user_create james password007 '[7, 12]' firstname='James Bond'
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "user.create"
            params = {"alias": alias, "passwd": passwd, "usrgrps": []}
            # User groups
            if not isinstance(usrgrps, list):
                usrgrps = [usrgrps]
            for usrgrp in usrgrps:
                params["usrgrps"].append({"usrgrpid": usrgrp})

params = _params_extend(params, _ignore_name=True, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["userids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def user_delete(users, **connection_args):
    """
    Delete zabbix users.

.. versionadded:: 2016.3.0

:param users: array of users (userids) to delete
    :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)

:return: On success array with userids of deleted users.

CLI Example:

.. code-block:: bash

salt '*' zabbix.user_delete 15
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "user.delete"
            if not isinstance(users, list):
                params = [users]
            else:
                params = users

ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["userids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def user_exists(alias, **connection_args):
    """
    Checks if user with given alias exists.

.. versionadded:: 2016.3.0

:param alias: user alias
    :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)

:return: True if user exists, else False.

CLI Example:

.. code-block:: bash

salt '*' zabbix.user_exists james
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "user.get"
            params = {"output": "extend", "filter": {"alias": alias}}
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return True if len(ret["result"]) > 0 else False
        else:
            raise KeyError
    except KeyError:
        return ret

def user_get(alias=None, userids=None, **connection_args):
    """
    Retrieve users according to the given parameters.

.. versionadded:: 2016.3.0

:param alias: user alias
    :param userids: return only users with the given IDs
    :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)

:return: Array with details of convenient users, False on failure of if no user found.

CLI Example:

.. code-block:: bash

salt '*' zabbix.user_get james
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "user.get"
            params = {"output": "extend", "filter": {}}
            if not userids and not alias:
                return {
                    "result": False,
                    "comment": (
                        "Please submit alias or userids parameter to retrieve users."
                    ),
                }
            if alias:
                params["filter"].setdefault("alias", alias)
            if userids:
                params.setdefault("userids", userids)
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"] if len(ret["result"]) > 0 else False
        else:
            raise KeyError
    except KeyError:
        return ret

def user_update(userid, **connection_args):
    """
    .. versionadded:: 2016.3.0

Update existing users

.. note::
        This function accepts all standard user properties: keyword argument
        names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/2.0/manual/appendix/api/user/definitions#user

:param userid: id of the user to update
    :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)

:return: Id of the updated user on success.

CLI Example:

.. code-block:: bash

salt '*' zabbix.user_update 16 visible_name='James Brown'
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "user.update"
            params = {
                "userid": userid,
            }
            params = _params_extend(params, _ignore_name=True, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["userids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def user_getmedia(userids=None, **connection_args):
    """
    .. versionadded:: 2016.3.0

Retrieve media according to the given parameters

.. note::
        This function accepts all standard usermedia.get properties: keyword
        argument names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/3.2/manual/api/reference/usermedia/get

:param userids: return only media that are used by the given users

:return: List of retrieved media, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.user_getmedia
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "usermedia.get"
            if userids:
                params = {"userids": userids}
            else:
                params = {}
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]
        else:
            raise KeyError
    except KeyError:
        return ret

def user_addmedia(
    userids, active, mediatypeid, period, sendto, severity, **connection_args
):
    """
    Add new media to multiple users.

.. versionadded:: 2016.3.0

:param userids: ID of the user that uses the media
    :param active: Whether the media is enabled (0 enabled, 1 disabled)
    :param mediatypeid: ID of the media type used by the media
    :param period: Time when the notifications can be sent as a time period
    :param sendto: Address, user name or other identifier of the recipient
    :param severity: Trigger severities to send notifications about
    :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)

:return: IDs of the created media.

CLI Example:

.. code-block:: bash

salt '*' zabbix.user_addmedia 4 active=0 mediatypeid=1 period='1-7,00:00-24:00' sendto='support2@example.com'
        severity=63

"""
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "user.addmedia"
            params = {"users": []}
            # Users
            if not isinstance(userids, list):
                userids = [userids]
            for user in userids:
                params["users"].append({"userid": user})
            # Medias
            params["medias"] = [
                {
                    "active": active,
                    "mediatypeid": mediatypeid,
                    "period": period,
                    "sendto": sendto,
                    "severity": severity,
                },
            ]

ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["mediaids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def user_deletemedia(mediaids, **connection_args):
    """
    Delete media by id.

.. versionadded:: 2016.3.0

:param mediaids: IDs of the media to delete
    :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)

:return: IDs of the deleted media, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.user_deletemedia 27
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "user.deletemedia"

if not isinstance(mediaids, list):
                mediaids = [mediaids]
            params = mediaids
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["mediaids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def user_list(**connection_args):
    """
    Retrieve all of the configured users.

.. versionadded:: 2016.3.0

:return: Array with user details.

CLI Example:

.. code-block:: bash

salt '*' zabbix.user_list
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "user.get"
            params = {"output": "extend"}
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]
        else:
            raise KeyError
    except KeyError:
        return ret

def usergroup_create(name, **connection_args):
    """
    .. versionadded:: 2016.3.0

Create new user group

.. note::
        This function accepts all standard user group properties: keyword
        argument names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/2.0/manual/appendix/api/usergroup/definitions#user_group

:param name: name of the user group
    :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)

:return:  IDs of the created user groups.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usergroup_create GroupName
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "usergroup.create"
            params = {"name": name}
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["usrgrpids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def usergroup_delete(usergroupids, **connection_args):
    """
    .. versionadded:: 2016.3.0

:param usergroupids: IDs of the user groups to delete

:return: IDs of the deleted user groups.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usergroup_delete 28
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "usergroup.delete"
            if not isinstance(usergroupids, list):
                usergroupids = [usergroupids]
            params = usergroupids
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["usrgrpids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def usergroup_exists(name=None, node=None, nodeids=None, **connection_args):
    """
    Checks if at least one user group that matches the given filter criteria exists

.. versionadded:: 2016.3.0

:param name: names of the user groups
    :param node: name of the node the user groups must belong to (This will override the nodeids parameter.)
    :param nodeids: IDs of the nodes the user groups must belong to

:return: True if at least one user group that matches the given filter criteria exists, else False.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usergroup_exists Guests
    """
    conn_args = _login(**connection_args)
    zabbix_version = apiinfo_version(**connection_args)
    ret = False
    try:
        if conn_args:
            # usergroup.exists deprecated
            if _LooseVersion(zabbix_version) > _LooseVersion("2.5"):
                if not name:
                    name = ""
                ret = usergroup_get(name, None, **connection_args)
                return bool(ret)
            # zabbix 2.4 and earlier
            else:
                method = "usergroup.exists"
                params = {}
                if not name and not node and not nodeids:
                    return {
                        "result": False,
                        "comment": (
                            "Please submit name, node or nodeids parameter to check if "
                            "at least one user group exists."
                        ),
                    }
                if name:
                    params["name"] = name
                # deprecated in 2.4
                if _LooseVersion(zabbix_version) < _LooseVersion("2.4"):
                    if node:
                        params["node"] = node
                    if nodeids:
                        params["nodeids"] = nodeids
                ret = _query(method, params, conn_args["url"], conn_args["auth"])
                return ret["result"]
        else:
            raise KeyError
    except KeyError:
        return ret

def usergroup_get(name=None, usrgrpids=None, userids=None, **connection_args):
    """
    .. versionadded:: 2016.3.0

Retrieve user groups according to the given parameters

.. note::
        This function accepts all usergroup_get properties: keyword argument
        names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/2.4/manual/api/reference/usergroup/get

:param name: names of the user groups
    :param usrgrpids: return only user groups with the given IDs
    :param userids: return only user groups that contain the given users
    :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)

:return: Array with convenient user groups details, False if no user group found or on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usergroup_get Guests
    """
    conn_args = _login(**connection_args)
    zabbix_version = apiinfo_version(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "usergroup.get"
            # Versions above 2.4 allow retrieving user group permissions
            if _LooseVersion(zabbix_version) > _LooseVersion("2.5"):
                params = {"selectRights": "extend", "output": "extend", "filter": {}}
            else:
                params = {"output": "extend", "filter": {}}
            if not name and not usrgrpids and not userids:
                return False
            if name:
                params["filter"].setdefault("name", name)
            if usrgrpids:
                params.setdefault("usrgrpids", usrgrpids)
            if userids:
                params.setdefault("userids", userids)
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])

return False if len(ret["result"]) < 1 else ret["result"]
        else:
            raise KeyError
    except KeyError:
        return ret

def usergroup_update(usrgrpid, **connection_args):
    """
    .. versionadded:: 2016.3.0

Update existing user group

.. note::
        This function accepts all standard user group properties: keyword
        argument names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/2.4/manual/api/reference/usergroup/object#user_group

:param usrgrpid: ID of the user group to update.
    :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)

:return: IDs of the updated user group, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usergroup_update 8 name=guestsRenamed
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "usergroup.update"
            params = {"usrgrpid": usrgrpid}
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["usrgrpids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def usergroup_list(**connection_args):
    """
    Retrieve all enabled user groups.

.. versionadded:: 2016.3.0

:return: Array with enabled user groups details, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usergroup_list
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "usergroup.get"
            params = {
                "output": "extend",
            }
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]
        else:
            raise KeyError
    except KeyError:
        return ret

def host_create(host, groups, interfaces, **connection_args):
    """
    .. versionadded:: 2016.3.0

Create new host

.. note::
        This function accepts all standard host properties: keyword argument
        names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/2.4/manual/api/reference/host/object#host

: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 _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: string with visible name of the host, use
        'visible_name' instead of 'name' parameter to not mess with value
        supplied from Salt sls file.

return: ID of the created host.

CLI Example:

.. code-block:: bash

salt '*' zabbix.host_create technicalname 4
        interfaces='{type: 1, main: 1, useip: 1, ip: "192.168.3.1", dns: "", port: 10050}'
        visible_name='Host Visible Name' inventory_mode=0 inventory='{"alias": "something"}'
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "host.create"
            params = {"host": host}
            # Groups
            if not isinstance(groups, list):
                groups = [groups]
            grps = []
            for group in groups:
                grps.append({"groupid": group})
            params["groups"] = grps
            # Interfaces
            if not isinstance(interfaces, list):
                interfaces = [interfaces]
            params["interfaces"] = interfaces
            params = _params_extend(params, _ignore_name=True, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["hostids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def host_delete(hostids, **connection_args):
    """
    Delete hosts.

.. versionadded:: 2016.3.0

:param hostids: Hosts (hostids) to delete.
    :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)

:return: IDs of the deleted hosts.

CLI Example:

.. code-block:: bash

salt '*' zabbix.host_delete 10106
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "host.delete"
            if not isinstance(hostids, list):
                params = [hostids]
            else:
                params = hostids
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["hostids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def host_exists(
    host=None, hostid=None, name=None, node=None, nodeids=None, **connection_args
):
    """
    Checks if at least one host that matches the given filter criteria exists.

.. versionadded:: 2016.3.0

:param host: technical name of the host
    :param hostids: Hosts (hostids) to delete.
    :param name: visible name of the host
    :param node: name of the node the hosts must belong to (zabbix API < 2.4)
    :param nodeids: IDs of the node the hosts must belong to (zabbix API < 2.4)
    :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)

:return: IDs of the deleted hosts, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.host_exists 'Zabbix server'
    """
    conn_args = _login(**connection_args)
    zabbix_version = apiinfo_version(**connection_args)
    ret = False
    try:
        if conn_args:
            # hostgroup.exists deprecated
            if _LooseVersion(zabbix_version) > _LooseVersion("2.5"):
                if not host:
                    host = None
                if not name:
                    name = None
                if not hostid:
                    hostid = None
                ret = host_get(host, name, hostid, **connection_args)
                return bool(ret)
            # zabbix 2.4 nad earlier
            else:
                method = "host.exists"
                params = {}
                if hostid:
                    params["hostid"] = hostid
                if host:
                    params["host"] = host
                if name:
                    params["name"] = name
                # deprecated in 2.4
                if _LooseVersion(zabbix_version) < _LooseVersion("2.4"):
                    if node:
                        params["node"] = node
                    if nodeids:
                        params["nodeids"] = nodeids
                if not hostid and not host and not name and not node and not nodeids:
                    return {
                        "result": False,
                        "comment": (
                            "Please submit hostid, host, name, node or nodeids"
                            " parameter tocheck if at least one host that matches the"
                            " given filter criteria exists."
                        ),
                    }
                ret = _query(method, params, conn_args["url"], conn_args["auth"])
                return ret["result"]
        else:
            raise KeyError
    except KeyError:
        return ret

def host_get(host=None, name=None, hostids=None, **connection_args):
    """
    .. versionadded:: 2016.3.0

Retrieve hosts according to the given parameters

.. note::
        This function accepts all optional host.get parameters: keyword
        argument names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/2.4/manual/api/reference/host/get

:param host: technical name of the host
    :param name: visible name of the host
    :param hostids: ids of the hosts
    :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)

:return: Array with convenient hosts details, False if no host found or on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.host_get 'Zabbix server'
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "host.get"
            params = {"output": "extend", "filter": {}}
            if not name and not hostids and not host:
                return False
            if name:
                params["filter"].setdefault("name", name)
            if hostids:
                params.setdefault("hostids", hostids)
            if host:
                params["filter"].setdefault("host", host)
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"] if len(ret["result"]) > 0 else False
        else:
            raise KeyError
    except KeyError:
        return ret

def host_update(hostid, **connection_args):
    """
    .. versionadded:: 2016.3.0

Update existing hosts

.. note::
        This function accepts all standard host and host.update properties:
        keyword argument names differ depending on your zabbix version, see the
        documentation for `host objects`_ and the documentation for `updating
        hosts`_.

.. _`host objects`: https://www.zabbix.com/documentation/2.4/manual/api/reference/host/object#host
        .. _`updating hosts`: https://www.zabbix.com/documentation/2.4/manual/api/reference/host/update

:param hostid: ID of the host to update
    :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: string with visible name of the host, use
        'visible_name' instead of 'name' parameter to not mess with value
        supplied from Salt sls file.

:return: ID of the updated host.

CLI Example:

.. code-block:: bash

salt '*' zabbix.host_update 10084 name='Zabbix server2'
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "host.update"
            params = {"hostid": hostid}
            params = _params_extend(params, _ignore_name=True, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["hostids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def host_inventory_get(hostids, **connection_args):
    """
    Retrieve host inventory according to the given parameters.
    See: https://www.zabbix.com/documentation/2.4/manual/api/reference/host/object#host_inventory

.. versionadded:: 2019.2.0

:param hostids: ID of the host to query
    :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)

:return: Array with host inventory fields, populated or not, False if host inventory is disabled or on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.host_inventory_get 101054
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "host.get"
            params = {"selectInventory": "extend"}
            if hostids:
                params.setdefault("hostids", hostids)
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return (
                ret["result"][0]["inventory"]
                if ret["result"] and ret["result"][0]["inventory"]
                else False
            )
        else:
            raise KeyError
    except KeyError:
        return ret

def host_inventory_set(hostid, **connection_args):
    """
    Update host inventory items
    NOTE: This function accepts all standard host: keyword argument names for inventory
    see: https://www.zabbix.com/documentation/2.4/manual/api/reference/host/object#host_inventory

.. versionadded:: 2019.2.0

:param hostid: ID of the host to update
    :param clear_old: Set to True in order to remove all existing inventory items before setting the specified items
    :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)

:return: ID of the updated host, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.host_inventory_set 101054 asset_tag=jml3322 type=vm clear_old=True
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            params = {}
            clear_old = False
            method = "host.update"

if connection_args.get("clear_old"):
                clear_old = True
            connection_args.pop("clear_old", None)

inventory_mode = connection_args.pop("inventory_mode", "0")

inventory_params = dict(_params_extend(params, **connection_args))
            for key in inventory_params:
                params.pop(key, None)

if hostid:
                params.setdefault("hostid", hostid)
            if clear_old:
                # Set inventory to disabled in order to clear existing data
                params["inventory_mode"] = "-1"
                ret = _query(method, params, conn_args["url"], conn_args["auth"])

# Set inventory mode to manual in order to submit inventory data
            params["inventory_mode"] = inventory_mode
            params["inventory"] = inventory_params
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]
        else:
            raise KeyError
    except KeyError:
        return ret

def host_list(**connection_args):
    """
    Retrieve all hosts.

.. versionadded:: 2016.3.0

:return: Array with details about hosts, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.host_list
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "host.get"
            params = {
                "output": "extend",
            }
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]
        else:
            raise KeyError
    except KeyError:
        return ret

def hostgroup_create(name, **connection_args):
    """
    .. versionadded:: 2016.3.0

Create a host group

.. note::
        This function accepts all standard host group properties: keyword
        argument names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/2.4/manual/api/reference/hostgroup/object#host_group

:param name: name of the host group
    :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)

:return: ID of the created host group.

CLI Example:

.. code-block:: bash

salt '*' zabbix.hostgroup_create MyNewGroup
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "hostgroup.create"
            params = {"name": name}
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["groupids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def hostgroup_delete(hostgroupids, **connection_args):
    """
    Delete the host group.

.. versionadded:: 2016.3.0

:param hostgroupids: IDs of the host groups to delete
    :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)

:return: ID of the deleted host groups, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.hostgroup_delete 23
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "hostgroup.delete"
            if not isinstance(hostgroupids, list):
                params = [hostgroupids]
            else:
                params = hostgroupids
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["groupids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def hostgroup_exists(
    name=None, groupid=None, node=None, nodeids=None, **connection_args
):
    """
    Checks if at least one host group that matches the given filter criteria exists.

.. versionadded:: 2016.3.0

:param name: names of the host groups
    :param groupid: host group IDs
    :param node: name of the node the host groups must belong to (zabbix API < 2.4)
    :param nodeids: IDs of the nodes the host groups must belong to (zabbix API < 2.4)
    :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)

:return: True if at least one host group exists, False if not or on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.hostgroup_exists MyNewGroup
    """
    conn_args = _login(**connection_args)
    zabbix_version = apiinfo_version(**connection_args)
    ret = False
    try:
        if conn_args:
            # hostgroup.exists deprecated
            if _LooseVersion(zabbix_version) > _LooseVersion("2.5"):
                if not groupid:
                    groupid = None
                if not name:
                    name = None
                ret = hostgroup_get(name, groupid, **connection_args)
                return bool(ret)
            # zabbix 2.4 nad earlier
            else:
                params = {}
                method = "hostgroup.exists"
                if groupid:
                    params["groupid"] = groupid
                if name:
                    params["name"] = name
                # deprecated in 2.4
                if _LooseVersion(zabbix_version) < _LooseVersion("2.4"):
                    if node:
                        params["node"] = node
                    if nodeids:
                        params["nodeids"] = nodeids
                if not groupid and not name and not node and not nodeids:
                    return {
                        "result": False,
                        "comment": (
                            "Please submit groupid, name, node or nodeids parameter"
                            " tocheck if at least one host group that matches the given"
                            " filter criteria exists."
                        ),
                    }
                ret = _query(method, params, conn_args["url"], conn_args["auth"])
                return ret["result"]
        else:
            raise KeyError
    except KeyError:
        return ret

def hostgroup_get(name=None, groupids=None, hostids=None, **connection_args):
    """
    .. versionadded:: 2016.3.0

Retrieve host groups according to the given parameters

.. note::
        This function accepts all standard hostgroup.get properities: keyword
        argument names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/2.2/manual/api/reference/hostgroup/get

:param name: names of the host groups
    :param groupid: host group IDs
    :param node: name of the node the host groups must belong to
    :param nodeids: IDs of the nodes the host groups must belong to
    :param hostids: return only host groups that contain the given hosts

:return: Array with host groups details, False if no convenient host group found or on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.hostgroup_get MyNewGroup
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "hostgroup.get"
            params = {"output": "extend"}
            if not groupids and not name and not hostids:
                return False
            if name:
                name_dict = {"name": name}
                params.setdefault("filter", name_dict)
            if groupids:
                params.setdefault("groupids", groupids)
            if hostids:
                params.setdefault("hostids", hostids)
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"] if len(ret["result"]) > 0 else False
        else:
            raise KeyError
    except KeyError:
        return ret

def hostgroup_update(groupid, name=None, **connection_args):
    """
    .. versionadded:: 2016.3.0

Update existing hosts group

.. note::
        This function accepts all standard host group properties: keyword
        argument names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/2.4/manual/api/reference/hostgroup/object#host_group

:param groupid: ID of the host group to update
    :param name: name of the host group
    :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)

:return: IDs of updated host groups.

CLI Example:

.. code-block:: bash

salt '*' zabbix.hostgroup_update 24 name='Renamed Name'
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "hostgroup.update"
            params = {"groupid": groupid}
            if name:
                params["name"] = name
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["groupids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def hostgroup_list(**connection_args):
    """
    Retrieve all host groups.

.. versionadded:: 2016.3.0

:return: Array with details about host groups, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.hostgroup_list
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "hostgroup.get"
            params = {
                "output": "extend",
            }
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]
        else:
            raise KeyError
    except KeyError:
        return ret

def hostinterface_get(hostids, **connection_args):
    """
    .. versionadded:: 2016.3.0

Retrieve host groups according to the given parameters

.. note::
        This function accepts all standard hostinterface.get properities:
        keyword argument names differ depending on your zabbix version, see
        here__.

.. __: https://www.zabbix.com/documentation/2.4/manual/api/reference/hostinterface/get

:param hostids: Return only host interfaces used by the given hosts.

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

:return: Array with host interfaces details, False if no convenient host interfaces found or on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.hostinterface_get 101054
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "hostinterface.get"
            params = {"output": "extend"}
            if hostids:
                params.setdefault("hostids", hostids)
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"] if len(ret["result"]) > 0 else False
        else:
            raise KeyError
    except KeyError:
        return ret

def hostinterface_create(
    hostid, ip_, dns="", main=1, if_type=1, useip=1, port=None, **connection_args
):
    """
    .. versionadded:: 2016.3.0

Create new host interface

.. note::
        This function accepts all standard host group interface: keyword
        argument names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/3.0/manual/api/reference/hostinterface/object

:param hostid: ID of the host the interface belongs to

:param ip_: IP address used by the interface

:param dns: DNS name used by the interface

:param main: whether the interface is used as default on the host (0 - not default, 1 - default)

:param port: port number used by the interface

:param type: Interface type (1 - agent; 2 - SNMP; 3 - IPMI; 4 - JMX)

:param useip: Whether the connection should be made via IP (0 - connect
        using host DNS name; 1 - connect using host IP address for this host
        interface)

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

:return: ID of the created host interface, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.hostinterface_create 10105 192.193.194.197
    """
    conn_args = _login(**connection_args)
    ret = False

if not port:
        port = INTERFACE_DEFAULT_PORTS[if_type]

try:
        if conn_args:
            method = "hostinterface.create"
            params = {
                "hostid": hostid,
                "ip": ip_,
                "dns": dns,
                "main": main,
                "port": port,
                "type": if_type,
                "useip": useip,
            }
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["interfaceids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def hostinterface_delete(interfaceids, **connection_args):
    """
    Delete host interface

.. versionadded:: 2016.3.0

:param interfaceids: IDs of the host interfaces to delete
    :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)

:return: ID of deleted host interfaces, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.hostinterface_delete 50
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "hostinterface.delete"
            if isinstance(interfaceids, list):
                params = interfaceids
            else:
                params = [interfaceids]
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["interfaceids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def hostinterface_update(interfaceid, **connection_args):
    """
    .. versionadded:: 2016.3.0

Update host interface

.. note::
        This function accepts all standard hostinterface: keyword argument
        names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/2.4/manual/api/reference/hostinterface/object#host_interface

:param interfaceid: ID of the hostinterface to update

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

:return: ID of the updated host interface, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.hostinterface_update 6 ip_=0.0.0.2
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "hostinterface.update"
            params = {"interfaceid": interfaceid}
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["interfaceids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def usermacro_get(
    macro=None,
    hostids=None,
    templateids=None,
    hostmacroids=None,
    globalmacroids=None,
    globalmacro=False,
    **connection_args
):
    """
    Retrieve user macros according to the given parameters.

Args:
        macro:          name of the usermacro
        hostids:        Return macros for the given hostids
        templateids:    Return macros for the given templateids
        hostmacroids:   Return macros with the given hostmacroids
        globalmacroids: Return macros with the given globalmacroids (implies globalmacro=True)
        globalmacro:    if True, returns only global macros

optional connection_args:
                _connection_user: zabbix user (can also be set in opts or pillar, see module's docstring)
                _connection_password: zabbix password (can also be set in opts or pillar, see module's docstring)
                _connection_url: url of zabbix frontend (can also be set in opts or pillar, see module's docstring)

Returns:
        Array with usermacro details, False if no usermacro found or on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usermacro_get macro='{$SNMP_COMMUNITY}'
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "usermacro.get"
            params = {"output": "extend", "filter": {}}
            if macro:
                # Python mistakenly interprets macro names starting and ending with '{' and '}' as a dict
                if isinstance(macro, dict):
                    macro = "{" + str(next(iter(macro))) + "}"
                if not macro.startswith("{") and not macro.endswith("}"):
                    macro = "{" + macro + "}"
                params["filter"].setdefault("macro", macro)
            if hostids:
                params.setdefault("hostids", hostids)
            elif templateids:
                params.setdefault("templateids", hostids)
            if hostmacroids:
                params.setdefault("hostmacroids", hostmacroids)
            elif globalmacroids:
                globalmacro = True
                params.setdefault("globalmacroids", globalmacroids)
            if globalmacro:
                params = _params_extend(params, globalmacro=True)
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"] if len(ret["result"]) > 0 else False
        else:
            raise KeyError
    except KeyError:
        return ret

def usermacro_create(macro, value, hostid, **connection_args):
    """
    Create new host usermacro.

:param macro: name of the host usermacro
    :param value: value of the host usermacro
    :param hostid: hostid or templateid
    :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)

return: ID of the created host usermacro.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usermacro_create '{$SNMP_COMMUNITY}' 'public' 1
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            params = {}
            method = "usermacro.create"
            if macro:
                # Python mistakenly interprets macro names starting and ending with '{' and '}' as a dict
                if isinstance(macro, dict):
                    macro = "{" + str(next(iter(macro))) + "}"
                if not macro.startswith("{") and not macro.endswith("}"):
                    macro = "{" + macro + "}"
                params["macro"] = macro
            params["value"] = value
            params["hostid"] = hostid
            params = _params_extend(params, _ignore_name=True, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["hostmacroids"][0]
        else:
            raise KeyError
    except KeyError:
        return ret

def usermacro_createglobal(macro, value, **connection_args):
    """
    Create new global usermacro.

:param macro: name of the global usermacro
    :param value: value of the global usermacro
    :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)

return: ID of the created global usermacro.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usermacro_createglobal '{$SNMP_COMMUNITY}' 'public'
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            params = {}
            method = "usermacro.createglobal"
            if macro:
                # Python mistakenly interprets macro names starting and ending with '{' and '}' as a dict
                if isinstance(macro, dict):
                    macro = "{" + str(next(iter(macro))) + "}"
                if not macro.startswith("{") and not macro.endswith("}"):
                    macro = "{" + macro + "}"
                params["macro"] = macro
            params["value"] = value
            params = _params_extend(params, _ignore_name=True, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["globalmacroids"][0]
        else:
            raise KeyError
    except KeyError:
        return ret

def usermacro_delete(macroids, **connection_args):
    """
    Delete host usermacros.

:param macroids: macroids of the host usermacros

return: IDs of the deleted host usermacro.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usermacro_delete 21
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "usermacro.delete"
            if isinstance(macroids, list):
                params = macroids
            else:
                params = [macroids]
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["hostmacroids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def usermacro_deleteglobal(macroids, **connection_args):
    """
    Delete global usermacros.

:param macroids: macroids of the global usermacros

return: IDs of the deleted global usermacro.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usermacro_deleteglobal 21
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "usermacro.deleteglobal"
            if isinstance(macroids, list):
                params = macroids
            else:
                params = [macroids]
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["globalmacroids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def usermacro_update(hostmacroid, value, **connection_args):
    """
    Update existing host usermacro.

:param hostmacroid: id of the host usermacro
    :param value: new value of the host usermacro
    :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)

return: ID of the update host usermacro.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usermacro_update 1 'public'
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            params = {}
            method = "usermacro.update"
            params["hostmacroid"] = hostmacroid
            params["value"] = value
            params = _params_extend(params, _ignore_name=True, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["hostmacroids"][0]
        else:
            raise KeyError
    except KeyError:
        return ret

def usermacro_updateglobal(globalmacroid, value, **connection_args):
    """
    Update existing global usermacro.

:param globalmacroid: id of the host usermacro
    :param value: new value of the host usermacro
    :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)

return: ID of the update global usermacro.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usermacro_updateglobal 1 'public'
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            params = {}
            method = "usermacro.updateglobal"
            params["globalmacroid"] = globalmacroid
            params["value"] = value
            params = _params_extend(params, _ignore_name=True, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["globalmacroids"][0]
        else:
            raise KeyError
    except KeyError:
        return ret

def mediatype_get(name=None, mediatypeids=None, **connection_args):
    """
    Retrieve mediatypes according to the given parameters.

Args:
        name:         Name or description of the mediatype
        mediatypeids: ids of the mediatypes

all optional mediatype.get parameters: keyword argument names depends on your zabbix version, see:

https://www.zabbix.com/documentation/2.2/manual/api/reference/mediatype/get

Returns:
        Array with mediatype details, False if no mediatype found or on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.mediatype_get name='Email'
        salt '*' zabbix.mediatype_get mediatypeids="['1', '2', '3']"
    """
    conn_args = _login(**connection_args)
    zabbix_version = apiinfo_version(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "mediatype.get"
            params = {"output": "extend", "filter": {}}
            if name:
                # since zabbix API 4.4, mediatype has new attribute: name
                if _LooseVersion(zabbix_version) >= _LooseVersion("4.4"):
                    params["filter"].setdefault("name", name)
                else:
                    params["filter"].setdefault("description", name)
            if mediatypeids:
                params.setdefault("mediatypeids", mediatypeids)
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"] if len(ret["result"]) > 0 else False
        else:
            raise KeyError
    except KeyError:
        return ret

def mediatype_create(name, mediatype, **connection_args):
    """
    Create new mediatype

.. note::
        This function accepts all standard mediatype properties: keyword
        argument names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/3.0/manual/api/reference/mediatype/object

:param mediatype: media type - 0: email, 1: script, 2: sms, 3: Jabber, 100: Ez Texting
    :param exec_path: exec path - Required for script and Ez Texting types, see Zabbix API docs
    :param gsm_modem: exec path - Required for sms type, see Zabbix API docs
    :param smtp_email: email address from which notifications will be sent, required for email type
    :param smtp_helo: SMTP HELO, required for email type
    :param smtp_server: SMTP server, required for email type
    :param status: whether the media type is enabled - 0: enabled, 1: disabled
    :param username: authentication user, required for Jabber and Ez Texting types
    :param passwd: authentication password, required for Jabber and Ez Texting types
    :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)

return: ID of the created mediatype.

CLI Example:

.. code-block:: bash

salt '*' zabbix.mediatype_create 'Email' 0 smtp_email='noreply@example.com'
        smtp_server='mailserver.example.com' smtp_helo='zabbix.example.com'
    """
    conn_args = _login(**connection_args)
    zabbix_version = apiinfo_version(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "mediatype.create"
            # since zabbix 4.4 api, mediatype has new attribute: name
            if _LooseVersion(zabbix_version) >= _LooseVersion("4.4"):
                params = {"name": name}
                _ignore_name = False
            else:
                params = {"description": name}
                _ignore_name = True
            params["type"] = mediatype
            params = _params_extend(params, _ignore_name, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["mediatypeid"]
        else:
            raise KeyError
    except KeyError:
        return ret

def mediatype_delete(mediatypeids, **connection_args):
    """
    Delete mediatype

:param interfaceids: IDs of the mediatypes to delete
    :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)

:return: ID of deleted mediatype, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.mediatype_delete 3
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "mediatype.delete"
            if isinstance(mediatypeids, list):
                params = mediatypeids
            else:
                params = [mediatypeids]
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["mediatypeids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def mediatype_update(mediatypeid, name=False, mediatype=False, **connection_args):
    """
    Update existing mediatype

.. note::
        This function accepts all standard mediatype properties: keyword
        argument names differ depending on your zabbix version, see here__.

.. __: https://www.zabbix.com/documentation/3.0/manual/api/reference/mediatype/object

:param mediatypeid: ID of the mediatype to update
    :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)

:return: IDs of the updated mediatypes, False on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.usergroup_update 8 name="Email update"
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "mediatype.update"
            params = {"mediatypeid": mediatypeid}
            if name:
                params["description"] = name
            if mediatype:
                params["type"] = mediatype
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"]["mediatypeids"]
        else:
            raise KeyError
    except KeyError:
        return ret

def template_get(name=None, host=None, templateids=None, **connection_args):
    """
    Retrieve templates according to the given parameters.

Args:
        host: technical name of the template
        name: visible name of the template
        hostids: ids of the templates

all optional template.get parameters: keyword argument names depends on your zabbix version, see:

https://www.zabbix.com/documentation/2.4/manual/api/reference/template/get

Returns:
        Array with convenient template details, False if no template found or on failure.

CLI Example:

.. code-block:: bash

salt '*' zabbix.template_get name='Template OS Linux'
        salt '*' zabbix.template_get templateids="['10050', '10001']"
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            method = "template.get"
            params = {"output": "extend", "filter": {}}
            if name:
                params["filter"].setdefault("name", name)
            if host:
                params["filter"].setdefault("host", host)
            if templateids:
                params.setdefault("templateids", templateids)
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            return ret["result"] if len(ret["result"]) > 0 else False
        else:
            raise KeyError
    except KeyError:
        return ret

def run_query(method, params, **connection_args):
    """
    Send Zabbix API call

Args:
        method: actual operation to perform via the API
        params: parameters required for specific method

all optional template.get parameters: keyword argument names depends on your zabbix version, see:

https://www.zabbix.com/documentation/2.4/manual/api/reference/

Returns:
        Response from Zabbix API

CLI Example:

.. code-block:: bash

salt '*' zabbix.run_query proxy.create '{"host": "zabbixproxy.domain.com", "status": "5"}'
    """
    conn_args = _login(**connection_args)
    ret = False
    try:
        if conn_args:
            params = _params_extend(params, **connection_args)
            ret = _query(method, params, conn_args["url"], conn_args["auth"])
            if isinstance(ret["result"], bool):
                return ret["result"]
            if ret["result"] is True or len(ret["result"]) > 0:
                return ret["result"]
            else:
                return False
        else:
            raise KeyError
    except KeyError:
        return ret

def configuration_import(config_file, rules=None, file_format="xml", **connection_args):
    """
    .. versionadded:: 2017.7

Imports Zabbix configuration specified in file to Zabbix server.

:param config_file: File with Zabbix config (local or remote)
    :param rules: Optional - Rules that have to be different from default (defaults are the same as in Zabbix web UI.)
    :param file_format: Config file format (default: xml)
    :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)

CLI Example:

.. code-block:: bash

salt '*' zabbix.configuration_import salt://zabbix/config/zabbix_templates.xml \
        "{'screens': {'createMissing': True, 'updateExisting': True}}"
    """
    zabbix_version = apiinfo_version(**connection_args)

if rules is None:
        rules = {}
    default_rules = {
        "discoveryRules": {
            "createMissing": True,
            "updateExisting": True,
            "deleteMissing": False,
        },
        "graphs": {
            "createMissing": True,
            "updateExisting": True,
            "deleteMissing": False,
        },
        "groups": {"createMissing": True},
        "hosts": {"createMissing": False, "updateExisting": False},
        "images": {"createMissing": False, "updateExisting": False},
        "items": {
            "createMissing": True,
            "updateExisting": True,
            "deleteMissing": False,
        },
        "maps": {"createMissing": False, "updateExisting": False},
        "screens": {"createMissing": False, "updateExisting": False},
        "templateLinkage": {"createMissing": True},
        "templates": {"createMissing": True, "updateExisting": True},
        "templateScreens": {
            "createMissing": True,
            "updateExisting": True,
            "deleteMissing": False,
        },
        "triggers": {
            "createMissing": True,
            "updateExisting": True,
            "deleteMissing": False,
        },
        "valueMaps": {"createMissing": True, "updateExisting": False},
    }
    if _LooseVersion(zabbix_version) >= _LooseVersion("3.2"):
        # rules/httptests added
        default_rules["httptests"] = {
            "createMissing": True,
            "updateExisting": True,
            "deleteMissing": False,
        }
    if _LooseVersion(zabbix_version) >= _LooseVersion("3.4"):
        # rules/applications/upateExisting deprecated
        default_rules["applications"] = {"createMissing": True, "deleteMissing": False}
    else:
        default_rules["applications"] = {
            "createMissing": True,
            "updateExisting": True,
            "deleteMissing": False,
        }
    new_rules = dict(default_rules)

if rules:
        for rule in rules:
            if rule in new_rules:
                new_rules[rule].update(rules[rule])
            else:
                new_rules[rule] = rules[rule]
    if "salt://" in config_file:
        tmpfile = salt.utils.files.mkstemp()
        cfile = __salt__["cp.get_file"](config_file, tmpfile)
        if not cfile or os.path.getsize(cfile) == 0:
            return {
                "name": config_file,
                "result": False,
                "message": "Failed to fetch config file.",
            }
    else:
        cfile = config_file
        if not os.path.isfile(cfile):
            return {
                "name": config_file,
                "result": False,
                "message": "Invalid file path.",
            }

with salt.utils.files.fopen(cfile, mode="r") as fp_:
        xml = fp_.read()

if "salt://" in config_file:
        salt.utils.files.safe_rm(cfile)

params = {"format": file_format, "rules": new_rules, "source": xml}
    log.info("CONFIGURATION IMPORT: rules: %s", str(params["rules"]))
    try:
        run_query("configuration.import", params, **connection_args)
        return {
            "name": config_file,
            "result": True,
            "message": 'Zabbix API "configuration.import" method called successfully.',
        }
    except SaltException as exc:
        return {"name": config_file, "result": False, "message": str(exc)}

003 File Manager

Editing: zabbix.py

Upload File

Create Folder