www.agile42.com                 the ultimate answer to agile                 en • de

Login
Login or Register
Demo Movie: Agilo for Scrum

This short movie will give you a fast overview of the Agilo functionalities: Agilo for Scrum Movie

more...
Efficient & Professional Scrum Implementation

"The motivation in our teams increased and we generate a much faster ROI."

Götz Bernhardi, CEO, Aquin Components

more...
Scrum Roundtable Berlin

Information, Experiences and Fun - that's what you can expect at the Scrum Roundtable in Berlin.

more...
50% Efficiency gained

The clear and easy-to-understand processes of Andrea Tomasini from agile42 played a major role in increasing the "Go to Market"

more...

Agilo for Scrum - Effective Scrum Tool

New Release Agilo for Scrum 0.6

The agile42 Team is proud to announce the new release 0.6 (Final 1.05.2008) of the successful tool "Agilo for Scrum". The documentation and the Wiki on the page https://agilo.agile42.com will be updated soon too.

Started the development of Agilo for Scrum 0.7

Following many of the requests of our "users" we started the porting of Agilo for Scrum to Trac 0.11, and with that we will take the opportunity to improve the following:

Please contribute with suggestions and comments on our Blog, we want to hear from you what do you think and what you need to work better ;-)

Quick Jumps

Be aware of the "Infinite Improbability Drive" side effects...

About Agilo for Scrum

Agilo for Scrum is a simple, web-based and straightforward tool to support the Scrum process. Agilo is based on Trac a very successful and widespread Ticket Tracking System, and developed using the Python programming language. Agilo is distributed as Open Source Software according to the Apache Software License 2.0 and can be

Just register and you will receive further information.

Agilo for Scrum - Details

Agilo extends Trac adding the following capabilities:

Real Ticket typing: Trac supports the creation of different types of ticket, but in the end it shows the same fields for every type and makes no more differences. We love the simplicity of Trac, including its great capabilities to be extended ;-) Thanks to the agilo-types plugin Agilo allows you to define which attributes belongs to which defined type of ticket, allowing much more consistent customization

Agilo Ticket View

Ticket References and Linking: Trac allows to hyperlink any kind of ticket, with some markup work and some automation. We wanted to enforce a bit of rules and structure linking between different types of Ticket so that they can better support the defined process. Linking is important, but more important is to define the semantic behind the linking of two different items. Consider the following example: You have a User Story (ticket) and you want to create a set of Tasks (ticket) to work on this User Story, and having the possibility to keep a relation between the User Story and the Tasks, to monitor changes, keep traceability and having a top-down view as well. What about having the possibility to define into the trac.ini that the User Story type of ticket, can be linked to the Task type of ticket, and having automatically the possibility to create a linked Task to a User Story, from the user interface?. To allow this we implemented the agilo-links plugin, which has the following capabilities:

The [agilo-links] plugin integrates also a new Ticket form, that allows to visualize the tickets in a more clear way, and:

Agilo Ticket Ajax Search

Sprint Data and Burndown Chart: What would be Scrum without it? We implemented a couple of plugins (agilo-scrumdashboard, agilo-sprint-backlog and agilo-charts) that allows an easy an simple implementation of the Scrum process, and particularly supports you in:

Agilo Burndown Chart

Download & Install

In order to install and try Agilo for Scrum you need to have Trac installed, and add some other packages to your Python library. Depending on the platform you are using the Trac installation may range from being trivial, to be tricky (if you will have to compile the whole dependency tree from source... for example), you can find detailed information on the Trac Wiki.

So let's get started:

  1. Download and Install a suitable Python distribution, we suggest you to use the version 2.4 many things in Trac 0.10 have not been really tested through with the newest versions. From the release 0.6-RC4 you can also use python 2.5, but you will have to download the source distribution and build the eggs yourself. If you plan to use SQLite database - the default trac installation choice - than consider using python2.5 which integrates sqlite3 libraries as a standard package.

  2. Download the appropriate Trac packages for your platform and follow the instruction on the Trac Download page. Please download the stable release (0.10.4) the plugins have not been tested yet with the new development version. We plan to migrate to the new version of trac 0.11 and the Genshi template engine as soon as agilo 0.6 will be released and trac 0.11 will be released.

  3. Install and configure Trac according to your needs, please follow the old Trac install guide, referring to version 0.10.4.

  4. Wow! if you have Trac already running you are almost done, we suggest do download and install also the great setuptools from PEAK, just run the following script: ez_setup.py and you'll get a lot easier life in installing Python packages.

  5. Register to our website and go straight to the Download section. Download all the python eggs and copy them into the plugin directory of your Trac project, or directly in the site-packages directory of your Python distribution. For convenience you can download the archive format agilo-latest.tar.gz containing all the plugins. It is available also the source distribution agilo-source-latest.tar.gz, including the build script (build_eggs.py). Both distributions contain now also a script to ease the initial configuration of Roles and access rights (create_roles.py). To get more info on the scripts, just launch them with the -h option... trivial isn't it?

  6. Enable the components in the trac.ini or via the Trac WebAdmin. To enable the plugins add to the [components] section of your project configuration file the following lines: 

    [components]
agilo_charts.* = enabled
agilo_import.* = enabled
agilo_links.* = enabled
agilo_scrumdashboard.* = enabled
agilo_sprint_backlog.* = enabled
agilo_sprint_data.* = enabled
agilo_theme.* = enabled
agilo_types.* = enabled
agilo_wrapper.* = enabled
trac.ticket.web_ui.newticketmodule = disabled
trac.ticket.web_ui.ticketmodule = disabled

    The last two lines are disabling the standard ticket handling of Trac and replacing it with the Agilo version, including also the tabbed pane and the links visualization.

  7. Remember that once the Trac server will be restarted you will need to perform an upgrade operation to correctly creates all the tables needed for the plugins to work. Normally you should see the message in the console telling you to run the upgrade command, something in the form: $ trac-admin <project_environment> upgrade. If you are using MySQL or PostgreSQL you may add the --no-backup parameter. Keep in mind that MySQL support is still experimental, due to many issues in the python bridge module, we try to keep it up to date, but still some problems may occur. For more information check directly the Trac Wiki Page

  8. Now you can configure the various plugins to support Scrum, even if since Agilo 0.6 the plugins are auto-configuring with some default parameters. You will need to edit your project trac.ini file, situated in <project_environment>/conf/trac.ini and restart Trac after the changes. Following some configuration examples, provided for your convenience.

  9. Have fun, and let us know what you think about it ;-)

  10. If you want to configure also the Subversion integration, that gives you the possibility of doing some operations via subversion comments, follow the instructions in the Subversion Integration section.

VMWare Virtual Machine

Now that the development of Agilo for Scrum 0.6 is completed, it is available also a VMWare Virtual Machine, running Linux Ubuntu Server 7.0 and with a complete pre-installed and working Agilo for Scrum 0.6. You can download it here please read through the Readme.txt and if you have problems with the eth0 interface, and the indication in the Readme.txt are not helping you, you can have a look to this thread.

Sample Configurations

Trac comes with the built-in capability to support customized fields for a Ticket, you can define your own fields creating a [ticket-custom] section into the trac.ini. For Agilo to work properly you will need to define the following:

NOTE: For "upgraders" be aware that the burndown table on the database is changed, you will have to perform an alter table or drop the table and let agilo recreate it for you. The table schema changed, renaming a column from date to day cause was clashing with some database specific functions. If you want to migrate the configuration from the previous version of Agilo, just edit your trac.ini file and replace the following: charts is now agilo-charts, links is now agilo-links, filteredticket is now agilo-types. Once you changed the sections, run the trac-admin <env> upgrade (--no-backup) and only the new keys will be added to the existing sections. 

[ticket-custom]  
drp_resources = text  
drp_resources.label = Resources

This field will contain the comma (,) separated list of users working on a task, it will be used by Agilo to calculate the workload for each resources within each Sprint. In case there is no owner assigned to a Task and resources are specified, the first resource in the list is promoted to the owner. 

i_links = text
i_links.label = Referenced By
linking_src = text
o_links = text
o_links.label = References

These fields are needed to store information related to the links between different tickets. More specific information on how to configure the agilo-links plugin are here. 

rd_points = select
rd_points.label = RD Points
rd_points.options =  |0|1|2|3|5|8|13|20|40|100
rd_points.order = 4
rd_points.value =

The rd_points field represent the User Story Points or Ideal Days that will be needed to complete and ship a specific User Story. If you want to know more about User Stories and their inventor Mike Cohn visit his website http://www.mountaingoatsoftware.com. The example uses the traditional Fibonacci-like non-linear sequence for Story Points, if you want to use Ideal Days, you can change the field in text and leave people free to put whatever number in it... or define your own sequence. 

remaining_time = text
remaining_time.label = Remaining Time

This fields represent the Estimated Remaining Time to complete a Task. It should be updated by the resources working with on a task, or by the ScrumMaster.

agilo-types Plugin

The agilo-types plugin, enables you to really define Ticket Types and show for that Ticket Type only some specific fields, beside the mandatory ones. To configure this plugin you will need to add the following section to your trac.ini: 

[agilo-types]
bug = milestone, owner
task = drp_resources, remaining_time, milestone, owner, 
story = owner, milestone, rd_points, reporter

On the left side are the defined Ticket Types (remember to create them using Trac admin interface or WebAdmin). For support Scrum you will need at least the following types: bug, task, story, if you want you can add also impediment so the ScrumMaster will have something to track impediments as well.

Agilo supports now also the definition of aliases for the ticket types, in some situation you make like to rename story, requirement, task, and bug to your specific needs, without breaking apart agilo. To do this you can now use the alias extension in the agilo-type sections as follows: 

[agilo-types]
bug.alias = Something to correct
requirement.alias = Something to make
story.alias = User Story
task.alias = Something to do

The agilo-links plugin, enables you to enforce a bit of structure on how to handle ticket dependencies, and allows you to define which kinds of links are allowed and which not. Moreover the agilo-links plugin offers some more functionalities to calculate aggregated property's values out of all the referenced tickets. To enable the agilo-links plugin you will need to add the following to your trac.ini: 

[agilo-links]
allow = story-task, bug-story, bug-task
bug.task.calculate = remaining_time=sum:remaining_time
bug.task.copy = milestone, owner
bug.task.show = remaining_time, owner
story.task.calculate = remaining_time=sum:remaining_time
story.task.copy = milestone
story.task.show = remaining_time, owner

The allow keyword define which pair of links are allowed, any other pair will not be allowed. This means that you will be able to create links only between story and task and in this direction, because the links are directional, the left side is the source and the right side is the destination. This reflects also the link search (in the Edit pane of a ticket) that will restrict the search only to the ticket of the right type.

The other properties should be read in the following way: source.destination.copy = [list of fields], means that when a linked item will be created, automatically all the listed fields will be copied from the source of the link to its destination. For example: 

bug.task.copy = milestone, owner

means that when creating a linked task from the Edit pane of a bug, the fields milestone and owner will be copied from the bug to the task. The calculate property: source.destination.calculate = [source_property]=[operator]:[destination_property], means that the defined source_property will not be read from the ticket, but calculated, using the operator from all the destination_property of the linked tickets. For example: 

story.task.calculate = remaining_time=sum:remaining_time

will calculate the remaining_time of a story (not that according to our configuration the remaining_time is not at all a story field) as the sum of all the linked tasks remaining_time.

Since Agilo 0.6 RC4 there is also the source.destination.show = [list of fields], that let's you specify which fields to show in the link preview on a ticket page. For example, if you are in a User Story, you can decide which fields you want to see on the linked tasks, assuming you are interested in remaining_time and owner of a task, than you will have to write: 

story.task.show = remaining_time, owner

The reason why it has been made configurable is to allow you the flexibility of showing any custom field you define in your specific meta-model definition.

Another new feature of Agilo 0.6 RC4 is the possibility to configure the links cache, that by default is set to cache links endpoints for 1500ms (1,5 sec.), and is set to cache also all the related first level tickets. There are now two new parameters for the cache in the agilo-links plugin: 

[agilo-links]
cache.timeout = 0 #milliseconds to cache timeout
cache.related = False #disable the caching of related tickets

The cache.related basically prefetch into the cache the next level of links if available, to serve it very fast when navigating to the next ticket. The prefetch also increase the performance of showing the optional fields on the link to other tickets. If you experience problems with the caching, like links disappearing and reappearing, than disable the cache. To be sure it is a cache problem, and not your browser cache or your proxy cache, reload the page first ;-)

Since Agilo 0.6 RC6 the attribute source.destination.sort = [list of properties] has been added. It sorts the outgoing links visualized into a ticket page. The default sorting is done by ticket summary, but the sorting is stable, therefore you can add additional parameters. For example the following configuration: 

[agilo-links]
...
requirement.story.sort = story_priority:desc, rd_points:desc

would sort the outgoing links of type story into a requirement ticket page first by summary, than by story_priority (decrescent), and finally by rd_points (decrescent). Since this version, the requirement as been added as a standard type and the property configuration is now done automatically. If you are upgrading from a previous version, remember that agilo will not override the properties already set, but will had the new ones. To avoid problems, we suggest you to create a dummy project, configure the component section to load agilo plugins, and run a trac-admin upgrade. This will update the trac.ini file with all the new settings, than you can marge them into your real project configuration.

agilo-scrumdashboard Plugin

This plugin is creating an overview page with all the links related to Scrum specific functionalities, so that the user of the system will be easily able to perform the most common operations. For example on the Scrum Dashboard you'll find the following shortcuts:

In the dashboard there are now some statistical charts showing you at a glimpse the Burndown chart for the current sprint (calculated based on the next due milestone) as well as statistics on the number of planned and closed tickets. Resources load is also provided to help the team understanding very fast if there is a particular team member that is too much loaded with work.

agilo-charts Plugin

The agilo-charts plugin is used to generate images at runtime, in particular is used to generate the Burndown chart and the statistical charts for a specific sprint. The plugin is using three external libraries, that you should make sure to install before being able to generate any chart. These libraries are:

that if you are lucky will be installable directly from your command prompt using the easy_install utility: 

$ easy_install numpy PIL matplotlib

For windows platform there are pre-compiled versions of both libraries, particularly important is to download one that is compatible with your Python distribution and contains the AGG backend (used by the plugin to generate antialiased PNG images, with easy_install should work fine).

In case the easy_install program will give you trouble in installing the above library, in particularly the PIL complaining about an unmatched required version, try the following (thanks to Tibor Gemes): 

$ easy_install --find-links \
http://www.pythonware.com/products/pil/ Imaging

For matplotlib you can also help easy_install to find the right version in the same way: 

$ easy_install --find-links \
http://sourceforge.net/project/showfiles.php?group_id=80706 matplotlib

Please remind that you will need the latest version of matplotlib (0.91.2), so if you have a linux distribution, make sure the distribution package is the right version, or install using easy_install as described above.

The Chart plugin can be configured to display images at a specific size, so that it will better fit to your company screen resolution. For example: 

[agilo-charts]
burndown.height = 480
burndown.width = 1080

will generate images 1080x480, keep in mind that depending on the layout you are using (for example with agile42 theme, see ThemeEnginePlugin for more details) it may result in page scrolling, and limit usability. These sizes are used as a standard, in case there will be no specific size paramaters on the URL (you can add width= and height= to specify the width and height in pixels).

Since Agilo 0.6 there is also a Wiki Macro available, that let's you embed charts into the wiki pages. To use it add the following into your wiki page: 

[[AgiloChart(<chart-type>, <milestone>, [<width>x<height>])]]
The available <chart-type> are:
    burndown
    sprint_tickets
    sprint_resources
The <milestone>:
    has to be limited by "" in case it contains a space in the name,
The <width> and <height>:
    are integer expressing the size in pixels

The Burndown chart generated will show the Sprint elapsed time, highlighting the weekends with a silver background, and showing the ideal burndown line (excluding the weekends), the actual burndown (calculated also during the weekend, in case someone is working) and the average trend with one day of forecast, showing the tendency given the actual burndown rate.

Subversion Integration

The agilo Subversion Integration, add some features to allow you to change the status of a ticket via the Subversion submit comment, as well as letting you change the remaining_time of a task. To configure it, you will have to activate the two hooks in the subversion repository. To do so, go to your subversion project root, and have a look inside the hooks folder. There you should find a set of sample scripts, you will have to bind agilo script agilo_svn_commit_hook.py to both the pre-commit and the post-commit hooks.

Examples on how to create these two scripts are provided in the comments of the agilo_svn_commit_hook.py script. The simplest possible examples could be the following: 

<pre-commit>
#!/bin/sh
REPOS="$1"
TXN="$2"
# Make sure that the log message contains some text.
SVNLOOK=/usr/bin/svnlook
PYTHON_EGG_CACHE=/var/cache/python
TRAC_ENV="/var/lib/trac/test"
LOG=`$SVNLOOK log -t "$TXN" "$REPOS"`
/where/ever/is/agilo_svn_hook_commit.py -s pre -e "$TRAC_ENV" \
-l "$LOG" || exit 1

And the post commit hook: 

<post-commit>
#!/bin/sh
REPOS="$1"
REV="$2"
TRAC_ENV='/var/lib/trac/test/'
/var/lib/svn/local/hooks/agilo_svn_hook_commit.py -s post \
-e "$TRAC_ENV" -r "$REV" || exit 1

For more info on how to configure and use Subversion hooks, refer to the Subversion books or online groups. The agilo scripts supports the following commands, some of which are included as a compatibility with the trac-post-commit-hook.py which is a part of the contrib distribution of subversion: 

CLOSE COMMANDS  = 'close', 'closed', 'closes', 'fix', 'fixed', 'fixes'
REFER COMMANDS  = 'addresses', 're', 'references', 'refs', 'see'
REMAIN COMMANDS = 'remaining', 'still', 'rem_time', 'time', 'rem'

Commands can be concatenated using and or & and are in the form of: 

This closes #34 and #35 and remaining #5:4h. See #43 for more details.

The above comment will do the following:

Roles and Access Rights

Some of the plugins make use of specific Access Rights, that must reflect the user configuration into the Trac permission database. You can configure the access right using both the trac-admin command line tool or the web based WebAdmin plugin. We suggest you to create some "Groups" and than associate users to one or more Groups to reflect the User - Role mapping. There is a script (create_roles.py), in both source and binary distributions, that creates the initial set of groups. The script is not intrusive therefore it is not deleting existing configurations.

For example: 

$ trac-admin <env> permission add scrum_master DRP_SCRUMASTER
$ trac-admin <env> permission add team_member DRP_TEAM_MEMBER
$ trac-admin <env> permission add product_owner DRP_REQUIREMENT

Creates ACL principals and than: 

$ trac-admin <env> permission add bill scrum_master
$ trac-admin <env> permission add jennifer product_owner
$ trac-admin <env> permission add tom team_member
$ trac-admin <env> permission add mary team_member
$ trac-admin <env> permission add john team_member

Assign real users to the roles, you will have to manage also the standard access rights in the same way, we suggest to create to high classes of users: anonymous and authenticated and assign to these to the basic ACLs, than when you create the Scrum roles, add also the authenticated group, than Trac will make the right association putting all the ACLs together (using AND operation).

Remember to create also one user with TRAC_ADMIN right if you want to use the WebAdmin interface.

Last but not Least

There are many third parties plugins that you can install in Trac, we normally use the following:

Please remember that the software is Open Source and distributed using the Apache Software License 2.0 therefore you may use it as-is and at your own risk ;-) For any feedback or problem please contact us.

Support & Maintenance

If you need help installing or customizing Agilo for Scrum we offer several services to support you. Just send us an email to find out more!!!

©2007 agile42, all rights reserved | last updated: May 6, 2008 | Imprint