Spring Application Advisor

https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/
Admin
Spring Application Advisor is a VMware Tanzu tool that helps developers analyze and optimize Spring...
Tokens:19,857
Snippets:131
Trust Score:9.9
Update:11 months ago
Show doc for...
Tokens:
Raw
### Install Java 17 with SDKMAN and run Maven tests

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-upgrade-boot

Installs Java 17 via SDKMAN, activates it, and executes the Maven wrapper test suite. Run this after updating pom.xml to confirm the build succeeds under Java 17.

```Bash
sdk install java 17.0.13-tem
sdk use java 17.0.13-tem
./mvnw test
```

--------------------------------

### Install Java 11 with SDKMAN and run Maven tests

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-upgrade-boot

Installs Java 11 using SDKMAN, sets it as the active version, and runs the Maven wrapper tests. Useful for verifying that the project builds correctly after upgrading dependencies to Java 11.

```Bash
sdk install java 11.0.25-tem
sdk use java 11.0.25-tem
./mvnw test
```

--------------------------------

### Spring Application Advisor CLI Commands

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/other-saas-ci-cd-tools

Basic CLI commands for Spring Application Advisor to get build configuration and apply upgrade plans. These commands are intended for script execution within a CI/CD pipeline.

```shell
# ...download and extract the advisor CLI...
export GIT_TOKEN_FOR_PRS = **WRITE_GIT_ACCESS_TOKEN**

advisor build-config get
advisor upgrade-plan apply --push --from-yml
```

--------------------------------

### Install GitLab Runner on Ubuntu VM

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/integrate-gitlab

Navigate to the home directory and install the GitLab Runner package on an Ubuntu-based VM in GKE using curl to fetch the installation script and apt-get for the package. Requires sudo privileges and internet access. This sets up the runner utility for custom executors.

```bash
cd /home/
curl -L "https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh" | sudo bash
sudo apt-get install gitlab-runner
```

--------------------------------

### Create custom-upgrades-mappings.json for Shared Libraries

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/custom-upgrades

Example JSON configuration for defining upgrade plans for shared libraries. Includes required and optional properties such as rewriteArtifacts, initRecipes, and projects with their respective requirements.

```json
{
  "rewriteArtifacts": [
      {
        "coordinates": "com.acme.recipes:acme-spring-recipes:5.22.0",
        "minimalJavaVersion": "8"
      }
   ],
  "initRecipes": [
       {
         "name": "my.first.custom.Recipe"
       },
       {
         "name": "my.second.custom.Recipe",
         "params": {
           "foo": "bar"
         }
       }
  ],
  "projects": [
    {
      "slug": "project-name",
      "coordinates": [
        "com.acme.project:project-module1",
        "com.acme.project:project-module2",
        ...
      ],
      "repositoryUrl": "https://github.com/acme/project-name",
      "rewrite": {
        "1.0.x": {
          "recipes": [
            {
              "name": "com.acme.recipes.project.UpgradeProject2_0"
              "params": {
                  "foo": "bar"
              }
            }
          ],
          "requirements": {
            "supportedJavaVersions": {
              "major": 21,
              "minor": 17
            }
            "supportedGenerations": {
              "spring-boot": "3.0.x",
              "spring-security": "6.0.x",
              "spring-security-rsa": "1.0.x",
              "spring-integration": "6.0.x",
              "spring-retry": "2.0.x"
            }
          },
          "nextRewrite": {
            "version": "2.0.x"
          }
        },
        "2.0.x": {
          "recipes": [],
          "requirements": {
            "supportedJavaVersions": {
              "major": 21,
              "minor": 17
            },
            "supportedGenerations": {
              "spring-boot": "3.2.x",
              "spring-security": "6.2.x",
              "spring-security-rsa": "1.1.x",
              "spring-integration": "6.2.x",
              "spring-retry": "2.0.x"
            }
            "excludedArtifacts": [
              "com.acme.project:project-module2"
            ]
          },
          "nextRewrite": null
        }
      }
    }
  ]
}
```

--------------------------------

### Publishing Build Configuration to Tanzu Hub (Shell)

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/portfolio-analysis-with-tanzu-platform

Publishes the dependencies and SBOM from a local Git repository to Tanzu Hub for analysis. Use from the repository root after setting environment variables. Inputs: Local build config; Outputs: Data sent to Tanzu Hub for viewing support status and vulnerabilities. Supports two alternative commands; choose based on your setup.

```shell
advisor build-config publish
```

```shell
cf repo publish-sbom
```

--------------------------------

### Build Upgrade Mapping with Application Advisor CLI

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

This command-line tool generates an upgrade mapping file based on a Git repository, calculating dependencies, Java version requirements, and submodules. This file guides Application Advisor in suggesting upgrade paths.  Requires the Application Advisor CLI. The `--offline` flag is recommended to ensure consistent version selection.

```bash
advisor mapping build -r https://github.com/Broadcom/acme-boot-starter --offline
```

--------------------------------

### Automate upgrade mappings update with Bash and jq

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/upgrade-from-1

This Bash script automates the update of custom upgrade mappings from Application Advisor 1.3.x to 1.4.x. It requires the `jq` tool to be installed on a Linux machine. The script processes all JSON files in a specified directory, updating the `nextRewrite` field structure.

```bash
#!/bin/bash

set -euo pipefail

function main () {
  if [ -z "$1" ]; then
    echo "Usage: $0 <directory-with-mappings>"
    exit 1
  fi

  DIRECTORY="$1"

  if [ ! -d "$DIRECTORY" ]; then
    echo "Error: the folder $DIRECTORY doesn't exist"
    exit 1
  fi

  FIELD="nextRewrite"

  for file in "$DIRECTORY"/*.json; do
    echo "Processing $file..."

    jq --arg key "$FIELD" '
      .projects |= map(
        .rewrite |= with_entries(
          if(.value.nextRewrite | type == "string") then
            .value.nextRewrite = {
              version: .value.nextRewrite
            }
          else
            .
          end
        )
      )
    ' "$file" > "${file}.tmp"

    cp "$file" "${file}.bak"
    mv "${file}.tmp" "$file"
  done

  echo "Process finished. Each original mapping has been moved to a backup file."
}

main "$@"
```

--------------------------------

### Configure Jenkins Pipeline with Application Advisor CLI

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/integrate-jenkins

This Jenkins Declarative Pipeline configuration demonstrates how to integrate Spring Application Advisor CLI commands into a CI/CD pipeline. It sets up environment credentials for Git operations and executes two key advisor commands: 'build-config get' for configuration analysis and 'upgrade-plan apply' for automated upgrades with pull request generation. The example assumes CloudBees Pipeline Templates are being used and requires proper Maven settings.xml configuration for Spring commercial repository access.

```groovy
pipeline {
    agent any

    environment {
    GIT_TOKEN_FOR_PRS = credentials('advisor_git_token_for_prs')
    }
    stages {
        stage(my-stage) {
            steps {
                …
            }
        }
        …
        stage('spring-app-advisor') {
            steps {
                sh 'advisor build-config get'
                sh 'advisor upgrade-plan apply --push --from-yml --token=$GIT_TOKEN_FOR_PRS
            }
        }
}
}
```

--------------------------------

### Handling Self-Signed Certificates for Tanzu Hub (Bash)

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/portfolio-analysis-with-tanzu-platform

Configures a custom TrustStore for environments with self-signed HTTPS certificates to allow Application Advisor to connect without validation errors. Involves extracting the certificate using OpenSSL, importing it with keytool, and running the publish command with JVM arguments. Dependencies: OpenSSL and keytool (Java JDK); Inputs: Server details; Outputs: Updated TrustStore for secure connection. Limitations: Manual process; use only for testing self-signed setups.

```bash
openssl s_client -showcerts -connect selfsigned.platform.com:443 </dev/null 2>/dev/null | openssl x509 -outform PEM > server-cert.pem

keytool -import -trustcacerts -keystore myTrustStore.jks -storepass changeit -file server-cert.pem -alias myserver

advisor build-config publish \
  -Djavax.net.ssl.trustStore=myTrustStore.jks \
  -Djavax.net.ssl.trustStorePassword=changeit
```

--------------------------------

### Bitbucket Integration Script for Application Advisor

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/integrate-bitbucket

This script automates the integration of Application Advisor with Bitbucket by fetching build config, applying upgrade plans, and creating a branch with a pull request if changes exist. It requires environment variables for Bitbucket host, project, slug, and access token. The script uses Git commands and Bitbucket REST API; limitations include manual setup for on-premise Bitbucket and compatibility with API version 2.0.

```bash
#!/bin/bash

export BB_HOST="bitbucket.org"
export PROJECT="REPLACE_ACME_PROJECT"
export SLUG="REPLACE_ACME_REPO"
export ACCESS_TOKEN="REPLACE_ACCESS_TOKEN"

advisor build-config get
advisor upgrade-plan apply
if [ $(git status --porcelain | wc -l) -eq "0" ]; then
  echo " Git repo is clean."
else
  if [ `git branch --list advisor` ]
  then
    echo "Pending changes to upgrade"
  else
    git checkout -b advisor
    git add .
    git commit -m "[Application Advisor] Spring upgrade"
    git push --set-upstream origin advisor
    curl -X POST -H "Content-Type: application/json" -H "Authorization: Bearer $ACCESS_TOKEN" -H 'Content-Type: application/json' https://api.bitbucket.org/2.0/repositories/$PROJECT/$SLUG/pullrequests -d '{"title": "advisor upgrade" , "source": { "branch": { "name": "advisor" }}}'
  fi
fi
```

--------------------------------

### Start GitLab Runner Instance

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/integrate-gitlab

Launch the registered GitLab runner by name to make it available for processing CI/CD jobs in the instance. Replace NAME-OF-THE-RUNNER with the configured runner name. This runs the runner service persistently.

```bash
sudo gitlab-runner run NAME-OF-THE-RUNNER
```

--------------------------------

### Maven Settings Configuration for Repository Mirroring

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/troubleshooting

This XML configuration shows how to set up Maven mirrors to simultaneously proxy Maven Central and a specific Spring Enterprise repository. It includes definitions for mirrors, active profiles, repositories, and server credentials for authentication. This is useful when dealing with custom repository setups or network restrictions.

```xml
<settings>
  <mirrors>
    <mirror>
      <id>internal-repository</id>
      <name>Maven Repository Manager running on repo.mycompany.com</name>
      <url>http://repo.mycompany.com/proxy</url>
      <mirrorOf>*,!spring-enterprise-subscription</mirrorOf>
    </mirror>
    <mirror>
      <id>mirror-spring-enterprise</id>
      <name>Mirror for Spring Enterprise</name>
      <url>http://repo.mycompany.com/spring-enterprise-repo</url>
      <mirrorOf>spring-enterprise-subscription</mirrorOf>
    </mirror>
  </mirrors>
  <activeProfiles>
      <activeProfile>org-profile</activeProfile>
  </activeProfiles>
  <profiles>
    <profile>
        <id>org-profile</id>
        <repositories>
          <repository>
            <id>spring-enterprise-subscription</id>
            <url>https://packages.broadcom.com/artifactory/spring-enterprise</url>
          </repository>
          <repository>
            <id>central</id>
            <url>http://central</url>
            <releases>
              <enabled>true</enabled>
            </releases>
            <snapshots>
              <enabled>true</enabled>
            </snapshots>
          </repository>
        </repositories>
    </profile>
  </profiles>
  <servers>
    <server>
      <id>mirror-spring-enterprise</id>
      <username>USERNAME</username>
      <password>PWD<password>
    </server>
    <server>
      <id>internal-repository</id>
      <username>USERNAME</username>
      <password>PWD<password>
    </server>
    <server>
      <id>spring-enterprise-subscription</id>
      <username>USERNAME</username>
      <password>PWD<password>
    </server>
  </servers>
</settings>
```

--------------------------------

### Run Advisor CLI to apply upgrade plan

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-upgrade-boot

Executes Advisor CLI commands to retrieve the current build configuration and apply the recommended upgrade plan. This automates migration steps for Spring Boot and other components.

```Bash
advisor build-config get && advisor upgrade-plan apply
```

--------------------------------

### Run Application Advisor (Shell)

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

Runs the Application Advisor commands to retrieve build configuration and upgrade plan information. Demonstrates how Application Advisor identifies dependencies and handles custom starters.

```shell
advisor build-config get

```

```shell
advisor upgrade-plan get

```

--------------------------------

### Clone Repositories (Shell)

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

Clones the `acme-bookings-app` and `acme-boot-starter` repositories from GitHub to the local machine. This prepares the project for upgrades and testing.

```shell
git clone https://github.com/Broadcom/acme-bookings-app

```

```shell
git clone https://github.com/Broadcom/acme-boot-starter

```

--------------------------------

### Copy Command for Advisor Mappings

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

This command copies a custom Application Advisor mapping file to a location where it will be loaded. This is a standard shell command used to manage configuration files for the advisor tool.

```bash
cp .advisor/mappings/acme-boot-starter.json /demo/acme-mappings.json
```

--------------------------------

### Configure GitLab Runner config.toml

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/integrate-gitlab

Edit the /etc/gitlab-runner/config.toml file to define a custom executor that invokes the advisor_exec.sh script during builds. Specifies concurrent jobs, session timeout, runner name, URL, token, directories, and cache settings. The token and CA file are from GitLab setup.

```toml
concurrent = 1
check_interval = 0
shutdown_timeout = 0

[session_server]
session_timeout = 1800

[[runners]]
name = "instance-for-gitlab-runner"
url = "https://gitlab.acme.com"
token = "" # From GitLab Runner Instance config
tls-ca-file = "gitlab.acme.com.crt"
executor = "custom"
builds_dir = "/home/gitlab/builds"
cache_dir = "/home/gitlab/cache"
[runners.cache]
    MaxUploadedArchiveSize = 0
[runners.custom]
    run_exec = "/home/gitlab/advisor_exec.sh"
```

--------------------------------

### Advisor CLI Commands for Upgrade Plan

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

These commands interact with the Application Advisor command-line interface to build configuration and retrieve an upgrade plan. They are essential for analyzing and planning application upgrades.

```bash
advisor build-config get
advisor upgrade plan get
```

--------------------------------

### Commit changes after upgrading from Java 11 to 17

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-upgrade-boot

Stages all changes and commits them with a message describing the upgrade from Java 11 to Java 17. Run after confirming the Java 17 build passes.

```Bash
git add .
git commit -m "Upgrade java from 11 to 17"
```

--------------------------------

### GitHub Actions Workflow for Spring App Advisor

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/other-saas-ci-cd-tools

A GitHub Actions workflow to automate the execution of Spring Application Advisor. It checks out code, sets up Java, configures Maven settings, and runs the advisor CLI to check configurations and apply upgrade plans.

```yaml
name: Spring App Advisor Workflow

on:
  schedule:
  - cron: "0 2 * * 1-5"
  push:
    branches: [ "main" ]

jobs:
  build:

    runs-on: ubuntu-latest
    permissions:
      contents: read

    steps:
    - uses: actions/checkout@v4
    - name: Set up JDK
      uses: actions/setup-java@v4
      with:
        java-version: '17'
        distribution: 'temurin'
    - name: Generates Maven Settings
      uses: 's4u/maven-settings-action@v3.1.0'
      with:
        servers: '[{"id": "tanzu-spring-release", "username":  "${{ secrets.BC_USER }}", "password": "${{ secrets.$BC_PWD }}"}]'
        repositories: '[{"id":"tanzu-spring-release", "name":"Spring Enterprise Supported Releases","url":"https://packages.broadcom.com/artifactory/spring-enterprise","snapshots":{"enabled":false}}]'
        pluginRepositories: '[{"id":"tanzu-spring-release", "name":"Spring Enterprise Supported Releases","url":"https://packages.broadcom.com/artifactory/spring-enterprise","snapshots":{"enabled":false}}]'
    - name: Runs Application Advisor
      continue-on-error: true
      env:
       GIT_TOKEN_FOR_PRS: ${{ secrets.advisor_git_token_for_prs }}
       ARTIFACTORY_TOKEN: ${{ secrets.advisor_artifactory_token }}
      run: |
        curl -L -H "Authorization: Bearer $ARTIFACTORY_TOKEN"  -o advisor-linux.tar -X GET https://packages.broadcom.com/artifactory/spring-enterprise/com/vmware/tanzu/spring/application-advisor-cli-linux/1.5.1/application-advisor-cli-linux-1.5.1.tar
        tar -xf advisor-linux.tar --strip-components=1 --exclude=./META-INF
        ./advisor build-config get
        ./advisor upgrade-plan apply --push --from-yml --token=$GIT_TOKEN_FOR_PRS
    - name: Get errors if exist
      if: always() && hashFiles('.advisor/errors/') != ''
      run: |
        cat .advisor/errors/*

```

--------------------------------

### Build Artifacts (Maven)

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

Builds the artifacts for different versions of the `acme-boot-starter` using Maven.  This makes them available for resolving dependencies when building `acme-bookings-app`.

```shell
git checkout 1.0.0
./mvnw install

```

```shell
git checkout 2.0.0
./mvnw install

```

--------------------------------

### Apply Upgrade Plan Changes

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

This command applies the upgrade plan generated by the Application Advisor and generates a diff to display the changes. This diff can be reviewed and applied to manually update the application's dependencies. Requires Application Advisor CLI and git.

```bash
advisor upgrade-plan apply
git diff
```

--------------------------------

### Configure Application Advisor MCP Server

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/model-context-protocol-server

Configures the Application Advisor MCP server for IDE integration. Uses bash command 'advisor mcp' with stdio transport. Required for connecting MCP clients to Application Advisor for upgrade plans and best practices advice.

```JSON
{
  "mcpServers": {
    "advisor-mcp-server": {
      "command": "bash",
      "args": ["-c", "advisor mcp"],
      "transportType": "stdio"
    }
  }
}
```

--------------------------------

### Commit changes after upgrading from Java 8 to 11

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-upgrade-boot

Stages all modified files and creates a Git commit documenting the upgrade from Java 8 to Java 11. Use after successful verification of the build.

```Bash
git add .
git commit -m "Upgrade java from 8 to 11"
```

--------------------------------

### Configuring Proxy for Tanzu Hub Connection (Shell with Java Args)

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/portfolio-analysis-with-tanzu-platform

Adds Java system properties to the Application Advisor command to route traffic through an HTTP/HTTPS proxy. Useful for environments requiring proxy access to Tanzu Hub. Inputs: Proxy host, port, and non-proxy hosts; Outputs: Proxied connection for publishing data. Dependencies: Java runtime; Limitations: Follows standard Java proxy settings; refer to Java docs for advanced configurations.

```shell
     -Dhttp.proxyHost=proxy.example.com \
     -Dhttp.proxyPort=8080 \
     -Dhttps.proxyHost=proxy.example.com \
     -Dhttps.proxyPort=8080 \
     -Dhttp.nonProxyHosts="localhost|127.0.0.1|*.internal.com"
```

--------------------------------

### Export Custom Mapping File

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

This command exports a JSON mapping file and sets an environment variable to make it available to the Application Advisor. This allows the Application Advisor to use the custom mapping for upgrade planning. The mapping file contains information about how to upgrade dependencies.

```bash
cp .advisor/mappings/acme-boot-starter.json /demo/acme-mappings.json
```

```bash
export SPRING_ADVISOR_MAPPING_CUSTOM_0_FILEPATH=/demo/acme-mappings.json
```

--------------------------------

### Application Advisor Upgrade Plan Output

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

This output represents the result of an Application Advisor upgrade plan. It details the steps required to upgrade dependencies, such as 'acme-boot-starter', 'spring-framework', and 'spring-boot', to specific versions. It highlights the advisor's ability to consolidate multiple minor version upgrades into a single step.

```text
🏃 Fetching and processing upgrade plan details [00m 01s] ok
 - Step 1:
    * Upgrade acme-boot-starter from 2.0.x to 3.0.x
    * Upgrade spring-framework from 6.0.x to 6.2.x
    * Upgrade spring-boot from 3.0.x to 3.5.x
```

--------------------------------

### Create Build and Cache Directories

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/integrate-gitlab

Create dedicated directories for GitLab builds and cache on the VM and set broad read/write/execute permissions (777). This ensures the runner can access and store project files during execution. Requires sudo access.

```bash
sudo mkdir /home/gitlab/builds
sudo chmod -R 777 /home/gitlab/builds

sudo mkdir /home/gitlab/cache
sudo chmod -R 777 /home/gitlab/cache
```

--------------------------------

### View Git Diff for OwnerController.java

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-upgrade-boot

Displays the changes made to the OwnerController.java file using `git diff`. This shows modifications such as replacing `javax.validation` with `jakarta.validation` and adjusting GET/POST mappings to handle trailing slashes.

```shell
git diff src/main/java/org/springframework/samples/petclinic/owner/OwnerController.java
```

--------------------------------

### Upload Advisor Script and Binary to VM

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/integrate-gitlab

Transfer the advisor_exec.sh script and advisor CLI binary from local directory to the GKE VM using gcloud compute scp. Requires gcloud CLI configured for project 'app-advisor' and zone 'us-central1-a'. Place files in /home/gitlab/ for runner access.

```bash
gcloud compute scp LOCAL-DIRECTORY/advisor_exec.sh root@"MACHINE-NAME":/home/gitlab --zone "us-central1-a" --project "app-advisor"
gcloud compute scp LOCAL-DIRECTORY/advisor root@"MACHINE-NAME":/home/gitlab --zone "us-central1-a" --project "app-advisor"
```

--------------------------------

### OwnerController Java Code Modifications

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-upgrade-boot

Illustrates code changes within the OwnerController.java file. Key changes include updating import statements from `javax.validation` to `jakarta.validation` and modifying controller mappings to accept paths with or without trailing slashes.

```java
package org.springframework.samples.petclinic.owner;

import java.util.List;
import java.util.Map;
import jakarta.validation.Valid;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;

/**
 * @author Juergen Hoeller
 * @author Mark Fisher
 * @author Ken Krebs
 * @author Mitchell Bailey
 * @author Sam Bright
 */
@Controller
class OwnerController {

       private static final String VIEWS_OWNER_CREATE_OR_UPDATE_FORM = "owners/createOrUpdateOwnerForm";
       private final OwnerRepository owners;

       public OwnerController(OwnerRepository owners) {
               this.owners = owners;
       }

       @InitBinder
       public void setAllowedFields(WebDataBinder dataBinder) {
               dataBinder.setDisallowedFields("id");
       }

       @GetMapping("/owners/find")
       public String findOwner(Map<String, Object> model) {
               model.put("owner", new Owner());
               return "owners/findOwners";
       }

       @GetMapping("/owners/" + "{ownerId}")
       public String showOwner(@PathVariable int ownerId, Map<String, Object> model) {
               Owner owner = this.owners.findById(ownerId);
               model.put("owner", owner);
               return "owners/ownerDetails";
       }

       @GetMapping("/owners")
       public String findOwners(Owner owner, BindingResult result, Pageable pageable, Map<String, Object> model) {

               // inbox 
               // TODO Auto-generated method stub
               if (owner.getLastName() == null) {
                       owner.setLastName(""); // empty string signifies broadest possible search
               }
               Page<Owner> ownerss = findPaginatedForOwners(owner, pageable);
               if (ownerss.hasContent()) {
                       return "owners/ownerList";
               }
               //

               // like /owners?ln=ls 
               List<Owner> results = this.owners.findByLastName(owner.getLastName());
               model.put("selections", results);
               return "owners/ownerList";
       }

       private Page<Owner> findPaginatedForOwners(Owner owner, Pageable pageable) {
               String lastName = owner.getLastName();
               // TODO Auto-generated method stub
               return owners.findByLastName(lastName, pageable);
       }

       @GetMapping({"/owners/new", "/owners/new/"})
       public String initCreationForm(Map<String, Object> model) {
               Owner owner = new Owner();
               model.put("owner", owner);
               return VIEWS_OWNER_CREATE_OR_UPDATE_FORM;
       }

       @PostMapping({"/owners/new", "/owners/new/"})
       public String processCreationForm(@Valid Owner owner, BindingResult result) {
               if (result.hasErrors()) {
                       return VIEWS_OWNER_CREATE_OR_UPDATE_FORM;
               }
               else {
                       this.owners.save(owner);
                       return "redirect:/owners/" + owner.getId();
               }
       }

       @GetMapping({"/owners/{ownerId}/edit", "/owners/{ownerId}/edit/"})
       public String initUpdateOwnerForm(@PathVariable("ownerId") int ownerId, Map<String, Object> model) {
               Owner owner = this.owners.findById(ownerId);
               model.put("owner", owner);
               return VIEWS_OWNER_CREATE_OR_UPDATE_FORM;
       }

       @PostMapping({"/owners/{ownerId}/edit", "/owners/{ownerId}/edit/"})
       public String processUpdateOwnerForm(@Valid Owner owner, BindingResult result, @PathVariable("ownerId") int ownerId) {
               if (result.hasErrors()) {
                       return VIEWS_OWNER_CREATE_OR_UPDATE_FORM;
               }
               else {
                       owner.setId(ownerId);
                       this.owners.save(owner);
                       return "redirect:/owners/" + ownerId;
               }
       }

}

```

--------------------------------

### Configure MCP Server with Environment Variables

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/model-context-protocol-server

Extends the basic MCP configuration to include environment variables. Solves the limitation where MCP servers don't inherit host environment variables. Essential for projects requiring private Artifactory access or other environment-specific configurations.

```JSON
{
  "mcpServers": {
    "advisor-mcp-server": {
      "command": "bash",
      "args": ["-c", "advisor mcp"],
      "transportType": "stdio",
      "env": {
        "ARTIFACTORY_REPOSITORY_URL": "https://my-private.artifactory.com"
      }
    }
  }
}
```

--------------------------------

### Dependency in pom.xml (XML)

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

Shows a sample dependency declaration in the `pom.xml` file of the `acme-bookings-app` project. It specifies that the application depends on `acme-boot-starter` version 1.0.0.

```xml
<dependency>
    <groupId>com.acme.boot</groupId>
    <artifactId>acme-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

```

--------------------------------

### Application Properties Configuration

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

This snippet demonstrates adding a logging pattern for date format in an `application.properties` file. This is crucial for consistent log output in Spring Boot applications.

```properties
logging.pattern.dateformat=yyyy-MM-dd HH:mm:ss.SSS
spring.application.name=acme-bookings-app
```

--------------------------------

### Package Application (Maven)

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

Packages the `acme-bookings-app` application using Maven. This verifies that the dependency on `acme-boot-starter` can be resolved.

```shell
./mvnw package

```

--------------------------------

### Custom Advisor Mapping Configuration (JSON)

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/how-to-guides-custom-boot-starter

This JSON configuration defines custom mappings for the Spring Application Advisor. It specifies coordinates, repository URLs, and rewrite rules for different versions of 'acme-boot-starter', including supported Java and Spring Boot versions. This allows for fine-grained control over upgrade paths.

```json
{
  "slug" : "acme-boot-starter",
  "coordinates" : [
    "com.acme.boot:acme-boot-starter"
  ],
  "repositoryUrl" : "https://github.gwd.broadcom.net/TNZ/acme-boot-starter",
  "rewrite" : {
    "1.0.x" : {
      "recipes" : [ ],
      "nextRewrite": {
        "version": "2.0.x"
      },
      "requirements" : {
        "supportedJavaVersions" : {
          "major" : 11,
          "minor" : 11
        },
        "supportedGenerations" : {
          "spring-boot" : "2.7.x"
        },
        "excludedArtifacts" : [ ]
      }
    },
    "2.0.x" : {
      "recipes" : [ ],
      "nextRewrite" : {
        "version": "3.0.x"
      },
      "requirements" : {
        "supportedJavaVersions" : {
          "major" : 17,
          "minor" : 17
        },
        "supportedGenerations" : {
          "spring-boot" : "3.0.x"
        },
        "excludedArtifacts" : [ ]
      }
    },
    "3.0.x" : {
     "recipes" : [ ],
     "nextRewrite" : null,
     "requirements" : {
       "supportedJavaVersions" : {
         "major" : 17,
         "minor" : 17
       },
       "supportedGenerations" : {
         "spring-boot" : "3.5.x"
       },
       "excludedArtifacts" : [ ]
     }
    }
  }
}
```

--------------------------------

### Setting Tanzu Hub Environment Variables (Bash)

Source: https://techdocs.broadcom.com/us/en/vmware-tanzu/spring/spring-application-advisor/1-5/spring-app-advisor/portfolio-analysis-with-tanzu-platform

Exports environment variables required to connect Application Advisor to Tanzu Hub. These variables include the platform URL, OAuth credentials, connection ID, and organization ID obtained from the Tanzu Hub UI. No additional dependencies are needed; set them before running advisor commands. Limitations: Variables must be unique and correctly formatted to avoid authentication failures.

```bash
export TANZU_PLATFORM_URL=https://tanzu.acme.com
export TANZU_PLATFORM_OAUTH_APP_ID=<YOUR_APP_KEY>
export TANZU_PLATFORM_OAUTH_APP_SECRET=<YOUR_APP_SECRET>
export TANZU_PLATFORM_API_ID=<YOUR_CONNECTION_ID>
export TANZU_PLATFORM_ORG_ID=<YOUR_ORG_ID>
```
Tokens:
Raw