def get_project(self, project, resolved=False, credentials=None):
"""
Get bugs for given project
"""
start = time()
bugs = []
tracker = project.tracker
credentials = credentials or self._get_credentials(tracker.id)
if not credentials:
return []
login_mapping = TrackerCredentials.get_logins_mapping(tracker)
fetcher = get_fetcher(tracker, credentials, login_mapping)
(fetcher.fetch_resolved_bugs_for_query if resolved else fetcher.fetch_bugs_for_query)(*project.get_selector_tuple())
while True:
if fetcher.isReady():
if fetcher.error:
WARN(u"Could not fetch bugs from tracker %s: %s" % (tracker.name, fetcher.error))
flash(u"Could not fetch bugs from tracker %s" % (tracker.name, ))
else:
for bug in fetcher:
bug.project = project
bugs.append(bug)
break
elif time() - start > MAX_TIMEOUT:
WARN(u"Fetchers for tracker %s timed-out" % (tracker.name, ))
flash(u"Getting bugs from tracker %s timed out" % (tracker.name, ))
else:
sleep(0.1)
bugs = self.add_time(bugs)
return bugs
def fetch_scrum(self, sprint_name, project_id=None):
if not self._custom_fields:
url = '/api/v1/projects/%s/custom_field_values.json' % project_id
url = str(make_path(self.tracker.url, url))
self.request(
url,
self.get_headers(),
partial(self.responded, on_success=partial(self.parse_custom_fields, partial(self.fetch_scrum, sprint_name, project_id))),
)
elif not self._milestones:
url = '/api/v1/milestones.json'
url = str(make_path(self.tracker.url, url))
self.request(
url,
self.get_headers(),
partial(self.responded, on_success=partial(self.parse_milestones, partial(self.fetch_scrum, sprint_name, project_id))),
)
else:
url = self.api_url() + '?'
milestone_id = self._milestones.get(sprint_name)
if not milestone_id:
flash('Wrong sprint name')
self.fail('Wrong sprint name')
else:
conditions_string = 'milestone-eq-%s' % self._milestones[sprint_name]
full_url = serialize_url(url, conditions_string=conditions_string)
self.fetch(full_url)
def get_project(self, project, resolved=False, credentials=None):
"""
Get bugs for given project
"""
start = time()
bugs = []
tracker = project.tracker
credentials = credentials or self._get_credentials(tracker.id)
if not credentials:
return []
login_mapping = TrackerCredentials.get_logins_mapping(tracker)
fetcher = get_fetcher(tracker, credentials, login_mapping)
(fetcher.fetch_resolved_bugs_for_query if resolved else fetcher.fetch_bugs_for_query)(*project.get_selector_tuple())
while True:
if fetcher.isReady():
if fetcher.error:
WARN(u"Could not fetch bugs from tracker %s: %s" % (tracker.name, fetcher.error))
flash(u"Could not fetch bugs from tracker %s" % (tracker.name, ))
else:
for bug in fetcher:
bug.project = project
bugs.append(bug)
break
elif time() - start > MAX_TIMEOUT:
WARN(u"Fetchers for tracker %s timed-out" % (tracker.name, ))
flash(u"Getting bugs from tracker %s timed out" % (tracker.name, ))
else:
sleep(0.1)
bugs = self.add_time(bugs)
return bugs
def get_sprint(self, sprint):
bugs = memcache.get(SCRUM_BUG_CACHE_KEY % sprint.id)
if bugs:
return bugs
query = self.request.db_session.query
project_ids = sprint.bugs_project_ids
entries = query(Project, Tracker, TrackerCredentials) \
.filter(Project.id.in_(project_ids)) \
.filter(Project.tracker_id==Tracker.id) \
.filter(TrackerCredentials.tracker_id==Project.tracker_id) \
.filter(TrackerCredentials.user_id==self.user.id).all()
fetchers = []
for project, tracker, creds in entries:
fetcher = get_fetcher(tracker, creds, tracker.logins_mapping)
fetcher.fetch_scrum(sprint.name, project.project_selector, project.component_selector)
fetchers.append(fetcher)
if tracker.type in ('bugzilla', 'rockzilla', 'igozilla'):
break
start = time()
bugs = []
while fetchers:
for i, fetcher in enumerate(fetchers):
if fetcher.isReady():
fetchers.pop(i)
if fetcher.error:
WARN(u"Could not fetch bugs from tracker %s: %s" % (fetcher.tracker.name, fetcher.error))
flash(u"Could not fetch bugs from tracker %s" % (fetcher.tracker.name, ))
else:
for bug in fetcher:
bugs.append(bug)
break
else:
# no fetcher is yet ready, give them time
if time() - start > MAX_TIMEOUT:
WARN(u"Fetchers for trackers %s timed-out" % (u', '.join(fetcher.tracker.name for fetcher in fetchers)))
for fetcher in fetchers:
pass
flash(u"Getting bugs from tracker %s timed out" % (fetcher.tracker.name, ))
fetchers = []
else:
sleep(0.1)
# all bugs were fetched, time to resolve their projects
projects = [bug.project_id for bug in bugs]
projects = dict((project.id, project) for project in Project.query.filter(Project.id.in_(projects)))
# now assign projects to bugs
for bug in bugs:
bug.project = projects.get(bug.project_id)
bugs = self.add_time(bugs, sprint=sprint)
memcache.set(SCRUM_BUG_CACHE_KEY % sprint.id, bugs, SCRUM_BUG_CACHE_TIMEOUT)
return bugs
def _get_bugs(self, fetcher_callback, full_mapping=True):
start = time()
fetchers = []
creds_q = DBSession.query(Tracker, TrackerCredentials)\
.filter(Tracker.id==TrackerCredentials.tracker_id)\
.filter(TrackerCredentials.user_id==self.user.id)
for tracker, credentials in creds_q:
if full_mapping:
mapping = TrackerCredentials.get_logins_mapping(tracker)
else:
mapping = {credentials.login.lower(): self.user}
fetcher = get_fetcher(tracker, credentials, mapping)
fetchers.append(fetcher)
fetcher_callback(fetcher) # initialize query
bugs = []
while fetchers:
for i, fetcher in enumerate(fetchers):
if fetcher.isReady():
fetchers.pop(i)
if fetcher.error:
WARN(u"Could not fetch bugs from tracker %s: %s" %
(fetcher.tracker.name, fetcher.error))
flash(u"Could not fetch bugs from tracker %s" %
(fetcher.tracker.name, ))
else:
for bug in fetcher:
bugs.append(bug)
break
else:
# no fetcher is yet ready, give them time
if time() - start > MAX_TIMEOUT:
WARN(u"Fetchers for trackers %s timed-out" %
(u', '.join(fetcher.tracker.name
for fetcher in fetchers)))
for fetcher in fetchers:
pass
flash(u"Getting bugs from tracker %s timed out" %
(fetcher.tracker.name, ))
fetchers = []
else:
sleep(0.1)
# all bugs were fetched, time to resolve their projects
projects = {}
for bug in bugs:
projects[bug.project_id] = None
# query for all project id's
projects = dict((project.id, project)
for project in Project.query.filter(
Project.id.in_(projects.keys())))
# now assign projects to bugs
for bug in bugs:
bug.project = projects.get(bug.project_id)
return bugs
def fetch_scrum(self, sprint_name, project_id=None):
if not self.unfuddle_data:
self.get_data(partial(self.fetch_scrum, sprint_name, project_id=project_id))
else:
projects_reversed = dict((v, k) for k, v in self.unfuddle_data["projects"].iteritems())
project_id = projects_reversed[project_id]
url = self.api_url() + "?"
milestone_id = self.unfuddle_data["milestones"].get((str(project_id), sprint_name))
if not milestone_id:
flash("Wrong sprint name")
self.fail("Wrong sprint name")
else:
conditions_string = "milestone-eq-%s" % milestone_id
full_url = serialize_url(url, conditions_string=conditions_string)
self.fetch(full_url)
def _get_bugs(self, fetcher_callback, full_mapping=True):
start = time()
fetchers = []
creds_q = DBSession.query(Tracker, TrackerCredentials)\
.filter(Tracker.id==TrackerCredentials.tracker_id)\
.filter(TrackerCredentials.user_id==self.user.id)
for tracker, credentials in creds_q:
if full_mapping:
mapping = TrackerCredentials.get_logins_mapping(tracker)
else:
mapping = {credentials.login.lower(): self.user}
fetcher = get_fetcher(tracker, credentials, mapping)
fetchers.append(fetcher)
fetcher_callback(fetcher) # initialize query
bugs = []
while fetchers:
for i, fetcher in enumerate(fetchers):
if fetcher.isReady():
fetchers.pop(i)
if fetcher.error:
WARN(u"Could not fetch bugs from tracker %s: %s" % (fetcher.tracker.name, fetcher.error))
flash(u"Could not fetch bugs from tracker %s" % (fetcher.tracker.name, ))
else:
for bug in fetcher:
bugs.append(bug)
break
else:
# no fetcher is yet ready, give them time
if time() - start > MAX_TIMEOUT:
WARN(u"Fetchers for trackers %s timed-out" % (u', '.join(fetcher.tracker.name for fetcher in fetchers)))
for fetcher in fetchers:
pass
flash(u"Getting bugs from tracker %s timed out" % (fetcher.tracker.name, ))
fetchers = []
else:
sleep(0.1)
# all bugs were fetched, time to resolve their projects
projects = {}
for bug in bugs:
projects[bug.project_id] = None
# query for all project id's
projects = dict((project.id, project) for project in Project.query.filter(Project.id.in_(projects.keys())))
# now assign projects to bugs
for bug in bugs:
bug.project = projects.get(bug.project_id)
return bugs
def fetch_scrum(self, sprint_name, project_id=None, component_id=None):
if not self.unfuddle_data:
self.get_data(partial(self.fetch_scrum, sprint_name, project_id=project_id))
else:
projects_reversed = dict((v,k) for k, v in self.unfuddle_data['projects'].iteritems())
_project_id = projects_reversed.get(project_id)
if not _project_id:
error = 'Wrong project name %s' % project_id
flash('Could match project selector "%s" to Unfuddle project names' % project_id)
self.fail(error)
return
url = self.api_url() + '?'
milestone_id = self.unfuddle_data['milestones'].get((str(_project_id), sprint_name))
if not milestone_id:
flash('Wrong sprint name')
self.fail('Wrong sprint name')
else:
conditions_string = 'milestone-eq-%s' % milestone_id
full_url = serialize_url(url, conditions_string=conditions_string)
self.fetch(full_url)
def __init__(self, sprint, real_bugs, allowed_colors=None):
# we have to copy bugs, because each section is removing their bugs
# from the list
self._resolve_blocked_and_dependson(real_bugs)
self.bugs = real_bugs[:]
bugs = real_bugs[:]
self._sprint = sprint
self._board_schema = sprint.get_board()
namespace = self.create_base_namespace()
for color in self._board_schema['colors']:
namespace['bugs'] = self.bugs
query_colors = self.TMPL_COLORS % color['cond'].strip()
try:
colored_bug = pyflwor.execute(query_colors, namespace)
except PyFlworException as e:
flash(str(e))
colored_bug = []
for cbug in colored_bug:
cbug.scrum.color = color['color']
self.bugs.remove(cbug)
if allowed_colors:
bugs = [
bug for bug in bugs if bug.scrum.color in allowed_colors
]
self.columns = [
Column(column, bugs)
for column in reversed(self._board_schema['board'])
]
self.columns = list(reversed(self.columns))
def fetch_scrum(self, sprint_name, project_id=None):
if not self._custom_fields:
url = '/api/v1/projects/%s/custom_field_values.json' % project_id
url = str(make_path(self.tracker.url, url))
self.request(
url,
self.get_headers(),
partial(self.responded,
on_success=partial(
self.parse_custom_fields,
partial(self.fetch_scrum, sprint_name,
project_id))),
)
elif not self._milestones:
url = '/api/v1/milestones.json'
url = str(make_path(self.tracker.url, url))
self.request(
url,
self.get_headers(),
partial(self.responded,
on_success=partial(
self.parse_milestones,
partial(self.fetch_scrum, sprint_name,
project_id))),
)
else:
url = self.api_url() + '?'
milestone_id = self._milestones.get(sprint_name)
if not milestone_id:
flash('Wrong sprint name')
self.fail('Wrong sprint name')
else:
conditions_string = 'milestone-eq-%s' % self._milestones[
sprint_name]
full_url = serialize_url(url,
conditions_string=conditions_string)
self.fetch(full_url)
def get_sprint(self, sprint):
project_ids = sprint.bugs_project_ids
entries = DBSession.query(Project, Tracker, TrackerCredentials, User) \
.filter(Project.id.in_(project_ids)) \
.filter(Project.tracker_id==Tracker.id) \
.filter(TrackerCredentials.tracker_id==Project.tracker_id) \
.filter(TrackerCredentials.user_id==User.id)\
.filter(TrackerCredentials.user_id==self.user.id).all()
fetchers = []
for project, tracker, creds, user in entries:
fetcher = get_fetcher(tracker, creds, user, tracker.logins_mapping)
fetcher.fetch_scrum(sprint.name, project.project_selector,
project.component_selector)
fetchers.append(fetcher)
if tracker.type in ('bugzilla', 'rockzilla', 'igozilla'):
break
start = time()
bugs = []
for fetcher in fetchers:
try:
fbugs = fetcher.get_result()
except FetcherTimeout as e:
flash(
'Fetchers for trackers %s timed-out' %
fetcher.tracker.name,
klass='error',
)
continue
except FetcherBadDataError as e:
flash(e, klass='error')
continue
except FetcherBaseException as e:
flash(
'Could not fetch bugs from tracker %s' %
fetcher.tracker.name,
klass='error',
)
continue
bugs.extend(fbugs)
projects = [bug.project_id for bug in bugs]
projects = dict(
(project.id, project)
for project in Project.query.filter(Project.id.in_(projects)))
# now assign projects to bugs
for bug in bugs:
bug.project = projects.get(bug.project_id)
bugs = self.add_time(bugs, sprint=sprint)
return bugs
def get_sprint(self, sprint):
project_ids = sprint.bugs_project_ids
entries = DBSession.query(Project, Tracker, TrackerCredentials, User) \
.filter(Project.id.in_(project_ids)) \
.filter(Project.tracker_id==Tracker.id) \
.filter(TrackerCredentials.tracker_id==Project.tracker_id) \
.filter(TrackerCredentials.user_id==User.id)\
.filter(TrackerCredentials.user_id==self.user.id).all()
fetchers = []
for project, tracker, creds, user in entries:
fetcher = get_fetcher(tracker, creds, user, tracker.logins_mapping)
fetcher.fetch_scrum(sprint.name, project.project_selector, project.component_selector)
fetchers.append(fetcher)
if tracker.type in ('bugzilla', 'rockzilla', 'igozilla'):
break
start = time()
bugs = []
for fetcher in fetchers:
try:
fbugs = fetcher.get_result()
except FetcherTimeout as e:
flash(
'Fetchers for trackers %s timed-out' % fetcher.tracker.name,
klass='error',
)
continue
except FetcherBadDataError as e:
flash(e, klass='error')
continue
except FetcherBaseException as e:
flash(
'Could not fetch bugs from tracker %s' % fetcher.tracker.name,
klass='error',
)
continue
bugs.extend(fbugs)
projects = [bug.project_id for bug in bugs]
projects = dict((project.id, project) for project in Project.query.filter(Project.id.in_(projects)))
# now assign projects to bugs
for bug in bugs:
bug.project = projects.get(bug.project_id)
bugs = self.add_time(bugs, sprint=sprint)
return bugs
def _get_bugs(self, fetcher_callback, full_mapping=True):
fetchers = []
creds_q = DBSession.query(Tracker, TrackerCredentials, User)\
.filter(Tracker.id==TrackerCredentials.tracker_id) \
.filter(User.id==TrackerCredentials.user_id)\
.filter(TrackerCredentials.user_id==self.user.id).all()
for tracker, credentials, user in creds_q:
if full_mapping:
mapping = TrackerCredentials.get_logins_mapping(tracker)
else:
mapping = {credentials.login.lower(): self.user}
fetcher = get_fetcher(tracker, credentials, user, mapping)
fetchers.append(fetcher)
fetcher_callback(fetcher) # initialize query
bugs = []
for fetcher in fetchers:
try:
fbugs = fetcher.get_result()
bugs.extend(fbugs)
except FetcherTimeout as e:
flash(
'Fetchers for trackers %s timed-out' %
fetcher.tracker.name,
klass='error',
)
except FetcherBadDataError as e:
flash(e, klass='error')
except FetcherBaseException as e:
flash(
'Could not fetch bugs from tracker %s' %
fetcher.tracker.name,
klass='error',
)
projects = {}
for bug in bugs:
projects[bug.project_id] = None
# query for all project id's
projects = dict((project.id, project)
for project in Project.query.filter(
Project.id.in_(projects.keys())))
# now assign projects to bugs
for bug in bugs:
bug.project = projects.get(bug.project_id)
return bugs
def _get_bugs(self, fetcher_callback, full_mapping=True):
fetchers = []
creds_q = DBSession.query(Tracker, TrackerCredentials, User)\
.filter(Tracker.id==TrackerCredentials.tracker_id) \
.filter(User.id==TrackerCredentials.user_id)\
.filter(TrackerCredentials.user_id==self.user.id).all()
for tracker, credentials, user in creds_q:
if full_mapping:
mapping = TrackerCredentials.get_logins_mapping(tracker)
else:
mapping = {credentials.login.lower(): self.user}
fetcher = get_fetcher(tracker, credentials, user, mapping)
fetchers.append(fetcher)
fetcher_callback(fetcher) # initialize query
bugs = []
for fetcher in fetchers:
try:
fbugs = fetcher.get_result()
bugs.extend(fbugs)
except FetcherTimeout as e:
flash(
'Fetchers for trackers %s timed-out' % fetcher.tracker.name,
klass='error',
)
except FetcherBadDataError as e:
flash(e, klass='error')
except FetcherBaseException as e:
flash(
'Could not fetch bugs from tracker %s' % fetcher.tracker.name,
klass='error',
)
projects = {}
for bug in bugs:
projects[bug.project_id] = None
# query for all project id's
projects = dict((project.id, project) for project in Project.query.filter(Project.id.in_(projects.keys())))
# now assign projects to bugs
for bug in bugs:
bug.project = projects.get(bug.project_id)
return bugs
def get_project(self, project, resolved=False, credentials=None):
"""
Get bugs for given project
"""
start = time()
bugs = []
tracker = project.tracker
credentials = credentials or self._get_credentials(tracker.id)
if not credentials:
return []
login_mapping = TrackerCredentials.get_logins_mapping(tracker)
fetcher = get_fetcher(tracker, credentials, self.user, login_mapping)
fetcher.fetch_bugs_for_query(*project.get_selector_tuple(),
resolved=resolved)
bugs = []
try:
for bug in fetcher.get_result():
bug.project = project
bugs.append(bug)
except FetcherTimeout as e:
flash(
'Fetchers for trackers %s timed-out' % fetcher.tracker.name,
klass='error',
)
except FetcherBadDataError as e:
flash(e, klass='error')
except FetcherBaseException as e:
flash(
'Could not fetch bugs from tracker %s' % fetcher.tracker.name,
klass='error',
)
bugs = self.add_time(bugs)
return bugs
def __init__(self, section, bugs):
self.name = section['name']
namespace = Board.create_base_namespace()
namespace['bugs'] = bugs
condition = section['cond'].strip()
if condition:
query = self.TMPL % section['cond']
try:
self.bugs = pyflwor.execute(query, namespace)
except PyflworSyntaxError as e:
flash("Syntax error in query: %s" % section['cond'])
self.bugs = []
except KeyError as e:
msg = "Unexpected token %s in query: '%s'" % (
e,
section['cond'],
)
flash(msg)
self.bugs = []
except PyFlworException as e:
flash(str(e))
self.bugs = []
except Exception as e:
err = "Problem with query %s, namespace %s" % (query, namespace)
EXCEPTION(err)
self.bugs = []
else:
# no condition == all bugs
self.bugs = bugs[:]
#those bugs that was taken should be removed from global bug list
for bug in self.bugs:
bugs.remove(bug)
def get_project(self, project, resolved=False, credentials=None):
"""
Get bugs for given project
"""
start = time()
bugs = []
tracker = project.tracker
credentials = credentials or self._get_credentials(tracker.id)
if not credentials:
return []
login_mapping = TrackerCredentials.get_logins_mapping(tracker)
fetcher = get_fetcher(tracker, credentials, self.user, login_mapping)
fetcher.fetch_bugs_for_query(*project.get_selector_tuple(), resolved=resolved)
bugs = []
try:
for bug in fetcher.get_result():
bug.project = project
bugs.append(bug)
except FetcherTimeout as e:
flash(
'Fetchers for trackers %s timed-out' % fetcher.tracker.name,
klass='error',
)
except FetcherBadDataError as e:
flash(e, klass='error')
except FetcherBaseException as e:
flash(
'Could not fetch bugs from tracker %s' % fetcher.tracker.name,
klass='error',
)
bugs = self.add_time(bugs)
return bugs
