Administering help content for web applications
Help content configurations
Video: Help content configuration options in the product
Installing help on your computer
Installing help on an intranet server
Changing help content connections
Configuring the help server for local or intranet help
Securing your help server
Configuring network connections and proxy settings
Troubleshooting the help setup
Accessing the log information
Testing remote help connections
Fixing proxy and firewall issues
Fixing Java virtual machine issues
No JAVA_HOME defined error
Help content configurations
Video: Help content configuration options in the product
Installing help on your computer
Installing help on an intranet server
Changing help content connections
Configuring the help server for local or intranet help
Securing your help server
Configuring network connections and proxy settings
Troubleshooting the help setup
Accessing the log information
Testing remote help connections
Fixing proxy and firewall issues
Fixing Java virtual machine issues
No JAVA_HOME defined error
Configuring help content for Eclipse client applications
Help content configurations
Installing help on your computer
Installing help on an intranet server
Changing help content connections
Troubleshooting the help setup
Accessing the log information
Testing remote help connections
Fixing proxy and firewall issues
Fixing Java virtual machine issues
No JAVA_HOME defined error
Help content configurations
Installing help on your computer
Installing help on an intranet server
Changing help content connections
Troubleshooting the help setup
Accessing the log information
Testing remote help connections
Fixing proxy and firewall issues
Fixing Java virtual machine issues
No JAVA_HOME defined error
Configuring help content for RCP applications
Help content configurations
Installing help on your computer
Installing help on an intranet server
Changing help content connections
Configuring the help server for local or intranet help
Securing your help server
Configuring network connections and proxy settings
Troubleshooting the help setup
Accessing the log information
Testing remote help connections
Fixing proxy and firewall issues
Fixing Java virtual machine issues
No JAVA_HOME defined error
Help content configurations
Installing help on your computer
Installing help on an intranet server
Changing help content connections
Configuring the help server for local or intranet help
Securing your help server
Configuring network connections and proxy settings
Troubleshooting the help setup
Accessing the log information
Testing remote help connections
Fixing proxy and firewall issues
Fixing Java virtual machine issues
No JAVA_HOME defined error
Engineering Lifecycle Management
Welcome
Engineering Lifecycle Management
Overview
Overview of ELM
Products and capabilities
DOORS Next
Comparison of DOORS and DOORS Next
EWM
ETM
RMM
Reporting
ENI
Global Configuration Management
Cloud offerings
Overview
Getting started
Subscribing on the IBM Marketplace
Getting support
Licensing, subscription, and overages
Architecture
Testing IBM Cloud Data Center Latency
Security
DOORS Next professional reporting template self-service portal
Migrating your repository
Learning
Getting started with ELM
Getting started with configuration management
Learning resources
Deployment wiki
Security considerations
What's new
Video tours
Rational solution for Collaborative Lifecycle Management
Tutorials
Money that matters lifecycle scenario
Introduction
Module 1: Plan a sprint
Lesson 1.1: Propose the requirements for a sprint
Lesson 1.2: Explore design options for the sprint
Lesson 1.3: Plan the development effort
Lesson 1.4: Plan the test effort
Lesson 1.5: Assess coverage
Module 2: Complete a story
Lesson 2.1: Create test scripts
Lesson 2.2: Develop a story
Lesson 2.3: Submit a build request
Lesson 2.4: Test for defects
Lesson 2.5: Fix a defect
Lesson 2.6: Confirm that the story is done
Module 3: Stabilize the sprint
Lesson 3.1: Prepare for a sprint shutdown
Summary
Customize process in your project area and team areas
Introduction: Customize process in your project area and team areas
Lesson 1: Create a lifecycle project and assign roles
Lesson 2: Create a timeline and iterations
Lesson 3: Create a team area and add a member
Lesson 4: Explore setting permissions
Lesson 5: Create a role
Lesson 6: Configure operation behavior (CCM)
Lesson 7: Configure operation behavior (QM)
Lesson 8: Customize behavior for an iteration type
Summary: Customize process in your project area and team areas
Samples
Money that Matters sample
Scenarios
ELM agile scenario
Installing and setting up
Installing ELM products
Configuring the environment
Planning the release
Developing a vision
Organizing requirements
Planning the project
Planning the test effort
Completing plan items
Elaborating plan items
Detailing requirements
Developing
Building
Testing
Fixing defects and verifying
Querying for defects
Fixing, delivering, and building
Verifying that defects are fixed
Assessing iteration completeness
Installing
Installing ELM
Upgrading and migrating
Upgrading ELM
Integrating
ELM integrations
Integrating applications on separate Jazz servers
Establishing cross-server communication
Approving access requests
Linking between project areas
HP ALM Quality Center
JIRA
Rational Asset Manager
Administering
Administering projects
Getting started with project areas and lifecycle projects
Administering lifecycle projects
Accessing the Lifecycle Project Administration user interface
Creating lifecycle projects from a template
Lifecycle project templates
Creating a lifecycle project and adding existing project areas
Adding project areas to a lifecycle project
Replacing or removing project areas from lifecycle projects
Adding members to projects
Assigning roles from within lifecycle projects
Configuring process role relationship rules
Modifying a predefined template
Creating a lifecycle project template
Modifying an LPA template to access an RM project template
Importing lifecycle project templates
Deleting lifecycle projects
Administering project areas: Tasks for all applications (web client)
Logging in for project administrators and team leads (web)
Understanding licenses, permissions, and access control
Planning project areas
Creating project areas
Project area
Process
Creating timelines, iterations, and iteration types
Creating timelines and iterations
Timeline
Iteration and iteration types
Creating an iteration type
Modifying timelines and iterations
Creating team areas and associating work item categories
Creating a team area
Team area
Defining categories that work items can be filed against in the web client
Work item category (Filed Against)
Adding and modifying users as members of project areas and team areas
Adding existing users
Assigning roles to a member
Roles
Assigning administrative privileges
Specifying team invitation content in a template
Adding and modifying roles and permissions
Permissions
Change and Configuration Management role-based permissions
Quality Management role-based permissions
Requirements Management role-based permissions
Modifying role-based permissions
Customizing permissions for a specific time period
Customizing permissions in a team area
Adding and removing roles
Restricting read access to project areas, team areas, and artifacts
Restricting read access to project areas or team areas
Restricting access to work item categories
Using access groups to control access to artifacts
Creating access groups
Editing access groups
Archiving access groups
Restoring archived access groups
Setting preconditions and follow-up actions
Preconditions and follow-up actions
Copying configurations
Creating configurations
Adding associations
Enabling architecture management in an EWM project area
Sharing the process of a project area
Enabling project area process sharing across servers
Making a project area shareable
Modifying a project area to use another project area's process
Archiving and restoring project areas and team areas
Archiving project areas and team areas
Restoring archived project areas and team areas
Managing process descriptions and practices
Creating process descriptions
Importing process descriptions
Exporting process descriptions
Archiving process descriptions
Restoring process descriptions
Deleting process descriptions
Creating practices
Importing practices
Exporting practices
Archiving practices, practice elements, and practice categories
Restoring practices, practice elements, and practice categories
Working with process templates
Deploying predefined process templates
Viewing process descriptions for predefined templates
Exporting process templates
Importing process templates
Editing process template IDs, names, and summaries
Viewing process history
Refreshing browser to see process changes
Collaborating
Managing dashboards
Dashboards
Creating personal dashboards
Accessing project and team dashboards
Customizing mini dashboards
Tracking progress with plan dashboards
Adding and organizing content on a dashboard
Creating effective dashboards
Adding and organizing tabs on dashboards
Saving changes to the dashboard
Refreshing dashboard content
Finding a dashboard
Configuring dashboard templates in the process
Adding and configuring widgets
Predefined widgets in the local catalog
Adding a widget
Adding an OpenSocial gadget
Adding the Lotus Connections widget to a project dashboard
Adding a widget from another application
Configuring widgets
Moving and copying widgets
Exporting widgets to HTML
Configuring widget catalog entries in the process
Troubleshooting and support
General product troubleshooting
Accessing the IBM Support community
Accessing release information
Subscribing to product updates
IBM Support Assistant
Getting fixes
Contacting IBM Software Support
Messages
Reference
Accessibility features
Accessibility for Eclipse products
Fonts and color settings
Specifying custom color settings
Configuring the context-sensitive help for screen readers
Keyboard shortcuts
Help system
Requirements Management (RM) application keyboard shortcuts
EWM keyboard shortcuts
ETM keyboard shortcuts
Global Configuration Management keyboard shortcuts
Glossary for ELM
Using the help
Interactive guides
Interactive guides
Jazz Team Server
Overview
Jazz Team Server overview
Deployment wiki
Installing
Installing IBM Engineering Lifecycle Management
Deployment and installation planning for the Engineering Lifecycle Management
Deployment and installation
Hardware and software requirements
Deployment topologies
How many Jazz Team Server to use
Planning your URIs
Applications in this release
Licensing
Single sign-on authentication
Planning to install on Linux, UNIX, IBM i, and z/OS systems
Planning to install on UNIX and Linux systems
Troubleshooting UNIX installations
Installing with Security-Enhanced Linux
Planning to install on IBM i systems
Planning to install on z/OS systems
SMP/E installation process
Checklist for z/OS installations
Installation information for z/OS system programmers
Setting up the JZOS batch launcher
Security on z/OS systems
RACF security
Jazz Team Server security on z/OS systems
Security for z/OS builds
Installation verification process (IVP)
Installing the configuration utility
Examples: Installation process and topology
Example: Installation process
Example topology: For evaluation
Example topology: Standard departmental
Example topology: Distributed enterprise
Techniques for changing your topology
Reverse proxy servers in topologies
DNS names in topologies
Server rename in topologies
Performance considerations
Maximizing performance
High availability and disaster recovery
Change and Configuration Management clustered environment
Quality Management clustered environment
Set up a cluster of Jazz Authorization Server
Downloading the installation media
Interactive installation guide
Interactive installation guide for adding applications
Installing Jazz Team Server and the ELM applications
Installing by using IBM Installation Manager
Installing from a command line
Choosing a different context root than default
Installing on IBM i systems
Installing on z/OS systems
Configuring your installation
Creating directories
Customizing configuration files
Customizing the provisioning profiles
Customizing the logging utility files
Starting the configuration utility
Running the configuration utility
Generating a configuration workflow
Modifying an existing configuration
Working with a configuration workflow
Selecting additional configuration options
Completing the installation
Setting up the database
Setting up a Db2 database
Manually configuring a Db2 database
Increasing IBM Db2 STMTHEAP size
Setting up an Oracle database
Manually configuring an Oracle database
Setting up an SQL Server database
Manually configuring an SQL Server database
Setting up a Db2 database on a z/OS system
Prerequisites
Setting up Db2 for z/OS for Jazz Team Server
Customizing the Jazz Team Server and ELM properties files for Db2
Configuring Jazz Team Server to use Db2 on z/OS
Creating database tables
Creating database tables remotely
Running UNLOAD and LOAD processes for backup
Managing Db2 for z/OS databases before upgrading IBM Engineering Lifecycle Management
Deploying and starting the server
Deploying and starting WebSphere Application Server
Administering the server by using Jython
Administering the server by using the Integrated Solutions Console
Setting up WebSphere Application Server
Deploying ELM applications on the server
Deploying by using single sign-on authentication
Configuring virtual hosts for applications
Configuring a reverse proxy
Importing the WebSphere Application Server certificate into the IBM HTTP Server plug-in
Starting and stopping Jazz Team Server on IBM i systems
Running Jazz Team Server and the ELM applications on z/OS systems or WebSphere Liberty profile on z/OS
Setting up user security on a z/OS system by using RACF
Configuring the Engineering Lifecycle Management and WebSphere Application Server for z/OS
Configuring the Engineering Lifecycle Management and WebSphere Application Server profile on z/OS
Starting the WebSphere Liberty server
Customizing the WebSphere Liberty jvm.options file
Deploying and starting Jazz Authorization Server
Changing the port numbers for the application server
Setting up user management
Managing users on WebSphere Application Server
Enabling LDAP on WebSphere Application Server
Custom realms for authentication and group membership
Managing users by using a federated, file-based registry
Configuring the federated repositories
Setting up groups and users
Managing users on WebSphere Liberty Server
Default user management on WebSphere Liberty server
Configuring an LDAP or an LDAP/SDBM connection
Managing users on Jazz Authorization Server
Configuring a file-based user registry
Configuring an LDAP user registry
Configuring the SCIM feature
Enabling SAML as an identity provider
LDAP and LDAP/SDBM configuration parameters
Configuring the server
Running custom setup
Running express setup
Running the setup from the command line
Running the setup from the command line in express mode
Completing the installation
Configuring the server on IBM i systems
Configuring security certificates
Installing a security certificate
Disabling security certificate settings
Configuring certificate and smart card authentication
Configuring client certificate support in Jazz Authorization Server
Configuring certificate authentication in Engineering Workflow Management
Support for NIST SP 800-131
Configuring WebSphere Application Server to support TLS 1.2 for NIST SP 800-131
Configuring IBM HTTP Server to support TLS 1.2 for NIST SP 800-131
Configuring WebSphere Liberty to support TLS 1.2 for NIST SP 800-131
Configuring repository tools to support TLS 1.2 for NIST SP 800-131
Configuring browsers to support TLS 1.2 for NIST SP 800-131
Configuring Engineering Workflow Management clients and build engines to support TLS 1.2 for NIST SP 800-131
Configuring the Rational ClearCase and Rational ClearQuest connectors to support TLS 1.2 for NIST SP 800-131
Configuring TLS Extended Master Secret (EMS) for WebSphere Application Server and WebSphere Liberty
Configuring Kerberos/SPNEGO SSO
Configuring the server
Deploying Kerberos/SPNEGO SSO
Supported platforms
Microsoft Active Directory
WebSphere Application Server
Multiple Microsoft Active Directory domain controllers
Proxy servers and IBM HTTP Server
LDAP
Verification of SPNEGO authentication
Configuring fallback authentication
Client certificates or smart cards in WebSphere Application Server with SPNEGO
Configuring fallback to application authentication
Configuring fallback to basic credentials
Configuring a SPNEGO filter for earlier client versions
Other installation and troubleshooting information
Logout and token licenses
Reverse lookup zones in the DNS
Host names in Windows domains
Configuring encryption
AES 256-bit encryption
Configuring WebSphere Application Server with SPNEGO for encryption
Enforcing encryption algorithms on domain clients
Troubleshooting SPNEGO issues on WebSphere Application Server
Configuring clients
ELM client
Windows client
kinit utility for local administrators
Encryption algorithms
Providing a session key to the IBM JRE
Linux, UNIX, z/OS, IBM i client
Web client
Modifying the Kerberos configuration and cache files
Ticket expiry
Cross-realm authentication
kinit cache file location
Configuring the krb5 file
Scripted authentication
Collecting debug information for client authentication issues
Changing the public URL by using server rename
Planning for server rename
Server rename
Supported scenarios
Mapping file for server rename
Server rename workflow
Supplemental information about server rename on Jazz.net
Topology diagrams and mapping file examples
Staging environment scenario
Pilot-to-production scenario
Production-to-production scenario
Impact of server rename on the ELM
Jazz Team Server
Change and Configuration Management (CCM) application
Data Collection Component
Lifecycle Query Engine and the Link Index Provider
Quality Management (QM) application
Changes to advanced properties
Engineering Requirements Management DOORS Next
IBM Engineering Lifecycle Optimization - Engineering Insights
Report Builder
Integrated products
Performing a server rename
Preparing the mapping file
Scenario: Setting up a test staging environment
Scenario: Moving a pilot or full production deployment
Changing the context root
Configuring after a database server move
Moving ELM databases to a different database server
Changing ELM databases to a different database vendor
Server rename and the Jazz Authorization Server
Verifying and troubleshooting server rename
Verifying URLs and links after a server rename
Completing the server rename verification process
Jazz Team Server
Change and Configuration Management
Data Collection Component
Global Configuration Management
Quality Management
Report Builder
IBM Engineering Lifecycle Optimization - Engineering Insights
Requirements Management
Rational ClearQuest and Rational ClearCase
Troubleshooting server rename
General recovery procedures
Recovering from generateURLMappings errors
Recovering from importURLMappings errors
Responding to server rename status errors
Reviewing a history of server renames
Configuring the location of the help in a distributed environment
Installing optional tools, clients, and samples
Installing the Build System Toolkit
Installing by using IBM Installation Manager
Installing from a .zip file
Installing the Build System Toolkit on IBM i systems
Installing and configuring the Build System Toolkit on z/OS systems
Creating additional directories (required)
Configuring the ISPF gateway for build, deployment, and promotion support
Installing the Rational Build Agent
Installing the Rational Build Agent on z/OS systems
Creating additional Rational Build Agent directories
Configuring the Rational Build Agent shell script
Completing the installation and running the Rational Build Agent
Using InetD to start the agent
Configuring the agent
Locating the agent configuration file
Changing the agent port
Configuring a different shell
bfagent executable file
bfagent.conf file
Installing on IBM i systems
Installing and running the Rational Build Agent on IBM i systems
Configuring the agent
Locating the agent configuration file for IBM i systems
Changing the agent port
Configuring a different shell
bfagent executable file
bfagent.conf file
Installing and configuring the Rational Build Agent on Linux, UNIX, and Windows
Installing an agent
Installing an agent on Windows
Installing an agent on Linux and UNIX
Running an agent
Running an agent on Windows
Running an agent on Linux and UNIX
Configuring the Rational Build Agent
Locating the agent configuration file
Changing the agent port
Configuring a different shell
Running agent commands on a Network Share File System (Windows)
bfagent executable file
bfagent.conf file
Build Agent Lookup Service
Configuring a lookup service task
Troubleshooting the Rational Build Agent
Installing IBM Engineering Workflow Management connectors
Installing IBM Engineering Workflow Management ClearCase Synchronizer
Installing by using IBM Installation Manager
Installing from a .zip file
Installing IBM Engineering Workflow Management ClearQuest Synchronizer
Installing by using Installation Manager
Installing from a .zip file
Installing IBM Engineering Workflow Management clients
Installing by using Installation Manager
Installing the Eclipse client from a .zip file
Installing the client in Eclipse (p2 install)
Installing the client for Microsoft Visual Studio IDE
Installing the Engineering Workflow Management Shell
Installing the MS-SCCI Provider
Connecting to the server
Installing the IBM Engineering Workflow Management ISPF client
ISPF client security
Security settings and classes
OMVS segment
Data set profiles
ISPF daemon started task on System z
ISPF daemon as a secure z/OS UNIX server
Application protection for the ISPF daemon
ISPF PassTicket support
z/OS UNIX program-controlled files for the ISPF daemon
Troubleshooting ISPF client security
Troubleshooting ISPF client permissions
Troubleshooting ISPF client PassTicket support
ISPF daemon configuration
Started tasks for the ISPF daemon
ISPF daemon configuration file (ispfdmn.conf)
ISPF daemon START (S) command
Configuring and running the ISPF client on z/OS systems
Starting the ISPF client
Installing the context-aware search tool
Installing on Windows, Linux, AIX, or Solaris systems
Installing on z/OS systems
Installing on IBM i systems
Starting and stopping the search engine
Installing the Money that Matters sample
Configuring the Money that Matters sample environment
Installing IBM Security AppScan Tester Edition
Interactive software packages removal guide
Removing Jazz Team Server and the ELM applications
Release notes
Upgrading and migrating
Upgrading IBM Engineering Lifecycle Management
Deployment and upgrade planning
Deployment and upgrade
Hardware and software requirements
Deployment and upgrade process
Client and server version compatibility
Reporting and the upgrade process
Licensing
Planning to upgrade on IBM i and z/OS systems
Special instructions for upgrading on IBM i
Planning to upgrade on z/OS
Staging a test environment for the upgrade process
Examples: Upgrade process and topology
Example: Upgrade stand-alone products to an integrated solution
Example topology: Upgrade from a distributed ELM enterprise to the current version
Downloading the installation media for an upgrade
Upgrading from version 5 to the current version
Interactive upgrade guide
Upgrade script files
Jazz Team Server upgrade script reference information
Change and Configuration Management upgrade script reference information
Quality Management upgrade script reference information
Requirements Management upgrade script reference information
Global Configuration Management upgrade script reference information
Data Collection Component upgrade script reference information
Report Builder upgrade script reference information
Lifecycle Query Engine upgrade script reference information
Link Index Provider upgrade script reference information
Engineering Insights upgrade script reference information
Upgrading the server configuration on z/OS
Configuring the data warehouse after an upgrade
Upgrading the WebSphere Liberty Profile
Enabling Jazz Security Architecture SSO after an upgrade
Verifying the upgrade
Verifying the configuration files during upgrade
Verifying logs, URLs, and administrative pages
Verifying users, licenses, and linked artifacts
Upgrading optional tools, clients, and reporting artifacts
Upgrading the Engineering Workflow Management clients for Microsoft Visual Studio and Eclipse IDE
Upgrading the Engineering Workflow Management Shell
Upgrading Jazz Build Engine
Upgrading the Build System Toolkit on IBM i
Upgrading the Build System Toolkit and Rational Build Agent on z/OS
Upgrading the ISPF client daemon
Upgrading the IBM Developer for z Systems integration
Upgrading Developer for z Systems
Upgrading ClearQuest Synchronizer
Upgrading process templates
Upgrading reporting artifacts
Migrating the database and application server
Migrating databases
Switching from Apache Tomcat to WebSphere Application Server
Changing WebSphere Application Server installations and instances
Administering
Administering IBM Engineering Lifecycle Management servers
Getting started: Server and repository administrator
Repository
Logging in to administer the server
Registering applications with Jazz Team Server
Managing registered applications
Managing licenses
Managing client access licenses
Client access license management
TRS Consumer - Internal license
Installing and managing client access license keys
Managing floating client access licenses
Floating client access license management overview
Installing and managing floating client access license keys
Monitoring and releasing floating client access licenses
Managing floating client access licenses — distributing Rational Common Licensing tokens
Setting up the Rational Common Licensing token service keys
Managing users
Understanding licenses, permissions, and access control
Creating users
Importing users from an external user registry
IBM i authentication methods
System users
Assigning client access licenses to users
Assigning default licenses to new users
Allowing users to register themselves
Receiving email notification when a new user self registers
Disabling the default administrative user
Disabling the default administrative user on IBM i
Archiving and restoring users
Resetting a user password
Changing your password
Configuring the server
Configuring email settings
Configuring database connections
Configuring feed settings
Configuring the frequency of feeds
Configuring themes
Configuring OAuth consumers
Registering consumer keys
Approving consumer keys
Editing consumer keys
Deleting consumer keys
Configuring friends
Establishing friend relationships
Editing servers in the friends list
Deleting servers from the friends list
Managing the URL whitelist
Configuring advanced properties
Suppressing Engineering Workflow Management pages in the web client
Resource-intensive scenarios
Compacting index files
Managing archived and unmapped resources
Configuring a custom logout page
Managing the size of the log file
Enabling automatic archiving of auditable links for work items
Enabling distributed source control
Enabling Open Services for Lifecycle Collaboration
Enabling an external content repository for source control
Moving servers and applications to different timezones
Configuring change event service
Synchronizing LDAP with Jazz Team Server repository user information
Viewing the results of a synchronization
Changing the synchronization frequency
Configuring authentication session timeout
Administering ELM servers in Liberty Admin Center
Interactive backup and restore guide
Backing up and restoring applications
Backing up and restoring the Derby database
Backing up and restoring other supported databases
Backing up and restoring the Jazz Authorization Server
Patch service for ELM applications
Viewing installed patches
Troubleshooting and support
Troubleshooting Jazz Team Server
Log file locations
Troubleshooting the Jazz Team Server setup wizard
Troubleshooting the SMTP server
Using the IBM Support Assistant Data Collector to gather diagnostic information
Running IBM Support Assistant Data Collector
Expanding the scope of data
Reducing the scope of data
Reference
Repository tools command-line reference
-addTables
-archiveUser
-backupJFSIndexes
-compacttdb
-copy
-createFriend
-createTables
-createUser
-createUsers
-createVersionIDs
-createWarehouse
-deleteJFSResources
-dropTables
-dumpArtifacts
-executeDiagnostics
-export
-exportServerRenameURLMappingHistory
-exportUsers
-exportVersionIDs
-finalizeApplicationMigration
-generateURLMappings
-generateWarehouseDDLScripts
-generateWarehouseUpgradeScripts
-help
-import
-importURLMappings
-importUsers
-importVersionIDs
-isServerRunning
-listIssuedFloatingLicenses
-listLicenses
-listStorageAreaKeys
-mergeLPAJTS
-migrateToJsaSso
-migration_ccm_updateConfigurationFiles
-migration_dcc_updateConfigurationFiles
-migration_gc_updateConfigurationFiles
-migration_jts_updateConfigurationFiles
-migration_qm_updateConfigurationFiles
-migration_rm_updateConfigurationFiles
-migration_relm_updateConfigurationFiles
-modifyLinkURIs
-moveContent
-onlineMigrate
-onlineMigrateEstimate
-onlineMigrateRevert
-onlineMigrateStop
-partitioning
-patchApplyApp
-patchApplyGlobal
-patchRevertApp
-patchRevertGlobal
-prepareJsaSsoMigration
-rebuildClosureTable
-rebuildIndices
-rebuildTextIndices
-registerApp
-reindex
-renameURIInWarehouse
-repairQueryableTables
-repairVersionsWithIdenticalTimestamp
-repairUnreferencedVersions
-repairMultipleVersionsMarkedAsCurrent
-repairSuites
-resetRepoLockId
-restoreJFSIndexes
-resumeIndexer
-rmExportLinkValidity
-rmImportLinkValidity
-scmExportComponent
-scmImportComponent
-setStorageAreaKeys
-setup
-setupConfiguration
-suspendIndexer
-synchronizeJFSIndexes
-syncUsers
-unregisterApp
-updateLPASampleTemplates
-upgradeWarehouse
-verify
-verifyJFSIndexes
-verifyURLMappings
-version
Engineering Requirements Management DOORS Next
Overview
Engineering Requirements Management DOORS Next
Comparison of DOORS and DOORS Next
Configuration management capabilities
Getting started
Administering RM projects
Creating and managing requirements
Video tours
Engineering Requirements Management DOORS Next overview
Tutorials
Create and define requirements
Introduction: Create and define requirements
Lesson 1: Create requirements and edit requirement attributes
Lesson 2: Create links in requirements
Lesson 3: Tag artifacts by using shared tags
Lesson 4: Import Microsoft Word documents
Find and view project artifacts in a requirements project
Introduction: Find and view project artifacts
Lesson 1: Open and view artifacts
Lesson 2: Find and tag artifacts
Comment on and review requirement artifacts
Introduction: Comment on and review requirement artifacts
Lesson 1: Comment on requirement artifacts
Lesson 2: Review and approve requirement artifacts
Installing
Installing the RM application
Upgrading
Upgrading the RM application
Integrating
DOORS
Configuring RM as a consumer
Associating RM projects with DOORS modules
Configuring RM as a provider
Rational ClearQuest
Rational Change
Administering
Administering IBM Engineering Lifecycle Management servers
Administering requirements projects or components
Permissions
Creating requirements projects
Managing project or component properties in requirements projects
Creating artifact types
Creating attributes
Creating requirement attribute data types
Module Options
Type Mapping
Creating link types
Link types
Link direction
Link constraints
Creating templates for requirements projects or components
Managing templates for requirements projects or components
Requirements project templates
Scaled Agile Framework (SAFe) 4.5 project templates
Creating artifact templates
Managing artifact templates
Creating module templates
Administering configuration management capabilities
Importing properties from another Requirements Management (RM) project or component
Copying artifacts between projects
Deleting artifacts from the repository
Administering link validity
Controlling changes after enabling configuration management
Cloning artifacts between components
Baselines
Enabling Electronic signatures for a baseline
Administering components
Components
Planning components
Creating components
Fixing component overlap
Archiving and restoring components
Showing and hiding archived components
Managing query workload
Backing up and restoring the index files
Analyzing and validating TRS feeds
Collaborating
Dashboards in the RM application
Composing and managing requirements
Joining a requirements project
Logging in to a requirements project repository
Project dashboards
Personal dashboard
Defining requirements
Creating artifacts
Artifacts
Creating diagrams to support requirements
Business process diagrams
Business process elements
Getting started with business process diagrams
Defining use cases
Use case specification outline
Wireframes
Editing attributes with multiple values
User Preferences
Filters and views
Artifact search
Locks
Uploading files
Inserting files
Data exchange methods
Vision document
Creating modules
Modules
Differences between collections and modules
User Preferences
Duplicating a module
Searching for artifacts in a module
Linking between artifacts in modules
Linking by attribute
Modifying hierarchy in modules
Reusing artifacts in modules
Base artifacts
Filters and module views
Adding comments to artifacts in a module
Exporting artifacts from modules to CSV and spreadsheet files
Importing and exporting files
Importing documents
Import document planning
Importing and extracting artifacts from documents
Importing and exporting CSV and spreadsheet files
Importing artifacts from CSV and spreadsheet files
Exporting artifacts to CSV and spreadsheet files
CSV file format and examples
Importing migration package files
Importing and exporting ReqIF files
Importing from ReqIF files
Exporting to ReqIF files
Creating collections
Collections
Comparing collections
Managing terminology and glossaries
Glossaries
Creating a glossary and terms
Commenting on artifacts
Reviewing artifacts
Reviews
Signing a baseline electronically
Creating reviews
Participating in reviews
Editing artifacts while reviewing a requirement collection
Managing requirements
Managing artifacts with attributes
Adding tags to artifacts and viewing tagged artifacts
Copying artifacts between projects
Requirement workflows
Comparison of artifact grouping methods in requirements management
Traceability
Link Validity
Managing requirements status and other properties
Analyzing the impact of change
Linking to other artifacts
Links between requirement artifacts
Linking artifacts in different projects or components
Linking by attribute
Linking to requirements artifacts in lifecycle applications
Filtering artifacts for links to other applications
Links explorer
Linking requirements to Rational ClearQuest records
Viewing artifact history
Managing artifacts by using configurations
Selecting a component and configuration
Managing configuration details
Creating streams
Creating baselines
Comparing configurations
Managing changes to artifacts
Creating change sets
Linking to work items
Showing change set contents
Discarding change sets
Delivering change sets
Showing where change sets were delivered
Delivering change sets to other streams
Accepting changes
Showing and setting link validity
Cloning requirement artifacts
Troubleshooting local configurations
Artifact recovery
Reporting
Reporting in the RM application
Creating document-style reports
Running data warehouse reports
Reports in the RM application
RM reportable REST API
Requirements management data dictionary
RM Attribute Enumerations
RM Attribute Values
RM Link Types
RM Parent-Child Links
RM Requirement
RM Requirement Collection / Module
RM Requirement Collection / Module Contents
RM Requirement Collection / Module to Test Plan Links
RM Requirement to Request Links
RM Requirement to Requirement Links
RM Requirement to Test Case Links
What's changed in the data dictionary
Extending product function
Extending the RM application
Migrating graphical artifacts
Extending by using OSLC services
RM as an OSLC service consumer
RM as an OSLC service provider
Links across OSLC domains
Additional OSLC integration services and requirements
Troubleshooting and support
Troubleshooting the RM application
Log file locations
Enabling web client logging
Fixing a converter issue in the server in headless mode
Recovering missing artifacts from configurations
Fixing file preview font issues in other languages
Opening artifacts in multiple tabs or windows
Opening artifacts in new tabs in the same window
Redirecting HTTP requests
Pasting invalid XHTML text
Cutting, copying, and pasting text
Updating custom Word templates
Creating a hyperlink to a local file
Moving artifacts from a folder
Creating a project template for a large project
Support information for the RM application
Troubleshooting local configurations
Engineering Workflow Management
Overview
Engineering Workflow Management
Getting started
Video tours
Engineering Workflow Management overview
EWM source control
EWM Build
Engineering Workflow Management planning
Engineering Workflow Management Enterprise Extensions tours
Dependency builds (part 1)
Dependency builds (part 2)
Dependency builds (part 3)
Dependency builds on IBM i
Context-aware search
Component promotion
Work item promotion (part 1)
Work item promotion (part 2)
Packaging and deployment
Source code data collection service
IBM Developer for System z integration feature
ISPF client
ISPF client build results management
Tutorials
Getting started
Get started with Engineering Lifecycle Management
Lesson 1: Setting up a project and team as Administrator
Lesson 2: Getting connected
Lesson 3: Using work items
Lesson 4: Working with plans
Lesson 5: Using the Team Dashboard and My Work views
Lesson 6: Managing source code
Lesson 7: Building with IBM Engineering Workflow Management Engineering Workflow ManagementBuild
Lesson 8: Using the web client
Summary
Tutorial: Exploring the Engineering Workflow Management JUnit example project
Using an Ant with Enterprise Extensions build to compile a COBOL application
Lesson 1: Preparing your environment
Lesson 2: Configuring the Rational Build Agent shell script
Lesson 3: Configuring the Rational Build Agent
Lesson 4: Creating data set definitions
Lesson 5: Creating translators
Lesson 6: Creating language definitions
Lesson 7: Creating a shared zComponent Project
Lesson 8: Adding zFolders and associating them with data set definitions
Lesson 9: Adding build artifacts and associating them with language definitions
Lesson 10: Configuring a build definition
Lesson 11: Requesting a build
Configuring the Jazz Team Server for a sample z/OS application
Tutorial: Understand the workbench environment
Introduction
Lesson 1: Work with perspectives and views
Lesson 2: Create projects and files
Lesson 3: Open and edit files
Lesson 4: Customize your workbench
Project planning
Plan an agile project
Introduction: Plan an agile project
Lesson 1: Create the product backlog
Lesson 2: Plan the release
Lesson 3: Plan the sprint
Lesson 4: View your work
Lesson 5: Track progress by using queries
Lesson 6: Schedule the sprint review
Lesson 7: Shut down the sprint
Summary: Plan an agile project
Plan a traditional project
Introduction: Plan a traditional project
Lesson 1: Create a release plan for the project
Lesson 2: Add resources to the project plan
Lesson 3: Identify and plan for risks
Lesson 4: Define project work
Lesson 5: Create phase plans and the plan schedule
Lesson 6: Assign owners to work items
Lesson 7: Take a snapshot of the planned schedule
Summary: Plan a traditional project
Get started with Quick Planner
Introduction: Get started with Quick Planner
Managing a project with Quick Planner
Define and manage risks
Lesson 1: Define a risk
Lesson 2: Create a risk action
Lesson 3: Linking a risk with a risk action
Summary: Define and manage risks
Create plans and work items in the Engineering Workflow Management client for Microsoft Visual Studio IDE
Create plans and work items
Lesson 1: Create a plan
Lesson 2: Create a work item
Project management
Control access to project areas and their artifacts
Introduction: Control access to project areas and their artifacts
Lesson 1: Control read access to project area
Lesson 2: Restrict access to work items based on team membership
Lesson 3: Control access to specific work items by using an access group
Lesson 4: Restrict access to source control artifacts
Summary: Control access to project areas and their artifacts
Standardize process by using project area process sharing
Introduction: Standardize process in your organization by using project process sharing
Lesson 1: Create a provider project area
Lesson 2: Create a standard setup process template
Lesson 3: Create a consumer project area
Lesson 4: Show that the consumer project area uses the process from the provider project area
Lesson 5: Override permissions in the consumer project area
Lesson 6: Prevent the consumer project area from overriding the permission settings inherited from the provider project area
Summary: Standardize process in your organization by using project area process sharing
Work item customization
Customize work items
Customize work items
Lesson 1: Create a work item type
Lesson 2: Create a work item attribute
Lesson 3: Create an enumeration attribute type
Lesson 4: Define a workflow with approval tracking
Lesson 5: Customize the work item editor
Lesson 6: Create a ToDo work item
Source control
Share changes with your team
Share changes with your team
Lesson 1: Create a repository workspace from a stream
Lesson 2: Deliver changes and resolve a work item
Lesson 3: Accept changes from other team members
Lesson 4: Resolve a conflict
Flowing changes to different repositories
Flowing changes to different repositories
Lesson 1: Flowing changes to different repositories (basic setup)
Lesson 2: Flowing changes to different repositories (advanced setup)
Share changes using the web client
Share changes using the web client
Lesson 1: Add files and folders to a stream
Lesson 2: Lock, download, and edit a file
Lesson 3: Create and edit a text file
Share changes with your team in the Engineering Workflow Management client for Microsoft Visual Studio IDE
Share changes with your team
Lesson 1: Create a repository workspace from a stream
Lesson 2: Deliver changes and resolve a work item
Lesson 3: Accept changes from other team members
Lesson 4: Share a project and solution
Share changes with your team in the Engineering Workflow Management Shell
Share changes with your team
Accept a team invitation
Create a repository workspace
Deliver changes to team members
Set preferences
Resolve a conflict
Work with Jazz properties
Share changes in Basic mode
Preserve component and workspace configuration in the Engineering Workflow Management client for Microsoft Visual Studio IDE
Preserve component and workspace configuration
Lesson 1: Create a component baseline
Lesson 2: Accept incoming baselines and change sets
Lesson 3: Create a snapshot and assign an owner to it
Build management
Manage builds with the Engineering Workflow Management Build
Manage builds with the Engineering Workflow Management Build
Lesson 1: Build definitions and build engines
Lesson 2: Build requests
Lesson 3: Build results
Manage builds with the Engineering Workflow Management Build in the Engineering Workflow Management client for Microsoft Visual Studio IDE
Manage builds with the Engineering Workflow Management Build
Lesson 1: Build definitions and build engines
Lesson 2: Build requests
Lesson 3: Build results
ClearCase and ClearQuest Synchronizers
Get started with the ClearCase Synchronizer
Introduction: Get started with the ClearCase Synchronizer
Create a Jazz administrative user
Add a process role to the Jazz administrative user
Create a ClearCase Synchronized Stream and merge workspace
Import files and folders from
Load imported files to a Engineering Workflow Management workspace
Deliver changes in a synchronized environment
Verify exported files in Rational ClearCase
Create a schedule for future synchronizations
Summary
Get started with the Rational ClearQuest Synchronizer
Module 1: Setting up your Rational ClearQuest environment
Lesson 1.1: Create a schema repository
Lesson 1.2: Create a schema and user database
Module 2: Setting up your Jazz environment
Lesson 2.1: Create an administrative user
Lesson 2.2: Create a project area
Module 3: Using the ClearQuest Synchronizer Setup Wizard
Lesson 3.1: Start the Rational ClearQuest Gateway
Lesson 3.2: Use the Rational ClearQuest Synchronizer Setup Wizard
Module 4: Editing synchronization rules
Lesson 4.1: Assign a role with necessary permissions to the ClearQuest Synchronizer user
Lesson 4.2: Edit Project synchronization rule
Lesson 4.3: Edit the Defect synchronization rule
Module 5: Enabling outgoing synchronization
Lesson 5.1: Enable outgoing synchronization for the Jazz Team Server
Lesson 5.2: Enable outgoing synchronization for the external repository connection
Module 6: Testing the configuration
Lesson 6.1: Submit a Project record
Lesson 6.2: Submit a Defect record
Summary
Scenarios
Iterative development
Planning an iteration
Managing iterations
Assessing iteration results
Managing risks
Installing
Installing the Change and Configuration Management application
Upgrading and migrating
Upgrading the Change and Configuration Management application
Online migration
Migrating Engineering Workflow Management Enterprise Extensions build maps
Migrating Engineering Workflow Management Enterprise Extensions source code data
Migrating from the ClearQuest Synchronizer to the ClearQuest Bridge
Integrating
Rational Build Forge
Creating build engines
Creating build definitions
Rational Change
Rational ClearCase
Getting started with connectors
EWM concepts
Synchronizing and importing data
Deploying Engineering Workflow Management
Planning to synchronize and import
Guidelines for Rational ClearCase users
Element types versus MIME content types
Selecting streams or branches to synchronize
Exporting to VOBs and UCM components
Imported components in synchronized streams
ClearCase Synchronizer subcommands
Updating the synchronizer after server rename
Production environments
Test-staging environments
Preparing the synchronization environment
Configuring a synchronization host
Selecting an operating system account
Creating a Jazz administrative user
Adding the Jazz administrative user to your team
Preparing a sub-VOB component
Known limitations of sub-VOB component mapping
Migrating a synchronization stream
Synchronizing data with the ClearCase Synchronizer
Creating a ClearCase Synchronized Stream and merge workspace
Importing files and folders from Rational ClearCase
Exporting files and folders to Rational ClearCase
Removing a synchronization root
Loading a component root folder into a sandbox
Specifying line termination characters for text files
Configuration specification details for base Rational ClearCase
Creating a synchronized stream work item template
Writing Rational ClearCase triggers for synchronization
Configuring a synchronized stream
Running synchronizations
Scheduling synchronization
Running custom scripts before and after synchronization
Resolving conflicts during synchronization
Stopping the synchronization engine process
Starting the synchronization engine process
Canceling and abandoning a synchronization request
Delivering changes in a synchronized environment
Importing history
Preparing to import
Importing multiple streams
Importing history from a UCM stream
Importing history from base Rational ClearCase
Verifying the imported history
Importing additional history
Managing the synchronization environment
Managing streams
Editing a synchronized stream
Synchronization options
Stream properties
Unlocking a synchronized stream
Changing the default script location
Managing the synchronization host
Changing the synchronization host
Changing the dynamic view
Upgrading the ClearCase Synchronizer
Managing merge workspaces
Modifying the workspace
Creating a workspace for a synchronized stream
Limitations and known problems
Troubleshooting synchronization problems
Synchronization errors
Migrating data
Planning to export and import
Identifying VOBs and subfolders to migrate
Choosing view configurations
Selecting versions to export by filtering
Examples of selecting versions with filters
Disk space
Incremental migration
Element types versus MIME content types
Preparing the environment
Configuring the export and import hosts
Selecting an operating system account for exporting
Adding the Jazz administrative user account to your team
Creating EWM streams and components
Exporting and importing data
Exporting multiple configurations
Migrating incrementally
Exporting data and specifying the change-set comment format
Updating character encoding of text files
Excluding file elements from the exported data files
Specifying the user accounts mapping
Importing data into EWM source control
Importing change-set links
Verifying stream and component histories
Verifying configuration and version histories
ClearCase Version Importer limitations and known problems
Export problems
Import problems
Error messages
ClearCase Bridge
Version compatibility and functionality
Connecting EWM and UCM
Manually associating activities with work items
Viewing linked work items and UCM activities
Enforcing an association
Configuring site-wide integration
Connecting EWM and base Rational ClearCase
Associating element versions with work items
Manually associating element versions with work items
Viewing linked work items and element versions
Updating the bridge after server rename
Production environments
Test-staging environments
Rational ClearQuest
ClearQuest Synchronizer
Getting started
Prerequisites
Configuration checklist
Deploying the ClearQuest Synchronizer
Connecting to multiple project areas
Starting the ClearQuest Gateway
Verifying the ClearQuest Gateway is running
Setting up the ClearQuest Synchronizer
Starting the setup wizard
Configuring Rational ClearQuest
Configuring Jazz Team Server
Creating record queries
Resetting the ClearQuest Gateway
Configuring project areas for synchronization
Synchronization rules
Planning synchronization rules
Sample planning worksheet
Reviewing synchronization rules
Creating synchronization rules
Mapping records to work items
Configuring rules for external users
Setting categories for rules
Creating rules for attachments
Mapping notes to comments
Mapping referenced fields
Displaying record contents
Synchronizing users
Outgoing synchronization
Connecting to external repositories
Modifying service parameters
Configuring OSLC linking
Stopping and restarting the ClearQuest Gateway
Enabling outgoing synchronization
Testing the ClearQuest Synchronizer
Tasks before and after a server rename
Preparing the ClearQuest Synchronizer
Test-staging environments
Production environments
Importing batches of records
Importing but not synchronizing records
Working in a synchronized environment
Associating categories with team areas
Viewing synchronization status
Finding and resolving conflicts
Showing ClearQuest Synchronizer events
Resolving blocked synchronization
Resolving server communication problems
Viewing log files
Deleting records and work items
Archiving synchronized project areas
Troubleshooting ClearQuest Synchronizer
Rational ClearQuest MultiSite
Applying the JazzInterop package
ClearQuest Synchronizer resources
Updating the JazzInterop package
ClearQuest Bridge
Getting started
Configuring
Working with records in the web client
Adding ClearQuest content to dashboards
Adding queries
Configuring queries
Adding charts
Configuring charts
Finding and reviewing records
Updating and resolving records
Associating work items with records
Agile planning for records
Managing the ClearQuest backlog
Updating work items and records
Prioritizing and scheduling work
Tracking progress
Resolving work items and records
Migrating records to work items
Customizing the mapping file
Mapping attributes
Specifying attribute types
Mapping attribute values
Concatenating field values
Mapping records to work items
Mapping state and resolution values
Mapping relationships
Importing FTP links
DOORS
Git
Integrating with GitHub Enterprise
Configuring the basic integration with GitHub Enterprise
Prerequisites
Registering the GitHub repository
Authorizing requests
Configuring webhooks
Validating the basic integration
Configuring traceability from work items to GitHub commits
Configuring webhooks for traceability
Linking commits to work items
Configuring process enforcement for Git Push operations
Prerequisites
Creating pre-receive hooks
Configuring pre-receive hooks
Setting permissions and preconditions for Git Push operations
Validating process enforcement
Capturing issue or commit discussion comments
Integrating with GitLab Community and GitLab Enterprise
Configuring the basic integration with GitLab
Prerequisites for integrating with GitLab
Registering the GitLab repository in EWM
Authorizing requests for GitLab
Installing the EWM Git Integration Toolkit
Generating a token for a GitLab user
Configuring traceability from work items to GitLab commits
Configuring traceability by using webhooks
Configuring webhooks in GitLab
Validating the webhook in GitLab
Configuring traceability by using post-receive hooks
Configuring the Git repository in GitLab
Deploying post-receive hooks in GitLab
Linking commits to work items
Configuring process enforcement for Git Push operations in GitLab
Prerequisites
Configuring the Git repository in GitLab
Configuring pre-receive hooks in GitLab
Setting permissions and preconditions for Git Push operations
Validating process enforcement
Capturing commit discussions in GitLab
Capturing issue or commit discussion comments
Integrating with Gerrit
Configuring the basic integration with Gerrit
Prerequisites for integrating with Gerrit
Registering the Gerrit repository
Authorizing requests
Installing the EWM Git Integration Toolkit
Configuring the Git repository in Gerrit
Configuring traceability from work items to Gerrit commits
Configuring ref-updated hooks
Configuring patchset-created hooks
Configuring web hooks
Linking commits to work items
Configuring process enforcement for Git Push operations in Gerrit
Prerequisites
Configuring ref-update hooks
Setting permissions and preconditions for Git Push operations
Validating process enforcement
Viewing commit details by using a Node.js server
Integrating with Node.js server
Prerequisites for integrating with Node.js
Setting up a Node.js server for Git
Installing the EWM Git Integration Toolkit
Configuring a Node.js server
Starting the Node.js server
Configuring authentication
Validating the setup of the Node.js server
Shutting down a Node.js server
Upgrading a Node.js server
Configuration properties
Configuring the basic integration with Node.js
Registering the Git repository for Node.js
Authorizing requests
Configuring the Git repository in a plain Git hosting server
Configuring process enforcement for Git Read operations
Setting permissions and preconditions for Git Push operations
Validating process enforcement for Git read operations
Configuring traceability from work items to Git commits
Deploying post-receive hooks
Linking commits to work items
Configuring process enforcement for Git Push operations on Node.js
Deploying pre-receive hooks
Setting permissions and preconditions for Git Push operations
Validating process enforcement
Integrating with Bitbucket
Configuring the basic integration with Bitbucket
Prerequisites for integrating with Bitbucket
Registering the Git repository in EWM
Authorizing requests for Bitbucket
Installing the EWM Git Integration Toolkit
Configuring traceability from work items to commits in Bitbucket
Configuring the Git repository in Bitbucket
Deploying post-receive hooks in a Git repository managed by Bitbucket
Linking commits to work items
Configuring process enforcement for Git Push operations in Bitbucket
Prerequisites
Configuring the Git repository in Bitbucket
Configuring pre-receive hooks in Bitbucket
Setting permissions and preconditions for Git Push operations
Validating process enforcement
Integrating with Jenkins and Git
Common tasks
Registering Git repositories
Registering and updating Git repositories by using scripts
Configuring the Git repository and hooks by using scripts
configure.sh git
configure.sh nodejs
configure.sh gitlab
configure.sh gerrit
configure.sh bitbucket
update.sh git
update.sh nodejs
update.sh gitlab
update.sh gerrit
update.sh bitbucket
Authorizing requests
Defining permissions and preconditions
Creating reference mappings
Using a shared user base for the Git hosting server and EWM
Configuring user branches
Associating work items with commits
Creating links from commit comments
Specifying work items in Git Notes
Automatic un-linking when history is changed
Updating work items with actionable Git comments
Creating work items with commits
Upgrading the EWM Git Integration Toolkit
Logging and troubleshooting
Enabling logging for the EWM server
Enabling logging for the Node.js server
Enabling logging for Node.js scripts for repository registration
Enabling logging for Node.js hooks
Troubleshooting the integration with Git
Hudson/Jenkins
Jenkins plugin
Creating a build engine
Creating a build definition
IBM Connections
Associating projects with communities
Adding IBM Connections to dashboards
Connecting to communities
Sharing work items and dashboards
IBM UrbanCode Deploy
Creating build definitions
Microsoft Source Code Control Interface
Setting up repository workspaces
Connecting to repositories and project areas
Creating repository workspaces
Loading repository workspaces
Sharing changes
Sharing changes
Checking in change sets
Accepting incoming change sets
Delivering change sets
Additional features
Engineering Rhapsody
Configuring MSSCCI as the source control provider
Source control operation mappings for Engineering Rhapsody
Sharing changes
Viewing change history
Viewing file properties
Setting preferences
PTC Windchill PDMLink
Rational Method Composer
Rational Synergy
Subversion
Importing repository contents
Importing dump files
Importing branches after you import the trunk
Linking work items to Subversion repositories
Rational Developer for i
Installing and configuring the integration
Integration overview
Engineering Workflow Management
Rational Developer for i
Developing IBM i applications
Sharing i Projects
IBM Developer for z Systems
Installing and configuring the integration
File agent RSE miner
Integrated client
Engineering Workflow Management
Integration overview
Engineering Workflow Management
Developer for z Systems
Adding resources to Engineering Workflow Management
Differences to operations after sharing artifacts
Managing dependencies
Loading artifacts
Adding artifacts to Engineering Workflow Management
Working with projects locally
Requesting user builds
Adding error feedback support
Built-in Jazz properties
PARM parameter character limits
Alternative DD names
Administering
Administering IBM Engineering Lifecycle Management servers
Administering change and configuration management project areas
Working in the web client
Working in the client for Eclipse IDE
Connecting to repositories and project areas
Accepting a team invitation
Creating and modifying project areas
Creating project areas
Sharing the process of a project area
Enabling project area process sharing across servers
Making a project area shareable
Modifying a project area to use another project area's process
Creating timelines, iterations, and iteration types
Setting project hours and days per week
Creating a team area
Adding and modifying users as members of project areas
Adding existing users
Creating users
Importing users from an external registry service
Assigning roles to users
Assigning administrative privileges
Modifying user information
Setting user work environments
Scheduling team member absences
Defining work item categories
Adding attachments to project areas and team areas
Restricting read access to project area, team areas, and artifacts
Restricting read access to project areas or team areas
Restricting access to work item categories
Archiving project areas and team areas
Adding associations
Customizing the process in projects, teams, and templates
Editing the process configuration source
Editing the process description
Modifying timelines and iterations
Modifying roles
Modifying permissions
Synchronizing time entries
Modifying operation behavior (preconditions and follow-up actions) in project areas and team areas
Operation Behavior (preconditions and follow-up actions)
Modifying project area initialization
Adding formal project management features to a process template
Process customization for formal project management
Viewing history of changes to process
Refreshing the client to see process changes
Working with process templates
Creating a process template
Process templates
Scrum process template
Formal Project Management Process template
Scaled Agile Framework (SAFe) 4.6 Essential process template
Scaled Agile Framework (SAFe) 4.6 Full process template
Scaled Agile Framework (SAFe) 4.5 Essential process template
Scaled Agile Framework (SAFe) 4.5 Full process template
Scaled Agile Framework (SAFe) 4.5 Large Solution process template
Scaled Agile Framework (SAFe) 4.5 Portfolio process template
Unconfigured Process template
Creating process template documentation
Including reports in a process template
Exporting and importing process templates
Migrating a project to a different process template
Adding a translation to a process template
Making templates translatable
Working in the client for Microsoft Visual Studio IDE
Working with projects and teams
Project concepts
Repository
Project area
Team area
Getting started with projects and teams
Accepting team invitations
Connecting to repositories
Deleting repository connections
Modifying repository connection properties
Viewing Client Access License and server information
Connecting to project areas
Disconnecting project areas
Clearing session history
Collaborating
Getting started with your development project
Getting started: Project administrator
Getting started: Team lead
Getting started: Team member
Quick reference
Managing dashboards
Creating development plans
Getting started with planning
Plans and work item management
Plan types
Agile planning
Traditional planning
Schedules in traditional project plans
Schedule dependencies
Schedule constraints
Critical path
Basic resource leveling
The Work Breakdown and Schedule chart
Planning the development with the Eclipse client
Planning projects
Creating project plans
Renaming and reassigning a plan
Duplicating plans
Setting work item types as plan items
Viewing plans associated to a work item
Subscribing to plans
Changing plan configuration settings for a project
Setting project hours and days per week
Computing progress of release plans
Showing time remaining or time spent
Configuring attributes in customized work items to display in a plan
Permitting users to modify allocation
Managing work items and work loads
Find, filter, and colorize work items
Associating plan views with a plan type
Modifying plan view elements in the process configuration
User profile
Setting a user's work environment
Scheduling team member absences
Configuring team loads
Managing work items in My Work view
Managing my new work
Managing my current work
Managing my future work
Previewing my work items
Planning the development with the web client
Planning projects
Creating iteration plans
Exporting plans to a .CSV file
Creating a child iteration
Tracking progress with plan dashboards
Importing and exporting plans with Microsoft Project
Importing, exporting, and reimporting project plans
Plan snapshots
Taking, comparing, and deleting plan snapshots
Linking development plans
Linking plans to artifacts in Configuration Management-enabled projects areas
Changing plan configuration settings for a project
Configuring general planning attributes
Configuring plan types and views attributes
Configuring default state groups and states
Configure plan view using WSJF (decimal) as a sorter
Managing work items
Viewing work items in a plan
Viewing the Work Breakdown and Schedule chart (Gantt chart)
Creating, modifying, and moving work items in a plan
Creating work items from requirements
Creating schedule dependencies between work items
Tracking work item relationships across projects
Organizing work items in a plan
Creating and editing plan views
Planning projects by using boards
Viewing work items with the Kanban board
Managing projects with Quick Planner
Creating a plan board
Creating a work board
Creating tag-based boards
Creating work items in Quick Planner boards
Creating color-coded tags in Quick Planner boards
Sharing Quick Planner boards
Visualizing dependencies using Program Board
Creating Program Board to visualize dependencies
Identifying potential problems by using plan checks
Ranking work items
Ranking all work items in a plan
Ranking work items by dragging
Ranking work items by using menu options
Changing the ranking of work items
Managing project resources
Allocating resources to a project
Adding allocation periods for resources
Modifying allocation periods for resources
Adding allocation periods for a project
Assessing team work with progress and load bars
Planning the development with the Engineering Workflow Management Client for Microsoft Visual Studio IDE
Creating development plans
Plans and work item management
Plans
Plan types
Release plan
Phase plan
Cross Project plan
Creating plans
Creating plan overviews
Adding plan pages
Renaming and reassigning plans
Managing work items
Grouping work items in plans
Creating, modifying, and moving work items in a plan
Creating plan views
Configuring plan views
Instant messaging
Connecting to local Sametime applications
Connecting to Jabber servers
Chatting with team members
Sending files to team members
Sending artifact links to team members from the EWM client for Microsoft Visual Studio IDE
Managing change and releases
Getting started with change management
Getting started with configuration management
Getting started with the IBM Engineering Workflow Management client for Microsoft Visual Studio IDE
Tracking work by using work items
Getting started with work items
Work items
Setting up work items
Defining categories that work items can be filed against
Defining categories that work items can be filed against in the web client
Defining releases
Defining releases in the web client
Using a template to create work items
Creating a work item template
Importing a template
Exporting a template
Deleting a work item template
Creating text templates
Time tracking for work items
Linking work items to artifacts in Configuration Management-enabled project areas
Enabling linking of work items to versioned artifacts
Limitations of linking work items to versioned artifacts
Working in the Eclipse client
Work items perspective and views
Work Items view
Team Artifact view
My Work view
Team Dashboard view
Tag Cloud view
Creating work items
Importing work items from a .CSV file in the Eclipse client
Importing Bugzilla bugs
Additional ways to create work items
Creating work items from a template
Creating a work item by copying an existing work item
Working on and resolving work items
Triaging work items
Updating work items
Merging changes made by another user
Modifying multiple work items simultaneously
Specifying work item constraints
Setting current work item
Viewing work item history
Linking
Linking between AM artifacts and local work items
Linking work items to test artifacts
Linking work items to requirements
Linking work items to plans
Entering time for a work item
Exporting work items
Printing work items
Restricting access to work items
Finding work items
Using predefined queries
Using the user editor commands to retrieve recent and in progress work items
Creating queries
Query structure
Custom attribute queries and link queries
Creating queries
Examples
Limitations
Configuring queries to show work item relationships
Retrieving a specific work item
Searching for potential duplicate work items
Searching from the Console and Error Log views
Using full-text search to find work items
Deleting work items in the Eclipse client
Deleting work item comments
Configuring notifications
Configuring feed settings
Managing risks
Defining risks
Creating risk actions
Setting the currency of risk costs
Customizing work items
Work item customization overview
Defining work item types and attributes
Setting the default work item type
Updating work items with new or modified attributes
Defining a workflow
Setting the order of work item state groups
Defining enumerations
Defining required and implied attributes
Configuring read-only attributes for work item type and work item state
Requiring Electronic Signatures in the web client
Requiring approvals for state transitions
Predefining queries
Customizing the work item editor
Customizing the Quick Information section
Displaying and hiding link types
Adding the Restricted Access presentation
Including process guidance in the work item editor
Customizing attributes
Customization types
Configuring calculated values
Configuring a calculated time value
Configuring default values
Configuring a default description
Configuring a role-based enumeration default
Configuring value sets
Configuring a dependent enumeration value set
Configuring a role-based user list value set
Configuring an HTTP filtered value set provider
Configuring script-based value sets
Configuring validators
Configuring a regular expression validator
Configuring conditions
Configuring dynamic required attributes
Configuring dynamic Read-Only attributes
Customizing email notifications
Defining mapping between change management type and work item type
Working in the web client
Work Items pages in the web client
Creating work items in the web client
Importing work items from a CSV file in the web client
Creating work items from a template
Creating child work items in the web client
Working on and resolving work items in the web client
Triaging work items in the web client
Updating work items in the web client
Modifying multiple work items simultaneously
Specifying work item constraints in the web client
Viewing work item history in the web client
Linking
Linking to work items on remote repositories in the web client
Linking Engineering Rhapsody Model Manager models and local work items
Linking work items to test cases in the web client
Linking work items to requirements in the web client
Linking work items to plans in the web client
Entering time for a work item in the web client
Restricting access to work items
Exporting work items in the web client
Printing work items in the web client
Finding work items in the web client
Using predefined queries in the web client
Using lifecycle queries
Creating queries
Query structure
Organizing queries
Custom attribute queries and link queries
Creating queries
Examples
Limitations
Retrieving a specific work item in the web client
Searching for duplicates
Tracking work items across projects
Deleting work items in the web client
Configuring notifications in the web client
Managing risks
Defining risks
Creating risk actions
Customizing work items in the web client
Work item customization overview
Setting preconditions and follow-up actions for saving work items
Defining work item types and attributes in the web client
Defining enumerations in the web client
Customizing the work item editor
Including process guidance in the work item editor
Adding the Restricted Access presentation
Defining a workflow in the web client
Requiring Electronic Signatures in the web client
Customizing email notifications in the web client
Defining mapping between change management type and work item type in the web client
Working with work items in the client for Microsoft Visual Studio
Getting started with work items
Team Artifact window
My Dashboard window
Configuring the My Dashboard window
Creating work items
Additional ways to create work items
Creating work items from a template
Creating work items in the web client
Working on and resolving work items
Triaging work items
Updating work items
Modifying multiple work items at once
Viewing work item history
Linking work items to artifacts on remote repositories
Tracking current work
Exporting work items
Finding work items
Creating queries
Using predefined queries
Retrieving specific work items
Configuring notifications
Linking to requirements and test artifacts
Managing source code in Engineering Workflow Management source control
Getting started with source control
Engineering Workflow Management source control icons
Setting maximum content size
Suppressing source control pages in the web client
Source control overview
The repository
Workspaces and sandboxes
File content types and line delimiters
Read access permissions
Creating custom attributes
Streams and components
Component baselines
Workspace snapshots
Change sets and change flow
Change sets
Change flow
Flow targets
Incoming change sets
Outgoing change sets
Change sets in a workspace
Change flow, conflict detection, and conflict resolution
Working in the Eclipse client
Sharing Eclipse projects with your team
Working independently in Engineering Workflow Management source control
Adding projects to repositories
Renaming projects in a repository workspace
Removing projects from a repository workspace
Moving projects to other components
Working with projects under Engineering Workflow Management source control
Checking in unresolved changes
Selecting resources to exclude from Engineering Workflow Management source control
Specifying file properties and line delimiter types
Using the File Properties wizard
Setting line delimiter handling
Changing resource properties
Locking resources
Locking streams and components
Automatically locking specific file types
Choosing automatic or manual check-ins
Viewing files in repositories
Searching for repository objects
Creating and managing change sets
Starting a new change set
Specifying current change sets
Completing change sets
Suspending change sets
Combining change sets
Duplicating change sets
Reversing change sets
Discarding change sets from workspaces
Locating change sets
Synchronizing a sandbox with a repository workspace
Creating and applying Engineering Workflow Management source control patches
Organizing projects into components and streams
Component sizing guidelines
Creating components
Renaming components
Searching streams or repository workspaces for components
Creating streams
Deleting streams
Organizing streams into folders
Creating stream queries
Organizing your source control into folders
Preserving and restoring component and workspace configurations
Creating component baselines
Taking workspace snapshots
Replacing workspace contents with snapshots
Creating or deleting snapshot associations
Repository workspaces in team environments
Creating new repository workspaces from streams
Creating new repository workspaces
Changing owners of repository workspaces
Creating load rules files
Creating duplicate workspaces
Creating duplicate workspaces from a point in time
Loading or unloading repository workspaces
Untracking or tracking repository workspaces
Replacing the contents of components or workspaces
Adding and removing components
Replacing stream contents with workspace or component contents
Viewing the operation history of a workspace
Rolling back streams or workspaces
Creating repository workspace and stream queries
Creating snapshot queries
Creating baseline queries
Organizing components into hierarchies
Adding and removing components in hierarchies
Viewing component hierarchy changes
Delivering and accepting component hierarchy changes
Replacing component hierarchies with baselines
Sharing changes with your team
Submitting changes for review
Accepting incoming change sets
Delivering change sets
Filtering for Engineering Workflow Management source control events
Sharing symbolic links
Setting read access permissions
Finding and resolving conflicts
Resolving conflicts in file content
Resolving structural conflicts
Merging changes that include gaps
Gaps in change set history
Workflow for merging gaps
Example of merging gaps
Merging a change set with a gap in its history
Resolving a conflict with a gap in its history
Completing the resulting change set
Accepting from the merge queue
Locating change sets
Exploring change sets
Merge gap examples for SCM CLI
Exploring the history of components and files
Viewing or editing the change history of components
Viewing the baseline history of components
Viewing component history graphically
Viewing the operation history of components
History graph quick reference
Viewing the change history of files or folders
Viewing version identifiers
Reviewing changes in change sets
Saving change logs
Viewing annotations
Comparing baselines
Locating change sets
Viewing check-in history
Deleting file content from the repository
Restoring deleted files or folders
Setting up external compare tools
Understanding and modifying change flows
Adding and changing workspace flow targets
Collaborating with another workspace
Adding and changing stream flow targets
Flowing changes between streams
Flowing changes to different repositories
Using work items and team process with Engineering Workflow Management source control
Associating change sets with work items
Working on work items
Team process preconditions
Restricting deliveries to streams
Working with the code review tool
Code review workflow
Code review preconditions
Associating change requests with change sets
Linking Engineering Workflow Management source control files to ELM artifacts
Visualizing workspaces and streams
Flow diagrams
Creating and populating flow diagrams
Flow diagram elements
Creating flow diagrams
Viewing incoming or outgoing flow nodes
Adding elements to flow diagrams
Linking elements in flow diagrams
Removing elements from diagrams
Changing properties in flow diagrams
Changing palette settings
Working in the shell
Working in Basic mode
Getting started with Basic mode
Creating a work area
Connecting to a repository
Opening a work area
Sharing changes with your team
Adding files or folders
Accepting incoming changes
Delivering changes
Managing resources
Refreshing changes
Moving files or folders
Renaming files or folders
Downloading the latest file version from a stream
Viewing the change history of files
Switching to previous versions
Comparing resources with repository versions
Creating duplicate workspaces from a point in time
Rolling back streams or workspaces
Viewing the operation history of a workspace
Setting preferences
Linking work items to changes
Configuring compare tools
Working in Advanced mode
Connecting to Jazz repositories and project areas
Connecting to repositories and project areas
Connecting to a project area by accepting a team invitation
Setting up repository workspaces
Creating repository workspaces
Loading repository workspaces
Creating a source control configuration file
Adding components
Modifying workspace flow targets
Setting up sandboxes
Creating sandboxes
Setting the current sandbox
Opening the Pending Changes view
Sharing changes with your team
Sharing folders
Associating work items with change sets
Accepting incoming change sets
Checking in change sets
Delivering change sets
Managing resources
Refreshing local changes
Moving files or folders
Renaming files or folders
Undoing changes
Locking and unlocking resources
Viewing the change history of files
Comparing resources with repository versions
Selecting resources to ignore
Viewing and editing Jazz properties
Disconnecting shared folders
Linking Engineering Workflow Management source control files to ELM artifacts
Creating duplicate workspaces from a point in time
Rolling back streams or workspaces
Viewing the operation history of a workspace
Setting preferences
Enabling automatic check ins
Configuring compare tools
Setting additional preferences
Working in the web client
Connecting to repositories from web browsers
Viewing repository contents
Creating custom link types
Creating streams
Modifying stream contents
Creating repository workspaces
Creating a snapshot for a workspace or stream
Creating baselines
Editing workspaces or streams
Editing baselines, components, or snapshots
Editing repository files
Adding files or folders to repositories
Creating text files in repositories
Deleting repository files or folders
Locking repository files
Renaming repository files or folders
Searching for repository artifacts
Editing change set comment
Viewing completed change sets
Create a new work item to associate with file
Associating work items with existing change sets
Working with the code review tool
Configuring code review for a project area
Code review workflow
Code review preconditions
Associating change requests with change sets
Viewing flow and lock information in the Workspace editor and Stream editors
Lock, unlock, and refresh using the Stream editor
Add component action in the stream workspace editor
Adding multiple files using the Component editor
Changing the global configuration context
Setting link validity
Locating change sets
Comparing source control items
Working in the command line
Managing source code in the client for Microsoft Visual Studio IDE
Getting started with IBM Engineering Workflow Management source control
Migrating
Migrating repository workspaces
Migrating from another Source Control provider to Jazz
Adding projects to repositories
Disconnecting projects from repositories
Moving solutions to other components
Read access permissions
Selecting resources to ignore in Engineering Workflow Management source control
Checking in automatically or manually
Undoing changes
Viewing files in repositories
Locking resources
Locking streams and components
Automatically locking specific file types
Linking Engineering Workflow Management source control files to ELM artifacts
Working in the Sandbox Explorer window
Creating a new sandbox
Setting the current sandbox
Sharing projects and solutions
Opening projects and solutions
Editing files
Moving files or folders
Renaming files or folders
Setting read access permissions
Managing change sets
Team process preconditions for Engineering Workflow Management source control operations
Starting new change sets
Configuring Static Analysis tools for source control deliveries
Configuring unit testing tools for source control deliveries
Delivering change sets
Accepting incoming change sets
Suspending change sets
Resuming change sets
Discarding change sets
Combining change sets
Duplicating change sets
Completing change sets
Reversing change sets
Moving files or folders to other change sets
Associating work items with change sets
Associating change requests with change sets
Enabling Open Services for Lifecycle Collaboration
Sharing symbolic links
Viewing change sets associated with work items
Exploring the history of components and files
Viewing the change history of components
Viewing the change history of files
Viewing the baseline history of components
Viewing component history graphically
Viewing the operation history of components
History graph quick reference
Viewing version identifiers
Reviewing changes in change sets
Saving change logs
Locating change sets
Viewing annotations
Creating streams and components
Creating streams
Creating duplicate streams
Creating components
Organizing components into hierarchies
Adding and removing components in hierarchies
Delivering and accepting component hierarchy changes
Replacing component hierarchies with baselines
Working with repository workspaces
Creating repository workspaces
Creating duplicate workspaces
Creating load rules files
Loading or unloading repository workspaces
Replacing component or workspace contents
Replacing stream contents with workspace or component contents
Rolling back streams or workspaces
Viewing the operation history of a workspace
Adding components
Deleting components
Preserving component and workspace configuration
Creating component baselines
Taking workspace snapshots
Replacing workspace contents with snapshots
Creating or deleting snapshot associations
Comparing resources
Comparing resources with repository versions
Comparing workspaces and streams
Comparing baselines
Comparing components with baselines, workspaces, and streams
Comparing workspaces or streams with snapshots
Finding and resolving conflicts
Merging changes in the compare editor
Resolving conflicts
Setting up file compare utilities
Compare arguments
Working with feeds
Viewing feeds
Subscribing to feeds
Understanding and modifying change flow
Modifying workspace flow targets
Collaborating with other workspaces
Adding and changing stream flow targets
Flowing changes to different repositories
Enabling distributed source control
Working with the code review tool
Configuring code review for a project area
Code review preconditions
Searching in the client for Microsoft Visual Studio IDE
Searching for change sets
Searching for components
Searching for workspaces or streams
Searching for snapshots
Filtering and searching for changes
Searching for files
Managing Enterprise Extensions source code
Enterprise Extensions system definitions
System definitions for IBM i
IBM i library definitions
Creating an IBM i library definition
IBM i library naming rules
IBM i language definitions
Creating an IBM i language definition
IBM i translators
Creating an IBM i translator
Translator output pattern rules
IBM i search paths
Creating IBM i search paths
IBM i system definitions generator overview
Generating IBM i build metadata automatically by using the system definitions generator.
Importing a component project to use with the system definitions generator
Running the IBM i system definitions generator
Running IBM i system definitions generator Ant tasks
IBM i system definition reference searches
Searching for object dependencies with the system definition reference search on IBM i
Archiving IBM i language definitions, library definitions, search paths, and translators
Rereferencing an IBM i language definition, library definition, search path, or translator
System definitions for z/OS
z/OS data set definitions
Creating a z/OS data set definition
z/OS data set naming rules
z/OS language definitions
Creating a z/OS language definition
z/OS translators
Collecting load module information
Creating a z/OS translator
Translator output pattern rules
Using STEPLIB and TASKLIB with z/OS translators
z/OS system definitions generator overview
Generating z/OS build metadata automatically by using the system definitions generator
Importing a zComponent project to use with the system definitions generator
Running the System z system definitions generator
Running System z System definitions generator Ant tasks
z/OS system definition reference searches
Searching for object dependencies with the system definition reference search on z/OS
Archiving z/OS language definitions, data set definitions, and translators
Rereferencing a z/OS language definition, data set definition, or translator
Mapping system definitions across repositories
Managing source code on IBM i
Loading an IBM i Project from the Jazz Team Server
Migrating IBM i Projects
Using quick fix to migrate IBM i Projects with Rational Developer for i
Working with IBM i projects by using the command line interface
Using the Compare with IBM i view for IBM i Projects
Managing source code on z/OS
mvsCodePage file property
Managing source code with the ISPF client
Setting ISPF client preferences
Repository connection
Creating or selecting a repository connection
Editing the repository connection
Deleting the repository connection
Logging in to a repository connection
Logging out of a repository connection
Connecting to a project area
Switching project areas
Repository workspaces
Creating or selecting a repository workspace
Editing the repository workspace settings
Changing the repository workspace flow target
Modifying the repository workspace components
Loading the repository workspace
Unloading the repository workspace
Reloading the repository workspace
Deleting the repository workspace
Viewing files in the repository workspace
Viewing pending changes in the repository workspace
Comparing a changed resource to the repository
Work with files in the repository
Creating a file
Sharing files to a repository
Sharing files to a loaded repository workspace
Sharing files to a new repository workspace
Locking a shared file
Unlocking a file
Editing files
Replacing local changes in an ISPF file
Viewing the change history of files or components
Viewing and changing file properties
Checking in a changed file
Create a work item for a change set
Renaming a file in the repository workspace
Deleting a file from the repository workspace
Searching for strings in data sets and members
Managing change sets
Resolving an incoming change set
Managing outgoing change sets
Resolving conflicts
Working with ISPF client builds
Viewing builds
Submitting a build request
Viewing build results
Working with build subsets
Troubleshooting the Engineering Workflow Management ISPF client
Source code data collection service
Searching for object dependencies with the system definition reference search on z/OS
Creating a source code data query
Loading files from the source code data view
Exporting source code data query results
Viewing source code data with the Source Code Data editor
Specifying a source code data scanner
Relationship of the source code data scanner and the dependency build
Changing the source code data collection service interval
Assigning a language definition to a resource
Creating a scan configuration for a stream
Requesting a source code data scan and viewing results
Viewing the status of a stream during scanning
Troubleshooting dependency data scanning
Searching for file dependencies with the Impact Analysis Search
Using the context-aware search
Defining a search engine to manage the search index
Setting up indexing and configuring search parameters
Selecting search engines
Configuring the search index
Scheduling search indexing
Configuring search synonyms
View the status of search engine indexing
Working with builds
Getting started with builds
About Engineering Workflow Management Build
A typical Engineering Workflow Management Build setup
Engineering Workflow Management Build setup variations
Dedicated build workspaces
Component load rules
Ant build toolkit
Build properties
Performing build tasks in the Eclipse client
Setting up builds and viewing results
Creating build definitions
Organizing build definitions into folders
Creating build engines
Configuring email notifications for builds
Requesting builds
Viewing build results
Viewing build status
Comparing build states
Administering Engineering Workflow Management Builds
Starting and stopping the Jazz Build Engine
Logging in to the Jazz Build Engine by using the scm login command
Flowing changes to a build workspace from different repositories
Tagging builds
Canceling build requests
Abandoning builds
Automatically deleting build results
Associating builds with releases
Creating encrypted password files
Setting release and timeline information for snapshots
Performing build tasks in the Web client
Creating and managing build engines
Creating and managing build definitions
Requesting a build
Viewing build results
Associating builds with releases
Viewing build definition and build engine configurations
Viewing build engine status
Viewing build queue status
Performing build tasks in the client for Microsoft Visual Studio IDE
Building with Jazz
About Engineering Workflow Management Build
Jazz build setup variations
Dedicated build workspaces
Component load rules
Ant build toolkit
Build properties
Setting up builds and viewing results
Creating build definitions
Requesting builds
Viewing build results
Tagging builds
Setting up Enterprise Extensions builds
Enterprise Extensions builds
Running dependency builds
Authenticating
Creating a build definition
z/OS build settings
IBM i build settings
Creating linkage source files
Simulating builds
Configuring the project
Running a build
Viewing status and results
Requesting builds
Requesting dependency, personal, and preview builds
Options for personal builds
Building subsets
Configuring the project
Configuring new build subset defaults
Creating subsets
Filtering subsets
Previewing subsets
Duplicating subsets
Ignoring changes
Always load during build
Viewing results
Including compiler error lists in dependency build results views
Including error lists in dependency build results views
Build reports
Dependency build maps
Reusing dependency build preprocessing results
Live logging for builds
Setting up your deployment for live logging
Enabling live logging for your build
Setting message severity level at build request
Using live logging
Console control buttons for live logging
Resolving dependencies from components in a different stream
Managing z/OS builds
Build templates available for z/OS
Building with Ant with Enterprise Extensions and the Rational Build Agent
Preparing your environment
Configuring the Rational Build Agent Service
Security for the Rational Build Agent
Creating a shared zComponent project
Creating a zFolder
Creating zFiles and associating them with language definitions
Creating a new Ant with Enterprise Extensions build definition
Using the Ant with Enterprise Extensions build definition editor
Requesting an Ant with Enterprise Extensions build
Ant with Enterprise Extensions tasks and data types
Ant with Enterprise Extensions custom data types
BuildableResourceCollection custom data type
BuildableResourceCollection parameter
BuildableResourceCollection examples
BuildableResourceList custom data type
BuildableResourceList example
BuildableResource custom data type
BuildableResource parameters
BuildableResource example
ComponentSelector custom data type
ComponentSelector parameters
ComponentSelector example
ProjectSelector custom data type
ProjectSelector parameters
ProjectSelector example
LanguageDefinitionSelector custom data type
LanguageDefinitionSelector parameters
LanguageDefinitionSelector example
Ant with Enterprise Extensions Compile custom data task
Compile custom data task
Compile examples
Using the Rational Build Agent to run command-driven builds
Defining and running a build using the Rational Build Agent
Using the Rational Build Agent and Job Monitor to run builds using JCL
Job Monitor customization
PARMLIB changes
PROCLIB changes
Job Monitor configuration file BLZJCNFG
Submitting JCL inside the build command
Prerequisites and security considerations
Submitting JCL contained in a build system data set
Providing JCL through a Rational Build Agent step command
Job Monitor security
JES security
Actions against jobs: target limitations
Actions against jobs: execution limitations
Access to spool files
Job Monitor configuration file
Security definitions
Define the Job Monitor started task
Define JES command security
Working with ISPF client builds
Viewing builds
Submitting a build request
Viewing build results
Working with build subsets
Using the Jazz Build Engine on z/OS
Running the Jazz Build Engine on z/OS
Creating a password file using BLZBPASS
Improving z/OS dependency build performance
Managing IBM i builds
Starting and stopping the Jazz Build Engine
Build templates available for IBM i
Overview of the IBM i build specification
Creating an IBM i Build Specification - Rational Build Agent build definition
Requesting a personal build for IBM i Build Specification builds
Creating an IBM i Command build definition
Enabling dependency data collection for your stream
Understanding build specification build results
Overview of build results
Viewing the build log file
Viewing the build output records file
Viewing compilation results
Synchronizing a repository workspace with mapped libraries on IBM i
Using the Continuous Load build definition template
Auditing with IBM i
Jazz build Ant task reference
Build Extension Toolkit
Build Definition Import/Export Ant Tasks
createBuildDefinition
deleteBuildDefinition
exportBuildDefinition
reportBuildDefinition
updateBuildDefinition
Build Definition Reference
Build Engines
Build Properties
Build Notification
Configuration Properties
Post-build Deliver Properties
Build Scheduling
Team Build Properties
Build Engine Import/Export Ant Tasks
createBuildEngine
deleteBuildEngine
exportBuildEngine
reportBuildEngine
updateBuildEngine
Build Engine Reference
engineProperty Element
enginePropertyCopy Element
hdsnEngineProperty Element
rbaEngineProperty Element
rbfEngineProperty Element
teamEngineProperty Element - Hudson/Jenkins Build Engine
teamEngineProperty Element - Rational Build Forge Build Engine
Source Control Ant Tasks
delieverChangeSetsToTarget
delieverWorkspaceSnapshot
getWorkspaceName
getWorkspaceOwner
getWorkspaceUuid
isWorkspaceCurrent
isWorkspaceNameUnique
setChangeSetsComplete
setWorkspaceName
setWorkspaceOwner
Build Services Ant Tasks
escapeProperty
getNextMacroCounter
getPassword
logMessage
PropertyNameList
setBuildResult
setBuildResultDeletable
setBuildResultNonDeletable
setPassword
stripTrailingBlanks
teamPlatformShutdown
teamPlatformStartup
unEscapeProperty
Work Item Ant Tasks
createWorkItem
updateWorkItem
copyWorkItem
getWorkItem
queryWorkItem
Enterprise Extensions System Definition Ant Tasks
fileMetadataDelete
folderMetadata
folderMetadatadelete
globalFileMetadata
globalFileMetadataDelete
globalFileMetadataRename
globalFileMetadataReport
globalFolderMetadata
globalFolderMetadataDelete
globalFolderMetadataRename
globalFolderMetadataReport
listLanguageUuid
listResourceUuid
listTranslatorUuid
listSearchPathUuid
remoteFileMetadata
remoteFileMetadataDelete
remoteFileMetadataRename
remoteFileMetadataReport
remoteFolderMetadata
remoteFolderMetadataDelete
remoteFolderMetadataRename
remoteFolderMetadataReport
tookitInit
toolkitTerm
SMP/E Definition Ant Tasks
createFunctionDefinitionSmpe
deleteFunctionDefinitionSmpe
createLanguageExtensionSmpe
createVersionDefinitionSmpe
deleteVersionDefinitionSmpe
exportTask
SMP/E Toolkit Ant Tasks
zOSFetch
zOSImport
zOSPassword
zOSStore
zVMFetch
zVMImport
zVMPassword
zVMStore
Publishing build results and contributions
artifactFilePublisher
artifactFileRetriever
artifactLinkPublisher
buildResultPublisher
cppunitLogPublisher
filePublisher
generateChangeLog
jdtCompileLogPublisher
junitLogPublisher
mstestLogPublisher
nunitLogPublisher
linkPublisher
logPublisher
logLinkPublisher
logRetriever
snapshotPublisher
workItemPublisher
Enabling progress monitoring
startBuildActivity
completeBuildActivity
Working with Jazz source control
teamAccept
teamFetch
teamLastModified
Controlling the build life cycle
requestTeamBuild
getNextTeamBuildRequest
startTeamBuild
completeTeamBuild
waitForTeamBuild
Packaging and deployment
requestPackage
requestDeploy
retrieveChildrenWorkItems
Miscellaneous tasks
deleteBuildResult
buildResultRetriever
pluginOrganizer
buildToolkitVersion
Ant attribute reference
Packaging and deploying with Enterprise Extensions
Configuring a project area for work item packaging
Package and deployment build authentication
Creating a package definition
Creating packages for UrbanCode Deploy
Configuring a z/OS package definition
Configuring an IBM i package definition
Configuring a Linux or UNIX package definition
Creating a ship list filter file
Creating an include or exclude file (optional)
Configuring the auto clean option
Requesting a package
Requesting a z/OS ship list package
Requesting a z/OS work item package
Requesting an IBM i ship list package
Requesting an IBM i work item package
Requesting a Linux or UNIX package
Requesting and viewing a package preview
Checking packaging results
Creating a deployment definition
Configuring a z/OS deployment definition
Configuring an IBM i deployment definition
Configuring a Linux or UNIX deployment definition
Requesting a deployment
Requesting a z/OS or IBM i deployment
Requesting a Linux or UNIX deployment
Checking deployment results
Scheduling packages and deployments
Querying packages and deployments
Exporting package and deployment query results
Promoting artifacts with Enterprise Extensions
Promotion build authentication
Creating source and target builds for promotion
Creating a promotion definition
Customizing promotion settings
Component promotion
Requesting a component promotion
Work item promotion
Configuring the project area for work item promotion
Requesting a work item promotion
Overriding settings in the promotion definition
Promoting work items without using the Engineering Workflow Management client
Viewing promotion status
Reporting
Change and Configuration Management (CCM) reporting
LQE-based reporting using Engineering Workflow Management resources
Reporting on change sets and work items
Creating reports from TRS feeds that include start and end dates of work items
Creating a report from a TRS feed that includes the electronic signature attributes of work item
Analyzing and validating TRS feeds
Change and configuration management BIRT reports
Change and configuration management BIRT report descriptions
Installing BIRT tools
Build reports
Source control reports
Work item reports
Using change and configuration management BIRT reports to get status
Checking project status by release
Checking project status by iteration
Determining project velocity
Change and configuration management data dictionary
Activity
Approval
Approval Descriptor
Approval State
Approval Type
Build Result
Compilation Result
Component
Contributor
Custom Attribute
Iteration
Project Area
Project Area Member
Project Area Role
Project Area Role Assignments
Task
Team Area
Team Area Member
Team Area Role
Team Area Role Assignments
Timeline
Timesheet
Unit Test Event
Unit Test Result
Work Item
Work Item Category
Work Item State
Work Item Status
Work Item Type
Work Item Type Mapping
Workspace/Stream
What's changed in the data dictionary
Change and configuration management reportable REST API
Extending product function
Extending EWM
Extending EWM by using OSLC services
EWM as an OSLC service consumer
EWM as an OSLC service provider
Links across OSLC domains
Additional OSLC integration services and requirements
Troubleshooting and support
Troubleshooting Engineering Workflow Management
Troubleshooting client-server connection issues
Measuring server response times
Limitations and known problems
Troubleshooting synchronization problems
Synchronization errors
ClearQuest Synchronizer limitations and known problems
ClearQuest Import Wizard limitations and known problems
ClearQuest Bridge limitations and known problems
Troubleshooting the Build Agent
Testing host name resolution
Testing the connection
Troubleshooting an agent on Windows systems
Troubleshooting an agent on UNIX and Linux systems
Troubleshooting Jazz Builds
Repeated TeamBuildStateException, in the server log, when abandoning a build
Troubleshooting z/OS
Troubleshooting Ant-based z/OS builds
File agent cannot log in to the Jazz Team Server on z/OS
Minimum Ant with Enterprise Extensions build region size
Using a different STEPLIB environment variable in the ISPF/TSO client
Using ISPF Statistics in Ant-based z/OS builds
Using DBCS characters in zComponent project and zFolder names
Read access permissions considerations for z/OS Ant-based builds
Using the same DD name for a temporary data set with the keep option in translators
Build fails when file list exceeds 100 KB
Build fails with abend S806 in the link-edit parser execution
Troubleshooting the ISPF gateway configuration
Troubleshooting the ISPF client
Member list shows incorrect local changes
Troubleshooting the conversion of code pages for DBCS characters on z/OS
Troubleshooting and support for IBM i
Troubleshooting and getting help for Jazz Team Server on IBM i
Disabling logging in Eclipse-based products
Reference
Source control command line reference
Example scm commands
Logging in to the repository
Getting started
Working independently
Accepting changes
Resolving conflicts
Working with changes
Releng tasks
Using the merge-queue command when accepting change sets with gaps
Environment variables
Synchronize streams across repositories
Kerberos authentication
Specifying file properties and line delimiter types for the source control command-line interface
scm
accept
accept example
add
add component
add component example
add flowtarget
add flowtarget example
add release
add release example
add subcomponent
add subcomponent example
add workitem
add workitem example
annotate
annotate example
checkin
checkin example
combine changesets
combine changesets example
compare
compare example
create
create baseline
create baseline example
create changeset
create changeset example
create component
create component example
create loadrules
create loadrules example
create snapshot
create snapshot example
create stream
create stream example
create workspace
create workspace example
daemon
daemon deregister
daemon deregister example
daemon register
daemon register example
daemon start
daemon start example
daemon stop
daemon stop example
delete
delete snapshot
delete snapshot example
delete state-content
delete state-content example
delete stream
delete stream example
delete workspace
delete workspace example
deliver
deliver example
diff
diff example
discard
discard example
duplicate changeset
duplicate changeset example
export
export code-review
export code-review example
get
get attributes
get attributes example
get change
get change example
get custom-attribute
get custom-attribute example
get file
get file example
get preference
get preference example
get property
get property example
help
help example
list
list accessgroups
list accessgroups example
list baselines
list baselines example
list changes
list changes example
list changesets
list changesets example
list components
list components example
list connections
list connections example
list daemons
list daemons example
list files
list files example
list flowtargets
list flowtargets example
list locks
list locks example
list merge-queue
list merge-queue example
list missing-changesets
list missing-changesets example
list preferences
list preferences example
list projectareas
list projectareas example
list queries
list queries example
list release
list release example
list smartcard-aliases
list smartcard-aliases example
list snapshots
list snapshots example
list states
list states example
list streams
list streams example
list teamareas
list teamareas example
list users
list users example
list workspaces
list workspaces example
load
load example
locate
locate example
login
login example
logout
logout example
move
move change
move change example
move path
move path example
move repository-path
move repository-path example
query
query example
refresh
refresh example
remove
remove component
remove component example
remove flowtarget
remove flowtarget example
remove merge-queue
remove merge-queue example
remove property
remove property example
remove subcomponent
remove subcomponent example
remove workitem
remove workitem example
repair
repair example
resolve
resolve conflict
resolve conflict example
resolve current-merge
resolve current-merge example
resume
resume changeset
resume changeset example
resume merge-queue
resume merge-queue example
set
set access
set access example
set attributes
set attributes example
set changeset
set changeset example
set component
set component example
set current-merge
set current-merge example
set custom-attribute
set custom-attribute example
set flowtarget
set flowtarget example
set lock
set lock example
set merge-queue
set merge-queue example
set preference
set preference example
set property
set property example
set user
set user example
share
share example
show
show attributes
show attributes example
show baseline-hierarchy
show baseline-hierarchy example
show conflicts
show conflicts example
show custom-attributes
show custom-attribute example
show history
show history example
show lastmod
show lastmod example
show operations
show operations example
show properties
show properties example
show sandbox-structure
show sandbox-structure example
show status
show status example
suspend
suspend changeset example
undo
undo change
undo change example
undo current-merge
undo current-merge example
undo merge
undo merge example
unload
unload example
unset
unset custom-attribute
unset custom-attribute example
unset flowtarget
unset flowtarget example
unset lock
unset lock example
version
version example
ClearCase Synchronizer subcommands
addSyncRoots
compare ccase
clones
create synchronizedStream
export ccase
import ccase
import ucmLinks
list, ls
requestSync
start syncEngine
stop syncEngine
update ccase encoding
update ccase skipElement
Subcommand exit codes
On Properties
preferences.properties file
Enabling default logging
z/OS source control command line reference
create dataset
list datasetdefinitions
zload
z/OS mass import tool overview
zimport
Mass import mapping file overview
Mass import tool mapping file format
Work item Email notification template syntax
Email template variables
Email template variable types
Syntax for plans
Quick query syntax
Text formatting syntax for plans
Operation preconditions and follow-up actions
Windows preferences for the Engineering Workflow Management client for Eclipse IDE
Engineering Test Management
Overview
Engineering Test Management
Configuration management capabilities
Getting started
Workflows and guidance
Typical use of Engineering Test Management
Enterprise environment workflow
Multi-channel testing workflow
Video tours
Engineering Test Management overview
Tutorials
Develop a test plan
Introduction: Develop a test plan
Lesson 1: Add support for multiple timelines and team areas
Lesson 2: Copy a test plan
Lesson 3: Select an iteration to create a test schedule
Lesson 4: Add a test plan section
Lesson 5: Define quality objectives and set entry and exit criteria
Lesson 6: Create a risk assessment
Lesson 7: Create a snapshot of the test plan
Work with requirements and the formal review process
Introduction: Work with requirements and the formal review process
Lesson 1: Submit a test plan for review
Lesson 2: Manage requirements related to the test plan
Lesson 3: Review and reject the test plan
Lesson 4: Generate test cases
Lesson 5: Discover suspect test cases
Lesson 6: Approve the test plan
Set up the test environment
Introduction: Set up the test environment
Lesson 1: Specify the test environment
Lesson 2: Generate test case execution records
Work with lab resources
Introduction: Work with lab resources
Module 1: Create lab resource data
Lesson 1.1: Create a physical machine
Lesson 1.2: Create a physical machine with minimal data
Lesson 1.3: Create a virtual image
Lesson 1.4: Display all lab resources
Lesson 1.5: Create a lab resource test environment
Lesson 1.6: Create a test cell for the test environment
Module 2: Request and reserve lab resources
Lesson 2.1: Reserve lab resources for immediate use
Lesson 2.2: Reserve a lab resource for a specific time period
Lesson 2.3: Request a lab resource
Lesson 2.4: Fulfill lab resource requests
Create and run a manual test
Introduction: Create and run a manual test
Lesson 1: Add a manual test script to a test case
Lesson 2: Add test data to a manual test script
Lesson 3: Add an execution variable to a test script
Lesson 4: Create keywords from steps in a manual test script
Lesson 5: Run a test and submit a defect
Work with test suites
Introduction: Work with test suites
Lesson 1: Create a test suite
Lesson 2: Add the test suite to a test plan
Lesson 3: Add existing test cases to a test suite
Lesson 4: Create a test suite execution record
Lesson 5: Run the test suite execution record
Lesson 6: Analyze the test suite execution records
Use reports to assess test results
Introduction: Use reports to assess test results
Lesson 1: Run and save a report
Lesson 2: Drill down into a report
Scenarios
Test Management
Identifying test motivators
Installing
Installing the Quality Management application
Installing Rational AppScan Tester Edition
Upgrading and migrating
Upgrading the Quality Management application
Migrating files into Engineering Test Management
Integrating
Engineering Requirements Management DOORS
Engineering Test Management and Engineering Requirements Management DOORS integration
Configuring Engineering Test Managment and Engineering Requirements Management DOORS integrations
Configuring Engineering Test Management to integrate with Engineering Requirements Management DOORS
Configuring Engineering Requirements Management DOORS to integrate with Engineering Test Management
Rational Change
Rational ClearQuest
Configuring the Rational ClearQuest Bridge as your defect provider
Synchronizing with Rational ClearQuest
Engineering Method Composer
Deploying process guidance
Rational or third-party test tools
Rational test tools integration overview
Third-party test tools integration overview
Rational Functional Tester
Enabling the manual test script recorder
Rational Integration Tester
Rational Performance Tester
Rational Test Workbench
Rational Test RealTime
Rational Test Virtualization Server
Establishing cross-server communication
Linking project areas and domains
Rational Service Tester for SOA Quality
IBM Security AppScan
Security testing overview
Sample data
Configuring IBM Security AppScan Tester Edition
Configuring the integration
Configuring IBM Security AppScan Tester Edition Adapter
Creating and running security tests
Selenium
JUnit Selenium adapter
Administering
Getting started administering projects
Configuring quality management project areas
Setting up timelines, iterations, and team areas
Defining custom workflows for test artifacts
Configuring auto-lock after a state change
Defining transition rules for approval tracking
Defining preconditions and follow-up actions
Preconditions and follow-up actions
Disallow modifications to completed approval groups
Copying precondition configurations
Creating precondition configurations
Defining preconditions for reviews
Mandating actual results in a manual test script
Defining a precondition to select test data records before executing test cases
Requiring electronic signatures for reviews
Allowing users to edit approved artifacts
Setting up a new project area with existing project settings
SAFe QM process templates
SAFe 4.5 QM process templates
Quality Management for Essential SAFe 4.5
Quality Management for Portfolio SAFe 4.5
Quality Management for Large Solution SAFe 4.5
Quality Management for Full SAFe 4.5
SAFe 4.6 QM process templates
Quality Management for Essential SAFe 4.6
Quality Management for Full SAFe 4.6
Copying project properties
Creating a project area template for quality management
Enforcing unique test artifact names
Assigning priority to test artifacts
Customizing work items
Using team areas for lab management
Managing project properties in a Quality Management project
Project properties
List settings in artifact editors
Enabling team areas and support for multiple timelines
Making shared test resources available
Unblocking test case execution records automatically
Creating types associated with machines
Setting up project-level quality objectives
Defining categories and category relationships
Defining custom attributes on the Project Properties page
Managing risk profiles
Defining your own risks
Using custom execution adapter types
Configuring custom execution adapter types
Creating test scripts that use custom test automation adapters
Permanently deleting sensitive data
Setting maximum attachment size
Administering configurations
Setting configuration management preferences
Allowing a role to restore content during a configuration merge
Enabling QM projects to use only baselines
Managing baselines in projects enabled only for baselines
Administering link validity
Administering components
Components
Planning components
Creating components
Archiving and restoring components
Deleting sensitive data from components
Cloning artifacts between components
Cloning: Referenced artifacts
Collaborating
Managing dashboards
Quality Management dashboards
Importing certificates and configuring browsers
Reporting
Engineering Test Management reporting
Quality management predefined reports
Defect reports
Execution reports
Requirements reports
Summary reports
Test case reports
Running and viewing reports for quality management
Running quality management reports for configurations
Running quality management reports to get status
Master and child test plan artifact relationships
Determining the quality of testing
Checking project status with the Execution Trend Report
Determining problem areas
Viewing pending work
Viewing work load distribution across testers
Determining which defects affect requirements
Customizing reports
Creating new report definitions from report templates and copies
Quality management data dictionary
Artifact Categories
Artifact Categories Type
Automation Job
Automation Job Result
Build Record
Defect / Work Item
Key Word
Lab Resource
Lab Resource Group
Non Manual Test Script
Quality Objective
Request
Requirement
Reservation
Test Artifacts Workflows
Test Artifacts Workflows State Group
Test Artifacts Workflows State Group Category
Test Artifacts Workflows Test Priority Category (new added in RQM 401)
Test Case
Test Case Execution Record
Test Case Result
Test Case Result's Result Details
Test Environment
Test Plan
Test Schedules
Test Script
Test Script Step
Test Suite
Test Suite Execution Record
Test Suite Result
Quality management reportable REST API
Testing
Getting started testing software
Getting started managing tests
Preparing to test
Creating custom attributes
Defining custom attributes on the Project Properties page
Displaying custom attributes in test artifacts
Displaying custom attributes and categories as fields and column headings
Identifying and creating requirements
Requirements-based testing
Requirements management
Managing requirements by using the RM application
Creating requirements
Creating requirement collections
Managing risk
How risk assessment scores are calculated
Managing risk profiles
Defining your own risks
Managing the team with work items
Organizing by using categories
Defining categories and category relationships
Displaying custom attributes and categories as fields and column headings
Setting quality objectives and entry and exit criteria
Example: Using quality objectives and entry and exit criteria
Setting up project-level quality objectives
Setting up a review process
Typical review process
Planning the review process
Developing test plans
Test plans
Test plan development checklist
Creating test plans
Creating test plans from templates
Managing test artifact sections
Importing test plans
Creating master and child test plans
Linking to requirement collections
Associating test plans with requirement collections, modules, and module views
Reconciling test plans with requirements in the Requirements Management application
Identifying changes by using link validity
Linking to collections in Engineering Requirements Management DOORS
Associating test plans with IBM Engineering Requirements Management DOORS requirement views
Reconciling test plans with requirements in Engineering Requirements Management DOORS
Linking to development plans
Creating test schedules
Estimating the size of test efforts
Planning test environments
Platform coverage and test environments
Defining your platform coverage
Generating new test environments
Adding existing test environments to a test plan
Creating test environment types
Creating types associated with machines
Creating types associated with any lab resource
Adding quality objectives to test plans
Making shared resources available to test plans
Copying portions of existing documents
Reviewing test plans
Assigning reviewers and approvers
Reviewing test artifacts
Tracking reviews
Developing test cases, test suites, and test scripts
Test cases and test suites
Developing test cases
Creating test cases
Managing test artifact sections
Importing test cases
Adding new test cases to test plans
Adding existing test cases to test plans
Adding existing test scripts to test cases
Adding new test scripts to test cases
Estimating the weight of individual test cases
Linking test cases to development work items
Linking test cases to architecture elements
Linking and managing requirements
Associating test cases with requirements
Generating test cases for requirements in requirement collections in the Requirement Management application
Reconciling test cases with associated requirements
Associating test cases with Engineering Requirements Management DOORS requirements
Reconciling test cases with requirements in Engineering Requirements Management DOORS
Requirement reconcile operation status types
Discovering and updating suspect test cases
Configuring data record selection criteria in test cases
Developing test suites
Creating test suites
Managing test artifact sections
Adding existing test cases to test suites
Adding new test cases to test suites
Adding existing test suites to test plans
Adding new test suites to test plans
Developing execution records for test cases and test suites
Creating a single test case execution record
Creating test suite execution records
Rolling up results for test case execution records
Rolling up results for test suite execution records
Generating test execution records automatically
Generating test execution records from a test plan
Editing test case and test suite execution records
Receiving email notifications for changes to test artifacts
Developing manual test scripts
Manual test scripts
Manual test script steps
Execution variables
Manual test scripts and statements
Using the manual test script recorder
Manual test script recorders
Enabling the manual test script recorder
Setting user preferences for the manual test script recorder
Creating or modifying manual test scripts with the recorder
Adding existing test scripts to test cases
Associating test artifacts with parent test artifacts
Creating manual test scripts
Filtering manual steps in the Manual Test editor
Creating manual test scripts from the test case design
Creating or modifying manual test scripts with the recorder
Customizing the display of manual test scripts
Editing manual test scripts
Editing manual test script steps
Attaching files to script steps
Adding comments to script steps
Verifying text
Providing assisted data entry text
Importing manual test scripts
Linking test script steps to requirements
Linking test script steps to requirements in the Requirements Management application
Linking test script steps to requirements in Engineering Requirements Management DOORS
Setting test script preferences for requirements management
Working with test data
Test data
Creating test data
Updating test data
Using test data in manual test scripts
Using keywords in manual tests
Keywords
Creating keywords
Searching for keywords
Creating automated keywords
Creating keyword-enabled manual test scripts
Editing keywords
Test data in keyword-enabled scripts
Incorporating execution variables into manual tests
Linking test artifacts with Engineering Workflow Management files
Referencing automated test scripts
Automated testing
Making shared test resources available
Creating references to automated test scripts on a local test machine
Creating references to automated test scripts at a shared location
Accessing UNC shares when running WebSphere Application Server as a Windows service
Importing automated test scripts from a test machine
Importing automated test scripts from a shared location
Creating IBM Security AppScan Enterprise test scripts
Managing test artifacts
Save conflicts
Suspect traceability in Quality Management artifacts
Assessing risk
Creating the initial risk assessment
Contributing to the community risk assessment
Comparing the risk of multiple test plans, test cases, and test suites
Copying test artifacts
Copying test artifacts while viewing a list
Copying a single test artifact
Duplicating execution records to another iteration
Creating versioned test artifacts with snapshots
Creating snapshots
Create a new test artifact from a snapshot
Editing, deleting, and reusing test artifacts
Editing test artifacts with the rich-text editor
Deleting and restoring test artifacts
Managing artifact attachments
Reusing test artifacts
Using the screen capture tool
Importing and exporting test artifacts
Exporting Word and Excel test artifacts
Installing the Word and Excel export utility
Creating configuration files for exporting Word and Excel test artifacts
Creating configuration files for Word
Creating configuration files for Excel
Modifying data during the export process
Exporting test artifacts from Word or Excel
Exporting test artifacts to a file
Exporting test artifacts to a repository
Removing the Word or Excel export utility
Troubleshooting the Word or Excel export utility
The RQM menu entry is not displayed
The export menu does not open
Test artifacts cannot be imported
Exporting test-artifact list views as CSV files
Managing the export job queue
Saving test artifacts as PDF files
Linking to requirements and development artifacts
Locking and unlocking test artifacts
Managing artifact templates and sections
Creating templates
Managing test artifact sections
Test plan template reference
Test case template reference
Test suite template reference
Reviewing test artifacts
Assigning reviewers and approvers
Reviewing test artifacts
Tracking reviews
Searching, filtering, and querying test artifacts
Test artifact list views
List settings in artifact editors
Row action menus in test artifact lists
Using the full-text search
Performing a quick search of test artifacts
Disabling automatic searches
Filtering manual steps in the Manual Test editor
Using filters and queries in the list views
Sorting list views
Filtering test artifacts with category filters
Using artifact filters
Using test case and test suite categories to filter execution records
Running saved queries from the sidebar
Adding test artifacts to dashboard widgets
Track test artifacts and activities for auditing
Viewing links to development, requirement, and test artifacts
Managing artifacts in projects enabled only for baselines
Managing artifacts by using configurations
Configuration data on dashboards
Selecting a component and configuration
Managing configuration details
Creating streams
Creating baselines
Showing and setting link validity
Cloning test artifacts
Troubleshooting local configurations
Comparing and merging test artifacts
Compare and merge operations
Viewing artifact versions in graphs
Comparing and merging artifact versions
Comparing configurations
Merging configurations
Markup for comparing configurations
Managing test artifacts in global configurations
Managing lab resources
Getting started managing lab resources
Lab management
Creating and viewing lab resources
Roles in test lab management
Customizing lab resource properties
Creating new test environments
Viewing test environments
Creating lab resource data for physical machines
Creating virtual images
Creating and viewing test cells
Managed virtual images and machines
Creating lab resource groups
Viewing lab resource groups
Searching for lab resources
Hiding lab resources
Deleting and restoring lab management artifacts
Updating lab resource data
Running scripts on remote lab resources
Creating and managing channels
Creating channels
Working with lab resource reservations and requests
Reserving lab resources for a specified time period
Managing reservations of lab resources
Customizing the calendar view
Viewing lab resource reservations
Creating lab resource requests
Viewing lab resource requests
Fulfilling requests and reserving lab resources
Running tests
Preparing for test execution
Test execution
Test case execution workflow
Test suite execution workflow
Test execution preferences
Running tests by using OSLC automation providers
Running test case execution records with deployment plans
Running manual tests
Running test cases
Running test suites
Running test case execution records
Running test suite execution records
Running manual tests with automated keywords
Running manual tests in off-line mode
Running tests without a test script
Selecting test record data during test runs
Running automated tests
Execution adapters
Enforcing reservations for lab resources
Running automated tests with an adapter
Running test suites on specific machines
Changing the adapter for scheduled executions
Optimizing the use of execution adapters
Running command-line tests
Setting up and starting the command-line adapter
Customizing the command-line adapter
Creating a job that uses the command-line adapter to test an application-under-test
Running tests with the command-line adapter using local resources
Running tests with the command-line adapter by reserving specific resources
Adding attachments and links to command-line execution results
Troubleshooting command-line adapter issues
Running JUnit Selenium adapter execution tests
Configuring adapters
Starting JUnit Selenium adapters
Creating and running Selenium scripts in the Quality Management application
Adding screen captures created by a JUnit Selenium test to execution results
Selenium adapter implementation for multiple test cases
Creating and running Rational Integration Tester scripts
Scheduling tests
Test execution schedules
Creating and viewing test execution schedules
Running execution records in execution schedules without precondition checks
Viewing scheduled jobs
Managing test runs and results
Managing active test runs
Updating test script steps during execution
Merging test script steps with updated test case results
Recalculating the weight distribution of test suite execution results
Recording test results without execution
Rerunning tests from test case results
Submitting and tracking defects
Defects
Configuring the CCM application as your defect provider
Designating blocking defects
Submitting defects during test execution
Checking for duplicate defects
Submitting defects from IBM Security AppScan Tester Edition to Engineering Test Management
Tracking test efforts
Quality Management dashboards
Traceability and test execution views
Tracking requirements and development artifacts
Tracking requirement coverage from test plans
Tracking test execution status
Test execution results
Viewing status from a list of test plans
Viewing status within test plans or test suites
Viewing status from a list of test execution records
Viewing status with the Execution Console
Configuring the display of execution status within test plans or test suites
Test artifact status icons
Updating multiple artifacts
Managing product builds
Test execution schedules
Managing product builds
Configuring Engineering Workflow Management as your build provider
Creating and viewing build records
Creating and viewing build definitions
Creating and viewing test cells
Creating and viewing test execution schedules
Extending product function
Extending the Quality Management application
Extending Engineering Test Management by using OSLC services
Engineering Test Management as an OSLC service consumer
Engineering Test Management as an OSLC service provider
Links across OSLC domains
Additional OSLC integration services and requirements
Load Runner Adapter and Quick Test Professional Adapter from HP
Loadrunner and Quick Test Professional adapters
Using HP Loadrunner Adapter
Installation
HP Loadrunner Adapter Installation
HP Loadrunner Adapter Manual Installation
Integration
HP Loadrunner Adapter
Preparing archive file for shared LoadRunner test scenario
Configuring LoadRunner adapter
References
HP LoadRunner Test Script Pages and Sections
LoadRunner Script Details
LoadRunner Shared Location
LoadRunner Test Script Local
HP LoadRunner Execution
Executing a Test Case that refers to a LoadRunner Script
LoadRunner Execution Results Details
Notices for LoadRunner Adapter
LoadRunner Adapter Trouble Shooting
Using HP Quick Test Professional Adapter
Installation
QTP Adapter Installation
Manual Adapter Install Option
Integration
QTP Test Professional Adapter Integration
Preparing archive file for shared QTP test script
Configuring QTP adapter
Mapping RQM Execution Variables to QTP parameters
References
HP Quick Test Professional Test Script Pages and Sections
QTP Script Details
QTP Shared Location
QTP Test Script Local
Notices for Quick Test Professional Adapter
HP Quick Test Professional Execution
Executing a Test Case that refers to a QTP Script
QTP Execution Results Details
QTP Adapter Trouble Shooting
Troubleshooting and support
Troubleshooting Engineering Test Management
Location of log files
Db2 errors
Browser cache issues
Execution fails with an IOException
Execution fails with low-level model error
Remote connection issues
Link to product documentation error
Fixing invalid characters in PDF files of test artifacts
Finding missing changes after modifying an installation
Execution adapter connection issues
Asynchronous migration issues
Troubleshooting local configurations
Support information for Engineering Test Management
Reference
Logging in to Engineering Test Management
Setting user preferences for quality management
Sizing recommendations for Engineering Test Management artifacts
Tracked resource sets
General reference for the QM application
Lab management reference
Engineering Test Management migrations
Engineering Test Management integrations
Project properties
Test artifact relationships
Lifecycle of test artifacts
Test execution states
User preferences for quality management
Reporting
Overview
Choosing a ELM reporting option
Introduction to the Jazz Reporting Service
Introduction to Document Builder
Deciding which data source to use
What's new
Reporting architecture
Data warehouse
Data Collection Component
Lifecycle Query Engine
Report descriptions
Reports and dashboards
Reporting videos and learning resources
Security considerations for Jazz Reporting Service
Tutorials
Create, refine, and manage reports (video)
Create a traceability report (step-by-step)
Trace multiple relationships of an artifact (step-by-step)
Document generation with Document Builder
Report designer: Designing reports from templates
Everyday user: Generating documents
Administrator: Embedding document generation
Document Builder samples
Running the Newskeeper sample
Installing
Deploying Document Builder
WebSphere Application Server
on a stand-alone server
EAR file deployment
On a distributed server
WAR file deployment
dgaas.war deployment
Configuring licenses on WebSphere Application Server
Configuring a reverse proxy
Liberty
Configuring licenses on Liberty
Configuring Document Builder
Configuring users
Configuring users on WebSphere Application Server
Configuring users on Liberty Profile
Configuring authentication
Container authentication
Jazz Team Server container authentication
Jazz Team Server SSO authentication
Microsoft Active Directory Service authentication
Enabling LDAP on WebSphere Application Server
Configuring flags
WebSphere Application Server
Enabling HTTPS
Installing a security certificate for Document Builder
Upgrading and migrating
Upgrading the Jazz Reporting Service applications
Enabling Jazz Reporting Service for Jazz Security Architecture single sign-on
Migrating LQE
Enabling Lifecycle Query Engine for Jazz Security Architecture single sign-on
Administering
Collecting data warehouse data
Administering Report Builder
Setting up and configuring
Managing data sources
Accessing reports on a separate server
Changing the database location
Changing the database backup interval
Activating ready-made reports
Enabling email notification
Assigning report managers
Increasing the maximum number of results in reports
Limiting the number of Excel records in a report
Removing corrupted data and compacting the RB database
Exporting reports to compressed files
Importing reports from compressed files
Administering Lifecycle Query Engine
Getting started with administration
Reducing downtime during LQE reindexing
Connecting to data sources
Adding data sources from a different JTS
Adding data sources from the same JTS
Adding data sources with root services documents
Adding data sources with URLs
Choosing TRS feeds to add
Managing data sources for LQE
Validating TRS feeds and the LQE index
Managing user access to data sources
Running SPARQL queries to test or debug
Collecting historical trend metrics
Setting up email notification
Monitoring and managing performance
Monitoring performance
Improving performance
Compacting indexed data
Improving query responsiveness
Analyzing server statistics
Managing the nodes
Distributing query workload
Lifecycle Query Engine licenses
Managing vocabularies
Backing up and restoring LQE and LDX
Configuring LQE by using properties files
Changing the database password
Removing sensitive data from LQE and LDX
Administering Document Builder
Managing document generation jobs
Adding commands before or after the document generation process
Document Builder URLs
User roles for Document Builder
Mapping roles from Jazz Team Server
Deploying new BIRT or EDG report resources
Viewing and canceling BIRT or EDG reports that are running
Reporting
Authoring reports
Authoring reports with Report Builder
Reporting across projects
Tips for working with traceability reports
Reporting on metrics and historical trends
Reporting on data in configurations
Reporting on data from DOORS
Finding all versions of an artifact
Editing SPARQL or SQL queries
Changing how your report looks
Exporting reports to different formats
Finding and organizing reports
Scheduling reports to run
Authoring document-style reports
Creating document-style reports
Customizing document-style reports
Configuring metadata for document-style reports
Setting up document-style reports from PUB templates
Generating documents with Document Builder
Creating reports from templates
Creating a report from an existing report
Working with JRS reports
Managing data sources
Copying a data source connection
Setting up a data source for configurations
Generating documents from reports
Generating a comparison document
Viewing generated documents
Setting permissions on assets
Sharing documents
Sharing resources with unique URLs
Promoting documents to prevent deletion
Scheduling document generation
Organizing assets and documents
Receiving notifications
Embedding document generation in OpenSocial containers
Managing reports
Creating effective dashboards
Importing certificates and configuring browsers for Report Builder reports
Adding Report Builder reports to dashboards
Refining Report Builder reports in dashboards
Managing available BIRT or document-style reports in the ELM applications
Running and viewing document-style reports
Creating and saving reusable reports
Running and viewing BIRT reports
Printing and exporting BIRT report output
Viewing predefined BIRT reports in dashboards
Organizing BIRT or EDG reports
Updating BIRT or EDG report resources in the project area
Troubleshooting
Troubleshooting for the Data Collection Component (DCC)
Troubleshooting Report Builder
Report Builder log files in Jazz Reporting Service log files
Resolving a corrupt database error
RB and LQE: Setting query and socket timeout
Troubleshooting Lifecycle Query Engine
Preventing out-of-memory errors
Starting LQE fails after data migration
How to access LQE if you lose the lqe.key file
LQE skips resources during indexing
Resolving invalid update warnings
Configuring Lifecycle Query Engine for Japanese text searches
Correctly formatting host names in URIs
Addressing truncated change log errors
Fixing an error 400 after logging into Document Builder
Reference
Ready-to-use reports
Considerations for reporting on data in configurations
Data dictionaries for reporting
Application reportable REST APIs
Configurations: Global and local
Overview
Configuration management: Concepts and capabilities
What's new in this release
Getting started with configuration management
Getting started with global configurations
Getting started with cross-project linking
Getting started with link validity
Tips on the screen
Before you begin
Preparing IBM Engineering Lifecycle Management applications to use configurations
Setting up global configurations
Video tours
Configurations and global configurations overview
Administering
Administering ELM servers
Administering configurations in ELM applications
Considerations for enabling configuration management
Settings related to configuration management
Links across project areas in configurations
Activating configuration management (RM and QM only)
Enabling configuration management in QM and RM project areas
Enabling configuration management in AM project areas
Setting configuration management preferences (QM only)
Setting permissions for configurations in project areas
Enabling link validity
Changing the frequency of link index updates
Granting access to link validity data
Viewing and managing local configurations in ELM applications
Creating streams and baselines
Enforcing change sets and links to work items
Comparing configurations
Archiving and restoring configurations
Administering global configuration project areas
Project areas for GCM
Team areas in the GCM application
Detecting deep component skew
Limiting GCM contributions
Enabling GCM servers to contribute configurations to other GCM servers
Creating RDF vocabulary documents and assigning URIs
Managing type definitions
Creating attributes
Creating data types
Creating branch values
Creating link types
Replacing large strings with queryable strings
Sharing type definitions across GCM project areas
Administering personal streams
Role-based permissions
Creating process templates
Managing process templates in the Global Configuration Management (GCM) application
Using configurations with global configurations
Workflow for variants and baselines in GCM and ELM applications
Cross-project links
Using link validity in IBM Engineering Lifecycle Management applications
Link validity
Viewing and changing link validity status
Reporting on link validity status
Working with multiple change sets
Using components in RM and QM
Components
Administering components in QM
Cloning artifacts between components (QM)
Cloning: referenced artifacts
Administering components in RM
Cloning artifacts between components (RM)
Using configurations
Workflow for using configurations in projects
Managing configurations of requirements artifacts
Managing configurations of test artifacts
Managing configurations of architecture artifacts
Managing configurations of implementation artifacts
Using global components and configurations
Start using a global configuration project
Logging in to the GCM application
Personal dashboards
Workflow for global configurations
Tags, attribute values, and links
Creating a component to establish a work context
Creating, renaming, and deleting tags
Adding tags, attributes, and links to a global configuration or component
Finding global configurations by using queries
Viewing configurations in a tree view
Opening a local configuration from a global configuration
Creating the global configuration hierarchy
Adding configurations to a stream
Creating a baseline to save a milestone
Creating baselines of local streams
Creating a variant by branching
Creating streams
Creating a baseline staging stream from a stream hierarchy
Creating a baseline staging stream from a baseline hierarchy
Managing the global configuration hierarchy
Archived global configurations and components
Managing configurations
Customizing access to components and configurations
Comparing global configurations
Updating streams to match baselines
Working with sections of the global configuration hierarchy
Finding where a stream or baseline is used in configurations
Viewing the history of a configuration
Archiving global configurations and components
Restoring archived global configurations and components
Checking for multiple different configurations of a component (detecting component skew)
Working with personal streams
Finding sensitive data
Deleting sensitive data
Reporting on components and configurations
Reporting on data in configurations
Configuration data on dashboards
Reference
GCM REST API
Troubleshooting and support
Troubleshooting configurations
Troubleshooting global configurations in the IBM Engineering Lifecycle Management (ELM) solution
Log file locations for GCM
Unexpected local configuration in Current Configuration menu
Configuration not replaced with stream or baseline from global configuration
Cannot see, create, or remove links to artifacts across applications
Cannot search for global configurations by attribute value
Pop-up blocker preventing GCM or ELM login
Troubleshooting external contributions
Cannot see the configurations you need in the configuration picker
Cannot add or remove contributions
No configuration details shown or browser blocks content
Engineering Insights
Overview
Getting started with Engineering Insights
On-screen tips and help
Security considerations
Tutorials
Working with views
Introduction: Views
Lesson 1: Create a view
Lesson 2: Populate a view with artifacts
Lesson 3: Edit the view
Lesson 4: Save and run the view
Lesson 5: Use the view to focus on specific artifacts
Working with impact analysis diagrams
Introduction: Impact analysis diagrams
Lesson 1: Create an impact analysis diagram
Lesson 2: Modify an impact analysis diagram
Lesson 3: Create an impact analysis filter
Installing
Upgrading and migrating
Upgrading to the latest version
Migrating queries from 5.0.2 or older versions
Integrating
PTC Windchill Product Lifecycle Management (PLM)
CE Connector for IoT
Upgrading the ELM Connector for IoT from version 6.0.5.1
Configuring the connector
Using Watson IoT Platform and IoT Connection Service data in ELM projects
Tracing relationships of IoT artifacts in views
Administering
Managing the application
Managing users
Managing project areas
Role-based permissions
Managing project content
Importing views and custom artifact elements
Exporting views and custom artifact elements
Enabling the configuration context menu
Managing the whitelist for uploading images
Removing sensitive data
Setting up a report template
Managing engineering data in complex projects
Technical overview
Terminology and concepts
Usage map
Working with data in configurations
Visualizing data across engineering disciplines
Using views
Ready-to-use views
Creating a view
Changing how nodes display in views
Creating a view by using custom containers
Creating custom artifact elements
Adding views to project dashboards
Organizing views and reports in folders
Finding artifacts
Analyzing the impact of change
Impact analysis workflow
Creating impact analysis profiles
Creating impact analysis diagrams
Full traceability
Impact analysis types
Creating impact analysis filters
Analyzing artifact relationships
What artifacts display in diagrams
Reporting
Generating reports from views
Working with reports
Opening artifact links
Troubleshooting and support
Log file locations and tracing
Accessing custom report templates
Administration and configuration problems
Unable to use full screen for views
Unable to access the product
Rhapsody Model Manager
Overview
Tutorial
Installing
Installing server components
Installing DXL scripts
Installing on individual computers
Create project area using EWM client
Upgrading and migrating
Migration from RDM
Importing RDM projects with API
Working with models
Create a project
Global configurations
Check-in and deliver model changes
Handling conflicting changes
Using the web interface
Viewing diagrams
Viewing tables and matrices
Link validity status
Working when disconnected from server
Integrating
Link elements to remote requirements
Link elements to test cases
Link elements to work items
Links to elements from other project areas
Refreshing remote data
Filter remote artifact packages
Administering
Enabling configuration management
Enabling Label mode
Display link validity
Information displayed for remote artifacts
Reduce load on remote server
Disable loading of remote artifacts
Configuration for TLS v1.2
Remove sensitive data
Deploy sample project
Reporting
Generate model reports
Generate traceability reports
Extending product function
API methods for remote artifacts
Welcome
Engineering Lifecycle Management
Overview
Overview of ELM
Products and capabilities
DOORS Next
Comparison of DOORS and DOORS Next
EWM
ETM
RMM
Reporting
ENI
Global Configuration Management
Cloud offerings
Overview
Getting started
Subscribing on the IBM Marketplace
Getting support
Licensing, subscription, and overages
Architecture
Testing IBM Cloud Data Center Latency
Security
DOORS Next professional reporting template self-service portal
Migrating your repository
Learning
Getting started with ELM
Getting started with configuration management
Learning resources
Deployment wiki
Security considerations
What's new
Video tours
Rational solution for Collaborative Lifecycle Management
Tutorials
Money that matters lifecycle scenario
Introduction
Module 1: Plan a sprint
Lesson 1.1: Propose the requirements for a sprint
Lesson 1.2: Explore design options for the sprint
Lesson 1.3: Plan the development effort
Lesson 1.4: Plan the test effort
Lesson 1.5: Assess coverage
Module 2: Complete a story
Lesson 2.1: Create test scripts
Lesson 2.2: Develop a story
Lesson 2.3: Submit a build request
Lesson 2.4: Test for defects
Lesson 2.5: Fix a defect
Lesson 2.6: Confirm that the story is done
Module 3: Stabilize the sprint
Lesson 3.1: Prepare for a sprint shutdown
Summary
Customize process in your project area and team areas
Introduction: Customize process in your project area and team areas
Lesson 1: Create a lifecycle project and assign roles
Lesson 2: Create a timeline and iterations
Lesson 3: Create a team area and add a member
Lesson 4: Explore setting permissions
Lesson 5: Create a role
Lesson 6: Configure operation behavior (CCM)
Lesson 7: Configure operation behavior (QM)
Lesson 8: Customize behavior for an iteration type
Summary: Customize process in your project area and team areas
Samples
Money that Matters sample
Scenarios
ELM agile scenario
Installing and setting up
Installing ELM products
Configuring the environment
Planning the release
Developing a vision
Organizing requirements
Planning the project
Planning the test effort
Completing plan items
Elaborating plan items
Detailing requirements
Developing
Building
Testing
Fixing defects and verifying
Querying for defects
Fixing, delivering, and building
Verifying that defects are fixed
Assessing iteration completeness
Installing
Installing ELM
Upgrading and migrating
Upgrading ELM
Integrating
ELM integrations
Integrating applications on separate Jazz servers
Establishing cross-server communication
Approving access requests
Linking between project areas
HP ALM Quality Center
JIRA
Rational Asset Manager
Administering
Administering projects
Getting started with project areas and lifecycle projects
Administering lifecycle projects
Accessing the Lifecycle Project Administration user interface
Creating lifecycle projects from a template
Lifecycle project templates
Creating a lifecycle project and adding existing project areas
Adding project areas to a lifecycle project
Replacing or removing project areas from lifecycle projects
Adding members to projects
Assigning roles from within lifecycle projects
Configuring process role relationship rules
Modifying a predefined template
Creating a lifecycle project template
Modifying an LPA template to access an RM project template
Importing lifecycle project templates
Deleting lifecycle projects
Administering project areas: Tasks for all applications (web client)
Logging in for project administrators and team leads (web)
Understanding licenses, permissions, and access control
Planning project areas
Creating project areas
Project area
Process
Creating timelines, iterations, and iteration types
Creating timelines and iterations
Timeline
Iteration and iteration types
Creating an iteration type
Modifying timelines and iterations
Creating team areas and associating work item categories
Creating a team area
Team area
Defining categories that work items can be filed against in the web client
Work item category (Filed Against)
Adding and modifying users as members of project areas and team areas
Adding existing users
Assigning roles to a member
Roles
Assigning administrative privileges
Specifying team invitation content in a template
Adding and modifying roles and permissions
Permissions
Change and Configuration Management role-based permissions
Quality Management role-based permissions
Requirements Management role-based permissions
Modifying role-based permissions
Customizing permissions for a specific time period
Customizing permissions in a team area
Adding and removing roles
Restricting read access to project areas, team areas, and artifacts
Restricting read access to project areas or team areas
Restricting access to work item categories
Using access groups to control access to artifacts
Creating access groups
Editing access groups
Archiving access groups
Restoring archived access groups
Setting preconditions and follow-up actions
Preconditions and follow-up actions
Copying configurations
Creating configurations
Adding associations
Enabling architecture management in an EWM project area
Sharing the process of a project area
Enabling project area process sharing across servers
Making a project area shareable
Modifying a project area to use another project area's process
Archiving and restoring project areas and team areas
Archiving project areas and team areas
Restoring archived project areas and team areas
Managing process descriptions and practices
Creating process descriptions
Importing process descriptions
Exporting process descriptions
Archiving process descriptions
Restoring process descriptions
Deleting process descriptions
Creating practices
Importing practices
Exporting practices
Archiving practices, practice elements, and practice categories
Restoring practices, practice elements, and practice categories
Working with process templates
Deploying predefined process templates
Viewing process descriptions for predefined templates
Exporting process templates
Importing process templates
Editing process template IDs, names, and summaries
Viewing process history
Refreshing browser to see process changes
Collaborating
Managing dashboards
Dashboards
Creating personal dashboards
Accessing project and team dashboards
Customizing mini dashboards
Tracking progress with plan dashboards
Adding and organizing content on a dashboard
Creating effective dashboards
Adding and organizing tabs on dashboards
Saving changes to the dashboard
Refreshing dashboard content
Finding a dashboard
Configuring dashboard templates in the process
Adding and configuring widgets
Predefined widgets in the local catalog
Adding a widget
Adding an OpenSocial gadget
Adding the Lotus Connections widget to a project dashboard
Adding a widget from another application
Configuring widgets
Moving and copying widgets
Exporting widgets to HTML
Configuring widget catalog entries in the process
Troubleshooting and support
General product troubleshooting
Accessing the IBM Support community
Accessing release information
Subscribing to product updates
IBM Support Assistant
Getting fixes
Contacting IBM Software Support
Messages
Reference
Accessibility features
Accessibility for Eclipse products
Fonts and color settings
Specifying custom color settings
Configuring the context-sensitive help for screen readers
Keyboard shortcuts
Help system
Requirements Management (RM) application keyboard shortcuts
EWM keyboard shortcuts
ETM keyboard shortcuts
Global Configuration Management keyboard shortcuts
Glossary for ELM
Using the help
Interactive guides
Interactive guides
Jazz Team Server
Overview
Jazz Team Server overview
Deployment wiki
Installing
Installing IBM Engineering Lifecycle Management
Deployment and installation planning for the Engineering Lifecycle Management
Deployment and installation
Hardware and software requirements
Deployment topologies
How many Jazz Team Server to use
Planning your URIs
Applications in this release
Licensing
Single sign-on authentication
Planning to install on Linux, UNIX, IBM i, and z/OS systems
Planning to install on UNIX and Linux systems
Troubleshooting UNIX installations
Installing with Security-Enhanced Linux
Planning to install on IBM i systems
Planning to install on z/OS systems
SMP/E installation process
Checklist for z/OS installations
Installation information for z/OS system programmers
Setting up the JZOS batch launcher
Security on z/OS systems
RACF security
Jazz Team Server security on z/OS systems
Security for z/OS builds
Installation verification process (IVP)
Installing the configuration utility
Examples: Installation process and topology
Example: Installation process
Example topology: For evaluation
Example topology: Standard departmental
Example topology: Distributed enterprise
Techniques for changing your topology
Reverse proxy servers in topologies
DNS names in topologies
Server rename in topologies
Performance considerations
Maximizing performance
High availability and disaster recovery
Change and Configuration Management clustered environment
Quality Management clustered environment
Set up a cluster of Jazz Authorization Server
Downloading the installation media
Interactive installation guide
Interactive installation guide for adding applications
Installing Jazz Team Server and the ELM applications
Installing by using IBM Installation Manager
Installing from a command line
Choosing a different context root than default
Installing on IBM i systems
Installing on z/OS systems
Configuring your installation
Creating directories
Customizing configuration files
Customizing the provisioning profiles
Customizing the logging utility files
Starting the configuration utility
Running the configuration utility
Generating a configuration workflow
Modifying an existing configuration
Working with a configuration workflow
Selecting additional configuration options
Completing the installation
Setting up the database
Setting up a Db2 database
Manually configuring a Db2 database
Increasing IBM Db2 STMTHEAP size
Setting up an Oracle database
Manually configuring an Oracle database
Setting up an SQL Server database
Manually configuring an SQL Server database
Setting up a Db2 database on a z/OS system
Prerequisites
Setting up Db2 for z/OS for Jazz Team Server
Customizing the Jazz Team Server and ELM properties files for Db2
Configuring Jazz Team Server to use Db2 on z/OS
Creating database tables
Creating database tables remotely
Running UNLOAD and LOAD processes for backup
Managing Db2 for z/OS databases before upgrading IBM Engineering Lifecycle Management
Deploying and starting the server
Deploying and starting WebSphere Application Server
Administering the server by using Jython
Administering the server by using the Integrated Solutions Console
Setting up WebSphere Application Server
Deploying ELM applications on the server
Deploying by using single sign-on authentication
Configuring virtual hosts for applications
Configuring a reverse proxy
Importing the WebSphere Application Server certificate into the IBM HTTP Server plug-in
Starting and stopping Jazz Team Server on IBM i systems
Running Jazz Team Server and the ELM applications on z/OS systems or WebSphere Liberty profile on z/OS
Setting up user security on a z/OS system by using RACF
Configuring the Engineering Lifecycle Management and WebSphere Application Server for z/OS
Configuring the Engineering Lifecycle Management and WebSphere Application Server profile on z/OS
Starting the WebSphere Liberty server
Customizing the WebSphere Liberty jvm.options file
Deploying and starting Jazz Authorization Server
Changing the port numbers for the application server
Setting up user management
Managing users on WebSphere Application Server
Enabling LDAP on WebSphere Application Server
Custom realms for authentication and group membership
Managing users by using a federated, file-based registry
Configuring the federated repositories
Setting up groups and users
Managing users on WebSphere Liberty Server
Default user management on WebSphere Liberty server
Configuring an LDAP or an LDAP/SDBM connection
Managing users on Jazz Authorization Server
Configuring a file-based user registry
Configuring an LDAP user registry
Configuring the SCIM feature
Enabling SAML as an identity provider
LDAP and LDAP/SDBM configuration parameters
Configuring the server
Running custom setup
Running express setup
Running the setup from the command line
Running the setup from the command line in express mode
Completing the installation
Configuring the server on IBM i systems
Configuring security certificates
Installing a security certificate
Disabling security certificate settings
Configuring certificate and smart card authentication
Configuring client certificate support in Jazz Authorization Server
Configuring certificate authentication in Engineering Workflow Management
Support for NIST SP 800-131
Configuring WebSphere Application Server to support TLS 1.2 for NIST SP 800-131
Configuring IBM HTTP Server to support TLS 1.2 for NIST SP 800-131
Configuring WebSphere Liberty to support TLS 1.2 for NIST SP 800-131
Configuring repository tools to support TLS 1.2 for NIST SP 800-131
Configuring browsers to support TLS 1.2 for NIST SP 800-131
Configuring Engineering Workflow Management clients and build engines to support TLS 1.2 for NIST SP 800-131
Configuring the Rational ClearCase and Rational ClearQuest connectors to support TLS 1.2 for NIST SP 800-131
Configuring TLS Extended Master Secret (EMS) for WebSphere Application Server and WebSphere Liberty
Configuring Kerberos/SPNEGO SSO
Configuring the server
Deploying Kerberos/SPNEGO SSO
Supported platforms
Microsoft Active Directory
WebSphere Application Server
Multiple Microsoft Active Directory domain controllers
Proxy servers and IBM HTTP Server
LDAP
Verification of SPNEGO authentication
Configuring fallback authentication
Client certificates or smart cards in WebSphere Application Server with SPNEGO
Configuring fallback to application authentication
Configuring fallback to basic credentials
Configuring a SPNEGO filter for earlier client versions
Other installation and troubleshooting information
Logout and token licenses
Reverse lookup zones in the DNS
Host names in Windows domains
Configuring encryption
AES 256-bit encryption
Configuring WebSphere Application Server with SPNEGO for encryption
Enforcing encryption algorithms on domain clients
Troubleshooting SPNEGO issues on WebSphere Application Server
Configuring clients
ELM client
Windows client
kinit utility for local administrators
Encryption algorithms
Providing a session key to the IBM JRE
Linux, UNIX, z/OS, IBM i client
Web client
Modifying the Kerberos configuration and cache files
Ticket expiry
Cross-realm authentication
kinit cache file location
Configuring the krb5 file
Scripted authentication
Collecting debug information for client authentication issues
Changing the public URL by using server rename
Planning for server rename
Server rename
Supported scenarios
Mapping file for server rename
Server rename workflow
Supplemental information about server rename on Jazz.net
Topology diagrams and mapping file examples
Staging environment scenario
Pilot-to-production scenario
Production-to-production scenario
Impact of server rename on the ELM
Jazz Team Server
Change and Configuration Management (CCM) application
Data Collection Component
Lifecycle Query Engine and the Link Index Provider
Quality Management (QM) application
Changes to advanced properties
Engineering Requirements Management DOORS Next
IBM Engineering Lifecycle Optimization - Engineering Insights
Report Builder
Integrated products
Performing a server rename
Preparing the mapping file
Scenario: Setting up a test staging environment
Scenario: Moving a pilot or full production deployment
Changing the context root
Configuring after a database server move
Moving ELM databases to a different database server
Changing ELM databases to a different database vendor
Server rename and the Jazz Authorization Server
Verifying and troubleshooting server rename
Verifying URLs and links after a server rename
Completing the server rename verification process
Jazz Team Server
Change and Configuration Management
Data Collection Component
Global Configuration Management
Quality Management
Report Builder
IBM Engineering Lifecycle Optimization - Engineering Insights
Requirements Management
Rational ClearQuest and Rational ClearCase
Troubleshooting server rename
General recovery procedures
Recovering from generateURLMappings errors
Recovering from importURLMappings errors
Responding to server rename status errors
Reviewing a history of server renames
Configuring the location of the help in a distributed environment
Installing optional tools, clients, and samples
Installing the Build System Toolkit
Installing by using IBM Installation Manager
Installing from a .zip file
Installing the Build System Toolkit on IBM i systems
Installing and configuring the Build System Toolkit on z/OS systems
Creating additional directories (required)
Configuring the ISPF gateway for build, deployment, and promotion support
Installing the Rational Build Agent
Installing the Rational Build Agent on z/OS systems
Creating additional Rational Build Agent directories
Configuring the Rational Build Agent shell script
Completing the installation and running the Rational Build Agent
Using InetD to start the agent
Configuring the agent
Locating the agent configuration file
Changing the agent port
Configuring a different shell
bfagent executable file
bfagent.conf file
Installing on IBM i systems
Installing and running the Rational Build Agent on IBM i systems
Configuring the agent
Locating the agent configuration file for IBM i systems
Changing the agent port
Configuring a different shell
bfagent executable file
bfagent.conf file
Installing and configuring the Rational Build Agent on Linux, UNIX, and Windows
Installing an agent
Installing an agent on Windows
Installing an agent on Linux and UNIX
Running an agent
Running an agent on Windows
Running an agent on Linux and UNIX
Configuring the Rational Build Agent
Locating the agent configuration file
Changing the agent port
Configuring a different shell
Running agent commands on a Network Share File System (Windows)
bfagent executable file
bfagent.conf file
Build Agent Lookup Service
Configuring a lookup service task
Troubleshooting the Rational Build Agent
Installing IBM Engineering Workflow Management connectors
Installing IBM Engineering Workflow Management ClearCase Synchronizer
Installing by using IBM Installation Manager
Installing from a .zip file
Installing IBM Engineering Workflow Management ClearQuest Synchronizer
Installing by using Installation Manager
Installing from a .zip file
Installing IBM Engineering Workflow Management clients
Installing by using Installation Manager
Installing the Eclipse client from a .zip file
Installing the client in Eclipse (p2 install)
Installing the client for Microsoft Visual Studio IDE
Installing the Engineering Workflow Management Shell
Installing the MS-SCCI Provider
Connecting to the server
Installing the IBM Engineering Workflow Management ISPF client
ISPF client security
Security settings and classes
OMVS segment
Data set profiles
ISPF daemon started task on System z
ISPF daemon as a secure z/OS UNIX server
Application protection for the ISPF daemon
ISPF PassTicket support
z/OS UNIX program-controlled files for the ISPF daemon
Troubleshooting ISPF client security
Troubleshooting ISPF client permissions
Troubleshooting ISPF client PassTicket support
ISPF daemon configuration
Started tasks for the ISPF daemon
ISPF daemon configuration file (ispfdmn.conf)
ISPF daemon START (S) command
Configuring and running the ISPF client on z/OS systems
Starting the ISPF client
Installing the context-aware search tool
Installing on Windows, Linux, AIX, or Solaris systems
Installing on z/OS systems
Installing on IBM i systems
Starting and stopping the search engine
Installing the Money that Matters sample
Configuring the Money that Matters sample environment
Installing IBM Security AppScan Tester Edition
Interactive software packages removal guide
Removing Jazz Team Server and the ELM applications
Release notes
Upgrading and migrating
Upgrading IBM Engineering Lifecycle Management
Deployment and upgrade planning
Deployment and upgrade
Hardware and software requirements
Deployment and upgrade process
Client and server version compatibility
Reporting and the upgrade process
Licensing
Planning to upgrade on IBM i and z/OS systems
Special instructions for upgrading on IBM i
Planning to upgrade on z/OS
Staging a test environment for the upgrade process
Examples: Upgrade process and topology
Example: Upgrade stand-alone products to an integrated solution
Example topology: Upgrade from a distributed ELM enterprise to the current version
Downloading the installation media for an upgrade
Upgrading from version 5 to the current version
Interactive upgrade guide
Upgrade script files
Jazz Team Server upgrade script reference information
Change and Configuration Management upgrade script reference information
Quality Management upgrade script reference information
Requirements Management upgrade script reference information
Global Configuration Management upgrade script reference information
Data Collection Component upgrade script reference information
Report Builder upgrade script reference information
Lifecycle Query Engine upgrade script reference information
Link Index Provider upgrade script reference information
Engineering Insights upgrade script reference information
Upgrading the server configuration on z/OS
Configuring the data warehouse after an upgrade
Upgrading the WebSphere Liberty Profile
Enabling Jazz Security Architecture SSO after an upgrade
Verifying the upgrade
Verifying the configuration files during upgrade
Verifying logs, URLs, and administrative pages
Verifying users, licenses, and linked artifacts
Upgrading optional tools, clients, and reporting artifacts
Upgrading the Engineering Workflow Management clients for Microsoft Visual Studio and Eclipse IDE
Upgrading the Engineering Workflow Management Shell
Upgrading Jazz Build Engine
Upgrading the Build System Toolkit on IBM i
Upgrading the Build System Toolkit and Rational Build Agent on z/OS
Upgrading the ISPF client daemon
Upgrading the IBM Developer for z Systems integration
Upgrading Developer for z Systems
Upgrading ClearQuest Synchronizer
Upgrading process templates
Upgrading reporting artifacts
Migrating the database and application server
Migrating databases
Switching from Apache Tomcat to WebSphere Application Server
Changing WebSphere Application Server installations and instances
Administering
Administering IBM Engineering Lifecycle Management servers
Getting started: Server and repository administrator
Repository
Logging in to administer the server
Registering applications with Jazz Team Server
Managing registered applications
Managing licenses
Managing client access licenses
Client access license management
TRS Consumer - Internal license
Installing and managing client access license keys
Managing floating client access licenses
Floating client access license management overview
Installing and managing floating client access license keys
Monitoring and releasing floating client access licenses
Managing floating client access licenses — distributing Rational Common Licensing tokens
Setting up the Rational Common Licensing token service keys
Managing users
Understanding licenses, permissions, and access control
Creating users
Importing users from an external user registry
IBM i authentication methods
System users
Assigning client access licenses to users
Assigning default licenses to new users
Allowing users to register themselves
Receiving email notification when a new user self registers
Disabling the default administrative user
Disabling the default administrative user on IBM i
Archiving and restoring users
Resetting a user password
Changing your password
Configuring the server
Configuring email settings
Configuring database connections
Configuring feed settings
Configuring the frequency of feeds
Configuring themes
Configuring OAuth consumers
Registering consumer keys
Approving consumer keys
Editing consumer keys
Deleting consumer keys
Configuring friends
Establishing friend relationships
Editing servers in the friends list
Deleting servers from the friends list
Managing the URL whitelist
Configuring advanced properties
Suppressing Engineering Workflow Management pages in the web client
Resource-intensive scenarios
Compacting index files
Managing archived and unmapped resources
Configuring a custom logout page
Managing the size of the log file
Enabling automatic archiving of auditable links for work items
Enabling distributed source control
Enabling Open Services for Lifecycle Collaboration
Enabling an external content repository for source control
Moving servers and applications to different timezones
Configuring change event service
Synchronizing LDAP with Jazz Team Server repository user information
Viewing the results of a synchronization
Changing the synchronization frequency
Configuring authentication session timeout
Administering ELM servers in Liberty Admin Center
Interactive backup and restore guide
Backing up and restoring applications
Backing up and restoring the Derby database
Backing up and restoring other supported databases
Backing up and restoring the Jazz Authorization Server
Patch service for ELM applications
Viewing installed patches
Troubleshooting and support
Troubleshooting Jazz Team Server
Log file locations
Troubleshooting the Jazz Team Server setup wizard
Troubleshooting the SMTP server
Using the IBM Support Assistant Data Collector to gather diagnostic information
Running IBM Support Assistant Data Collector
Expanding the scope of data
Reducing the scope of data
Reference
Repository tools command-line reference
-addTables
-archiveUser
-backupJFSIndexes
-compacttdb
-copy
-createFriend
-createTables
-createUser
-createUsers
-createVersionIDs
-createWarehouse
-deleteJFSResources
-dropTables
-dumpArtifacts
-executeDiagnostics
-export
-exportServerRenameURLMappingHistory
-exportUsers
-exportVersionIDs
-finalizeApplicationMigration
-generateURLMappings
-generateWarehouseDDLScripts
-generateWarehouseUpgradeScripts
-help
-import
-importURLMappings
-importUsers
-importVersionIDs
-isServerRunning
-listIssuedFloatingLicenses
-listLicenses
-listStorageAreaKeys
-mergeLPAJTS
-migrateToJsaSso
-migration_ccm_updateConfigurationFiles
-migration_dcc_updateConfigurationFiles
-migration_gc_updateConfigurationFiles
-migration_jts_updateConfigurationFiles
-migration_qm_updateConfigurationFiles
-migration_rm_updateConfigurationFiles
-migration_relm_updateConfigurationFiles
-modifyLinkURIs
-moveContent
-onlineMigrate
-onlineMigrateEstimate
-onlineMigrateRevert
-onlineMigrateStop
-partitioning
-patchApplyApp
-patchApplyGlobal
-patchRevertApp
-patchRevertGlobal
-prepareJsaSsoMigration
-rebuildClosureTable
-rebuildIndices
-rebuildTextIndices
-registerApp
-reindex
-renameURIInWarehouse
-repairQueryableTables
-repairVersionsWithIdenticalTimestamp
-repairUnreferencedVersions
-repairMultipleVersionsMarkedAsCurrent
-repairSuites
-resetRepoLockId
-restoreJFSIndexes
-resumeIndexer
-rmExportLinkValidity
-rmImportLinkValidity
-scmExportComponent
-scmImportComponent
-setStorageAreaKeys
-setup
-setupConfiguration
-suspendIndexer
-synchronizeJFSIndexes
-syncUsers
-unregisterApp
-updateLPASampleTemplates
-upgradeWarehouse
-verify
-verifyJFSIndexes
-verifyURLMappings
-version
Engineering Requirements Management DOORS Next
Overview
Engineering Requirements Management DOORS Next
Comparison of DOORS and DOORS Next
Configuration management capabilities
Getting started
Administering RM projects
Creating and managing requirements
Video tours
Engineering Requirements Management DOORS Next overview
Tutorials
Create and define requirements
Introduction: Create and define requirements
Lesson 1: Create requirements and edit requirement attributes
Lesson 2: Create links in requirements
Lesson 3: Tag artifacts by using shared tags
Lesson 4: Import Microsoft Word documents
Find and view project artifacts in a requirements project
Introduction: Find and view project artifacts
Lesson 1: Open and view artifacts
Lesson 2: Find and tag artifacts
Comment on and review requirement artifacts
Introduction: Comment on and review requirement artifacts
Lesson 1: Comment on requirement artifacts
Lesson 2: Review and approve requirement artifacts
Installing
Installing the RM application
Upgrading
Upgrading the RM application
Integrating
DOORS
Configuring RM as a consumer
Associating RM projects with DOORS modules
Configuring RM as a provider
Rational ClearQuest
Rational Change
Administering
Administering IBM Engineering Lifecycle Management servers
Administering requirements projects or components
Permissions
Creating requirements projects
Managing project or component properties in requirements projects
Creating artifact types
Creating attributes
Creating requirement attribute data types
Module Options
Type Mapping
Creating link types
Link types
Link direction
Link constraints
Creating templates for requirements projects or components
Managing templates for requirements projects or components
Requirements project templates
Scaled Agile Framework (SAFe) 4.5 project templates
Creating artifact templates
Managing artifact templates
Creating module templates
Administering configuration management capabilities
Importing properties from another Requirements Management (RM) project or component
Copying artifacts between projects
Deleting artifacts from the repository
Administering link validity
Controlling changes after enabling configuration management
Cloning artifacts between components
Baselines
Enabling Electronic signatures for a baseline
Administering components
Components
Planning components
Creating components
Fixing component overlap
Archiving and restoring components
Showing and hiding archived components
Managing query workload
Backing up and restoring the index files
Analyzing and validating TRS feeds
Collaborating
Dashboards in the RM application
Composing and managing requirements
Joining a requirements project
Logging in to a requirements project repository
Project dashboards
Personal dashboard
Defining requirements
Creating artifacts
Artifacts
Creating diagrams to support requirements
Business process diagrams
Business process elements
Getting started with business process diagrams
Defining use cases
Use case specification outline
Wireframes
Editing attributes with multiple values
User Preferences
Filters and views
Artifact search
Locks
Uploading files
Inserting files
Data exchange methods
Vision document
Creating modules
Modules
Differences between collections and modules
User Preferences
Duplicating a module
Searching for artifacts in a module
Linking between artifacts in modules
Linking by attribute
Modifying hierarchy in modules
Reusing artifacts in modules
Base artifacts
Filters and module views
Adding comments to artifacts in a module
Exporting artifacts from modules to CSV and spreadsheet files
Importing and exporting files
Importing documents
Import document planning
Importing and extracting artifacts from documents
Importing and exporting CSV and spreadsheet files
Importing artifacts from CSV and spreadsheet files
Exporting artifacts to CSV and spreadsheet files
CSV file format and examples
Importing migration package files
Importing and exporting ReqIF files
Importing from ReqIF files
Exporting to ReqIF files
Creating collections
Collections
Comparing collections
Managing terminology and glossaries
Glossaries
Creating a glossary and terms
Commenting on artifacts
Reviewing artifacts
Reviews
Signing a baseline electronically
Creating reviews
Participating in reviews
Editing artifacts while reviewing a requirement collection
Managing requirements
Managing artifacts with attributes
Adding tags to artifacts and viewing tagged artifacts
Copying artifacts between projects
Requirement workflows
Comparison of artifact grouping methods in requirements management
Traceability
Link Validity
Managing requirements status and other properties
Analyzing the impact of change
Linking to other artifacts
Links between requirement artifacts
Linking artifacts in different projects or components
Linking by attribute
Linking to requirements artifacts in lifecycle applications
Filtering artifacts for links to other applications
Links explorer
Linking requirements to Rational ClearQuest records
Viewing artifact history
Managing artifacts by using configurations
Selecting a component and configuration
Managing configuration details
Creating streams
Creating baselines
Comparing configurations
Managing changes to artifacts
Creating change sets
Linking to work items
Showing change set contents
Discarding change sets
Delivering change sets
Showing where change sets were delivered
Delivering change sets to other streams
Accepting changes
Showing and setting link validity
Cloning requirement artifacts
Troubleshooting local configurations
Artifact recovery
Reporting
Reporting in the RM application
Creating document-style reports
Running data warehouse reports
Reports in the RM application
RM reportable REST API
Requirements management data dictionary
RM Attribute Enumerations
RM Attribute Values
RM Link Types
RM Parent-Child Links
RM Requirement
RM Requirement Collection / Module
RM Requirement Collection / Module Contents
RM Requirement Collection / Module to Test Plan Links
RM Requirement to Request Links
RM Requirement to Requirement Links
RM Requirement to Test Case Links
What's changed in the data dictionary
Extending product function
Extending the RM application
Migrating graphical artifacts
Extending by using OSLC services
RM as an OSLC service consumer
RM as an OSLC service provider
Links across OSLC domains
Additional OSLC integration services and requirements
Troubleshooting and support
Troubleshooting the RM application
Log file locations
Enabling web client logging
Fixing a converter issue in the server in headless mode
Recovering missing artifacts from configurations
Fixing file preview font issues in other languages
Opening artifacts in multiple tabs or windows
Opening artifacts in new tabs in the same window
Redirecting HTTP requests
Pasting invalid XHTML text
Cutting, copying, and pasting text
Updating custom Word templates
Creating a hyperlink to a local file
Moving artifacts from a folder
Creating a project template for a large project
Support information for the RM application
Troubleshooting local configurations
Engineering Workflow Management
Overview
Engineering Workflow Management
Getting started
Video tours
Engineering Workflow Management overview
EWM source control
EWM Build
Engineering Workflow Management planning
Engineering Workflow Management Enterprise Extensions tours
Dependency builds (part 1)
Dependency builds (part 2)
Dependency builds (part 3)
Dependency builds on IBM i
Context-aware search
Component promotion
Work item promotion (part 1)
Work item promotion (part 2)
Packaging and deployment
Source code data collection service
IBM Developer for System z integration feature
ISPF client
ISPF client build results management
Tutorials
Getting started
Get started with Engineering Lifecycle Management
Lesson 1: Setting up a project and team as Administrator
Lesson 2: Getting connected
Lesson 3: Using work items
Lesson 4: Working with plans
Lesson 5: Using the Team Dashboard and My Work views
Lesson 6: Managing source code
Lesson 7: Building with IBM Engineering Workflow Management Engineering Workflow ManagementBuild
Lesson 8: Using the web client
Summary
Tutorial: Exploring the Engineering Workflow Management JUnit example project
Using an Ant with Enterprise Extensions build to compile a COBOL application
Lesson 1: Preparing your environment
Lesson 2: Configuring the Rational Build Agent shell script
Lesson 3: Configuring the Rational Build Agent
Lesson 4: Creating data set definitions
Lesson 5: Creating translators
Lesson 6: Creating language definitions
Lesson 7: Creating a shared zComponent Project
Lesson 8: Adding zFolders and associating them with data set definitions
Lesson 9: Adding build artifacts and associating them with language definitions
Lesson 10: Configuring a build definition
Lesson 11: Requesting a build
Configuring the Jazz Team Server for a sample z/OS application
Tutorial: Understand the workbench environment
Introduction
Lesson 1: Work with perspectives and views
Lesson 2: Create projects and files
Lesson 3: Open and edit files
Lesson 4: Customize your workbench
Project planning
Plan an agile project
Introduction: Plan an agile project
Lesson 1: Create the product backlog
Lesson 2: Plan the release
Lesson 3: Plan the sprint
Lesson 4: View your work
Lesson 5: Track progress by using queries
Lesson 6: Schedule the sprint review
Lesson 7: Shut down the sprint
Summary: Plan an agile project
Plan a traditional project
Introduction: Plan a traditional project
Lesson 1: Create a release plan for the project
Lesson 2: Add resources to the project plan
Lesson 3: Identify and plan for risks
Lesson 4: Define project work
Lesson 5: Create phase plans and the plan schedule
Lesson 6: Assign owners to work items
Lesson 7: Take a snapshot of the planned schedule
Summary: Plan a traditional project
Get started with Quick Planner
Introduction: Get started with Quick Planner
Managing a project with Quick Planner
Define and manage risks
Lesson 1: Define a risk
Lesson 2: Create a risk action
Lesson 3: Linking a risk with a risk action
Summary: Define and manage risks
Create plans and work items in the Engineering Workflow Management client for Microsoft Visual Studio IDE
Create plans and work items
Lesson 1: Create a plan
Lesson 2: Create a work item
Project management
Control access to project areas and their artifacts
Introduction: Control access to project areas and their artifacts
Lesson 1: Control read access to project area
Lesson 2: Restrict access to work items based on team membership
Lesson 3: Control access to specific work items by using an access group
Lesson 4: Restrict access to source control artifacts
Summary: Control access to project areas and their artifacts
Standardize process by using project area process sharing
Introduction: Standardize process in your organization by using project process sharing
Lesson 1: Create a provider project area
Lesson 2: Create a standard setup process template
Lesson 3: Create a consumer project area
Lesson 4: Show that the consumer project area uses the process from the provider project area
Lesson 5: Override permissions in the consumer project area
Lesson 6: Prevent the consumer project area from overriding the permission settings inherited from the provider project area
Summary: Standardize process in your organization by using project area process sharing
Work item customization
Customize work items
Customize work items
Lesson 1: Create a work item type
Lesson 2: Create a work item attribute
Lesson 3: Create an enumeration attribute type
Lesson 4: Define a workflow with approval tracking
Lesson 5: Customize the work item editor
Lesson 6: Create a ToDo work item
Source control
Share changes with your team
Share changes with your team
Lesson 1: Create a repository workspace from a stream
Lesson 2: Deliver changes and resolve a work item
Lesson 3: Accept changes from other team members
Lesson 4: Resolve a conflict
Flowing changes to different repositories
Flowing changes to different repositories
Lesson 1: Flowing changes to different repositories (basic setup)
Lesson 2: Flowing changes to different repositories (advanced setup)
Share changes using the web client
Share changes using the web client
Lesson 1: Add files and folders to a stream
Lesson 2: Lock, download, and edit a file
Lesson 3: Create and edit a text file
Share changes with your team in the Engineering Workflow Management client for Microsoft Visual Studio IDE
Share changes with your team
Lesson 1: Create a repository workspace from a stream
Lesson 2: Deliver changes and resolve a work item
Lesson 3: Accept changes from other team members
Lesson 4: Share a project and solution
Share changes with your team in the Engineering Workflow Management Shell
Share changes with your team
Accept a team invitation
Create a repository workspace
Deliver changes to team members
Set preferences
Resolve a conflict
Work with Jazz properties
Share changes in Basic mode
Preserve component and workspace configuration in the Engineering Workflow Management client for Microsoft Visual Studio IDE
Preserve component and workspace configuration
Lesson 1: Create a component baseline
Lesson 2: Accept incoming baselines and change sets
Lesson 3: Create a snapshot and assign an owner to it
Build management
Manage builds with the Engineering Workflow Management Build
Manage builds with the Engineering Workflow Management Build
Lesson 1: Build definitions and build engines
Lesson 2: Build requests
Lesson 3: Build results
Manage builds with the Engineering Workflow Management Build in the Engineering Workflow Management client for Microsoft Visual Studio IDE
Manage builds with the Engineering Workflow Management Build
Lesson 1: Build definitions and build engines
Lesson 2: Build requests
Lesson 3: Build results
ClearCase and ClearQuest Synchronizers
Get started with the ClearCase Synchronizer
Introduction: Get started with the ClearCase Synchronizer
Create a Jazz administrative user
Add a process role to the Jazz administrative user
Create a ClearCase Synchronized Stream and merge workspace
Import files and folders from
Load imported files to a Engineering Workflow Management workspace
Deliver changes in a synchronized environment
Verify exported files in Rational ClearCase
Create a schedule for future synchronizations
Summary
Get started with the Rational ClearQuest Synchronizer
Module 1: Setting up your Rational ClearQuest environment
Lesson 1.1: Create a schema repository
Lesson 1.2: Create a schema and user database
Module 2: Setting up your Jazz environment
Lesson 2.1: Create an administrative user
Lesson 2.2: Create a project area
Module 3: Using the ClearQuest Synchronizer Setup Wizard
Lesson 3.1: Start the Rational ClearQuest Gateway
Lesson 3.2: Use the Rational ClearQuest Synchronizer Setup Wizard
Module 4: Editing synchronization rules
Lesson 4.1: Assign a role with necessary permissions to the ClearQuest Synchronizer user
Lesson 4.2: Edit Project synchronization rule
Lesson 4.3: Edit the Defect synchronization rule
Module 5: Enabling outgoing synchronization
Lesson 5.1: Enable outgoing synchronization for the Jazz Team Server
Lesson 5.2: Enable outgoing synchronization for the external repository connection
Module 6: Testing the configuration
Lesson 6.1: Submit a Project record
Lesson 6.2: Submit a Defect record
Summary
Scenarios
Iterative development
Planning an iteration
Managing iterations
Assessing iteration results
Managing risks
Installing
Installing the Change and Configuration Management application
Upgrading and migrating
Upgrading the Change and Configuration Management application
Online migration
Migrating Engineering Workflow Management Enterprise Extensions build maps
Migrating Engineering Workflow Management Enterprise Extensions source code data
Migrating from the ClearQuest Synchronizer to the ClearQuest Bridge
Integrating
Rational Build Forge
Creating build engines
Creating build definitions
Rational Change
Rational ClearCase
Getting started with connectors
EWM concepts
Synchronizing and importing data
Deploying Engineering Workflow Management
Planning to synchronize and import
Guidelines for Rational ClearCase users
Element types versus MIME content types
Selecting streams or branches to synchronize
Exporting to VOBs and UCM components
Imported components in synchronized streams
ClearCase Synchronizer subcommands
Updating the synchronizer after server rename
Production environments
Test-staging environments
Preparing the synchronization environment
Configuring a synchronization host
Selecting an operating system account
Creating a Jazz administrative user
Adding the Jazz administrative user to your team
Preparing a sub-VOB component
Known limitations of sub-VOB component mapping
Migrating a synchronization stream
Synchronizing data with the ClearCase Synchronizer
Creating a ClearCase Synchronized Stream and merge workspace
Importing files and folders from Rational ClearCase
Exporting files and folders to Rational ClearCase
Removing a synchronization root
Loading a component root folder into a sandbox
Specifying line termination characters for text files
Configuration specification details for base Rational ClearCase
Creating a synchronized stream work item template
Writing Rational ClearCase triggers for synchronization
Configuring a synchronized stream
Running synchronizations
Scheduling synchronization
Running custom scripts before and after synchronization
Resolving conflicts during synchronization
Stopping the synchronization engine process
Starting the synchronization engine process
Canceling and abandoning a synchronization request
Delivering changes in a synchronized environment
Importing history
Preparing to import
Importing multiple streams
Importing history from a UCM stream
Importing history from base Rational ClearCase
Verifying the imported history
Importing additional history
Managing the synchronization environment
Managing streams
Editing a synchronized stream
Synchronization options
Stream properties
Unlocking a synchronized stream
Changing the default script location
Managing the synchronization host
Changing the synchronization host
Changing the dynamic view
Upgrading the ClearCase Synchronizer
Managing merge workspaces
Modifying the workspace
Creating a workspace for a synchronized stream
Limitations and known problems
Troubleshooting synchronization problems
Synchronization errors
Migrating data
Planning to export and import
Identifying VOBs and subfolders to migrate
Choosing view configurations
Selecting versions to export by filtering
Examples of selecting versions with filters
Disk space
Incremental migration
Element types versus MIME content types
Preparing the environment
Configuring the export and import hosts
Selecting an operating system account for exporting
Adding the Jazz administrative user account to your team
Creating EWM streams and components
Exporting and importing data
Exporting multiple configurations
Migrating incrementally
Exporting data and specifying the change-set comment format
Updating character encoding of text files
Excluding file elements from the exported data files
Specifying the user accounts mapping
Importing data into EWM source control
Importing change-set links
Verifying stream and component histories
Verifying configuration and version histories
ClearCase Version Importer limitations and known problems
Export problems
Import problems
Error messages
ClearCase Bridge
Version compatibility and functionality
Connecting EWM and UCM
Manually associating activities with work items
Viewing linked work items and UCM activities
Enforcing an association
Configuring site-wide integration
Connecting EWM and base Rational ClearCase
Associating element versions with work items
Manually associating element versions with work items
Viewing linked work items and element versions
Updating the bridge after server rename
Production environments
Test-staging environments
Rational ClearQuest
ClearQuest Synchronizer
Getting started
Prerequisites
Configuration checklist
Deploying the ClearQuest Synchronizer
Connecting to multiple project areas
Starting the ClearQuest Gateway
Verifying the ClearQuest Gateway is running
Setting up the ClearQuest Synchronizer
Starting the setup wizard
Configuring Rational ClearQuest
Configuring Jazz Team Server
Creating record queries
Resetting the ClearQuest Gateway
Configuring project areas for synchronization
Synchronization rules
Planning synchronization rules
Sample planning worksheet
Reviewing synchronization rules
Creating synchronization rules
Mapping records to work items
Configuring rules for external users
&n