JavaForge: Remote Build- and Deploy Automation using Groovy
Repetitive tasks are boring, especially if they take long. And since they are boring, they are inherently error prone. A typical example is a long and complicated build procedure that is performed manually every time. This is where programmatic automation enters the game to accelerate builds, and to reduce costs and errors.
Olaf Davidson of the U.S. Department of Agriculture shows us how his project hosted at JavaForge solves a fairly complicated build scenario with a surprisingly concise script. The script itself is written in Groovy, an alternative language that runs on the JVM, and the solution relies on the Groovy Codebeamer Scripting framework, also maintained by Olaf.
The actual script does the followings:
- Checks the need for a build
- Performs the build (locally)
- Changes the item status
- Creates a new 'milestone' item
- Uploads the build product to the Document Manager
- Attaches the build product and build process output to the milestone item
- Tags the source code repository
- Associates the fixed bugs and implemented features to the milestone build
- Posts a notification
One more note: Groovy might not be your cup of tea, but this should not stop you. At the end, all you need is a client application written in your favourite language, accessing the codeBeamer remote API. The primary bindings for the API are Java and C#, but some of our customers have successfully implemented remote clients in PHP and C/C++, too.
package ngmfbuild
import cbscript.*
import static cbscript.CB.*
def SVN = "c:/cygwin/bin/svn.exe"
def ANT = "c:/java/apache-ant-1.7.1/bin/ant.bat"
def SVN_URL = "http://svn.javaforge.com/svn/oms"
def ms = "3.0.11"
def qstatus = "Ready"
def dry = false
println "Login JF/OMS..."
def jf = CB.login("http://javaforge.com/remote-api", "odavid", new
File("c:/tmp/jfpass").text)
def prj = jf.projects.find{ it.name == "Object Modeling System" }
println "Query bugs and tracker ..."
// query for candidates: fixed bugs
def readyBugs = prj.trackers.find {it.name == "Bugs"}.issues.findAll {
it.status == qstatus
}
// query for candidates in Feature requests
def readyFeatures = prj.trackers.find {it.name == "Features"}.issues.findAll {
it.status == qstatus
}
// combine all features and bugs into one single list
def readyList = readyBugs + readyFeatures
println "There are ${readyList.size} bug fixes/new features ready for
the build..."
if (!readyList.empty) { // or require a minimum number of fixes/feature
println " Bugs:"
readyBugs.each{println " ${it.id} - ${it.summary}"}
println " Features:"
readyFeatures.each{println " ${it.id} - ${it.summary}"}
println "Building ngmf.all ..."
StringBuffer stdout = new StringBuffer()
StringBuffer stderr = new StringBuffer()
p = "${ANT} -Doms.version=${ms} -f c:/od/projects/ngmf.all/build.xml clean jar".execute()
p.consumeProcessOutput(stdout, stderr)
p.waitFor()
if (p.exitValue()) {
println "ERROR !!!!!!!!!!!!!"
println stderr
return
}
println "Branding Console with ${ms}"
replaceVar(new File("C:/od/projects/ngmf.dcon/src/ngmfcon/resources/ConApp.properties"), ms)
println "Building ngmf.con ..."
stdout = new StringBuffer()
stderr = new StringBuffer()
p = "${ANT} -f c:/od/projects/ngmf.con/build.xml clean jar".execute()
p.consumeProcessOutput(stdout, stderr)
p.waitFor()
if (p.exitValue()) {
println "ERROR !!!!!!!!!!!!!"
println stderr
return
}
// dry run is done here.
if (dry) {
println "DRY RUN, STOP HERE !!!!!!!!!!!!!!!"
jf.logout();
return
}
// commit new release About
println "Committing Branding ..."
svn = """${SVN} ci "../ngmf.dcon/src/ngmfdcon/resources/NgmfdconApp.properties" -m 'Branding ${ms}'""".execute()
tag_out = svn.text.trim()
tag_err = svn.err.text
println tag_out
println tag_err
// tag the whole trunk
println "Tagging ${SVN_URL}/tags/${ms} ..."
svn = "${SVN} copy ${SVN_URL}/trunk ${SVN_URL}/tags/${ms} -m 'tagged ${ms}'".execute()
tag_out = svn.text.trim()
tag_err = svn.err.text
String info = "!!!Milestone ${ms} Build Info \n" +
"; __Build Process Exit Status__: ${p.exitValue()} (see attachments for details)\n" +
"; __SVN Tag URL__: " +
"[tags/${ms}|http://javaforge.com/proj/sources/sccBrowse.do?proj_id=1781&dirname=tags/${ms}] " +
"(external: [${SVN_URL}/tags/${ms}])\n" +
"; __SVN Log__: " +
"[${tag_out}|http://javaforge.com/proj/sources/sccFileLog.do?proj_id=1781&filename=tags%2F${ms}&isDir=true]"
println "Creating new Milestone Item ${ms} ... "
def mt = prj.trackers.find {it.name == "Milestones"}
def milestone = mt.submit(summary:ms, text:info, priority:NORMAL)
//
println " Attaching build output ... "
milestone.attach(name:"stdout.txt", content:stdout.toString(), text:"Build output.")
println " Attaching build product ... "
milestone.attach(name:"oms-"+ms+".zip", file:"c:/od/projects/ngmf.all/oms3.zip", text:"OMS Zip Distribution.")
println " Uploading to documents ... "
// copy the build to documents
doc = prj.artifact("Releases/v3/oms-"+ms+".zip")
doc << new File("c:/od/projects/ngmf.all/oms3.zip")
//
println "Associating all bugs/features to the new milestone ..."
readyList.each{ task -> milestone.relate(task, RELATED) }
println "Closing related bugs/features ..."
readyList.each{ it.status = "Closed" }
println "Spreading the news ..."
def news = prj.forums.find {it.name == "News"}
news.post(subject:"Milestone Release: " + ms, text:"Milestone details : " + CB.link(milestone));
} else {
println " Nothing is ready for build."
}
println "Logout ..."
jf.logout();
def replaceVar(File file, String val) {
file.text = file.text.replaceAll(/(Application.version = )\S+/, "\$1$val")
}
Posted at 12:58PM Mar 05, 2010 by Intland Team in Tutorials | 0 Comments
Better multi-tasking with the codeBeamer Mylyn connector
In todays highly competitive business world, noone has the luxury of working on a single task at a time anymore. Instead, we all make expensive context switches between very different tasks all the time. And, I guess, we all are searching for more efficient time management methods (GTD, anyone?) and tools that help us to reduce the information overload. Mylyn is one of those.
What is Mylyn? Mylyn is a task-focused interface for Eclipse that makes multi-tasking easy. It makes tasks a first class part of Eclipse, importing them from external task repositories, like the codeBeamer task and bug trackers, for instance. Once your tasks are integrated, Mylyn monitors your work activity, and uses this task context to focus the user interface on the task-at-hand. This improves productivity by reducing searching, scrolling, and navigation.
A Mylyn connector for codeBeamer, Intland's ALM software, has been available for years now. Last December, we decided to re-engineer it from ground up. Why? The new version incorporates long awaited changes based on the first hand experience of our customers and our internal development team, and it will also establish the basis for future improvements. This is where the story starts to get more interesting.
In the next iteration (due to summer 2010), we will add Mylyn Team Support features to HgEclipse. It will enable navigating from change sets to tasks, generate automatic commit messages and working with patches. Mylyn already has it for Subversion and CVS, but for Mercurial it is not available at the moment.
OK, let's get back to the spring release. The new codeBeamer Mylyn Connector beta will be out in April 2010. Version highlights:
- Support for Eclipse 3.5
- Task contexts saved to, shared on and restored from the codeBeamer server
- Wiki markup support
- Streamlined UI: easier and faster configuration of queries
So you say you don't have Mylyn installed? Well, chances are you actually have. The Galileo Eclipse package is shipped with Mylyn by default. In case you are using an earlier version of Eclipse, see the link in Resources.
Resources
- Mylyn project homepage
- Download Mylyn
- HgEclipse project homepage: a plugin providing support for the highly popular Mercurial distributed version control system within the Eclipse IDE
Posted at 01:26PM Feb 26, 2010 by Intland Team in Announcements | 0 Comments
HgEclipse versus EGit tutorial
If you are using the Eclipse IDE and one of the Mercurial or Git Distributed Version Control Systems, or just considering Mercurial or Git and find it difficult to choose, then you don't want to miss it, friend.
Ekke (pictured in the right) is publishing a series of blog posts, kind of comparing HgEclipse (Eclipse plugin for Mercurial) to Egit (Eclipse plugin for Git). No doubt, this is a hot topic. There is godzillions of Mercurial vs Git comparisons available on the web. What makes this one particularly interesting, though, is the focus on Eclipse and the pragmatic approach. No fluff, just stuff.
I want to learn more on using Mercurial and Git with Eclipse
In case you are looking for more information on the same subject, we've just created a HgEclipse Tutorials page on JavaForge to maintain all relevant links, videos, whatever. Have a something to add? Please go ahead!
Posted at 10:24AM Feb 22, 2010 by Intland Team in Tutorials | 0 Comments
What Martin Fowler thinks about Version Control in 2010
Martin Fowler, a well known expert in OO, modeling, design patterns, methodologies and everything software engineering, published a great article on recent innovations in Version Control. He discusses Centralized and Distributed approaches, plus Subversion, Git and Mercurial (and some alternative products) from a very pragmatic aspect. His thoughts are perfectly in synch with what we experience on a daily basis, and what we saw while talking to our clients. Recommended reading.
Another partly related resource has been published by ThoughtWorks, the company Martin works for. The scope of their Technology Radar Jan 2010 goes far beyond VCS, it is a study of all emerging technologies and trends in IT. Absolutely recommended.
Finally, let me mention that our flagship product, codeBeamer, and its free brother, codeBeamer Managed Repositories are developed along the same ideas: they will not enforce you to make the final decision between Subversion, Git and Mercurial. As Martin points out, each of those three has their own virtues and each of them fit particularly well to certain business situations.
Instead, codeBeamer supports Subversion AND Git AND Mercurial. Even better, it enables you to choose a different VCS for each of your projects. Sounds too good to be true?
Posted at 10:56AM Feb 18, 2010 by Intland Team in News | 0 Comments
Free tickets for "embedded world 2010"
As I wrote a couple of weeks ago, Intland will exhibit at major conferences this year. The first one in the row is embedded world 2010. The good news is that we have free tickets for you!
Sounds good, right? Just contact us by emailing to dagmar(at)intland.com till February 25, and we will take care of the details.
Read here for more information:
http://www.embedded-world.de
Nürnberg, Germany
March 2-4, 2010
Posted at 12:50PM Feb 15, 2010 by Intland Team in News | 1 Comments
Sneak peek at the future codeBeamer UI/UX design
Our User Interface and User Experience Team has just opened a new Facebook gallery to publish an early preview of their recent work. At the moment, there are couple of mockup pictures uploaded, to illustrate the 2010 directions of the codeBeamer interface design. Please note that these are design mockups: the goal is not to pixel-precisely mimick the final screens, but to evaluate the layout, the controls and the feel.
As you probably notice, our approach is driven more by usability and simplicity, than by aesthetics. It doesn't mean it will be ugly when it's completed. It means that every time when we have to choose between nice-looking and productive, our priority will be on productivity. We want to make screens quick to understand and functions easy to use. Everything that you need in a context to be at your finger tips. Not merely to impress your eyes.
It's all for you. What do you think?
Posted at 02:41PM Feb 12, 2010 by Intland Team in News | 2 Comments
JavaForge Project: jPlay - a music catalog and player in Java
This blog post is the first article in a new series that we are launching today.
Starting from this week, we will introduce notable JavaForge projects and community members on a regular basis. How does it work? We will pick up an active project pretty much randomly, and will make a quick email interview with the team members. Your answers are then published in the Intland blog and in our periodic newsletters. This is a great opportunity for you to introduce your projects to a wider audience, and a great opportunity for us to learn more about how we could improve our free project hosting service. We plan to reuse this collective wisdom in our commercial products, too.
Would like to participate in it? Just tweet a message with the #javaforge hashtag to @intland, and we will get back to you right away.
The first project we would like to introduce you is jPlay, a desktop music catalog and player developed in Java.
Interviewee Profile
Name: Carlos HocesBio: Electronics and Automation Engineer
Location: Spain
The jPlay Project (Website)
What is your project about?
We try to build a Java desktop application to manage a catalogue of music media, files and broadcasting streams, and be able to play them. There are many of this kind, but very few written in Java language. We are also building a set of tools, that will not only serve as a programming factory and framework for jPlay development, but also as a reusable set of packages for other projects development as well.We think Java language is powerful enough, and unfortunately not widely used for mainstream applications. We also try to help at filling this gap with our project.
How are people using your project in real life?
The project hasn't yet been released. It's still a work in progress at this time, and is under a very active development. We plan to release an early access build very soon. It currently is able to run, is capable of managing a music catalogue, and plays music files and radio streams; but we want to retouch the GUI interface a bit, and add some features in phase of development, before going to an alpha release.What was your biggest surprise?
This project has been source opened and hosted (in another repository) for several months by now, and this is the very first time it gets some attention, thanks to the JavaForge team. We knew desktop programming in Java doesn't seem to grab attention enough, other than for in-house development; but I didn't expect such a dense silence. Mainstream applications may use, for their background “plumbing”, the very same sophisticated technologies as any corporate in-house development does - when not even more advanced ones; but I have the feeling they are seen sort of no more than “toys”.Your biggest challenge?
We wanted to connect the best and latest Java technologies, along with embedded SQL engines (we currently use MySQL), to a modern and nice looking user interface, easy to use and featured, but very efficient and performing in the background. Glueing all together, while keeping a modular and abstract approach was (and still is) quite challenging.Your biggest achievement?
To get it running without watching the computer falling apart?
Joking aside, Salvatore Ciaramella, project co-administrator, made an excellent job with the SQL agnostic factory classes, which allow any programmer to work with the SQL engine, without any need of knowledge of SQL language. Let's not forget at all his great contributions to logging, monitoring, settings, GUI design and many, many ideas which help jPlay to jump-up to what's now.
It was very exciting and rewarding for myself the Swing extensions developed straight from JDK, to include several new functions and features, like embedded pop-up menus, adjustable columns in tables, the tree-table used for system files, zebra stripping, among many others, and the Drag'n'Drop.
Can you tell us about the team?
This is a team project, in the full sense of the word. We're currently just two people, Salvatore and me; but I must say we can make “noise” as if we were a dozen or so, minimumObjectives, ideas, goals, challenges, achievements... everything is shared!
How do you coordinate the project and communicate with members?
Respecting the base structure of the project, any idea is shared, openly discussed, and if it seems valuable and feasible, it's assigned and put on test. Once it's ready to get incorporated to the project itself, everyone collaborates to make it running, enhance it, clear bugs, etc.The usual communication method is by using the forums, and mailing lists.
In order to get an idea about our working style, I would suggest a reading of our forums.
Your future directions?
We see jPlay as a starting point, sort of a basement for a multimedia set of applications, frameworks and tools, both server based and client side, which may bring the true power of Java language out of its current confinement into “tools, servers and in-house”, to a wide spread of mainstream users. We also think this kind of development may benefit the language itself, and more dedicated and professional application developments as well.As Salvatore use to say: “Hope we will create something I could share with other people, known and unknown.”
Are you looking for contributors? If so, how can others contribute?
We are always willing to welcome contributors. They may share ideas, code, contents, beta testing, help with translations. There is always room for anyone willing to do a serious work in this project.To put it in Salvatore's own words: “Let me say that even if we made "something", we will of course gain a shift, 'with a little help from our friends' (to quote the Beatles) over the net
. Hope many will join. Hope this will be a new dawn on JavaForge.”
Experiences with JavaForge
Why did you choose JavaForge?
We came from another well known hosting site, which is closing (or “something” like that) within next weeks. Most of our current forum entries were ported from that site to JavaForge.There were a couple of details that helped our decision move to JavaForge: the NetBeans support via a plug-in, and the nice, comfortable, featured and so professional hosting service JavaForge offers.
Strengths of JF?
It's clear, concise, and very well featured. Setting up a project, and start working on it, takes very little effort. Moving a project from some other site up to JavaForge could be done very quickly, easily, and the end result may have a nice looking too. What else?
Weaknesses of JF?
I am very naïve at JavaForge, but I saw a potential problem with admin settings. I would prefer to have all settings in a single place: there are some inside Admin, but also inside Forums as well. This may be very confusing at first.I miss a simple Web hosting for projects: once they are release to generally available, it could be easier to connect users to project development.
What SCM system are you using?
We do use Subversion. I think is simple, efficient, well supported. Sometimes it may go nuts; but I don't know of any absolutely fail-safe version control system.What would you advise to someone thinking about starting a project on JavaForge?
To have a very close look at the site: it has much more to offer than it seems to at first glance.Posted at 02:44PM Feb 09, 2010 by Intland Team in Customer Stories | 0 Comments
What YOU say about HgEclipse
The #Mercurial Eclipse plugin (HgEclipse) is miles ahead of the #Git plugin in both features and stability.
Neil Hartner on Twitter
#HgEclipse makes me seriously considering about switching from #git to #mercurial. The plugin is just so much better.
@woeye on Twitter
Well, all I can say is Wow! MercurialEclipse was ok, but Intland has taken it to very useable.
Mike Wilkes in his blog
...and installed the excellent HgEclipse plugin using the Eclipse "Install New Software" option.
Immo Hüneke in his blog
eclipseをtexエディターとしてしか使ってないという変な状態。Texlipse＋HGEclipse万歳
@alpha_emitter on Twitter
Loving the new HgEclipse plugin! http://javaforge.com/project/HGE -- finally a usable Team Synchronisation view, ssh push works.. #happy
@asynchronaut on Twitter
HgEclipse (http://bit.ly/8ZwUUG) лучше Mercurial Eclipse (http://bit.ly/91wtg3). Я хотя бы могу на русском писать #Eclipse #Mercurial
@mi_estas on Twitter
HgEclipse seems to be a nice successor of the MercurialEclipse plugin: http://javaforge.com/project/HGE #hg
@goeldner on Twitter
Replaced Mercurial Eclipse 1.4.2 with HgEclipse 1.5.0 RC1. And it works great. New syncronization View is fantastic. Hope they merge soon.
@slavus on Twitter
Testing HgEclipse - Mercurial plugin for Eclipse. Though Cloning wizard fails on OS X, it seems to work nicely otherwise.
@huima on Twitter
Posted at 12:47PM Feb 03, 2010 by Intland Team in Customer Stories | 2 Comments
Going Agile with Git and codeBeamer (Tutorial)
Clearvision, our terrific partner in the UK and a real expert in all things change management, generously released their Git Workshop training materials. This package was originally composed for a large telco, which is in the midst of reengineering its processes for the Android mobile computing platform. Now, the tutorial is available for the public. A sincere "thank you" goes to Gerry, Martin, and all the Clearvision team.
What is it?
This is a step-by-step tutorial that explains how to launch projects with the Git Distributed Version Control System and codeBeamer, Intland's collaboration software, and then leads you through the most common SCM tasks: cloning repositories, making and committing changes, and pushing changes. If you look beyond the obvious SCM operations, it shortly introduces you also to:- Agile planning
- Daily agile reviews
- Sharing information and collaborating in wikis
- Releasing project artifacts automatically, by using commit triggers and Ant scripts
Recommended for: developers, tech and team leads, project managers
Duration: 60 minutes (strictly speaking)
Resources
- codeBeamer & Git Workshop by Clearvision
- Clearvision company site
- Git project home
- codeBeamer product page (alternatively, see codeBeamer Managed Repositories if you look for a free tool)
Posted at 05:18PM Feb 01, 2010 by Intland Team in Tutorials | 0 Comments
HgEclipse 1.5.0 Final Released
As you might already know, the Release Candidate of HgEclipse 1.5.0 has been out since last November. Now we are happy to announce that the 1.5.0 stable release is available! If you were waiting for the stable release, don't hesistate any longer. For those who are not familiar with the project: HgEclipse is a Mercurial Distributed Version Control plugin for the Eclipse IDE, which is geared towards enterprise use.
1.5.0 is the first stable release delivered by Intland. Our ultimate goal is to evolve this plugin accompanied by our free and commercial products to a truly Enterprise-scale Distributed Version Control Solution.
You can download the plugin from JavaForge.
Changes since 1.5.0RC1
A couple of days ago, we posted the sneak preview of the change list to the Facebook page of HgEclipse. We will follow this practice in the future as well, so become a fan on Facebook if you want to keep up with the project, always know all the latest and interact with fellow users.- History View improvements:
- New features like "Compare with previous"
- Icon decorations instead of cryptical action letters
- Full set of "Open" and "Compare" context menus for the change set files
- Highlighting the base file in the changed files set
- Consistency fix: default action for double click is now "compare with the previous"
- Tags can be shown for single files
- Sigcheck analysis is optional now
- Graph view bug fixes and performance enhancements
- Merge View improvements:
- Conflict dialog changed from modal dialog to use 3-way merge editor
- New context menus: "Open merge editor", "Open default editor", "Mark resolve/unresolve" and "Show history"
- Ugly text actions from the toolbar removed
- "Compare" action now compares with the predecessor of the current version, if the file is not changed
- Enabled reverting a file (even if file is not changed) to a specific revision from the Revert dialog
- Added content assistance for the "Switch to" revision text field
- New feature to "Close" named branches
- Annotations are following file rename/move history
- Various other bug fixes
Future
The next release is scheduled by 2010 April. Currently we are planning and prioritizing worklog items for the next sprint, so we are keen to receive user feedback and would welcome your contribution. Tweet us what feature you would like to see in 1.6.0, and tell us what you think in general on LinkedIn.Hey! Still here? Now the interesting part: within a couple of weeks, we will roll out a new version of the codeBeamer Mylyn connector. This will be a great addition to your free tool set consisting of Mercurial, Eclipse, HgEclipse, Mylyn and codeBeamer Managed Repositories. Imagine this:
- you clone a repository from Mercurial easily maintained by codeBeamer MR,
- pull in issues from codeBeamer to Mylyn tasks,
- work on resolving the issues,
- commit your change sets to Mercurial,
- then push what you have done back to Mercurial, and close issue.
Finally
- Download HgEclipse via Eclipse Update in a minute.
- Watch the 4 minute tutorial video on YouTube.
- Join the project on JavaForge, get the source code and help us.
- Tweet us what you think about or what you are doing with the plugin. We would love to hear from you.
- Visit the HgEclipse Facebook page.
- Meet fellow users in the Linkedin group.
Posted at 11:29AM Jan 27, 2010 by Intland Team in Announcements | 13 Comments
Intland hits the road again: upcoming events in 2010
At Intland, we have a long tradition of meeting our customers, users of our free software, and anyone interested in what we do, personally at popular conferences, exhibitions and trade shows worldwide. This year, Intland hits the road again. Here are the first two major events we will be represented at, in the first half of the year.
embedded world 2010
Nürnberg, Germany
March 2-4, 2010
http://www.embedded-world.de
The embedded world Exhibition & Conference remains the world's undisputed biggest get-together for the international embedded community, as the figures show. The exhibition set another new record in 2009 with more than 700 exhibitors, and some 16,000 trade visitors used the opportunity to obtain an impression of the latest trends in embedded technologies.
embedded world 2010 will again prove its power of innovation for hardware, software, tools and services.
ITIL Forum 2010
Frankfurt/Germany
May 4-5, 2010
http://www.itil-kongress-iir.de
Anwenderakzeptanz für ITIL steigt!
Immer mehr ITIL-Anwender bestätigen, dass ITIL V3 die Verzahnung zwischen IT-Services und den unternehmensübergreifenden Businessprozessen entscheidend verbessert.
Auch mehr und mehr IT-Verantwortliche sind überzeugt, dass die IT-Prozesse grundsätzlich stärker auf die Geschäftsanforderungen ausgerichtet werden müssen. Vom Risikomanagement in ITIL V3 bis zu Service Validation and Testing – auf dem Weg zu Service Operation sind einige Herausforderungen zu meistern.
Unser ITIL Forum bietet Ihnen die Möglichkeit, Lösungen und Strategien erfolgreicher Unternehmen ausführlich kennen zu lernen. Hören Sie in den Expertenberichten, wie Sie sich an globalen IT-Standards ausrichten, Prozesse implementieren und diese kontinuierlich verbessern.
Die Früchte der Bemühungen sind Kosteneinsparungen in Betrieb und Entwicklung, zielstrebige Prozess-Rollouts und kontinuierliche Prozessverbesserungen in der IT-Service-Organisation.
All right, let's hook up at these events! Meet our people, ask questions or let's just chat about our products, JavaForge, our solutions, our industry, and whatever interests you. We will do our best to answer everything. Good bye until then.
In case you can't be there, you can ping us any time tweeting your questions to @intland at Twitter.
Posted at 01:46PM Jan 22, 2010 by Intland Team in News | 0 Comments
Google Code and Mercurial Tutorial for Eclipse Users
This post is a short introduction to using the Eclipse IDE and the HgEclipse plugin for projects hosted at Google Code Mercurial repositories.
HgEclipse is a free and open source Eclipse plugin that supports the Mercurial Distributed Version Control System right within the IDE, thus making these two a very convenient and efficient toolset for Java and C/C++ development. It is important to note that HgEclipse is absolutely not limited to Google Code's Mercurial repositories, it works with any Mercurial repository. We use Google Code merely because of its immediate availability and easy use.
What is Google Code? It is a popular hosting service for open source projects. It provides revision control, a rudimentary wiki, a basic issue tracker and file downloads. As for revision control, since April 2009 Google Code offers the Mercurial Distributed Version Control System as an option besides Subversion. (Git is still unsupported by Google Code. If you are a Git user, codeBeamer Managed Repositories is a compelling option for you!)
We recommend watching the guided video first, then reading the explanatory notes below. First, here is the video tutorial. Watch it in full-screen HD:
1 - Installing HgEclipse
You can easily install the plugin with the Eclipse Update Manager. Read here how.2 - Cloning a repository from Google Code
You start by making a local copy (or clone according to the right DVCS terminology) of the repository hosted at the Google servers, and import that to Eclipse as a new project.Luckily, HgEclipse offers a dedicated wizard for cloning and it makes the whole process very easy. The only thing you will need is the repository URL that is visible at the Command-line access section, under the Source tab in Google Code. You don't even need to authenticate with user name and password, since the Google Code repositories can be cloned anonymously.
3 - Working locally and committing your changes
You can add, delete and modify files just as you do it without Mercurial. The small grey stars over the regular file icons always indicate the files which have uncommitted changes.When you decide you want to commit some changes, the most convenient way to do that is switching to the Syncronization View. This view shows three types of changes:
- Uncomitted: your local changes that are waiting to be committed to your local repo.
- Outgoing: changes committed to the local repo, but not pushed to Google Code yet.
- Incoming: changes that were pushed to Google Code by other developers, but are not pulled into your local repo yet.
Don't forget that, unlike in centralized version control systems, at this point these changes are still only in your local repo, and not in Google Code! The distributed approach also has the advantage that you can commit even offline. You need to be online only when pushing to Google Code.
4 - Pushing your changes to Google Code
If you have changes that are worth to be contributed to the Google Code repo, then it's time to push them. This requires you to login to Google Code. Important: to identify yourself, you have to use your Google Code specific password, not your regular Google user account. You can see this password clicking your user name in the web interface, then switching to the Settings tab.Final words
If you are curious about the more advanced features like branching and tags, just tweet a message to @intland on Twitter, and we will be happy to write more.Posted at 04:34PM Jan 12, 2010 by Intland Team in Tutorials | 2 Comments
Enterprise mashups with codeBeamer
This post is written by a guest writer, G. Hussain Chinoy of Bespoke Systems.
Hussain is writing about his experience building an awesome timeline mash-up. His app pulls out events from Google Calendars and issues from codeBeamer's super-elastic trackers, and visualizes them along a SIMILE timeline. What makes it even more interesting from technical perspective is the mix of technologies involved: .NET in the serverside, heavy javascript magic in the clientside, Google Calendar running in the cloud, and codeBeamer running in a Java servlet container and exposing its .NET remote API. The right tool for the right job.
We are incredibly appreciative of the efforts you put into projects like this. We will be doing whatever we can to support them, and would love to see more. Do you have questions? Comments? Something to show for the codeBeamer community? Just tweet us at @intland, and we will get back to you immediately.
CodeBeamer Timeline Builder
(Please click the images for their high resolution versions.)Background
Project dashboarding - viewing the progress of a software development project from different viewpoints - has been an interest of mine ever since I started developing software. After one particularly difficult project involving issues with requirements, development and operations deployment and environmental difficulties, with no shortage of fingerpointing going on, I thought it would be good to step back and see the project from a linear timeline perspective and gain some objectivity. Additionally and especially for long running projects, viewing time linearly helps us as humans see the scope of events.
Simile Timeline + Google Calendar
I'd already had a calendar that was a great repository of significant events, which meetings I'd scheduled, etc. in Google Calendar. The data originally came from the corporate Outlook, synced up to Google Calendar with the Google Calendar Sync application. Using the Simile Timeline Javascript widget, I wrote a quick export from Google Calendar using the Google Calendar Data API to format the calendar events into the Simile Timeline json format. Since the events were hand coded Client Requirements (grey), Impediment (red) and Success (green), viewing the events linearly helped clear up the discussion around where the issues were in deploying the application. This quick web application was very well received and project managers in both development and operations, as well as other non-project related developers and managers, since they were able to see the timeline of events that occurred for this particular project. I hadn't fully automated the import from Google Calendar to the Project Timeline page, and that's what led to the next step.Dynamic Timeline Generation
The timeline view of the project was very useful and I thought it'd be a great perspective for other projects. Most of the projects at the organization use codeBeamer by Intland as an issue tracker and document repository. CodeBeamer has a much richer ability to code tasks / tracker items with statuses as well as start dates, end dates, and changed dates. Being able to dynamically pull project info via tracker lists and view them in a linear timeline looked to be a great start for a project dashboard.
The Timeline Builder was constructed with two picklists, one that displayed the lists of projects available and the second picklist that was contextual to the project's actual tracker lists. The codeBeamer repository is organized such that every project has multiple "tracker lists" such as Business Requirements, Change Requests, Production Releases, and Defects. Project administrators can also add tracker lists as needed. When a project is selected from the first picklist, an AJAX call is made to the codeBeamer services, returning the project-specific tracker lists. When a user selects a tracker list, the application issues an AJAX query and retrieves the list of tracker events and then displays them as a timeline. The timeline has three horizontally scrollable bands: a weekly view, a monthly view and a yearly view. Each of them can be dragged left or right and the display of events will be synchronized. The display is "coded" by status: tems with a status of "closed" are represented as a solid blue ribbon, individual events have a circle icon, "in progress" events are a slightly transparent blue ribbon, "open" items are represented by a slightly transparent red ribbon with a solid red circle icon. Selecting a timeline event yields a link to the original codeBeamer tracker item as well as a short description along with the open and closed/last updated information. Below the timeline is a tabular representation of all the event data.
Technology Decisions
The organization uses .NET predominantly so I decided on using WCF and the codeBeamer .NET SDK to serve up the Simile Timeline JSON and ASP.NET (without WebForms) and jQuery to make AJAX requests to the WCF codeBeamer services. Additionally, the organization is standardized on Windows 2003 and IIS6, so I passed on using ASP.NET MVC on IIS6. Each codeBeamer project can have multiple task trackers ("tracker lists"), so there were three total JSON services: GetAllProjects, GetTrackerListsForProject, and the last, GetTimelineForTrackerList, which retrieved all tracker items for a particular tracker list as Simile JSON events. Additionally, I used two jQuery plugins - jTemplates to populate portions of the page, and flexigrid to show the same events in a table below the timeline.Findings and Stumblings
Looking at the variety of projects that we have in a linear format brought some interesting insights, the first of which is that almost no two projects use Tracker lists the same way. Not every project uses codeBeamer the same way, even though we have default tracker lists for Business Requirements, Change Requests, Production Releases, and Defects. Not every Task Lead uses the default statuses the same way - some close all tracker items only when a project has deployed, and create a separate status - "development complete" - for developers to use. Tracker items stay open throughout the iteration. For long-running, multi-year projects, cyclicality was shown quite well in a linear timeline - periods of project activity were clearly mapped to variety of business cycles.With the differences in usage of codeBeamer trackers, the high level of ability to customize tracker item templates, and the variability in conforming to the SDLC in the organization, comparing project-to-project is difficult in general, not just with a linear timeline.
The decision to use .NET WCF and a jQuery-driven front-end separated the codeBeamer Tracker List JSON generation service from the UI application, creating two projects which may or may not have been a good idea - although service-oriented, it's two distinct codebases to maintain. Another interesting challenge was the codeBeamer API documentation for .NET - there isn't really any, for either Hessian C# or the codeBeamer Remote API. Using Reflector and referring to the codeBeamer Java SDK Javadocs did help, but a Sandcastle generated documentation set would've been useful. Thankfully, the Java and .NET API's are extremely similar, so it wasn't a problem interpreting what should've happened.
Project Next Steps / Directions
For the current iteration of this timeline builder I have a few minor technical issues I'd like to address. I'm planning on having better integration between the flexigrid table of events and the simile timeline so that when you select an item from the table, it scrolls the timeline to the relevant event. Another enhancement would be to allow stacking timelines of multiple projects for juxtaposition.
I'd also like to expand the data feed to other task tracker applications. The organization also uses VersionOne's on-line agile project tracking application which has similar data to codeBeamer. A future revision to this application may include pulling from VersionOne project data dynamically in a similar manner (choose a project, see a timeline). Similar "coding" issues occur with VersionOne as with codeBeamer use, but since VersionOne is more focused on an agile project management lifecycle, I expect representing the variety of task types to be somewhat easier. An initial version is pictured below (using jstree to visualize the project hierarchy, at the left). Coding (designating the display of open, closed, in progress, etc.) is a bigger issue, and relates more to the choice of software project management structure - agile, etc. - but is something that's greatly needed to get a consistent level of display. Other project tracking software, which I'm familiar with from a user standpoint, that may be usable include Redmine and Assembla/Trac.
From the technical framework, I may experiment with ASP.NET MVC next (which would remove the need for a separate WCF project) and then GWT (with the codeBeamer Java SDK) to see which one is more code-efficient.
Thanks for reading this writeup!
G. Hussain Chinoy
hussain.chinoy @ bespokesystems
Posted at 02:41PM Jan 07, 2010 by Intland Team in Customer Stories | 0 Comments
Looking back at Intland in 2009
2009 has been a busy year for Intland. Lots enhancements in our products, lots of awesome customers wordwide, lots of valueable feedback from the community, and lots of exciting changes in the collaboration space.
Let's see the most important events along our 2009 timeline:
Moving JavaForge to Amazon Elastic Compute Cloud
In the beginning of the year (pretty much during the Christmas holiday actually, so that we interfere the least with always-busy open source enthusiasts), we moved JavaForge.com, our free project hosting service, from a traditional hosting environment to the Amazon EC2 cloud infrastructure. Our motivation was a mix of enhancing availability, lowering operational costs, experimenting with the cloud, and most importantly providing higher quality service for our users.Experiences: so far so good, the story is not over yet. During the whole year, competition in the cloud computing space was fierce, and we expect major changes in 2010 as well (within months). At the moment we keep our eye primarily on Amazon EC2, Google App Engine and SpringSource Cloud Foundry.
Release of codeBeamer 5.3
This release satisfied some long time feature requests, like aggregation and distribution of issue properties, and introducing wiki pages as tracker dashboards. It also incorporated major performance improvements and an early access version of the Mercurial support.Even if the Mercurial support in codeBeamer 5.3 was considered early access, this was a major cornerstone of future codeBeamer versions (see the next item to figure out why).
Making Distributed Version Control a core strategy
High emphasis on Distributed Version Control was one of the most important decisions we made during the year, if not the most important one. We are big believers in the superiority of the distributed collaboration approach, thus:- codeBeamer, our Collaborative Application Lifecycle Management solution, now supports Git and Mercurial repositories in addition to Subversion, CVS and such.
- We launched a brand new free tool, codeBeamer Managed Repositories, that makes creating and managing Subversion, Git and Mercurial reporistories quick and easy.
- We released a Mercurial plugin for Eclipse, HgEclipse, that makes it possible to collaborate on really large projects in the Eclipse IDE.
Twitter and Facebook
We successfully launched our Twitter stream and our Facebook page. We have been fairly active on Twitter engaging with our users, spreading useful links and exciting short news, following the trends, but we were not really spending much time on Facebook. (This is something we will change in 2010.)For now, just follow @intland on Twitter and become a fan of codeBeamer at Facebook if you don't want to miss anything that matters.
Release of codeBeamer 5.4
Big new features were: editing wiki pages in Microsoft Word directly (neat!), improved support for Git and Mercurial, calculated issue properties, issue escalation, just to name a few.Looking at the download counts, 5.4 is the most popular codeBeamer version ever. Go and get a free download or free live trial.
Release of codeBeamer Managed Repositories 1.0
Later in the year we launched codeBeamer Managed Repositories (or MR in short). Learning from our own experiences, we wanted to save time and headache for Subversion, Git and Mercurial users, and to make repository management quick, easy and convenient.Despite of the festive season, more than 1000 users installed codeBeamer MR in December only. Don't miss your late Christmas present
, codeBeamer Managed Repositories is still available for free download.
Release of HgEclipse 1.5.0-RC1
Converting from Subversion to Mercurial was the biggest change in our interal development tool set and processes. (We blogged about it here, here and here.) After the initial frustration we are happy we made the change. This project was a sort of spin-off of the migration process, which we developed for our own needs and then made it publicly available.You can install HgEclipse in 5 seconds, and feel free to join the project any time.
And how about 2010?
Please wait a little for our next blog post, coming soon.Finally
Thank you so much for your support and in-sights in 2009, you are an AWESOME community!Posted at 02:47PM Jan 06, 2010 by Intland Team in News | 0 Comments
"Well, all I can say is 'Wow!'. MercurialEclipse was ok, but in one release, Intland has taken it to very useable."
Have you heard of HgEclipse, the Mercurial plugin for Eclipse that actually works?
We have released it for the public last December (see this post). Since then more than a 1000 Mercurial users installed it, and now we are receiving positive feedback all over the blogosphere and Twitter.
Mike Wilkes of Intelliware.ca writes (see his original blog post for the full review):
Well, all I can say is 'Wow!'. MercurialEclipse was ok, but in one release, Intland has taken it to very useable. They're calling their version HGEclipse to differentiate from MercurialEclipse.
2 big highlights. They synchronize view is now very useful, as it shows uncommitted changes, incoming and outgoing changesets.
They've also fixed the history/compare view. Mercurial tracks file copies, but MercurialEclipse would create an error if you tried to compare a file version with the current name to one with the old name.
HGEclipse resolves it correctly, and shows the differences.
Do you have a question, comment, suggestion or tip? Leave your feedback in the project issue trackers.
Posted at 03:30PM Jan 05, 2010 by Intland Team in Customer Stories | 2 Comments