Tracking multiple OpenStack projects using StoryBoard
StoryBoard is a new task tracking system which is aimed at the systems where projects are closely related, and OpenStack is definitely a good example of that. In inter-related systems like OpenStack, a feature or a bug usually affects more than one project, so it should be tracked simultaneously across those projects. The proof-of-concept was presented in the Havana release cycle by OpenStack release manager Thierry Carrez, and active development started during the Icehouse development cycle. The project is now driven by three major contributor companies: the OpenStack Foundation, Mirantis, and HP.
As you would expect, StoryBoard manipulates Projects and Users in a way similar to other task trackers. (The Project Groups API is partially implemented, but it will allow a better tracking experience.)
In this article, we'll look at the basic components of StoryBoard, how it's structured, and where it's going.
The Structure of StoryBoard
StoryBoard introduces two basic models designed for task tracking in an inter-related projects system: stories, and tasks.
Stories are the objects that represent feature requests or bug reports. A Story does not belong to a single Project. It describes, in general terms, what should be done overall. The Story is a place for a discussion, so all Users can to post comments under the Story. When it's clear what should be done to complete a Story, the Tasks can be created.
Whenever a change to a Story happens, such as a status change or he assignment of a related Task to a User, that change is displayed in the Event TimeLine under the Story.
A Task is an atomic change that should be made to a single project to progress a Story. A project can have as many tasks as necessary to implement a single Story. Each Task has its own independent status, and can be assigned to a different User working on one Story. The Story also has a status, which is calculated automatically depending on the status of each of the tasks inside it.
Those are the concepts that are already implemented. The Web-UI is available at https://storyboard.openstack.org.
There are a few OpenStack Infra projects which are tracking their tasks using StoryBoard: Nodepool, Zuul and more joining right now. Also, StoryBoard has it's own tasks tracked inside StoryBoard.
The StoryBoard project itself
If we dive a bit deeper inside StoryBoard as a project, we find that there are actually two projects: the REST API server, and the web client.
StoryBoard REST API server
Like most OpenStack projects, StoryBoard provides a REST API server that other projects and applications can call.
Also like most other OpenStack projects, the packaging and installation processes are managed with tox and pbr, and the dependencies are in sync with the rest of OpenStack. Structurally, the main pieces of the StoryBoard server are:
SQLAlchemy, responsible for ORM and database communications.
Alembic, to handle migrations
The API itself, based on Pecan/WSME bindings
Oslo.config and other Oslo libraries
The REST API is used by the Web client.
StoryBoard Web client
Even with all of this functionality in place, there a number of tasks that remain before StoryBoard will be a full featured task tracker, and design discussions are ongoing.
For example, StoryBoard needs a RBAC mechanism to allow project managers control their own projects, and anyone making use of StoryBoard, such as a developer or manager, needs the ability to prioritize tasks and stories. Obviously those priorities are going different when considered from different perspectives.
Also, being a Task tracker, StoryBoard can’t live without a fast and reliable search mechanism. The Elasticsearch framework has been proposed to handle that, but details are still under discussion.
Lastly, but still important, StoryBoard needs subscription/notification functionality to enable Users to subscribe to changes that interest them.
If you're interested in seeing it in action, along with Zuul and Nodepool, StoryBoard has a special sandbox Project where Users can create tasks to see how it all works.
Both the API and the Web client are tested on the OpenStack CI infrastructure. If the tests pass, the commits are automatically continuously deployed to storyboard.openstack.org. So you are always going to see the latest StoryBoard there.
You can also get a feel for the project by viewing this demo: