~launchpad-pqm/launchpad/devel

# Copyright 2009-2011 Canonical Ltd.  This software is licensed under the

# GNU Affero General Public License version 3 (see the file LICENSE).

"""Bugzilla ExternalBugTracker utility."""

__metaclass__ = type

__all__ = [

    'Bugzilla',

    'BugzillaAPI',

    'BugzillaLPPlugin',

    'needs_authentication',

    ]

from email.Utils import parseaddr

import re

from httplib import BadStatusLine

from urllib2 import URLError

from xml.dom import minidom

import xml.parsers.expat

import xmlrpclib

import pytz

from zope.component import getUtility

from zope.interface import implements

from canonical.config import config

from lp.services.messages.interfaces.message import IMessageSet

from canonical.launchpad.webapp.url import (

    urlappend,

    urlparse,

    )

from lp.bugs.externalbugtracker.base import (

    BugNotFound,

    BugTrackerAuthenticationError,

    BugTrackerConnectError,

    ExternalBugTracker,

    InvalidBugId,

    LookupTree,

    UnknownRemoteImportanceError,

    UnknownRemoteStatusError,

    UnparsableBugData,

    UnparsableBugTrackerVersion,

    )

from lp.bugs.externalbugtracker.xmlrpc import UrlLib2Transport

from lp.bugs.interfaces.bugtask import (

    BugTaskImportance,

    BugTaskStatus,

    )

from lp.bugs.interfaces.externalbugtracker import (

    ISupportsBackLinking,

    ISupportsCommentImport,

    ISupportsCommentPushing,

    UNKNOWN_REMOTE_IMPORTANCE,

    )

from lp.services import encoding

from lp.services.database.isolation import ensure_no_transaction

class Bugzilla(ExternalBugTracker):

    """An ExternalBugTrack for dealing with remote Bugzilla systems."""

    batch_query_threshold = 0 # Always use the batch method.

    _test_xmlrpc_proxy = None

    def __init__(self, baseurl, version=None):

        super(Bugzilla, self).__init__(baseurl)

        self.version = self._parseVersion(version)

        self.is_issuezilla = False

        self.remote_bug_status = {}

        self.remote_bug_importance = {}

        self.remote_bug_product = {}

    @ensure_no_transaction

    def _remoteSystemHasBugzillaAPI(self):

        """Return True if the remote host offers the Bugzilla API.

        :return: True if the remote host offers an XML-RPC API and its

            version is > 3.4. Return False otherwise.

        """

        api = BugzillaAPI(self.baseurl)

        if self._test_xmlrpc_proxy is not None:

            proxy = self._test_xmlrpc_proxy

        else:

            proxy = api.xmlrpc_proxy

        try:

            # We try calling Bugzilla.version() on the remote

            # server because it's the most lightweight method there is.

            remote_version = proxy.Bugzilla.version()

        except xmlrpclib.Fault, fault:

            # 'Client' is a hangover. Either Bugzilla or the Perl

            # XML-RPC lib in use returned it as faultCode. It's wrong,

            # but it's known wrongness, so we recognize it here.

            if fault.faultCode in (xmlrpclib.METHOD_NOT_FOUND, 'Client'):

                return False

            else:

                raise

        except xmlrpclib.ProtocolError, error:

            # We catch 404s, which occur when xmlrpc.cgi doesn't exist

            # on the remote server, and 500s, which sometimes occur when

            # an invalid request is made to the remote server. We allow

            # any other error types to propagate upward.

            if error.errcode in (404, 500):

                return False

            else:

                raise

        except (xmlrpclib.ResponseError, xml.parsers.expat.ExpatError):

            # The server returned an unparsable response.

            return False

        else:

            # Older versions of the Bugzilla API return tuples. We

            # consider anything other than a mapping to be unsupported.

            if isinstance(remote_version, dict):

                if remote_version['version'] >= '3.4':

                    return True

            return False

    @ensure_no_transaction

    def _remoteSystemHasPluginAPI(self):

        """Return True if the remote host has the Launchpad plugin installed.

        """

        plugin = BugzillaLPPlugin(self.baseurl)

        if self._test_xmlrpc_proxy is not None:

            proxy = self._test_xmlrpc_proxy

        else:

            proxy = plugin.xmlrpc_proxy

        try:

            # We try calling Launchpad.plugin_version() on the remote

            # server because it's the most lightweight method there is.

            proxy.Launchpad.plugin_version()

        except xmlrpclib.Fault, fault:

            # 'Client' is a hangover. Either Bugzilla or the Perl

            # XML-RPC lib in use returned it as faultCode. It's wrong,

            # but it's known wrongness, so we recognize it here.

            if fault.faultCode in (xmlrpclib.METHOD_NOT_FOUND, 'Client'):

                return False

            else:

                raise

        except xmlrpclib.ProtocolError, error:

            # We catch 404s, which occur when xmlrpc.cgi doesn't exist

            # on the remote server, and 500s, which sometimes occur when

            # the Launchpad Plugin isn't installed. Everything else we

            # can consider to be a problem, so we let it travel up the

            # stack for the error log.

            if error.errcode in (404, 500):

                return False

            else:

                raise

        except (xmlrpclib.ResponseError, xml.parsers.expat.ExpatError):

            # The server returned an unparsable response.

            return False

        else:

            return True

    def getExternalBugTrackerToUse(self):

        """Return the correct `Bugzilla` subclass for the current bugtracker.

        See `IExternalBugTracker`.

        """

        # checkwatches isn't set up to handle errors here, so we supress

        # known connection issues. They'll be handled and logged later on when

        # further requests are attempted.

        try:

            if self._remoteSystemHasPluginAPI():

                return BugzillaLPPlugin(self.baseurl)

            elif self._remoteSystemHasBugzillaAPI():

                return BugzillaAPI(self.baseurl)

        except (xmlrpclib.ProtocolError, URLError, BadStatusLine):

            pass

        return self

    def _parseDOMString(self, contents):

        """Return a minidom instance representing the XML contents supplied"""

        # Some Bugzilla sites will return pages with content that has

        # broken encoding. It's unfortunate but we need to guess the

        # encoding that page is in, and then encode() it into the utf-8

        # that minidom requires.

        contents = encoding.guess(contents).encode("utf-8")

        return minidom.parseString(contents)

    def _probe_version(self):

        """Retrieve and return a remote bugzilla version.

        If the version cannot be parsed from the remote server

        `UnparsableBugTrackerVersion` will be raised. If the remote

        server cannot be reached `BugTrackerConnectError` will be

        raised.

        """

        version_xml = self._getPage('xml.cgi?id=1')

        try:

            document = self._parseDOMString(version_xml)

        except xml.parsers.expat.ExpatError, e:

            raise BugTrackerConnectError(self.baseurl,

                "Failed to parse output when probing for version: %s" % e)

        bugzilla = document.getElementsByTagName("bugzilla")

        if not bugzilla:

            # Welcome to Disneyland. The Issuezilla tracker replaces

            # "bugzilla" with "issuezilla".

            bugzilla = document.getElementsByTagName("issuezilla")

            if bugzilla:

                self.is_issuezilla = True

            else:

                raise UnparsableBugTrackerVersion(

                    'Failed to parse version from xml.cgi for %s: could '

                    'not find top-level bugzilla element'

                    % self.baseurl)

        version = bugzilla[0].getAttribute("version")

        return self._parseVersion(version)

    def _parseVersion(self, version):

        """Return a Bugzilla version parsed into a tuple.

        A typical tuple will be in the form (major_version,

        minor_version), so the version string '2.15' would be returned

        as (2, 15).

        If the passed version is None, None will be returned.

        If the version cannot be parsed `UnparsableBugTrackerVersion`

        will be raised.

        """

        if version is None:

            return None

        version_numbers = re.findall('[0-9]+', version)

        if len(version_numbers) == 0:

            raise UnparsableBugTrackerVersion(

                'Failed to parse version %r for %s' %

                (version, self.baseurl))

        return tuple(int(number) for number in version_numbers)

    _importance_lookup = {

        'blocker': BugTaskImportance.CRITICAL,

        'critical': BugTaskImportance.CRITICAL,

        'immediate': BugTaskImportance.CRITICAL,

        'urgent': BugTaskImportance.CRITICAL,

        'p5': BugTaskImportance.CRITICAL,

        'crash': BugTaskImportance.HIGH,

        'grave': BugTaskImportance.HIGH,

        'major': BugTaskImportance.HIGH,

        'high': BugTaskImportance.HIGH,

        'p4': BugTaskImportance.HIGH,

        'normal': BugTaskImportance.MEDIUM,

        'medium': BugTaskImportance.MEDIUM,

        'p3': BugTaskImportance.MEDIUM,

        'minor': BugTaskImportance.LOW,

        'low': BugTaskImportance.LOW,

        'trivial': BugTaskImportance.LOW,

        'p2': BugTaskImportance.LOW,

        'p1': BugTaskImportance.LOW,

        'enhancement': BugTaskImportance.WISHLIST,

        'wishlist': BugTaskImportance.WISHLIST,

        }

    def convertRemoteImportance(self, remote_importance):

        """See `ExternalBugTracker`."""

        words = remote_importance.lower().split()

        try:

            return self._importance_lookup[words.pop()]

        except KeyError:

            raise UnknownRemoteImportanceError(remote_importance)

        except IndexError:

            return BugTaskImportance.UNKNOWN

        return BugTaskImportance.UNKNOWN

    _status_lookup_titles = 'Bugzilla status', 'Bugzilla resolution'

    _status_lookup = LookupTree(

        ('ASSIGNED', 'ON_DEV', 'FAILS_QA', 'STARTED',

         BugTaskStatus.INPROGRESS),

        ('NEEDINFO', 'NEEDINFO_REPORTER', 'NEEDSINFO', 'WAITING', 'SUSPENDED',

         'PLEASETEST',

         BugTaskStatus.INCOMPLETE),

        ('PENDINGUPLOAD', 'MODIFIED', 'RELEASE_PENDING', 'ON_QA',

         BugTaskStatus.FIXCOMMITTED),

        ('REJECTED', BugTaskStatus.INVALID),

        ('RESOLVED', 'VERIFIED', 'CLOSED',

            LookupTree(

                ('CODE_FIX', 'CURRENTRELEASE', 'ERRATA', 'NEXTRELEASE',

                 'PATCH_ALREADY_AVAILABLE', 'FIXED', 'RAWHIDE',

                 'DOCUMENTED',

                 BugTaskStatus.FIXRELEASED),

                ('WONTFIX', 'WILL_NOT_FIX', 'NOTOURBUG', 'UPSTREAM',

                 BugTaskStatus.WONTFIX),

                ('OBSOLETE', 'INSUFFICIENT_DATA', 'INCOMPLETE', 'EXPIRED',

                 BugTaskStatus.EXPIRED),

                ('INVALID', 'WORKSFORME', 'NOTABUG', 'CANTFIX',

                 'UNREPRODUCIBLE', 'DUPLICATE',

                 BugTaskStatus.INVALID))),

        ('REOPENED', 'NEW', 'UPSTREAM', 'DEFERRED',

         BugTaskStatus.CONFIRMED),

        ('UNCONFIRMED', BugTaskStatus.NEW),

        )

    def convertRemoteStatus(self, remote_status):

        """See `IExternalBugTracker`.

        Bugzilla status consist of two parts separated by space, where

        the last part is the resolution. The resolution is optional.

        """

        try:

            return self._status_lookup.find(*remote_status.split())

        except KeyError:

            raise UnknownRemoteStatusError(remote_status)

    def initializeRemoteBugDB(self, bug_ids):

        """See `ExternalBugTracker`.

        This method is overriden so that Bugzilla version issues can be

        accounted for.

        """

        if self.version is None:

            self.version = self._probe_version()

        super(Bugzilla, self).initializeRemoteBugDB(bug_ids)

    def getRemoteBug(self, bug_id):

        """See `ExternalBugTracker`."""

        return (bug_id, self.getRemoteBugBatch([bug_id]))

    def _checkBugSearchResult(self, document):

        """Does `document` appear to be a bug search result page?

        :param document: An `xml.dom.Document` built from a bug search result

            on the bugzilla instance.

        :raise UnparsableBugData: If `document` does not appear to be a bug

            search result.

        """

        root = document.documentElement

        if root.tagName == 'html':

            raise UnparsableBugData(

                "Bug search on %s returned a <%s> instead of an RDF page." % (

                    self.baseurl, root.tagName))

    def getRemoteBugBatch(self, bug_ids):

        """See `ExternalBugTracker`."""

        # XXX: GavinPanella 2007-10-25 bug=153532: The modification of

        # self.remote_bug_status later on is a side-effect that should

        # really not be in this method, but for the fact that

        # getRemoteStatus needs it at other times. Perhaps

        # getRemoteBug and getRemoteBugBatch could return RemoteBug

        # objects which have status properties that would replace

        # getRemoteStatus.

        if self.is_issuezilla:

            buglist_page = 'xml.cgi'

            data = {

                'download_type': 'browser',

                'output_configured': 'true',

                'include_attachments': 'false',

                'include_dtd': 'true',

                'id': ','.join(bug_ids),

                }

            bug_tag = 'issue'

            id_tag = 'issue_id'

            status_tag = 'issue_status'

            resolution_tag = 'resolution'

            priority_tag = 'priority'

            severity_tag = None

        elif self.version < (2, 16):

            buglist_page = 'xml.cgi'

            data = {'id': ','.join(bug_ids)}

            bug_tag = 'bug'

            id_tag = 'bug_id'

            status_tag = 'bug_status'

            resolution_tag = 'resolution'

            priority_tag = 'priority'

            severity_tag = 'bug_severity'

        else:

            buglist_page = 'buglist.cgi'

            data = {

                'form_name': 'buglist.cgi',

                'bug_id_type': 'include',

                'columnlist':

                    ('id,product,bug_status,resolution,'

                     'priority,bug_severity'),

                'bug_id': ','.join(bug_ids),

                }

            if self.version < (2, 17, 1):

                data.update({'format': 'rdf'})

            else:

                data.update({'ctype': 'rdf'})

            bug_tag = 'bz:bug'

            id_tag = 'bz:id'

            status_tag = 'bz:bug_status'

            resolution_tag = 'bz:resolution'

            priority_tag = 'bz:priority'

            severity_tag = 'bz:bug_severity'

        buglist_xml = self._postPage(

            buglist_page, data, repost_on_redirect=True)

        try:

            document = self._parseDOMString(buglist_xml)

        except xml.parsers.expat.ExpatError, e:

            raise UnparsableBugData(

                "Failed to parse XML description for %s bugs %s: %s"

                % (self.baseurl, bug_ids, e))

        self._checkBugSearchResult(document)

        bug_nodes = document.getElementsByTagName(bug_tag)

        for bug_node in bug_nodes:

            # We use manual iteration to pick up id_tags instead of

            # getElementsByTagName because the latter does a recursive

            # search, and in some documents we've found the id_tag to

            # appear under other elements (such as "has_duplicates") in

            # the document hierarchy.

            bug_id_nodes = [node for node in bug_node.childNodes if

                            node.nodeName == id_tag]

            if not bug_id_nodes:

                # Something in the output is really weird; this will

                # show up as a bug not found, but we can catch that

                # later in the error logs.

                continue

            bug_id_node = bug_id_nodes[0]

            assert len(bug_id_node.childNodes) == 1, (

                "id node should contain a non-empty text string.")

            bug_id = str(bug_id_node.childNodes[0].data)

            # This assertion comes in late so we can at least tell what

            # bug caused this crash.

            assert len(bug_id_nodes) == 1, ("Should be only one id node, "

                "but %s had %s." % (bug_id, len(bug_id_nodes)))

            status_nodes = bug_node.getElementsByTagName(status_tag)

            if not status_nodes:

                # Older versions of bugzilla used bz:status; this was

                # later changed to bz:bug_status. For robustness, and

                # because there is practically no risk of reading wrong

                # data here, just try the older format as well.

                status_nodes = bug_node.getElementsByTagName("bz:status")

            assert len(status_nodes) == 1, ("Couldn't find a status "

                                            "node for bug %s." % bug_id)

            bug_status_node = status_nodes[0]

            assert len(bug_status_node.childNodes) == 1, (

                "status node for bug %s should contain a non-empty "

                "text string." % bug_id)

            status = bug_status_node.childNodes[0].data

            resolution_nodes = bug_node.getElementsByTagName(resolution_tag)

            assert len(resolution_nodes) <= 1, (

                "Should be only one resolution node for bug %s." % bug_id)

            if resolution_nodes:

                assert len(resolution_nodes[0].childNodes) <= 1, (

                    "Resolution for bug %s should just contain "

                    "a string." % bug_id)

                if resolution_nodes[0].childNodes:

                    resolution = resolution_nodes[0].childNodes[0].data

                    status += ' %s' % resolution

            self.remote_bug_status[bug_id] = status

            # Priority (for Importance)

            priority = ''

            priority_nodes = bug_node.getElementsByTagName(priority_tag)

            assert len(priority_nodes) <= 1, (

                "Should only be one priority node for bug %s" % bug_id)

            if priority_nodes:

                bug_priority_node = priority_nodes[0]

                assert len(bug_priority_node.childNodes) == 1, (

                    "priority node for bug %s should contain a non-empty "

                    "text string." % bug_id)

                priority = bug_priority_node.childNodes[0].data

            # Severity (for Importance)

            if severity_tag:

                severity_nodes = bug_node.getElementsByTagName(severity_tag)

                assert len(severity_nodes) <= 1, (

                    "Should only be one severity node for bug %s." % bug_id)

                if severity_nodes:

                    assert len(severity_nodes[0].childNodes) <= 1, (

                        "Severity for bug %s should just contain "

                        "a string." % bug_id)

                    if severity_nodes[0].childNodes:

                        severity = severity_nodes[0].childNodes[0].data

                        priority += ' %s' % severity

            self.remote_bug_importance[bug_id] = priority

            # Product

            product_nodes = bug_node.getElementsByTagName('bz:product')

            assert len(product_nodes) <= 1, (

                "Should be at most one product node for bug %s." % bug_id)

            if len(product_nodes) == 0:

                self.remote_bug_product[bug_id] = None

            else:

                product_node = product_nodes[0]

                self.remote_bug_product[bug_id] = (

                    product_node.childNodes[0].data)

    def getRemoteImportance(self, bug_id):

        """See `ExternalBugTracker`."""

        try:

            if bug_id not in self.remote_bug_importance:

                return "Bug %s is not in remote_bug_importance" %(bug_id)

            return self.remote_bug_importance[bug_id]

        except:

            return UNKNOWN_REMOTE_IMPORTANCE

    def getRemoteStatus(self, bug_id):

        """See ExternalBugTracker."""

        if not bug_id.isdigit():

            raise InvalidBugId(

                "Bugzilla (%s) bug number not an integer: %s" % (

                    self.baseurl, bug_id))

        try:

            return self.remote_bug_status[bug_id]

        except KeyError:

            raise BugNotFound(bug_id)

    def getRemoteProduct(self, remote_bug):

        """See `IExternalBugTracker`."""

        if remote_bug not in self.remote_bug_product:

            raise BugNotFound(remote_bug)

        return self.remote_bug_product[remote_bug]

def needs_authentication(func):

    """Decorator for automatically authenticating if needed.

    If an `xmlrpclib.Fault` with error code 410 is raised by the

    function, we'll try to authenticate and call the function again.

    """

    def decorator(self, *args, **kwargs):

        try:

            return func(self, *args, **kwargs)

        except xmlrpclib.Fault, fault:

            # Catch authentication errors only.

            if fault.faultCode != 410:

                raise

            self._authenticate()

            return func(self, *args, **kwargs)

    return decorator

class BugzillaAPI(Bugzilla):

    """An `ExternalBugTracker` to handle Bugzillas that offer an API."""

    implements(

        ISupportsBackLinking, ISupportsCommentImport, ISupportsCommentPushing)

    def __init__(self, baseurl, xmlrpc_transport=None,

                 internal_xmlrpc_transport=None):

        super(BugzillaAPI, self).__init__(baseurl)

        self._bugs = {}

        self._bug_aliases = {}

        self.xmlrpc_endpoint = urlappend(self.baseurl, 'xmlrpc.cgi')

        self.internal_xmlrpc_transport = internal_xmlrpc_transport

        if xmlrpc_transport is None:

            self.xmlrpc_transport = UrlLib2Transport(self.xmlrpc_endpoint)

        else:

            self.xmlrpc_transport = xmlrpc_transport

    def getExternalBugTrackerToUse(self):

        """The Bugzilla API has been chosen, so return self."""

        return self

    @property

    def xmlrpc_proxy(self):

        """Return an `xmlrpclib.ServerProxy` to self.xmlrpc_endpoint."""

        return xmlrpclib.ServerProxy(

            self.xmlrpc_endpoint, transport=self.xmlrpc_transport)

    @property

    def credentials(self):

        credentials_config = config['checkwatches.credentials']

        # Extract the hostname from the current base url using urlparse.

        hostname = urlparse(self.baseurl)[1]

        try:

            # XXX gmb 2009-08-19 bug=391131

            #     We shouldn't be using this here. Ideally we'd be able

            #     to get the credentials from the BugTracker object.

            #     If you find yourself adding credentials for, for

            #     example, www.password.username.pirateninjah4x0rz.org,

            #     think about fixing the above bug instead.

            username = credentials_config['%s.username' % hostname]

            password = credentials_config['%s.password' % hostname]

            return {'login': username, 'password': password}

        except KeyError:

            raise BugTrackerAuthenticationError(

                self.baseurl, "No credentials found.")

    @ensure_no_transaction

    def _authenticate(self):

        """Authenticate with the remote Bugzilla instance.

        The native Bugzilla API uses a standard (username, password)

        paradigm for authentication. If the username and password are

        correct, Bugzilla will send back a login cookie which we can use

        to re-authenticate with each subsequent method call.

        """

        try:

            self.xmlrpc_proxy.User.login(self.credentials)

        except xmlrpclib.Fault, fault:

            raise BugTrackerAuthenticationError(

                self.baseurl,

                "Fault %s: %s" % (fault.faultCode, fault.faultString))

    def _storeBugs(self, remote_bugs):

        """Store remote bugs in the local `bugs` dict."""

        for remote_bug in remote_bugs:

            self._bugs[remote_bug['id']] = remote_bug

            # The bug_aliases dict is a mapping between aliases and bug

            # IDs. We use the aliases dict to look up the correct ID for

            # a bug. This allows us to reference a bug by either ID or

            # alias.

            if remote_bug.get('alias', '') != '':

                self._bug_aliases[remote_bug['alias']] = remote_bug['id']

    @ensure_no_transaction

    def getCurrentDBTime(self):

        """See `IExternalBugTracker`."""

        time_dict = self.xmlrpc_proxy.Bugzilla.time()

        # The server's DB time is the one that we want to use. However,

        # this may not be in UTC, so we need to convert it. Since we

        # can't guarantee that the timezone data returned by the server

        # is sane, we work out the server's offset from UTC by looking

        # at the difference between the web_time and the web_time_utc

        # values.

        server_web_datetime = time_dict['web_time']

        server_web_datetime_utc = time_dict['web_time_utc']

        server_utc_offset = server_web_datetime - server_web_datetime_utc

        server_db_datetime = time_dict['db_time']

        server_utc_datetime = server_db_datetime - server_utc_offset

        return server_utc_datetime.replace(tzinfo=pytz.timezone('UTC'))

    def _getActualBugId(self, bug_id):

        """Return the actual bug id for an alias or id."""

        # See if bug_id is actually an alias.

        actual_bug_id = self._bug_aliases.get(bug_id)

        # bug_id isn't an alias, so try turning it into an int and

        # looking the bug up by ID.

        if actual_bug_id is not None:

            return actual_bug_id

        else:

            try:

                actual_bug_id = int(bug_id)

            except ValueError:

                # If bug_id can't be int()'d then it's likely an alias

                # that doesn't exist, so raise BugNotFound.

                raise BugNotFound(bug_id)

            # Check that the bug does actually exist. That way we're

            # treating integer bug IDs and aliases in the same way.

            if actual_bug_id not in self._bugs:

                raise BugNotFound(bug_id)

            return actual_bug_id

    def _getBugIdsToRetrieve(self, bug_ids):

        """For a set of bug IDs, return those for which we have no data."""

        bug_ids_to_retrieve = []

        for bug_id in bug_ids:

            try:

                self._getActualBugId(bug_id)

            except BugNotFound:

                bug_ids_to_retrieve.append(bug_id)

        return bug_ids_to_retrieve

    @ensure_no_transaction

    def initializeRemoteBugDB(self, bug_ids):

        """See `IExternalBugTracker`."""

        # First, discard all those bug IDs about which we already have

        # data.

        bug_ids_to_retrieve = self._getBugIdsToRetrieve(bug_ids)

        # Pull the bug data from the remote server. permissive=True here

        # prevents Bugzilla from erroring if we ask for a bug it doesn't

        # have.

        response_dict = self.xmlrpc_proxy.Bug.get({

            'ids': bug_ids_to_retrieve,

            'permissive': True,

            })

        remote_bugs = response_dict['bugs']

        self._storeBugs(remote_bugs)

    def getRemoteStatus(self, bug_id):

        """See `IExternalBugTracker`."""

        actual_bug_id = self._getActualBugId(bug_id)

        # Attempt to get the status and resolution from the bug. If

        # we don't have the data for either of them, raise an error.

        try:

            status = self._bugs[actual_bug_id]['status']

            resolution = self._bugs[actual_bug_id]['resolution']

        except KeyError:

            raise UnparsableBugData(