Feeds:
Posts
Comments

Archive for September, 2010

Regularly, the Jumpstart team members are invited to assist customers who either decided to adopt Rational Team Concert (RTC) and need to adapt their Maven build and deployment process to RTC or, as an “open source shop” wants to challenge RTC on this subject.

So, I would like to share with you some recommendations which helped our customers  in dealing with Maven when it meets RTC

Maven-RTC integration: first impression

Generally, the customer first impression, when we show the Maven/RTC integration, is pretty good.

Actually, RTC-Maven integration is straight forward (cf: Jazz-Wiki: A Jazz-based Maven build); once the user has chosen to create a Build Definition using the Maven Build template, he needs to specify:

  1. in which folder is stored the pom.xml (Project location) and
  2. which Maven goals to reach during the build. That’s it!

Unfortunately, this is not always so easy… Each customer I have met has had some particularities that I would like to share in his post.
(more…)

Advertisements

Read Full Post »

They did it!

Since this morning we can download the latest RTC milestone: RTC 3.0 RC0.

Enjoy it and post your feedback, your defects or your enhancements on the community site: http://jazz.net

Read Full Post »

This spring Steve Wasleski (Jazz Jumpstart team), Steve Speicher (OSLC and Change Management Architect) and myself built a workshop on Jazz Extensibility for Innovate 2010, the Rational Software Conference. This workshop, labs and source code, has been published on jazz.net under this link: OSLC Workshop and Jazz Extensions Workshop.

During the labs elaboration, I had to understand how the Jazz Team Server manages the authentication: Form-based Authentication and how to interact with it as a client. Because it took me some times to figure it out, I think this blog is a good place to extract this part of the lab and share it with the “Rest of the World”.

The Form-Based Authentication is a three steps process:

  1. The client requests a protected resource.
  2. If the client is not authenticated, the server redirects to the login page, and the client has to fill the form and submit it to the server.
  3. If the login has succeeded, the client submits a request the protected resource again and should get it back.

Clearly, the behavior doesn’t seem obvious because the process seems to indicate that it requires a human behind interaction.
Actually, you can perfectly emulate and manage this interaction programmatically.
Let say you want to reach a resource designated by a URL (protectedResource) which is protected by a Form-based authentication.
The following snippet code describes how you will implement this 3-steps process:

HttpGet documentGet = new HttpGet(protectedResource);
documentGet.addHeader("accept", mediaType);
//
// Step (1): Request the protected resource
//
HttpResponse response = httpClient.execute(documentGet);
if (response.getStatusLine().getStatusCode() == 200) {
   Header header =
         response.getFirstHeader("x-com-ibm-team-repository-web-auth-msg");
   if ((header!=null) && ("authrequired".equals(header.getValue()))) {
      response.getEntity().consumeContent();
      // The server requires an authentication: Create the login form
      HttpPost formPost = new HttpPost(serverURI+"/j_security_check");
      List nvps = new ArrayList();
      nvps.add(new BasicNameValuePair("j_username", login));
      nvps.add(new BasicNameValuePair("j_password", password));
      formPost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
      //
      // Step (2): The client submits the login form
      //
      HttpResponse formResponse = httpClient.execute(formPost);
      header = formResponse.getFirstHeader("X-com-ibm-team-repository-web-auth-msg");
      if ((header!=null) && ("authfailed".equals(header.getValue()))) {
         // The login failed
         throw new InvalidCredentialsException("Authentication failed");
      } else {
         // The login succeed
         formResponse.getEntity().consumeContent();
         //
         // Step (3): Request again the protected resource
         //
         HttpGet documentGet2 = new HttpGet(protectedResource);
         documentGet2.addHeader("accept", mediaType);
         return httpClient.execute(documentGet2);
      }
   }
return response;

This code is based on Apache HTTP Client (Release 4.0.1) APIs.

I hope it will help.

-Philippe

Read Full Post »

Deploying for the first time a new feature on a Jazz Team Server (JTS) is pretty straight forward:

  1. Create an Eclipse update site including the feature (e.g. com.my.addendum) you want to add to the JTS,
  2. Copy the site.xml file, the /features and the /plugins folders in a com.my.addendum directory located under the <root>/jazz/server/ folder
  3. Create a com.my.addendum.ini file under the /jazz/server/conf/jazz/provision_profiles folder
  4. Open the new ini file with Notepad and enter these two lines:
    url=file:../com.my.addendum
    featureid=com.my.addendum
  5. Save the ini file
  6. Restart your JTS and you are all set

Now, if you try to apply the same deployment process to update your feature, you will realize that the JTS keeps the same code; the bundles are actually cached.

So, to reset this cache, you have two main options:

  • Either by accessing to the JTS internal features links:
    1. Start your JTS
    2. Open your web browser on https://<yourserver&gt;:<port>/jazz/admin?internal=true
    3. Once you have logged on, on the bottom-left of the web UI, you will discover a set of links that you never saw before:
    4. Click on Server Reset
    5. A button labeled Request Server Reset will appear
    6. Press the button to request a reset of the server. The server will be reset during the next start up…
    7. Restart your JTS and your are all set
  • You can also directly access to this feature calling this URL:
    • https://<yourserver>:<port>/jazz/admin/cmd/requestReset

I hope it will help

Special thanks to my buddy Eric Jodet from the Jazz L3 Maintenance who shown me the trick…

-Philippe

Read Full Post »

The Jazz Jumpstart team

I recall when Paul Vanderlei invited me to join his new team, the first thing I did after his call was to google for Jumpstart.

You can imagine, as a French native speaker,  my surprise when I discovered that a “Jumpstart” is this device that helps you start a car.

Since that time I understood what the Jazz project was expecting from our team: provide this (minimal) amount of energy which can help close a deal or deploy a Jazz workbench in a customer environment.

Most of the Jumpstart team engagements are specific, so I would like to use this blog to gather some interesting points I learned with and/or I taught to my customers when they are suing a Jazz workbench like Rational Team Concert.

Your feedbacks are very welcome. I will do my best to take them under consideration.

Read Full Post »

Let’s start it…

I would like to use this blog to share my professional points of interests on different subjects. As a member of the Jazz Jumpstart team, I will mainly talk about the collaborative platform developed by IBM Rational. Nevertheless, if I find other interesting topics I will certainly use this blog to gather them.

So welcome to my technical blog…

Read Full Post »