| | |
| | import logging |
| |
|
| | from requests.exceptions import HTTPError |
| |
|
| | from .rest_client import AtlassianRestAPI |
| |
|
| | log = logging.getLogger(__name__) |
| |
|
| |
|
| | class Bamboo(AtlassianRestAPI): |
| | """ Private methods """ |
| |
|
| | def _get_generator( |
| | self, |
| | path, |
| | elements_key="results", |
| | element_key="result", |
| | data=None, |
| | flags=None, |
| | params=None, |
| | headers=None, |
| | max_results=None, |
| | ): |
| | """ |
| | Generic method to return a generator with the results returned from Bamboo. It is intended to work for |
| | responses in the form: |
| | { |
| | 'results': |
| | { |
| | 'size': 5, |
| | 'start-index': 0, |
| | 'max-result': 5, |
| | 'result': [] |
| | }, |
| | ... |
| | } |
| | In this case we would have elements_key='results' element_key='result'. |
| | The only reason to use this generator is to abstract dealing with response pagination from the client |
| | |
| | :param path: URI for the resource |
| | :return: generator with the contents of response[elements_key][element_key] |
| | """ |
| | start_index = 0 |
| | params["start-index"] = start_index |
| | response = self.get(path, data, flags, params, headers) |
| | if self.advanced_mode: |
| | try: |
| | response.raise_for_status() |
| | response = response.json() |
| | except HTTPError as e: |
| | logging.error("Broken response: {}".format(e)) |
| | yield e |
| | try: |
| | results = response[elements_key] |
| | size = 0 |
| | |
| | if size > max_results or results["size"] == 0: |
| | return |
| | for r in results[element_key]: |
| | size += 1 |
| | yield r |
| | start_index += results["max-result"] |
| | except TypeError: |
| | logging.error("Broken response: {}".format(response)) |
| | yield response |
| |
|
| | def base_list_call( |
| | self, resource, expand, favourite, clover_enabled, max_results, label=None, start_index=0, **kwargs |
| | ): |
| | flags = [] |
| | params = {"max-results": max_results} |
| | if expand: |
| | params["expand"] = expand |
| | if favourite: |
| | flags.append("favourite") |
| | if clover_enabled: |
| | flags.append("cloverEnabled") |
| | if label: |
| | params["label"] = label |
| | params.update(kwargs) |
| | if "elements_key" in kwargs and "element_key" in kwargs: |
| | return self._get_generator( |
| | self.resource_url(resource), |
| | flags=flags, |
| | params=params, |
| | elements_key=kwargs["elements_key"], |
| | element_key=kwargs["element_key"], |
| | max_results=max_results, |
| | ) |
| | params["start-index"] = start_index |
| | return self.get(self.resource_url(resource), flags=flags, params=params) |
| |
|
| | """ Projects & Plans """ |
| |
|
| | def projects(self, expand=None, favourite=False, clover_enabled=False, max_results=25): |
| | return self.base_list_call( |
| | "project", |
| | expand=expand, |
| | favourite=favourite, |
| | clover_enabled=clover_enabled, |
| | max_results=max_results, |
| | elements_key="projects", |
| | element_key="project", |
| | ) |
| |
|
| | def project(self, project_key, expand=None, favourite=False, clover_enabled=False): |
| | resource = "project/{}".format(project_key) |
| | return self.base_list_call( |
| | resource=resource, |
| | expand=expand, |
| | favourite=favourite, |
| | clover_enabled=clover_enabled, |
| | start_index=0, |
| | max_results=25, |
| | ) |
| |
|
| | def project_plans(self, project_key, start_index=0, max_results=25): |
| | """ |
| | Returns a generator with the plans in a given project |
| | :param project_key: Project key |
| | :param start_index: |
| | :param max_results: |
| | :return: Generator with plans |
| | """ |
| | resource = "project/{}".format(project_key) |
| | return self.base_list_call( |
| | resource, |
| | expand="plans", |
| | favourite=False, |
| | clover_enabled=False, |
| | start_index=start_index, |
| | max_results=max_results, |
| | elements_key="plans", |
| | element_key="plan", |
| | ) |
| |
|
| | def plans( |
| | self, |
| | expand=None, |
| | favourite=False, |
| | clover_enabled=False, |
| | start_index=0, |
| | max_results=25, |
| | ): |
| | return self.base_list_call( |
| | "plan", |
| | expand=expand, |
| | favourite=favourite, |
| | clover_enabled=clover_enabled, |
| | start_index=start_index, |
| | max_results=max_results, |
| | elements_key="plans", |
| | element_key="plan", |
| | ) |
| |
|
| | def plan_directory_info(self, plan_key): |
| | """ |
| | Returns information about the directories where artifacts, build logs, and build results will be stored. |
| | Disabled by default. |
| | See https://confluence.atlassian.com/display/BAMBOO/Plan+directory+information+REST+API for more information. |
| | :param plan_key: |
| | :return: |
| | """ |
| | resource = "planDirectoryInfo/{}".format(plan_key) |
| | return self.get(self.resource_url(resource)) |
| |
|
| | def get_plan(self, plan_key, expand=None): |
| | """ |
| | Get plan information. |
| | :param plan_key: |
| | :param expand: optional |
| | :return: |
| | """ |
| | params = {} |
| | if expand: |
| | params["expand"] = expand |
| | resource = "rest/api/latest/plan/{}".format(plan_key) |
| | return self.get(resource, params=params) |
| |
|
| | def delete_plan(self, plan_key): |
| | """ |
| | Marks plan for deletion. Plan will be deleted by a batch job. |
| | :param plan_key: |
| | :return: |
| | """ |
| | resource = "rest/api/latest/plan/{}".format(plan_key) |
| | return self.delete(resource) |
| |
|
| | def disable_plan(self, plan_key): |
| | """ |
| | Disable plan. |
| | :param plan_key: str TST-BLD |
| | :return: DELETE request |
| | """ |
| | resource = "plan/{plan_key}/enable".format(plan_key=plan_key) |
| | return self.delete(self.resource_url(resource)) |
| |
|
| | def enable_plan(self, plan_key): |
| | """ |
| | Enable plan. |
| | :param plan_key: str TST-BLD |
| | :return: POST request |
| | """ |
| | resource = "plan/{plan_key}/enable".format(plan_key=plan_key) |
| | return self.post(self.resource_url(resource)) |
| |
|
| | """ Branches """ |
| |
|
| | def search_branches(self, plan_key, include_default_branch=True, max_results=25, start=0): |
| | params = { |
| | "max-result": max_results, |
| | "start-index": start, |
| | "masterPlanKey": plan_key, |
| | "includeMasterBranch": include_default_branch, |
| | } |
| | size = 1 |
| | while params["start-index"] < size: |
| | results = self.get(self.resource_url("search/branches"), params=params) |
| | size = results["size"] |
| | for r in results["searchResults"]: |
| | yield r |
| | params["start-index"] += results["max-result"] |
| |
|
| | def plan_branches( |
| | self, |
| | plan_key, |
| | expand=None, |
| | favourite=False, |
| | clover_enabled=False, |
| | max_results=25, |
| | ): |
| | """api/1.0/plan/{projectKey}-{buildKey}/branch""" |
| | resource = "plan/{}/branch".format(plan_key) |
| | return self.base_list_call( |
| | resource, |
| | expand, |
| | favourite, |
| | clover_enabled, |
| | max_results, |
| | elements_key="branches", |
| | element_key="branch", |
| | ) |
| |
|
| | def get_branch_info(self, plan_key, branch_name): |
| | """ |
| | Get information about a plan branch |
| | :param plan_key: |
| | :param branch_name: |
| | :return: |
| | """ |
| | resource = "plan/{plan_key}/branch/{branch_name}".format(plan_key=plan_key, branch_name=branch_name) |
| | return self.get(self.resource_url(resource)) |
| |
|
| | def create_branch( |
| | self, |
| | plan_key, |
| | branch_name, |
| | vcs_branch=None, |
| | enabled=False, |
| | cleanup_enabled=False, |
| | ): |
| | """ |
| | Method for creating branch for a specified plan. |
| | You can use vcsBranch query param to define which vcsBranch should newly created branch use. |
| | If not specified it will not override vcsBranch from the main plan. |
| | |
| | :param plan_key: str TST-BLD |
| | :param branch_name: str new-shiny-branch |
| | :param vcs_branch: str feature/new-shiny-branch, /refs/heads/new-shiny-branch |
| | :param enabled: bool |
| | :param cleanup_enabled: bool |
| | :return: PUT request |
| | """ |
| | resource = "plan/{plan_key}/branch/{branch_name}".format(plan_key=plan_key, branch_name=branch_name) |
| | params = {} |
| | if vcs_branch: |
| | params = dict( |
| | vcsBranch=vcs_branch, |
| | enabled="true" if enabled else "false", |
| | cleanupEnabled="true" if cleanup_enabled else "false", |
| | ) |
| | return self.put(self.resource_url(resource), params=params) |
| |
|
| | def get_vcs_branches(self, plan_key, max_results=25): |
| | """ |
| | Get all vcs names for the current plan |
| | :param plan_key: str TST-BLD |
| | :param max_results |
| | :return: |
| | """ |
| | resource = "plan/{plan_key}/vcsBranches".format(plan_key=plan_key) |
| | return self.base_list_call( |
| | resource, |
| | start_index=0, |
| | max_results=max_results, |
| | clover_enabled=None, |
| | expand=None, |
| | favourite=None, |
| | ) |
| |
|
| | """ Build results """ |
| |
|
| | def results( |
| | self, |
| | project_key=None, |
| | plan_key=None, |
| | job_key=None, |
| | build_number=None, |
| | expand=None, |
| | favourite=False, |
| | clover_enabled=False, |
| | issue_key=None, |
| | label=None, |
| | start_index=0, |
| | max_results=25, |
| | include_all_states=False, |
| | ): |
| | """ |
| | Get results as generic method |
| | :param project_key: |
| | :param plan_key: |
| | :param job_key: |
| | :param build_number: |
| | :param expand: |
| | :param favourite: |
| | :param clover_enabled: |
| | :param issue_key: |
| | :param label: |
| | :param start_index: |
| | :param max_results: |
| | :param include_all_states: |
| | :return: |
| | """ |
| | resource = "result" |
| | if project_key and plan_key and job_key and build_number: |
| | resource += "/{}-{}-{}/{}".format(project_key, plan_key, job_key, build_number) |
| | elif project_key and plan_key and build_number: |
| | resource += "/{}-{}/{}".format(project_key, plan_key, build_number) |
| | elif project_key and plan_key: |
| | resource += "/{}-{}".format(project_key, plan_key) |
| | elif project_key: |
| | resource += "/" + project_key |
| |
|
| | params = {} |
| | if issue_key: |
| | params["issueKey"] = issue_key |
| | if include_all_states: |
| | params["includeAllStates"] = include_all_states |
| | return self.base_list_call( |
| | resource, |
| | expand=expand, |
| | favourite=favourite, |
| | clover_enabled=clover_enabled, |
| | start_index=start_index, |
| | max_results=max_results, |
| | elements_key="results", |
| | element_key="result", |
| | label=label, |
| | **params |
| | ) |
| |
|
| | def latest_results( |
| | self, |
| | expand=None, |
| | favourite=False, |
| | clover_enabled=False, |
| | label=None, |
| | issue_key=None, |
| | start_index=0, |
| | max_results=25, |
| | include_all_states=False, |
| | ): |
| | """ |
| | Get latest Results |
| | :param expand: |
| | :param favourite: |
| | :param clover_enabled: |
| | :param label: |
| | :param issue_key: |
| | :param start_index: |
| | :param max_results: |
| | :param include_all_states: |
| | :return: |
| | """ |
| | return self.results( |
| | expand=expand, |
| | favourite=favourite, |
| | clover_enabled=clover_enabled, |
| | label=label, |
| | issue_key=issue_key, |
| | start_index=start_index, |
| | max_results=max_results, |
| | include_all_states=include_all_states, |
| | ) |
| |
|
| | def project_latest_results( |
| | self, |
| | project_key, |
| | expand=None, |
| | favourite=False, |
| | clover_enabled=False, |
| | label=None, |
| | issue_key=None, |
| | start_index=0, |
| | max_results=25, |
| | include_all_states=False, |
| | ): |
| | """ |
| | Get latest Project Results |
| | :param project_key: |
| | :param expand: |
| | :param favourite: |
| | :param clover_enabled: |
| | :param label: |
| | :param issue_key: |
| | :param start_index: |
| | :param max_results: |
| | :param include_all_states: |
| | :return: |
| | """ |
| | return self.results( |
| | project_key, |
| | expand=expand, |
| | favourite=favourite, |
| | clover_enabled=clover_enabled, |
| | label=label, |
| | issue_key=issue_key, |
| | start_index=start_index, |
| | max_results=max_results, |
| | include_all_states=include_all_states, |
| | ) |
| |
|
| | def plan_results( |
| | self, |
| | project_key, |
| | plan_key, |
| | expand=None, |
| | favourite=False, |
| | clover_enabled=False, |
| | label=None, |
| | issue_key=None, |
| | start_index=0, |
| | max_results=25, |
| | include_all_states=False, |
| | ): |
| | """ |
| | Get Plan results |
| | :param project_key: |
| | :param plan_key: |
| | :param expand: |
| | :param favourite: |
| | :param clover_enabled: |
| | :param label: |
| | :param issue_key: |
| | :param start_index: |
| | :param max_results: |
| | :param include_all_states: |
| | :return: |
| | """ |
| | return self.results( |
| | project_key, |
| | plan_key, |
| | expand=expand, |
| | favourite=favourite, |
| | clover_enabled=clover_enabled, |
| | label=label, |
| | issue_key=issue_key, |
| | start_index=start_index, |
| | max_results=max_results, |
| | include_all_states=include_all_states, |
| | ) |
| |
|
| | def build_result(self, build_key, expand=None, include_all_states=False, start=0, max_results=25): |
| | """ |
| | Returns details of a specific build result |
| | :param expand: expands build result details on request. Possible values are: artifacts, comments, labels, |
| | Jira Issues, stages. stages expand is available only for top level plans. It allows to drill down to job results |
| | using stages.stage.results.result. All expand parameters should contain results.result prefix. |
| | :param build_key: Should be in the form XX-YY[-ZZ]-99, that is, the last token should be an integer representing |
| | the build number |
| | :param include_all_states |
| | :param start: |
| | :param max_results: |
| | """ |
| | try: |
| | int(build_key.split("-")[-1]) |
| | resource = "result/{}".format(build_key) |
| | return self.base_list_call( |
| | resource, |
| | expand, |
| | favourite=False, |
| | clover_enabled=False, |
| | start_index=start, |
| | max_results=max_results, |
| | include_all_states=include_all_states, |
| | ) |
| | except ValueError: |
| | raise ValueError('The key "{}" does not correspond to a build result'.format(build_key)) |
| |
|
| | def build_latest_result(self, plan_key, expand=None, include_all_states=False): |
| | """ |
| | Returns details of a latest build result |
| | :param expand: expands build result details on request. Possible values are: artifacts, comments, labels, |
| | Jira Issues, stages. stages expand is available only for top level plans. It allows to drill down to job results |
| | using stages.stage.results.result. All expand parameters should contain results.result prefix. |
| | :param plan_key: Should be in the form XX-YY[-ZZ] |
| | :param include_all_states: |
| | """ |
| | try: |
| | resource = "result/{}/latest.json".format(plan_key) |
| | return self.base_list_call( |
| | resource, |
| | expand, |
| | favourite=False, |
| | clover_enabled=False, |
| | start_index=0, |
| | max_results=25, |
| | include_all_states=include_all_states, |
| | ) |
| | except ValueError: |
| | raise ValueError('The key "{}" does not correspond to the latest build result'.format(plan_key)) |
| |
|
| | def delete_build_result(self, build_key): |
| | """ |
| | Deleting result for specific build |
| | :param build_key: Take full build key, example: PROJECT-PLAN-8 |
| | """ |
| | custom_resource = "/build/admin/deletePlanResults.action" |
| | build_key = build_key.split("-") |
| | plan_key = "{}-{}".format(build_key[0], build_key[1]) |
| | build_number = build_key[2] |
| | params = {"buildKey": plan_key, "buildNumber": build_number} |
| | return self.post(custom_resource, params=params, headers=self.form_token_headers) |
| |
|
| | def execute_build(self, plan_key, stage=None, execute_all_stages=True, custom_revision=None, **bamboo_variables): |
| | """ |
| | Fire build execution for specified plan. |
| | !IMPORTANT! NOTE: for some reason, this method always execute all stages |
| | :param plan_key: str TST-BLD |
| | :param stage: str stage-name |
| | :param execute_all_stages: bool |
| | :param custom_revision: str revisionName |
| | :param bamboo_variables: dict {variable=value} |
| | :return: POST request |
| | """ |
| | resource = "queue/{plan_key}".format(plan_key=plan_key) |
| | params = {} |
| | if stage: |
| | execute_all_stages = False |
| | params["stage"] = stage |
| | if custom_revision: |
| | params["customRevision"] = custom_revision |
| | params["executeAllStages"] = "true" if execute_all_stages else "false" |
| | if bamboo_variables: |
| | for key, value in bamboo_variables.items(): |
| | params["bamboo.variable.{}".format(key)] = value |
| |
|
| | return self.post(self.resource_url(resource), params=params) |
| |
|
| | def stop_build(self, plan_key): |
| | """ |
| | Stop the build which is in progress at the moment. |
| | :param plan_key: str TST-BLD |
| | :return: GET request |
| | """ |
| | resource = "/build/admin/stopPlan.action?planKey={}".format(plan_key) |
| | return self.post(path=resource, headers=self.no_check_headers) |
| |
|
| | """ Comments & Labels """ |
| |
|
| | def comments(self, project_key, plan_key, build_number, start_index=0, max_results=25): |
| | resource = "result/{}-{}-{}/comment".format(project_key, plan_key, build_number) |
| | params = {"start-index": start_index, "max-results": max_results} |
| | return self.get(self.resource_url(resource), params=params) |
| |
|
| | def create_comment(self, project_key, plan_key, build_number, comment, author=None): |
| | resource = "result/{}-{}-{}/comment".format(project_key, plan_key, build_number) |
| | comment_data = { |
| | "author": author if author else self.username, |
| | "content": comment, |
| | } |
| | return self.post(self.resource_url(resource), data=comment_data) |
| |
|
| | def labels(self, project_key, plan_key, build_number, start_index=0, max_results=25): |
| | resource = "result/{}-{}-{}/label".format(project_key, plan_key, build_number) |
| | params = {"start-index": start_index, "max-results": max_results} |
| | return self.get(self.resource_url(resource), params=params) |
| |
|
| | def create_label(self, project_key, plan_key, build_number, label): |
| | resource = "result/{}-{}-{}/label".format(project_key, plan_key, build_number) |
| | return self.post(self.resource_url(resource), data={"name": label}) |
| |
|
| | def delete_label(self, project_key, plan_key, build_number, label): |
| | resource = "result/{}-{}-{}/label/{}".format(project_key, plan_key, build_number, label) |
| | return self.delete(self.resource_url(resource)) |
| |
|
| | def get_projects(self): |
| | """Method used to list all projects defined in Bamboo. |
| | Projects without any plan are not listed by default, unless showEmpty query param is set to true.""" |
| | resource = "project?showEmpty" |
| | for project in self.get(self.resource_url(resource)): |
| | yield project |
| |
|
| | def get_project(self, project_key): |
| | """Method used to retrieve information for project specified as project key. |
| | Possible expand parameters: plans, list of plans for project. plans.plan, list of plans with plan details |
| | (only plans visible - READ permission for user)""" |
| | resource = "project/{}?showEmpty".format(project_key) |
| | return self.get(self.resource_url(resource)) |
| |
|
| | def delete_project(self, project_key): |
| | """Marks project for deletion. Project will be deleted by a batch job.""" |
| | resource = "project/{}".format(project_key) |
| | return self.delete(self.resource_url(resource)) |
| |
|
| | """ Deployments """ |
| |
|
| | def deployment_projects(self): |
| | resource = "deploy/project/all" |
| | for project in self.get(self.resource_url(resource)): |
| | yield project |
| |
|
| | def deployment_project(self, project_id): |
| | resource = "deploy/project/{}".format(project_id) |
| | return self.get(self.resource_url(resource)) |
| |
|
| | def deployment_environment_results(self, env_id, expand=None, max_results=25): |
| | resource = "deploy/environment/{environmentId}/results".format(environmentId=env_id) |
| | params = {"max-result": max_results, "start-index": 0} |
| | size = 1 |
| | if expand: |
| | params["expand"] = expand |
| | while params["start-index"] < size: |
| | results = self.get(self.resource_url(resource), params=params) |
| | size = results["size"] |
| | for r in results["results"]: |
| | yield r |
| | params["start-index"] += results["max-result"] |
| |
|
| | def deployment_dashboard(self, project_id=None): |
| | """ |
| | Returns the current status of each deployment environment |
| | If no project id is provided, returns all projects. |
| | """ |
| | resource = "deploy/dashboard/{}".format(project_id) if project_id else "deploy/dashboard" |
| | return self.get(self.resource_url(resource)) |
| |
|
| | """ Users & Groups """ |
| |
|
| | def get_users_in_global_permissions(self, start=0, limit=25): |
| | """ |
| | Provide users in global permissions configuration |
| | :param start: |
| | :param limit: |
| | :return: |
| | """ |
| | params = {"limit": limit, "start": start} |
| | url = "rest/api/latest/permissions/global/users" |
| | return self.get(url, params=params) |
| |
|
| | def get_groups(self, start=0, limit=25): |
| | """ |
| | Retrieve a paginated list of groups. |
| | The authenticated user must have restricted administrative permission or higher to use this resource. |
| | :param start: |
| | :param limit: |
| | :return: |
| | """ |
| | params = {"limit": limit, "start": start} |
| | url = "rest/api/latest/admin/groups" |
| | return self.get(url, params=params) |
| |
|
| | def create_group(self, group_name): |
| | """ |
| | Create a new group. |
| | The authenticated user must have restricted administrative permission or higher to use this resource. |
| | :param group_name: |
| | :return: |
| | """ |
| | url = "rest/api/latest/admin/groups" |
| | data = {"name": group_name} |
| | return self.post(url, data=data) |
| |
|
| | def delete_group(self, group_name): |
| | """ |
| | Deletes the specified group, removing it from the system. |
| | The authenticated user must have restricted administrative permission or higher to use this resource. |
| | :param group_name: |
| | :return: |
| | """ |
| | url = "rest/api/latest/admin/groups/{}".format(group_name) |
| | return self.delete(url) |
| |
|
| | def add_users_into_group(self, group_name, users): |
| | """ |
| | Add multiple users to a group. |
| | The list of usernames should be passed as request body. |
| | The authenticated user must have restricted administrative permission or higher to use this resource. |
| | :param group_name: |
| | :param users: list |
| | :return: |
| | """ |
| | url = "rest/api/latest/admin/groups/{}/add-users".format(group_name) |
| | return self.post(url, data=users) |
| |
|
| | def remove_users_from_group(self, group_name, users): |
| | """ |
| | Remove multiple users from a group. |
| | The list of usernames should be passed as request body. |
| | The authenticated user must have restricted administrative permission or higher to use this resource. |
| | :param group_name: |
| | :param users: list |
| | :return: |
| | """ |
| | url = "rest/api/latest/admin/groups/{}/remove-users".format(group_name) |
| | return self.delete(url, data=users) |
| |
|
| | def get_users_from_group(self, group_name, filter_users=None, start=0, limit=25): |
| | """ |
| | Retrieves a list of users that are members of a specified group. |
| | The authenticated user must have restricted administrative permission or higher to use this resource. |
| | :param filter_users: |
| | :param group_name: |
| | :param start: |
| | :param limit: |
| | :return: |
| | """ |
| | params = {"limit": limit, "start": start} |
| | if filter_users: |
| | params = {"filter": filter_users} |
| | url = "rest/api/latest/admin/groups/{}/more-members".format(group_name) |
| | return self.get(url, params=params) |
| |
|
| | def get_users_not_in_group(self, group_name, filter_users="", start=0, limit=25): |
| | """ |
| | Retrieves a list of users that are not members of a specified group. |
| | The authenticated user must have restricted administrative permission or higher to use this resource. |
| | :param filter_users: |
| | :param group_name: |
| | :param start: |
| | :param limit: |
| | :return: |
| | """ |
| | params = {"limit": limit, "start": start} |
| | if filter_users: |
| | params = {"filter": filter_users} |
| |
|
| | url = "rest/api/latest/admin/groups/{}/more-non-members".format(group_name) |
| | return self.get(url, params=params) |
| |
|
| | def get_build_queue(self, expand="queuedBuilds"): |
| | """ |
| | Lists all the builds waiting in the build queue, adds or removes a build from the build queue. |
| | May be used also to resume build on manual stage or rerun failed jobs. |
| | :return: |
| | """ |
| | params = {"expand": expand} |
| | return self.get("rest/api/latest/queue", params=params) |
| |
|
| | def get_deployment_users(self, deployment_id, filter_name=None, start=0, limit=25): |
| | """ |
| | Retrieve a list of users with their explicit permissions to given resource. |
| | The list can be filtered by some attributes. |
| | This resource is paged and returns a single page of results. |
| | :param deployment_id: |
| | :param filter_name: |
| | :param start: |
| | :param limit: |
| | :return: |
| | """ |
| | params = {"limit": limit, "start": start} |
| | if filter_name: |
| | params = {"name": filter_name} |
| | resource = "permissions/deployment/{}/users".format(deployment_id) |
| | return self.get(self.resource_url(resource), params=params) |
| |
|
| | def revoke_user_from_deployment(self, deployment_id, user, permissions=["READ", "WRITE", "BUILD"]): |
| | """ |
| | Revokes deployment project permissions from a given user. |
| | :param deployment_id: |
| | :param user: |
| | :param permissions: |
| | :return: |
| | """ |
| | resource = "permissions/deployment/{}/users/{}".format(deployment_id, user) |
| | return self.delete(self.resource_url(resource), data=permissions) |
| |
|
| | def grant_user_to_deployment(self, deployment_id, user, permissions): |
| | """ |
| | Grants deployment project permissions to a given user. |
| | :param deployment_id: |
| | :param user: |
| | :param permissions: |
| | :return: |
| | """ |
| | resource = "permissions/deployment/{}/users/{}".format(deployment_id, user) |
| | return self.put(self.resource_url(resource), data=permissions) |
| |
|
| | def get_deployment_groups(self, deployment_id, filter_name=None, start=0, limit=25): |
| | """ |
| | Retrieve a list of groups with their deployment project permissions. |
| | The list can be filtered by some attributes. |
| | This resource is paged returns a single page of results. |
| | :param deployment_id: |
| | :param filter_name: |
| | :param start: |
| | :param limit: |
| | :return: |
| | """ |
| | params = {"limit": limit, "start": start} |
| | if filter_name: |
| | params = {"name": filter_name} |
| | resource = "permissions/deployment/{}/groups".format(deployment_id) |
| | return self.get(self.resource_url(resource), params=params) |
| |
|
| | def revoke_group_from_deployment(self, deployment_id, group, permissions=["READ", "WRITE", "BUILD"]): |
| | """ |
| | Revokes deployment project permissions from a given group. |
| | :param deployment_id: |
| | :param group: |
| | :param permissions: |
| | :return: |
| | """ |
| | resource = "permissions/deployment/{}/groups/{}".format(deployment_id, group) |
| | return self.delete(self.resource_url(resource), data=permissions) |
| |
|
| | def grant_group_to_deployment(self, deployment_id, group, permissions): |
| | """ |
| | Grants deployment project permissions to a given group. |
| | :param deployment_id: |
| | :param group: |
| | :param permissions: |
| | :return: |
| | """ |
| | resource = "permissions/deployment/{}/groups/{}".format(deployment_id, group) |
| | return self.put(self.resource_url(resource), data=permissions) |
| |
|
| | def get_environment_users(self, environment_id, filter_name=None, start=0, limit=25): |
| | """ |
| | Retrieve a list of users with their explicit permissions to given resource. |
| | The list can be filtered by some attributes. |
| | This resource is paged and returns a single page of results. |
| | :param environment_id: |
| | :param filter_name: |
| | :param start: |
| | :param limit: |
| | :return: |
| | """ |
| | params = {"limit": limit, "start": start} |
| | if filter_name: |
| | params = {"name": filter_name} |
| | resource = "permissions/environment/{}/users".format(environment_id) |
| | return self.get(self.resource_url(resource), params=params) |
| |
|
| | def revoke_user_from_environment(self, environment_id, user, permissions=["READ", "WRITE", "BUILD"]): |
| | """ |
| | Revokes deployment environment permissions from a given user. |
| | :param environment_id: |
| | :param user: |
| | :param permissions: |
| | :return: |
| | """ |
| | resource = "permissions/environment/{}/users/{}".format(environment_id, user) |
| | return self.delete(self.resource_url(resource), data=permissions) |
| |
|
| | def grant_user_to_environment(self, environment_id, user, permissions): |
| | """ |
| | Grants deployment environment permissions to a given user. |
| | :param environment_id: |
| | :param user: |
| | :param permissions: |
| | :return: |
| | """ |
| | resource = "permissions/environment/{}/users/{}".format(environment_id, user) |
| | return self.put(self.resource_url(resource), data=permissions) |
| |
|
| | def get_environment_groups(self, environment_id, filter_name=None, start=0, limit=25): |
| | """ |
| | Retrieve a list of groups with their deployment environment permissions. |
| | The list can be filtered by some attributes. |
| | This resource is paged returns a single page of results. |
| | :param environment_id: |
| | :param filter_name: |
| | :param start: |
| | :param limit: |
| | :return: |
| | """ |
| | params = {"limit": limit, "start": start} |
| | if filter_name: |
| | params = {"name": filter_name} |
| | resource = "permissions/environment/{}/groups".format(environment_id) |
| | return self.get(self.resource_url(resource), params=params) |
| |
|
| | def revoke_group_from_environment(self, environment_id, group, permissions=["READ", "WRITE", "BUILD"]): |
| | """ |
| | Revokes deployment environment permissions from a given group. |
| | :param environment_id: |
| | :param group: |
| | :param permissions: |
| | :return: |
| | """ |
| | resource = "permissions/environment/{}/groups/{}".format(environment_id, group) |
| | return self.delete(self.resource_url(resource), data=permissions) |
| |
|
| | def grant_group_to_environment(self, environment_id, group, permissions): |
| | """ |
| | Grants deployment environment permissions to a given group. |
| | :param environment_id: |
| | :param group: |
| | :param permissions: |
| | :return: |
| | """ |
| | resource = "permissions/environment/{}/groups/{}".format(environment_id, group) |
| | return self.put(self.resource_url(resource), data=permissions) |
| |
|
| | """Other actions""" |
| |
|
| | def server_info(self): |
| | return self.get(self.resource_url("info")) |
| |
|
| | def agent_status(self, online=False): |
| | """ |
| | Provides a list of all agents. |
| | |
| | :param online: filter only online agents (default False = all) |
| | :return: |
| | """ |
| | return self.get(self.resource_url("agent"), params={"online": online}) |
| |
|
| | def agent_is_online(self, agent_id): |
| | """ |
| | Get agent online status. |
| | |
| | :param agent_id: Bamboo agent ID (integer number) |
| | :return: True/False |
| | """ |
| | response = self.get(self.resource_url("agent/{}/status".format(agent_id))) |
| | return response["online"] |
| |
|
| | def agent_enable(self, agent_id): |
| | """ |
| | Enable agent |
| | |
| | :param agent_id: Bamboo agent ID (integer number) |
| | :return: None |
| | """ |
| | self.put(self.resource_url("agent/{}/enable".format(agent_id))) |
| |
|
| | def agent_disable(self, agent_id): |
| | """ |
| | Disable agent |
| | |
| | :param agent_id: Bamboo agent ID (integer number) |
| | :return: None |
| | """ |
| | self.put(self.resource_url("agent/{}/disable".format(agent_id))) |
| |
|
| | def agent_remote(self, online=False): |
| | """ |
| | Provides a list of all agent authentication statuses. |
| | |
| | :param online: list only online agents (default False = all) |
| | :return: list of agent-describing dictionaries |
| | """ |
| | return self.get(self.resource_url("agent/remote"), params={"online": online}) |
| |
|
| | def agent_details(self, agent_id, expand=None): |
| | """ |
| | Provides details of an agent with given id. |
| | |
| | :param agent_id: Bamboo agent ID (integer number) |
| | :param expand: Expand fields (None, capabilities, executableEnvironments, executableJobs) |
| | :return: |
| | """ |
| | params = None |
| | if expand: |
| | params = {"expand": expand} |
| | return self.get(self.resource_url("agent/{}".format(agent_id)), params=params) |
| |
|
| | def agent_capabilities(self, agent_id, include_shared=True): |
| | """ |
| | List agent's capabilities. |
| | |
| | :param agent_id: Bamboo agent ID (integer number) |
| | :param include_shared: Include shared capabilities |
| | :return: agents |
| | """ |
| | return self.get( |
| | self.resource_url("agent/{}/capability".format(agent_id)), params={"includeShared": include_shared} |
| | ) |
| |
|
| | def activity(self): |
| | return self.get("build/admin/ajax/getDashboardSummary.action") |
| |
|
| | def get_custom_expiry(self, limit=25): |
| | """ |
| | Get list of all plans where user has admin permission and which override global expiry settings. |
| | If global expiry is not enabled it returns empty response. |
| | :param limit: |
| | """ |
| | url = "rest/api/latest/admin/expiry/custom/plan?limit={}".format(limit) |
| | return self.get(url) |
| |
|
| | def reports(self, max_results=25): |
| | params = {"max-results": max_results} |
| | return self._get_generator( |
| | self.resource_url("chart/reports"), |
| | elements_key="reports", |
| | element_key="report", |
| | params=params, |
| | ) |
| |
|
| | def chart( |
| | self, |
| | report_key, |
| | build_keys, |
| | group_by_period, |
| | date_filter=None, |
| | date_from=None, |
| | date_to=None, |
| | width=None, |
| | height=None, |
| | start_index=9, |
| | max_results=25, |
| | ): |
| | params = { |
| | "reportKey": report_key, |
| | "buildKeys": build_keys, |
| | "groupByPeriod": group_by_period, |
| | "start-index": start_index, |
| | "max-results": max_results, |
| | } |
| | if date_filter: |
| | params["dateFilter"] = date_filter |
| | if date_filter == "RANGE": |
| | params["dateFrom"] = date_from |
| | params["dateTo"] = date_to |
| | if width: |
| | params["width"] = width |
| | if height: |
| | params["height"] = height |
| | return self.get(self.resource_url("chart"), params=params) |
| |
|
| | def reindex(self): |
| | """ |
| | Returns status of the current indexing operation. |
| | reindexInProgress - reindex is currently performed in background reindexPending - reindex is required |
| | (i.e. it failed before or some upgrade task asked for it) |
| | """ |
| | return self.get(self.resource_url("reindex")) |
| |
|
| | def stop_reindex(self): |
| | """ |
| | Kicks off a reindex. Requires system admin permissions to perform this reindex. |
| | """ |
| | return self.post(self.resource_url("reindex")) |
| |
|
| | def health_check(self): |
| | """ |
| | Get health status |
| | https://confluence.atlassian.com/jirakb/how-to-retrieve-health-check-results-using-rest-api-867195158.html |
| | :return: |
| | """ |
| | |
| | response = self.get("rest/troubleshooting/1.0/check/") |
| | if not response: |
| | |
| | response = self.get("rest/supportHealthCheck/1.0/check/") |
| | return response |
| |
|
| | def upload_plugin(self, plugin_path): |
| | """ |
| | Provide plugin path for upload into Jira e.g. useful for auto deploy |
| | :param plugin_path: |
| | :return: |
| | """ |
| | files = {"plugin": open(plugin_path, "rb")} |
| | upm_token = self.request( |
| | method="GET", |
| | path="rest/plugins/1.0/", |
| | headers=self.no_check_headers, |
| | trailing=True, |
| | ).headers["upm-token"] |
| | url = "rest/plugins/1.0/?token={upm_token}".format(upm_token=upm_token) |
| | return self.post(url, files=files, headers=self.no_check_headers) |
| |
|
