def get_project_member(self, project_id, member_id, expect_status_code = 200, expect_response_body = None, **kwargs):
client = self._get_client(**kwargs)
data = []
try:
data, status_code, _ = client.projects_project_id_members_mid_get_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 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 upload_chart(self,
repository,
chart,
prov=None,
expect_status_code=201,
**kwargs):
client = self._get_client(**kwargs)
try:
_, status_code, _ = client.chartrepo_repo_charts_post_with_http_info(
repository, chart)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
else:
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(201, 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 delete_repoitory(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)
return e.body
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
def delete_chart_with_version(self,
repository,
chart_name,
version,
expect_status_code=200,
**kwargs):
client = self._get_client(**kwargs)
try:
_, status_code, _ = client.chartrepo_repo_charts_name_version_delete_with_http_info(
repository, chart_name, version)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
else:
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
def delete_instance(self,
preheat_instance_name,
expect_status_code=200,
expect_response_body=None,
**kwargs):
client = self._get_client(**kwargs)
try:
_, status_code, header = _, status_code, _ = client.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 delete_tag(self,
project_name,
repo_name,
reference,
tag_name,
expect_status_code=200,
**kwargs):
try:
_, status_code, _ = self._get_client(
**kwargs).delete_tag_with_http_info(project_name, repo_name,
reference, tag_name)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
else:
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
def create_project(self, name=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 = {}
client = self._get_client(**kwargs)
try:
_, status_code, header = client.create_project_with_http_info(v2_swagger_client.ProjectReq(project_name=name, metadata=metadata))
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 create_label(self, name=None, desc="", color="", scope="g",
project_id=0, expect_status_code = 201, **kwargs):
if name is None:
name = base._random_name("label")
label = v2_swagger_client.Label(name=name,
description=desc, color=color,
scope=scope, project_id=project_id)
client = self._get_client(**kwargs)
try:
_, status_code, header = client.create_label_with_http_info(label)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
else:
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 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 add_label_to_reference(self,
project_name,
repo_name,
reference,
label_id,
expect_status_code=200,
**kwargs):
label = v2_swagger_client.Label(id=label_id)
try:
body, status_code, _ = self._get_client(
**kwargs).add_label_with_http_info(project_name, repo_name,
reference, label)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
else:
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(200, status_code)
return body
def get_project(self,
project_id,
expect_status_code=200,
expect_response_body=None,
**kwargs):
try:
data, status_code, _ = self._get_client(
**kwargs).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)
print("Project {} info: {}".format(project_id, data))
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")
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 = self._get_client(**kwargs).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 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 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")
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 = self._get_client(**kwargs).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_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 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.get_configurations_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_tag(self,
project_name,
repo_name,
reference,
tag_name,
expect_status_code=201,
ignore_conflict=False,
**kwargs):
tag = v2_swagger_client.Tag(name=tag_name)
try:
_, status_code, _ = self._get_client(
**kwargs).create_tag_with_http_info(project_name, repo_name,
reference, tag)
except ApiException as e:
if e.status == 409 and ignore_conflict == True:
return
base._assert_status_code(expect_status_code, e.status)
else:
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(201, 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
def create_tag_immutability_policy_rule(
self,
project_id,
selector_repository_decoration="repoMatches",
selector_repository="**",
selector_tag_decoration="matches",
selector_tag="**",
expect_status_code=201,
**kwargs):
#repoExcludes,excludes
client = self._get_client(**kwargs)
immutable_rule = v2_swagger_client.ImmutableRule(
action="immutable",
template="immutable_template",
priority=0,
scope_selectors={
"repository": [{
"kind": "doublestar",
"decoration": selector_repository_decoration,
"pattern": selector_repository
}]
},
tag_selectors=[{
"kind": "doublestar",
"decoration": selector_tag_decoration,
"pattern": selector_tag
}])
try:
_, status_code, header = client.create_immu_rule_with_http_info(
project_id, immutable_rule)
except ApiException as e:
base._assert_status_code(expect_status_code, e.status)
else:
base._assert_status_code(expect_status_code, status_code)
base._assert_status_code(201, status_code)
return base._get_id_from_header(header)
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
try:
_, status_code, header = self._get_client(**kwargs).update_immu_rule_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 scan_image(self, repo_name, tag, expect_status_code=202, **kwargs):
client = self._get_client(**kwargs)
data, status_code, _ = client.repositories_repo_name_tags_tag_scan_post_with_http_info(
repo_name, tag)
base._assert_status_code(expect_status_code, status_code)
return data
def get_repo_signatures(self, repo_name, expect_status_code=200, **kwargs):
client = self._get_client(**kwargs)
data, status_code, _ = client.repositories_repo_name_signatures_get_with_http_info(
repo_name)
base._assert_status_code(expect_status_code, status_code)
return data
def get_repository(self, project_id, **kwargs):
client = self._get_client(**kwargs)
data, status_code, _ = client.repositories_get_with_http_info(
project_id)
base._assert_status_code(200, status_code)
return data
def delete_repoitory(self, repo_name, **kwargs):
client = self._get_client(**kwargs)
_, status_code, _ = client.repositories_repo_name_delete_with_http_info(
repo_name)
base._assert_status_code(200, status_code)
def get_projects(self, params, **kwargs):
client = self._get_client(**kwargs)
data = []
data, status_code, _ = client.projects_get_with_http_info(**params)
base._assert_status_code(200, status_code)
return data
def get_project_log(self, project_id, expect_status_code=200, **kwargs):
client = self._get_client(**kwargs)
body, status_code, _ = client.projects_project_id_logs_get_with_http_info(
project_id)
base._assert_status_code(expect_status_code, status_code)
return body
