IBM Rational Team Concert (RTC) is a powerful tool for managing source code, tracking work items, and streamlining software development workflows. It helps teams collaborate effectively, integrate with CI/CD pipelines, and maintain control over their projects. By using RTC, organizations can improve development efficiency and maintain high-quality software releases.
Prerequisites
Before getting started, you’ll need a Red Hat Linux server, an RTC server installation (or access to an existing one), and a user account with the necessary permissions. Some familiarity with Linux commands will also be helpful.
Step 1: Installing the RTC Client
The first step is to set up the RTC client, which allows developers to interact with the RTC server, manage source code, and work with repositories. To do this, you need to download the RTC Eclipse Client from IBM’s website. Once you have the installation package, move it to your Red Hat Linux machine and extract it with:
mkdir -p /opt/rtc-client
cd /opt/rtc-client
unzip /path/to/RTC-Eclipse-Client.zip
After extracting the files, navigate to the installation directory and launch the client:
cd /opt/rtc-client/eclipse
./eclipse &
This will open the RTC client interface. From here, you can configure your connection to the RTC server, set up workspaces, and start managing your projects.
Step 2: Connecting to the RTC Server
Now that the RTC client is up and running, you need to connect it to your RTC server. Open the Team Artifacts view in Eclipse and click on Create a Repository Connection. Enter your RTC server URL and provide your login credentials. Once authenticated, you’ll see the available projects and repositories.
To verify your connection from the command line, you can also use the RTC command-line interface (CLI). Install the RTC CLI tools and run:
lscm login -r https://rtc-server.example.com -u your_username -P your_password
If the login is successful, you’re now connected and ready to start working with RTC repositories.
Step 3: Setting Up a New Repository Workspace
To begin working with source code in RTC, you need to create a repository workspace. This acts as your local working copy of the project. In the RTC client, navigate to Source Control, then select New Repository Workspace. Choose a stream to flow changes from and click Finish.
From the command line, you can create a workspace using:
lscm create workspace "My_Workspace" -r https://rtc-server.example.com
After setting up your workspace, you’ll want to load its contents to your local machine. Run the following command to bring down the source code:
lscm load "My_Workspace" -d ~/rtc-projects
This will create a directory with your project files, allowing you to start making changes.
Step 4: Managing Source Code with RTC
With your workspace ready, you can now work on your source code, make changes, and commit them back to the repository. Navigate to your project directory and make some modifications. Once you’re done, use the following command to check which files have changed:
lscm status
If the changes look good, add them to your pending changes:
lscm checkin -r https://rtc-server.example.com -d ~/rtc-projects
After checking in the changes, you need to deliver them to the shared stream so others can see your updates:
lscm deliver -r https://rtc-server.example.com
At this point, your changes are now part of the main repository, and other team members can access them.
Step 5: Automating Builds with RTC Build Engine
To streamline development, you can set up automated builds using the RTC Build Engine. This ensures that your changes are continuously integrated and tested. First, install the RTC Build System Toolkit and configure the build agent on your Red Hat Linux server.
Download and extract the build toolkit:
mkdir -p /opt/rtc-build
cd /opt/rtc-build
unzip /path/to/RTC-Build-System-Toolkit.zip
Next, create a build engine definition in the RTC web interface. Provide a name, select the build agent, and define a build script. On your server, start the build agent using:
cd /opt/rtc-build/jazz/buildsystem/buildengine/eclipse
./buildengine.sh -repository https://rtc-server.example.com -engine MyBuildEngine
Once the build engine is running, you can trigger builds manually or automatically when new changes are delivered. This helps ensure that your code is always in a deployable state.
Troubleshooting Tips
If you run into issues, here are some common solutions:
- Connection issues? Double-check your RTC server URL and make sure your credentials are correct.
- Workspace not loading? Ensure that your workspace is properly created and that you have the necessary permissions.
- Builds failing? Look at the build logs in the RTC web interface to see where the error is occurring.
Conclusion
That’s it! You’ve successfully set up IBM Rational Team Concert on Red Hat Linux and configured it for source control, workspace management, and automated builds. RTC helps teams collaborate effectively, keep track of development progress, and ensure that code changes are properly managed. Now that you’ve got the basics down, explore more advanced features like work item tracking, branching strategies, and integrations with CI/CD pipelines to optimize your development workflow.