- Kunagi Developer Guide
- Setting up the development environment
- Get ilarkesto and kunagi projects from GitHub
- Building and running Kunagi from Eclipse
- Building a .war file
- Architecture Overview
Kunagi Developer Guide
Setting up the development environment
Get ilarkesto and kunagi projects from GitHub
Kunagi is hosted on the social coding platform GitHub, so you can download the sources from there:
If you plan to contribute, you should get an GitHub account and clone the projects like described in the Collaborating section.
Building and running Kunagi from Eclipse
Download dependencies by executing the
update-libs.bsh script in the ilarkesto directory. Windows users have to download ilarkesto-lib.zip manualy and extract its contents into the
ilarkesto project directory.
Open ilarkesto and kunagi as projects in Eclipse.
Start Kunagi with Eclipse by running
ScrumGwtApplication.windows.launch from the kunagi project.
To compile and run unit tests, install the TestNG Eclipse plugin.
Building a .war file
If you want to test your changes as a real web application, you need to install Ant and execute it in the kunagi project directory:
This will create
kunagi.war in the build directory. You can put this file into the webapps directory of your web application server. We recommend Tomcat 6.
Clone projects from GitHub
Create a GitHub account.
Install Git on your computer:
sudo apt-get install git-gui
Windows users can follow this tutorial.
Set username and email in git:
git config --global user.name "Full Name" git config --global user.email "email@example.com"
Make sure to add a public key to your Git account following the instruction on generating SSH keys if you don't already have one. Now you can create local clones of ilarkesto and kunagi in your workspace directory:
git clone https://github.com/your-github-name/ilarkesto.git git clone https://github.com/your-github-name/kunagi.git
Commit changes to your local git repository:
git add . git commit -am "my commit comment"
Push changes to your remote repository on GitHub:
Inform us about your changes using the Pull Request button on GitHub, so we can, should we agree that it makes sense in the overall concept of Kunagi, integrate your patch. Issues with Kunagi can be discussed using the issue system on Kunagi website, while discussions about created patches may be held in the commit comments on GitHub.
To keep your copy of Kunagi up to date, pull changes from our repository to yours:
git pull git://github.com/Kunagi/kunagi.git master
More infos here: Forking a project on GitHub
The client sources are Java files in
ScrumGwtApplication. Every single user runs his own instance of the client.
The server source files are placed in
src/main/java/scrum/server/.... The entry point is
The client communicates with the server through asynchronous service calls. Every service call returns the same
DataTransferObject to the client, which contains data for the client. It can even contain data, which has nothing to do with the service call. This could be entities, which were modified by other clients.
The server manages all active clients with
Conversation objects. These conversations contain the
DataTransferObject. New data can be put into the transfer object at any time. It gets transferred to the client with the next service call.
Service calls are implemented in the
ScrumServiceImpl class and run on the server.
See Model Driven Architechture for creating service calls.
Entities are persistent objects. For every entity, there are two implementations. One on the server and one on the client. They always have the same class name, only the package differs.
When entity properties are changed on the client, the framework triggers the
ChangePropertiesServiceCall immediately. This service call sends the changes to the server, which updates the server instance and sends the changes to all other active conversations/clients.
On the server, on startup, all entities are loaded from XML files into memory. When entity properties are changed, the framework saves the modified entities back to the XML files.
Model Driven Architecture
Some source files are generated from models. These are entities and its DAOs (Data Access Objects), service calls, events and client components. The generated Java files are checked in to SCM for convinience into
The models are coded in Java in the
ScrumModelApplication class or modeled in the GUI modeller
ScrumModeller and saved in
ScrumModeller and clicking
Save & Generate generates the sources.
We use Kunagi, of course.