def main():
argument_spec = ld_common_argument_spec()
argument_spec.update(
dict(
state=dict(type="str",
default="present",
choices=["absent", "present"]),
key=dict(type="str", required=True, aliases=["custom_role_key"]),
name=dict(type="str"),
description=dict(type="str"),
policy=policy_argument_spec(),
))
module = AnsibleModule(argument_spec=argument_spec)
if not HAS_LD:
module.fail_json(msg=missing_required_lib("launchdarkly_api"),
exception=LD_IMP_ERR)
configuration = configure_instance(module.params["api_key"])
api_instance = launchdarkly_api.CustomRolesApi(
launchdarkly_api.ApiClient(configuration))
if module.params["state"] == "present":
if module.params.get("key") and _fetch_custom_role(
module, api_instance):
_configure_custom_role(module, api_instance)
else:
_create_custom_role(module, api_instance)
elif module.params["state"] == "absent":
_delete_custom_role(module, api_instance)
def main():
module = AnsibleModule(argument_spec=dict(
state=dict(
type="str", default="present", choices=["absent", "present"]),
api_key=dict(
required=True,
type="str",
no_log=True,
fallback=(env_fallback, ["LAUNCHDARKLY_ACCESS_TOKEN"]),
),
environment_key=dict(type="str", required=True),
project_key=dict(type="str", required=True),
user_segment_key=dict(type="str", required=True),
environment_targets=dict(type="list", required=True),
included_actions=dict(type="list",
choices=["updateTargets", "updateRules"]),
excluded_actions=dict(type="list",
choices=["updateTargets", "updateRules"]),
))
if not HAS_LD:
module.fail_json(msg=missing_required_lib("launchdarkly_api"),
exception=LD_IMP_ERR)
configuration = configure_instance(module.params["api_key"])
api_instance = launchdarkly_api.UserSegmentsApi(
launchdarkly_api.ApiClient(configuration))
_configure_user_sync(module, api_instance)
def main():
module = AnsibleModule(argument_spec=dict(
api_key=dict(
required=True,
type="str",
no_log=True,
fallback=(env_fallback, ["LAUNCHDARKLY_ACCESS_TOKEN"]),
),
project_key=dict(type="str", required=False),
tags=dict(type="list", required=False),
environment_tags=dict(type="list", required=False),
))
if not HAS_LD:
module.fail_json(msg=missing_required_lib("launchdarkly_api"),
exception=LD_IMP_ERR)
# Set up API
configuration = configure_instance(module.params["api_key"])
api_instance = launchdarkly_api.ProjectsApi(
launchdarkly_api.ApiClient(configuration))
project = _fetch_projects(module, api_instance)
module.exit_json(changed=True, project=project)
def main():
argument_spec = ld_common_argument_spec()
argument_spec.update(
dict(
state=dict(
type="str",
default="present",
choices=["absent", "present", "enabled", "disabled"],
),
name=dict(type="str"),
sign=dict(type="bool", default=False),
url=dict(type="str"),
webhook_id=dict(type="str"),
tags=dict(type="list", elements="str"),
statements=policy_argument_spec(),
))
module = AnsibleModule(argument_spec=argument_spec)
if not HAS_LD:
module.fail_json(msg=missing_required_lib("launchdarkly_api"),
exception=LD_IMP_ERR)
configuration = configure_instance(module.params["api_key"])
api_instance = launchdarkly_api.WebhooksApi(
launchdarkly_api.ApiClient(configuration))
if module.params["state"] in ["present", "enabled"]:
webhook = _fetch_webhook(module, api_instance)
if webhook:
_configure_webhook(module, api_instance, webhook)
else:
_create_webhook(module, api_instance)
elif module.params["state"] == "absent":
_delete_webhook(module, api_instance)
def main():
required_if = [
["kind", "str", ["variations"]],
["kind", "json", ["variations"]],
["kind", "number", ["variations"]],
]
argument_spec = ld_common_argument_spec()
argument_spec.update(
dict(
state=dict(type="str",
default="present",
choices=["absent", "present"]),
name=dict(type="str", required_if=["state", "present"]),
kind=dict(
choices=["str", "bool", "json", "number"],
required_if=["state", "present"],
),
project_key=dict(default="default", type="str"),
key=dict(required=True, type="str"),
temporary=dict(type="bool", default=True),
tags=dict(type="list"),
description=dict(type="str"),
variations=dict(
type="list",
elements="dict",
options=dict(
name=dict(type="str"),
value=dict(type="raw"),
description=dict(type="str"),
),
),
include_in_snippet=dict(type="bool", default=False),
comment=dict(type="str"),
maintainer_id=dict(type="str"),
))
module = AnsibleModule(argument_spec=argument_spec,
required_if=required_if)
if not HAS_LD:
module.fail_json(msg=missing_required_lib("launchdarkly_api"),
exception=LD_IMP_ERR)
# Set up API
configuration = configure_instance(module.params["api_key"])
api_instance = launchdarkly_api.FeatureFlagsApi(
launchdarkly_api.ApiClient(configuration))
if module.params["state"] == "present":
feature_flag = _fetch_flag(module, api_instance)
if feature_flag:
_configure_flag(module, api_instance, feature_flag)
else:
_create_flag(module, api_instance)
elif module.params["state"] == "absent":
_delete_flag(module, api_instance)
def run(self, terms, api_key=None, **kwargs):
try:
api_key = os.environ.get("LAUNCHDARKLY_ACCESS_TOKEN", api_key)
configuration = configure_instance(api_key)
api_instance = launchdarkly_api.UserSegmentsApi(
launchdarkly_api.ApiClient(configuration))
except Exception as e:
raise AnsibleError("Error starting LaunchDarkly SDK: %s" % e)
project = terms[0]
environment = terms[1]
# TODO add tag support
# tags = terms[2]
ret = []
project = api_instance.get_user_segments(project, environment)
ret.append(project)
return ret
def main():
mutually_exclusive = []
spec = ld_common_argument_spec()
spec.update(ld_env_arg_spec())
spec.update(
dict(
state=dict(type="str",
default="present",
choices=["absent", "present"]),
api_key=dict(
required=True,
type="str",
no_log=True,
fallback=(env_fallback, ["LAUNCHDARKLY_ACCESS_TOKEN"]),
),
project_key=dict(type="str", required=True),
secure_mode=dict(type="bool"),
require_comments=dict(type="bool"),
confirm_changes=dict(type="bool"),
default_track_events=dict(type="bool"),
tags=dict(type="list", elements="str"),
))
module = AnsibleModule(argument_spec=spec,
mutually_exclusive=mutually_exclusive)
if not HAS_LD:
module.fail_json(msg=missing_required_lib("launchdarkly_api"),
exception=LD_IMP_ERR)
configuration = configure_instance(module.params["api_key"])
api_instance = launchdarkly_api.EnvironmentsApi(
launchdarkly_api.ApiClient(configuration))
if module.params["state"] == "present":
environment = _fetch_environment(module, api_instance)
if environment:
_configure_environment(module, api_instance, environment)
else:
_create_environment(module, api_instance)
elif module.params["state"] == "absent":
_delete_environment(module, api_instance)
def run(self, terms, api_key=None, **kwargs):
try:
api_key = os.environ.get("LAUNCHDARKLY_ACCESS_TOKEN", api_key)
configuration = configure_instance(api_key)
api_instance = launchdarkly_api.EnvironmentsApi(
launchdarkly_api.ApiClient(configuration))
except Exception as e:
raise AnsibleError("Error starting LaunchDarkly SDK: %s" % e)
project = terms[0]
environment = terms[1]
ret = []
try:
# TODO: Add ability to lookup multiple environments
project = api_instance.get_environment(project, environment)
except ApiException as e:
raise AnsibleError("Failed to lookup environment: %s" % e.reason)
ret.append(project)
return ret
def main():
module = AnsibleModule(
argument_spec=dict(
api_key=dict(
required=True,
type="str",
no_log=True,
fallback=(env_fallback, ["LAUNCHDARKLY_ACCESS_TOKEN"]),
),
env=dict(type="str"),
project_key=dict(type="str", required=True),
key=dict(type="str"),
summary=dict(type="bool"),
archived=dict(type="bool"),
tag=dict(type="str"),
)
)
if not HAS_LD:
module.fail_json(
msg=missing_required_lib("launchdarkly_api"), exception=LD_IMP_ERR
)
# Set up API
configuration = configure_instance(module.params["api_key"])
api_instance = launchdarkly_api.FeatureFlagsApi(
launchdarkly_api.ApiClient(configuration)
)
try:
feature_flags = fetch_flags(module.params, api_instance)
except launchdarkly_api.rest.ApiException as e:
fail_exit(module, e)
if feature_flags.get("items"):
flags = feature_flags["items"]
else:
flags = feature_flags
module.exit_json(changed=True, feature_flags=flags)
def main():
argument_spec = ld_common_argument_spec()
argument_spec.update(
dict(
env=dict(type="str"),
project_key=dict(type="str", required=True),
tag=dict(type="str"),
)
)
module = AnsibleModule(argument_spec=argument_spec)
if not HAS_LD:
module.fail_json(
msg=missing_required_lib("launchdarkly_api"), exception=LD_IMP_ERR
)
# Set up API
configuration = configure_instance(module.params["api_key"])
api_instance = launchdarkly_api.FeatureFlagsApi(
launchdarkly_api.ApiClient(configuration)
)
feature_flags = _fetch_flags(module, api_instance)
flags = feature_flags["items"]
results = []
for flag in flags:
result = rego_test(module, flag)
if result.results[0].failures:
validation_fail = {"key": flag["key"], "failures": []}
for failure in result.results[0].failures:
validation_fail["failures"].append(failure["msg"])
results.append(validation_fail)
if results:
module.exit_json(failed=True, validated=False, validation=results)
else:
module.exit_json(changed=True, validated=True)
def main():
argument_spec = ld_common_argument_spec()
argument_spec.update(
dict(
state=dict(type="str",
default="present",
choices=["absent", "present"]),
project_key=dict(type="str", required=True),
name=dict(type="str", required_if=["state", "present"]),
environments=dict(type="list",
elements="dict",
options=ld_env_arg_spec()),
tags=dict(type="list", elements="str"),
include_in_snippet_by_default=dict(type="bool"),
))
module = AnsibleModule(argument_spec=argument_spec)
if not HAS_LD:
module.fail_json(msg=missing_required_lib("launchdarkly_api"),
exception=LD_IMP_ERR)
configuration = configure_instance(module.params["api_key"])
api_instance = launchdarkly_api.ProjectsApi(
launchdarkly_api.ApiClient(configuration))
if module.params["environments"]:
for env in module.params["environments"]:
del env["environment_key"]
if module.params["state"] == "present":
project = _fetch_project(module, api_instance)
if project:
_configure_project(module, api_instance, project)
else:
_create_project(module, api_instance)
elif module.params["state"] == "absent":
_delete_project(module, api_instance)
def main():
argument_spec = ld_common_argument_spec()
argument_spec.update(
dict(
state=dict(type="str",
default="present",
choices=["absent", "present"]),
environment_key=dict(type="str", required=True),
project_key=dict(type="str", required=True),
user_segment_key=dict(type="str", required=True),
name=dict(type="str"),
description=dict(type="str"),
tags=dict(type="list"),
included=dict(type="list"),
excluded=dict(type="list"),
rules=usr_argument_spec(),
))
module = AnsibleModule(argument_spec=argument_spec)
if not HAS_LD:
module.fail_json(msg=missing_required_lib("launchdarkly_api"),
exception=LD_IMP_ERR)
configuration = configure_instance(module.params["api_key"])
api_instance = launchdarkly_api.UserSegmentsApi(
launchdarkly_api.ApiClient(configuration))
if module.params["state"] == "present":
user_segment = _fetch_user_segment(module, api_instance)
if user_segment:
_configure_user_segment(module, api_instance, user_segment)
else:
_create_user_segment(module, api_instance)
elif module.params["state"] == "absent":
_delete_user_segment(module, api_instance)
def main():
argument_spec = ld_common_argument_spec()
argument_spec.update(
dict(
state=dict(
type="str",
default="present",
choices=["absent", "present", "enabled", "disabled"],
),
flag_key=dict(type="str", required=True),
environment_key=dict(type="str", required=True),
project_key=dict(type="str", required=True),
off_variation=dict(type="int"),
track_events=dict(type="bool"),
comment=dict(type="str"),
salt=dict(type="str"),
targets=dict(
type="list",
elements="dict",
options=dict(
values=dict(type="list"),
variation=dict(type="int"),
state=dict(
type="str",
default="replace",
choices=["add", "remove", "replace", "absent"],
),
),
),
fallthrough=dict(
type="dict",
options=dict(
variation=dict(type="int"),
rollout=dict(
type="dict",
# elements="dict",
bucket_by=dict(type="str"),
weighted_variations=dict(
type="list",
elements="dict",
options=dict(
variation=dict(type="int"), weight=dict(type="int")
),
),
),
),
),
rules=rule_argument_spec(),
prerequisites=dict(
type="list",
options=dict(key=dict(type="str"), variation=dict(type="int")),
),
)
)
module = AnsibleModule(argument_spec=argument_spec)
if not HAS_LD:
module.fail_json(
msg=missing_required_lib("launchdarkly_api"), exception=LD_IMP_ERR
)
configuration = configure_instance(module.params["api_key"])
api_instance = launchdarkly_api.FeatureFlagsApi(
launchdarkly_api.ApiClient(configuration)
)
if module.params["state"] == "absent":
_delete_feature_flag_env(module, api_instance)
else:
feature_flag = _fetch_feature_flag(module, api_instance)
_configure_feature_flag_env(module, api_instance, feature_flag)
def main():
module = AnsibleModule(argument_spec=dict(
api_key=dict(
required=True,
type="str",
no_log=True,
fallback=(env_fallback, ["LAUNCHDARKLY_ACCESS_TOKEN"]),
),
api_key_dest=dict(
required=True,
type="str",
no_log=True,
fallback=(env_fallback, ["LAUNCHDARKLY_DEST_ACCESS_TOKEN"]),
),
project_key=dict(type="str", required=True),
project_key_dest=dict(type="str", required=True),
flag_tag=dict(type="list", elements="str"),
environments_copy=dict(type="bool", default=True),
name=dict(type="str"),
))
if not HAS_LD:
module.fail_json(msg=missing_required_lib("launchdarkly_api"),
exception=LD_IMP_ERR)
# Setup the necessary API clients
api_instance_src_user = launchdarkly_api.UserSegmentsApi(
launchdarkly_api.ApiClient(configure_instance(
module.params["api_key"])))
api_instance_src_proj = launchdarkly_api.ProjectsApi(
launchdarkly_api.ApiClient(configure_instance(
module.params["api_key"])))
api_instance_src_fflag = launchdarkly_api.FeatureFlagsApi(
launchdarkly_api.ApiClient(configure_instance(
module.params["api_key"])))
api_instance_dest_user = launchdarkly_api.UserSegmentsApi(
launchdarkly_api.ApiClient(
configure_instance(module.params["api_key_dest"])))
api_instance_dest_proj = launchdarkly_api.ProjectsApi(
launchdarkly_api.ApiClient(
configure_instance(module.params["api_key_dest"])))
api_instance_dest_fflag = launchdarkly_api.FeatureFlagsApi(
launchdarkly_api.ApiClient(
configure_instance(module.params["api_key_dest"])))
api_instance_dest_env = launchdarkly_api.EnvironmentsApi(
launchdarkly_api.ApiClient(
configure_instance(module.params["api_key_dest"])))
_project_sync(
module,
api_instance_src_proj,
api_instance_dest_proj,
api_instance_dest_env,
api_instance_src_user,
api_instance_dest_user,
api_instance_src_fflag,
api_instance_dest_fflag,
)
