Photo by GuerrillaBuzz on Unsplash

Managing Cross-Application Dependencies in z/OS Applications

In the ecosystem of z/OS applications, managing cross-application dependencies is crucial for ensuring seamless integration and efficient operation when adopting Git-based practices. This blog post explores the essential concepts and tools for handling these dependencies during the build phase, highlighting new supporting tools such as the DBB Git Migration Modeler and the concept of Application Descriptor files.

Git Repositories Organization

When adopting Git, it is generally accepted that each application has its own Git repository, with a dedicated pipeline setup and cadence. In the mainframe world, applications provide services through public interfaces, defined in includes files (like copybooks in Cobol) or represented by object decks, which consumers need access to for successful builds. This organization helps in managing dependencies effectively by isolating changes and allowing each application to evolve independently, while consuming services provided by others.

Introduction to Cross-Application Dependencies

Cross-application dependencies between z/OS applications are natural like with other languages. The shift to Git and smaller application repositories introduced a physical separation of sources belonging to different applications. When using multiple Git repositories to manage components’ lifecycles independently, it becomes important to document how applications depend on each other’s materials to successfully build and deploy.

How to declare Cross-Application Dependencies

To document their dependencies on each other, applications should use a standard mechanism to list these dependencies and potentially the versions of the applications that they rely on. As a solution, we are introducing a specific file called the Application Descriptor, which describes:

• The lists of artifacts with their properties (type, usage),
• The known application dependencies required for build and deployment,
• The other applications that consume services provided by the primary application.

Using an Application Descriptor file offers several advantages:

• Centralized Documentation: It provides a single source of truth for all dependencies, making it easier to track and manage them.
• Automated Dependency Management: Enable pipelines to automatically retrieve and validate external dependencies, reducing manual effort and errors.
• Enhanced Collaboration: Development teams can clearly understand the dependencies and services their applications rely on, facilitating better coordination.
• Improved Build and Deployment Processes: By explicitly declaring dependencies, the build and deployment processes become more predictable and reliable.
• Scalability: As applications grow and evolve, the Application Descriptor ensures that dependencies are managed consistently, supporting scalability.
  

Creation and management of the Application Descriptor files

Manually creating an Application Descriptor file would be cumbersome, time-consuming and heavily reliant on developers’ knowledge and experience. But the DBB Git Migration Modeler is your friend! This open-source utility assists in migrating source codebases to Git, analyzing cross-application dependencies, and also is generating Application Descriptor files.

The DBB Git Migration Modeler offers several key benefits for managing cross-application dependencies:

• Automated Analysis and Grouping: The Migration Modeler helps verify existing application boundaries and groups artifacts into applications based on documented naming conventions. This automation reduces manual effort and ensures accuracy.
• Migration Support: It assists in migrating source codebases from PDSs to z/OS UNIX System Services and configuration of properties, streamlining the transition to Git.
• Dependency Analysis: The tool analyzes cross-application dependencies, providing insights into how applications interact and depend on each other. This analysis is crucial for planning changes and updates throughout the lifecycle of applications.
• Build Framework Integration: By generating build properties, the tool prepares a correct configuration for build pipelines, ensuring consistent configuration with the legacy source-code management solution.
• Open-Source and Customizable: As an open-source tool, the Migration Modeler can be customized to fit specific organizational needs, providing flexibility and adaptability.

It also supports identifying unclaimed and shared files, and initializing Git repositories and baselines archives, based on the latest packaging capabilities.  

A sample Cross-Application Scenario

Consider an application "Payments" that depends on services from "Customers" and "Cards." The Application Descriptor for "Payments" would include dependencies on specific versions of these services. The Application Descriptor file for the Payments application would then contain the following Dependencies section:

During the build process, the pipeline automatically fetches the required dependencies at the specified version, validate them, and can even ensure that all prerequisites are met before deploying the build artifacts into a target runtime environment.

Conclusion

Effectively managing cross-application dependencies in z/OS applications is essential for maintaining stability and enabling continuous integration and delivery. Adopting Application Descriptor files to document these dependencies between z/OS applications can help customers successfully migrate to Git-based CI/CD pipelines. Furthermore, the DBB Git Migration Modeler is designed to help organizations migrate their source code base to Git while implementing best practices to streamline their development processes and reduce the risk of integration issues. This ultimately leads to more reliable and robust Git-based development workflows using an open-source approach.

Authors: Dennis Behm and Mathieu Dalbin