def assign_user_to_group(self, user, group_identifier, access_level):
group = find_group(self._gitlab, group_identifier)
if self._module.check_mode:
return True
if group is None:
return False
if self.member_exists(group, self.get_user_id(user)):
member = self.find_member(group, self.get_user_id(user))
if not self.member_as_good_access_level(
group, member.id, self.ACCESS_LEVEL[access_level]):
member.access_level = self.ACCESS_LEVEL[access_level]
member.save()
return True
else:
try:
group.members.create({
'user_id':
self.get_user_id(user),
'access_level':
self.ACCESS_LEVEL[access_level]
})
except gitlab.exceptions.GitlabCreateError as e:
self._module.fail_json(
msg="Failed to assign user to group: %s" % to_native(e))
return True
return False
def exists_group(self, project_identifier):
# When group/user exists, object will be stored in self.group_object.
group = find_group(self._gitlab, project_identifier)
if group:
self.group_object = group
return True
return False
def main():
argument_spec = basic_auth_argument_spec()
argument_spec.update(
dict(
api_token=dict(type='str', no_log=True),
name=dict(type='str', required=True),
path=dict(type='str'),
description=dict(type='str'),
state=dict(type='str',
default="present",
choices=["absent", "present"]),
parent=dict(type='str'),
visibility=dict(type='str',
default="private",
choices=["internal", "private", "public"]),
project_creation_level=dict(
type='str', choices=['developer', 'maintainer', 'noone']),
auto_devops_enabled=dict(type='bool'),
subgroup_creation_level=dict(type='str',
choices=['maintainer', 'owner']),
require_two_factor_authentication=dict(type='bool'),
avatar_path=dict(type='path'),
))
module = AnsibleModule(
argument_spec=argument_spec,
mutually_exclusive=[
['api_username', 'api_token'],
['api_password', 'api_token'],
],
required_together=[
['api_username', 'api_password'],
],
required_one_of=[['api_username', 'api_token']],
supports_check_mode=True,
)
group_name = module.params['name']
group_path = module.params['path']
description = module.params['description']
state = module.params['state']
parent_identifier = module.params['parent']
group_visibility = module.params['visibility']
project_creation_level = module.params['project_creation_level']
auto_devops_enabled = module.params['auto_devops_enabled']
subgroup_creation_level = module.params['subgroup_creation_level']
require_two_factor_authentication = module.params[
'require_two_factor_authentication']
avatar_path = module.params['avatar_path']
if not HAS_GITLAB_PACKAGE:
module.fail_json(msg=missing_required_lib("python-gitlab"),
exception=GITLAB_IMP_ERR)
gitlab_instance = gitlab_authentication(module)
# Define default group_path based on group_name
if group_path is None:
group_path = group_name.replace(" ", "_")
gitlab_group = GitLabGroup(module, gitlab_instance)
parent_group = None
if parent_identifier:
parent_group = find_group(gitlab_instance, parent_identifier)
if not parent_group:
module.fail_json(
msg="Failed create GitLab group: Parent group doesn't exists")
group_exists = gitlab_group.exists_group(parent_group.full_path + '/' +
group_path)
else:
group_exists = gitlab_group.exists_group(group_path)
if state == 'absent':
if group_exists:
gitlab_group.delete_group()
module.exit_json(changed=True,
msg="Successfully deleted group %s" % group_name)
else:
module.exit_json(changed=False,
msg="Group deleted or does not exists")
if state == 'present':
if gitlab_group.create_or_update_group(
group_name, parent_group, {
"path": group_path,
"description": description,
"visibility": group_visibility,
"project_creation_level": project_creation_level,
"auto_devops_enabled": auto_devops_enabled,
"subgroup_creation_level": subgroup_creation_level,
"require_two_factor_authentication":
require_two_factor_authentication,
"avatar_path": avatar_path,
}):
module.exit_json(
changed=True,
msg="Successfully created or updated the group %s" %
group_name,
group=gitlab_group.group_object._attrs)
else:
module.exit_json(changed=False,
msg="No need to update the group %s" % group_name,
group=gitlab_group.group_object._attrs)
def main():
argument_spec = basic_auth_argument_spec()
argument_spec.update(auth_argument_spec())
argument_spec.update(
dict(
group=dict(type='str'),
name=dict(type='str', required=True),
path=dict(type='str'),
description=dict(type='str'),
initialize_with_readme=dict(type='bool', default=False),
default_branch=dict(type='str'),
issues_enabled=dict(type='bool', default=True),
merge_requests_enabled=dict(type='bool', default=True),
merge_method=dict(type='str',
default='merge',
choices=["merge", "rebase_merge", "ff"]),
wiki_enabled=dict(type='bool', default=True),
snippets_enabled=dict(default=True, type='bool'),
visibility=dict(type='str',
default="private",
choices=["internal", "private", "public"],
aliases=["visibility_level"]),
import_url=dict(type='str'),
state=dict(type='str',
default="present",
choices=["absent", "present"]),
lfs_enabled=dict(default=False, type='bool'),
username=dict(type='str'),
allow_merge_on_skipped_pipeline=dict(type='bool'),
only_allow_merge_if_all_discussions_are_resolved=dict(type='bool'),
only_allow_merge_if_pipeline_succeeds=dict(type='bool'),
packages_enabled=dict(type='bool'),
remove_source_branch_after_merge=dict(type='bool'),
squash_option=dict(
type='str',
choices=['never', 'always', 'default_off', 'default_on']),
ci_config_path=dict(type='str'),
shared_runners_enabled=dict(type='bool'),
avatar_path=dict(type='path'),
))
module = AnsibleModule(
argument_spec=argument_spec,
mutually_exclusive=[
['api_username', 'api_token'],
['api_username', 'api_oauth_token'],
['api_username', 'api_job_token'],
['api_token', 'api_oauth_token'],
['api_token', 'api_job_token'],
['group', 'username'],
],
required_together=[
['api_username', 'api_password'],
],
required_one_of=[[
'api_username', 'api_token', 'api_oauth_token', 'api_job_token'
]],
supports_check_mode=True,
)
group_identifier = module.params['group']
project_name = module.params['name']
project_path = module.params['path']
project_description = module.params['description']
initialize_with_readme = module.params['initialize_with_readme']
issues_enabled = module.params['issues_enabled']
merge_requests_enabled = module.params['merge_requests_enabled']
merge_method = module.params['merge_method']
wiki_enabled = module.params['wiki_enabled']
snippets_enabled = module.params['snippets_enabled']
visibility = module.params['visibility']
import_url = module.params['import_url']
state = module.params['state']
lfs_enabled = module.params['lfs_enabled']
username = module.params['username']
allow_merge_on_skipped_pipeline = module.params[
'allow_merge_on_skipped_pipeline']
only_allow_merge_if_all_discussions_are_resolved = module.params[
'only_allow_merge_if_all_discussions_are_resolved']
only_allow_merge_if_pipeline_succeeds = module.params[
'only_allow_merge_if_pipeline_succeeds']
packages_enabled = module.params['packages_enabled']
remove_source_branch_after_merge = module.params[
'remove_source_branch_after_merge']
squash_option = module.params['squash_option']
ci_config_path = module.params['ci_config_path']
shared_runners_enabled = module.params['shared_runners_enabled']
avatar_path = module.params['avatar_path']
default_branch = module.params['default_branch']
if default_branch and not initialize_with_readme:
module.fail_json(
msg=
"Param default_branch need param initialize_with_readme set to true"
)
if not HAS_GITLAB_PACKAGE:
module.fail_json(msg=missing_required_lib("python-gitlab"),
exception=GITLAB_IMP_ERR)
gitlab_instance = gitlab_authentication(module)
# Set project_path to project_name if it is empty.
if project_path is None:
project_path = project_name.replace(" ", "_")
gitlab_project = GitLabProject(module, gitlab_instance)
namespace = None
namespace_id = None
if group_identifier:
group = find_group(gitlab_instance, group_identifier)
if group is None:
module.fail_json(
msg="Failed to create project: group %s doesn't exists" %
group_identifier)
namespace_id = group.id
else:
if username:
namespace = gitlab_instance.namespaces.list(search=username)[0]
else:
namespace = gitlab_instance.namespaces.list(
search=gitlab_instance.user.username)[0]
namespace_id = namespace.id
if not namespace_id:
module.fail_json(
msg=
"Failed to find the namespace or group ID which is required to look up the namespace"
)
try:
namespace = gitlab_instance.namespaces.get(namespace_id)
except gitlab.exceptions.GitlabGetError as e:
module.fail_json(
msg="Failed to find the namespace for the given user: %s" %
to_native(e))
if not namespace:
module.fail_json(msg="Failed to find the namespace for the project")
project_exists = gitlab_project.exists_project(namespace, project_path)
if state == 'absent':
if project_exists:
gitlab_project.delete_project()
module.exit_json(changed=True,
msg="Successfully deleted project %s" %
project_name)
module.exit_json(changed=False,
msg="Project deleted or does not exists")
if state == 'present':
if gitlab_project.create_or_update_project(
project_name, namespace, {
"path": project_path,
"description": project_description,
"initialize_with_readme": initialize_with_readme,
"default_branch": default_branch,
"issues_enabled": issues_enabled,
"merge_requests_enabled": merge_requests_enabled,
"merge_method": merge_method,
"wiki_enabled": wiki_enabled,
"snippets_enabled": snippets_enabled,
"visibility": visibility,
"import_url": import_url,
"lfs_enabled": lfs_enabled,
"allow_merge_on_skipped_pipeline":
allow_merge_on_skipped_pipeline,
"only_allow_merge_if_all_discussions_are_resolved":
only_allow_merge_if_all_discussions_are_resolved,
"only_allow_merge_if_pipeline_succeeds":
only_allow_merge_if_pipeline_succeeds,
"packages_enabled": packages_enabled,
"remove_source_branch_after_merge":
remove_source_branch_after_merge,
"squash_option": squash_option,
"ci_config_path": ci_config_path,
"shared_runners_enabled": shared_runners_enabled,
"avatar_path": avatar_path,
}):
module.exit_json(
changed=True,
msg="Successfully created or updated the project %s" %
project_name,
project=gitlab_project.project_object._attrs)
module.exit_json(changed=False,
msg="No need to update the project %s" % project_name,
project=gitlab_project.project_object._attrs)