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 = 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.labels_post_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_system_robot(self, permission_list, duration, robot_name=None, robot_desc=None, expect_status_code=201, **kwargs): if robot_name is None: robot_name = base._random_name("robot") if robot_desc is None: robot_desc = base._random_name("robot_desc") robotAccountCreate = v2_swagger_client.RobotCreate( name=robot_name, description=robot_desc, duration=duration, level="system", disable=False, permissions=permission_list) print("robotAccountCreate:", robotAccountCreate) client = self._get_client(**kwargs) data = [] data, status_code, header = client.create_robot_with_http_info( robotAccountCreate) 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 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_scan_all_schedule(self, schedule_type, cron=None, expect_status_code=201, expect_response_body=None, **kwargs): client = self._get_client(**kwargs) scanschedule = swagger_client.AdminJobScheduleObj() scanschedule.type = schedule_type if cron is not None: scanschedule.cron = cron scan_all_schedule = swagger_client.AdminJobSchedule(scanschedule) try: _, status_code, header = client.system_scan_all_schedule_post_with_http_info( scan_all_schedule) except ApiException as e: if e.status == expect_status_code: if expect_response_body is not None and e.body.strip( ) != expect_response_body.strip(): raise Exception( r"Create Scan All schedule response body is not as expected {} actual status is {}." .format(expect_response_body.strip(), e.body.strip())) else: return e.reason, e.body else: raise Exception( r"Create Scan All schedule result is not as expected {} actual status is {}." .format(expect_status_code, e.status)) base._assert_status_code(expect_status_code, status_code) return base._get_id_from_header(header)
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 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 = self._get_client(**kwargs).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 create_gc_schedule(self, schedule_type, is_delete_untagged, cron = None, expect_status_code = 201, expect_response_body = None, **kwargs): client = self._get_client(**kwargs) gc_parameters = {'delete_untagged':is_delete_untagged} gc_schedule = swagger_client.AdminJobScheduleObj() gc_schedule.type = schedule_type if cron is not None: gc_schedule.cron = cron gc_job = swagger_client.AdminJobSchedule() gc_job.schedule = gc_schedule gc_job.parameters = gc_parameters try: _, status_code, header = client.system_gc_schedule_post_with_http_info(gc_job) except ApiException as e: if e.status == expect_status_code: if expect_response_body is not None and e.body.strip() != expect_response_body.strip(): raise Exception(r"Create GC schedule response body is not as expected {} actual status is {}.".format(expect_response_body.strip(), e.body.strip())) else: return e.reason, e.body else: raise Exception(r"Create GC schedule result is not as expected {} actual status is {}.".format(expect_status_code, e.status)) base._assert_status_code(expect_status_code, status_code) return base._get_id_from_header(header)
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.projects_post_with_http_info( swagger_client.ProjectReq(name, metadata)) except ApiException as e: if e.status == expect_status_code: if expect_response_body is not None and e.body.strip( ) != expect_response_body.strip(): raise Exception( r"Create project result body is not as expected {} actual status is {}." .format(expect_response_body.strip(), e.body.strip())) else: return e.reason, e.body else: raise Exception( r"Create project result is not as expected {} actual status is {}." .format(expect_status_code, e.status)) base._assert_status_code(expect_status_code, status_code) return base._get_id_from_header(header), name
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 create_user(self, name=None, email=None, user_password=None, realname=None, expect_status_code=201, **kwargs): if name is None: name = base._random_name("user") if realname is None: realname = base._random_name("realname") if email is None: email = '%s@%s.com' % (realname, "vmware") if user_password is None: user_password = "******" user_req = v2_swagger_client.UserCreationReq(username=name, email=email, password=user_password, realname=realname) try: _, status_code, header = self._get_client( **kwargs).create_user_with_http_info(user_req) except ApiException as e: base._assert_status_code(expect_status_code, e.status) else: base._assert_status_code(expect_status_code, status_code) return base._get_id_from_header(header), name
def add_project_members(self, project_id, user_id=None, member_role_id=None, _ldap_group_dn=None, expect_status_code=201, **kwargs): kwargs['api_type'] = 'member' projectMember = v2_swagger_client.ProjectMember() if user_id is not None: projectMember.member_user = {"user_id": int(user_id)} if member_role_id is None: projectMember.role_id = 1 else: projectMember.role_id = member_role_id if _ldap_group_dn is not None: projectMember.member_group = v2_swagger_client.UserGroup( ldap_group_dn=_ldap_group_dn) data = [] try: data, status_code, header = self._get_client( **kwargs).create_project_member_with_http_info( project_id, project_member=projectMember) except ApiException as e: base._assert_status_code(expect_status_code, e.status) else: base._assert_status_code(expect_status_code, status_code) return base._get_id_from_header(header)
def add_project_members(self, project_id, user_id=None, member_role_id=None, _ldap_group_dn=None, expect_status_code=201, **kwargs): kwargs['api_type'] = 'products' projectMember = swagger_client.ProjectMember() if user_id is not None: projectMember.member_user = {"user_id": int(user_id)} if member_role_id is None: projectMember.role_id = 1 else: projectMember.role_id = member_role_id if _ldap_group_dn is not None: projectMember.member_group = swagger_client.UserGroup( ldap_group_dn=_ldap_group_dn) client = self._get_client(**kwargs) data = [] data, status_code, header = client.projects_project_id_members_post_with_http_info( project_id, project_member=projectMember) base._assert_status_code(expect_status_code, status_code) return base._get_id_from_header(header)
def create_registry(self, url, registry_type="harbor", description="", credentialType="basic", access_key="admin", access_secret="Harbor12345", name=base._random_name("registry"), insecure=True, expect_status_code=201, **kwargs): client = self._get_client(**kwargs) registryCredential = v2_swagger_client.RegistryCredential( type=credentialType, access_key=access_key, access_secret=access_secret) registry = v2_swagger_client.Registry(name=name, url=url, description=description, type=registry_type, insecure=insecure, credential=registryCredential) print("registry:", registry) _, status_code, header = client.create_registry_with_http_info( registry) base._assert_status_code(expect_status_code, status_code) return base._get_id_from_header(header), _
def create_project(self, name=None, metadata={}, **kwargs): if name is None: name = base._random_name("project") client = self._get_client(**kwargs) _, _, header = client.projects_post_with_http_info( swagger_client.ProjectReq(name, metadata)) return base._get_id_from_header(header), name
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 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 create_user(self, name=None, email=None, user_password=None, realname=None, role_id=None, **kwargs): if name is None: name = base._random_name("user") if realname is None: realname = base._random_name("realname") if email is None: email = '%s@%s.com' % (realname, "vmware") if user_password is None: user_password = "******" if role_id is None: role_id = 0 client = self._get_client(**kwargs) user = swagger_client.User(username=name, email=email, password=user_password, realname=realname, role_id=role_id) _, status_code, header = client.users_post_with_http_info(user) base._assert_status_code(201, status_code) return base._get_id_from_header(header), name
def create_project_robot(self, project_name, expires_at, 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, **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.Permission( 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, expires_at=expires_at, level="project", permissions=permission_list) client = self._get_client(**kwargs) data = [] data, status_code, header = client.create_robot_with_http_info( robotAccountCreate) 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 add_project_robot_account(self, project_id, project_name, expires_at, 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, **kwargs): kwargs['api_type'] = 'products' 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 = [] resource_by_project_id = "/project/" + str(project_id) + "/repository" resource_helm_by_project_id = "/project/" + str( project_id) + "/helm-chart" resource_helm_create_by_project_id = "/project/" + str( project_id) + "/helm-chart-version" action_pull = "pull" action_push = "push" action_read = "read" action_create = "create" if has_pull_right is True: robotAccountAccess = swagger_client.RobotAccountAccess( resource=resource_by_project_id, action=action_pull) access_list.append(robotAccountAccess) if has_push_right is True: robotAccountAccess = swagger_client.RobotAccountAccess( resource=resource_by_project_id, action=action_push) access_list.append(robotAccountAccess) if has_chart_read_right is True: robotAccountAccess = swagger_client.RobotAccountAccess( resource=resource_helm_by_project_id, action=action_read) access_list.append(robotAccountAccess) if has_chart_create_right is True: robotAccountAccess = swagger_client.RobotAccountAccess( resource=resource_helm_create_by_project_id, action=action_create) access_list.append(robotAccountAccess) robotAccountCreate = swagger_client.RobotAccountCreate( robot_name, robot_desc, expires_at, access_list) client = self._get_client(**kwargs) data = [] data, status_code, header = client.projects_project_id_robots_post_with_http_info( project_id, robotAccountCreate) 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 add_project_members(self, project_id, user_id, member_role_id = None, expect_status_code = 201, **kwargs): if member_role_id is None: member_role_id = 1 _member_user = {"user_id": int(user_id)} projectMember = swagger_client.ProjectMember(member_role_id, member_user = _member_user) client = self._get_client(**kwargs) data = [] data, status_code, header = client.projects_project_id_members_post_with_http_info(project_id, project_member = projectMember) base._assert_status_code(expect_status_code, status_code) return base._get_id_from_header(header)
def create_project(self, name=None, metadata=None, **kwargs): if name is None: name = base._random_name("project") if metadata is None: metadata = {} client = self._get_client(**kwargs) _, status_code, header = client.projects_post_with_http_info( swagger_client.ProjectReq(name, metadata)) base._assert_status_code(201, status_code) project_id = base._get_id_from_header(header) return name, project_id
def create_replication_policy(self, dest_registry=None, src_registry=None, name=None, description="", dest_namespace = "", filters=None, trigger=v2_swagger_client.ReplicationTrigger(type="manual",trigger_settings=v2_swagger_client.ReplicationTriggerSettings(cron="")), deletion=False, override=True, enabled=True, expect_status_code = 201, **kwargs): if name is None: name = base._random_name("rule") if filters is None: filters = [] policy = v2_swagger_client.ReplicationPolicy(name=name, description=description,dest_namespace=dest_namespace, dest_registry=dest_registry, src_registry=src_registry,filters=filters, trigger=trigger, deletion=deletion, override=override, enabled=enabled) _, status_code, header = self._get_client(**kwargs).create_replication_policy_with_http_info(policy) base._assert_status_code(expect_status_code, status_code) return base._get_id_from_header(header), name
def create_registry(self, endpoint, name=base._random_name("registry"), username="", password="", insecure=True, **kwargs): client = self._get_client(**kwargs) registry = swagger_client.RepTargetPost(name=name, endpoint=endpoint, username=username, password=password, insecure=insecure) _, _, header = client.targets_post_with_http_info(registry) return base._get_id_from_header(header), name
def create_label(self, name=base._random_name("label"), desc="", color="", scope="g", project_id=0, **kwargs): label = swagger_client.Label(name=name, description=desc, color=color, scope=scope, project_id=project_id) client = self._get_client(**kwargs) _, _, header = client.labels_post_with_http_info(label) return base._get_id_from_header(header), name
def create_retention_policy(self, project_id, selector_repository="**", selector_tag="**", expect_status_code=201, **kwargs): policy = swagger_client.RetentionPolicy( algorithm='or', rules=[ swagger_client.RetentionRule(disabled=False, action="retain", template="always", params={}, scope_selectors={ "repository": [{ "kind": "doublestar", "decoration": "repoMatches", "pattern": selector_repository }] }, tag_selectors=[{ "kind": "doublestar", "decoration": "matches", "pattern": selector_tag }]) ], trigger={ "kind": "Schedule", "settings": { "cron": "" }, "references": {} }, scope={ "level": "project", "ref": project_id }, ) client = self._get_client(**kwargs) _, status_code, header = client.retentions_post_with_http_info(policy) base._assert_status_code(expect_status_code, status_code) return base._get_id_from_header(header)
def create_target(self, endpoint_target = None, username_target = "target_user", password_target = "Aa123456", name_target=base._random_name("target"), target_type=0, insecure_target=True, expect_status_code = 201, **kwargs): if endpoint_target is None: endpoint_target = r"https://{}.{}.{}.{}".format(int(round(time.time() * 1000)) % 100, int(round(time.time() * 1000)) % 200, int(round(time.time() * 1000)) % 100, int(round(time.time() * 1000)) % 254) client = self._get_client(**kwargs) policy = swagger_client.RepTarget(name=name_target, endpoint=endpoint_target, username=username_target, password=password_target, type=target_type, insecure=insecure_target) _, status_code, header = client.targets_post_with_http_info(policy) base._assert_status_code(expect_status_code, status_code) return base._get_id_from_header(header), name_target
def create_replication_rule(self, projectIDList, targetIDList, name=base._random_name("rule"), desc="", filters=[], trigger=swagger_client.RepTrigger(kind="Manual"), replicate_deletion=True, replicate_existing_image_now=False, **kwargs): projects = [] for projectID in projectIDList: projects.append(swagger_client.Project(project_id=int(projectID))) targets = [] for targetID in targetIDList: targets.append(swagger_client.RepTarget(id=int(targetID))) for filter in filters: filter["value"] = int(filter["value"]) client = self._get_client(**kwargs) policy = swagger_client.RepPolicy(name=name, description=desc, projects=projects, targets=targets, filters=filters, trigger=trigger, replicate_deletion=replicate_deletion, replicate_existing_image_now=replicate_existing_image_now) _, _, header = client.policies_replication_post_with_http_info(policy) return base._get_id_from_header(header), name
def create_user(self, name=None, email=None, password=None, realname=None, **kwargs): if name is None: name = base._random_name("user") if realname is None: realname = base._random_name("realname") if email is None: email = '%s@%s.com' % (realname, "vmware") if password is None: password = "******" client = self._get_client(**kwargs) user = swagger_client.User(None, name, email, password, realname, None, None, None, None, None, None, None, None, None) print user _, _, header = client.users_post_with_http_info(user) return base._get_id_from_header(header), name
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_gc_schedule(self, schedule_type, offtime = None, weekday = None, expect_status_code = 201, expect_response_body = None, **kwargs): client = self._get_client(**kwargs) gcscheduleschedule = swagger_client.GCScheduleSchedule() gcscheduleschedule.type = schedule_type if offtime is not None: gcscheduleschedule.offtime = offtime if weekday is not None: gcscheduleschedule.weekday = weekday gc_schedule = swagger_client.GCSchedule(gcscheduleschedule) try: _, status_code, header = client.system_gc_schedule_post_with_http_info(gc_schedule) except ApiException as e: if e.status == expect_status_code: if expect_response_body is not None and e.body.strip() != expect_response_body.strip(): raise Exception(r"Create GC schedule response body is not as expected {} actual status is {}.".format(expect_response_body.strip(), e.body.strip())) else: return e.reason, e.body else: raise Exception(r"Create GC schedule result is not as expected {} actual status is {}.".format(expect_status_code, e.status)) base._assert_status_code(expect_status_code, status_code) return base._get_id_from_header(header)