Merge lp:~russell/ibid/jira-plugin into lp:~ibid-core/ibid/old-trunk-1.6

[Russell Cloran]

[Russell Cloran (russell)]

I suspect that there will be quite a lot of feedback here ;)

[Michael Gorven (mgorven)]

Good enough for now (despite the scary caching).
 review approve

review: Approve

[Stefano Rivera (stefanor)]

I can't comment too much on it, as I don't know jira. But besides from being scary, this is an OK plugin.

It is a bit messy though:
* Your editor leaves empty lines with whitespace in them
* Commented out bits of code
* Unneeded imports
* regex substitution that should probably be re.escaped()ed

So here's a grudging approve

review: Approve

[Jonathan Hitchcock (vhata)]

This needs fixing to work with generic Jira instances - I will run it against Yola's Jira and debug it for a bit (it doesn't work right now, ootb).

review: Needs Fixing

[Stefano Rivera (stefanor)]

Can you add a copyright header to the top (see any other file in current trunk)

Also, the @cached issue is fixed now.

review: Needs Fixing

[Max Rabkin (max-rabkin)]

Needs to migrate to new-style help.

review: Needs Fixing

Unmerged revisions

821. By Russell Cloran on 2010-01-03

Fix usage information

820. By Russell Cloran on 2010-01-03

Use the new-ish conflate stuff

819. By Russell Cloran on 2010-01-03

First pass at a Jira plugin

=== added file 'ibid/plugins/jira.py'
--- ibid/plugins/jira.py	1970-01-01 00:00:00 +0000
+++ ibid/plugins/jira.py	2010-01-03 15:50:26 +0000
@@ -0,0 +1,249 @@
+import logging
+import re
+from collections import defaultdict
+from datetime import datetime
+
+import suds.client
+
+import ibid
+from ibid.plugins import Processor, handler, match, RPC
+from ibid.config import Option, BoolOption
+from ibid.utils import ago
+
+help = {'jira': u'Retrieves tickets from a Jira instance.'}
+
+class LoginError(Exception):
+    pass
+
+class cached(object):
+    def __init__(self, property=None):
+        self._property = property
+    
+    def __call__(self, method):
+        self._method = method
+        if self._property is None:
+            self._property = '_' + method.__name__
+        return self
+    
+    def __get__(self, instance, owner):
+        if getattr(instance, self._property, None):
+            return getattr(instance, self._property)
+        
+        setattr(instance, self._property, self._method(instance))
+        return getattr(instance, self._property)
+    
+    def __set__(self, instance, value):
+        setattr(instance, self._property, value)
+
+def exceptional_response(m):
+    def inner(self, event, *args, **kwargs):
+        try:
+            return m(self, event, *args, **kwargs)
+        except LoginError:
+            event.addresponse(u"I couldn't log in to Jira")
+        except Exception:
+            raise
+    
+    return inner
+
+class JiraProxy(object):
+    """
+    This proxy object looks like a bit of overkill that could just live in
+    the Processor, but... A Processor's setup() should be as minimal as
+    possible, so we want to make cached information (the list of projects,
+    statuses, versions, etc) lazily loaded.
+    
+    Unfortunately, the default Processor looks at all attributes to search
+    for handlers (and clock event handlers), and so even if the lazily
+    loaded information lived on the processor, it would be loaded the first
+    time anybody queries the bot (no matter which plugin), so we instead
+    move it to a separate object.
+    """
+    query_template = r"^(?:(my|\S+?(?:'s))\s+)?(?:(%(statuses)s)\s+)?tickets(?:\s+for\s+(.+?))?(?:(?:\s+ver\w*)?\s+(.+?))?$"
+    def __init__(self, processor, url, username, password):
+        logging.getLogger('suds').setLevel(logging.WARN)
+        self.processor = processor
+        self.client = suds.client.Client(url + 'rpc/soap/jirasoapservice-v2?wsdl')
+        self.username = username
+        self.password = password
+        self.tok = ''
+        
+        # Ticket information
+        self.priorities = None
+        self.statuses = None
+        self.types = None
+        
+        # Projects components and versions
+        self.projects = None
+        self.components = None
+        self.versions = None
+    
+    def call(self, method, *args, **kwargs):
+        if not self.tok:
+            try:
+                self.tok = self.client.service.login(self.username, self.password)
+            except Exception, e:
+                raise LoginError
+        
+        try:
+            return getattr(self.client.service, method)(self.tok, *args, **kwargs)
+        except suds.client.WebFault, e:
+            if e.fault.faultstring.startswith('com.atlassian.jira.rpc.exception.RemoteAuthenticationException'):
+                try:
+                    self.tok = self.client.service.login(self.username, self.password)
+                except Exception:
+                    raise LoginError
+                else:
+                    # Don't recurse, silly
+                    return getattr(self.client.service, method)(self.tok, *args, **kwargs)
+    
+    @cached()
+    def client(self):
+        return suds.client.Client(self.url + '/rpc/soap/jirasoapservice-v2?wsdl')
+    
+    @cached()
+    def priorities(self):
+        return dict([(p.id, p.name) for p in self.call('getPriorities')])
+    
+    @cached()
+    def statuses(self):
+        statuses = dict([(s.id, s.name) for s in self.call('getStatuses')])
+        status_alts = "|".join(statuses.values())
+        self.processor.handle_list.im_func.pattern = re.compile(self.query_template % {'statuses': status_alts}, re.IGNORECASE)
+        return statuses
+    
+    @cached()
+    def types(self):
+        return dict([(t.id, t.name) for t in self.call('getIssueTypes')])
+    
+    @cached()
+    def projects(self):
+        projects = dict([(p.key, p) for p in self.call('getProjectsNoSchemes')])
+        
+        proj_alts = "|".join(projects.keys())
+        self.processor.get.im_func.pattern = re.compile(r'^(?:ticket\s+)?((?:%s)-\d+)$' % proj_alts)
+        
+        return projects
+    
+    @cached()
+    def components(self):
+        tmp = defaultdict(list)
+        for p in self.projects.values():
+            p.components = self.call('getComponents', p.key)
+            for component in p.components:
+                tmp[component.name].append(p.key)
+        
+        return tmp
+    
+    @cached()
+    def versions(self):
+        tmp = defaultdict(list)
+        for p in self.projects.values():
+            p.versions = self.call('getVersions', p.key)
+            for version in p.versions:
+                tmp[version.name].append(p)
+        
+        return tmp
+    
+    def get_ticket(self, tag):
+        try:
+            return self.call('getIssue', tag)
+        except suds.client.WebFault:
+            return None
+    
+    def query(self, query, n=10):
+        return self.call('getIssuesFromJqlSearch', query, n)
+
+class Tickets(Processor): #, RPC):
+    u"""ticket <ticket key>
+    <ticket key>
+    <my|<who>'s> <status> tickets <for (project|component)> <ver version>"""
+    feature = 'jira'
+    priority = 250
+    url = Option('url', "URL of Jira instance")
+    username = Option('username', "Jira account username")
+    password = Option('password', "Jira account password")
+    default_project = Option('default_project', "Default project for searches which don't specify a component or project")
+    
+    # source = Option('source', 'Source to send commit notifications to')
+    # channel = Option('channel', 'Channel to send commit notifications to')
+    # announce_changes = BoolOption('announce_changes', u'Announce changes to tickets', True)
+
+    def __init__(self, name):
+        # RPC.__init__(self)
+        self.log = logging.getLogger('plugins.jira')
+        Processor.__init__(self, name)
+        self.j = JiraProxy(self, self.url, self.username, self.password)
+    
+    def setup(self):
+        self.get.im_func.pattern = re.compile('^(%s-\d+)$' % (self.default_project, ))
+        # TODO: Should be able to update the Jira proxy if any config changed
+    
+    @handler
+    @exceptional_response
+    def get(self, event, tag):
+        ticket = self.j.get_ticket(tag)
+        
+        if ticket:
+            try:
+                fixVersion = 'for %s ' % ticket.fixVersions[0].name
+            except:
+                fixVersion = ''
+            event.addresponse(u'Ticket %(key)s (%(status)s %(priority)s %(type)s in %(component)s %(fixVersion)s'
+                u'reported %(ago)s ago assigned to %(owner)s: "%(summary)s" %(url)s', {
+                'key': ticket.key,
+                'status': self.j.statuses.get(ticket.status, 'Unknown'),
+                'priority': self.j.priorities.get(ticket.priority, 'Unknown'),
+                'type': self.j.types.get(ticket.type, 'Unknown'),
+                'component': ", ".join([c.name for c in ticket.components]),
+                'fixVersion': fixVersion,
+                'ago': ago(datetime.now() - ticket.created, 2),
+                'owner': ticket.assignee,
+                'summary': ticket.summary,
+                'url': '%sbrowse/%s' % (self.url, ticket.key),
+            })
+        else:
+            event.addresponse(u"No such ticket")
+    
+    @match(r"^(?:(my|\S+?(?:'s))\s+)?(?:(open|closed|review)\s+)?tickets(?:\s+for\s+(.+?))?(?:(?:\s+ver\w*)?\s+(.+?))?$")
+    @exceptional_response
+    def handle_list(self, event, owner, status, component, version):
+        status = status or 'open'
+        if status.lower() == 'open':
+            statuses = ("Accepted", "Assigned", "In Progress", "New", "Open", "Reopened")
+        else:
+            statuses = (status.lower(),)
+        
+        query = "status in (%s)" % (", ".join(['"%s"'%s for s in statuses]))
+        
+        if owner:
+            if owner.lower() == 'my':
+                owner = event.sender['nick'].lower()
+            else:
+                owner = owner.lower().replace("'s", '')
+            query += " and assignee='%s'" % (owner, )
+        
+        if not component:
+            component = self.default_project
+        
+        # This should have some way of specifying project and component
+        # so that two projects with the same name components can be distinguished.
+        if component in self.j.projects:
+            query += " and project='%s'" % (component, )
+        elif component in self.j.components:
+            query += " and component='%s'" % (component, )
+        
+        if version:
+            query += " and (affectedVersion='%s' or fixVersion='%s')" % (version, version)
+        
+        tickets = self.j.query(query, 10)
+        
+        if len(tickets) > 0:
+            if owner:
+                 event.addresponse(u'\n'.join(['%s: "%s"' % (ticket.key, ticket.summary) for ticket in tickets]), conflate='; ')
+            else:
+                event.addresponse(u'\n'.join(['%s (%s): "%s"' % (ticket.key, ticket.assignee, ticket.summary) for ticket in tickets]), conflate='; ')
+        else:
+            event.addresponse(u"No tickets found")
+
+# vi: set et sta sw=4 ts=4: