In the world of modern software development, effective collaboration and version control are essential. As projects grow in size and complexity, development teams need structured workflows that allow seamless collaboration, controlled integration of changes, and reduced risk of conflicts. This is where the Integration Manager Workflow comes into play.
In this comprehensive blog, we will walk you through how Integration Manager Workflows operate, how pull requests streamline collaboration, and how this methodology applies to both Git and Mercurial users. We will also explore how advanced hierarchical setups empower large teams to maintain control over codebases across multiple levels.
What is Integration Manager Workflow?
The Integration Manager Workflow is a tried-and-tested collaboration model where developers contribute to a project through controlled, structured pull requests. This workflow ensures that all changes to the central, “official” repository pass through an integration manager who reviews, accepts, or rejects contributions.
Unlike other workflows that might be specific to a particular distributed version control system (DVCS), codeBeamer uniquely supports the Integration Manager Workflow in a DVCS-agnostic manner. Whether you use Git or Mercurial, this workflow provides a consistent approach to collaboration and integration.
Key Components of the Integration Manager Workflow
The Integration Manager Workflow consists of several key repository types:
Blessed Repository: The official, server-side repository that contains the authoritative version of the source code. All product builds and deployments originate from this repository.
Integration Manager Repository: A local clone of the blessed repository used by the integration manager, who is often a senior developer or team lead.
Developer Public Repositories: Server-side forks of the blessed repository where individual developers publish their work.
Developer Private Repositories: Local clones on the developers’ machines where day-to-day development happens.
This structure ensures clear boundaries between development, review, and official code integration, reducing conflicts and enhancing code quality.
Integration Manager Workflow: Step-by-Step
1. Forking the Repository
The workflow begins with developers creating a public fork of the blessed repository. In codeBeamer, this is easily done by navigating to the blessed repository and clicking “Fork,” then providing a name and description for the new repository.
After creating the public fork, developers clone it to their local machine for private development using:
git clone <clone-url-of-your-developer-public>
Or for Mercurial:
hg clone <clone-url-of-your-developer-public>
Developers then work within these private repositories, committing changes and pushing them back to their public forks.
2. Sending Pull Requests
Once a developer completes a feature, bug fix, or set of changes, they send a pull request to the blessed repository. In codeBeamer, this is done by navigating to the developer public repository and clicking “Send Pull Request”—a streamlined process supported by robust codeBeamer services for managing collaborative development workflows.
The pull request summarizes the changes, explains their purpose, and provides relevant details for reviewers. Multiple integrators can be invited to participate in the review process, promoting collaborative evaluation and higher code quality.
3. Viewing and Managing Pull Requests
Pull requests appear in the “Pull Requests” tab of the target repository, with filtering options for status and visibility into pending requests. Integration managers receive email notifications for new pull requests.
The review process often includes discussions and peer code reviews via comments within the pull request.
Dig Deeper: Codebeamer 3.0 is Coming!
4. Accepting or Rejecting Pull Requests
Integration managers assess the proposed changes. They can:
Accept and merge changes directly if no conflicts exist.
Reject changes with feedback.
Allow the developer to revoke the pull request if necessary.
This structured process ensures all code modifications meet quality standards and align with project goals.
5. Merging Pull Requests via Web Interface
If no conflicts are present, integration managers can use the codeBeamer web interface to merge the pull request with a simple click. This updates the blessed repository with the approved changes.
Developers must then synchronize their local clones to reflect the latest state:
git pull <upstream-remote> master
Or for Mercurial:
hg pull -u <upstream-symbolic-name>
6. Manually Resolving Merge Conflicts
When merge conflicts arise, developers or integration managers resolve them manually. With Git:
git pull <remote-name> master
# Resolve conflicts in editor
git commit -a -m “Resolved conflicts”
git push
With Mercurial:
hg pull -u <symbolic-name>
hg resolve -m <file-name>
hg commit -m “Resolved conflicts”
hg push
codeBeamer automatically updates the pull request status to “completed” once the merge is finalized.
Synchronizing Local Clones with Upstream Repositories
To minimize merge conflicts and stay aligned with the latest codebase, developers regularly sync their local private repositories with the blessed repository.
Git Example:
git remote add upstream <blessed-repo-url>
git pull upstream master
Mercurial Example:
Edit .hg/hgrc to add:
[paths]
hgtest-blessed = ssh://user@server.com/hg/blessed-repo
Then sync with:
hg pull -u hgtest-blessed
Frequent synchronization ensures a smoother development experience and reduces integration headaches.
Advanced Integration Manager Workflows: Multi-Level Hierarchies
For large organizations with multiple teams, a deeper hierarchy improves control and structure. A typical setup might look like this:
blessed
|
|– team-a-public
| |– developer1-public
| |– developer2-public
|
|– team-b-public
| |– developer3-public
| |– developer4-public
Benefits of Multi-Level Workflows:
Team leads act as intermediate integrators, reviewing and merging changes before they reach the blessed repository.
Greater control over what code reaches the official codebase.
Scalability for organizations with multiple teams or departments.
Flexibility to introduce additional review and quality gates at team levels.
This hierarchical approach can be expanded to accommodate organizations of any size or complexity.
Why Choose codeBeamer for Integration Manager Workflows?
Unlike many tools that are tightly bound to either Git or Mercurial, codeBeamer implements the Integration Manager Workflow in a DVCS-agnostic way. This flexibility enables organizations with mixed version control environments to adopt consistent workflows across all teams—especially when working with an experienced Codebeamer ALM partner.
codeBeamer’s Key Advantages:
Unified workflow for both Git and Mercurial teams.
Intuitive pull request management with rich collaboration tools.
Visual repository hierarchy and clear project structure.
Streamlined conflict resolution and automated pull request status updates.
Conclusion: Structured Collaboration for Modern Teams
In fast-paced development environments, ad hoc collaboration and unstructured code integration can quickly lead to chaos. The Integration Manager Workflow brings order, accountability, and quality control to distributed development.
Whether you’re a solo developer or part of a large, multi-level organization, this workflow ensures that:
Code contributions are reviewed and approved before integration.
Developers maintain control over their work while contributing to shared projects.
Teams minimize conflicts, enhance code quality, and promote collaboration.
By leveraging codeBeamer, including its powerful codeBeamer Requirements Management capabilities, and following Integration Manager Workflows, development teams can work smarter, integrate with confidence, and build reliable software products.
Ready to streamline your development workflow? Embrace the Integration Manager model with Git, Mercurial, and codeBeamer—partner with a trusted digital transformation company to maximize your results. Contact us today to learn how we can help transform your development process.
