VSoft Technologies Blogs

Continua CI and FinalBuilder integration improvements

Tue, 21 Jun 2016 15:35:25 GMT

Continua CI 1.8.0.176 and FinalBuilder 8.0.0.1817 (both released today) provide somewhat better integration between the two products.

Continua CI 1.8

The FinalBuilder Action in Continua CI now produces an xml file that is consumed by FinalBuilder when run under Continua CI. This xml file contains all the useful information about a build, such as version numbers, changesets, variables etc.

There is also a new option on the action that will automatically apply Continua CI variable values to matching FinalBuilder variables. What this means is, if you have a variable declared in both FinalBuilder and Continua CI with the same name, FinalBuilder's variable will automatically get the value of the Continua CI variable at runtime. This option is only available for FinalBuilder 8, if you select FinalBuilder 7 the option will not be visible. If the version of FinalBuilder 8 you are running does not support this integration, a warning will appear in the Continua CI build log.

FinalBuilder 8

FinalBuilder 8 has two new actions.

The "Is Running Under Continua" action is an If Then style action, i.e. the children of this action will only run if FinalBuilder is running under Continua CI.

The other action is the Continua CI - Get Version Info action - this action will take the version info from Continua CI and apply it to a version info property set in your FinalBuilder project.;

The action is smart enough to use the correct version info scheme depending on whether the propertyset is a win32 or dotnet propertyset. This greatly simplifies getting the version info from Continua into FinalBuilder, no need to declare 4 variables on both sides and set them in the FinalBuilder Action in Continua CI.

Scripting

That xml file I mentioned above is loaded into a Continua object model that is available in action script events. If you do make use of it, you should be sure to check the Continua.IsRunningUnderContinua property before using the rest of the object model (the script editor provides intellisense for the model.

The future of FinalBuilder Server is Continua CI

Mon, 11 Mar 2013 07:36:02 GMT

It's been a long time coming, but the release of Continua CI, our next generation Continuous Integration server product is almost here. Continua CI will replace FinalBuilder Server (FBS), in other words, FBS 7 is the last Major release of FinalBuilder Server. Of course we will continue to support FinalBuilder Server 7 for some time, but no new features will be added to it.

Licensing wise, customers with current Software Assurance (on FinalBuilder Server User licenses) will automatically receive Continua CI licenses when it is released (using 2 User licenses = 1 Concurrent Build License). I detailed how Continua CI licensing will work in this blog post.

It's fair to say that FinalBuilder Server has some major limitations, the main one being scalability. The architecture of FBS is such that moving it forward to provide better performance and scability would be next to impossible, so we decided to start from scratch, taking into account what customers were asking for, where the industry were heading, and looking for better ways to aproach continuous integration in general.

Continua CI is written using C#, .NET 4, ASP.NET MVC4 + extensive use of jQuery. It uses a database engine (PostgreSQL or SQL Server 2008+) unlike FBS which uses .net serialization (which has been problematic).

Feature	FinalBuilder Server	Continua CI
Build Runners	FinalBuilder Only	FinalBuilder, Ant, Nant, MSBuild, Visual Studio (more will be added)
Version Control Systems	Accurev, Alien Brain, Bazaar, Starteam, CVS, File System, Git, Mercurial, Perforce, PlasticSCM, Subversion, SurroundSCM, Vault, SourceSafe, TFS	Bazaar, FileSystem, Git, Mercurial, Perforce, Subversion*, SurroundSCM, TFS, Vault (Others will be added based on demand.. except sourcesafe... let it die people!)
VCS Branch Support*	Single Branch	All Branches, Single Branch or By Pattern (depends on VCS type)
VCS Checkout/Get	Optional, can be handled by FB script.	Clean checkout into clean workspace for each build. Source is cached on Server and agents.
Issue Tracker support	None	FogBugz, Bugzilla,Jira, Youtrack, custom.
Stages, Conditions	Single FinalBuilder Script	Unlimited Stages, unlimited build runners.
Concurrent Builds	Only of different projects, builds of projects currently running are queued.	Concurrency based on license and agent(s) configuration.
Scalability	Single Server, requires full server install on other machines when single server is loaded too heavily.	Central Server, 1 or more agents installed on as many machines as you like.
Licensing	Per User licensing.	Per Concurrent Build - Free install includes 1 Concurrent build, 1 local agent, unlimited users. At least 1 concurrent build license is needed to allow remote agents.
Security Model	Simple Users & Roles.	Users, Groups, Roles, Permissions, Access Control Lists (global, project and configuration levels)
Authentication	Limited Active Directory support, Forms Authentication only.	Forms only, Mixed or Windows only Authentication
Platforms	Windows Only.	Windows Only - other Platforms in the future.
(*) - Branch monitoring only available on Git, Mercurial and Subversion.

Migrating to Continua CI

Key Differences

Whilst both Continua and FinalBuilder Server (FBS) are both Continuous Integration Servers, they are quite different in how they operate. Continua CI's design is based on feedback from FinalBuilder Server customers, and with a view to making it appeal to more users (FBS is only of use to FinalBuilder Users). The differences in concepts between the two products make it difficult to create an comprehensive automated migration from FBS to Continua. There is a conversion tool that provides a "leg up" in the conversion, but some manual intervention will be needed (more on that in a future post).

Working with FinalBuilder Projects

Perhaps the biggest difference for FBS users is where the FinalBuilder Project Files live. In FBS, the FinalBuilder project files (.fbp7/.fbz7) are managed by FBS and each FBS project references a single FB projects. In Continua, your FinalBuilder Project files must be in a version control Repository that is referenced by your Configuration. Continua is not tied to FinalBuilder in any way, FinalBuilder is just one of a number of different Build Runner Actions available.

Where and when the Build runs

FinalBuilder Server projects all run on the same machine, the one where FBS is installed. This unfortunately limits how many builds can be run concurrently. FBS also doesn't allow multiple builds of the same project to run concurrently, so for example a CI build triggered by a checkin, and a manually started build for the same project cannot run at the same time. The main reason for this is that the working folder and source code are managed by the FinalBuilder project.

Continua CI uses Build Agents to run the builds. Agents can be installed on the same machine as Continua Server, or on other machines. Each agent can run multiple concurrent builds (limited only by hardware resources and software licenses), and each build get's its own working folder and copy of the source code (which is managed by Continua). When a build is queued in Continua, it's requirements (compilers & other tools needed) are evaluated against the available Agents capabilities, and a suitable agent is selected. The build will run when a suitable agent is available to run the build. This may be immediately or at a later time. If no suitable agent is available, then the build will stay on the queue until one becomes available or the build is cancelled by a user.

Continua CI and FinalBuilder

Continua includes a FinalBuilder Action which will run any FinalBuilder Project which is available in the build's workspace. To get the FinalBuilder project into the build workspace, it needs to be in a Repository which is associated with the Configuration. Note that this action only supports FinalBuilder 7.0.0.1795 or later, if you are using older versions of FinalBuilder, you can still use them with the Execute Program Action. FinalBuilder needs to be installed on each Agent machine (the agent will detect that it is installed, and report that to the server).

FinalBuilder Project Variables

Since Continua lacks the tight integration with FinalBuilder that FBS has, it has no knowledge of the internals of the FinalBuilder Project and that includes Project Variables. The FinalBuilder Action in Continua allows you to set the values of those project variables from the action, but you will need to know what those project variables are. Continua is unable to inspect the FinalBuilder Project to determine the varianbles needed as it has no access to the FinalBuilder Project file at design time. We are currently looking at ways to make this easier.

Continua CI and the future

Of course, what will be released soon is only the start of what we have planned for Continua CI. We are planning an aggressive release cycle, with frequent updates. We have a long list of features we plan to implement. Continua CI is built on a modular platform, and we will be releasing other modules over time.

Documentation

Documentation site
Continua CI Concepts
Migrating from FinalBuilder Server
Setting up a real world project

Take Continua CI for a spin

The beta download links are pinned at the top of the Continua CI General Discussion forum

What if I find a bug?

Please post as much information as you can about your environment, the build of Continua CI you are using and the bug in the Continua CI Bug Reports forum.

Introducing Continua CI - Beta

Sun, 20 Jan 2013 10:13:42 GMT

We have now opened up the Beta program for Continua CI.

What is Continua CI

Continua CI is our next generation Continuous Integration server product. This product will replace FinalBuilder Server once it's released.

Continua CI is a far more advanced CI server than FinalBuilder Server, it's not tied to FinalBuilder (although it works very nicely with it), Continua CI supports FinalBuilder, MSBuild, ANT, NANT & Visual Studio as build engines (more will come in updates). The builds are performed by Agents, either on the same machine or on other machines as the Continua CI Server.

Version Control Support

In the initial release these version control systems will be supported :

Bazaar, Git, Mercurial, Perforce, Subversion, SurroundSCM, TFS & Vault

Note that we have absolutely no plans to add support for Source Safe(it's long overdue for retirement). We will add support for others in the future where there is demand.

System Requirements

Server :

Windows Server 2003 or higher (no windows XP), .NET 4.0, SQLServer 2008 or higher, or PostgreSQL 9.1.3 or higher (this is the default db an installed with the server)

Agent : Windows XP SP3 or higher, .NET 4.0 - other platform support is currently being investigated.

Browser : HTML5 capable browser - IE9, Google Chrome 21 or higher, Firefox 14 or higher.

Licensing

Out of the box, Free of charge, Continua supports :

Unlimited Users
Unlimited Projects
Unlimited Configurations
1 Local Agent(on the same machine as the server)
1 Concurrent Build.

After that you can purchase concurrent build licenses. Once you have at least 1 license installed, you can use as many remote agents as you like, agents do not take up licenses, concurrent builds do.

We explored many different licensing schemes and we believe this scheme will work out better for most people. The most common complaint about FinalBuilder Server was the per user licensing. Managing user licenses is easy when you have a small local team, but for larger distributed teams it becomes problematic. Most build servers have lots of projects but they are typically only running a few projects concurrently. Also, by not licensing agents, it allows you to have agents with specific capabilities. Agents report their capabilities to the server and are chosen for a build based the requirments of the project and the agent's capabilities. Say for example you have a project that is rarely built and it uses a specific tool and only installed on one machine, installing an agent on that machine will not tie up a license, it will only use a license when that project is being built.

Moving from FinalBuilder Server

There is unfortunately no direct migration from FinalBuilder Server. The two products are very different, so unfortunately the only option at this time is to start from scratch. We do have someone working on migration scripts, but those scripts will not get you fully up and running in Continua CI. The main issue has to do with where the FinalBuilder project files live in FB Server (on the server) vs Continua CI (in your version control system).

I recommend reading this page to help understand the different concepts between the two products.

How much will I have to pay when it's released?

If you have a current FinalBuilder Server Users Software Assurance Subscription at the time of release, we will convert your FinalBuilder Server User licenses into Continua Concurrent Build licenses (2 users = 1 concurrent build license).

New Concurrent Build licenses will be priced at US$199.

How do I get it?

The beta download links are pinned at the top of the Continua CI General Discussion forum

Can I see some Documentation?

Yes, the product documentation is here. The documentation is still being written however there is fair bit there already.

What if I find a bug?

Please post as much information as you can about your environment, the build of Continua CI you are using and the bug in the Continua CI Bug Reports forum.

DUnit and FinalBuilder/FinalBuilder Server - better integration.

Sun, 14 Nov 2010 03:00:00 GMT

FinalBuilder has had an NUnit action for some time now, but for DUnit we have always advocated just compiling the unit test executable as a console app using the TextTestRunner, and using the Execute Program action. This has worked fine, however it doesn't provide the same sort of integration into FinalBuilder Server as the NUnit action provides.

FinalBuilder 7.0.0.848 or later includes a new DUnit action. This action is designed to run DUnit test applications that are written as console apps, and use the FinalBuilder.XMLTestRunner.pas file to run the unit tests. This unit produces and xml report file in the same format as NUnit, which means that FinalBuilder already knows how to parse it. Also included in the FinalBuilder\DUnit folder is an XSL stylesheet and a CSS file to transform the xml report file to html (which can be done using the TransformXML action. The FinalBuilder.XMLTestRunner is a combination of the xml test runner and the text test runner. It still writes out to the console (which the action sends to the FinalBuilder log) and it also writes the xml report file.

When the DUnit action is used under FinaBuilder Server 7.x - the DUnit results are shown on the Status page :

and in a separate tab on the Build Log page :

The Passes and Failures can be inspected by clicking on the green or red buttons.

The FinalBuilder\DUnit folder also includes a simple example test application which shows how to structure your test executable to use the FinalBuilder.XMLTestRunner.

FinalBuilder 7.0.0.848 is available - disclaimer - please note it is a Test build, which means it's a build which contains bug fixes and or new features since the last official update, but has not had the same testing applied to it as an official update build would.

Broken the Build? Time to get your just desserts

Thu, 08 Jan 2009 03:00:00 GMT

Suma, a frustrated stackoverflow member, recently asked "what other teams do when someone breaks the build?"

The answers, including photo evidence, were definitely some of the more humourous I've seen on stackoverflow.

I think I prefer Jeff Atwood's penance of doughnuts over physical foam assault and humiliation, but that's just because of my sweet tooth and not my kindheartedness.

Image source: Jeff Atwood on stackoverflow.com

If you fear being the target of a Nerf assault, perhaps FinalBuilder Server can help with its Build Responsibility flag. By taking responsibility for fixing the build you can mitigate the wrath of angry team members.

Pervasiveness of Continuous Integration

Tue, 02 Sep 2008 04:00:00 GMT

Do you currently use a Continuous Integration system?

Since releasing the full featured FBServer in April, we’ve seen healthy growth in its adoption as a Continuous Integration Server; however, the 2008 FB Survey showed quite low adoption of Continuous Integration systems in general among FinalBuilder users.

More importantly, of those not using any CI system, 2/3’s did not intend to start using a CI system in the next 12 months!

Do you plan to start using a Continuous Integration system within the next 12 months?

For users of an automated build tool, most of whom have free access to a very easy-to-configure Continuous Integration server, these are incredibly low proportions! I can only speculate that perhaps the benefits of CI aren’t as well known, or appreciated, as the benefits of a fully automated build and release process.

---

This is the 3rd post in a series discussing insights uncovered in the 2008 FinalBuilder survey.

Big day today...

Mon, 21 May 2007 04:00:00 GMT

A day of releases today. FinalBuilder 5.5 is released today, and so is our newest product, FinalBuilder Server!

FinalBuilder 5.5 adds plenty of minor enhancements (including support for CodeGear Delphi 2007), bug fixes, etc, but the main thing is that the Professional version now gets a license of FinalBuilder Server thrown in! That's how we're justifying the jump from 5.0 to 5.5 :) We've already received a ton of very positive feedback on FinalBuilder Server, and I must say that it is quite nice to use.

In a nutshell, FinalBuilder Server is a web interface for centralizing and managing your builds. It relies on the FinalBuilder FBCMD.exe underneath as the build engine, but there are significant differences especially as far as logging is concerned. There is now a separate logging server, and FBCMD redirects all the logging to that server. This means that you can run more than one instance of the same project at the same time - plus of course FB Server needs access to the logs during and after the builds so that it can display the log output, statistics, build history etc.

FinalBuilder Server has been almost a year in development, and we've had quite a long beta period for it too. We have really been concentrating on ease-of-use and quality. Many features were put on the todo list instead of implemented straight away because the number one goal was to build a very solid base to work on. It's been running the FinalBuilder, FinalBuilder Server, and Automise builds for almost 5 months now, and we've had a fair number of customers use it during the beta - so, finally, today is the day for it's first release :)

More information on FinalBuilder Server here: https://www.finalbuilder.com/finalbuilder-server

Also - I forgot to blog about it before, but Automise 2 was released a couple of weeks ago. We added over 140 actions - there's some seriously cool stuff in there :)