In a recent post, XebiaLabs' CTO Vincent Partington discussed some important organizational topics you will want to address while introducing deployment automation using Deployit.
Preparing your organization is, of course, crucial to getting maximum possible benefits from deployment automation. A few technical considerations also apply when introducing Deployit, and here we'd like to go into these so that you can be sure your infrastructure is ready when it comes to carrying out your first fully automated deployment.
(more...)

Tags: Deployit
Filed under Deployment, Middleware, Process, Xebia Labs | No Comments »

Last month XebiaLabs released the Personal Edition of Deployit. Now that people have been able to experience in a simple environment how Deployit can work for them, you might wonder how to start using Deployit for real in your development and operations environments. In this blog and its sequel we will go over the things we've learned when starting to use Deployit. We will also be covering this subject (and a lot of other subjects!) in our upcoming Deployit webinar series.

There are organizational and technical consequences to introducing a deployment automation product. But let's focus on the organizational aspects first. These pointers will help you get started with implementing Deployit in your organization in the right way.
(more...)

Filed under Deployment, Middleware, Process, Xebia Labs | No Comments »

We've already been talking about Deployit, XebiaLabs' deployment automation product, for some time. Now we are proud to announce that you can try Deployit for yourself by downloading the Personal Edition of Deployit!

If you don't know what Deployit is yet, have a look at the movie below!

To summarize; Deployit will automate your Java EE application deployments and, because of the overview it offers and the history it keeps, it also allows you to manage and optimize your deployments.
(more...)

Filed under Deployment, Java, Middleware, Xebia Labs, websphere | No Comments »

Last year, before the Christmas holidays , I described how we do middleware integration testing at XebiaLabs and I described the way we deploy test servlets by wrapping them in WAR and EAR files that get generated on the fly. There is only one thing left to explain; how do we integrate these tests into a continuous build using Maven and VMware?

Running the middleware integration tests

So let's start with the Maven configuration. As I mentioned in the first blog of this series, the integration tests are recognizable by the fact that the classnames end in Itest. That means they won't get picked up by the default configuration of the Maven Surefire plugin. And that is fortunate because we don't always want to run these tests. Firstly they require a very specific test setup (the application server configurations should be in an expected state, see below) and secondly they can take a long time to complete and that would get in the way of the quick turnaround we want from commit builds in our continuous integration system.
(more...)

Filed under Deployment, JBoss, Java, Maven, Middleware, TDD, Testing, Virtualization, Xebia Labs | 2 Comments »

I'm going to start a series on the future of deployment. How and what do we deploy in, say 5 years or so. Of-course this is my opinion and please add your own ideas in the comments below.

To start this series off i'm going to talk about the current state of things, or at least what i see at a lot of enterprise customers. Most of the enterprises i've been at have physical servers which are used by numerous applications from different development teams. Some of these servers are old and have been in maintenance by operations for years (+4 years ). That means that the server has changed, lots of deltas, aka, patches, deployments etc. have been applied and as my colleague Vincent has stated applying deltas has its cons Of-course i'm talking about servers and not applications and the same rules do not apply, or do they?

(more...)

Filed under Deployment, Middleware, Virtualization, Xebia Labs | 2 Comments »

Last week I wrote about the approach we use at XebiaLabs to test the integrations with the different middleware products our Java EE deployment automation product Deployit supports.

The blog finished with the promise that I would discuss how to test that an application can really use the configurations that our middleware integrations (a.k.a. steps) create. But before we delve into that, let us first answer the question as to why we need this. If the code can configure a datasource without the application server, it must be OK for an application to use it, right? Well, not always. While WebSphere and WebLogic contain some functionality to test the connection to the database and thereby verify whether the datasource has been configured correctly, this functionality is not available for other configurations such as JMS settings. And JBoss has no such functionality at all. So the question is: how can we prove that an application can really work with the configurations created by our steps?
(more...)

Filed under Deployment, Java, Maven, Middleware, TDD, Testing, Virtualization, Xebia Labs | No Comments »

For Deployit, XebiaLabs' automated deployment product for Java EE applications, we are always building and modifying integrations with middleware systems such as IBM WebSphere, Oracle WebLogic and the JBoss application server. These integrations are small enough so that they can be rearranged to get many different deployment scenarios. A typical step, as we call these integrations, would be "Create WebSphere datasource" or "Restart WebLogic Server". So how do the test that code?

We've had some success using FitNesse and VMware to do integration tests on our deployment scenarios. But there were a few problems with this apporach:

• We could only test complete deployment scenarios in this way. If we wanted to test just a single step, we had to make a deployment scenario that used that step just to be able to test it.
• Because FitNesse does not provide any feedback while a test is running and the steps, let alone the deployment scenarios, can sometimes take a while to execute, there was little feedback on the progress.
• While it is possible to debug a FitNesse Fixture using Eclipse the process is not very convenient when debugging a technical component such as this step.
• To verify that a deployment scenario has executed succesfully we had to extend our FitNesse Fixture often. And while debugging code under test in FitNesse is complicated enough, debugging a Fixture is even harder!

Clearly we needed a different approach if we wanted to develop new steps easily.
(more...)

Filed under Deployment, Java, Maven, Middleware, TDD, Testing, Virtualization, Xebia Labs, websphere | 3 Comments »

In my previous blog on the deployment capabilities of the major application servers, I asked, as a joke, whether anybody knew the difference between containment paths, configuration IDs and object names in WebSphere's scripting interface wsadmin. I didn't get (nor expect ) an answer. But instead of keeping you in the dark, this blog will explain the difference between these three and how you can translate between them.

Configuration ID

Configuration IDs are the most common id you will encounter when working with wsadmin. They uniquely specify an element in the configuration of WebSphere Application Server and are needed to modify the configuration with one of the commands in the AdminConfig object.

(more...)

Filed under Deployment, Java, Xebia Labs, websphere | 2 Comments »

At XebiaLabs we know a thing or two about the automated deployment of Java EE applications . One thing that strikes me as odd is the fact that the people you would expect to know most about application deployment, the application server vendors, don't seem to understand the problem at all.

On one of our previous blogs, you can read up on what we see as the full scope of a Java EE application deployment. The short version is this:

• It's more than just deploying an EAR file or a WAR file. For starters, it can involve more than one of these.
• Most applications also need other kinds of artifacts to be deployed, such as static content for the webserver or static configuration files to be read by the Java code on startup.
• You'll also need to configure Java EE resources such as data sources, JMS providers, etc.
• In most cases you need to configure the middleware itself too. Think about creating and configuring application server clusters, or setting up Apache virtual host configurations.
• All this needs to happen in the right order to minimize (or prevent) downtime of the application during deployment and improve speed of the deployment.

So what do the application server vendors make of this?
(more...)

Filed under Deployment, Xebia Labs | 6 Comments »

My colleague Robert van Loghem and I have been blogging about Java EE deployment the last few weeks. And that is not without a reason; we have built Deployit, a product to automate Java EE deployments. We've already mentioned it before in some of our podcasts and blogs, so now might be a good time to explain some of the concepts behind our product.

The problem

The problem our product is addressing is that Java EE deployments are tedious and unpredictable affairs that can also be very dependent on specific knowledge. The guys at ZeroTurnaround conducted a survey on Java EE redeployment and restart times. The results are interesting, especially when you consider that these times are for a redeployment in a development environment. Consider the challenges of doing this in a production environment with an application server cluster, multiple web servers, and databases and so forth that all need to be configured and restarted using a full redeployment scenario. I believe that the only way to do deploy applicaitons in a reliable and efficient manner is to automate this task. Something that IT analysts such as Gartner and Forrester also see as an emerging and hot topic.
(more...)

Filed under Deployment, Middleware, Xebia Labs | No Comments »