def main():
# use the predefined argument spec for url
argument_spec = grafana_argument_spec()
argument_spec.update(
state=dict(choices=['present', 'absent', 'export'], default='present'),
org_id=dict(default=1, type='int'),
folder=dict(type='str', default='General'),
uid=dict(type='str'),
slug=dict(type='str'),
path=dict(aliases=['dashboard_url'], type='str'),
dashboard_id=dict(type='str'),
dashboard_revision=dict(type='str', default='1'),
overwrite=dict(type='bool', default=False),
commit_message=dict(
type='str',
aliases=['message'],
deprecated_aliases=[dict(name='message', version='2.14')]),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
required_together=[['url_username', 'url_password', 'org_id']],
mutually_exclusive=[['url_username', 'grafana_api_key'],
['uid', 'slug'], ['path', 'dashboard_id']],
)
if 'message' in module.params:
module.fail_json(
msg=
"'message' is reserved keyword, please change this parameter to 'commit_message'"
)
try:
if module.params['state'] == 'present':
result = grafana_create_dashboard(module, module.params)
elif module.params['state'] == 'absent':
result = grafana_delete_dashboard(module, module.params)
else:
result = grafana_export_dashboard(module, module.params)
except GrafanaAPIException as e:
module.fail_json(failed=True, msg="error : %s" % to_native(e))
return
except GrafanaMalformedJson as e:
module.fail_json(failed=True, msg="error : %s" % to_native(e))
return
except GrafanaDeleteException as e:
module.fail_json(failed=True,
msg="error : Can't delete dashboard : %s" %
to_native(e))
return
except GrafanaExportException as e:
module.fail_json(failed=True,
msg="error : Can't export dashboard : %s" %
to_native(e))
return
module.exit_json(failed=False, **result)
return
def main():
# use the predefined argument spec for url
argument_spec = grafana_argument_spec()
argument_spec.update(
name=dict(required=True, type='str'),
ds_type=dict(choices=['graphite',
'prometheus',
'elasticsearch',
'influxdb',
'opentsdb',
'mysql',
'postgres',
'cloudwatch',
'alexanderzobnin-zabbix-datasource',
'sni-thruk-datasource'], required=True),
ds_url=dict(required=True, type='str'),
access=dict(default='proxy', choices=['proxy', 'direct']),
database=dict(type='str', default=""),
user=dict(default='', type='str'),
password=dict(default='', no_log=True, type='str'),
basic_auth_user=dict(type='str'),
basic_auth_password=dict(type='str', no_log=True),
with_credentials=dict(default=False, type='bool'),
tls_client_cert=dict(type='str', no_log=True),
tls_client_key=dict(type='str', no_log=True),
tls_ca_cert=dict(type='str', no_log=True),
tls_skip_verify=dict(type='bool', default=False),
is_default=dict(default=False, type='bool'),
org_id=dict(default=1, type='int'),
es_version=dict(type='int', default=5, choices=[2, 5, 56]),
max_concurrent_shard_requests=dict(type='int', default=256),
time_field=dict(default='@timestamp', type='str'),
time_interval=dict(type='str'),
interval=dict(type='str', choices=['', 'Hourly', 'Daily', 'Weekly', 'Monthly', 'Yearly'], default=''),
tsdb_version=dict(type='int', default=1, choices=[1, 2, 3]),
tsdb_resolution=dict(type='str', default='second', choices=['second', 'millisecond']),
sslmode=dict(default='disable', choices=['disable', 'require', 'verify-ca', 'verify-full']),
trends=dict(default=False, type='bool'),
aws_auth_type=dict(default='keys', choices=['keys', 'credentials', 'arn']),
aws_default_region=dict(default='us-east-1', choices=['ap-northeast-1', 'ap-northeast-2', 'ap-southeast-1', 'ap-southeast-2', 'ap-south-1',
'ca-central-1',
'cn-north-1', 'cn-northwest-1',
'eu-central-1', 'eu-west-1', 'eu-west-2', 'eu-west-3',
'sa-east-1',
'us-east-1', 'us-east-2', 'us-gov-west-1', 'us-west-1', 'us-west-2']),
aws_access_key=dict(default='', no_log=True, type='str'),
aws_secret_key=dict(default='', no_log=True, type='str'),
aws_credentials_profile=dict(default='', type='str'),
aws_assume_role_arn=dict(default='', type='str'),
aws_custom_metrics_namespaces=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
required_together=[['url_username', 'url_password', 'org_id'], ['tls_client_cert', 'tls_client_key']],
mutually_exclusive=[['url_username', 'grafana_api_key'], ['tls_ca_cert', 'tls_skip_verify']],
required_if=[
['ds_type', 'opentsdb', ['tsdb_version', 'tsdb_resolution']],
['ds_type', 'influxdb', ['database']],
['ds_type', 'elasticsearch', ['database', 'es_version', 'time_field', 'interval']],
['ds_type', 'mysql', ['database']],
['ds_type', 'postgres', ['database', 'sslmode']],
['ds_type', 'cloudwatch', ['aws_auth_type', 'aws_default_region']],
['es_version', 56, ['max_concurrent_shard_requests']]
],
)
state = module.params['state']
name = module.params['name']
grafana_iface = GrafanaInterface(module)
ds = grafana_iface.datasource_by_name(name)
if state == 'present':
payload = get_datasource_payload(module.params)
if ds is None:
result = grafana_iface.create_datasource(payload)
ds = grafana_iface.datasource_by_name(name)
module.exit_json(changed=True, datasource=ds, msg='Datasource %s created' % name)
else:
diff = compare_datasources(payload.copy(), ds.copy())
if diff.get('before') == diff.get('after'):
module.exit_json(changed=False, datasource=ds, msg='Datasource %s unchanged' % name)
grafana_iface.update_datasource(ds.get('id'), payload)
ds = grafana_iface.datasource_by_name(name)
module.exit_json(changed=True, diff=diff, datasource=ds, msg='Datasource %s updated' % name)
else:
if ds is None:
module.exit_json(changed=False, datasource=None, msg='Datasource %s does not exist.' % name)
grafana_iface.delete_datasource(name)
module.exit_json(changed=True, datasource=None, msg='Datasource %s deleted.' % name)
is_admin=target_user.get("isGrafanaAdmin"))
param_dict = dict(email=email, name=name, login=login, is_admin=is_admin)
return target_user_dict != param_dict
def setup_module_object():
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False,
required_if=[
['state', 'present', ['name', 'email']],
],
required_together=grafana_required_together())
return module
argument_spec = grafana_argument_spec()
argument_spec.update(
state=dict(choices=['present', 'absent'], default='present'),
name=dict(type='str', required=False),
email=dict(type='str', required=False),
login=dict(type='str', required=True),
password=dict(type='str', required=False, no_log=True),
is_admin=dict(type='bool', default=False),
)
argument_spec.pop('grafana_api_key')
def main():
module = setup_module_object()
state = module.params['state']
name = module.params['name']
self._module.fail_json(failed=True,
msg="User '%s' does not exists" % email)
return user.get("id")
def setup_module_object():
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
required_together=base.grafana_required_together(),
mutually_exclusive=base.grafana_mutually_exclusive(),
)
return module
argument_spec = base.grafana_argument_spec()
argument_spec.update(
name=dict(type='str', required=True),
email=dict(type='str', required=True),
members=dict(type='list', elements='str', required=False),
enforce_members=dict(type='bool', default=False),
skip_version_check=dict(type='bool', default=False),
)
def main():
module = setup_module_object()
state = module.params['state']
name = module.params['name']
email = module.params['email']
def main():
argument_spec = grafana_argument_spec()
argument_spec.update(
org_id=dict(type='int', default=1),
uid=dict(type='str'),
name=dict(type='str'),
type=dict(type='str',
choices=[
'dingding', 'discord', 'email', 'googlechat', 'hipchat',
'kafka', 'line', 'teams', 'opsgenie', 'pagerduty',
'prometheus', 'pushover', 'sensu', 'slack', 'telegram',
'threema', 'victorops', 'webhook'
]),
is_default=dict(type='bool', default=False),
include_image=dict(type='bool', default=False),
disable_resolve_message=dict(type='bool', default=False),
reminder_frequency=dict(type='str'),
dingding_url=dict(type='str'),
dingding_message_type=dict(type='list',
elements='str',
choices=['link', 'action_card']),
discord_url=dict(type='str'),
discord_message_content=dict(type='str'),
email_addresses=dict(type='list', elements='str'),
email_single=dict(type='bool'),
googlechat_url=dict(type='str'),
hipchat_url=dict(type='str'),
hipchat_api_key=dict(type='str', no_log=True),
hipchat_room_id=dict(type='str'),
kafka_url=dict(type='str'),
kafka_topic=dict(type='str'),
line_token=dict(type='str', no_log=True),
teams_url=dict(type='str'),
opsgenie_url=dict(type='str'),
opsgenie_api_key=dict(type='str', no_log=True),
opsgenie_auto_close=dict(type='bool'),
opsgenie_override_priority=dict(type='bool'),
pagerduty_integration_key=dict(type='str', no_log=True),
pagerduty_severity=dict(
type='list',
elements='str',
choices=['critical', 'error', 'warning', 'info']),
pagerduty_auto_resolve=dict(type='bool'),
pagerduty_message_in_details=dict(type='bool'),
prometheus_url=dict(type='str'),
prometheus_username=dict(type='str'),
prometheus_password=dict(type='str', no_log=True),
pushover_api_token=dict(type='str', no_log=True),
pushover_user_key=dict(type='str', no_log=True),
pushover_devices=dict(type='list', elements='str'),
pushover_priority=dict(
type='list',
elements='str',
choices=['emergency', 'high', 'normal', 'low', 'lowest']),
pushover_retry=dict(type='int'), # TODO: only when priority==emergency
pushover_expire=dict(
type='int'), # TODO: only when priority==emergency
pushover_alert_sound=dict(type='str'), # TODO: add sound choices
pushover_ok_sound=dict(type='str'), # TODO: add sound choices
sensu_url=dict(type='str'),
sensu_source=dict(type='str'),
sensu_handler=dict(type='str'),
sensu_username=dict(type='str'),
sensu_password=dict(type='str', no_log=True),
slack_url=dict(type='str', no_log=True),
slack_recipient=dict(type='str'),
slack_username=dict(type='str'),
slack_icon_emoji=dict(type='str'),
slack_icon_url=dict(type='str'),
slack_mention_users=dict(type='list', elements='str'),
slack_mention_groups=dict(type='list', elements='str'),
slack_mention_channel=dict(type='list',
elements='str',
choices=['here', 'channel']),
slack_token=dict(type='str', no_log=True),
telegram_bot_token=dict(type='str'),
telegram_chat_id=dict(type='str'),
threema_gateway_id=dict(type='str'),
threema_recepient_id=dict(type='str'),
threema_api_secret=dict(type='str', no_log=True),
victorops_url=dict(type='str'),
victorops_auto_resolve=dict(type='bool'),
webhook_url=dict(type='str'),
webhook_username=dict(type='str'),
webhook_password=dict(type='str', no_log=True),
webhook_http_method=dict(type='list',
elements='str',
choices=['POST', 'PUT']))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
required_together=[['url_username', 'url_password', 'org_id'],
['prometheus_username', 'prometheus_password'],
['sensu_username', 'sensu_password']],
mutually_exclusive=[['url_username', 'grafana_api_key']],
required_if=[
['state', 'present', ['name', 'type']],
['type', 'dingding', ['dingding_url']],
['type', 'discord', ['discord_url']],
['type', 'email', ['email_addresses']],
['type', 'googlechat', ['googlechat_url']],
['type', 'hipchat', ['hipchat_url']],
['type', 'kafka', ['kafka_url', 'kafka_topic']],
['type', 'line', ['line_token']], ['type', 'teams', ['teams_url']],
['type', 'opsgenie', ['opsgenie_url', 'opsgenie_api_key']],
['type', 'pagerduty', ['pagerduty_integration_key']],
['type', 'prometheus', ['prometheus_url']],
['type', 'pushover', ['pushover_api_token', 'pushover_user_key']],
['type', 'sensu', ['sensu_url']], ['type', 'slack', ['slack_url']],
['type', 'telegram', ['telegram_bot_token', 'telegram_chat_id']],
[
'type', 'threema',
[
'threema_gateway_id', 'threema_recepient_id',
'threema_api_secret'
]
], ['type', 'victorops', ['victorops_url']],
['type', 'webhook', ['webhook_url']]
])
if module.params['state'] == 'present':
result = grafana_create_or_update_notification_channel(
module, module.params)
module.exit_json(failed=False, **result)
else:
result = grafana_delete_notification_channel(module, module.params)
module.exit_json(failed=False, **result)
