padv.pipeline.GitLabOptions

Options for generating pipeline files for GitLab CI

expand all in page

    Description

    Use the padv.pipeline.GitLabOptions object to specify options for generating GitLab® pipeline files. To generate pipeline files, pass the object to the padv.pipeline.generatePipeline function.

    Creation

    Syntax

    options = padv.pipeline.GitLabOptions(GeneratorVersion=version)
    options = padv.pipeline.GitLabOptions(___,PropertyName=Value)

    Description

    options = padv.pipeline.GitLabOptions(GeneratorVersion=version) creates configuration options for generating a GitLab CI pipeline using the specified pipeline generator version.

    • Use GeneratorVersion=1 if you need to maintain compatibility with existing pipelines.

    • Use GeneratorVersion=2 for new pipelines or when upgrading your pipeline setup.

    example

    options = padv.pipeline.GitLabOptions(___,PropertyName=Value) sets properties using one or more name-value arguments.

    Some properties are available in Both Versions, while other properties are specific to Version 1 Only or Version 2 Only.

    Input Arguments

    expand all

    Pipeline generator version, specified as either:

    • 1 — Pipeline Generator Version 1 provides compatibility with the original pipeline generator functionality. Use GeneratorVersion=1 if you need to maintain compatibility with existing pipelines. For more information, see Integrate Process into GitLab.

    • 2 — Pipeline Generator Version 2 contains several improvements to pipeline file propagation, generated pipeline file size, and integration with artifact management systems. Use GeneratorVersion=2 for new pipelines or when upgrading your pipeline setup. For more information, see Process Integration and Artifact Management for GitLab.

    Properties

    expand all

    Both Versions

    GitLab CI/CD tags, specified as a string or string array. Use this property to specify the tags that appear next to the tags keyword in a generated GitLab pipeline configuration file.

    The GitLab CI/CD tags select a GitLab Runner for a job. The property Tags specifies which CI/CD tags appear next to the tags keyword in a generated pipeline configuration file.

    For more information, see the tags keyword in the GitLab CI/CD YAML syntax reference.

    Example: options = padv.pipeline.GitLabOptions(Tags="high_memory")

    Data Types: string

    Command to start MATLAB program, specified as a string.

    If you use a custom command to launch MATLAB on your machine, make sure to set this property. The default value of this property is "matlab", which assumes MATLAB is available in the PATH environment variable for your system and runs the default MATLAB executable.

    Example: "C:\Program Files\MATLAB\R2024b\bin\matlab.exe"

    Data Types: string

    Command-line startup options for MATLAB, specified as a string.

    Use this property to specify the command-line startup options that the pipeline uses when starting the MATLAB program. This property defines the command-line startup options that appear next to the -batch option and MatlabLaunchCmd value in the"script" section of the generated pipeline file. The pipeline starts MATLAB with the specified startup options. By default, the support package launches MATLAB using the -batch option. If you need to run MATLAB without the -batch option, specify the property AddBatchStartupOption as false.

    Some MATLAB code, including some built-in tasks, can only run successfully if a display is available for your machine. For more information, see Set Up Virtual Display Machines Without Displays.

    Example: padv.pipeline.GitLabOptions(MatlabStartupOptions = "-nodesktop -logfile mylogfile.log")

    Data Types: string

    Specify whether to open MATLAB using -batch startup option, specified as a numeric or logical 0 (false) or 1 (true).

    By default, the support package launches MATLAB in CI using the -batch startup option.

    If you need to launch MATLAB with options that are not compatible with -batch, specify AddBatchStartupOption as false.

    Example: padv.pipeline.GitLabOptions(AddBatchStartupOption = false)

    Data Types: logical

    Checkout Git submodules at the beginning of each pipeline stage, specified as either:

    • "false"

    • "true"

    • "recursive"

    Data Types: string

    Number of stages and grouping of tasks in CI pipeline, specified as either:

    • padv.pipeline.Architecture.SingleStage — The pipeline has a single stage, named Runprocess, that runs each of the tasks in the process.

      Example pipeline graphic that shows one stage that runs all tasks on all models

    • padv.pipeline.Architecture.SerialStages — The pipeline has one stage for each task iteration in the process.

      Example pipeline graphic that shows one stage that runs TaskA on ModelA, one stage that runs TaskA on ModelB, one stage that runs TaskB on ModelA, and one stage that runs TaskB on ModelB

    • padv.pipeline.Architecture.SerialStagesGroupPerTask — The pipeline has one stage for each task in the process.

      Example pipeline graphic that shows one stage that runs one task, TaskA, and one stage that runs another task, TaskB

    • padv.pipeline.Architecture.IndependentModelPipelines— The pipeline contains parallel, downstream pipelines for each model. Each downstream pipeline independently runs the tasks associated with that model. To make sure the jobs run in parallel, make sure that you either have multiple build agents available or configure your build agent to run parallel jobs.

      Example pipeline graphic showing two parallel downstream pipelines. One pipeline that runs tasks on ModelA. One pipeline that runs tasks on ModelB.

    Example: padv.pipeline.GitLabOptions(PipelineArchitecture = padv.pipeline.Architecture.SerialStages)

    Options for runprocess command, specified as a padv.pipeline.RunProcessOptions object.

    The padv.pipeline.RunProcessOptions object has properties for the name-value arguments in the runprocess function, except for the arguments Tasks, Process, Subprocesses, and FilterArtifact.

    For example, to have the pipeline generator use a command like runprocess(DryRun = true) in GitLab, you can create a padv.pipeline.RunProcessOptions object, specify the property values, and pass the object to padv.pipeline.GitLabOptions:

    rpo = padv.pipeline.RunProcessOptions;
rpo.DryRun = true;
glo = padv.pipeline.GitLabOptions(RunprocessCommandOptions = rpo);

    Note

    The GenerateJUnitForProcess property in padv.pipeline.RunProcessOptions is set to false by default. Previously, in padv.pipeline.GitLabOptions, this property was true by default. The GenerateJUnitForProcess property in padv.pipeline.GitLabOptions will be removed in a future release. Make sure to specify the GenerateJUnitForProcess property in padv.pipeline.RunProcessOptions to the value that you want the pipeline to use.

    Example: padv.pipeline.GitLabOptions(RunprocessCommandOptions = padv.pipeline.RunProcessOptions)

    Stop running pipeline after stage fails, specified as either:

    • 1 (true) — Stop the pipeline immediately when any stage fails.

    • 0 (false) — Allow the pipeline to continue running subsequent stages, even if a previous stage fails.

    If you use the built-in tasks padv.builtin.task.RunTestsPerModel or padv.builtin.task.RunTestsPerTestCase to run tests, keep StopOnStageFailure set to false. This prevents the pipeline from skipping the padv.builtin.task.MergeTestResults task if a test stage fails.

    Data Types: logical

    File name of generated GitLab pipeline file, specified as a string.

    By default, the generated pipeline generates into the subfolder derived > pipeline, relative to the project root. To change where the pipeline file generates, specify GeneratedPipelineDirectory.

    Example: padv.pipeline.GitLabOptions(GeneratedYMLFileName = "padv_generated_pipeline_file")

    Data Types: string

    Location where the generated pipeline file generates, specified as a string.

    This property defines the directory where the generated pipeline file generates.

    By default, the generated pipeline file is named "simulink_pipeline.yml". To change the name of the generated pipeline file, specify the GeneratedYMLFileName property.

    Example: padv.pipeline.GitLabOptions(GeneratedPipelineDirectory = fullfile("derived","pipeline","test"))

    Data Types: string

    When to collect build artifacts, specified as:

    • "never", 0, or false — Never collect artifacts

    • "on_success" — Only collect artifacts when the pipeline succeeds

    • "on_failure" — Only collect artifacts when the pipeline fails

    • "always", 1, or true — Always collect artifacts

    If the pipeline collects artifacts, the child pipeline contains a job, Collect_Artifacts, that compresses the build artifacts into a ZIP file and attaches the file to the job.

    This property creates an "artifacts" section in the generated pipeline file. For more information, see the artifacts keyword in the GitLab CI/CD YAML syntax reference.

    Example: padv.pipeline.GitLabOptions(EnableArtifactCollection="on_failure")

    Data Types: logical | string

    Name of ZIP file for job artifacts, specified as a string.

    This property specifies the file name that appears next to the name keyword in the generated pipeline file. For more information, see artifacts:name in the GitLab CI/CD YAML syntax reference.

    Example: padv.pipeline.GitLabOptions(ArtifactZipFileName = "my_job_artifacts.zip")

    Data Types: string

    Generate Process Advisor build report, specified as a numeric or logical 1 (true) or 0 (false).

    Example: padv.pipeline.GitLabOptions(GenerateReport = false)

    Data Types: logical

    File format for the generated report, specified as one of these values:

    • "pdf" — PDF file

    • "html" — HTML report, packaged as a zipped file that contains the HTML file, images, style sheet, and JavaScript® files of the report

    • "html-file" — HTML report, consisting of a single HTML file that contains the text, style sheets, JavaScript, and base64-encoded images of the report

    • "docx" — Microsoft® Word document

    Example: padv.pipeline.GitLabOptions(ReportFormat = "html-file")

    Name and path of generated report, specified as a string array.

    By default, the report path uses a relative path to the project root and the pipeline generator generates a report ProcessAdvisorReport.pdf.

    As a recommended practice, set the ReportPath to a sub-folder within the project root. CI pipelines cannot archive files located in the project root itself.

    Example: padv.pipeline.GitLabOptions(ReportPath = "myReport")

    Data Types: string

    Enable integration with OpenTelemetry to view detailed pipeline timing and execution data, specified as a numeric or logical true (1) or false (0).

    Before you enable the OpenTelemetry integration, you must install the OpenTelemetry-MATLAB package and set up OpenTelemetry, as shown in Collect Detailed Execution Data with OpenTelemetry Integration.

    Data Types: logical

    Version 1 Only

    How long GitLab stores job artifacts before the artifacts expire, specified as a string.

    For Pipeline Generator Version 1, generated pipelines use this property to determine how long GitLab stores job artifacts before the artifacts expire and GitLab deletes the artifacts. This property specifies the expiry time that appears next to the expire_in keyword in the generated pipeline file. For a list of valid possible inputs, see artifacts:expire_in in the GitLab CI/CD YAML syntax reference.

    Pipeline Generator Version 2 ignores this property.

    Example: padv.pipeline.GitLabOptions(ArtifactsExpireIn = "60 days")

    Data Types: string

    The pipeline generator does not use this property.

    Enable pipeline caching to support incremental builds in CI, specified as a numeric or logical 0 (false) or 1 (true).

    For Pipeline Generator Version 1, generated pipelines use caching by default to help the performance of incremental builds in CI. However, if a generated pipeline has persistent conflicts and generates errors when merging artifact information from parallel jobs, you can disable pipeline caching by specifying EnablePipelineCaching as 0 (false). Disabling pipeline caching increases build times, but can help avoid merge conflicts.

    Pipeline Generator Version 2 ignores this property.

    Data Types: logical

    Version 2 Only

    Path to root folder of support packages on build agent, specified as a string.

    You can find this location by using the function matlabshared.supportpkg.getSupportPackageRoot on the build agent.

    Note

    If you specify this property, you must also specify the variable MW_SUPPORT_PACKAGE_ROOT in your CI system.

    Pipeline Generator Version 1 does not support this property.

    Example: "C:\\ProgramData\\MATLAB\\SupportPackages\\R2025a\\bin"

    Data Types: string

    Relative path from repository root to project root folder, specified as a string.

    If your project root folder is at the repository root, leave RelativeProjectPath as an empty string "".

    If your project is located in a subfolder, set RelativeProjectPath to the subfolder path relative to the repository root. The value of RelativeProjectPath must be the portion of the project path after the repository root and must be a valid sub-path within the full path to the project root folder. The path must end with the file separator /.

    For example:

    SituationProject Root FolderValid RelativeProjectPath
    Project in repository repo"/home/user/repo-root/"""
    Project in subfolder"/home/user/repo-root/src/myproject/""src/myproject/"

    Note

    If you specify this property, you must also specify the variable MW_RELATIVE_PROJECT_PATH in your CI system. The path must end with the file separator /.

    Pipeline Generator Version 1 does not support this property.

    Example: "src/myproject/"

    Example: "subfolder/src/myproject/"

    Data Types: string

    Name of remote build cache directory, specified as a string.

    The pipeline generator uses the directory to store pipeline artifact caches on the remote build cache service. The artifacts and sub-folders are inside a root folder. You can specify the name of the root folder by using the RemoteBuildCacheName property.

    For example, inside your artifact storage location, the pipeline generator can generate a folder structure such as:

    <RemoteBuildCacheName>/
└── branchName/
    └── folderForEachRunId/
        └── folderForEachTaskIteration/
            ├── Project/
                ├── PA_Results/
                ├── derived/
            │       └── artifacts.dmr
        ├── ir_dag.json
        ├── simulink_pipeline
└── __lastSuccessfulRunId__

    As a best practice, use a unique name for each pipeline and project to avoid conflicts between different pipelines.

    Example: "GitLab MATLAB Pipeline"

    Data Types: string

    Artifact storage approach, specified as one of the values in this table. The artifact service mode determines how the pipeline stores and retrieves artifact caches. Depending on which approach you choose, you must also specify the additional properties and credentials in the Requirements column.

    ValueDescriptionRequirements
    "network"

    Store artifacts on a network drive

    Set the NetworkStoragePath property.

    "jfrog"

    Store artifacts in a JFrog Artifactory repository

    Set both the ArtifactoryUrl and ArtifactoryRepoName properties.

    In your CI system, save your JFrog API token as a secret with the ID ARTIFACTORY_API_TOKEN_SECRET.

    "s3"

    Store artifacts in an Amazon S3™ bucket

    Set both the S3BucketName and S3AwsAccessKeyID properties.

    In your CI system, save your Amazon S3 access key as a secret with the ID S3_AWS_SECRET_ACCESS_KEY_SECRET.

    "azure_blob"Store artifacts in an Azure® Blob Storage container

    Set the AzContainerName property.

    In your CI system, save your Azure storage account connection string as a secret with the ID AZ_CONNECTION_STRING_SECRET.

    Pipeline Generator Version 1 does not support this property.

    Path to network storage location for storing artifacts when ArtifactServiceMode is "network", specified as a string.

    Specify the path to a shared network location that all agents running the pipeline can access.

    Pipeline Generator Version 1 does not support this property.

    Example: "/artifactManagement/cacheStorage"

    Data Types: string

    URL of JFrog Artifactory server for storing artifacts when ArtifactServiceMode is "jfrog", specified as a string.

    Pipeline Generator Version 1 does not support this property.

    Example: "http://localhost:8082/artifactory"

    Data Types: string

    Name of JFrog Artifactory repository for storing artifacts when ArtifactServiceMode is "jfrog", specified as a string.

    Pipeline Generator Version 1 does not support this property.

    Example: "example-repo-local"

    Data Types: string

    Name of the Amazon S3 bucket for storing artifacts when ArtifactServiceMode is "s3", specified as a string.

    Pipeline Generator Version 1 does not support this property.

    Example: "my-artifacts-bucket"

    Data Types: string

    AWS access key ID for storing artifacts in an Amazon S3 bucket when ArtifactServiceMode is "s3", specified as a string.

    Pipeline Generator Version 1 does not support this property.

    Example: "AKIAIOSFODNN7EXAMPLE"

    Data Types: string

    Name of Azure Blob Storage container for storing artifacts when ArtifactServiceMode is "azure_blob", specified as a string.

    You can only specify a single container name, not multiple container names.

    Pipeline Generator Version 1 does not support this property.

    Example: "mycontainer"

    Data Types: string

    Execution environment of runner, specified as either:

    • "default" — Runs tasks directly on the host machine without containerization.

    • "container" — Runs tasks inside a containerized environment, such as a Docker® container. Specify the container by using the ImageTag property.

    Pipeline Generator Version 1 does not support this property.

    Full name of the container image that the generated pipeline uses when RunnerType is "container", specified as a string.

    The image must be an OCI-compliant image, such as a Docker image.

    Pipeline Generator Version 1 does not support this property.

    Example: "mycompany/pipeline-runner:latest"

    Data Types: string

    Branches to check for cached build artifacts, specified as a string.

    To support incremental builds, the pipeline generator attempts to restore the cache from the last successful run on the same branch. If no cache is available, the pipeline checks for cached build artifacts on the branches that you specify. By default, the fallback branch is main, but you can specify multiple fallback branches and the pipeline checks each one in order. If the pipeline generator does not find a cache on the specified branches, the pipeline runs a full build, executing each task in the process without skipping tasks. For more information, see How Pipeline Generation Works.

    Pipeline Generator Version 1 does not support this property.

    Example: ["develop"]

    Example: ["main","develop"]

    Data Types: string

    Examples

    collapse all

    This example code shows how to generate a GitLab pipeline file in MATLAB using Pipeline Generator Version 1. However, typically, you configure your options object and call the pipeline generator from inside a GitLab CI pipeline file. For a complete example, see Integrate Process into GitLab.

    Note

    Pipeline Generator Version 1 is provided for compatibility with the original pipeline generator functionality. Pipeline Generator Version 2 is recommended for enhanced file propagation and artifact management, but requires you to update your setup and workflow.

    Load a project. For this example, you can load a Process Advisor example project.

    processAdvisorExampleStart

    Represent your pipeline generator options by creating a padv.pipeline.GitLabOptions object for pipeline generator version 1.

    op = padv.pipeline.GitLabOptions(GeneratorVersion=1);

    Specify the tag for your GitLab Runner.

    op.Tags = "my_gitlab_runner";

    Generate a pipeline file.

    padv.pipeline.generatePipeline(op)
    The pipeline generator generates a GitLab CI pipeline file, simulink_pipeline.yml, for the current project, process model, and pipeline generator options.

    This example code shows how to configure and generate a GitLab pipeline file using Pipeline Generator Version 2 and network artifact storage. For the complete example, see Process Integration and Artifact Management for GitLab.

    Inside your generate_gitlab_pipeline.m file, you can use a shared network location for your artifacts by specifying the NetworkStoragePath property. For this example, suppose you have a shared network location /artifactManagement/cacheStorage.

    % Copyright 2025 The MathWorks, Inc.

function generate_gitlab_pipeline()
    workspace = string(getenv('CI_PROJECT_DIR'));
    supportPackageRoot = string(getenv('MW_SUPPORT_PACKAGE_ROOT'));
    relativeProjectPath = string(getenv('MW_RELATIVE_PROJECT_PATH'));
    remoteBuildCacheName = string(getenv('MW_REMOTE_BUILD_CACHE_NAME'));
    pipelineGenDirectory = string(getenv('MW_PIPELINE_GEN_DIRECTORY'));

    cp = openProject(strcat(workspace,filesep,string(relativeProjectPath)));
    op = padv.pipeline.GitLabOptions;
    op.Tags = "my_gitlab_runner";
    op.PipelineArchitecture = "SerialStagesGroupPerTask";
    op.GeneratorVersion = 2;
    op.SupportPackageRoot = supportPackageRoot;
    op.GeneratedPipelineDirectory = pipelineGenDirectory;
    op.StopOnStageFailure = true;
    op.RunprocessCommandOptions.GenerateJUnitForProcess = true;
    op.ReportPath = "$PROJECTROOT$/PA_Results/Report/ProcessAdvisorReport";
    op.RelativeProjectPath = relativeProjectPath;
    op.RemoteBuildCacheName = remoteBuildCacheName;

    op.ArtifactServiceMode = "network";
    op.NetworkStoragePath = "/artifactManagement/cacheStorage";
    padv.pipeline.generatePipeline(op, "CIPipeline");
end
    Note that this example code uses an example GitLab Runner tag of "my_gitlab_runner".

    This example code shows how to configure and generate a GitLab pipeline file using Pipeline Generator Version 2 and JFrog Artifactory. For the complete example, see Process Integration and Artifact Management for GitLab.

    Inside your generate_gitlab_pipeline.m file, you can use a JFrog Artifactory repository for your artifacts by specifying the ArtifactServiceMode property as "jfrog" and specifying the properties ArtifactoryUrl and ArtifactoryRepoName.

    % Copyright 2025 The MathWorks, Inc.

function generate_gitlab_pipeline()
    workspace = string(getenv('CI_PROJECT_DIR'));
    supportPackageRoot = string(getenv('MW_SUPPORT_PACKAGE_ROOT'));
    relativeProjectPath = string(getenv('MW_RELATIVE_PROJECT_PATH'));
    remoteBuildCacheName = string(getenv('MW_REMOTE_BUILD_CACHE_NAME'));
    pipelineGenDirectory = string(getenv('MW_PIPELINE_GEN_DIRECTORY'));

    cp = openProject(strcat(workspace,filesep,string(relativeProjectPath)));
    op = padv.pipeline.GitLabOptions;
    op.Tags = "my_gitlab_runner";
    op.PipelineArchitecture = "SerialStagesGroupPerTask";
    op.GeneratorVersion = 2;
    op.SupportPackageRoot = supportPackageRoot;
    op.GeneratedPipelineDirectory = pipelineGenDirectory;
    op.StopOnStageFailure = true;
    op.RunprocessCommandOptions.GenerateJUnitForProcess = true;
    op.ReportPath = "$PROJECTROOT$/PA_Results/Report/ProcessAdvisorReport";
    op.RelativeProjectPath = relativeProjectPath;
    op.RemoteBuildCacheName = remoteBuildCacheName;

    op.ArtifactServiceMode = "jfrog";
    op.ArtifactoryUrl = "http://localhost:8082/artifactory";
    op.ArtifactoryRepoName = "example-repo-local";
    padv.pipeline.generatePipeline(op, "CIPipeline");
end
    Note that this example code uses an example GitLab Runner tag of "my_gitlab_runner".

    This example code shows how to configure and generate a GitLab pipeline file using Pipeline Generator Version 2 and Amazon S3 storage. For the complete example, see Process Integration and Artifact Management for GitLab.

    Inside your generate_gitlab_pipeline.m file, you can use Amazon S3 storage for your artifacts by specifying the ArtifactServiceMode property as "s3" and specifying the properties S3BucketName and S3AwsAccessKeyID.

    % Copyright 2025 The MathWorks, Inc.

function generate_gitlab_pipeline()
    workspace = string(getenv('CI_PROJECT_DIR'));
    supportPackageRoot = string(getenv('MW_SUPPORT_PACKAGE_ROOT'));
    relativeProjectPath = string(getenv('MW_RELATIVE_PROJECT_PATH'));
    remoteBuildCacheName = string(getenv('MW_REMOTE_BUILD_CACHE_NAME'));
    pipelineGenDirectory = string(getenv('MW_PIPELINE_GEN_DIRECTORY'));

    cp = openProject(strcat(workspace,filesep,string(relativeProjectPath)));
    op = padv.pipeline.GitLabOptions;
    op.Tags = "my_gitlab_runner";
    op.PipelineArchitecture = "SerialStagesGroupPerTask";
    op.GeneratorVersion = 2;
    op.SupportPackageRoot = supportPackageRoot;
    op.GeneratedPipelineDirectory = pipelineGenDirectory;
    op.StopOnStageFailure = true;
    op.RunprocessCommandOptions.GenerateJUnitForProcess = true;
    op.ReportPath = "$PROJECTROOT$/PA_Results/Report/ProcessAdvisorReport";
    op.RelativeProjectPath = relativeProjectPath;
    op.RemoteBuildCacheName = remoteBuildCacheName;

    op.ArtifactServiceMode = "s3";
    op.S3BucketName = "my-artifacts-bucket";
    op.S3AwsAccessKeyID = "AKIAIOSFODNN7EXAMPLE";
    padv.pipeline.generatePipeline(op, "CIPipeline");
end
    Note that this example code uses an example GitLab Runner tag of "my_gitlab_runner".

    This example code shows how to configure and generate a GitLab pipeline file using Pipeline Generator Version 2 and Azure Blob Storage. For the complete example, see Process Integration and Artifact Management for GitLab.

    Inside your generate_gitlab_pipeline.m file, you can use Azure Blob Storage for your artifacts by specifying the ArtifactServiceMode property as "azure_blob" and specifying the property AzContainerName.

    % Copyright 2025 The MathWorks, Inc.

function generate_gitlab_pipeline()
    workspace = string(getenv('CI_PROJECT_DIR'));
    supportPackageRoot = string(getenv('MW_SUPPORT_PACKAGE_ROOT'));
    relativeProjectPath = string(getenv('MW_RELATIVE_PROJECT_PATH'));
    remoteBuildCacheName = string(getenv('MW_REMOTE_BUILD_CACHE_NAME'));
    pipelineGenDirectory = string(getenv('MW_PIPELINE_GEN_DIRECTORY'));

    cp = openProject(strcat(workspace,filesep,string(relativeProjectPath)));
    op = padv.pipeline.GitLabOptions;
    op.Tags = "my_gitlab_runner";
    op.PipelineArchitecture = "SerialStagesGroupPerTask";
    op.GeneratorVersion = 2;
    op.SupportPackageRoot = supportPackageRoot;
    op.GeneratedPipelineDirectory = pipelineGenDirectory;
    op.StopOnStageFailure = true;
    op.RunprocessCommandOptions.GenerateJUnitForProcess = true;
    op.ReportPath = "$PROJECTROOT$/PA_Results/Report/ProcessAdvisorReport";
    op.RelativeProjectPath = relativeProjectPath;
    op.RemoteBuildCacheName = remoteBuildCacheName;

    op.ArtifactServiceMode = "azure_blob";
    op.AzContainerName = "mycontainer";
    padv.pipeline.generatePipeline(op, "CIPipeline");
end
    Note that this example code uses an example GitLab Runner tag of "my_gitlab_runner".

    Version History

    expand all

    See Also

    Topics