Redmine. Configure jabber alerts in 5 minutes

Redmine is an excellent project management and bug tracking system. However (from my personal experience of use), she is not able to build a self-organizing error control system in the working team. Developers are too busy to keep track of all comments related to their tasks; on the other hand, the author who created this or that task rarely peers into it. In cases where the task is set incorrectly or needs to be clarified, the dialogue between the performer and the author may be delayed, because the discussion is sluggish. Because of this, the tracker list turns into a garbage dump of irrelevant tasks. It becomes easier to solve the problem directly, without resorting to Redmine. The effectiveness of such a system is small.

It is worth saying that it is the self-organizing system that interests me. Surely, you can hire some specialist who will kick developers to look into the tracker more often, ring up users, etc. But in the realities of small companies, this is a luxury. Therefore, it seems to me that this problem needs to be solved through some kind of notification mechanism.

Immediately, the problem can be solved as follows:

• Redmine is able to send alerts by mail. In principle, what you need, but has several disadvantages: first, no one will check email every five minutes; secondly, this notification feature can be disabled by the user; in the absence of corporate mail, such notification letters rush to the spam section.
• An extension for the IDE, for example mylyn for Eclipse. Unfortunately, it solves the problem only from one end: ordinary users do not have any IDE. But for developers it gives the broadest opportunities to work with Redmine straight from the IDE. Probably, this is even the best option (for developers) if the company is able to deploy a workplace with an IDE preinstalled and a customized extension.
• Alerts via jabber or icq.

For Redmine there is an interesting jabber-bot orangutan . This is an ambitious project, the goal of which is to organize work with Redmine via the jabber protocol. In an ideal world, you can: close, create, and comment on tasks by simply sending command messages in human language. But it is in an ideal world. But in real life there are difficulties in setting up, the commands are fixed, there is no talk of a human language. In addition, for the bot to work on Redmine, you need to roll a plugin, written for some shaggy version. And the main disadvantage: support only English.
')
Unfortunately, I didn’t find any other features for organizing jabber alerts for Redmine. I had to create my own service alerts.

"Send2me" alert service

As I wrote earlier, Redmine is able to send email alerts about changes in tasks. Taking advantage of this opportunity, you can implement sending jabber-notifications by directly sending e-mail messages to a list of jabber-addresses. Based on this idea, send2me.org appeared.

After registration, each user receives a personal mailbox, for example, “mail@send2me.org”. Any message sent to this email inbox is sent to the list of jabber contacts according to the created rules. The service provides a simple interface to describe the rules for selecting messages for distribution. Rules are described by conditional jump blocks, regular expressions, and a routing table. These three components make it possible to describe an arbitrarily complex rule for sending messages. However, creating a rule for sending alerts from Redmine is a trivial task, thanks to the built-in templates.

So, let's set up jabber-notifications for Redmine:

1. We register at send2me.org and get a personal mailbox, for example “mail@send2me.org”.

2. In Redmine, we create a user who will listen to all alerts, and specify “mail@send2me.org” as his email address. Thus, we ensure that all changes in the tasks will be sent to the specified mail.

3. Now we need to create a rule for processing messages Redmine. To do this, go under your user to send2me.org and click on the “Add” button in the “Rules” section.



In the form for editing the rule, specify the “Redmine” template.



Go through the points that need to be changed.

• In the first block (the red number “1” in the image) we discard all messages that do not come from Redmine. This is done by a regular expression:
  

    $ header {'X-Redmine-Host'} = ~ /^yourredminehost.com$/ 

  Accordingly, instead of " yourredminehost.com " you should enter the host of your Redmine.
• In the second block, we discard all messages not from our project. The regular expression is used:
  

    $ header {'X-Redmine-Project'} = ~ / ^ identifier $ / 

  where " identifier " is the project identifier in Redmine. This block is optional - if you delete it, you will receive messages from all projects.
• Finally, in the third block, you need to fill in the correspondence table of Redmine users and their jabber contacts.

Note: to determine the recipients of the message headers are used, which generates Redmine.

         ($ header {'X-Redmine-Issue-Author'}, 
           $ header {'X-Redmine-Issue-Assignee'}, 
           split (';', $ header {'X-Redmine-Watchers'})) 

Unfortunately, Redmine does not add task observers to the message header. Therefore, out-of-the-box alerts will only come to task authors and assigned performers. To identify observers use the additional header " X-Redmine-Watchers ". To make it work, you need to install a simple plugin for Redmine (it does not require any migration, nor any manipulations with the Redmine configuration).

This completes the procedure for configuring jabber-alerts Redmine. Further for those who are interested, I will describe the architecture of the service send2me.org

Alert service architecture

The figure shows a schematic diagram of the organization of such a service.



Any letter received by e-mail is processed as follows:

• Postfix - receives the received message and forwards it to the named pipe. Postfix is ​​configured in such a way that it redirects only messages from users for whom there is an entry in the send2me.org database (i.e. for registered users) to the pipe. The remaining messages are deleted.
• Rule processor (rule handler) - retrieves the message from the named pipe and applies a set of user rules to it. If the message is not discarded according to the rules, then it is prepared for sending to jabber contacts and redirected to the next named pipe.
• Ejabberd module (bot) - retrieves the message from the named pipe and sends it.

A separate link is web crud , written in Dancer and intended to create and edit custom rules.

Attachments of letters are not processed by the service, but are cut when received using renattach .

I find it difficult to assess the performance of such an architecture: postfix and ejabberd are well-known high-quality products. I suppose the narrow part is the parts of the system I wrote in perl. I think, rather quickly habraeffekt will fall down my nischebrodsky server (1Ghz & 512MB), but on service of really interested users it quite will be enough.