| #!/usr/bin/env python |
| |
| # Copyright (c) 2010 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| # For Spreadsheets: |
| try: |
| from xml.etree import ElementTree |
| except ImportError: |
| from elementtree import ElementTree |
| import gdata.spreadsheet.service |
| import gdata.service |
| import atom.service |
| import gdata.spreadsheet |
| import atom |
| |
| # For Issue Tracker: |
| import gdata.projecthosting.client |
| import gdata.projecthosting.data |
| import gdata.gauth |
| import gdata.client |
| import gdata.data |
| import atom.http_core |
| import atom.core |
| |
| # For this script: |
| import getpass |
| from optparse import OptionParser |
| import pickle |
| from sets import Set |
| |
| # Settings |
| credentials_store = 'creds.dat' |
| |
| class Merger(object): |
| def __init__(self, ss_key, ss_ws_key, tracker_message, tracker_project, |
| debug, pretend): |
| self.ss_key = ss_key |
| self.ss_ws_key = ss_ws_key |
| self.tracker_message = tracker_message |
| self.tracker_project = tracker_project |
| self.debug_enabled = debug |
| self.pretend = pretend |
| self.user_agent = 'adlr-tracker-spreadsheet-merger' |
| self.it_keys = ['id', 'owner', 'status', 'title'] |
| |
| def debug(self, message): |
| """Prints message if debug mode is set.""" |
| if self.debug_enabled: |
| print message |
| |
| def print_feed(self, feed): |
| 'Handy for debugging' |
| for i, entry in enumerate(feed.entry): |
| print 'id:', entry.id |
| if isinstance(feed, gdata.spreadsheet.SpreadsheetsCellsFeed): |
| print '%s %s\n' % (entry.title.text, entry.content.text) |
| elif isinstance(feed, gdata.spreadsheet.SpreadsheetsListFeed): |
| print '%s %s %s' % (i, entry.title.text, entry.content.text) |
| # Print this row's value for each column (the custom dictionary is |
| # built using the gsx: elements in the entry.) |
| print 'Contents:' |
| for key in entry.custom: |
| print ' %s: %s' % (key, entry.custom[key].text) |
| print '\n', |
| else: |
| print '%s %s\n' % (i, entry.title.text) |
| |
| |
| def tracker_login(self): |
| """Logs user into Tracker, using cached credentials if possible. |
| Saves credentials after login.""" |
| self.it_client = gdata.projecthosting.client.ProjectHostingClient() |
| self.it_client.source = self.user_agent |
| |
| self.load_creds() |
| |
| if self.tracker_token and self.tracker_user: |
| print 'Using existing credential for tracker login' |
| self.it_client.auth_token = self.tracker_token |
| else: |
| self.tracker_user = raw_input('Issue Tracker Login:') |
| password = getpass.getpass('Password:') |
| self.it_client.ClientLogin(self.tracker_user, password, |
| source=self.user_agent, service='code', |
| account_type='GOOGLE') |
| self.tracker_token = self.it_client.auth_token |
| self.store_creds() |
| |
| def spreadsheet_login(self): |
| """Logs user into Google Spreadsheets, using cached credentials if possible. |
| Saves credentials after login.""" |
| self.gd_client = gdata.spreadsheet.service.SpreadsheetsService() |
| self.gd_client.source = self.user_agent |
| |
| self.load_creds() |
| if self.docs_token: |
| print 'Using existing credential for docs login' |
| self.gd_client.SetClientLoginToken(self.docs_token) |
| else: |
| self.gd_client.email = raw_input('Google Docs Login:') |
| self.gd_client.password = getpass.getpass('Password:') |
| self.gd_client.ProgrammaticLogin() |
| self.docs_token = self.gd_client.GetClientLoginToken() |
| self.store_creds() |
| |
| def fetch_spreadsheet_issues(self): |
| """Fetches all issues from the user-specified spreadsheet. Returns |
| them as an array or dictionaries.""" |
| feed = self.gd_client.GetListFeed(self.ss_key, self.ss_ws_key) |
| issues = [] |
| for entry in feed.entry: |
| issue = {} |
| for key in entry.custom: |
| issue[key] = entry.custom[key].text |
| issue['__raw_entry'] = entry |
| issues.append(issue) |
| return issues |
| |
| def ids_for_spreadsheet_issues(self, ss_issues): |
| """Returns a Set of strings, each string an id from ss_issues""" |
| ret = Set() |
| for ss_issue in ss_issues: |
| ret.add(ss_issue['id']) |
| return ret |
| |
| def tracker_issues_for_query_feed(self, feed): |
| """Converts a feed object from a query to a list of tracker issue |
| dictionaries.""" |
| issues = [] |
| for issue in feed.entry: |
| issue_dict = {} |
| issue_dict['labels'] = [label.text for label in issue.label] |
| issue_dict['id'] = issue.id.text.split('/')[-1] |
| issue_dict['title'] = issue.title.text |
| issue_dict['status'] = issue.status.text |
| if issue.owner: |
| issue_dict['owner'] = issue.owner.username.text |
| issues.append(issue_dict) |
| return issues |
| |
| def fetch_tracker_issues(self, ss_issues): |
| """Fetches all relevant issues from traacker and returns them as an array |
| of dictionaries. Relevance is: |
| - has an ID that's in ss_issues, OR |
| - (is Area=Installer AND status is open). |
| Open status is one of: Unconfirmed, Untriaged, Available, Assigned, |
| Started, Upstream""" |
| issues = [] |
| got_results = True |
| index = 1 |
| while got_results: |
| query = gdata.projecthosting.client.Query(label='Area-Installer', |
| max_results=50, |
| start_index=index) |
| feed = self.it_client.get_issues('chromium-os', query=query) |
| if not feed.entry: |
| got_results = False |
| index = index + len(feed.entry) |
| issues.extend(self.tracker_issues_for_query_feed(feed)) |
| # Now, remove issues that are open or in ss_issues. |
| ss_ids = self.ids_for_spreadsheet_issues(ss_issues) |
| open_statuses = ['Unconfirmed', 'Untriaged', 'Available', 'Assigned', |
| 'Started', 'Upstream'] |
| new_issues = [] |
| for issue in issues: |
| if issue['status'] in open_statuses or issue['id'] in ss_ids: |
| new_issues.append(issue) |
| # Remove id from ss_ids, if it's there |
| ss_ids.discard(issue['id']) |
| issues = new_issues |
| |
| # Now, for each ss_id that didn't turn up in the query, explicitly add it |
| for id_ in ss_ids: |
| query = gdata.projecthosting.client.Query(issue_id=id_, |
| max_results=50, |
| start_index=index) |
| feed = self.it_client.get_issues('chromium-os', query=query) |
| if not feed.entry: |
| print 'No result for id', id_ |
| continue |
| issues.extend(self.tracker_issues_for_query_feed(feed)) |
| |
| return issues |
| |
| def store_creds(self): |
| """Stores login credentials to disk.""" |
| obj = {} |
| if self.docs_token: |
| obj['docs_token'] = self.docs_token |
| if self.tracker_token: |
| obj['tracker_token'] = self.tracker_token |
| if self.tracker_user: |
| obj['tracker_user'] = self.tracker_user |
| try: |
| f = open(credentials_store, 'w') |
| pickle.dump(obj, f) |
| f.close() |
| except IOError: |
| print 'Unable to store credentials' |
| |
| def load_creds(self): |
| """Loads login credentials from disk.""" |
| self.docs_token = None |
| self.tracker_token = None |
| self.tracker_user = None |
| try: |
| f = open(credentials_store, 'r') |
| obj = pickle.load(f) |
| f.close() |
| if obj.has_key('docs_token'): |
| self.docs_token = obj['docs_token'] |
| if obj.has_key('tracker_token'): |
| self.tracker_token = obj['tracker_token'] |
| if obj.has_key('tracker_user'): |
| self.tracker_user = obj['tracker_user'] |
| except IOError: |
| print 'Unable to load credentials' |
| |
| def browse(self): |
| """Browses Spreadsheets to help the user find the spreadsheet and |
| worksheet keys""" |
| print 'Browsing spreadsheets...' |
| |
| if self.ss_key and self.ss_ws_key: |
| print 'You already passed in --ss_key and --ss_ws_key. No need to browse.' |
| return |
| |
| print 'Logging in...' |
| self.spreadsheet_login() |
| |
| if not self.ss_key: |
| print 'Fetching spreadsheets...' |
| feed = self.gd_client.GetSpreadsheetsFeed() |
| print '' |
| print 'Spreadsheet key - Title' |
| for entry in feed.entry: |
| key = entry.id.text.split('/')[-1] |
| title = entry.title.text |
| print '"%s" - "%s"' % (key, title) |
| print '' |
| print 'Done. Rerun with --ss_key=KEY to browse a list of worksheet keys.' |
| else: |
| print 'Fetching worksheets for spreadsheet', self.ss_key |
| feed = self.gd_client.GetWorksheetsFeed(self.ss_key) |
| for entry in feed.entry: |
| key = entry.id.text.split('/')[-1] |
| title = entry.title.text |
| print '' |
| print 'Worksheet key - Title' |
| print '"%s" - "%s"' % (key, title) |
| print '' |
| print 'Done. You now have keys for --ss_key and --ss_ws_key.' |
| |
| def tracker_issue_for_id(self, issues, id_): |
| """Returns the element of issues which has id_ for the key 'id'""" |
| for issue in issues: |
| if issue['id'] == id_: |
| return issue |
| return None |
| |
| def spreadsheet_issue_to_tracker_dict(self, ss_issue): |
| """Converts a spreadsheet issue to the dict format that is used to |
| represent a tracker issue.""" |
| ret = {} |
| ret['project'] = self.tracker_project |
| ret['title'] = ss_issue['title'] |
| ret['summary'] = self.tracker_message |
| ret['owner'] = ss_issue['owner'] |
| if ss_issue.get('status') is not None: |
| ret['status'] = ss_issue['status'] |
| ret['labels'] = [] |
| for (key, value) in ss_issue.items(): |
| if key.endswith('-') and (value is not None): |
| ret['labels'].append(key.title() + value) |
| return ret |
| |
| def label_from_prefix(self, prefix, corpus): |
| """Given a corpus (array of lable strings), return the first label |
| that begins with the specified prefix.""" |
| for label in corpus: |
| if label.startswith(prefix): |
| return label |
| return None |
| |
| def update_spreadsheet_issue_to_tracker_dict(self, ss_issue, t_issue): |
| """Updates a given tracker issue with data from the spreadsheet issue.""" |
| ret = {} |
| ret['title'] = ss_issue['title'] |
| ret['id'] = ss_issue['id'] |
| ret['summary'] = self.tracker_message |
| if ss_issue['status'] != t_issue['status']: |
| ret['status'] = ss_issue['status'] |
| |
| if ss_issue.get('owner'): |
| if (not t_issue.has_key('owner')) or \ |
| (ss_issue['owner'] != t_issue['owner']): |
| ret['owner'] = ss_issue['owner'] |
| # labels |
| ret['labels'] = [] |
| for (key, value) in ss_issue.items(): |
| caps_key = key.title() |
| if not caps_key.endswith('-'): |
| continue |
| ss_label = None |
| if value: |
| ss_label = caps_key + value.title() |
| t_label = self.label_from_prefix(caps_key, t_issue['labels']) |
| |
| if t_label is None and ss_label is None: |
| # Nothing |
| continue |
| |
| if (t_label is not None) and \ |
| ((ss_label is None) or (ss_label != t_label)): |
| ret['labels'].append('-' + t_label) |
| |
| if (ss_label is not None) and \ |
| ((t_label is None) or (t_label != ss_label)): |
| ret['labels'].append(ss_label) |
| return ret |
| |
| def tracker_issue_has_changed(self, t_issue, ss_issue): |
| """Returns True iff ss_issue indicates changes in t_issue that need to be |
| committed up to the Issue Tracker.""" |
| if t_issue is None: |
| return True |
| potential_commit = \ |
| self.update_spreadsheet_issue_to_tracker_dict(ss_issue, t_issue) |
| |
| if potential_commit.has_key('status') or \ |
| potential_commit.has_key('owner') or \ |
| (len(potential_commit['labels']) > 0): |
| return True |
| if potential_commit['title'] != t_issue['title']: |
| return True |
| return False |
| |
| def spreadsheet_to_tracker_commits(self, ss_issues, t_issues): |
| """Given the current state of all spreadsheet issues and tracker issues, |
| returns a list of all commits that need to go to tracker to get it in |
| line with the spreadsheet.""" |
| ret = [] |
| for ss_issue in ss_issues: |
| t_issue = self.tracker_issue_for_id(t_issues, ss_issue['id']) |
| commit = {} |
| # TODO see if an update is needed at all |
| if t_issue is None: |
| commit['type'] = 'append' |
| commit['dict'] = self.spreadsheet_issue_to_tracker_dict(ss_issue) |
| commit['__ss_issue'] = ss_issue |
| else: |
| if not self.tracker_issue_has_changed(t_issue, ss_issue): |
| continue |
| commit['type'] = 'update' |
| commit['dict'] = \ |
| self.update_spreadsheet_issue_to_tracker_dict(ss_issue, t_issue) |
| ret.append(commit) |
| return ret |
| |
| def fetch_issues(self): |
| """Logs into Docs/Tracker, and fetches spreadsheet and tracker issues""" |
| print 'Logging into Docs...' |
| self.spreadsheet_login() |
| print 'Logging into Tracker...' |
| self.tracker_login() |
| |
| print 'Fetching spreadsheet issues...' |
| ss_issues = self.fetch_spreadsheet_issues() |
| self.debug('Spreadsheet issues: %s' % ss_issues) |
| print 'Fetching tracker issues...' |
| t_issues = self.fetch_tracker_issues(ss_issues) |
| self.debug('Tracker issues: %s' % t_issues) |
| return (t_issues, ss_issues) |
| |
| def spreadsheet_to_tracker(self): |
| """High-level function to manage migrating data from the spreadsheet |
| to Tracker.""" |
| (t_issues, ss_issues) = self.fetch_issues() |
| print 'Calculating deltas...' |
| commits = self.spreadsheet_to_tracker_commits(ss_issues, t_issues) |
| self.debug('got commits: %s' % commits) |
| if not commits: |
| print 'No deltas. Done.' |
| return |
| |
| for commit in commits: |
| dic = commit['dict'] |
| labels = dic.get('labels') |
| owner = dic.get('owner') |
| status = dic.get('status') |
| |
| if commit['type'] == 'append': |
| print 'Creating new tracker issue...' |
| if self.pretend: |
| print '(Skipping because --pretend is set)' |
| continue |
| created = self.it_client.add_issue(self.tracker_project, |
| dic['title'], |
| self.tracker_message, |
| self.tracker_user, |
| labels=labels, |
| owner=owner, |
| status=status) |
| issue_id = created.id.text.split('/')[-1] |
| print 'Created issue with id:', issue_id |
| print 'Write id back to spreadsheet row...' |
| raw_entry = commit['__ss_issue']['__raw_entry'] |
| ss_issue = commit['__ss_issue'] |
| del ss_issue['__raw_entry'] |
| ss_issue.update({'id': issue_id}) |
| self.gd_client.UpdateRow(raw_entry, ss_issue) |
| print 'Done.' |
| else: |
| print 'Updating issue with id:', dic['id'] |
| if self.pretend: |
| print '(Skipping because --pretend is set)' |
| continue |
| self.it_client.update_issue(self.tracker_project, |
| dic['id'], |
| self.tracker_user, |
| comment=self.tracker_message, |
| status=status, |
| owner=owner, |
| labels=labels) |
| print 'Done.' |
| |
| def spreadsheet_issue_for_id(self, issues, id_): |
| """Given the array of spreadsheet issues, return the first one that |
| has id_ for the key 'id'.""" |
| for issue in issues: |
| if issue['id'] == id_: |
| return issue |
| return None |
| |
| def value_for_key_in_labels(self, label_array, prefix): |
| """Given an array of labels and a prefix, return the non-prefix part |
| of the first label that has that prefix. E.g. if label_array is |
| ["Mstone-R7", "Area-Installer"] and prefix is "Area-", returns |
| "Installer".""" |
| for label in label_array: |
| if label.startswith(prefix): |
| return label[len(prefix):] |
| return None |
| |
| def tracker_issue_to_spreadsheet_issue(self, t_issue, ss_keys): |
| """Converts a tracker issue to the format used by spreadsheet, given |
| the row headings ss_keys.""" |
| new_row = {} |
| for key in ss_keys: |
| if key.endswith('-'): |
| # label |
| new_row[key] = self.value_for_key_in_labels(t_issue['labels'], |
| key.title()) |
| # Special cases |
| if key in self.it_keys and key in t_issue: |
| new_row[key] = t_issue[key] |
| return new_row |
| |
| def spreadsheet_row_needs_update(self, ss_issue, t_issue): |
| """Returns True iff the spreadsheet issue passed in needs to be updated |
| to match data in the tracker issue.""" |
| new_ss_issue = self.tracker_issue_to_spreadsheet_issue(t_issue, |
| ss_issue.keys()) |
| for key in new_ss_issue.keys(): |
| if not ss_issue.has_key(key): |
| continue |
| if new_ss_issue[key] != ss_issue[key]: |
| return True |
| return False |
| |
| def tracker_to_spreadsheet_commits(self, t_issues, ss_issues): |
| """Given the current set of spreadsheet and tracker issues, computes |
| commits needed to go to Spreadsheets to get the spreadsheet in line |
| with what's in Tracker.""" |
| ret = [] |
| keys = ss_issues[0].keys() |
| for t_issue in t_issues: |
| commit = {} |
| ss_issue = self.spreadsheet_issue_for_id(ss_issues, t_issue['id']) |
| if ss_issue is None: |
| # New issue |
| commit['new_row'] = self.tracker_issue_to_spreadsheet_issue(t_issue, |
| keys) |
| commit['type'] = 'append' |
| elif self.spreadsheet_row_needs_update(ss_issue, t_issue): |
| commit['__raw_entry'] = ss_issue['__raw_entry'] |
| del ss_issue['__raw_entry'] |
| ss_issue.update(self.tracker_issue_to_spreadsheet_issue(t_issue, keys)) |
| commit['dict'] = ss_issue |
| commit['type'] = 'update' |
| else: |
| continue |
| ret.append(commit) |
| return ret |
| |
| def tracker_to_spreadsheet(self): |
| """High-level function to migrate data from Tracker to the spreadsheet.""" |
| (t_issues, ss_issues) = self.fetch_issues() |
| if len(ss_issues) == 0: |
| raise Exception('Error: must have at least one non-header row in '\ |
| 'spreadsheet') |
| return |
| ss_keys = ss_issues[0].keys() |
| |
| print 'Calculating deltas...' |
| ss_commits = self.tracker_to_spreadsheet_commits(t_issues, ss_issues) |
| self.debug('commits: %s' % ss_commits) |
| if not ss_commits: |
| print 'Nothing to commit.' |
| return |
| print 'Committing...' |
| for commit in ss_commits: |
| self.debug('Operating on commit: %s' % commit) |
| if commit['type'] == 'append': |
| print 'Appending new row...' |
| if not self.pretend: |
| self.gd_client.InsertRow(commit['new_row'], |
| self.ss_key, self.ss_ws_key) |
| else: |
| print '(Skipped because --pretend set)' |
| if commit['type'] == 'update': |
| print 'Updating row...' |
| if not self.pretend: |
| self.gd_client.UpdateRow(commit['__raw_entry'], commit['dict']) |
| else: |
| print '(Skipped because --pretend set)' |
| print 'Done.' |
| |
| def main(): |
| class PureEpilogOptionParser(OptionParser): |
| def format_epilog(self, formatter): |
| return self.epilog |
| |
| parser = PureEpilogOptionParser() |
| parser.add_option('-a', '--action', dest='action', metavar='ACTION', |
| help='Action to perform') |
| parser.add_option('-d', '--debug', action='store_true', dest='debug', |
| default=False, help='Print debug output.') |
| parser.add_option('-m', '--message', dest='message', metavar='TEXT', |
| help='Log message when updating Tracker issues') |
| parser.add_option('-p', '--pretend', action='store_true', dest='pretend', |
| default=False, help="Don't commit anything.") |
| parser.add_option('--ss_key', dest='ss_key', metavar='KEY', |
| help='Spreadsheets key (find with browse action)') |
| parser.add_option('--ss_ws_key', dest='ss_ws_key', metavar='KEY', |
| help='Spreadsheets worksheet key (find with browse action)') |
| parser.add_option('--tracker_project', dest='tracker_project', |
| metavar='PROJECT', |
| help='Tracker project (default: chromium-os)', |
| default='chromium-os') |
| parser.epilog = """Actions: |
| browse -- browse spreadsheets to find spreadsheet and worksheet keys. |
| ss_to_t -- for each entry in spreadsheet, apply its values to tracker. |
| If no ID is in the spreadsheet row, a new tracker item is created |
| and the spreadsheet is updated. |
| t_to_ss -- for each tracker entry, apply it or add it to the spreadsheet. |
| |
| |
| This script can be used to migrate Issue Tracker issues between Issue Tracker |
| and Google Spreadsheets. The spreadsheet should have certain columns in any |
| order: Id, Owner, Title, Status. The spreadsheet may have any label of the |
| form 'Key-'. For those labels that end in '-', this script assumes the cell |
| value and the header form a label that should be applied to the issue. E.g. |
| if the spredsheet has a column named 'Mstone-' and a cell under it called |
| 'R8' that corresponds to the label 'Mstone-R8' in Issue Tracker. |
| |
| To migrate data, you must choose on each invocation of this script if you |
| wish to migrate data from Issue Tracker to a spreadsheet of vice-versa. |
| |
| When migrating from Tracker, all found issues based on the query |
| (which is currently hard-coded to "label=Area-Installer") will be inserted |
| into the spreadsheet (overwritng existing cells if a row with matching ID |
| is found). Custom columns in the spreadsheet won't be overwritten, so if |
| the spreadsheet contains extra columns about issues (e.g. time estimates) |
| they will be preserved. |
| |
| When migrating from spreadsheet to Tracker, each row in the spreadsheet |
| is compared to existing tracker issues that match the query |
| (which is currently hard-coded to "label=Area-Installer"). If the |
| spreadsheet row has no Id, a new Issue Tracker issue is created and the new |
| Id is written back to the spreadsheet. If an existing tracker issue exists, |
| it's updated with the data from the spreadsheet if anything has changed. |
| |
| Suggested usage: |
| - Create a spreadsheet with columns Id, Owner, Title, Status, and any label |
| prefixes as desired. |
| - Run this script with '-b' to browse your spreadsheet and get the |
| spreadsheet key. |
| - Run this script again with '-b' and the spreadsheet key to get the |
| worksheet key. |
| - Run this script with "-a t_to_ss" or "-a ss_to_t" to migrate data in either |
| direction. |
| |
| Known issues: |
| - query is currently hardcoded to label=Area-Installer. That should be |
| a command-line flag. |
| - When creating a new issue on tracker, the owner field isn't set. I (adlr) |
| am not sure why. Workaround: If you rerun this script, tho, it will detect |
| a delta and update the tracker issue with the owner, which seems to succeed. |
| """ |
| |
| (options, args) = parser.parse_args() |
| |
| merger = Merger(options.ss_key, options.ss_ws_key, |
| options.message, options.tracker_project, |
| options.debug, options.pretend) |
| if options.action == 'browse': |
| merger.browse() |
| elif options.action == 'ss_to_t': |
| if not options.message: |
| print 'Error: when updating tracker, -m MESSAGE required.' |
| return |
| merger.spreadsheet_to_tracker() |
| elif options.action == 't_to_ss': |
| merger.tracker_to_spreadsheet() |
| else: |
| raise Exception('Unknown action requested.') |
| |
| if __name__ == '__main__': |
| main() |