| #!/usr/bin/env python3 |
| |
| # Copyright (c) 2020 The Regents of the University of California |
| # All Rights Reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer; |
| # redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution; |
| # neither the name of the copyright holders nor the names of its |
| # contributors may be used to endorse or promote products derived from |
| # this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| from gerrit import GerritResponseParser as Parser |
| from gerrit import GerritRestAPI |
| from util import add_maintainers_to_change, convert_time_in_seconds |
| |
| import json |
| import time |
| |
| import sys |
| sys.path.append('..') |
| import maint.lib.maintainers |
| |
| |
| class GerritBotConfig: |
| def __init__(self, config = {}): |
| self.__dict__.update(config) |
| @staticmethod |
| def DefaultConfig(): |
| default_config = GerritBotConfig() |
| |
| # path to the file containing the username and password of the |
| # Gerrit bot |
| default_config.auth_file_path = ".data/auth" |
| |
| # path to the file containing the previous time a query to Gerrit |
| # REST API was made |
| default_config.time_tracker_file_path = ".data/prev_query_time" |
| |
| # path to the file containing the map each maintainer email address |
| # to the one account id (ie, the "_account_id" field of ReviewerInfo) |
| default_config.maintainer_account_ids_file_path = \ |
| ".data/maintainer_ids.json" |
| |
| # query changes made within 2 days if prev_query_time is not specified |
| default_config.default_query_age = "2d" |
| |
| # path to the maintainers file |
| # if it is `None`, the maintainers library will figure that out |
| default_config.maintainers_file_path = None |
| |
| default_config.api_entry_point = "https://gem5-review.googlesource.com" |
| default_config.projects_prefix = "public/gem5" |
| default_config.query_limit = 1000 # at most 1000 new changes per query |
| default_config.request_timeout = 10 # seconds |
| return default_config |
| |
| class GerritBot: |
| def __init__(self, config): |
| self.config = config |
| |
| self.auth = self.__read_auth_file(self.config.auth_file_path) |
| |
| # Initalize the Gerrit API Object |
| self.gerrit_api = GerritRestAPI(self.auth, |
| self.config.api_entry_point, |
| self.config.request_timeout) |
| |
| self.account_id = self.__get_bot_account_id() |
| self.maintainers = maint.lib.maintainers.Maintainers.from_file( |
| self.config.maintainers_file_path) |
| self.maintainer_account_ids = self.__read_maintainer_account_id_file( |
| self.maintainers, self.config.maintainer_account_ids_file_path) |
| def __read_auth_file(self, auth_file_path): |
| username = "" |
| password = "" |
| with open(auth_file_path, "r") as f: |
| lines = f.readlines() |
| username = lines[0].strip() |
| password = lines[1].strip() |
| return (username, password) |
| |
| def __read_time_tracker_file(self, file_path): |
| prev_query_time = 0 |
| |
| try: |
| with open(file_path, "r") as f: |
| lines = f.readlines() |
| prev_query_time = int(float(lines[0].strip())) |
| except FileNotFoundError: |
| print(f"warning: cannot find the time tracker file at " |
| f"`{file_path}`. Previous query time is set to 0.") |
| except IndexError: |
| print(f"warning: cannot find the content of the time tracker file " |
| f"at `{file_path}`. Previous query time is set 0.") |
| |
| return prev_query_time |
| |
| def __update_time_tracker_file(self, file_path, prev_query_time): |
| with open(file_path, "w") as f: |
| f.write(f"{prev_query_time}\n") |
| f.write(f"# The above time is the result of calling time.time() " |
| f"in Python.") |
| |
| def __read_maintainer_account_id_file(self, maintainers, file_path): |
| account_ids = {} |
| try: |
| with open(file_path, "r") as f: |
| account_ids = json.load(f) |
| except (FileNotFoundError, json.decoder.JSONDecodeError): |
| # create a placeholder file |
| with open(file_path, "w") as f: |
| json.dump(account_ids, f) |
| account_ids = self.__update_maintainer_account_id_file(file_path, |
| maintainers) |
| return account_ids |
| |
| def __update_maintainer_account_id_file(self, file_path, maintainers): |
| # get the current map |
| with open(file_path, "r") as f: |
| account_ids = json.load(f) |
| # get maintainer email addresses |
| email_addresses = set() |
| for tag, subsys in maintainers: |
| for maint in subsys.maintainers: |
| email_addresses.add(maint[1]) |
| # get account ids of the addresses |
| for email_address in email_addresses: |
| if email_address in account_ids: |
| continue |
| account_id = self.__get_one_account_id(email_address) |
| if account_id: |
| account_ids[email_address] = account_id |
| # write the map to a json file |
| with open(file_path, "w") as f: |
| json.dump(account_ids, f, indent=4) |
| return account_ids |
| |
| def __get_one_account_id(self, email_address): |
| query = f"email:{email_address}" |
| response = self.gerrit_api.query_account(query, 1) |
| accounts = Parser.get_json_content(response) |
| if len(accounts) == 0: |
| print(f"warn: unable to obtain the account id of " |
| f"\"{email_address}\"") |
| print(vars(response)) |
| return None |
| return accounts[0]["_account_id"] |
| |
| def __get_bot_account_id(self): |
| account_info = Parser.parse(self.gerrit_api.get_account("self")) |
| return account_info._account_id |
| |
| def __query_new_changes(self, query_age): |
| query = (f"projects:{self.config.projects_prefix} " |
| f"status:open -is:wip -age:{query_age}") |
| response = self.gerrit_api.query_changes( |
| query, self.config.query_limit, |
| ["CURRENT_REVISION", "REVIEWER_UPDATES", "DETAILED_ACCOUNTS"] |
| ) |
| |
| if response.status_code >= 300: |
| print("Error: Couldn't query new Gerrit changes") |
| print(vars(query_new_gerrit_changes_response)) |
| raise Error() |
| |
| new_changes = Parser.get_json_content(response) |
| |
| return new_changes |
| |
| def _pre_run(self): |
| self.prev_query_time = \ |
| self.__read_time_tracker_file(self.config.time_tracker_file_path) |
| self.curr_time = time.time() |
| if self.prev_query_time > 0: |
| # adding 10 seconds to the query age to make sure that |
| # we won't miss any new changes |
| self.query_age = \ |
| convert_time_in_seconds( |
| int(self.curr_time - self.prev_query_time + 10)) |
| else: |
| self.query_age = self.config.default_query_age |
| |
| def _run(self): |
| new_changes = self.__query_new_changes(self.query_age) |
| for new_change in new_changes: |
| add_maintainers_to_change(new_change, |
| self.maintainers, |
| self.maintainer_account_ids, |
| self.gerrit_api) |
| |
| def _post_run(self): |
| self.__update_time_tracker_file(self.config.time_tracker_file_path, |
| self.curr_time) |
| |
| def run(self): |
| self._pre_run() |
| self._run() |
| self._post_run() |
| |
| if __name__ == "__main__": |
| default_config = GerritBotConfig.DefaultConfig() |
| gerrit_bot = GerritBot(default_config) |
| gerrit_bot.run() |
