def set_configurations(client, expect_status_code = 200, expect_response_body = None, **config):
conf = {}
if "project_creation_restriction" in config and config.get("project_creation_restriction") is not None:
conf["project_creation_restriction"] = config.get("project_creation_restriction")
if "token_expiration" in config and config.get("token_expiration") is not None:
conf["token_expiration"] = config.get("token_expiration")
if "ldap_filter" in config and config.get("ldap_filter") is not None:
conf["ldap_filter"] = config.get("ldap_filter")
if "ldap_group_attribute_name" in config and config.get("ldap_group_attribute_name") is not None:
conf["ldap_group_attribute_name"] = config.get("ldap_group_attribute_name")
if "ldap_group_base_dn" in config:
conf["ldap_group_base_dn"] = config.get("ldap_group_base_dn")
if "ldap_group_search_filter" in config and config.get("ldap_group_search_filter") is not None:
conf["ldap_group_search_filter"] = config.get("ldap_group_search_filter")
if "ldap_group_search_scope" in config and config.get("ldap_group_search_scope") is not None:
conf["ldap_group_search_scope"] = config.get("ldap_group_search_scope")
if "ldap_group_admin_dn" in config and config.get("ldap_group_admin_dn") is not None:
conf["ldap_group_admin_dn"] = config.get("ldap_group_admin_dn")
try:
_, status_code, _ = client.update_configurations_with_http_info(conf)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
def retag_image(self,
repo_name,
tag,
src_image,
override=True,
expect_status_code=200,
expect_response_body=None,
**kwargs):
client = self._get_client(**kwargs)
request = swagger_client.RetagReq(tag=tag,
src_image=src_image,
override=override)
try:
data, status_code, _ = client.repositories_repo_name_tags_post_with_http_info(
repo_name, request)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
return data
def set_configurations(client, expect_status_code = 200, expect_response_body = None, **config):
conf = swagger_client.Configurations()
if "project_creation_restriction" in config:
conf.project_creation_restriction = config.get("project_creation_restriction")
if "token_expiration" in config:
conf.token_expiration = config.get("token_expiration")
if "ldap_filter" in config:
conf.ldap_filter = config.get("ldap_filter")
if "ldap_group_attribute_name" in config:
conf.ldap_group_attribute_name = config.get("ldap_group_attribute_name")
if "ldap_group_base_dn" in config:
conf.ldap_group_base_dn = config.get("ldap_group_base_dn")
if "ldap_group_search_filter" in config:
conf.ldap_group_search_filter = config.get("ldap_group_search_filter")
if "ldap_group_search_scope" in config:
conf.ldap_group_search_scope = config.get("ldap_group_search_scope")
try:
_, status_code, _ = client.configurations_put_with_http_info(conf)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
def update_tag_immutability_policy_rule(self, project_id, rule_id, selector_repository_decoration = None,
selector_repository=None, selector_tag_decoration = None,
selector_tag=None, disabled = None, expect_status_code = 200, **kwargs):
rule = self.get_rule( project_id, rule_id,**kwargs)
if selector_repository_decoration:
rule.scope_selectors["repository"][0].decoration = selector_repository_decoration
if selector_repository:
rule.scope_selectors["repository"][0].pattern = selector_repository
if selector_tag_decoration:
rule.tag_selectors[0].decoration = selector_tag_decoration
if selector_tag:
rule.tag_selectors[0].pattern = selector_tag
if disabled is not None:
rule.disabled = disabled
client = self._get_client(**kwargs)
try:
_, status_code, header = client.projects_project_id_immutabletagrules_id_put_with_http_info(project_id, rule_id, rule)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
else:
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
return base._get_id_from_header(header)
def create_policy(
self,
project_name,
project_id,
provider_id,
name=None,
description="It's a dragonfly policy",
filters=r'[{"type":"repository","value":"re*"},{"type":"tag","value":"v1.0*"}]',
trigger=r'{"type":"manual","trigger_setting":{"cron":""}}',
enabled=True,
expect_status_code=201,
expect_response_body=None,
**kwargs):
if name is None:
name = base._random_name("policy")
client = self._get_client(**kwargs)
policy = v2_swagger_client.PreheatPolicy(name=name,
project_id=project_id,
provider_id=provider_id,
description=description,
filters=filters,
trigger=trigger,
enabled=enabled)
print("policy:", policy)
try:
data, status_code, header = client.create_policy_with_http_info(
project_name, policy)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(201, status_code)
return base._get_id_from_header(header), name
def get_configurations(self,
item_name=None,
expect_status_code=200,
expect_response_body=None,
**kwargs):
client = self._get_client(**kwargs)
try:
data, status_code, _ = client.configurations_get_with_http_info()
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
if item_name is not None:
return {
'project_creation_restriction':
data.project_creation_restriction.value,
'token_expiration': data.token_expiration.value,
}.get(
item_name,
'Get Configutation Error: Item name {} is not exist'.format(
item_name))
return data
def create_instance(self,
name=None,
description="It's a dragonfly instance",
vendor="dragonfly",
endpoint_url="http://20.32.244.16",
auth_mode="NONE",
enabled=True,
insecure=True,
expect_status_code=201,
expect_response_body=None,
**kwargs):
if name is None:
name = base._random_name("instance")
client = self._get_client(**kwargs)
instance = v2_swagger_client.Instance(name=name,
description=description,
vendor=vendor,
endpoint=endpoint_url,
auth_mode=auth_mode,
enabled=enabled)
print("instance:", instance)
try:
_, status_code, header = client.create_instance_with_http_info(
instance)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(201, status_code)
return base._get_id_from_header(header), name
def update_webhook(self,
project_id,
webhook_policy_id,
event_types=None,
name=None,
desc=None,
enabled=None,
targets=None,
expect_status_code=200,
expect_response_body=None,
**kwargs):
policy = v2_swagger_client.WebhookPolicy()
if name is not None:
policy.name = name
if desc is not None:
policy.desc = desc
if enabled is not None:
policy.enabled = enabled
if targets is not None:
policy.targets = targets
if event_types is not None:
policy.event_types = event_types
try:
_, status_code, header = self._get_client(
**kwargs).update_webhook_policy_of_project_with_http_info(
project_id, webhook_policy_id, policy)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
def create_project(self,
name=None,
registry_id=None,
metadata=None,
expect_status_code=201,
expect_response_body=None,
**kwargs):
if name is None:
name = base._random_name("project")
if metadata is None:
metadata = {}
if registry_id is None:
registry_id = registry_id
project = v2_swagger_client.ProjectReq(project_name=name,
registry_id=registry_id,
metadata=metadata)
try:
_, status_code, header = self._get_client(
**kwargs).create_project_with_http_info(project)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(201, status_code)
return base._get_id_from_header(header), name
def delete_instance(self, preheat_instance_name, expect_status_code = 200, expect_response_body = None, **kwargs):
try:
_, status_code, header = _, status_code, _ = self._get_client(**kwargs).delete_instance_with_http_info(preheat_instance_name)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
else:
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
def stop_scan_artifact(self, project_name, repo_name, reference, expect_status_code = 202, expect_response_body = None, **kwargs):
try:
data, status_code, _ = self._get_client(**kwargs).stop_scan_artifact_with_http_info(project_name, repo_name, reference)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
return data
def delete_repository(self, project_name, repo_name, expect_status_code = 200, expect_response_body = None, **kwargs):
client = self._get_client(**kwargs)
try:
_, status_code, _ = client.delete_repository_with_http_info(project_name, repo_name)
except Exception as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
else:
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
def get_project(self, project_id, expect_status_code = 200, expect_response_body = None, **kwargs):
client = self._get_client(**kwargs)
try:
data, status_code, _ = client.get_project_with_http_info(project_id)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
return data
def copy_artifact(self, project_name, repo_name, _from, expect_status_code = 201, expect_response_body = None, **kwargs):
client = self._get_client(**kwargs)
try:
data, status_code, _ = client.copy_artifact_with_http_info(project_name, repo_name, _from)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(201, status_code)
return data
def get_project_member(self, project_id, member_id, expect_status_code = 200, expect_response_body = None, **kwargs):
from swagger_client.rest import ApiException
kwargs['api_type'] = 'member'
data = []
try:
data, status_code, _ = self._get_client(**kwargs).get_project_member_with_http_info(project_id, member_id,)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
return data
def create_project_robot(self, project_name, duration, robot_name = None, robot_desc = None,
has_pull_right = True, has_push_right = True, has_chart_read_right = True,
has_chart_create_right = True, expect_status_code = 201, expect_response_body = None,
**kwargs):
if robot_name is None:
robot_name = base._random_name("robot")
if robot_desc is None:
robot_desc = base._random_name("robot_desc")
if has_pull_right is False and has_push_right is False:
has_pull_right = True
access_list = []
action_pull = "pull"
action_push = "push"
action_read = "read"
action_create = "create"
if has_pull_right is True:
robotAccountAccess = v2_swagger_client.Access(resource = "repository", action = action_pull)
access_list.append(robotAccountAccess)
if has_push_right is True:
robotAccountAccess = v2_swagger_client.Access(resource = "repository", action = action_push)
access_list.append(robotAccountAccess)
if has_chart_read_right is True:
robotAccountAccess = v2_swagger_client.Access(resource = "helm-chart", action = action_read)
access_list.append(robotAccountAccess)
if has_chart_create_right is True:
robotAccountAccess = v2_swagger_client.Access(resource = "helm-chart-version", action = action_create)
access_list.append(robotAccountAccess)
robotaccountPermissions = v2_swagger_client.RobotPermission(kind = "project", namespace = project_name, access = access_list)
permission_list = []
permission_list.append(robotaccountPermissions)
robotAccountCreate = v2_swagger_client.RobotCreate(name=robot_name, description=robot_desc, duration=duration, level="project", permissions = permission_list)
client = self._get_client(**kwargs)
data = []
try:
data, status_code, header = client.create_robot_with_http_info(robotAccountCreate)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
else:
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(201, status_code)
return base._get_id_from_header(header), data
def delete_webhook(self,
project_id,
webhook_policy_id,
expect_status_code=200,
expect_response_body=None,
**kwargs):
try:
_, status_code, _ = self._get_client(
**kwargs).delete_webhook_policy_of_project_with_http_info(
project_id, webhook_policy_id)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
def delete_artifact(self,
project_name,
repo_name,
reference,
expect_status_code=200,
expect_response_body=None,
**kwargs):
try:
_, status_code, _ = self._get_client(
**kwargs).delete_artifact_with_http_info(
project_name, repo_name, reference)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
else:
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
def get_webhook(self,
project_id,
webhook_policy_id,
expect_status_code=200,
expect_response_body=None,
**kwargs):
try:
data, status_code, header = self._get_client(
**kwargs).get_webhook_policy_of_project_with_http_info(
project_id, webhook_policy_id)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
print("Webhooks:", data)
return data
def set_configurations(client,
expect_status_code=200,
expect_response_body=None,
**config):
conf = swagger_client.Configurations()
if "project_creation_restriction" in config:
conf.project_creation_restriction = config.get(
"project_creation_restriction")
if "token_expiration" in config:
conf.token_expiration = config.get("token_expiration")
try:
_, status_code, _ = client.configurations_put_with_http_info(conf)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
def create_webhook(self,
project_id,
targets,
event_types=[
"DELETE_ARTIFACT", "PULL_ARTIFACT", "PUSH_ARTIFACT",
"DELETE_CHART", "DOWNLOAD_CHART", "UPLOAD_CHART",
"QUOTA_EXCEED", "QUOTA_WARNING", "SCANNING_FAILED",
"TAG_RETENTION"
],
name=None,
desc=None,
enabled=True,
expect_status_code=201,
expect_response_body=None,
**kwargs):
if name is None:
name = base._random_name("webhook") + (str(project_id))
if desc is None:
desc = base._random_name("webhook desc") + (str(project_id))
policy = v2_swagger_client.WebhookPolicy(name=name,
description=desc,
project_id=project_id,
targets=targets,
event_types=event_types,
enabled=enabled)
try:
_, status_code, header = self._get_client(
**kwargs).create_webhook_policy_of_project_with_http_info(
project_id, policy)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
if expect_response_body is not None:
base._assert_status_body(expect_response_body, e.body)
return
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(201, status_code)
return base._get_id_from_header(header), name
