Git
- Last updated
- Save as PDF
Overview
When dealing with millions of lines of code, it’s very important to know why the code was written in the first place. For safety-critical or highly regulated products, it is absolutely essential. However, manually linking code changes to the originating feature or defect is both tedious and error prone.
Note: Due to the nature of how Git commits are utilized and architected, they can only flow one-way out of Hub, as part of an Outbound-Only collection.
Key Features and Benefits
Software delivery organizations integrate their Git-based repositories, which provide source code version control, and the other tools that house the originating requirements, stories, defects and tests. Thanks to integration, developers can automate code traceability and link lines of source code they changed to the originating artifact (requirement, user story, defect or task).
Code traceability is implemented in one of two ways. In the first, upon ‘code commit’, an existing artifact is updated with a link to the change set. In the second, upon ‘code commit’, a new artifact for the change set is created and linked to an existing artifact (requirement, user story, defect or task). Hub supports both these flavors of code traceability between Git-based repositories - GitHub, GitLab, BitBucket, Gerrit, Gitea and Azure Repos - and tens of popular tools in the software delivery toolchain, like Jira, Azure DevOps, Jama, ServiceNow and Digital.ai Agility.
Common Integration Patterns
Demo Videos
Supported Git Hosting Services
The Git connector can connect to the following hosting services in order to flow code commits and related commit information:
- Bitbucket
- Gerrit
- Gitea
- GitHub
- GitLab
- Visual Studio Team Services
- Custom URL
Connector Setup Details
This section describes the basic steps needed to prepare your Git instance for use with Hub. Note that additional fields for synchronization or configuration of queries may be required depending on the requirements of your integration.
Minimal User Permissions & Hub User
We recommend that you create a new user within your external tool, to be used only for your Hub integration. This is the user information you will enter when setting up your repository connection within Planview Hub. By creating a new user, you will ensure that the correct permissions are granted, and allow for traceability of the modifications that are made by the synchronization. Please note, for a Git connection, your user will need to have a secure password or key. Hub will not allow you to save a repository connection utilizing a weak password/token, such as 'tasktop.'
See the Git documentation to learn how to create a custom user in Git.
In order to use the Git connector, you must ensure:
-
Your user credentials have sufficient permission to clone the repository
Connecting to the Git Repository
Standard Authentication
Required Fields:
- Location/Connection URL
- Example Format: http://github.com/tasktop/repository.git
- This should be the URL that the Git repository can be cloned from
- Git Hosting Service
- Select the hosting service (such as Bitbucket, GitHub, etc.) that you are utilizing
- Username
- Password
Optional Fields:
- Git Hosting Web URL
- The base URL for the service hosting the repository, (e.g., https://github.com or https://gitlab.com). This will be used to construct URLs for artifacts synchronized via Hub. If empty, Hub will attempt to determine the URL, but it may be incorrect.
- Note: If "Custom URL" is selected as the hosting service, this URL should contain a (commit) placeholder for the commit ID, (i.e., https://customhosting/commits/(commit))
- Connection Security: If checked, insecure connections to this repository will be allowed. See details here.
Note: Proxy configuration for the Git repository cannot be configured within the Hub UI. It must be manually configured for the Hub installation by adding the http proxy properties to the Catalina configuration. See more details here.
Learn more about how to set up your repository in Planview Hub here.
SSH Public/Private Key
Required Fields:
- Location/Connection URL
- Example Format: http://github.com/tasktop/repository.git
- This should be the URL that the Git repository can be cloned from
- Git Hosting Service
- Select the hosting service (such as Bitbucket, GitHub, etc.) that you are utilizing
- Private Key
- Private Key Passphrase
You can learn about this authentication method here.
Optional Fields:
- Git Hosting Web URL
- The base URL for the service hosting the repository, (e.g., https://github.com or https://gitlab.com). This will be used to construct URLs for artifacts synchronized via Hub. If empty, Hub will attempt to determine the URL, but it may be incorrect. If "Custom URL" is selected as the hosting service, this URL should contain a (commit) placeholder for the commit ID (i.e., https://customhosting/commits/(commit))
- Connection Security: If checked, insecure connections to this repository will be allowed. See details here.
Other Configuration Settings
Flowing Source Code Information in Hub
Hub comes with two pre-built integration templates which allow you to easily flow source code information such as code commits or changesets from Git to other tools such as Jama or Jira.
To learn more about how to configure these integrations, please review the following pages:
Person Reconciliation
For person reconciliation, the following fields are available:
ID used in person reconciliation script |
Label in Git |
---|---|
person-id |
user.email |
person-email |
user.email |
person-display-name |
user.name |
Learn more about how to configure person reconciliation in Planview Hub here.
Full Scan
In general, a full scan is not required to synchronize updates from this repository. However, it is possible that some read-only fields may require a full scan. Please consult with customer care for additional details.
Special Use Cases
Flowing Git Commits to Jama
Many organizations may need to gain visibility into the commits Developer's are making to their codebase. As a Hub user, you may consider flowing commits from Git to a Requirements Management tool. A large driver for this scenario is to reduce overhead for developers working in the SCM tool, by enabling an integration that flows commits and their relevant information to the Requirements Management tool.
The special use case details outlined below involve flowing Git commits to Jama. When configuring this use case, some important implications should be noted when setting up the Hub integration - This is due to Jama's underlying architecture:
To create new 'code' artifacts in Jama (or other custom artifact types) and have them correspond to 'commits' in Git, you must:
- Create a 'set' in Jama for "code" (or whichever artifact type the commit will flow to in Jama). This must be in the same project or 'component' as the artifacts the commits will be referencing.
- If a 'set' does not exist, an error will occur instructing you to create a 'set' for the "code" to live in.
- If there is no referenced artifact, the commit will be created in a "code" set in the parent project.
- If the referenced 'requirement' artifact is in a 'component', there must also be a "code" set in the same 'component' or else an error will occur.
- Limitation: You cannot put the "code" artifacts into a 'folder' within a Jama 'set'. "Code" artifacts must be created directly under a 'set'.
- If there are multiple "code" sets in a component or project, the commit will be created in the first project based on how Jama orders them.
Supported Features
Special Features Supported
You can learn more about special features in Planview Hub here.
Feature |
Custom Type Supported? |
Applicable Hub Version |
Applicable Repository Versions |
---|---|---|---|
Time Worked (Worklogs) Impersonation |
|
|
|
Comments Impersonation Public/Private |
|||
Attachments Impersonation |
|||
State Transitions |
Supported Artifact Types
Learn about the difference between containers and work items in Planview Hub here.
Supported Work Items
Supported Work Item Type |
Applicable Hub Versions |
Applicable Repository Versions |
Unique URL? |
---|---|---|---|
Commits |
Planview Hub: 18.4.1 and later |
Any supported repository version: |
Yes (depends on hosting provider) |
Supported Containers
Containers that can synchronize between repositories |
Applicable Hub Versions |
Applicable Repository Versions |
Unique URL? |
---|---|---|---|
N/A |
|||
Containers used to define the boundary of a collection (when clicking 'Manage Branches' on a collection) |
|||
Branches |
Planview Hub: 18.4.1 and later |
Any supported repository version: |
N/A |
Containers used for artifact routing |
|
|
|
N/A |
|
|
|
Learn more about containment in Planview Hub here.
Supported Field Types
Note: If one field of a given type is supported, others that are also that type in theory should also work. However, sometimes there are instances in which this is not the case due to the repository. So, while we can claim support for fields at the type level, there is a chance that some specific fields of a given type will not synchronize properly.
Field Type |
Does Hub support custom fields of this type? |
How is field type referenced in the repository? |
Sample Repository Fields Supported |
Particular Repository Fields NOT Supported |
---|---|---|---|---|
String |
N/A |
Commit Hash Commit Message Short Commit Message (the first line of the commit message) |
||
Single-select |
N/A |
Type |
||
Multi-select |
N/A |
Branches |
||
Boolean |
||||
Date |
|
|
|
|
Date Time |
N/A |
Committed Authored |
||
Duration |
|
|
|
|
Double |
|
|
|
|
Long |
||||
Person |
N/A |
Committer Author |
||
Persons |
||||
Relationship(s) |
||||
Rich Text |
|
|
|
|
Location |
N/A |
URL |
||
Web Links |
|
|
|
|
Functional Limitations
Category |
Limitation |
Applicable Hub Version |
Applicable Repository Version |
---|---|---|---|
Third Party Functional Limitation |
Commits Commits cannot be created or modified within Git. Updates can only flow out of Git and into a separate target repository. |
Planview Hub: 18.4.1 and later |
Any supported repository version: |
Third Party Functional Limitation |
Change Detection Commits will not change, thus there is no change detection. If a commit appears on a branch that it did not when it was previously processed, the only way to re-detect this is to reprocess the commit. |
Planview Hub: 18.4.1 and later |
Any supported repository version: |