81 changed files with 2834 additions and 1908 deletions
--- a/.github/holopin.yml
+++ b/.github/holopin.yml
@ -1,6 +1,6 @@
 organization: dapr
-defaultSticker: clutq4bgp107990fl1h4m7jp3b
+defaultSticker: clmjkxscc122740fl0mkmb7egi
 stickers:
  -
-    id: clutq4bgp107990fl1h4m7jp3b
-    alias: cli-badge
+    id: clmjkxscc122740fl0mkmb7egi
+    alias: ghc2023
--- a/.github/workflows/dapr_cli.yaml
+++ b/.github/workflows/dapr_cli.yaml
@ -29,7 +29,7 @@ jobs:
    name: Build ${{ matrix.target_os }}_${{ matrix.target_arch }} binaries
    runs-on: ${{ matrix.os }}
    env:
-      GOLANG_CI_LINT_VER: v1.61.0
+      GOLANG_CI_LINT_VER: v1.55.2
      GOOS: ${{ matrix.target_os }}
      GOARCH: ${{ matrix.target_arch }}
      GOPROXY: https://proxy.golang.org
@ -73,12 +73,42 @@ jobs:
          echo "GOBIN=$HOME/bin" >> $GITHUB_ENV
          mkdir -p $HOME/bin
      - name: Check out code into the Go module directory
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
      - name: Set up Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v3
        id: setup-go
        with:
          go-version-file: 'go.mod'
+      - name: Cache Go modules (Linux)
+        if: matrix.target_os == 'linux'
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cache/go-build
+            ~/go/pkg/mod
+          key: ${{ matrix.target_os }}-${{ matrix.target_arch }}-go-${{ steps.setup-go.outputs.go-version }}-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ matrix.target_os }}-${{ matrix.target_arch }}-go-${{ steps.setup-go.outputs.go-version }}-
+      - name: Cache Go modules (Windows)
+        if: matrix.target_os == 'windows'
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~\AppData\Local\go-build
+            ~\go\pkg\mod
+          key: ${{ matrix.target_os }}-${{ matrix.target_arch }}-go-${{ steps.setup-go.outputs.go-version }}-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ matrix.target_os }}-${{ matrix.target_arch }}-go-${{ steps.setup-go.outputs.go-version }}-
+      - name: Cache Go modules (macOS)
+        if: matrix.target_os == 'darwin'
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/Library/Caches/go-build
+            ~/go/pkg/mod
+          key: ${{ matrix.target_os }}-${{ matrix.target_arch }}-go-${{ steps.setup-go.outputs.go-version }}-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ matrix.target_os }}-${{ matrix.target_arch }}-go-${{ steps.setup-go.outputs.go-version }}-
      - name: Run golangci-lint
        if: matrix.target_arch == 'amd64' && matrix.target_os == 'linux'
        uses: golangci/golangci-lint-action@v3.2.0
@ -173,7 +203,7 @@ jobs:
    runs-on: windows-latest
    steps:
      - name: Check out code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
      - name: Parse release version and set REL_VERSION
        run: python ./.github/scripts/get_release_version.py
      - name: Update winget manifests
--- a/.github/workflows/dev_container_feature_release.yaml
+++ b/.github/workflows/dev_container_feature_release.yaml
@ -11,7 +11,7 @@ jobs:
      pull-requests: write
      packages: write
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3

      - name: "Publish Features"
        uses: devcontainers/action@v1
--- a/.github/workflows/dev_container_feature_test.yaml
+++ b/.github/workflows/dev_container_feature_test.yaml
@ -22,7 +22,7 @@ jobs:
          - ubuntu:latest
          - mcr.microsoft.com/devcontainers/base:ubuntu
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3

      - name: "Install latest devcontainer CLI"
        run: npm install -g @devcontainers/cli
@ -39,7 +39,7 @@ jobs:
        features:
          - dapr-cli
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3

      - name: "Install latest devcontainer CLI"
        run: npm install -g @devcontainers/cli
@ -52,7 +52,7 @@ jobs:
    runs-on: ubuntu-latest
    continue-on-error: true
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3

      - name: "Install latest devcontainer CLI"
        run: npm install -g @devcontainers/cli
--- a/.github/workflows/dev_container_feature_validate.yaml
+++ b/.github/workflows/dev_container_feature_validate.yaml
@ -9,7 +9,7 @@ jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3

      - name: "Validate devcontainer-feature.json files"
        uses: devcontainers/action@v1
--- a/.github/workflows/fossa.yml
+++ b/.github/workflows/fossa.yml
@ -34,7 +34,7 @@ jobs:
      FOSSA_API_KEY: b88e1f4287c3108c8751bf106fb46db6 # This is a push-only token that is safe to be exposed.
    steps:
      - name: "Checkout code"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3

      - name: "Run FOSSA Scan"
        uses: fossas/fossa-action@v1.3.1 # Use a specific version if locking is preferred
--- a/.github/workflows/installdaprwin.yml
+++ b/.github/workflows/installdaprwin.yml
@ -38,7 +38,7 @@ jobs:

    steps:
      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3

      # Install Dapr
      - name: Install DAPR CLI
--- a/.github/workflows/kind_e2e.yaml
+++ b/.github/workflows/kind_e2e.yaml
@ -50,10 +50,11 @@ jobs:
    name: E2E tests for K8s (KinD)
    runs-on: ubuntu-latest
    env:
-      DAPR_RUNTIME_PINNED_VERSION: 1.14.4
+      DAPR_RUNTIME_PINNED_VERSION: 1.13.0-rc.2
      DAPR_DASHBOARD_PINNED_VERSION: 0.14.0
      DAPR_RUNTIME_LATEST_STABLE_VERSION:
      DAPR_DASHBOARD_LATEST_STABLE_VERSION:
+      DAPR_TGZ: dapr-1.13.0-rc.2.tgz
    strategy:
      fail-fast: false # Keep running if one leg fails.
      matrix:
@ -79,14 +80,23 @@ jobs:
          kind-image-sha: sha256:9be91e9e9cdf116809841fc77ebdb8845443c4c72fe5218f3ae9eb57fdb4bace
    steps:
    - name: Check out code onto GOPATH
-      uses: actions/checkout@v4
+      uses: actions/checkout@v3
      with:
        path: ./src/github.com/dapr/cli
    - name: Set up Go
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v3
      id: setup-go
      with:
        go-version-file: './src/github.com/dapr/cli/go.mod'
+    - name: Cache Go modules
+      uses: actions/cache@v3
+      with:
+        path: |
+          ~/.cache/go-build
+          ~/go/pkg/mod
+        key: ${{ matrix.k8s-version }}-${{ matrix.kind-version }}-go-${{ steps.setup-go.outputs.go-version }}-${{ hashFiles('**/go.sum') }}
+        restore-keys: |
+          ${{ matrix.k8s-version }}-${{ matrix.kind-version }}-go-${{ steps.setup-go.outputs.go-version }}-

    - name: Configure KinD
      # Generate a KinD configuration file that uses:
@ -173,7 +183,6 @@ jobs:
        export TEST_OUTPUT_FILE=$GITHUB_WORKSPACE/test-e2e-kind.json
        echo "TEST_OUTPUT_FILE=$TEST_OUTPUT_FILE" >> $GITHUB_ENV
        export GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}
-        export TEST_DAPR_HA_MODE=${{ matrix.mode }}
        make e2e-build-run-k8s
      shell: bash
    - name: Run tests with Docker hub
@ -182,7 +191,6 @@ jobs:
        export TEST_OUTPUT_FILE=$GITHUB_WORKSPACE/test-e2e-kind.json
        echo "TEST_OUTPUT_FILE=$TEST_OUTPUT_FILE" >> $GITHUB_ENV
        export GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}
-        export TEST_DAPR_HA_MODE=${{ matrix.mode }}
        make e2e-build-run-k8s
      shell: bash
    - name: Upload test results
--- a/.github/workflows/self_hosted_e2e.yaml
+++ b/.github/workflows/self_hosted_e2e.yaml
@ -38,12 +38,12 @@ jobs:
      GOARCH: ${{ matrix.target_arch }}
      GOPROXY: https://proxy.golang.org
      ARCHIVE_OUTDIR: dist/archives
-      DAPR_RUNTIME_PINNED_VERSION: "1.14.4"
+      DAPR_RUNTIME_PINNED_VERSION: "1.13.0-rc.2"
      DAPR_DASHBOARD_PINNED_VERSION: 0.14.0
      DAPR_RUNTIME_LATEST_STABLE_VERSION: ""
      DAPR_DASHBOARD_LATEST_STABLE_VERSION: ""
      GOLANG_PROTOBUF_REGISTRATION_CONFLICT: warn
-      PODMAN_VERSION: 5.4.0
+      PODMAN_VERSION: 4.4.4
    strategy:
      # TODO: Remove this when our E2E tests are stable for podman on MacOS.
      fail-fast: false # Keep running if one leg fails.
@ -72,12 +72,42 @@ jobs:
          echo "GOBIN=$HOME/bin" >> $GITHUB_ENV
          mkdir -p $HOME/bin
      - name: Check out code into the Go module directory
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
      - name: Set up Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v3
        id: setup-go
        with:
          go-version-file: "go.mod"
+      - name: Cache Go modules (Linux)
+        if: matrix.target_os == 'linux'
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cache/go-build
+            ~/go/pkg/mod
+          key: ${{ matrix.target_os }}-${{ matrix.target_arch }}-go-${{ steps.setup-go.outputs.go-version }}-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ matrix.target_os }}-${{ matrix.target_arch }}-go-${{ steps.setup-go.outputs.go-version }}-
+      - name: Cache Go modules (Windows)
+        if: matrix.target_os == 'windows'
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~\AppData\Local\go-build
+            ~\go\pkg\mod
+          key: ${{ matrix.target_os }}-${{ matrix.target_arch }}-go-${{ steps.setup-go.outputs.go-version }}-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ matrix.target_os }}-${{ matrix.target_arch }}-go-${{ steps.setup-go.outputs.go-version }}-
+      - name: Cache Go modules (macOS)
+        if: matrix.target_os == 'darwin'
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/Library/Caches/go-build
+            ~/go/pkg/mod
+          key: ${{ matrix.target_os }}-${{ matrix.target_arch }}-go-${{ steps.setup-go.outputs.go-version }}-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ matrix.target_os }}-${{ matrix.target_arch }}-go-${{ steps.setup-go.outputs.go-version }}-
      - name: Install podman - MacOS
        timeout-minutes: 15
        if: matrix.os == 'macos-latest-large' && matrix.dapr_install_mode == 'complete'
@ -90,10 +120,8 @@ jobs:

          # Start podman machine
          sudo podman-mac-helper install
-          podman machine init -v $HOME:$HOME --memory 16384 --cpus 12
+          podman machine init
          podman machine start --log-level debug
-          podman machine ssh sudo sysctl -w kernel.keys.maxkeys=20000
-          podman info
          echo "CONTAINER_RUNTIME=podman" >> $GITHUB_ENV
      - name: Determine latest Dapr Runtime version including Pre-releases
        if: github.base_ref == 'master'
--- a/.github/workflows/upgrade_e2e.yaml
+++ b/.github/workflows/upgrade_e2e.yaml
@ -74,14 +74,24 @@ jobs:
          kind-image-sha: sha256:9be91e9e9cdf116809841fc77ebdb8845443c4c72fe5218f3ae9eb57fdb4bace
    steps:
    - name: Check out code onto GOPATH
-      uses: actions/checkout@v4
+      uses: actions/checkout@v3
      with:
        path: ./src/github.com/dapr/cli
    - name: Set up Go
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v3
      id: setup-go
      with:
        go-version-file: './src/github.com/dapr/cli/go.mod'
+    - name: Cache Go modules
+      uses: actions/cache@v3
+      with:
+        path: |
+          ~/.cache/go-build
+          ~/go/pkg/mod
+        key: ${{ matrix.k8s-version }}-${{ matrix.kind-version }}-go-${{ steps.setup-go.outputs.go-version }}-${{ hashFiles('**/go.sum') }}
+        restore-keys: |
+          ${{ matrix.k8s-version }}-${{ matrix.kind-version }}-go-${{ steps.setup-go.outputs.go-version }}-
+

    - name: Configure KinD
      # Generate a KinD configuration file that uses:
@ -137,7 +147,6 @@ jobs:
      run: |
        export TEST_OUTPUT_FILE=$GITHUB_WORKSPACE/test-e2e-upgrade-kind.json
        echo "TEST_OUTPUT_FILE=$TEST_OUTPUT_FILE" >> $GITHUB_ENV
-        export TEST_DAPR_HA_MODE=${{ matrix.mode }}
        make e2e-build-run-upgrade

    - name: Run tests with Docker hub
@ -145,7 +154,6 @@ jobs:
      run: |
        export TEST_OUTPUT_FILE=$GITHUB_WORKSPACE/test-e2e-upgrade-kind.json
        echo "TEST_OUTPUT_FILE=$TEST_OUTPUT_FILE" >> $GITHUB_ENV
-        export TEST_DAPR_HA_MODE=${{ matrix.mode }}
        make e2e-build-run-upgrade

    - name: Upload test results
--- a/.golangci.yml
+++ b/.golangci.yml
@ -4,7 +4,7 @@ run:
  concurrency: 4

  # timeout for analysis, e.g. 30s, 5m, default is 1m
-  timeout: 10m
+  deadline: 10m

  # exit code when at least one issue was found, default is 1
  issues-exit-code: 1
@ -16,22 +16,28 @@ run:
  #build-tags:
  #  - mytag

-issues:
  # which dirs to skip: they won't be analyzed;
  # can use regexp here: generated.*, regexp is applied on full path;
  # default value is empty list, but next dirs are always skipped independently
  # from this option's value:
  # third_party$, testdata$, examples$, Godeps$, builtin$
-  exclude-dirs:
+  skip-dirs:
    - ^pkg.*client.*clientset.*versioned.*
    - ^pkg.*client.*informers.*externalversions.*
    - pkg.*mod.*k8s.io.*

+  # which files to skip: they will be analyzed, but issues from them
+  # won't be reported. Default value is empty list, but there is
+  # no need to include all autogenerated files, we confidently recognize
+  # autogenerated files. If it's not please let us know.
+  skip-files: []
+  #  - ".*\\.my\\.go$"
+  #  - lib/bad.go
+
 # output configuration options
 output:
  # colored-line-number|line-number|json|tab|checkstyle, default is "colored-line-number"
-  formats: 
-  - format: tab
+  format: tab

  # print lines of code with issue, default is true
  print-issued-lines: true
@ -65,6 +71,9 @@ linters-settings:
    statements: 40

  govet:
+    # report about shadowed variables
+    check-shadowing: true
+
    # settings per analyzer
    settings:
      printf: # analyzer name, run `go tool vet help` to see all analyzers
@ -73,18 +82,13 @@ linters-settings:
          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Warnf
          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Errorf
          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Fatalf
-          - github.com/dapr/cli/pkg/print.FailureStatusEvent
-          - github.com/dapr/cli/pkg/print.SuccessStatusEvent
-          - github.com/dapr/cli/pkg/print.WarningStatusEvent
-          - github.com/dapr/cli/pkg/print.InfoStatusEvent
-          - github.com/dapr/cli/pkg/print.StatusEvent
-          - github.com/dapr/cli/pkg/print.Spinner

    # enable or disable analyzers by name
    enable:
      - atomicalign
-      - shadow
    enable-all: false
+    disable:
+      - shadow
    disable-all: false
  revive:
    # linting errors below this confidence will be ignored, default is 0.8
@ -102,6 +106,9 @@ linters-settings:
  gocognit:
    # minimal code complexity to report, 30 by default (but we recommend 10-20)
    min-complexity: 10
+  maligned:
+    # print struct with more effective memory layout or not, false by default
+    suggest-new: true
  dupl:
    # tokens count to trigger issue, 150 by default
    threshold: 100
@ -134,7 +141,7 @@ linters-settings:
    # XXX: if you enable this setting, unused will report a lot of false-positives in text editors:
    # if it's called for subdir of a project it can't find funcs usages. All text editor integrations
    # with golangci-lint call it on a directory with the changed file.
-    exported-fields-are-used: false
+    check-exported: false
  unparam:
    # Inspect exported functions, default is false. Set to true if no external program/library imports your code.
    # XXX: if you enable this setting, unparam will report a lot of false-positives in text editors:
@ -209,17 +216,12 @@ linters-settings:
    # Allow case blocks to end with a whitespace.
    # Allow declarations (var) to be cuddled.
    allow-cuddle-declarations: false
-  testifylint:
-    disable:
-      - require-error
-      

 linters:
  fast: false
  enable-all: true
  disable:
    # TODO Enforce the below linters later
-    - musttag
    - dupl
    - errcheck
    - funlen
@ -228,48 +230,39 @@ linters:
    - gocyclo
    - gocognit
    - godox
+    - interfacer
    - lll
+    - maligned
+    - scopelint
    - unparam
    - wsl
    - gomnd
    - testpackage
    - nestif
+    - goerr113
    - nlreturn
    - exhaustive
-    - exhaustruct
-    - noctx
    - gci
-    - tparallel
-    - paralleltest
-    - wrapcheck
-    - tagliatelle
-    - ireturn
-    - errchkjson
-    - contextcheck
+    - noctx
+    - exhaustivestruct
+    - exhaustruct
    - gomoddirectives
-    - godot
-    - cyclop
-    - varnamelen
-    - errorlint
-    - forcetypeassert
-    - maintidx
-    - nilnil
-    - predeclared
-    - tenv
-    - thelper
+    - paralleltest
+    - tparallel
    - wastedassign
-    - containedctx
-    - gosimple
-    - nonamedreturns
-    - asasalint
-    - rowserrcheck
-    - sqlclosecheck
-    - inamedparam
-    - tagalign
-    - mnd
-    - canonicalheader
-    - exportloopref
-    - execinquery
-    - err113
-    - fatcontext
+    - cyclop
    - forbidigo
+    - tagliatelle
+    - thelper
+    - wrapcheck
+    - varnamelen
+    - forcetypeassert
+    - ireturn
+    - golint
+    - nosnakecase
+    - tagalign
+    - varcheck
+    - deadcode
+    - structcheck
+    - ifshort
+    - testifylint
--- a/Gopkg.lock
+++ b/Gopkg.lock
@ -0,0 +1,991 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  digest = "1:80004fcc5cf64e591486b3e11b406f1e0d17bf85d475d64203c8494f5da4fcd1"
+  name = "cloud.google.com/go"
+  packages = ["compute/metadata"]
+  pruneopts = "UT"
+  revision = "8c41231e01b2085512d98153bcffb847ff9b4b9f"
+  version = "v0.38.0"
+
+[[projects]]
+  digest = "1:6b1426cad7057b717351eacf5b6fe70f053f11aac1ce254bbf2fd72c031719eb"
+  name = "contrib.go.opencensus.io/exporter/ocagent"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "dcb33c7f3b7cfe67e8a2cea10207ede1b7c40764"
+  version = "v0.4.12"
+
+[[projects]]
+  digest = "1:b88fe174accff6609eee9dc7e4ec9f828cbda83e3646111538dbcc7f762f1a56"
+  name = "github.com/Azure/go-autorest"
+  packages = [
+    "autorest",
+    "autorest/adal",
+    "autorest/azure",
+    "autorest/date",
+    "logger",
+    "tracing",
+  ]
+  pruneopts = "UT"
+  revision = "f29a2eccaa178b367df0405778cd85e0af7b4225"
+  version = "v12.1.0"
+
+[[projects]]
+  digest = "1:d5e752c67b445baa5b6cb6f8aa706775c2aa8e41aca95a0c651520ff2c80361a"
+  name = "github.com/Microsoft/go-winio"
+  packages = [
+    ".",
+    "pkg/guid",
+  ]
+  pruneopts = "UT"
+  revision = "6c72808b55902eae4c5943626030429ff20f3b63"
+  version = "v0.4.14"
+
+[[projects]]
+  branch = "master"
+  digest = "1:174cfc45f3f3e0f24f4bc3d2c80d8bcd4c02e274f9a0c4e7fcb6ff3273c0eeee"
+  name = "github.com/Pallinder/sillyname-go"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "97aeae9e6ba11ec62a40cf8b6b4bc42116c0a303"
+
+[[projects]]
+  digest = "1:04457f9f6f3ffc5fea48e71d62f2ca256637dee0a04d710288e27e05c8b41976"
+  name = "github.com/Sirupsen/logrus"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "839c75faf7f98a33d445d181f3018b5c3409a45e"
+  version = "v1.4.2"
+
+[[projects]]
+  digest = "1:937ce6e0cd5ccfec205f444a0d9c74f5680cbb68cd0a992b000559bf964ea20b"
+  name = "github.com/briandowns/spinner"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "e3fb08e7443c496a847cb2eef48e3883f3e12c38"
+  version = "v1.6.1"
+
+[[projects]]
+  digest = "1:c1100fc71e23b6a32b2c68a5202a848fd13811d5a10b12edb8019c3667d1cd9a"
+  name = "github.com/cenkalti/backoff"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "4b4cebaf850ec58f1bb1fec5bdebdf8501c2bc3f"
+  version = "v3.0.0"
+
+[[projects]]
+  digest = "1:fdb4ed936abeecb46a8c27dcac83f75c05c87a46d9ec7711411eb785c213fa02"
+  name = "github.com/census-instrumentation/opencensus-proto"
+  packages = [
+    "gen-go/agent/common/v1",
+    "gen-go/agent/metrics/v1",
+    "gen-go/agent/trace/v1",
+    "gen-go/metrics/v1",
+    "gen-go/resource/v1",
+    "gen-go/trace/v1",
+  ]
+  pruneopts = "UT"
+  revision = "a105b96453fe85139acc07b68de48f2cbdd71249"
+  version = "v0.2.0"
+
+[[projects]]
+  digest = "1:95ea6524ccf5526a5f57fa634f2789266684ae1c15ce1a0cab3ae68e7ea3c4d0"
+  name = "github.com/dapr/dapr"
+  packages = [
+    "pkg/apis/components",
+    "pkg/apis/components/v1alpha1",
+    "pkg/components",
+    "pkg/config/modes",
+  ]
+  pruneopts = "UT"
+  revision = "c75b111b7d2258ce7339f6b40c6d1af5b0b6de22"
+  version = "v0.2.0"
+
+[[projects]]
+  digest = "1:ffe9824d294da03b391f44e1ae8281281b4afc1bdaa9588c9097785e3af10cec"
+  name = "github.com/davecgh/go-spew"
+  packages = ["spew"]
+  pruneopts = "UT"
+  revision = "8991bc29aa16c548c550c7ff78260e27b9ab7c73"
+  version = "v1.1.1"
+
+[[projects]]
+  digest = "1:76dc72490af7174349349838f2fe118996381b31ea83243812a97e5a0fd5ed55"
+  name = "github.com/dgrijalva/jwt-go"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "06ea1031745cb8b3dab3f6a236daf2b0aa468b7e"
+  version = "v3.2.0"
+
+[[projects]]
+  digest = "1:4ddc17aeaa82cb18c5f0a25d7c253a10682f518f4b2558a82869506eec223d76"
+  name = "github.com/docker/distribution"
+  packages = [
+    "digestset",
+    "reference",
+  ]
+  pruneopts = "UT"
+  revision = "2461543d988979529609e8cb6fca9ca190dc48da"
+  version = "v2.7.1"
+
+[[projects]]
+  digest = "1:c4c7064c2c67a0a00815918bae489dd62cd88d859d24c95115d69b00b3d33334"
+  name = "github.com/docker/docker"
+  packages = [
+    "api/types",
+    "api/types/blkiodev",
+    "api/types/container",
+    "api/types/events",
+    "api/types/filters",
+    "api/types/mount",
+    "api/types/network",
+    "api/types/reference",
+    "api/types/registry",
+    "api/types/strslice",
+    "api/types/swarm",
+    "api/types/time",
+    "api/types/versions",
+    "api/types/volume",
+    "client",
+    "pkg/tlsconfig",
+  ]
+  pruneopts = "UT"
+  revision = "092cba3727bb9b4a2f0e922cd6c0f93ea270e363"
+  version = "v1.13.1"
+
+[[projects]]
+  digest = "1:811c86996b1ca46729bad2724d4499014c4b9effd05ef8c71b852aad90deb0ce"
+  name = "github.com/docker/go-connections"
+  packages = [
+    "nat",
+    "sockets",
+    "tlsconfig",
+  ]
+  pruneopts = "UT"
+  revision = "7395e3f8aa162843a74ed6d48e79627d9792ac55"
+  version = "v0.4.0"
+
+[[projects]]
+  digest = "1:e95ef557dc3120984bb66b385ae01b4bb8ff56bcde28e7b0d1beed0cccc4d69f"
+  name = "github.com/docker/go-units"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "519db1ee28dcc9fd2474ae59fca29a810482bfb1"
+  version = "v0.4.0"
+
+[[projects]]
+  digest = "1:865079840386857c809b72ce300be7580cb50d3d3129ce11bf9aa6ca2bc1934a"
+  name = "github.com/fatih/color"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "5b77d2a35fb0ede96d138fc9a99f5c9b6aef11b4"
+  version = "v1.7.0"
+
+[[projects]]
+  digest = "1:abeb38ade3f32a92943e5be54f55ed6d6e3b6602761d74b4aab4c9dd45c18abd"
+  name = "github.com/fsnotify/fsnotify"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9"
+  version = "v1.4.7"
+
+[[projects]]
+  digest = "1:2cd7915ab26ede7d95b8749e6b1f933f1c6d5398030684e6505940a10f31cfda"
+  name = "github.com/ghodss/yaml"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "0ca9ea5df5451ffdf184b4428c902747c2c11cd7"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:adddf11eb27039a3afcc74c5e3d13da84e189012ec37acfc2c70385f25edbe0f"
+  name = "github.com/gocarina/gocsv"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "2fc85fcf0c07e8bb9123b2104e84cfc2a5b53724"
+
+[[projects]]
+  digest = "1:4d02824a56d268f74a6b6fdd944b20b58a77c3d70e81008b3ee0c4f1a6777340"
+  name = "github.com/gogo/protobuf"
+  packages = [
+    "proto",
+    "sortkeys",
+  ]
+  pruneopts = "UT"
+  revision = "ba06b47c162d49f2af050fb4c75bcbc86a159d5c"
+  version = "v1.2.1"
+
+[[projects]]
+  digest = "1:489a99067cd08971bd9c1ee0055119ba8febc1429f9200ab0bec68d35e8c4833"
+  name = "github.com/golang/protobuf"
+  packages = [
+    "jsonpb",
+    "proto",
+    "protoc-gen-go/descriptor",
+    "protoc-gen-go/generator",
+    "protoc-gen-go/generator/internal/remap",
+    "protoc-gen-go/plugin",
+    "ptypes",
+    "ptypes/any",
+    "ptypes/duration",
+    "ptypes/struct",
+    "ptypes/timestamp",
+    "ptypes/wrappers",
+  ]
+  pruneopts = "UT"
+  revision = "b5d812f8a3706043e23a9cd5babf2e5423744d30"
+  version = "v1.3.1"
+
+[[projects]]
+  digest = "1:a6181aca1fd5e27103f9a920876f29ac72854df7345a39f3b01e61c8c94cc8af"
+  name = "github.com/google/gofuzz"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "f140a6486e521aad38f5917de355cbf147cc0496"
+  version = "v1.0.0"
+
+[[projects]]
+  digest = "1:582b704bebaa06b48c29b0cec224a6058a09c86883aaddabde889cd1a5f73e1b"
+  name = "github.com/google/uuid"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "0cd6bf5da1e1c83f8b45653022c74f71af0538a4"
+  version = "v1.1.1"
+
+[[projects]]
+  digest = "1:65c4414eeb350c47b8de71110150d0ea8a281835b1f386eacaa3ad7325929c21"
+  name = "github.com/googleapis/gnostic"
+  packages = [
+    "OpenAPIv2",
+    "compiler",
+    "extensions",
+  ]
+  pruneopts = "UT"
+  revision = "7c663266750e7d82587642f65e60bc4083f1f84e"
+  version = "v0.2.0"
+
+[[projects]]
+  digest = "1:c7810b83a74c6ec1d14d16d4b950c09abce6fbe9cc660ac2cde5b57efa8cc12e"
+  name = "github.com/gophercloud/gophercloud"
+  packages = [
+    ".",
+    "openstack",
+    "openstack/identity/v2/tenants",
+    "openstack/identity/v2/tokens",
+    "openstack/identity/v3/tokens",
+    "openstack/utils",
+    "pagination",
+  ]
+  pruneopts = "UT"
+  revision = "c2d73b246b48e239d3f03c455905e06fe26e33c3"
+  version = "v0.1.0"
+
+[[projects]]
+  digest = "1:4f30fff718a459f9be272e7aa87463cdf4ba27bb8bd7f586ac34c36d670aada4"
+  name = "github.com/grpc-ecosystem/grpc-gateway"
+  packages = [
+    "internal",
+    "runtime",
+    "utilities",
+  ]
+  pruneopts = "UT"
+  revision = "cddead4ec1d10cc62f08e1fd6f8591fbe71cfff9"
+  version = "v1.9.1"
+
+[[projects]]
+  digest = "1:67474f760e9ac3799f740db2c489e6423a4cde45520673ec123ac831ad849cb8"
+  name = "github.com/hashicorp/golang-lru"
+  packages = ["simplelru"]
+  pruneopts = "UT"
+  revision = "7087cb70de9f7a8bc0a10c375cb0d2280a8edf9c"
+  version = "v0.5.1"
+
+[[projects]]
+  digest = "1:c0d19ab64b32ce9fe5cf4ddceba78d5bc9807f0016db6b1183599da3dcc24d10"
+  name = "github.com/hashicorp/hcl"
+  packages = [
+    ".",
+    "hcl/ast",
+    "hcl/parser",
+    "hcl/printer",
+    "hcl/scanner",
+    "hcl/strconv",
+    "hcl/token",
+    "json/parser",
+    "json/scanner",
+    "json/token",
+  ]
+  pruneopts = "UT"
+  revision = "8cb6e5b959231cc1119e43259c4a608f9c51a241"
+  version = "v1.0.0"
+
+[[projects]]
+  digest = "1:a0cefd27d12712af4b5018dc7046f245e1e3b5760e2e848c30b171b570708f9b"
+  name = "github.com/imdario/mergo"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "7c29201646fa3de8506f701213473dd407f19646"
+  version = "v0.3.7"
+
+[[projects]]
+  digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be"
+  name = "github.com/inconshreveable/mousetrap"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
+  version = "v1.0"
+
+[[projects]]
+  digest = "1:f5a2051c55d05548d2d4fd23d244027b59fbd943217df8aa3b5e170ac2fd6e1b"
+  name = "github.com/json-iterator/go"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "0ff49de124c6f76f8494e194af75bde0f1a49a29"
+  version = "v1.1.6"
+
+[[projects]]
+  digest = "1:fa4b4bfa0edfb83c4690d8746ea25bc2447ad0c20063ba72adcb5725f54acde0"
+  name = "github.com/klauspost/compress"
+  packages = [
+    "flate",
+    "gzip",
+    "zlib",
+  ]
+  pruneopts = "UT"
+  revision = "4e96aec082898e4dad17d8aca1a7e2d01362ff6c"
+  version = "v1.9.2"
+
+[[projects]]
+  digest = "1:31e761d97c76151dde79e9d28964a812c46efc5baee4085b86f68f0c654450de"
+  name = "github.com/konsorten/go-windows-terminal-sequences"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "f55edac94c9bbba5d6182a4be46d86a2c9b5b50e"
+  version = "v1.0.2"
+
+[[projects]]
+  digest = "1:5a0ef768465592efca0412f7e838cdc0826712f8447e70e6ccc52eb441e9ab13"
+  name = "github.com/magiconair/properties"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "de8848e004dd33dc07a2947b3d76f618a7fc7ef1"
+  version = "v1.8.1"
+
+[[projects]]
+  digest = "1:c658e84ad3916da105a761660dcaeb01e63416c8ec7bc62256a9b411a05fcd67"
+  name = "github.com/mattn/go-colorable"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
+  version = "v0.0.9"
+
+[[projects]]
+  digest = "1:e150b5fafbd7607e2d638e4e5cf43aa4100124e5593385147b0a74e2733d8b0d"
+  name = "github.com/mattn/go-isatty"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "c2a7a6ca930a4cd0bc33a3f298eb71960732a3a7"
+  version = "v0.0.7"
+
+[[projects]]
+  digest = "1:0356f3312c9bd1cbeda81505b7fd437501d8e778ab66998ef69f00d7f9b3a0d7"
+  name = "github.com/mattn/go-runewidth"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "3ee7d812e62a0804a7d0a324e0249ca2db3476d3"
+  version = "v0.0.4"
+
+[[projects]]
+  branch = "master"
+  digest = "1:56aff9bb73896906956fee6927207393212bfaa732c1aab4feaf29de4b1418e9"
+  name = "github.com/mitchellh/go-ps"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "621e5597135b1d14a7d9c2bfc7bc312e7c58463c"
+
+[[projects]]
+  digest = "1:53bc4cd4914cd7cd52139990d5170d6dc99067ae31c56530621b18b35fc30318"
+  name = "github.com/mitchellh/mapstructure"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "3536a929edddb9a5b34bd6861dc4a9647cb459fe"
+  version = "v1.1.2"
+
+[[projects]]
+  digest = "1:33422d238f147d247752996a26574ac48dcf472976eda7f5134015f06bf16563"
+  name = "github.com/modern-go/concurrent"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "bacd9c7ef1dd9b15be4a9909b8ac7a4e313eec94"
+  version = "1.0.3"
+
+[[projects]]
+  digest = "1:e32bdbdb7c377a07a9a46378290059822efdce5c8d96fe71940d87cb4f918855"
+  name = "github.com/modern-go/reflect2"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "4b7aa43c6742a2c18fdef89dd197aaae7dac7ccd"
+  version = "1.0.1"
+
+[[projects]]
+  branch = "master"
+  digest = "1:6491080aa184f88c2bb8e2f6056e5e0e9a578b2d8666efbd6e97bc37a0c41e72"
+  name = "github.com/nightlyone/lockfile"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "0ad87eef1443f64d3d8c50da647e2b1552851124"
+
+[[projects]]
+  digest = "1:abcdbf03ca6ca13d3697e2186edc1f33863bbdac2b3a44dfa39015e8903f7409"
+  name = "github.com/olekukonko/tablewriter"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "e6d60cf7ba1f42d86d54cdf5508611c4aafb3970"
+  version = "v0.0.1"
+
+[[projects]]
+  digest = "1:ee4d4af67d93cc7644157882329023ce9a7bcfce956a079069a9405521c7cc8d"
+  name = "github.com/opencontainers/go-digest"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "279bed98673dd5bef374d3b6e4b09e2af76183bf"
+  version = "v1.0.0-rc1"
+
+[[projects]]
+  digest = "1:6eea828983c70075ca297bb915ffbcfd3e34c5a50affd94428a65df955c0ff9c"
+  name = "github.com/pelletier/go-toml"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "903d9455db9ff1d7ac1ab199062eca7266dd11a3"
+  version = "v1.6.0"
+
+[[projects]]
+  digest = "1:7413525ee648f20b4181be7fe8103d0cb98be9e141926a03ee082dc207061e4e"
+  name = "github.com/phayes/freeport"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "b8543db493a5ed890c5499e935e2cad7504f3a04"
+  version = "1.0.2"
+
+[[projects]]
+  digest = "1:cf31692c14422fa27c83a05292eb5cbe0fb2775972e8f1f8446a71549bd8980b"
+  name = "github.com/pkg/errors"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "ba968bfe8b2f7e042a574c888954fccecfa385b4"
+  version = "v0.8.1"
+
+[[projects]]
+  digest = "1:bb495ec276ab82d3dd08504bbc0594a65de8c3b22c6f2aaa92d05b73fbf3a82e"
+  name = "github.com/spf13/afero"
+  packages = [
+    ".",
+    "mem",
+  ]
+  pruneopts = "UT"
+  revision = "588a75ec4f32903aa5e39a2619ba6a4631e28424"
+  version = "v1.2.2"
+
+[[projects]]
+  digest = "1:08d65904057412fc0270fc4812a1c90c594186819243160dc779a402d4b6d0bc"
+  name = "github.com/spf13/cast"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "8c9545af88b134710ab1cd196795e7f2388358d7"
+  version = "v1.3.0"
+
+[[projects]]
+  digest = "1:645cabccbb4fa8aab25a956cbcbdf6a6845ca736b2c64e197ca7cbb9d210b939"
+  name = "github.com/spf13/cobra"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "ef82de70bb3f60c65fb8eebacbb2d122ef517385"
+  version = "v0.0.3"
+
+[[projects]]
+  digest = "1:1b753ec16506f5864d26a28b43703c58831255059644351bbcb019b843950900"
+  name = "github.com/spf13/jwalterweatherman"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "94f6ae3ed3bceceafa716478c5fbf8d29ca601a1"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:c1b1102241e7f645bc8e0c22ae352e8f0dc6484b6cb4d132fa9f24174e0119e2"
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "298182f68c66c05229eb03ac171abe6e309ee79a"
+  version = "v1.0.3"
+
+[[projects]]
+  digest = "1:0b60fc944fb6a7b6c985832bd341bdb7ed8fe894fea330414e7774bb24652962"
+  name = "github.com/spf13/viper"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "72b022eb357a56469725dcd03918449e2278d02e"
+  version = "v1.5.0"
+
+[[projects]]
+  digest = "1:f4b32291cad5efac2bfdba89ccde6aa04618b62ce06c1a571da2dc4f3f2677fb"
+  name = "github.com/subosito/gotenv"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "2ef7124db659d49edac6aa459693a15ae36c671a"
+  version = "v1.2.0"
+
+[[projects]]
+  digest = "1:c468422f334a6b46a19448ad59aaffdfc0a36b08fdcc1c749a0b29b6453d7e59"
+  name = "github.com/valyala/bytebufferpool"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "e746df99fe4a3986f4d4f79e13c1e0117ce9c2f7"
+  version = "v1.0.0"
+
+[[projects]]
+  digest = "1:15ad8a80098fcc7a194b9db6b26d74072a852e4faa957848c8118193d3c69230"
+  name = "github.com/valyala/fasthttp"
+  packages = [
+    ".",
+    "fasthttputil",
+    "stackless",
+  ]
+  pruneopts = "UT"
+  revision = "e5f51c11919d4f66400334047b897ef0a94c6f3c"
+  version = "v20180529"
+
+[[projects]]
+  digest = "1:4c93890bbbb5016505e856cb06b5c5a2ff5b7217584d33f2a9071ebef4b5d473"
+  name = "go.opencensus.io"
+  packages = [
+    ".",
+    "internal",
+    "internal/tagencoding",
+    "metric/metricdata",
+    "metric/metricproducer",
+    "plugin/ocgrpc",
+    "plugin/ochttp",
+    "plugin/ochttp/propagation/b3",
+    "plugin/ochttp/propagation/tracecontext",
+    "resource",
+    "stats",
+    "stats/internal",
+    "stats/view",
+    "tag",
+    "trace",
+    "trace/internal",
+    "trace/propagation",
+    "trace/tracestate",
+  ]
+  pruneopts = "UT"
+  revision = "43463a80402d8447b7fce0d2c58edf1687ff0b58"
+  version = "v0.19.3"
+
+[[projects]]
+  branch = "master"
+  digest = "1:bbe51412d9915d64ffaa96b51d409e070665efc5194fcf145c4a27d4133107a4"
+  name = "golang.org/x/crypto"
+  packages = ["ssh/terminal"]
+  pruneopts = "UT"
+  revision = "e1dfcc566284e143ba8f9afbb3fa563f2a0d212b"
+
+[[projects]]
+  branch = "master"
+  digest = "1:01a2f697724170f98739b5261ec830eafc626f56b6786c730578dabcce47649c"
+  name = "golang.org/x/net"
+  packages = [
+    "context",
+    "context/ctxhttp",
+    "http/httpguts",
+    "http2",
+    "http2/hpack",
+    "idna",
+    "internal/socks",
+    "internal/timeseries",
+    "proxy",
+    "trace",
+  ]
+  pruneopts = "UT"
+  revision = "a4d6f7feada510cc50e69a37b484cb0fdc6b7876"
+
+[[projects]]
+  branch = "master"
+  digest = "1:645cb780e4f3177111b40588f0a7f5950efcfb473e7ff41d8d81b2ba5eaa6ed5"
+  name = "golang.org/x/oauth2"
+  packages = [
+    ".",
+    "google",
+    "internal",
+    "jws",
+    "jwt",
+  ]
+  pruneopts = "UT"
+  revision = "9f3314589c9a9136388751d9adae6b0ed400978a"
+
+[[projects]]
+  branch = "master"
+  digest = "1:382bb5a7fb4034db3b6a2d19e5a4a6bcf52f4750530603c01ca18a172fa3089b"
+  name = "golang.org/x/sync"
+  packages = ["semaphore"]
+  pruneopts = "UT"
+  revision = "112230192c580c3556b8cee6403af37a4fc5f28c"
+
+[[projects]]
+  branch = "master"
+  digest = "1:656ce95b4cdf841c00825f4cb94f6e0e1422d7d6faaf3094e94cd18884a32251"
+  name = "golang.org/x/sys"
+  packages = [
+    "unix",
+    "windows",
+  ]
+  pruneopts = "UT"
+  revision = "a129542de9ae0895210abff9c95d67a1f33cb93d"
+
+[[projects]]
+  digest = "1:8d8faad6b12a3a4c819a3f9618cb6ee1fa1cfc33253abeeea8b55336721e3405"
+  name = "golang.org/x/text"
+  packages = [
+    "collate",
+    "collate/build",
+    "internal/colltab",
+    "internal/gen",
+    "internal/language",
+    "internal/language/compact",
+    "internal/tag",
+    "internal/triegen",
+    "internal/ucd",
+    "language",
+    "secure/bidirule",
+    "transform",
+    "unicode/bidi",
+    "unicode/cldr",
+    "unicode/norm",
+    "unicode/rangetable",
+  ]
+  pruneopts = "UT"
+  revision = "342b2e1fbaa52c93f31447ad2c6abc048c63e475"
+  version = "v0.3.2"
+
+[[projects]]
+  branch = "master"
+  digest = "1:9fdc2b55e8e0fafe4b41884091e51e77344f7dc511c5acedcfd98200003bff90"
+  name = "golang.org/x/time"
+  packages = ["rate"]
+  pruneopts = "UT"
+  revision = "9d24e82272b4f38b78bc8cff74fa936d31ccd8ef"
+
+[[projects]]
+  digest = "1:5f003878aabe31d7f6b842d4de32b41c46c214bb629bb485387dbcce1edf5643"
+  name = "google.golang.org/api"
+  packages = ["support/bundler"]
+  pruneopts = "UT"
+  revision = "aac82e61c0c8fe133c297b4b59316b9f481e1f0a"
+  version = "v0.6.0"
+
+[[projects]]
+  digest = "1:04f2ff15fc59e1ddaf9900ad0e19e5b19586b31f9dafd4d592b617642b239d8f"
+  name = "google.golang.org/appengine"
+  packages = [
+    ".",
+    "internal",
+    "internal/app_identity",
+    "internal/base",
+    "internal/datastore",
+    "internal/log",
+    "internal/modules",
+    "internal/remote_api",
+    "internal/urlfetch",
+    "urlfetch",
+  ]
+  pruneopts = "UT"
+  revision = "54a98f90d1c46b7731eb8fb305d2a321c30ef610"
+  version = "v1.5.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:3565a93b7692277a5dea355bc47bd6315754f3246ed07a224be6aec28972a805"
+  name = "google.golang.org/genproto"
+  packages = [
+    "googleapis/api/httpbody",
+    "googleapis/rpc/status",
+    "protobuf/field_mask",
+  ]
+  pruneopts = "UT"
+  revision = "a7e196e89fd3a3c4d103ca540bd5dac3a736e375"
+
+[[projects]]
+  digest = "1:e8800ddadd6bce3bc0c5ffd7bc55dbdddc6e750956c10cc10271cade542fccbe"
+  name = "google.golang.org/grpc"
+  packages = [
+    ".",
+    "balancer",
+    "balancer/base",
+    "balancer/roundrobin",
+    "binarylog/grpc_binarylog_v1",
+    "codes",
+    "connectivity",
+    "credentials",
+    "credentials/internal",
+    "encoding",
+    "encoding/proto",
+    "grpclog",
+    "internal",
+    "internal/backoff",
+    "internal/balancerload",
+    "internal/binarylog",
+    "internal/channelz",
+    "internal/envconfig",
+    "internal/grpcrand",
+    "internal/grpcsync",
+    "internal/syscall",
+    "internal/transport",
+    "keepalive",
+    "metadata",
+    "naming",
+    "peer",
+    "resolver",
+    "resolver/dns",
+    "resolver/passthrough",
+    "stats",
+    "status",
+    "tap",
+  ]
+  pruneopts = "UT"
+  revision = "501c41df7f472c740d0674ff27122f3f48c80ce7"
+  version = "v1.21.1"
+
+[[projects]]
+  digest = "1:2d1fbdc6777e5408cabeb02bf336305e724b925ff4546ded0fa8715a7267922a"
+  name = "gopkg.in/inf.v0"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "d2d2541c53f18d2a059457998ce2876cc8e67cbf"
+  version = "v0.9.1"
+
+[[projects]]
+  digest = "1:4d2e5a73dc1500038e504a8d78b986630e3626dc027bc030ba5c75da257cdb96"
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "51d6538a90f86fe93ac480b35f37b2be17fef232"
+  version = "v2.2.2"
+
+[[projects]]
+  digest = "1:86ad5797d1189de342ed6988fbb76b92dc0429a4d677ad69888d6137efa5712e"
+  name = "k8s.io/api"
+  packages = [
+    "admissionregistration/v1beta1",
+    "apps/v1",
+    "apps/v1beta1",
+    "apps/v1beta2",
+    "auditregistration/v1alpha1",
+    "authentication/v1",
+    "authentication/v1beta1",
+    "authorization/v1",
+    "authorization/v1beta1",
+    "autoscaling/v1",
+    "autoscaling/v2beta1",
+    "autoscaling/v2beta2",
+    "batch/v1",
+    "batch/v1beta1",
+    "batch/v2alpha1",
+    "certificates/v1beta1",
+    "coordination/v1",
+    "coordination/v1beta1",
+    "core/v1",
+    "events/v1beta1",
+    "extensions/v1beta1",
+    "networking/v1",
+    "networking/v1beta1",
+    "node/v1alpha1",
+    "node/v1beta1",
+    "policy/v1beta1",
+    "rbac/v1",
+    "rbac/v1alpha1",
+    "rbac/v1beta1",
+    "scheduling/v1",
+    "scheduling/v1alpha1",
+    "scheduling/v1beta1",
+    "settings/v1alpha1",
+    "storage/v1",
+    "storage/v1alpha1",
+    "storage/v1beta1",
+  ]
+  pruneopts = "UT"
+  revision = "6e4e0e4f393bf5e8bbff570acd13217aa5a770cd"
+  version = "kubernetes-1.14.1"
+
+[[projects]]
+  digest = "1:78f6a824d205c6cb0d011cce241407646b773cb57ee27e8c7e027753b4111075"
+  name = "k8s.io/apimachinery"
+  packages = [
+    "pkg/api/errors",
+    "pkg/api/meta",
+    "pkg/api/resource",
+    "pkg/apis/meta/v1",
+    "pkg/apis/meta/v1/unstructured",
+    "pkg/apis/meta/v1beta1",
+    "pkg/conversion",
+    "pkg/conversion/queryparams",
+    "pkg/fields",
+    "pkg/labels",
+    "pkg/runtime",
+    "pkg/runtime/schema",
+    "pkg/runtime/serializer",
+    "pkg/runtime/serializer/json",
+    "pkg/runtime/serializer/protobuf",
+    "pkg/runtime/serializer/recognizer",
+    "pkg/runtime/serializer/streaming",
+    "pkg/runtime/serializer/versioning",
+    "pkg/selection",
+    "pkg/types",
+    "pkg/util/clock",
+    "pkg/util/errors",
+    "pkg/util/framer",
+    "pkg/util/intstr",
+    "pkg/util/json",
+    "pkg/util/naming",
+    "pkg/util/net",
+    "pkg/util/runtime",
+    "pkg/util/sets",
+    "pkg/util/validation",
+    "pkg/util/validation/field",
+    "pkg/util/yaml",
+    "pkg/version",
+    "pkg/watch",
+    "third_party/forked/golang/reflect",
+  ]
+  pruneopts = "UT"
+  revision = "6a84e37a896db9780c75367af8d2ed2bb944022e"
+  version = "kubernetes-1.14.1"
+
+[[projects]]
+  digest = "1:37f699391265222af7da4bf8e443ca03dd834ce362fbb4b19b4d67492ff06781"
+  name = "k8s.io/client-go"
+  packages = [
+    "discovery",
+    "kubernetes",
+    "kubernetes/scheme",
+    "kubernetes/typed/admissionregistration/v1beta1",
+    "kubernetes/typed/apps/v1",
+    "kubernetes/typed/apps/v1beta1",
+    "kubernetes/typed/apps/v1beta2",
+    "kubernetes/typed/auditregistration/v1alpha1",
+    "kubernetes/typed/authentication/v1",
+    "kubernetes/typed/authentication/v1beta1",
+    "kubernetes/typed/authorization/v1",
+    "kubernetes/typed/authorization/v1beta1",
+    "kubernetes/typed/autoscaling/v1",
+    "kubernetes/typed/autoscaling/v2beta1",
+    "kubernetes/typed/autoscaling/v2beta2",
+    "kubernetes/typed/batch/v1",
+    "kubernetes/typed/batch/v1beta1",
+    "kubernetes/typed/batch/v2alpha1",
+    "kubernetes/typed/certificates/v1beta1",
+    "kubernetes/typed/coordination/v1",
+    "kubernetes/typed/coordination/v1beta1",
+    "kubernetes/typed/core/v1",
+    "kubernetes/typed/events/v1beta1",
+    "kubernetes/typed/extensions/v1beta1",
+    "kubernetes/typed/networking/v1",
+    "kubernetes/typed/networking/v1beta1",
+    "kubernetes/typed/node/v1alpha1",
+    "kubernetes/typed/node/v1beta1",
+    "kubernetes/typed/policy/v1beta1",
+    "kubernetes/typed/rbac/v1",
+    "kubernetes/typed/rbac/v1alpha1",
+    "kubernetes/typed/rbac/v1beta1",
+    "kubernetes/typed/scheduling/v1",
+    "kubernetes/typed/scheduling/v1alpha1",
+    "kubernetes/typed/scheduling/v1beta1",
+    "kubernetes/typed/settings/v1alpha1",
+    "kubernetes/typed/storage/v1",
+    "kubernetes/typed/storage/v1alpha1",
+    "kubernetes/typed/storage/v1beta1",
+    "pkg/apis/clientauthentication",
+    "pkg/apis/clientauthentication/v1alpha1",
+    "pkg/apis/clientauthentication/v1beta1",
+    "pkg/version",
+    "plugin/pkg/client/auth",
+    "plugin/pkg/client/auth/azure",
+    "plugin/pkg/client/auth/exec",
+    "plugin/pkg/client/auth/gcp",
+    "plugin/pkg/client/auth/oidc",
+    "plugin/pkg/client/auth/openstack",
+    "rest",
+    "rest/watch",
+    "third_party/forked/golang/template",
+    "tools/auth",
+    "tools/clientcmd",
+    "tools/clientcmd/api",
+    "tools/clientcmd/api/latest",
+    "tools/clientcmd/api/v1",
+    "tools/metrics",
+    "tools/reference",
+    "transport",
+    "util/cert",
+    "util/connrotation",
+    "util/flowcontrol",
+    "util/homedir",
+    "util/jsonpath",
+    "util/keyutil",
+  ]
+  pruneopts = "UT"
+  revision = "1a26190bd76a9017e289958b9fba936430aa3704"
+  version = "kubernetes-1.14.1"
+
+[[projects]]
+  digest = "1:c696379ad201c1e86591785579e16bf6cf886c362e9a7534e8eb0d1028b20582"
+  name = "k8s.io/klog"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "e531227889390a39d9533dde61f590fe9f4b0035"
+  version = "v0.3.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:8b40227d4bf8b431fdab4f9026e6e346f00ac3be5662af367a183f78c57660b3"
+  name = "k8s.io/utils"
+  packages = ["integer"]
+  pruneopts = "UT"
+  revision = "8fab8cb257d50c8cf94ec9771e74826edbb68fb5"
+
+[[projects]]
+  digest = "1:7719608fe0b52a4ece56c2dde37bedd95b938677d1ab0f84b8a7852e4c59f849"
+  name = "sigs.k8s.io/yaml"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "fd68e9863619f6ec2fdd8625fe1f02e7c877e480"
+  version = "v1.1.0"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  input-imports = [
+    "github.com/Pallinder/sillyname-go",
+    "github.com/briandowns/spinner",
+    "github.com/dapr/dapr/pkg/components",
+    "github.com/dapr/dapr/pkg/config/modes",
+    "github.com/docker/docker/client",
+    "github.com/fatih/color",
+    "github.com/gocarina/gocsv",
+    "github.com/google/uuid",
+    "github.com/mitchellh/go-ps",
+    "github.com/nightlyone/lockfile",
+    "github.com/olekukonko/tablewriter",
+    "github.com/phayes/freeport",
+    "github.com/spf13/cobra",
+    "github.com/spf13/viper",
+    "gopkg.in/yaml.v2",
+    "k8s.io/api/core/v1",
+    "k8s.io/apimachinery/pkg/apis/meta/v1",
+    "k8s.io/client-go/kubernetes",
+    "k8s.io/client-go/plugin/pkg/client/auth",
+    "k8s.io/client-go/plugin/pkg/client/auth/gcp",
+    "k8s.io/client-go/tools/clientcmd",
+  ]
+  solver-name = "gps-cdcl"
+  solver-version = 1
--- a/Gopkg.toml
+++ b/Gopkg.toml
@ -0,0 +1,54 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[[constraint]]
+  name = "github.com/fatih/color"
+  version = "1.7.0"
+
+[[constraint]]
+  name = "github.com/spf13/cobra"
+  version = "0.0.3"
+
+[[constraint]]
+  name = "github.com/spf13/viper"
+  version = "1.5.0"
+
+[[override]]
+  version = "kubernetes-1.14.1"
+  name = "k8s.io/apimachinery"
+
+[[override]]
+  version = "kubernetes-1.14.1"
+  name = "k8s.io/api"
+
+[[override]]
+  version = "kubernetes-1.14.1"
+  name = "k8s.io/client-go"
+
+[prune]
+  go-tests = true
+  unused-packages = true
--- a/2
+++ b/2
@ -174,7 +174,7 @@ e2e-build-run-k8s: build test-e2e-k8s
 ################################################################################
 .PHONY: test-e2e-upgrade
 test-e2e-upgrade: test-deps
-	gotestsum --jsonfile $(TEST_OUTPUT_FILE) --format standard-verbose -- -timeout 60m -count=1 -tags=e2e ./tests/e2e/upgrade/...
+	gotestsum --jsonfile $(TEST_OUTPUT_FILE) --format standard-verbose -- -timeout 40m -count=1 -tags=e2e ./tests/e2e/upgrade/...

 ################################################################################
 # Build, E2E Tests for Kubernetes Upgrade									   #
--- a/cmd/annotate.go
+++ b/cmd/annotate.go
@ -21,11 +21,6 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
-	"strconv"
-
-	"github.com/dapr/dapr/pkg/runtime"
-
-	"k8s.io/apimachinery/pkg/api/resource"

 	"github.com/spf13/cobra"

@ -65,8 +60,8 @@ var (
 	annotateReadinessProbeThreshold      int
 	annotateDaprImage                    string
 	annotateAppSSL                       bool
-	annotateMaxRequestBodySize           string
-	annotateReadBufferSize               string
+	annotateMaxRequestBodySize           int
+	annotateReadBufferSize               int
 	annotateHTTPStreamRequestBody        bool
 	annotateGracefulShutdownSeconds      int
 	annotateEnableAPILogging             bool
@ -323,23 +318,12 @@ func getOptionsFromFlags() kubernetes.AnnotateOptions {
 	if annotateAppSSL {
 		o = append(o, kubernetes.WithAppSSL())
 	}
-	if annotateMaxRequestBodySize != "-1" {
-		if q, err := resource.ParseQuantity(annotateMaxRequestBodySize); err != nil {
-			print.FailureStatusEvent(os.Stderr, "error parsing value of max-body-size: %s, error: %s", annotateMaxRequestBodySize, err.Error())
-			os.Exit(1)
-		} else {
-			o = append(o, kubernetes.WithMaxRequestBodySize(int(q.Value())))
-		}
+	if annotateMaxRequestBodySize != -1 {
+		o = append(o, kubernetes.WithMaxRequestBodySize(annotateMaxRequestBodySize))
 	}
-	if annotateReadBufferSize != "-1" {
-		if q, err := resource.ParseQuantity(annotateReadBufferSize); err != nil {
-			print.FailureStatusEvent(os.Stderr, "error parsing value of read-buffer-size: %s, error: %s", annotateMaxRequestBodySize, err.Error())
-			os.Exit(1)
-		} else {
-			o = append(o, kubernetes.WithReadBufferSize(int(q.Value())))
-		}
+	if annotateReadBufferSize != -1 {
+		o = append(o, kubernetes.WithReadBufferSize(annotateReadBufferSize))
 	}
-
 	if annotateHTTPStreamRequestBody {
 		o = append(o, kubernetes.WithHTTPStreamRequestBody())
 	}
@ -401,8 +385,8 @@ func init() {
 	AnnotateCmd.Flags().StringVar(&annotateDaprImage, "dapr-image", "", "The image to use for the dapr sidecar container")
 	AnnotateCmd.Flags().BoolVar(&annotateAppSSL, "app-ssl", false, "Enable SSL for the app")
 	AnnotateCmd.Flags().MarkDeprecated("app-ssl", "This flag is deprecated and will be removed in a future release. Use \"app-protocol\" flag with https or grpcs instead")
-	AnnotateCmd.Flags().StringVar(&annotateMaxRequestBodySize, "max-body-size", strconv.Itoa(runtime.DefaultMaxRequestBodySize>>20)+"Mi", "The maximum request body size to use")
-	AnnotateCmd.Flags().StringVar(&annotateReadBufferSize, "read-buffer-size", strconv.Itoa(runtime.DefaultReadBufferSize>>10)+"Ki", "The maximum size of HTTP header read buffer in kilobytes")
+	AnnotateCmd.Flags().IntVar(&annotateMaxRequestBodySize, "max-request-body-size", -1, "The maximum request body size to use")
+	AnnotateCmd.Flags().IntVar(&annotateReadBufferSize, "http-read-buffer-size", -1, "The maximum size of HTTP header read buffer in kilobytes")
 	AnnotateCmd.Flags().BoolVar(&annotateHTTPStreamRequestBody, "http-stream-request-body", false, "Enable streaming request body for HTTP")
 	AnnotateCmd.Flags().IntVar(&annotateGracefulShutdownSeconds, "graceful-shutdown-seconds", -1, "The number of seconds to wait for the app to shutdown")
 	AnnotateCmd.Flags().BoolVar(&annotateEnableAPILogging, "enable-api-logging", false, "Enable API logging for the Dapr sidecar")
--- a/cmd/dashboard.go
+++ b/cmd/dashboard.go
@ -18,7 +18,6 @@ import (
 	"net"
 	"os"
 	"os/signal"
-	"strconv"

 	"github.com/pkg/browser"
 	"github.com/spf13/cobra"
@ -181,9 +180,9 @@ dapr dashboard -k -p 0
 			}()

 			// url for dashboard after port forwarding.
-			webURL := "http://" + net.JoinHostPort(dashboardHost, strconv.Itoa(portForward.LocalPort))
+			webURL := fmt.Sprintf("http://%s", net.JoinHostPort(dashboardHost, fmt.Sprint(portForward.LocalPort))) //nolint: perfsprint

-			print.InfoStatusEvent(os.Stdout, "Dapr dashboard found in namespace:\t"+foundNamespace)
+			print.InfoStatusEvent(os.Stdout, fmt.Sprintf("Dapr dashboard found in namespace:\t%s", foundNamespace))
 			print.InfoStatusEvent(os.Stdout, fmt.Sprintf("Dapr dashboard available at:\t%s\n", webURL))

 			err = browser.OpenURL(webURL)
--- a/cmd/mtls.go
+++ b/cmd/mtls.go
@ -67,7 +67,7 @@ dapr mtls export -o ./certs
 		}

 		dir, _ := filepath.Abs(exportPath)
-		print.SuccessStatusEvent(os.Stdout, "Trust certs successfully exported to "+dir)
+		print.SuccessStatusEvent(os.Stdout, fmt.Sprintf("Trust certs successfully exported to %s", dir))
 	},
 	PostRun: func(cmd *cobra.Command, args []string) {
 		kubernetes.CheckForCertExpiry()
--- a/cmd/renew_certificate.go
+++ b/cmd/renew_certificate.go
@ -103,7 +103,7 @@ dapr mtls renew-cert -k --valid-until <no of days> --restart
 					print.InfoStatusEvent(os.Stdout, "Using password file to generate root certificate")
 					err = kubernetes.RenewCertificate(kubernetes.RenewCertificateParams{
 						RootPrivateKeyFilePath: privateKey,
-						ValidUntil:             time.Hour * time.Duration(validUntil*24), //nolint:gosec
+						ValidUntil:             time.Hour * time.Duration(validUntil*24),
 						Timeout:                timeout,
 						ImageVariant:           imageVariant,
 					})
@ -113,7 +113,7 @@ dapr mtls renew-cert -k --valid-until <no of days> --restart
 				} else {
 					print.InfoStatusEvent(os.Stdout, "generating fresh certificates")
 					err = kubernetes.RenewCertificate(kubernetes.RenewCertificateParams{
-						ValidUntil:   time.Hour * time.Duration(validUntil*24), //nolint:gosec
+						ValidUntil:   time.Hour * time.Duration(validUntil*24),
 						Timeout:      timeout,
 						ImageVariant: imageVariant,
 					})
@ -129,7 +129,7 @@ dapr mtls renew-cert -k --valid-until <no of days> --restart
 				logErrorAndExit(err)
 			}
 			print.SuccessStatusEvent(os.Stdout,
-				"Certificate rotation is successful! Your new certicate is valid through "+expiry.Format(time.RFC1123))
+				fmt.Sprintf("Certificate rotation is successful! Your new certicate is valid through %s", expiry.Format(time.RFC1123)))

 			if restartDaprServices {
 				restartControlPlaneService()
--- a/cmd/run.go
+++ b/cmd/run.go
@ -20,7 +20,6 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
-	"slices"
 	"strconv"
 	"strings"
 	"time"
@ -28,11 +27,8 @@ import (
 	"golang.org/x/mod/semver"

 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 	"github.com/spf13/viper"

-	daprRuntime "github.com/dapr/dapr/pkg/runtime"
-
 	"github.com/dapr/cli/pkg/kubernetes"
 	"github.com/dapr/cli/pkg/metadata"
 	"github.com/dapr/cli/pkg/print"
@ -59,8 +55,8 @@ var (
 	resourcesPaths       []string
 	appSSL               bool
 	metricsPort          int
-	maxRequestBodySize   string
-	readBufferSize       string
+	maxRequestBodySize   int
+	readBufferSize       int
 	unixDomainSocket     string
 	enableAppHealth      bool
 	appHealthPath        string
@ -80,15 +76,6 @@ const (
 	runtimeWaitTimeoutInSeconds = 60
 )

-// Flags that are compatible with --run-file
-var runFileCompatibleFlags = []string{
-	"kubernetes",
-	"help",
-	"version",
-	"runtime-path",
-	"log-as-json",
-}
-
 var RunCmd = &cobra.Command{
 	Use:   "run",
 	Short: "Run Dapr and (optionally) your application side by side. Supported platforms: Self-hosted",
@ -139,14 +126,6 @@ dapr run --run-file /path/to/directory -k
 	},
 	Run: func(cmd *cobra.Command, args []string) {
 		if len(runFilePath) > 0 {
-			// Check for incompatible flags
-			incompatibleFlags := detectIncompatibleFlags(cmd)
-			if len(incompatibleFlags) > 0 {
-				// Print warning message about incompatible flags
-				warningMsg := "The following flags are ignored when using --run-file and should be configured in the run file instead: " + strings.Join(incompatibleFlags, ", ")
-				print.WarningStatusEvent(os.Stdout, warningMsg)
-			}
-
 			runConfigFilePath, err := getRunFilePath(runFilePath)
 			if err != nil {
 				print.FailureStatusEvent(os.Stderr, "Failed to get run file path: %v", err)
@ -251,7 +230,7 @@ dapr run --run-file /path/to/directory -k
 					output.DaprGRPCPort)
 			}

-			if (daprVer.RuntimeVersion != "edge") && (semver.Compare(fmt.Sprintf("v%v", daprVer.RuntimeVersion), "v1.14.0-rc.1") == -1) {
+			if semver.Compare(fmt.Sprintf("v%v", daprVer.RuntimeVersion), "v1.14.0-rc.1") == -1 {
 				print.InfoStatusEvent(os.Stdout, "The scheduler is only compatible with dapr runtime 1.14 onwards.")
 				for i, arg := range output.DaprCMD.Args {
 					if strings.HasPrefix(arg, "--scheduler-host-address") {
@ -340,14 +319,14 @@ dapr run --run-file /path/to/directory -k

 			stdErrPipe, pipeErr := output.AppCMD.StderrPipe()
 			if pipeErr != nil {
-				print.FailureStatusEvent(os.Stderr, "Error creating stderr for App: "+err.Error())
+				print.FailureStatusEvent(os.Stderr, fmt.Sprintf("Error creating stderr for App: %s", err.Error()))
 				appRunning <- false
 				return
 			}

 			stdOutPipe, pipeErr := output.AppCMD.StdoutPipe()
 			if pipeErr != nil {
-				print.FailureStatusEvent(os.Stderr, "Error creating stdout for App: "+err.Error())
+				print.FailureStatusEvent(os.Stderr, fmt.Sprintf("Error creating stdout for App: %s", err.Error()))
 				appRunning <- false
 				return
 			}
@ -356,13 +335,13 @@ dapr run --run-file /path/to/directory -k
 			outScanner := bufio.NewScanner(stdOutPipe)
 			go func() {
 				for errScanner.Scan() {
-					fmt.Println(print.Blue("== APP == " + errScanner.Text()))
+					fmt.Println(print.Blue(fmt.Sprintf("== APP == %s", errScanner.Text())))
 				}
 			}()

 			go func() {
 				for outScanner.Scan() {
-					fmt.Println(print.Blue("== APP == " + outScanner.Text()))
+					fmt.Println(print.Blue(fmt.Sprintf("== APP == %s", outScanner.Text())))
 				}
 			}()

@ -416,7 +395,7 @@ dapr run --run-file /path/to/directory -k
 			}

 			appCommand := strings.Join(args, " ")
-			print.InfoStatusEvent(os.Stdout, "Updating metadata for app command: "+appCommand)
+			print.InfoStatusEvent(os.Stdout, fmt.Sprintf("Updating metadata for app command: %s", appCommand))
 			err = metadata.Put(output.DaprHTTPPort, "appCommand", appCommand, output.AppID, unixDomainSocket)
 			if err != nil {
 				print.WarningStatusEvent(os.Stdout, "Could not update sidecar metadata for appCommand: %s", err.Error())
@ -494,8 +473,8 @@ func init() {
 	RunCmd.Flags().MarkDeprecated("app-ssl", "This flag is deprecated and will be removed in the future releases. Use \"app-protocol\" flag with https or grpcs values instead")
 	RunCmd.Flags().IntVarP(&metricsPort, "metrics-port", "M", -1, "The port of metrics on dapr")
 	RunCmd.Flags().BoolP("help", "h", false, "Print this help message")
-	RunCmd.Flags().StringVarP(&maxRequestBodySize, "max-body-size", "", strconv.Itoa(daprRuntime.DefaultMaxRequestBodySize>>20)+"Mi", "Max size of request body in MB")
-	RunCmd.Flags().StringVarP(&readBufferSize, "read-buffer-size", "", strconv.Itoa(daprRuntime.DefaultReadBufferSize>>10)+"Ki", "HTTP header read buffer in KB")
+	RunCmd.Flags().IntVarP(&maxRequestBodySize, "dapr-http-max-request-size", "", -1, "Max size of request body in MB")
+	RunCmd.Flags().IntVarP(&readBufferSize, "dapr-http-read-buffer-size", "", -1, "HTTP header read buffer in KB")
 	RunCmd.Flags().StringVarP(&unixDomainSocket, "unix-domain-socket", "u", "", "Path to a unix domain socket dir. If specified, Dapr API servers will use Unix Domain Sockets")
 	RunCmd.Flags().BoolVar(&enableAppHealth, "enable-app-health-check", false, "Enable health checks for the application using the protocol defined with app-protocol")
 	RunCmd.Flags().StringVar(&appHealthPath, "app-health-check-path", "", "Path used for health checks; HTTP only")
@ -529,8 +508,6 @@ func executeRun(runTemplateName, runFilePath string, apps []runfileconfig.App) (
 		// Set defaults if zero value provided in config yaml.
 		app.RunConfig.SetDefaultFromSchema()

-		app.RunConfig.SchedulerHostAddress = validateSchedulerHostAddress(daprVer.RuntimeVersion, app.RunConfig.SchedulerHostAddress)
-
 		// Validate validates the configs and modifies the ports to free ports, appId etc.
 		err := app.RunConfig.Validate()
 		if err != nil {
@ -547,7 +524,6 @@ func executeRun(runTemplateName, runFilePath string, apps []runfileconfig.App) (
 			exitWithError = true
 			break
 		}
-
 		// Combined multiwriter for logs.
 		var appDaprdWriter io.Writer
 		// appLogWriter is used when app command is present.
@ -688,17 +664,6 @@ func executeRunWithAppsConfigFile(runFilePath string, k8sEnabled bool) {
 	}
 }

-// populate the scheduler host address based on the dapr version.
-func validateSchedulerHostAddress(version, address string) string {
-	// If no SchedulerHostAddress is supplied, set it to default value.
-	if semver.Compare(fmt.Sprintf("v%v", version), "v1.15.0-rc.0") == 1 {
-		if address == "" {
-			return "localhost"
-		}
-	}
-	return address
-}
-
 func getRunConfigFromRunFile(runFilePath string) (runfileconfig.RunFileConfig, []runfileconfig.App, error) {
 	config := runfileconfig.RunFileConfig{}
 	apps, err := config.GetApps(runFilePath)
@ -1080,26 +1045,3 @@ func getRunFilePath(path string) (string, error) {
 	}
 	return path, nil
 }
-
-// getConflictingFlags checks if any flags are set other than the ones passed in the excludedFlags slice.
-// Used for logic or notifications when any of the flags are conflicting and should not be used together.
-func getConflictingFlags(cmd *cobra.Command, excludedFlags ...string) []string {
-	var conflictingFlags []string
-	cmd.Flags().Visit(func(f *pflag.Flag) {
-		if !slices.Contains(excludedFlags, f.Name) {
-			conflictingFlags = append(conflictingFlags, f.Name)
-		}
-	})
-	return conflictingFlags
-}
-
-// detectIncompatibleFlags checks if any incompatible flags are used with --run-file
-// and returns a slice of the flag names that were used
-func detectIncompatibleFlags(cmd *cobra.Command) []string {
-	if runFilePath == "" {
-		return nil // No run file specified, so no incompatibilities
-	}
-
-	// Get all flags that are not in the compatible list
-	return getConflictingFlags(cmd, append(runFileCompatibleFlags, "run-file")...)
-}
--- a/cmd/run_test.go
+++ b/cmd/run_test.go
@ -1,78 +0,0 @@
-package cmd
-
-import (
-	"testing"
-
-	"github.com/spf13/cobra"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestValidateSchedulerHostAddress(t *testing.T) {
-	t.Run("test scheduler host address - v1.14.0-rc.0", func(t *testing.T) {
-		address := validateSchedulerHostAddress("1.14.0-rc.0", "")
-		assert.Equal(t, "", address)
-	})
-
-	t.Run("test scheduler host address - v1.15.0-rc.0", func(t *testing.T) {
-		address := validateSchedulerHostAddress("1.15.0", "")
-		assert.Equal(t, "localhost:50006", address)
-	})
-}
-
-func TestDetectIncompatibleFlags(t *testing.T) {
-	// Setup a temporary run file path to trigger the incompatible flag check
-	originalRunFilePath := runFilePath
-	runFilePath = "some/path"
-	defer func() {
-		// Restore the original runFilePath
-		runFilePath = originalRunFilePath
-	}()
-
-	t.Run("detect incompatible flags", func(t *testing.T) {
-		// Create a test command with flags
-		cmd := &cobra.Command{Use: "test"}
-		cmd.Flags().String("app-id", "", "")
-		cmd.Flags().String("dapr-http-port", "", "")
-		cmd.Flags().String("kubernetes", "", "")   // Compatible flag
-		cmd.Flags().String("runtime-path", "", "") // Compatible flag
-		cmd.Flags().String("log-as-json", "", "")  // Compatible flag
-
-		// Mark flags as changed
-		cmd.Flags().Set("app-id", "myapp")
-		cmd.Flags().Set("dapr-http-port", "3500")
-		cmd.Flags().Set("kubernetes", "true")
-		cmd.Flags().Set("runtime-path", "/path/to/runtime")
-		cmd.Flags().Set("log-as-json", "true")
-
-		// Test detection
-		incompatibleFlags := detectIncompatibleFlags(cmd)
-		assert.Len(t, incompatibleFlags, 2)
-		assert.Contains(t, incompatibleFlags, "app-id")
-		assert.Contains(t, incompatibleFlags, "dapr-http-port")
-		assert.NotContains(t, incompatibleFlags, "kubernetes")
-		assert.NotContains(t, incompatibleFlags, "runtime-path")
-		assert.NotContains(t, incompatibleFlags, "log-as-json")
-	})
-
-	t.Run("no incompatible flags when run file not specified", func(t *testing.T) {
-		// Create a test command with flags
-		cmd := &cobra.Command{Use: "test"}
-		cmd.Flags().String("app-id", "", "")
-		cmd.Flags().String("dapr-http-port", "", "")
-
-		// Mark flags as changed
-		cmd.Flags().Set("app-id", "myapp")
-		cmd.Flags().Set("dapr-http-port", "3500")
-
-		// Temporarily clear runFilePath
-		originalRunFilePath := runFilePath
-		runFilePath = ""
-		defer func() {
-			runFilePath = originalRunFilePath
-		}()
-
-		// Test detection
-		incompatibleFlags := detectIncompatibleFlags(cmd)
-		assert.Nil(t, incompatibleFlags)
-	})
-}
--- a/cmd/stop.go
+++ b/cmd/stop.go
@ -98,7 +98,7 @@ dapr stop --run-file /path/to/directory -k
 func init() {
 	StopCmd.Flags().StringVarP(&stopAppID, "app-id", "a", "", "The application id to be stopped")
 	StopCmd.Flags().StringVarP(&runFilePath, "run-file", "f", "", "Path to the run template file for the list of apps to stop")
-	StopCmd.Flags().BoolVarP(&stopK8s, "kubernetes", "k", false, "Stop deployments in Kubernetes based on multi-app run file")
+	StopCmd.Flags().BoolVarP(&stopK8s, "kubernetes", "k", false, "Stop deployments in Kunernetes based on multi-app run file")
 	StopCmd.Flags().BoolP("help", "h", false, "Print this help message")
 	RootCmd.AddCommand(StopCmd)
 }
--- a/go.mod
+++ b/go.mod
@ -1,245 +1,275 @@
 module github.com/dapr/cli

-go 1.23.5
+go 1.21

 require (
-	github.com/Masterminds/semver v1.5.0
-	github.com/Masterminds/semver/v3 v3.3.0
+	github.com/Azure/go-autorest/autorest v0.11.28 // indirect
+	github.com/Azure/go-autorest/autorest/adal v0.9.22 // indirect
 	github.com/Pallinder/sillyname-go v0.0.0-20130730142914-97aeae9e6ba1
 	github.com/briandowns/spinner v1.19.0
-	github.com/dapr/dapr v1.15.0-rc.3.0.20250107220753-e073759df4c1
-	github.com/dapr/go-sdk v1.11.0
-	github.com/dapr/kit v0.13.1-0.20241127165251-30e2c24840b4
-	github.com/docker/docker v25.0.6+incompatible
-	github.com/evanphx/json-patch/v5 v5.9.0
-	github.com/fatih/color v1.17.0
+	github.com/dapr/dapr v1.13.0-rc.6
+	github.com/dapr/go-sdk v1.6.1-0.20240209153236-ac26e622c4a6
+	github.com/docker/docker v20.10.21+incompatible
+	github.com/fatih/color v1.15.0
 	github.com/gocarina/gocsv v0.0.0-20220927221512-ad3251f9fa25
-	github.com/hashicorp/go-retryablehttp v0.7.7
+	github.com/hashicorp/go-retryablehttp v0.7.1
 	github.com/hashicorp/go-version v1.6.0
-	github.com/kolesnikovae/go-winjob v1.0.0
 	github.com/mitchellh/go-ps v1.0.0
 	github.com/nightlyone/lockfile v1.0.0
 	github.com/olekukonko/tablewriter v0.0.5
 	github.com/phayes/freeport v0.0.0-20220201140144-74d24b5ae9f5
 	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c
 	github.com/shirou/gopsutil v3.21.11+incompatible
-	github.com/spf13/cobra v1.8.1
-	github.com/spf13/pflag v1.0.5
+	github.com/spf13/cobra v1.8.0
 	github.com/spf13/viper v1.13.0
-	github.com/stretchr/testify v1.10.0
-	golang.org/x/mod v0.22.0
-	golang.org/x/sys v0.28.0
+	github.com/stretchr/testify v1.8.4
+	golang.org/x/sys v0.18.0
 	gopkg.in/yaml.v2 v2.4.0
-	helm.sh/helm/v3 v3.17.1
-	k8s.io/api v0.32.1
-	k8s.io/apiextensions-apiserver v0.32.1
-	k8s.io/apimachinery v0.32.1
-	k8s.io/cli-runtime v0.32.1
-	k8s.io/client-go v0.32.1
+	helm.sh/helm/v3 v3.11.1
+	k8s.io/api v0.28.4
+	k8s.io/apiextensions-apiserver v0.28.4
+	k8s.io/apimachinery v0.28.4
+	k8s.io/cli-runtime v0.28.4
+	k8s.io/client-go v0.28.4
 	k8s.io/helm v2.16.10+incompatible
 	sigs.k8s.io/yaml v1.4.0
 )

 require (
-	cel.dev/expr v0.18.0 // indirect
+	github.com/Masterminds/semver/v3 v3.2.0
+	golang.org/x/mod v0.14.0
+)
+
+require (
+	github.com/alphadose/haxmap v1.3.1 // indirect
+	github.com/antlr4-go/antlr/v4 v4.13.0 // indirect
+	github.com/armon/go-metrics v0.4.1 // indirect
+	github.com/boltdb/bolt v1.3.1 // indirect
+	github.com/evanphx/json-patch v5.7.0+incompatible // indirect
+	github.com/go-chi/chi/v5 v5.0.11 // indirect
+	github.com/go-chi/cors v1.2.1 // indirect
+	github.com/hashicorp/go-hclog v1.5.0 // indirect
+	github.com/hashicorp/go-immutable-radix v1.3.1 // indirect
+	github.com/hashicorp/go-msgpack v0.5.5 // indirect
+	github.com/hashicorp/go-msgpack/v2 v2.1.1 // indirect
+	github.com/hashicorp/golang-lru v1.0.2 // indirect
+	github.com/hashicorp/raft v1.4.0 // indirect
+	github.com/hashicorp/raft-boltdb v0.0.0-20230125174641-2a8082862702 // indirect
+	github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0 // indirect
+	github.com/panjf2000/ants/v2 v2.8.1 // indirect
+	github.com/segmentio/asm v1.2.0 // indirect
+	github.com/sourcegraph/conc v0.3.0 // indirect
+	github.com/spiffe/go-spiffe/v2 v2.1.6 // indirect
+	github.com/zeebo/errs v1.3.0 // indirect
+	go.mongodb.org/mongo-driver v1.12.1 // indirect
+	go.opentelemetry.io/otel/metric v1.23.1 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
+	golang.org/x/tools v0.17.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20240116215550-a9fa1716bcac // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240205150955-31a09d347014 // indirect
+)
+
+require (
+	cloud.google.com/go/compute v1.23.3 // indirect
+	cloud.google.com/go/compute/metadata v0.2.3 // indirect
 	contrib.go.opencensus.io/exporter/prometheus v0.4.2 // indirect
-	dario.cat/mergo v1.0.1 // indirect
-	github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 // indirect
-	github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 // indirect
-	github.com/BurntSushi/toml v1.4.0 // indirect
-	github.com/Code-Hex/go-generics-cache v1.3.1 // indirect
+	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
+	github.com/Azure/go-autorest v14.2.0+incompatible // indirect
+	github.com/Azure/go-autorest/autorest/date v0.3.0 // indirect
+	github.com/Azure/go-autorest/logger v0.2.1 // indirect
+	github.com/Azure/go-autorest/tracing v0.6.0 // indirect
+	github.com/BurntSushi/toml v1.2.1 // indirect
 	github.com/MakeNowJust/heredoc v1.0.0 // indirect
 	github.com/Masterminds/goutils v1.1.1 // indirect
-	github.com/Masterminds/sprig/v3 v3.3.0 // indirect
-	github.com/Masterminds/squirrel v1.5.4 // indirect
-	github.com/Microsoft/go-winio v0.6.2 // indirect
+	github.com/Masterminds/semver v1.5.0
+	github.com/Masterminds/sprig/v3 v3.2.3 // indirect
+	github.com/Masterminds/squirrel v1.5.3 // indirect
+	github.com/Microsoft/go-winio v0.6.0 // indirect
+	github.com/Microsoft/hcsshim v0.9.6 // indirect
 	github.com/PuerkitoBio/purell v1.2.1 // indirect
-	github.com/aavaz-ai/pii-scrubber v0.0.0-20220812094047-3fa450ab6973 // indirect
-	github.com/alphadose/haxmap v1.4.0 // indirect
-	github.com/anshal21/go-worker v1.1.0 // indirect
-	github.com/antlr4-go/antlr/v4 v4.13.0 // indirect
+	github.com/andybalholm/brotli v1.0.6 // indirect
 	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/blang/semver/v4 v4.0.0 // indirect
 	github.com/bufbuild/protocompile v0.6.0 // indirect
-	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cenkalti/backoff/v4 v4.2.1 // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/chai2010/gettext-go v1.0.2 // indirect
 	github.com/chebyrash/promise v0.0.0-20230709133807-42ec49ba1459 // indirect
 	github.com/cloudevents/sdk-go/binding/format/protobuf/v2 v2.14.0 // indirect
-	github.com/cloudevents/sdk-go/v2 v2.15.2 // indirect
-	github.com/containerd/containerd v1.7.24 // indirect
-	github.com/containerd/errdefs v0.3.0 // indirect
-	github.com/containerd/log v0.1.0 // indirect
-	github.com/containerd/platforms v0.2.1 // indirect
-	github.com/cyphar/filepath-securejoin v0.3.6 // indirect
-	github.com/dapr/components-contrib v1.15.0-rc.1.0.20241216170750-aca5116d95c9 // indirect
-	github.com/dapr/durabletask-go v0.5.1-0.20241216172832-16da3e7c3530 // indirect
+	github.com/cloudevents/sdk-go/v2 v2.14.0 // indirect
+	github.com/containerd/containerd v1.6.18 // indirect
+	github.com/containerd/continuity v0.3.0 // indirect
+	github.com/cyphar/filepath-securejoin v0.2.4 // indirect
+	github.com/dapr/components-contrib v1.13.0-rc.4 // indirect
+	github.com/dapr/kit v0.13.0
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
-	github.com/distribution/reference v0.6.0 // indirect
-	github.com/dlclark/regexp2 v1.10.0 // indirect
-	github.com/docker/cli v25.0.1+incompatible // indirect
-	github.com/docker/distribution v2.8.3+incompatible // indirect
+	github.com/docker/cli v20.10.21+incompatible // indirect
+	github.com/docker/distribution v2.8.1+incompatible // indirect
 	github.com/docker/docker-credential-helpers v0.7.0 // indirect
-	github.com/docker/go-connections v0.5.0 // indirect
+	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-metrics v0.0.1 // indirect
-	github.com/docker/go-units v0.5.0 // indirect
+	github.com/docker/go-units v0.4.0 // indirect
 	github.com/emicklei/go-restful/v3 v3.11.0 // indirect
-	github.com/evanphx/json-patch v5.9.0+incompatible // indirect
-	github.com/exponent-io/jsonpath v0.0.0-20210407135951-1de76d718b3f // indirect
-	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/evanphx/json-patch/v5 v5.8.1
+	github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d // indirect
 	github.com/fsnotify/fsnotify v1.7.0 // indirect
-	github.com/fxamacker/cbor/v2 v2.7.0 // indirect
 	github.com/ghodss/yaml v1.0.1-0.20190212211648-25d852aebe32 // indirect
-	github.com/go-chi/chi/v5 v5.1.0 // indirect
-	github.com/go-chi/cors v1.2.1 // indirect
 	github.com/go-errors/errors v1.4.2 // indirect
-	github.com/go-gorp/gorp/v3 v3.1.0 // indirect
+	github.com/go-gorp/gorp/v3 v3.0.2 // indirect
 	github.com/go-kit/log v0.2.1 // indirect
-	github.com/go-logfmt/logfmt v0.6.0 // indirect
-	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/go-logfmt/logfmt v0.5.1 // indirect
+	github.com/go-logr/logr v1.4.1 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
-	github.com/go-openapi/jsonpointer v0.21.0 // indirect
+	github.com/go-openapi/jsonpointer v0.20.0 // indirect
 	github.com/go-openapi/jsonreference v0.20.2 // indirect
-	github.com/go-openapi/swag v0.23.0 // indirect
+	github.com/go-openapi/swag v0.22.4 // indirect
 	github.com/gobwas/glob v0.2.3 // indirect
 	github.com/goccy/go-json v0.10.2 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang-jwt/jwt/v4 v4.5.0 // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/golang/protobuf v1.5.4 // indirect
-	github.com/google/btree v1.1.3 // indirect
-	github.com/google/cel-go v0.22.0 // indirect
-	github.com/google/gnostic-models v0.6.8 // indirect
+	github.com/golang/mock v1.6.0 // indirect
+	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/google/btree v1.1.2 // indirect
+	github.com/google/cel-go v0.18.2 // indirect
+	github.com/google/gnostic v0.6.9 // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/google/gofuzz v1.2.0 // indirect
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/mux v1.8.1 // indirect
-	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/gosuri/uitable v0.0.4 // indirect
 	github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 // indirect
 	github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 // indirect
-	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0 // indirect
 	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
-	github.com/hashicorp/go-multierror v1.1.1 // indirect
 	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
-	github.com/huandu/xstrings v1.5.0 // indirect
+	github.com/huandu/xstrings v1.3.3 // indirect
+	github.com/imdario/mergo v0.3.16 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/jhump/protoreflect v1.15.3 // indirect
-	github.com/jmoiron/sqlx v1.4.0 // indirect
+	github.com/jhump/protoreflect v1.15.2 // indirect
+	github.com/jmoiron/sqlx v1.3.5 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/compress v1.17.10 // indirect
+	github.com/klauspost/compress v1.17.4 // indirect
+	github.com/kolesnikovae/go-winjob v1.0.0
 	github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 // indirect
 	github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 // indirect
 	github.com/lestrrat-go/blackmagic v1.0.2 // indirect
 	github.com/lestrrat-go/httpcc v1.0.1 // indirect
-	github.com/lestrrat-go/httprc v1.0.5 // indirect
+	github.com/lestrrat-go/httprc v1.0.4 // indirect
 	github.com/lestrrat-go/iter v1.0.2 // indirect
-	github.com/lestrrat-go/jwx/v2 v2.0.21 // indirect
+	github.com/lestrrat-go/jwx/v2 v2.0.19 // indirect
 	github.com/lestrrat-go/option v1.0.1 // indirect
-	github.com/lib/pq v1.10.9 // indirect
+	github.com/lib/pq v1.10.7 // indirect
 	github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de // indirect
-	github.com/magiconair/properties v1.8.7 // indirect
+	github.com/magiconair/properties v1.8.6 // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
 	github.com/marusama/semaphore/v2 v2.5.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.9 // indirect
+	github.com/microsoft/durabletask-go v0.4.1-0.20240122160106-fb5c4c05729d // indirect
 	github.com/mitchellh/copystructure v1.2.0 // indirect
-	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
+	github.com/mitchellh/go-wordwrap v1.0.0 // indirect
 	github.com/mitchellh/mapstructure v1.5.1-0.20220423185008-bf980b35cac4 // indirect
 	github.com/mitchellh/reflectwalk v1.0.2 // indirect
 	github.com/moby/locker v1.0.1 // indirect
-	github.com/moby/spdystream v0.5.0 // indirect
-	github.com/moby/term v0.5.0 // indirect
+	github.com/moby/spdystream v0.2.0 // indirect
+	github.com/moby/term v0.0.0-20221205130635-1aeaba878587 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 // indirect
+	github.com/morikuni/aec v1.0.0 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
-	github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f // indirect
 	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.1.0 // indirect
+	github.com/opencontainers/image-spec v1.1.0-rc2 // indirect
+	github.com/opencontainers/runc v1.1.12 // indirect
 	github.com/openzipkin/zipkin-go v0.4.2 // indirect
-	github.com/panjf2000/ants/v2 v2.8.1 // indirect
 	github.com/pelletier/go-toml v1.9.5 // indirect
-	github.com/pelletier/go-toml/v2 v2.0.9 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.6 // indirect
 	github.com/peterbourgon/diskv v2.0.1+incompatible // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/pkoukk/tiktoken-go v0.1.6 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
-	github.com/prometheus/client_golang v1.20.4 // indirect
-	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.59.1 // indirect
-	github.com/prometheus/procfs v0.15.1 // indirect
+	github.com/prometheus/client_golang v1.17.0 // indirect
+	github.com/prometheus/client_model v0.5.0 // indirect
+	github.com/prometheus/common v0.45.0 // indirect
+	github.com/prometheus/procfs v0.12.0 // indirect
 	github.com/prometheus/statsd_exporter v0.22.7 // indirect
-	github.com/rubenv/sql-migrate v1.7.1 // indirect
+	github.com/rubenv/sql-migrate v1.2.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/segmentio/asm v1.2.0 // indirect
-	github.com/shopspring/decimal v1.4.0 // indirect
+	github.com/shopspring/decimal v1.2.0 // indirect
 	github.com/sirupsen/logrus v1.9.3 // indirect
 	github.com/sony/gobreaker v0.5.0 // indirect
-	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/spf13/afero v1.8.2 // indirect
-	github.com/spf13/cast v1.7.0 // indirect
+	github.com/spf13/cast v1.6.0 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
-	github.com/spiffe/go-spiffe/v2 v2.1.7 // indirect
-	github.com/stoewer/go-strcase v1.3.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/stoewer/go-strcase v1.2.0 // indirect
+	github.com/stretchr/objx v0.5.0 // indirect
 	github.com/subosito/gotenv v1.4.1 // indirect
 	github.com/tidwall/transform v0.0.0-20201103190739-32f242e2dbde // indirect
-	github.com/tklauser/go-sysconf v0.3.12 // indirect
-	github.com/tklauser/numcpus v0.6.1 // indirect
-	github.com/tmc/langchaingo v0.1.12 // indirect
-	github.com/x448/float16 v0.8.4 // indirect
+	github.com/tklauser/go-sysconf v0.3.10 // indirect
+	github.com/tklauser/numcpus v0.4.0 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasthttp v1.51.0 // indirect
 	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
 	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
 	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
 	github.com/xlab/treeprint v1.2.0 // indirect
-	github.com/yusufpapurcu/wmi v1.2.3 // indirect
-	github.com/zeebo/errs v1.3.0 // indirect
-	go.mongodb.org/mongo-driver v1.14.0 // indirect
+	github.com/yusufpapurcu/wmi v1.2.2 // indirect
 	go.opencensus.io v0.24.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 // indirect
-	go.opentelemetry.io/otel v1.32.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.30.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.30.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.26.0 // indirect
-	go.opentelemetry.io/otel/exporters/zipkin v1.26.0 // indirect
-	go.opentelemetry.io/otel/metric v1.32.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.30.0 // indirect
-	go.opentelemetry.io/otel/trace v1.32.0 // indirect
-	go.opentelemetry.io/proto/otlp v1.3.1 // indirect
-	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/crypto v0.31.0 // indirect
-	golang.org/x/exp v0.0.0-20241204233417-43b7b7cde48d // indirect
-	golang.org/x/net v0.33.0 // indirect
-	golang.org/x/oauth2 v0.23.0 // indirect
-	golang.org/x/sync v0.10.0 // indirect
-	golang.org/x/term v0.27.0 // indirect
-	golang.org/x/text v0.21.0 // indirect
-	golang.org/x/time v0.7.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20240924160255-9d4c2d233b61 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20241202173237-19429a94021a // indirect
-	google.golang.org/grpc v1.68.1 // indirect
-	google.golang.org/protobuf v1.35.2 // indirect
-	gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect
+	go.opentelemetry.io/otel v1.23.1 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.21.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.21.0 // indirect
+	go.opentelemetry.io/otel/exporters/zipkin v1.21.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.21.0 // indirect
+	go.opentelemetry.io/otel/trace v1.23.1 // indirect
+	go.opentelemetry.io/proto/otlp v1.0.0 // indirect
+	go.starlark.net v0.0.0-20230525235612-a134d8f9ddca // indirect
+	golang.org/x/crypto v0.21.0 // indirect
+	golang.org/x/exp v0.0.0-20240119083558-1b970713d09a // indirect
+	golang.org/x/net v0.23.0 // indirect
+	golang.org/x/oauth2 v0.16.0 // indirect
+	golang.org/x/sync v0.6.0 // indirect
+	golang.org/x/term v0.18.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	golang.org/x/time v0.3.0 // indirect
+	gomodules.xyz/jsonpatch/v2 v2.4.0 // indirect
+	google.golang.org/appengine v1.6.8 // indirect
+	google.golang.org/grpc v1.61.0 // indirect
+	google.golang.org/protobuf v1.32.0 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	k8s.io/apiserver v0.32.1 // indirect
-	k8s.io/component-base v0.32.1 // indirect
-	k8s.io/klog/v2 v2.130.1 // indirect
-	k8s.io/kube-openapi v0.0.0-20241105132330-32ad38e42d3f // indirect
-	k8s.io/kubectl v0.32.1 // indirect
-	k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738 // indirect
-	oras.land/oras-go v1.2.5 // indirect
-	sigs.k8s.io/controller-runtime v0.19.0 // indirect
-	sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 // indirect
-	sigs.k8s.io/kustomize/api v0.18.0 // indirect
-	sigs.k8s.io/kustomize/kyaml v0.18.1 // indirect
-	sigs.k8s.io/structured-merge-diff/v4 v4.4.2 // indirect
+	k8s.io/apiserver v0.28.4 // indirect
+	k8s.io/component-base v0.28.4 // indirect
+	k8s.io/klog/v2 v2.110.1 // indirect
+	k8s.io/kube-openapi v0.0.0-20231113174909-778a5567bc1e // indirect
+	k8s.io/kubectl v0.26.0 // indirect
+	k8s.io/utils v0.0.0-20240102154912-e7106e64919e // indirect
+	oras.land/oras-go v1.2.2 // indirect
+	sigs.k8s.io/controller-runtime v0.16.3 // indirect
+	sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect
+	sigs.k8s.io/kustomize/api v0.15.0 // indirect
+	sigs.k8s.io/kustomize/kyaml v0.15.0 // indirect
+	sigs.k8s.io/structured-merge-diff/v4 v4.4.1 // indirect
+)
+
+replace (
+	github.com/Azure/go-autorest => github.com/Azure/go-autorest v14.2.0+incompatible
+	github.com/docker/docker => github.com/moby/moby v17.12.0-ce-rc1.0.20200618181300-9dc6525e6118+incompatible
+	github.com/russross/blackfriday => github.com/russross/blackfriday v1.5.2
+	k8s.io/api => k8s.io/api v0.25.2
+	k8s.io/apimachinery => k8s.io/apimachinery v0.25.2
+	k8s.io/cli-runtime => k8s.io/cli-runtime v0.25.2
+	k8s.io/client => github.com/kubernetes-client/go v0.0.0-20190928040339-c757968c4c36
+	k8s.io/client-go => k8s.io/client-go v0.25.2
+	k8s.io/kube-openapi => k8s.io/kube-openapi v0.0.0-20221012153701-172d655c2280
+	sigs.k8s.io/kustomize/api => sigs.k8s.io/kustomize/api v0.12.1
+	sigs.k8s.io/kustomize/kyaml => sigs.k8s.io/kustomize/kyaml v0.13.9
 )
--- a/go.sum
+++ b/go.sum
--- a/pkg/kubernetes/annotator.go
+++ b/pkg/kubernetes/annotator.go
@ -55,8 +55,8 @@ const (
 	daprReadinessProbeThresholdKey      = "dapr.io/sidecar-readiness-probe-threshold"
 	daprImageKey                        = "dapr.io/sidecar-image"
 	daprAppSSLKey                       = "dapr.io/app-ssl"
-	daprMaxRequestBodySizeKey           = "dapr.io/max-body-size"
-	daprReadBufferSizeKey               = "dapr.io/read-buffer-size"
+	daprMaxRequestBodySizeKey           = "dapr.io/http-max-request-size"
+	daprReadBufferSizeKey               = "dapr.io/http-read-buffer-size"
 	daprHTTPStreamRequestBodyKey        = "dapr.io/http-stream-request-body"
 	daprGracefulShutdownSecondsKey      = "dapr.io/graceful-shutdown-seconds"
 	daprEnableAPILoggingKey             = "dapr.io/enable-api-logging"
--- a/pkg/kubernetes/annotator_test.go
+++ b/pkg/kubernetes/annotator_test.go
@ -292,6 +292,7 @@ func TestAnnotate(t *testing.T) {
 			var out bytes.Buffer
 			in := []io.Reader{inputFile}
 			for i, annotation := range tt.annotations {
+				annotation := annotation
 				annotator := NewK8sAnnotator(K8sAnnotatorConfig{
 					TargetResource:  &annotation.targetResource,
 					TargetNamespace: &annotation.targetNamespace,
@ -333,7 +334,7 @@ func TestAnnotate(t *testing.T) {

 			for i := range expectedDocs {
 				if tt.printOutput {
-					t.Logf(outDocs[i]) //nolint:govet
+					t.Logf(outDocs[i])
 				}
 				assert.YAMLEq(t, expectedDocs[i], outDocs[i])
 			}
--- a/pkg/kubernetes/components_test.go
+++ b/pkg/kubernetes/components_test.go
@ -15,7 +15,7 @@ package kubernetes

 import (
 	"bytes"
-	"errors"
+	"fmt"
 	"testing"

 	"github.com/stretchr/testify/assert"
@ -242,7 +242,7 @@ func TestComponents(t *testing.T) {
 			err := writeComponents(&buff,
 				func() (*v1alpha1.ComponentList, error) {
 					if len(tc.errString) > 0 {
-						return nil, errors.New(tc.errString)
+						return nil, fmt.Errorf(tc.errString)
 					}

 					return &v1alpha1.ComponentList{Items: tc.k8sConfig}, nil
--- a/pkg/kubernetes/configuration.go
+++ b/pkg/kubernetes/configuration.go
@ -43,7 +43,7 @@ func GetDaprControlPlaneCurrentConfig() (*v1alpha1.Configuration, error) {
 	if err != nil {
 		return nil, err
 	}
-	output, err := utils.RunCmdAndWait("kubectl", "get", "configurations.dapr.io/daprsystem", "-n", namespace, "-o", "json")
+	output, err := utils.RunCmdAndWait("kubectl", "get", "configurations/daprsystem", "-n", namespace, "-o", "json")
 	if err != nil {
 		return nil, err
 	}
--- a/pkg/kubernetes/configurations_test.go
+++ b/pkg/kubernetes/configurations_test.go
@ -15,7 +15,7 @@ package kubernetes

 import (
 	"bytes"
-	"errors"
+	"fmt"
 	"testing"

 	"github.com/stretchr/testify/assert"
@ -221,7 +221,7 @@ func TestConfigurations(t *testing.T) {
 			err := writeConfigurations(&buff,
 				func() (*v1alpha1.ConfigurationList, error) {
 					if len(tc.errString) > 0 {
-						return nil, errors.New(tc.errString)
+						return nil, fmt.Errorf(tc.errString)
 					}

 					return &v1alpha1.ConfigurationList{Items: tc.k8sConfig}, nil
--- a/pkg/kubernetes/kubernetes.go
+++ b/pkg/kubernetes/kubernetes.go
@ -249,10 +249,10 @@ func daprChartValues(config InitConfiguration, version string) (map[string]inter
 	helmVals := []string{
 		fmt.Sprintf("global.ha.enabled=%t", config.EnableHA),
 		fmt.Sprintf("global.mtls.enabled=%t", config.EnableMTLS),
-		"global.tag=" + utils.GetVariantVersion(version, config.ImageVariant),
+		fmt.Sprintf("global.tag=%s", utils.GetVariantVersion(version, config.ImageVariant)),
 	}
 	if len(config.ImageRegistryURI) != 0 {
-		helmVals = append(helmVals, "global.registry="+config.ImageRegistryURI)
+		helmVals = append(helmVals, fmt.Sprintf("global.registry=%s", config.ImageRegistryURI))
 	}
 	helmVals = append(helmVals, config.Args...)

@ -265,9 +265,9 @@ func daprChartValues(config InitConfiguration, version string) (map[string]inter
 		if err != nil {
 			return nil, err
 		}
-		helmVals = append(helmVals, "dapr_sentry.tls.root.certPEM="+string(rootCertBytes),
-			"dapr_sentry.tls.issuer.certPEM="+string(issuerCertBytes),
-			"dapr_sentry.tls.issuer.keyPEM="+string(issuerKeyBytes),
+		helmVals = append(helmVals, fmt.Sprintf("dapr_sentry.tls.root.certPEM=%s", string(rootCertBytes)),
+			fmt.Sprintf("dapr_sentry.tls.issuer.certPEM=%s", string(issuerCertBytes)),
+			fmt.Sprintf("dapr_sentry.tls.issuer.keyPEM=%s", string(issuerKeyBytes)),
 		)
 	}

@ -301,7 +301,7 @@ func install(releaseName, releaseVersion, helmRepo string, config InitConfigurat
 	}

 	if releaseName == daprReleaseName {
-		err = applyCRDs("v" + version)
+		err = applyCRDs(fmt.Sprintf("v%s", version))
 		if err != nil {
 			return err
 		}
@ -311,7 +311,7 @@ func install(releaseName, releaseVersion, helmRepo string, config InitConfigurat
 	installClient.ReleaseName = releaseName
 	installClient.Namespace = config.Namespace
 	installClient.Wait = config.Wait
-	installClient.Timeout = time.Duration(config.Timeout) * time.Second //nolint:gosec
+	installClient.Timeout = time.Duration(config.Timeout) * time.Second

 	values, err := daprChartValues(config, version)
 	if err != nil {
@ -340,7 +340,7 @@ func installThirdParty(releaseName, chartName, releaseVersion, helmRepo string,
 	installClient.ReleaseName = releaseName
 	installClient.Namespace = thirdPartyDevNamespace
 	installClient.Wait = config.Wait
-	installClient.Timeout = time.Duration(config.Timeout) * time.Second //nolint:gosec
+	installClient.Timeout = time.Duration(config.Timeout) * time.Second

 	values := map[string]interface{}{}

--- a/pkg/kubernetes/pods_test.go
+++ b/pkg/kubernetes/pods_test.go
@ -28,9 +28,9 @@ func TestListPodsInterface(t *testing.T) {
 		output, err := ListPodsInterface(k8s, map[string]string{
 			"test": "test",
 		})
-		assert.NoError(t, err, "unexpected error")
+		assert.Nil(t, err, "unexpected error")
 		assert.NotNil(t, output, "Expected empty list")
-		assert.Empty(t, output.Items, "Expected length 0")
+		assert.Equal(t, 0, len(output.Items), "Expected length 0")
 	})
 	t.Run("one matching pod", func(t *testing.T) {
 		k8s := fake.NewSimpleClientset((&v1.Pod{
@ -46,9 +46,9 @@ func TestListPodsInterface(t *testing.T) {
 		output, err := ListPodsInterface(k8s, map[string]string{
 			"test": "test",
 		})
-		assert.NoError(t, err, "unexpected error")
+		assert.Nil(t, err, "unexpected error")
 		assert.NotNil(t, output, "Expected non empty list")
-		assert.Len(t, output.Items, 1, "Expected length 0")
+		assert.Equal(t, 1, len(output.Items), "Expected length 0")
 		assert.Equal(t, "test", output.Items[0].Name, "expected name to match")
 		assert.Equal(t, "test", output.Items[0].Namespace, "expected namespace to match")
 	})
--- a/pkg/kubernetes/portforward.go
+++ b/pkg/kubernetes/portforward.go
@ -14,7 +14,6 @@ limitations under the License.
 package kubernetes

 import (
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
@ -134,7 +133,7 @@ func (pf *PortForward) Init() error {
 			return fmt.Errorf("can not get the local and remote ports: %w", err)
 		}
 		if len(ports) == 0 {
-			return errors.New("can not get the local and remote ports: error getting ports length")
+			return fmt.Errorf("can not get the local and remote ports: error getting ports length")
 		}

 		pf.LocalPort = int(ports[0].Local)
--- a/pkg/kubernetes/renew_certificate.go
+++ b/pkg/kubernetes/renew_certificate.go
@ -121,7 +121,7 @@ func renewCertificate(rootCert, issuerCert, issuerKey []byte, timeout uint, imag
 	// Reuse the existing helm configuration values i.e. tags, registry, etc.
 	upgradeClient.ReuseValues = true
 	upgradeClient.Wait = true
-	upgradeClient.Timeout = time.Duration(timeout) * time.Second //nolint:gosec
+	upgradeClient.Timeout = time.Duration(timeout) * time.Second
 	upgradeClient.Namespace = status[0].Namespace

 	// Override the helm configuration values with the new certificates.
@ -146,12 +146,12 @@ func createHelmParamsForNewCertificates(ca, issuerCert, issuerKey string) (map[s
 	args := []string{}

 	if ca != "" && issuerCert != "" && issuerKey != "" {
-		args = append(args, "dapr_sentry.tls.root.certPEM="+ca,
-			"dapr_sentry.tls.issuer.certPEM="+issuerCert,
-			"dapr_sentry.tls.issuer.keyPEM="+issuerKey,
+		args = append(args, fmt.Sprintf("dapr_sentry.tls.root.certPEM=%s", ca),
+			fmt.Sprintf("dapr_sentry.tls.issuer.certPEM=%s", issuerCert),
+			fmt.Sprintf("dapr_sentry.tls.issuer.keyPEM=%s", issuerKey),
 		)
 	} else {
-		return nil, errors.New("parameters not found")
+		return nil, fmt.Errorf("parameters not found")
 	}

 	for _, v := range args {
--- a/pkg/kubernetes/run.go
+++ b/pkg/kubernetes/run.go
@ -297,7 +297,7 @@ func createDeploymentConfig(client versioned.Interface, app runfileconfig.App) d
 						Name:            app.AppID,
 						Image:           app.ContainerImage,
 						Env:             getEnv(app),
-						ImagePullPolicy: corev1.PullPolicy(app.ContainerImagePullPolicy),
+						ImagePullPolicy: corev1.PullAlways,
 					},
 				},
 			},
@ -317,7 +317,7 @@ func createDeploymentConfig(client versioned.Interface, app runfileconfig.App) d
 	if app.AppPort != 0 {
 		dep.Spec.Template.Spec.Containers[0].Ports = []corev1.ContainerPort{
 			{
-				ContainerPort: int32(app.AppPort), //nolint:gosec
+				ContainerPort: int32(app.AppPort),
 			},
 		}
 	}
--- a/pkg/kubernetes/status.go
+++ b/pkg/kubernetes/status.go
@ -65,6 +65,7 @@ func NewStatusClient() (*StatusClient, error) {

 // List status for Dapr resources.
 func (s *StatusClient) Status() ([]StatusOutput, error) {
+	//nolint
 	client := s.client
 	if client == nil {
 		return nil, errors.New("kubernetes client not initialized")
--- a/pkg/kubernetes/status_test.go
+++ b/pkg/kubernetes/status_test.go
@ -83,7 +83,7 @@ func TestStatus(t *testing.T) {
 		if err != nil {
 			t.Fatalf("%s status should not raise an error", err.Error())
 		}
-		assert.Empty(t, status, "Expected status to be empty list")
+		assert.Equal(t, 0, len(status), "Expected status to be empty list")
 	})

 	t.Run("one status waiting", func(t *testing.T) {
@ -102,8 +102,8 @@ func TestStatus(t *testing.T) {
 		}
 		k8s := newTestSimpleK8s(newDaprControlPlanePod(pd))
 		status, err := k8s.Status()
-		assert.NoError(t, err, "status should not raise an error")
-		assert.Len(t, status, 1, "Expected status to be non-empty list")
+		assert.Nil(t, err, "status should not raise an error")
+		assert.Equal(t, 1, len(status), "Expected status to be non-empty list")
 		stat := status[0]
 		assert.Equal(t, "dapr-dashboard", stat.Name, "expected name to match")
 		assert.Equal(t, "dapr-system", stat.Namespace, "expected namespace to match")
@ -131,8 +131,8 @@ func TestStatus(t *testing.T) {
 		}
 		k8s := newTestSimpleK8s(newDaprControlPlanePod(pd))
 		status, err := k8s.Status()
-		assert.NoError(t, err, "status should not raise an error")
-		assert.Len(t, status, 1, "Expected status to be non-empty list")
+		assert.Nil(t, err, "status should not raise an error")
+		assert.Equal(t, 1, len(status), "Expected status to be non-empty list")
 		stat := status[0]
 		assert.Equal(t, "dapr-dashboard", stat.Name, "expected name to match")
 		assert.Equal(t, "dapr-system", stat.Namespace, "expected namespace to match")
@ -140,7 +140,7 @@ func TestStatus(t *testing.T) {
 		assert.Equal(t, "0.0.1", stat.Version, "expected version to match")
 		assert.Equal(t, 1, stat.Replicas, "expected replicas to match")
 		assert.Equal(t, "True", stat.Healthy, "expected health to match")
-		assert.Equal(t, "Running", stat.Status, "expected running status")
+		assert.Equal(t, stat.Status, "Running", "expected running status")
 	})

 	t.Run("one status terminated", func(t *testing.T) {
@ -160,8 +160,8 @@ func TestStatus(t *testing.T) {
 		k8s := newTestSimpleK8s(newDaprControlPlanePod(pd))

 		status, err := k8s.Status()
-		assert.NoError(t, err, "status should not raise an error")
-		assert.Len(t, status, 1, "Expected status to be non-empty list")
+		assert.Nil(t, err, "status should not raise an error")
+		assert.Equal(t, 1, len(status), "Expected status to be non-empty list")
 		stat := status[0]
 		assert.Equal(t, "dapr-dashboard", stat.Name, "expected name to match")
 		assert.Equal(t, "dapr-system", stat.Namespace, "expected namespace to match")
@ -169,7 +169,7 @@ func TestStatus(t *testing.T) {
 		assert.Equal(t, "0.0.1", stat.Version, "expected version to match")
 		assert.Equal(t, 1, stat.Replicas, "expected replicas to match")
 		assert.Equal(t, "False", stat.Healthy, "expected health to match")
-		assert.Equal(t, "Terminated", stat.Status, "expected terminated status")
+		assert.Equal(t, stat.Status, "Terminated", "expected terminated status")
 	})

 	t.Run("one status pending", func(t *testing.T) {
@ -193,8 +193,8 @@ func TestStatus(t *testing.T) {

 		k8s := newTestSimpleK8s(pod)
 		status, err := k8s.Status()
-		assert.NoError(t, err, "status should not raise an error")
-		assert.Len(t, status, 1, "Expected status to be non-empty list")
+		assert.Nil(t, err, "status should not raise an error")
+		assert.Equal(t, 1, len(status), "Expected status to be non-empty list")
 		stat := status[0]
 		assert.Equal(t, "dapr-dashboard", stat.Name, "expected name to match")
 		assert.Equal(t, "dapr-system", stat.Namespace, "expected namespace to match")
@ -202,13 +202,13 @@ func TestStatus(t *testing.T) {
 		assert.Equal(t, "0.0.1", stat.Version, "expected version to match")
 		assert.Equal(t, 1, stat.Replicas, "expected replicas to match")
 		assert.Equal(t, "False", stat.Healthy, "expected health to match")
-		assert.Equal(t, "Pending", stat.Status, "expected pending status")
+		assert.Equal(t, stat.Status, "Pending", "expected pending status")
 	})

 	t.Run("one status empty client", func(t *testing.T) {
 		k8s := &StatusClient{}
 		status, err := k8s.Status()
-		assert.Error(t, err, "status should raise an error")
+		assert.NotNil(t, err, "status should raise an error")
 		assert.Equal(t, "kubernetes client not initialized", err.Error(), "expected errors to match")
 		assert.Nil(t, status, "expected nil for status")
 	})
@ -263,7 +263,7 @@ func TestControlPlaneServices(t *testing.T) {

 	k8s := newTestSimpleK8s(runtimeObj...)
 	status, err := k8s.Status()
-	assert.NoError(t, err, "status should not raise an error")
+	assert.Nil(t, err, "status should not raise an error")

 	assert.Equal(t, len(expectedReplicas), len(status), "Expected status to be empty list")

@ -305,8 +305,8 @@ func TestControlPlaneVersion(t *testing.T) {
 		pd.imageURI = tc.imageURI
 		k8s := newTestSimpleK8s(newDaprControlPlanePod(pd))
 		status, err := k8s.Status()
-		assert.NoError(t, err, "status should not raise an error")
-		assert.Len(t, status, 1, "Expected status to be non-empty list")
+		assert.Nil(t, err, "status should not raise an error")
+		assert.Equal(t, 1, len(status), "Expected status to be non-empty list")
 		stat := status[0]
 		assert.Equal(t, tc.expectedVersion, stat.Version, "expected version to match")
 	}
--- a/pkg/kubernetes/uninstall.go
+++ b/pkg/kubernetes/uninstall.go
@ -41,7 +41,7 @@ func Uninstall(namespace string, uninstallAll bool, uninstallDev bool, timeout u
 	}

 	uninstallClient := helm.NewUninstall(config)
-	uninstallClient.Timeout = time.Duration(timeout) * time.Second //nolint:gosec
+	uninstallClient.Timeout = time.Duration(timeout) * time.Second

 	// Uninstall Dashboard as a best effort.
 	// Chart versions < 1.11 for Dapr will delete dashboard as part of the main chart.
--- a/pkg/kubernetes/upgrade.go
+++ b/pkg/kubernetes/upgrade.go
@ -14,22 +14,16 @@ limitations under the License.
 package kubernetes

 import (
-	"context"
-	"errors"
 	"fmt"
 	"net/http"
 	"os"
-	"strings"
 	"time"

 	helm "helm.sh/helm/v3/pkg/action"
 	"helm.sh/helm/v3/pkg/chart"
 	"helm.sh/helm/v3/pkg/release"
-	core_v1 "k8s.io/api/core/v1"
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/helm/pkg/strvals"

-	"github.com/Masterminds/semver/v3"
 	"github.com/hashicorp/go-version"

 	"github.com/dapr/cli/pkg/print"
@ -54,8 +48,6 @@ var crdsFullResources = []string{
 	"httpendpoints.dapr.io",
 }

-var versionWithHAScheduler = semver.MustParse("1.15.0-rc.1")
-
 type UpgradeConfig struct {
 	RuntimeVersion   string
 	DashboardVersion string
@ -119,7 +111,7 @@ func Upgrade(conf UpgradeConfig) error {
 	if !hasDashboardInDaprChart && willHaveDashboardInDaprChart && dashboardExists {
 		print.InfoStatusEvent(os.Stdout, "Dashboard being uninstalled prior to Dapr control plane upgrade...")
 		uninstallClient := helm.NewUninstall(helmConf)
-		uninstallClient.Timeout = time.Duration(conf.Timeout) * time.Second //nolint:gosec
+		uninstallClient.Timeout = time.Duration(conf.Timeout) * time.Second

 		_, err = uninstallClient.Run(dashboardReleaseName)
 		if err != nil {
@ -164,42 +156,13 @@ func Upgrade(conf UpgradeConfig) error {
 		return err
 	}

-	// used to signal the deletion of the scheduler pods only when downgrading from 1.15 to previous versions to handle incompatible changes
-	// in other cases the channel should be nil
-	var downgradeDeletionChan chan error
-
 	if !isDowngrade(conf.RuntimeVersion, daprVersion) {
-		err = applyCRDs("v" + conf.RuntimeVersion)
+		err = applyCRDs(fmt.Sprintf("v%s", conf.RuntimeVersion))
 		if err != nil {
 			return fmt.Errorf("unable to apply CRDs: %w", err)
 		}
 	} else {
 		print.InfoStatusEvent(os.Stdout, "Downgrade detected, skipping CRDs.")
-
-		targetVersion, errVersion := semver.NewVersion(conf.RuntimeVersion)
-		if errVersion != nil {
-			return fmt.Errorf("unable to parse dapr target version: %w", errVersion)
-		}
-
-		currentVersion, errVersion := semver.NewVersion(daprVersion)
-		if errVersion != nil {
-			return fmt.Errorf("unable to parse dapr current version: %w", errVersion)
-		}
-
-		if currentVersion.GreaterThanEqual(versionWithHAScheduler) && targetVersion.LessThan(versionWithHAScheduler) {
-			downgradeDeletionChan = make(chan error)
-			// Must delete all scheduler pods from cluster due to incompatible changes in version 1.15 with older versions.
-			go func() {
-				// Add an artificial delay to allow helm upgrade to progress and delete the pods only when necessary.
-				time.Sleep(15 * time.Second)
-				errDeletion := deleteSchedulerPods(status[0].Namespace, currentVersion, targetVersion)
-				if errDeletion != nil {
-					downgradeDeletionChan <- fmt.Errorf("failed to delete scheduler pods: %w", errDeletion)
-					print.FailureStatusEvent(os.Stderr, "Failed to delete scheduler pods: "+errDeletion.Error())
-				}
-				close(downgradeDeletionChan)
-			}()
-		}
 	}

 	chart, err := GetDaprHelmChartName(helmConf)
@ -216,15 +179,6 @@ func Upgrade(conf UpgradeConfig) error {
 		return fmt.Errorf("failure while running upgrade: %w", err)
 	}

-	// wait for the deletion of the scheduler pods to finish
-	if downgradeDeletionChan != nil {
-		select {
-		case <-downgradeDeletionChan:
-		case <-time.After(3 * time.Minute):
-			return errors.New("timed out waiting for downgrade deletion")
-		}
-	}
-
 	if dashboardChart != nil {
 		if dashboardExists {
 			if _, err = upgradeClient.Run(dashboardReleaseName, dashboardChart, vals); err != nil {
@ -247,73 +201,6 @@ func Upgrade(conf UpgradeConfig) error {
 	return nil
 }

-func deleteSchedulerPods(namespace string, currentVersion *semver.Version, targetVersion *semver.Version) error {
-	ctxWithTimeout, cancel := context.WithTimeout(context.Background(), time.Second*30)
-	defer cancel()
-
-	var pods *core_v1.PodList
-
-	// wait for at least one pod of the target version to be in the list before deleting the rest
-	// check the label app.kubernetes.io/version to determine the version of the pod
-	foundTargetVersion := false
-	for {
-		if foundTargetVersion {
-			break
-		}
-		k8sClient, err := Client()
-		if err != nil {
-			return err
-		}
-
-		pods, err = k8sClient.CoreV1().Pods(namespace).List(ctxWithTimeout, meta_v1.ListOptions{
-			LabelSelector: "app=dapr-scheduler-server",
-		})
-		if err != nil && !errors.Is(err, context.DeadlineExceeded) {
-			return err
-		}
-
-		if len(pods.Items) == 0 {
-			return nil
-		}
-
-		for _, pod := range pods.Items {
-			pv, ok := pod.Labels["app.kubernetes.io/version"]
-			if ok {
-				podVersion, err := semver.NewVersion(pv)
-				if err == nil && podVersion.Equal(targetVersion) {
-					foundTargetVersion = true
-					break
-				}
-			}
-		}
-		time.Sleep(5 * time.Second)
-	}
-
-	if pods == nil {
-		return errors.New("no scheduler pods found")
-	}
-
-	// get a fresh client to ensure we have the latest state of the cluster
-	k8sClient, err := Client()
-	if err != nil {
-		return err
-	}
-
-	// delete scheduler pods of the current version, i.e. >1.15.0
-	for _, pod := range pods.Items {
-		if pv, ok := pod.Labels["app.kubernetes.io/version"]; ok {
-			podVersion, err := semver.NewVersion(pv)
-			if err == nil && podVersion.Equal(currentVersion) {
-				err = k8sClient.CoreV1().Pods(namespace).Delete(ctxWithTimeout, pod.Name, meta_v1.DeleteOptions{})
-				if err != nil {
-					return fmt.Errorf("failed to delete pod %s during downgrade: %w", pod.Name, err)
-				}
-			}
-		}
-	}
-	return nil
-}
-
 // WithRetry enables retry with the specified max retries and retry interval.
 func WithRetry(maxRetries int, retryInterval time.Duration) UpgradeOption {
 	return func(o *UpgradeOptions) {
@ -353,7 +240,7 @@ func helmUpgrade(client *helm.Upgrade, name string, chart *chart.Chart, vals map

 		// create a totally new helm client, this ensures that we fetch a fresh openapi schema from the server on each attempt.
 		client, _, err = newUpgradeClient(client.Namespace, UpgradeConfig{
-			Timeout: uint(client.Timeout), //nolint:gosec
+			Timeout: uint(client.Timeout),
 		})
 		if err != nil {
 			return nil, fmt.Errorf("unable to create helm client: %w", err)
@ -368,11 +255,6 @@ func highAvailabilityEnabled(status []StatusOutput) bool {
 		if s.Name == "dapr-dashboard" {
 			continue
 		}
-		// Skip the scheduler server because it's in HA mode by default since version 1.15.0
-		// This will fall back to other dapr services to determine if HA mode is enabled.
-		if strings.HasPrefix(s.Name, "dapr-scheduler-server") {
-			continue
-		}
 		if s.Replicas > 1 {
 			return true
 		}
@ -385,7 +267,7 @@ func applyCRDs(version string) error {
 		url := fmt.Sprintf("https://raw.githubusercontent.com/dapr/dapr/%s/charts/dapr/crds/%s.yaml", version, crd)

 		resp, _ := http.Get(url) //nolint:gosec
-		if resp != nil && resp.StatusCode == http.StatusOK {
+		if resp != nil && resp.StatusCode == 200 {
 			defer resp.Body.Close()

 			_, err := utils.RunCmdAndWait("kubectl", "apply", "-f", url)
@ -404,18 +286,18 @@ func upgradeChartValues(ca, issuerCert, issuerKey string, haMode, mtls bool, con
 	if err != nil {
 		return nil, err
 	}
-	globalVals = append(globalVals, "global.tag="+utils.GetVariantVersion(conf.RuntimeVersion, conf.ImageVariant))
+	globalVals = append(globalVals, fmt.Sprintf("global.tag=%s", utils.GetVariantVersion(conf.RuntimeVersion, conf.ImageVariant)))

 	if mtls && ca != "" && issuerCert != "" && issuerKey != "" {
-		globalVals = append(globalVals, "dapr_sentry.tls.root.certPEM="+ca,
-			"dapr_sentry.tls.issuer.certPEM="+issuerCert,
-			"dapr_sentry.tls.issuer.keyPEM="+issuerKey,
+		globalVals = append(globalVals, fmt.Sprintf("dapr_sentry.tls.root.certPEM=%s", ca),
+			fmt.Sprintf("dapr_sentry.tls.issuer.certPEM=%s", issuerCert),
+			fmt.Sprintf("dapr_sentry.tls.issuer.keyPEM=%s", issuerKey),
 		)
 	} else {
 		globalVals = append(globalVals, "global.mtls.enabled=false")
 	}
 	if len(conf.ImageRegistryURI) != 0 {
-		globalVals = append(globalVals, "global.registry="+conf.ImageRegistryURI)
+		globalVals = append(globalVals, fmt.Sprintf("global.registry=%s", conf.ImageRegistryURI))
 	}
 	if haMode {
 		globalVals = append(globalVals, "global.ha.enabled=true")
@ -452,7 +334,7 @@ func newUpgradeClient(namespace string, cfg UpgradeConfig) (*helm.Upgrade, *helm
 	client.Namespace = namespace
 	client.CleanupOnFail = true
 	client.Wait = true
-	client.Timeout = time.Duration(cfg.Timeout) * time.Second //nolint:gosec
+	client.Timeout = time.Duration(cfg.Timeout) * time.Second

 	return client, helmCfg, nil
 }
--- a/pkg/kubernetes/upgrade_test.go
+++ b/pkg/kubernetes/upgrade_test.go
@ -31,38 +31,6 @@ func TestHAMode(t *testing.T) {
 		assert.True(t, r)
 	})

-	t.Run("ha mode with scheduler and other services", func(t *testing.T) {
-		s := []StatusOutput{
-			{
-				Name:     "dapr-scheduler-server",
-				Replicas: 3,
-			},
-			{
-				Name:     "dapr-placement-server",
-				Replicas: 3,
-			},
-		}
-
-		r := highAvailabilityEnabled(s)
-		assert.True(t, r)
-	})
-
-	t.Run("non-ha mode with only scheduler image variant", func(t *testing.T) {
-		s := []StatusOutput{
-			{
-				Name:     "dapr-scheduler-server-mariner",
-				Replicas: 3,
-			},
-			{
-				Name:     "dapr-placement-server-mariner",
-				Replicas: 3,
-			},
-		}
-
-		r := highAvailabilityEnabled(s)
-		assert.True(t, r)
-	})
-
 	t.Run("non-ha mode", func(t *testing.T) {
 		s := []StatusOutput{
 			{
@ -73,46 +41,6 @@ func TestHAMode(t *testing.T) {
 		r := highAvailabilityEnabled(s)
 		assert.False(t, r)
 	})
-
-	t.Run("non-ha mode with scheduler and other services", func(t *testing.T) {
-		s := []StatusOutput{
-			{
-				Name:     "dapr-scheduler-server",
-				Replicas: 3,
-			},
-			{
-				Name:     "dapr-placement-server",
-				Replicas: 1,
-			},
-		}
-
-		r := highAvailabilityEnabled(s)
-		assert.False(t, r)
-	})
-
-	t.Run("non-ha mode with only scheduler", func(t *testing.T) {
-		s := []StatusOutput{
-			{
-				Name:     "dapr-scheduler-server",
-				Replicas: 3,
-			},
-		}
-
-		r := highAvailabilityEnabled(s)
-		assert.False(t, r)
-	})
-
-	t.Run("non-ha mode with only scheduler image variant", func(t *testing.T) {
-		s := []StatusOutput{
-			{
-				Name:     "dapr-scheduler-server-mariner",
-				Replicas: 3,
-			},
-		}
-
-		r := highAvailabilityEnabled(s)
-		assert.False(t, r)
-	})
 }

 func TestMTLSChartValues(t *testing.T) {
--- a/pkg/rundata/rundata.go
+++ b/pkg/rundata/rundata.go
@ -69,7 +69,7 @@ func tryGetRunDataLock() (*lockfile.Lockfile, error) {
 		return nil, err
 	}

-	for range 10 {
+	for i := 0; i < 10; i++ {
 		err = lockFile.TryLock()

 		// Error handling is essential, as we only try to get the lock.
--- a/pkg/runexec/runexec.go
+++ b/pkg/runexec/runexec.go
@ -14,7 +14,7 @@ limitations under the License.
 package runexec

 import (
-	"errors"
+	"fmt"
 	"io"
 	"os"
 	"os/exec"
@ -86,7 +86,7 @@ func (c *CmdProcess) WithOutputWriter(w io.Writer) {
 // SetStdout should be called after WithOutputWriter.
 func (c *CmdProcess) SetStdout() error {
 	if c.Command == nil {
-		return errors.New("command is nil")
+		return fmt.Errorf("command is nil")
 	}
 	c.Command.Stdout = c.OutputWriter
 	return nil
@ -99,7 +99,7 @@ func (c *CmdProcess) WithErrorWriter(w io.Writer) {
 // SetStdErr should be called after WithErrorWriter.
 func (c *CmdProcess) SetStderr() error {
 	if c.Command == nil {
-		return errors.New("command is nil")
+		return fmt.Errorf("command is nil")
 	}
 	c.Command.Stderr = c.ErrorWriter
 	return nil
@ -108,7 +108,7 @@ func (c *CmdProcess) SetStderr() error {
 func NewOutput(config *standalone.RunConfig) (*RunOutput, error) {
 	// set default values from RunConfig struct's tag.
 	config.SetDefaultFromSchema()
-
+	//nolint
 	err := config.Validate()
 	if err != nil {
 		return nil, err
--- a/pkg/runexec/runexec_test.go
+++ b/pkg/runexec/runexec_test.go
@ -20,8 +20,6 @@ import (
 	"strings"
 	"testing"

-	"github.com/stretchr/testify/require"
-
 	"github.com/stretchr/testify/assert"

 	"github.com/dapr/cli/pkg/standalone"
@ -82,10 +80,10 @@ func setupRun(t *testing.T) {
 	componentsDir := standalone.GetDaprComponentsPath(myDaprPath)
 	configFile := standalone.GetDaprConfigPath(myDaprPath)
 	err = os.MkdirAll(componentsDir, 0o700)
-	assert.NoError(t, err, "Unable to setup components dir before running test")
+	assert.Equal(t, nil, err, "Unable to setup components dir before running test")
 	file, err := os.Create(configFile)
 	file.Close()
-	assert.NoError(t, err, "Unable to create config file before running test")
+	assert.Equal(t, nil, err, "Unable to create config file before running test")
 }

 func tearDownRun(t *testing.T) {
@ -96,9 +94,9 @@ func tearDownRun(t *testing.T) {
 	configFile := standalone.GetDaprConfigPath(myDaprPath)

 	err = os.RemoveAll(componentsDir)
-	assert.NoError(t, err, "Unable to delete default components dir after running test")
+	assert.Equal(t, nil, err, "Unable to delete default components dir after running test")
 	err = os.Remove(configFile)
-	assert.NoError(t, err, "Unable to delete default config file after running test")
+	assert.Equal(t, nil, err, "Unable to delete default config file after running test")
 }

 func assertCommonArgs(t *testing.T, basicConfig *standalone.RunConfig, output *RunOutput) {
@ -122,9 +120,9 @@ func assertCommonArgs(t *testing.T, basicConfig *standalone.RunConfig, output *R
 	assertArgumentEqual(t, "components-path", standalone.GetDaprComponentsPath(daprPath), output.DaprCMD.Args)
 	assertArgumentEqual(t, "app-ssl", "", output.DaprCMD.Args)
 	assertArgumentEqual(t, "metrics-port", "9001", output.DaprCMD.Args)
-	assertArgumentEqual(t, "max-body-size", "-1", output.DaprCMD.Args)
+	assertArgumentEqual(t, "dapr-http-max-request-size", "-1", output.DaprCMD.Args)
 	assertArgumentEqual(t, "dapr-internal-grpc-port", "5050", output.DaprCMD.Args)
-	assertArgumentEqual(t, "read-buffer-size", "-1", output.DaprCMD.Args)
+	assertArgumentEqual(t, "dapr-http-read-buffer-size", "-1", output.DaprCMD.Args)
 	assertArgumentEqual(t, "dapr-listen-addresses", "127.0.0.1", output.DaprCMD.Args)
 }

@ -182,8 +180,8 @@ func TestRun(t *testing.T) {
 		AppProtocol:        "http",
 		ComponentsPath:     componentsDir,
 		AppSSL:             true,
-		MaxRequestBodySize: "-1",
-		HTTPReadBufferSize: "-1",
+		MaxRequestBodySize: -1,
+		HTTPReadBufferSize: -1,
 		EnableAPILogging:   true,
 		APIListenAddresses: "127.0.0.1",
 	}
@ -296,21 +294,21 @@ func TestRun(t *testing.T) {
 		basicConfig.ProfilePort = 0
 		basicConfig.EnableProfiling = true
 		basicConfig.MaxConcurrency = 0
-		basicConfig.MaxRequestBodySize = ""
-		basicConfig.HTTPReadBufferSize = ""
+		basicConfig.MaxRequestBodySize = 0
+		basicConfig.HTTPReadBufferSize = 0
 		basicConfig.AppProtocol = ""

 		basicConfig.SetDefaultFromSchema()

 		assert.Equal(t, -1, basicConfig.AppPort)
-		assert.Equal(t, -1, basicConfig.HTTPPort)
-		assert.Equal(t, -1, basicConfig.GRPCPort)
-		assert.Equal(t, -1, basicConfig.MetricsPort)
-		assert.Equal(t, -1, basicConfig.ProfilePort)
+		assert.True(t, basicConfig.HTTPPort == -1)
+		assert.True(t, basicConfig.GRPCPort == -1)
+		assert.True(t, basicConfig.MetricsPort == -1)
+		assert.True(t, basicConfig.ProfilePort == -1)
 		assert.True(t, basicConfig.EnableProfiling)
 		assert.Equal(t, -1, basicConfig.MaxConcurrency)
-		assert.Equal(t, "4Mi", basicConfig.MaxRequestBodySize)
-		assert.Equal(t, "4Ki", basicConfig.HTTPReadBufferSize)
+		assert.Equal(t, -1, basicConfig.MaxRequestBodySize)
+		assert.Equal(t, -1, basicConfig.HTTPReadBufferSize)
 		assert.Equal(t, "http", basicConfig.AppProtocol)

 		// Test after Validate gets called.
@ -318,52 +316,14 @@ func TestRun(t *testing.T) {
 		assert.NoError(t, err)

 		assert.Equal(t, 0, basicConfig.AppPort)
-		assert.Positive(t, basicConfig.HTTPPort)
-		assert.Positive(t, basicConfig.GRPCPort)
-		assert.Positive(t, basicConfig.MetricsPort)
-		assert.Positive(t, basicConfig.ProfilePort)
+		assert.True(t, basicConfig.HTTPPort > 0)
+		assert.True(t, basicConfig.GRPCPort > 0)
+		assert.True(t, basicConfig.MetricsPort > 0)
+		assert.True(t, basicConfig.ProfilePort > 0)
 		assert.True(t, basicConfig.EnableProfiling)
 		assert.Equal(t, -1, basicConfig.MaxConcurrency)
-		assert.Equal(t, "4Mi", basicConfig.MaxRequestBodySize)
-		assert.Equal(t, "4Ki", basicConfig.HTTPReadBufferSize)
+		assert.Equal(t, -1, basicConfig.MaxRequestBodySize)
+		assert.Equal(t, -1, basicConfig.HTTPReadBufferSize)
 		assert.Equal(t, "http", basicConfig.AppProtocol)
 	})
-
-	t.Run("run with max body size without units", func(t *testing.T) {
-		basicConfig.MaxRequestBodySize = "4000000"
-
-		output, err := NewOutput(basicConfig)
-		require.NoError(t, err)
-		assertArgumentEqual(t, "max-body-size", "4M", output.DaprCMD.Args)
-	})
-
-	t.Run("run with max body size with units", func(t *testing.T) {
-		basicConfig.MaxRequestBodySize = "4Mi"
-
-		output, err := NewOutput(basicConfig)
-		require.NoError(t, err)
-		assertArgumentEqual(t, "max-body-size", "4Mi", output.DaprCMD.Args)
-
-		basicConfig.MaxRequestBodySize = "5M"
-
-		output, err = NewOutput(basicConfig)
-		require.NoError(t, err)
-		assertArgumentEqual(t, "max-body-size", "5M", output.DaprCMD.Args)
-	})
-
-	t.Run("run with read buffer size set without units", func(t *testing.T) {
-		basicConfig.HTTPReadBufferSize = "16001"
-
-		output, err := NewOutput(basicConfig)
-		require.NoError(t, err)
-		assertArgumentEqual(t, "read-buffer-size", "16001", output.DaprCMD.Args)
-	})
-
-	t.Run("run with read buffer size set with units", func(t *testing.T) {
-		basicConfig.HTTPReadBufferSize = "4Ki"
-
-		output, err := NewOutput(basicConfig)
-		require.NoError(t, err)
-		assertArgumentEqual(t, "read-buffer-size", "4Ki", output.DaprCMD.Args)
-	})
 }
--- a/pkg/runfileconfig/run_file_config.go
+++ b/pkg/runfileconfig/run_file_config.go
@ -41,9 +41,8 @@ type RunFileConfig struct {

 // ContainerConfiguration represents the application container configuration parameters.
 type ContainerConfiguration struct {
-	ContainerImage           string `yaml:"containerImage"`
-	ContainerImagePullPolicy string `yaml:"containerImagePullPolicy"`
-	CreateService            bool   `yaml:"createService"`
+	ContainerImage string `yaml:"containerImage"`
+	CreateService  bool   `yaml:"createService"`
 }

 // App represents the configuration options for the apps in the run file.
--- a/pkg/runfileconfig/run_file_config_parser.go
+++ b/pkg/runfileconfig/run_file_config_parser.go
@ -26,8 +26,6 @@ import (
 	"gopkg.in/yaml.v2"
 )

-var imagePullPolicyValuesAllowed = []string{"Always", "Never", "IfNotPresent"}
-
 // Parse the provided run file into a RunFileConfig struct.
 func (a *RunFileConfig) parseAppsConfig(runFilePath string) error {
 	var err error
@ -72,7 +70,7 @@ func (a *RunFileConfig) validateRunConfig(runFilePath string) error {
 		a.Common.ResourcesPaths = append(a.Common.ResourcesPaths, a.Common.ResourcesPath)
 	}

-	for i := range len(a.Apps) {
+	for i := 0; i < len(a.Apps); i++ {
 		if a.Apps[i].AppDirPath == "" {
 			return errors.New("required field 'appDirPath' not found in the provided app config file")
 		}
@ -99,15 +97,6 @@ func (a *RunFileConfig) validateRunConfig(runFilePath string) error {
 		if len(strings.TrimSpace(a.Apps[i].ResourcesPath)) > 0 {
 			a.Apps[i].ResourcesPaths = append(a.Apps[i].ResourcesPaths, a.Apps[i].ResourcesPath)
 		}
-
-		// Check containerImagePullPolicy is valid.
-		if a.Apps[i].ContainerImagePullPolicy != "" {
-			if !utils.Contains(imagePullPolicyValuesAllowed, a.Apps[i].ContainerImagePullPolicy) {
-				return fmt.Errorf("invalid containerImagePullPolicy: %s, allowed values: %s", a.Apps[i].ContainerImagePullPolicy, strings.Join(imagePullPolicyValuesAllowed, ", "))
-			}
-		} else {
-			a.Apps[i].ContainerImagePullPolicy = "Always"
-		}
 	}
 	return nil
 }
@ -223,6 +212,9 @@ func (a *RunFileConfig) resolvePathToAbsAndValidate(baseDir string, paths ...*st
 			return err
 		}
 		absPath := utils.GetAbsPath(baseDir, *path)
+		if err != nil {
+			return err
+		}
 		*path = absPath
 		if err = utils.ValidateFilePath(*path); err != nil {
 			return err
--- a/pkg/runfileconfig/run_file_config_parser_test.go
+++ b/pkg/runfileconfig/run_file_config_parser_test.go
@ -14,7 +14,6 @@ limitations under the License.
 package runfileconfig

 import (
-	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@ -33,9 +32,6 @@ var (
 	runFileForPrecedenceRuleDaprDir = filepath.Join(".", "testdata", "test_run_config_precedence_rule_dapr_dir.yaml")
 	runFileForLogDestination        = filepath.Join(".", "testdata", "test_run_config_log_destination.yaml")
 	runFileForMultiResourcePaths    = filepath.Join(".", "testdata", "test_run_config_multiple_resources_paths.yaml")
-
-	runFileForContainerImagePullPolicy        = filepath.Join(".", "testdata", "test_run_config_container_image_pull_policy.yaml")
-	runFileForContainerImagePullPolicyInvalid = filepath.Join(".", "testdata", "test_run_config_container_image_pull_policy_invalid.yaml")
 )

 func TestRunConfigFile(t *testing.T) {
@ -45,7 +41,7 @@ func TestRunConfigFile(t *testing.T) {
 		err := appsRunConfig.parseAppsConfig(validRunFilePath)

 		assert.NoError(t, err)
-		assert.Len(t, appsRunConfig.Apps, 2)
+		assert.Equal(t, 2, len(appsRunConfig.Apps))

 		assert.Equal(t, 1, appsRunConfig.Version)
 		assert.NotEmpty(t, appsRunConfig.Common.ResourcesPath)
@ -64,7 +60,7 @@ func TestRunConfigFile(t *testing.T) {

 		apps, err := config.GetApps(validRunFilePath)
 		assert.NoError(t, err)
-		assert.Len(t, apps, 2)
+		assert.Equal(t, 2, len(apps))
 		assert.Equal(t, "webapp", apps[0].AppID)
 		assert.Equal(t, "backend", apps[1].AppID)
 		assert.Equal(t, "HTTP", apps[0].AppProtocol)
@ -90,8 +86,8 @@ func TestRunConfigFile(t *testing.T) {
 		assert.Equal(t, filepath.Join(apps[1].AppDirPath, ".dapr", "resources"), apps[1].ResourcesPaths[0])

 		// test merged envs from common and app sections.
-		assert.Len(t, apps[0].Env, 2)
-		assert.Len(t, apps[1].Env, 2)
+		assert.Equal(t, 2, len(apps[0].Env))
+		assert.Equal(t, 2, len(apps[1].Env))
 		assert.Contains(t, apps[0].Env, "DEBUG")
 		assert.Contains(t, apps[0].Env, "tty")
 		assert.Contains(t, apps[1].Env, "DEBUG")
@ -233,7 +229,7 @@ func TestRunConfigFile(t *testing.T) {
 		config := RunFileConfig{}
 		apps, err := config.GetApps(runFileForLogDestination)
 		assert.NoError(t, err)
-		assert.Len(t, apps, 6)
+		assert.Equal(t, 6, len(apps))

 		assert.Equal(t, "file", apps[0].DaprdLogDestination.String())
 		assert.Equal(t, "fileAndConsole", apps[0].AppLogDestination.String())
@ -255,51 +251,6 @@ func TestRunConfigFile(t *testing.T) {
 	})
 }

-func TestContainerImagePullPolicy(t *testing.T) {
-	testcases := []struct {
-		name                   string
-		runfFile               string
-		expectedPullPolicies   []string
-		expectedBadPolicyValue string
-		expectedErr            bool
-	}{
-		{
-			name:                 "default value is Always",
-			runfFile:             validRunFilePath,
-			expectedPullPolicies: []string{"Always", "Always"},
-			expectedErr:          false,
-		},
-		{
-			name:                 "custom value is respected",
-			runfFile:             runFileForContainerImagePullPolicy,
-			expectedPullPolicies: []string{"IfNotPresent", "Always"},
-			expectedErr:          false,
-		},
-		{
-			name:                   "invalid value is rejected",
-			runfFile:               runFileForContainerImagePullPolicyInvalid,
-			expectedPullPolicies:   []string{"Always", "Always"},
-			expectedBadPolicyValue: "Invalid",
-			expectedErr:            true,
-		},
-	}
-
-	for _, tc := range testcases {
-		t.Run(tc.name, func(t *testing.T) {
-			config := RunFileConfig{}
-			config.parseAppsConfig(tc.runfFile)
-			err := config.validateRunConfig(tc.runfFile)
-			if tc.expectedErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), fmt.Sprintf("invalid containerImagePullPolicy: %s, allowed values: Always, Never, IfNotPresent", tc.expectedBadPolicyValue))
-				return
-			}
-			assert.Equal(t, tc.expectedPullPolicies[0], config.Apps[0].ContainerImagePullPolicy)
-			assert.Equal(t, tc.expectedPullPolicies[1], config.Apps[1].ContainerImagePullPolicy)
-		})
-	}
-}
-
 func TestMultiResourcePathsResolution(t *testing.T) {
 	config := RunFileConfig{}

@ -346,7 +297,7 @@ func TestMultiResourcePathsResolution(t *testing.T) {

 	for _, tc := range testcases {
 		t.Run(tc.name, func(t *testing.T) {
-			assert.Len(t, config.Apps[tc.appIndex].ResourcesPaths, tc.expectedNoOfResources)
+			assert.Equal(t, tc.expectedNoOfResources, len(config.Apps[tc.appIndex].ResourcesPaths))
 			var rsrcFound bool
 			for _, resourcePath := range config.Apps[tc.appIndex].ResourcesPaths {
 				if rsrcFound = strings.Contains(resourcePath, tc.expectedResourcesPathsContains); rsrcFound {
--- a/pkg/runfileconfig/testdata/test_run_config_container_image_pull_policy.yaml
+++ b/pkg/runfileconfig/testdata/test_run_config_container_image_pull_policy.yaml
@ -1,24 +0,0 @@
-version: 1
-common:
-  resourcesPath: ./app/resources
-  appProtocol: HTTP
-  appHealthProbeTimeout: 10
-  env:
-    DEBUG: false
-    tty: sts
-apps:
-  - appDirPath: ./webapp/
-    resourcesPath: ./resources
-    configFilePath: ./config.yaml
-    appPort: 8080
-    appHealthProbeTimeout: 1
-    containerImagePullPolicy: IfNotPresent
-    containerImage: ghcr.io/dapr/dapr-workflows-python-sdk:latest
-  - appID: backend
-    appDirPath: ./backend/
-    appProtocol: GRPC
-    appPort: 3000
-    unixDomainSocket: /tmp/test-socket
-    env:
-      DEBUG: true
-    containerImage: ghcr.io/dapr/dapr-workflows-csharp-sdk:latest
--- a/pkg/runfileconfig/testdata/test_run_config_container_image_pull_policy_invalid.yaml
+++ b/pkg/runfileconfig/testdata/test_run_config_container_image_pull_policy_invalid.yaml
@ -1,24 +0,0 @@
-version: 1
-common:
-  resourcesPath: ./app/resources
-  appProtocol: HTTP
-  appHealthProbeTimeout: 10
-  env:
-    DEBUG: false
-    tty: sts
-apps:
-  - appDirPath: ./webapp/
-    resourcesPath: ./resources
-    configFilePath: ./config.yaml
-    appPort: 8080
-    appHealthProbeTimeout: 1
-    containerImagePullPolicy: Invalid
-    containerImage: ghcr.io/dapr/dapr-workflows-python-sdk:latest
-  - appID: backend
-    appDirPath: ./backend/
-    appProtocol: GRPC
-    appPort: 3000
-    unixDomainSocket: /tmp/test-socket
-    env:
-      DEBUG: true
-    containerImage: ghcr.io/dapr/dapr-workflows-csharp-sdk:latest
--- a/pkg/standalone/container.go
+++ b/pkg/standalone/container.go
@ -85,6 +85,7 @@ func confirmContainerIsRunningOrExists(containerName string, isRunning bool, run

 	// If 'docker ps' failed due to some reason.
 	if err != nil {
+		//nolint
 		return false, fmt.Errorf("unable to confirm whether %s is running or exists. error\n%v", containerName, err.Error())
 	}
 	// 'docker ps' worked fine, but the response did not have the container name.
@ -99,6 +100,7 @@ func confirmContainerIsRunningOrExists(containerName string, isRunning bool, run
 }

 func isContainerRunError(err error) bool {
+	//nolint
 	if exitError, ok := err.(*exec.ExitError); ok {
 		exitCode := exitError.ExitCode()
 		return exitCode == 125
@ -107,6 +109,7 @@ func isContainerRunError(err error) bool {
 }

 func parseContainerRuntimeError(component string, err error) error {
+	//nolint
 	if exitError, ok := err.(*exec.ExitError); ok {
 		exitCode := exitError.ExitCode()
 		if exitCode == 125 { // see https://github.com/moby/moby/pull/14012
--- a/pkg/standalone/dashboard_test.go
+++ b/pkg/standalone/dashboard_test.go
@ -26,8 +26,8 @@ func TestDashboardRun(t *testing.T) {

 		assert.NoError(t, err)
 		assert.Contains(t, cmd.Args[0], "dashboard")
-		assert.Equal(t, "--port", cmd.Args[1])
-		assert.Equal(t, "9090", cmd.Args[2])
+		assert.Equal(t, cmd.Args[1], "--port")
+		assert.Equal(t, cmd.Args[2], "9090")
 	})

 	t.Run("start dashboard on random free port", func(t *testing.T) {
@ -35,7 +35,7 @@ func TestDashboardRun(t *testing.T) {

 		assert.NoError(t, err)
 		assert.Contains(t, cmd.Args[0], "dashboard")
-		assert.Equal(t, "--port", cmd.Args[1])
-		assert.NotEqual(t, "0", cmd.Args[2])
+		assert.Equal(t, cmd.Args[1], "--port")
+		assert.NotEqual(t, cmd.Args[2], "0")
 	})
 }
--- a/pkg/standalone/invoke.go
+++ b/pkg/standalone/invoke.go
@ -64,7 +64,7 @@ func (s *Standalone) Invoke(appID, method string, data []byte, verb string, path
 }

 func makeEndpoint(lo ListOutput, method string) string {
-	return fmt.Sprintf("http://127.0.0.1:%d/v%s/invoke/%s/method/%s", lo.HTTPPort, api.RuntimeAPIVersion, lo.AppID, method)
+	return fmt.Sprintf("http://127.0.0.1:%s/v%s/invoke/%s/method/%s", fmt.Sprintf("%v", lo.HTTPPort), api.RuntimeAPIVersion, lo.AppID, method) //nolint: perfsprint
 }

 func handleResponse(response *http.Response) (string, error) {
--- a/pkg/standalone/list.go
+++ b/pkg/standalone/list.go
@ -66,7 +66,7 @@ func List() ([]ListOutput, error) {
 	for _, proc := range processes {
 		executable := strings.ToLower(proc.Executable())
 		if (executable == "daprd") || (executable == "daprd.exe") {
-			procDetails, err := process.NewProcess(int32(proc.Pid())) //nolint:gosec
+			procDetails, err := process.NewProcess(int32(proc.Pid()))
 			if err != nil {
 				continue
 			}
@ -105,9 +105,9 @@ func List() ([]ListOutput, error) {
 				enableMetrics = true
 			}

-			maxRequestBodySize := getIntArg(argumentsMap, "max-body-size", runtime.DefaultMaxRequestBodySize)
+			maxRequestBodySize := getIntArg(argumentsMap, "--dapr-http-max-request-size", runtime.DefaultMaxRequestBodySize)

-			httpReadBufferSize := getIntArg(argumentsMap, "read-buffer-size", runtime.DefaultReadBufferSize)
+			httpReadBufferSize := getIntArg(argumentsMap, "--dapr-http-read-buffer-size", runtime.DefaultReadBufferSize)

 			appID := argumentsMap["--app-id"]
 			appCmd := ""
--- a/pkg/standalone/publish.go
+++ b/pkg/standalone/publish.go
@ -62,7 +62,7 @@ func (s *Standalone) Publish(publishAppID, pubsubName, topic string, payload []b
 			},
 		}
 	} else {
-		url = fmt.Sprintf("http://localhost:%d/v%s/publish/%s/%s%s", instance.HTTPPort, api.RuntimeAPIVersion, pubsubName, topic, queryParams)
+		url = fmt.Sprintf("http://localhost:%s/v%s/publish/%s/%s%s", fmt.Sprintf("%v", instance.HTTPPort), api.RuntimeAPIVersion, pubsubName, topic, queryParams) //nolint: perfsprint
 	}

 	contentType := "application/json"
@ -94,7 +94,7 @@ func (s *Standalone) Publish(publishAppID, pubsubName, topic string, payload []b
 }

 func getDaprInstance(list []ListOutput, publishAppID string) (ListOutput, error) {
-	for i := range list {
+	for i := 0; i < len(list); i++ {
 		if list[i].AppID == publishAppID {
 			return list[i], nil
 		}
@ -112,7 +112,7 @@ func getQueryParams(metadata map[string]interface{}) string {
 	}
 	// Prefix with "?" and remove the last "&".
 	if queryParams != "" {
-		queryParams = "?" + queryParams[:len(queryParams)-1]
+		queryParams = fmt.Sprintf("?%s", queryParams[:len(queryParams)-1])
 	}
 	return queryParams
 }
--- a/pkg/standalone/publish_test.go
+++ b/pkg/standalone/publish_test.go
@ -212,7 +212,7 @@ func TestGetQueryParams(t *testing.T) {
 		queryParams := getQueryParams(tc.metadata)

 		if queryParams != "" {
-			assert.True(t, strings.HasPrefix(queryParams, "?"), "expected query params to start with '?'")
+			assert.True(t, queryParams[0] == '?', "expected query params to start with '?'")
 			queryParams = queryParams[1:]
 		}

--- a/pkg/standalone/run.go
+++ b/pkg/standalone/run.go
@ -24,14 +24,14 @@ import (
 	"strconv"
 	"strings"

-	"k8s.io/apimachinery/pkg/api/resource"
+	dockerClient "github.com/docker/docker/client"

 	"github.com/Pallinder/sillyname-go"
 	"github.com/phayes/freeport"
 	"gopkg.in/yaml.v2"

 	"github.com/dapr/cli/pkg/print"
-	localloader "github.com/dapr/dapr/pkg/components/loader"
+	"github.com/dapr/dapr/pkg/components"
 )

 type LogDestType string
@ -81,8 +81,8 @@ type SharedRunConfig struct {
 	ResourcesPaths []string `arg:"resources-path" yaml:"resourcesPaths"`
 	// Speicifcally omitted from annotations as appSSL is deprecated.
 	AppSSL             bool   `arg:"app-ssl" yaml:"appSSL"`
-	MaxRequestBodySize string `arg:"max-body-size" annotation:"dapr.io/max-body-size" yaml:"maxBodySize" default:"4Mi"`
-	HTTPReadBufferSize string `arg:"read-buffer-size" annotation:"dapr.io/read-buffer-size" yaml:"readBufferSize" default:"4Ki"`
+	MaxRequestBodySize int    `arg:"dapr-http-max-request-size" annotation:"dapr.io/http-max-request-size" yaml:"daprHTTPMaxRequestSize" default:"-1"`
+	HTTPReadBufferSize int    `arg:"dapr-http-read-buffer-size" annotation:"dapr.io/http-read-buffer-size" yaml:"daprHTTPReadBufferSize" default:"-1"`
 	EnableAppHealth    bool   `arg:"enable-app-health-check" annotation:"dapr.io/enable-app-health-check" yaml:"enableAppHealthCheck"`
 	AppHealthPath      string `arg:"app-health-check-path" annotation:"dapr.io/app-health-check-path" yaml:"appHealthCheckPath"`
 	AppHealthInterval  int    `arg:"app-health-probe-interval" annotation:"dapr.io/app-health-probe-interval" ifneq:"0" yaml:"appHealthProbeInterval"`
@ -116,8 +116,8 @@ func (config *RunConfig) validateResourcesPaths() error {
 			return fmt.Errorf("error validating resources path %q : %w", dirPath, err)
 		}
 	}
-	localLoader := localloader.NewLocalLoader(config.AppID, dirPath)
-	err := localLoader.Validate(context.Background())
+	componentsLoader := components.NewLocalComponents(dirPath...)
+	_, err := componentsLoader.Load()
 	if err != nil {
 		return fmt.Errorf("error validating components in resources path %q : %w", dirPath, err)
 	}
@ -131,9 +131,9 @@ func (config *RunConfig) validatePlacementHostAddr() error {
 	}
 	if indx := strings.Index(placementHostAddr, ":"); indx == -1 {
 		if runtime.GOOS == daprWindowsOS {
-			placementHostAddr += ":6050"
+			placementHostAddr = fmt.Sprintf("%s:6050", placementHostAddr)
 		} else {
-			placementHostAddr += ":50005"
+			placementHostAddr = fmt.Sprintf("%s:50005", placementHostAddr)
 		}
 	}
 	config.PlacementHostAddr = placementHostAddr
@ -141,21 +141,27 @@ func (config *RunConfig) validatePlacementHostAddr() error {
 }

 func (config *RunConfig) validateSchedulerHostAddr() error {
-	schedulerHostAddr := config.SchedulerHostAddress
-	if len(schedulerHostAddr) == 0 {
+	// If the scheduler isn't running - don't add the flag to the runtime cmd.
+	docker, err := dockerClient.NewClientWithOpts()
+	if err != nil {
+		return err
+	}
+	_, err = docker.ContainerInspect(context.Background(), "dapr_scheduler")
+	if err == nil {
+		schedulerHostAddr := config.SchedulerHostAddress
+		if len(schedulerHostAddr) == 0 {
+			schedulerHostAddr = "localhost"
+		}
+		if indx := strings.Index(schedulerHostAddr, ":"); indx == -1 {
+			if runtime.GOOS == daprWindowsOS {
+				schedulerHostAddr = fmt.Sprintf("%s:6060", schedulerHostAddr)
+			} else {
+				schedulerHostAddr = fmt.Sprintf("%s:50006", schedulerHostAddr)
+			}
+		}
+		config.SchedulerHostAddress = schedulerHostAddr
 		return nil
 	}
-
-	if indx := strings.Index(schedulerHostAddr, ":"); indx == -1 {
-		if runtime.GOOS == daprWindowsOS {
-			schedulerHostAddr += ":6060"
-		} else {
-			schedulerHostAddr += ":50006"
-		}
-	}
-
-	config.SchedulerHostAddress = schedulerHostAddr
-
 	return nil
 }

@ -228,27 +234,12 @@ func (config *RunConfig) Validate() error {
 	if config.MaxConcurrency < 1 {
 		config.MaxConcurrency = -1
 	}
-
-	qBody, err := resource.ParseQuantity(config.MaxRequestBodySize)
-	if err != nil {
-		return fmt.Errorf("invalid max request body size: %w", err)
+	if config.MaxRequestBodySize < 0 {
+		config.MaxRequestBodySize = -1
 	}

-	if qBody.Value() < 0 {
-		config.MaxRequestBodySize = "-1"
-	} else {
-		config.MaxRequestBodySize = qBody.String()
-	}
-
-	qBuffer, err := resource.ParseQuantity(config.HTTPReadBufferSize)
-	if err != nil {
-		return fmt.Errorf("invalid http read buffer size: %w", err)
-	}
-
-	if qBuffer.Value() < 0 {
-		config.HTTPReadBufferSize = "-1"
-	} else {
-		config.HTTPReadBufferSize = qBuffer.String()
+	if config.HTTPReadBufferSize < 0 {
+		config.HTTPReadBufferSize = -1
 	}

 	err = config.validatePlacementHostAddr()
@ -282,27 +273,12 @@ func (config *RunConfig) ValidateK8s() error {
 	if config.MaxConcurrency < 1 {
 		config.MaxConcurrency = -1
 	}
-
-	qBody, err := resource.ParseQuantity(config.MaxRequestBodySize)
-	if err != nil {
-		return fmt.Errorf("invalid max request body size: %w", err)
+	if config.MaxRequestBodySize < 0 {
+		config.MaxRequestBodySize = -1
 	}

-	if qBody.Value() < 0 {
-		config.MaxRequestBodySize = "-1"
-	} else {
-		config.MaxRequestBodySize = qBody.String()
-	}
-
-	qBuffer, err := resource.ParseQuantity(config.HTTPReadBufferSize)
-	if err != nil {
-		return fmt.Errorf("invalid http read buffer size: %w", err)
-	}
-
-	if qBuffer.Value() < 0 {
-		config.HTTPReadBufferSize = "-1"
-	} else {
-		config.HTTPReadBufferSize = qBuffer.String()
+	if config.HTTPReadBufferSize < 0 {
+		config.HTTPReadBufferSize = -1
 	}

 	return nil
@ -322,7 +298,7 @@ func (meta *DaprMeta) portExists(port int) bool {
 	if port <= 0 {
 		return false
 	}
-
+	//nolint
 	_, ok := meta.ExistingPorts[port]
 	if ok {
 		return true
@ -379,7 +355,7 @@ func (config *RunConfig) getArgs() []string {
 // Recursive function to get all the args from the config struct.
 // This is needed because the config struct has embedded struct.
 func getArgsFromSchema(schema reflect.Value, args []string) []string {
-	for i := range schema.NumField() {
+	for i := 0; i < schema.NumField(); i++ {
 		valueField := schema.Field(i).Interface()
 		typeField := schema.Type().Field(i)
 		key := typeField.Tag.Get("arg")
@ -421,7 +397,7 @@ func (config *RunConfig) SetDefaultFromSchema() {
 }

 func (config *RunConfig) setDefaultFromSchemaRecursive(schema reflect.Value) {
-	for i := range schema.NumField() {
+	for i := 0; i < schema.NumField(); i++ {
 		valueField := schema.Field(i)
 		typeField := schema.Type().Field(i)
 		if typeField.Type.Kind() == reflect.Struct {
@ -447,7 +423,7 @@ func (config *RunConfig) getEnv() []string {

 	// Handle values from config that have an "env" tag.
 	schema := reflect.ValueOf(*config)
-	for i := range schema.NumField() {
+	for i := 0; i < schema.NumField(); i++ {
 		valueField := schema.Field(i).Interface()
 		typeField := schema.Type().Field(i)
 		key := typeField.Tag.Get("env")
@ -507,7 +483,7 @@ func (config *RunConfig) getAppProtocol() string {
 func (config *RunConfig) GetEnv() map[string]string {
 	env := map[string]string{}
 	schema := reflect.ValueOf(*config)
-	for i := range schema.NumField() {
+	for i := 0; i < schema.NumField(); i++ {
 		valueField := schema.Field(i).Interface()
 		typeField := schema.Type().Field(i)
 		key := typeField.Tag.Get("env")
@ -531,7 +507,7 @@ func (config *RunConfig) GetEnv() map[string]string {
 func (config *RunConfig) GetAnnotations() map[string]string {
 	annotations := map[string]string{}
 	schema := reflect.ValueOf(*config)
-	for i := range schema.NumField() {
+	for i := 0; i < schema.NumField(); i++ {
 		valueField := schema.Field(i).Interface()
 		typeField := schema.Type().Field(i)
 		key := typeField.Tag.Get("annotation")
--- a/pkg/standalone/standalone.go
+++ b/pkg/standalone/standalone.go
@ -652,19 +652,15 @@ func runSchedulerService(wg *sync.WaitGroup, errorChan chan<- error, info initIn
 		// /var/lock and can therefore mount the Docker volume here.
 		// TODO: update the Dapr scheduler dockerfile to create a scheduler user id writeable
 		// directory at /var/lib/dapr/scheduler, then update the path here.
-		if strings.EqualFold(info.imageVariant, "mariner") {
-			args = append(args, "--volume", *info.schedulerVolume+":/var/tmp")
-		} else {
-			args = append(args, "--volume", *info.schedulerVolume+":/var/lock")
-		}
+		args = append(args, "--volume", *info.schedulerVolume+":/var/lock")
 	}

-	osPort := 50006
 	if info.dockerNetwork != "" {
 		args = append(args,
 			"--network", info.dockerNetwork,
 			"--network-alias", DaprSchedulerContainerName)
 	} else {
+		osPort := 50006
 		if runtime.GOOS == daprWindowsOS {
 			osPort = 6060
 		}
@ -677,15 +673,7 @@ func runSchedulerService(wg *sync.WaitGroup, errorChan chan<- error, info initIn
 		)
 	}

-	if strings.EqualFold(info.imageVariant, "mariner") {
-		args = append(args, image, "--etcd-data-dir=/var/tmp/dapr/scheduler")
-	} else {
-		args = append(args, image, "--etcd-data-dir=/var/lock/dapr/scheduler")
-	}
-
-	if schedulerOverrideHostPort(info) {
-		args = append(args, fmt.Sprintf("--override-broadcast-host-port=localhost:%v", osPort))
-	}
+	args = append(args, image, "--etcd-data-dir=/var/lock/dapr/scheduler")

 	_, err = utils.RunCmdAndWait(runtimeCmd, args...)
 	if err != nil {
@ -700,21 +688,6 @@ func runSchedulerService(wg *sync.WaitGroup, errorChan chan<- error, info initIn
 	errorChan <- nil
 }

-func schedulerOverrideHostPort(info initInfo) bool {
-	if info.runtimeVersion == "edge" || info.runtimeVersion == "dev" {
-		return true
-	}
-
-	runV, err := semver.NewVersion(info.runtimeVersion)
-	if err != nil {
-		return true
-	}
-
-	v115rc5, _ := semver.NewVersion("1.15.0-rc.5")
-
-	return runV.GreaterThan(v115rc5)
-}
-
 func moveDashboardFiles(extractedFilePath string, dir string) (string, error) {
 	// Move /release/os/web directory to /web.
 	oldPath := path_filepath.Join(path_filepath.Dir(extractedFilePath), "web")
@ -907,7 +880,7 @@ func createSlimConfiguration(wg *sync.WaitGroup, errorChan chan<- error, info in
 func makeDefaultComponentsDir(installDir string) error {
 	// Make default components directory.
 	componentsDir := GetDaprComponentsPath(installDir)
-
+	//nolint
 	_, err := os.Stat(componentsDir)
 	if os.IsNotExist(err) {
 		errDir := os.MkdirAll(componentsDir, 0o755)
@ -974,7 +947,7 @@ func unzip(r *zip.Reader, targetDir string, binaryFilePrefix string) (string, er
 			return "", err
 		}

-		if strings.HasSuffix(fpath, binaryFilePrefix+".exe") {
+		if strings.HasSuffix(fpath, fmt.Sprintf("%s.exe", binaryFilePrefix)) {
 			foundBinary = fpath
 		}

@ -1032,6 +1005,7 @@ func untar(reader io.Reader, targetDir string, binaryFilePrefix string) (string,
 	foundBinary := ""
 	for {
 		header, err := tr.Next()
+		//nolint
 		if err == io.EOF {
 			break
 		} else if err != nil {
@ -1054,7 +1028,7 @@ func untar(reader io.Reader, targetDir string, binaryFilePrefix string) (string,
 			continue
 		}

-		f, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, os.FileMode(header.Mode)) //nolint:gosec
+		f, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, os.FileMode(header.Mode))
 		if err != nil {
 			return "", err
 		}
@ -1103,14 +1077,14 @@ func moveFileToPath(filepath string, installLocation string) (string, error) {

 		if !strings.Contains(strings.ToLower(p), strings.ToLower(destDir)) {
 			destDir = utils.SanitizeDir(destDir)
-			pathCmd := "[System.Environment]::SetEnvironmentVariable('Path',[System.Environment]::GetEnvironmentVariable('Path','user') + '" + ";" + destDir + "', 'user')"
+			pathCmd := "[System.Environment]::SetEnvironmentVariable('Path',[System.Environment]::GetEnvironmentVariable('Path','user') + '" + fmt.Sprintf(";%s", destDir) + "', 'user')"
 			_, err := utils.RunCmdAndWait("powershell", pathCmd)
 			if err != nil {
 				return "", err
 			}
 		}

-		return destDir + "\\daprd.exe", nil
+		return fmt.Sprintf("%s\\daprd.exe", destDir), nil
 	}

 	if strings.HasPrefix(fileName, daprRuntimeFilePrefix) && installLocation != "" {
@ -1135,7 +1109,7 @@ func createRedisStateStore(redisHost string, componentsPath string) error {
 	redisStore.Spec.Metadata = []componentMetadataItem{
 		{
 			Name:  "redisHost",
-			Value: redisHost + ":6379",
+			Value: fmt.Sprintf("%s:6379", redisHost),
 		},
 		{
 			Name:  "redisPassword",
@ -1170,7 +1144,7 @@ func createRedisPubSub(redisHost string, componentsPath string) error {
 	redisPubSub.Spec.Metadata = []componentMetadataItem{
 		{
 			Name:  "redisHost",
-			Value: redisHost + ":6379",
+			Value: fmt.Sprintf("%s:6379", redisHost),
 		},
 		{
 			Name:  "redisPassword",
--- a/pkg/standalone/standalone_test.go
+++ b/pkg/standalone/standalone_test.go
@ -98,6 +98,7 @@ func TestResolveImageWithGHCR(t *testing.T) {
 	}

 	for _, test := range tests {
+		test := test
 		t.Run(test.name, func(t *testing.T) {
 			t.Parallel()
 			got, err := resolveImageURI(test.args)
@ -143,6 +144,7 @@ func TestResolveImageWithDockerHub(t *testing.T) {
 	}

 	for _, test := range tests {
+		test := test
 		t.Run(test.name, func(t *testing.T) {
 			t.Parallel()
 			got, err := resolveImageURI(test.args)
@ -188,6 +190,7 @@ func TestResolveImageWithPrivateRegistry(t *testing.T) {
 	}

 	for _, test := range tests {
+		test := test
 		t.Run(test.name, func(t *testing.T) {
 			t.Parallel()
 			got, err := resolveImageURI(test.args)
@ -326,7 +329,7 @@ func TestInitLogActualContainerRuntimeName(t *testing.T) {
 			}

 			err := Init(latestVersion, latestVersion, "", false, "", "", test.containerRuntime, "", "", nil)
-			assert.Error(t, err)
+			assert.NotNil(t, err)
 			assert.Contains(t, err.Error(), test.containerRuntime)
 		})
 	}
--- a/pkg/standalone/stop.go
+++ b/pkg/standalone/stop.go
@ -18,7 +18,6 @@ package standalone

 import (
 	"fmt"
-	"strconv"
 	"syscall"

 	"github.com/dapr/cli/utils"
@ -32,10 +31,10 @@ func Stop(appID string, cliPIDToNoOfApps map[int]int, apps []ListOutput) error {
 			// Kill the Daprd process if Daprd was started without CLI, otherwise
 			// kill the CLI process which also kills the associated Daprd process.
 			if a.CliPID == 0 || cliPIDToNoOfApps[a.CliPID] > 1 {
-				pid = strconv.Itoa(a.DaprdPID)
+				pid = fmt.Sprintf("%v", a.DaprdPID) //nolint: perfsprint
 				cliPIDToNoOfApps[a.CliPID]--
 			} else {
-				pid = strconv.Itoa(a.CliPID)
+				pid = fmt.Sprintf("%v", a.CliPID) //nolint: perfsprint
 			}

 			_, err := utils.RunCmdAndWait("kill", pid)
--- a/pkg/standalone/stop_windows.go
+++ b/pkg/standalone/stop_windows.go
@ -20,7 +20,6 @@ import (
 	"time"

 	"github.com/dapr/cli/utils"
-
 	"github.com/kolesnikovae/go-winjob"
 	"golang.org/x/sys/windows"
 )
--- a/pkg/syscall/syscall_windows.go
+++ b/pkg/syscall/syscall_windows.go
@ -26,7 +26,6 @@ import (
 	"golang.org/x/sys/windows"

 	"github.com/dapr/cli/pkg/print"
-
 	"github.com/kolesnikovae/go-winjob"
 	"github.com/kolesnikovae/go-winjob/jobapi"
 )
--- a/pkg/version/version.go
+++ b/pkg/version/version.go
@ -15,7 +15,6 @@ package version

 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
@ -113,30 +112,23 @@ func GetLatestReleaseGithub(githubURL string) (string, error) {
 		}

 		if len(githubRepoReleases) == 0 {
-			return "", errors.New("no releases")
+			return "", fmt.Errorf("no releases")
 		}

 		defaultVersion, _ := version.NewVersion("0.0.0")
 		latestVersion := defaultVersion

 		for _, release := range githubRepoReleases {
-			cur, err := version.NewVersion(strings.TrimPrefix(release.TagName, "v"))
-			if err != nil || cur == nil {
-				print.WarningStatusEvent(os.Stdout, "Malformed version %s, skipping", release.TagName)
-				continue
-			}
-			// Prerelease versions and versions with metadata are skipped.
-			if cur.Prerelease() != "" || cur.Metadata() != "" {
-				continue
-			}
-
-			if cur.GreaterThan(latestVersion) {
-				latestVersion = cur
+			if !strings.Contains(release.TagName, "-rc") {
+				cur, _ := version.NewVersion(strings.TrimPrefix(release.TagName, "v"))
+				if cur.GreaterThan(latestVersion) {
+					latestVersion = cur
+				}
 			}
 		}

 		if latestVersion.Equal(defaultVersion) {
-			return "", errors.New("no releases")
+			return "", fmt.Errorf("no releases")
 		}

 		return latestVersion.String(), nil
@ -152,7 +144,7 @@ func GetLatestReleaseHelmChart(helmChartURL string) (string, error) {
 			return "", err
 		}
 		if len(helmChartReleases.Entries.Dapr) == 0 {
-			return "", errors.New("no releases")
+			return "", fmt.Errorf("no releases")
 		}

 		for _, release := range helmChartReleases.Entries.Dapr {
@ -167,6 +159,6 @@ func GetLatestReleaseHelmChart(helmChartURL string) (string, error) {
 			return release.Version, nil
 		}

-		return "", errors.New("no releases")
+		return "", fmt.Errorf("no releases")
 	})
 }
--- a/pkg/version/version_test.go
+++ b/pkg/version/version_test.go
@ -162,52 +162,6 @@ func TestGetVersionsGithub(t *testing.T) {
 			"no releases",
 			"",
 		},
-		{
-			"Malformed version no releases",
-			"/malformed_version_no_releases",
-			`[
-  {
-    "url": "https://api.github.com/repos/dapr/dapr/releases/186741665",
-    "html_url": "https://github.com/dapr/dapr/releases/tag/vedge",
-    "id": 186741665,
-    "tag_name": "vedge",
-    "target_commitish": "master",
-    "name": "Dapr Runtime vedge",
-    "draft": false,
-    "prerelease": false
-  }
-]			`,
-			"no releases",
-			"",
-		},
-		{
-			"Malformed version with latest",
-			"/malformed_version_with_latest",
-			`[
-  {
-    "url": "https://api.github.com/repos/dapr/dapr/releases/186741665",
-    "html_url": "https://github.com/dapr/dapr/releases/tag/vedge",
-    "id": 186741665,
-    "tag_name": "vedge",
-    "target_commitish": "master",
-    "name": "Dapr Runtime vedge",
-    "draft": false,
-    "prerelease": false
-  },
-  {
-	"url": "https://api.github.com/repos/dapr/dapr/releases/44766923",
-	"html_url": "https://github.com/dapr/dapr/releases/tag/v1.5.1",
-	"id": 44766923,
-	"tag_name": "v1.5.1",
-	"target_commitish": "master",
-	"name": "Dapr Runtime v1.5.1",
-	"draft": false,
-	"prerelease": false
-  }
-]			`,
-			"",
-			"1.5.1",
-		},
 	}
 	m := http.NewServeMux()
 	s := http.Server{Addr: ":12345", Handler: m, ReadHeaderTimeout: time.Duration(5) * time.Second}
@ -225,7 +179,7 @@ func TestGetVersionsGithub(t *testing.T) {

 	for _, tc := range tests {
 		t.Run(tc.Name, func(t *testing.T) {
-			version, err := GetLatestReleaseGithub("http://localhost:12345" + tc.Path)
+			version, err := GetLatestReleaseGithub(fmt.Sprintf("http://localhost:12345%s", tc.Path))
 			assert.Equal(t, tc.ExpectedVer, version)
 			if tc.ExpectedErr != "" {
 				assert.EqualError(t, err, tc.ExpectedErr)
@ -334,7 +288,7 @@ entries:

 	for _, tc := range tests {
 		t.Run(tc.Name, func(t *testing.T) {
-			version, err := GetLatestReleaseHelmChart("http://localhost:12346" + tc.Path)
+			version, err := GetLatestReleaseHelmChart(fmt.Sprintf("http://localhost:12346%s", tc.Path))
 			assert.Equal(t, tc.ExpectedVer, version)
 			if tc.ExpectedErr != "" {
 				assert.EqualError(t, err, tc.ExpectedErr)
--- a/tests/e2e/common/common.go
+++ b/tests/e2e/common/common.go
@ -19,12 +19,10 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
-	"strconv"
 	"strings"
 	"testing"
 	"time"

-	"github.com/Masterminds/semver/v3"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	core_v1 "k8s.io/api/core/v1"
@ -48,23 +46,12 @@ const (
 	ClusterRoles
 	ClusterRoleBindings

-	numHAPodsWithScheduler      = 16
-	numHAPodsOld                = 13
-	numNonHAPodsWithHAScheduler = 8
-	numNonHAPodsWithScheduler   = 6
-	numNonHAPodsOld             = 5
+	numHAPods    = 13
+	numNonHAPods = 5

 	thirdPartyDevNamespace = "default"
 	devRedisReleaseName    = "dapr-dev-redis"
 	devZipkinReleaseName   = "dapr-dev-zipkin"
-
-	DaprModeHA    = "ha"
-	DaprModeNonHA = "non-ha"
-)
-
-var (
-	VersionWithScheduler   = semver.MustParse("1.14.0-rc.1")
-	VersionWithHAScheduler = semver.MustParse("1.15.0-rc.1")
 )

 type VersionDetails struct {
@ -86,7 +73,6 @@ type TestOptions struct {
 	CheckResourceExists      map[Resource]bool
 	UninstallAll             bool
 	InitWithCustomCert       bool
-	TimeoutSeconds           int
 }

 type TestCase struct {
@ -118,29 +104,6 @@ func GetVersionsFromEnv(t *testing.T, latest bool) (string, string) {
 	return daprRuntimeVersion, daprDashboardVersion
 }

-func GetRuntimeVersion(t *testing.T, latest bool) *semver.Version {
-	daprRuntimeVersion, _ := GetVersionsFromEnv(t, latest)
-	runtimeVersion, err := semver.NewVersion(daprRuntimeVersion)
-	require.NoError(t, err)
-	return runtimeVersion
-}
-
-func GetDaprTestHaMode() string {
-	daprHaMode := os.Getenv("TEST_DAPR_HA_MODE")
-	if daprHaMode != "" {
-		return daprHaMode
-	}
-	return ""
-}
-
-func ShouldSkipTest(mode string) bool {
-	envDaprHaMode := GetDaprTestHaMode()
-	if envDaprHaMode != "" {
-		return envDaprHaMode != mode
-	}
-	return false
-}
-
 func UpgradeTest(details VersionDetails, opts TestOptions) func(t *testing.T) {
 	return func(t *testing.T) {
 		daprPath := GetDaprPath()
@ -161,20 +124,14 @@ func UpgradeTest(details VersionDetails, opts TestOptions) func(t *testing.T) {
 			args = append(args, "--image-variant", details.ImageVariant)
 		}

-		if opts.TimeoutSeconds > 0 {
-			args = append(args, "--timeout", strconv.Itoa(opts.TimeoutSeconds))
-		}
-
 		output, err := spawn.Command(daprPath, args...)
 		t.Log(output)
 		require.NoError(t, err, "upgrade failed")

 		done := make(chan struct{})
-		defer close(done)
 		podsRunning := make(chan struct{})
-		defer close(podsRunning)

-		go waitAllPodsRunning(t, DaprTestNamespace, opts.HAEnabled, done, podsRunning, details)
+		go waitAllPodsRunning(t, DaprTestNamespace, opts.HAEnabled, done, podsRunning)
 		select {
 		case <-podsRunning:
 			t.Logf("verified all pods running in namespace %s are running after upgrade", DaprTestNamespace)
@ -240,7 +197,7 @@ func GetTestsOnInstall(details VersionDetails, opts TestOptions) []TestCase {
 		{"clusterroles exist " + details.RuntimeVersion, ClusterRolesTest(details, opts)},
 		{"clusterrolebindings exist " + details.RuntimeVersion, ClusterRoleBindingsTest(details, opts)},
 		{"apply and check components exist " + details.RuntimeVersion, ComponentsTestOnInstallUpgrade(opts)},
-		{"apply and check httpendpoints exist " + details.RuntimeVersion, HTTPEndpointsTestOnInstallUpgrade(opts, TestOptions{})},
+		{"apply and check httpendpoints exist " + details.RuntimeVersion, HTTPEndpointsTestOnInstallUpgrade(opts)},
 		{"check mtls " + details.RuntimeVersion, MTLSTestOnInstallUpgrade(opts)},
 		{"status check " + details.RuntimeVersion, StatusTestOnInstallUpgrade(details, opts)},
 	}
@ -368,10 +325,10 @@ func ComponentsTestOnInstallUpgrade(opts TestOptions) func(t *testing.T) {
 	}
 }

-func HTTPEndpointsTestOnInstallUpgrade(installOpts TestOptions, upgradeOpts TestOptions) func(t *testing.T) {
+func HTTPEndpointsTestOnInstallUpgrade(opts TestOptions) func(t *testing.T) {
 	return func(t *testing.T) {
 		// if dapr is installed with httpendpoints.
-		if installOpts.ApplyHTTPEndpointChanges {
+		if opts.ApplyHTTPEndpointChanges {
 			// apply any changes to the httpendpoint.
 			t.Log("apply httpendpoint changes")
 			output, err := spawn.Command("kubectl", "apply", "-f", "../testdata/namespace.yaml")
@ -380,17 +337,12 @@ func HTTPEndpointsTestOnInstallUpgrade(installOpts TestOptions, upgradeOpts Test
 			output, err = spawn.Command("kubectl", "apply", "-f", "../testdata/httpendpoint.yaml")
 			t.Log(output)
 			require.NoError(t, err, "expected no error on kubectl apply")
-
-			if installOpts.ApplyHTTPEndpointChanges && upgradeOpts.ApplyHTTPEndpointChanges {
-				require.Equal(t, "httpendpoint.dapr.io/httpendpoint unchanged\n", output, "expected output to match")
-			} else {
-				require.Equal(t, "httpendpoint.dapr.io/httpendpoint created\n", output, "expected output to match")
-			}
+			require.Equal(t, "httpendpoints.dapr.io/httpendpoint created\nhttpendpoints.dapr.io/httpendpoint created\n", output, "expected output to match")
+			httpEndpointOutputCheck(t, output)

 			t.Log("check applied httpendpoint exists")
-			output, err = spawn.Command("kubectl", "get", "httpendpoint")
+			_, err = spawn.Command("kubectl", "get", "httpendpoint")
 			require.NoError(t, err, "expected no error on calling to retrieve httpendpoints")
-			httpEndpointOutputCheck(t, output)
 		}
 	}
 }
@ -400,12 +352,6 @@ func StatusTestOnInstallUpgrade(details VersionDetails, opts TestOptions) func(t
 		daprPath := GetDaprPath()
 		output, err := spawn.Command(daprPath, "status", "-k")
 		require.NoError(t, err, "status check failed")
-
-		version, err := semver.NewVersion(details.RuntimeVersion)
-		if err != nil {
-			t.Error("failed to parse runtime version", err)
-		}
-
 		var notFound map[string][]string
 		if !opts.HAEnabled {
 			notFound = map[string][]string{
@ -415,11 +361,6 @@ func StatusTestOnInstallUpgrade(details VersionDetails, opts TestOptions) func(t
 				"dapr-placement-server": {details.RuntimeVersion, "1"},
 				"dapr-operator":         {details.RuntimeVersion, "1"},
 			}
-			if version.GreaterThanEqual(VersionWithHAScheduler) {
-				notFound["dapr-scheduler-server"] = []string{details.RuntimeVersion, "3"}
-			} else if version.GreaterThanEqual(VersionWithScheduler) {
-				notFound["dapr-scheduler-server"] = []string{details.RuntimeVersion, "1"}
-			}
 		} else {
 			notFound = map[string][]string{
 				"dapr-sentry":           {details.RuntimeVersion, "3"},
@ -428,9 +369,6 @@ func StatusTestOnInstallUpgrade(details VersionDetails, opts TestOptions) func(t
 				"dapr-placement-server": {details.RuntimeVersion, "3"},
 				"dapr-operator":         {details.RuntimeVersion, "3"},
 			}
-			if version.GreaterThanEqual(VersionWithScheduler) {
-				notFound["dapr-scheduler-server"] = []string{details.RuntimeVersion, "3"}
-			}
 		}

 		if details.ImageVariant != "" {
@ -438,9 +376,6 @@ func StatusTestOnInstallUpgrade(details VersionDetails, opts TestOptions) func(t
 			notFound["dapr-sidecar-injector"][0] = notFound["dapr-sidecar-injector"][0] + "-" + details.ImageVariant
 			notFound["dapr-placement-server"][0] = notFound["dapr-placement-server"][0] + "-" + details.ImageVariant
 			notFound["dapr-operator"][0] = notFound["dapr-operator"][0] + "-" + details.ImageVariant
-			if notFound["dapr-scheduler-server"] != nil {
-				notFound["dapr-scheduler-server"][0] = notFound["dapr-scheduler-server"][0] + "-" + details.ImageVariant
-			}
 		}

 		lines := strings.Split(output, "\n")[1:] // remove header of status.
@ -449,13 +384,13 @@ func StatusTestOnInstallUpgrade(details VersionDetails, opts TestOptions) func(t
 			cols := strings.Fields(strings.TrimSpace(line))
 			if len(cols) > 6 { // atleast 6 fields are verified from status (Age and created time are not).
 				if toVerify, ok := notFound[cols[0]]; ok { // get by name.
-					require.Equal(t, DaprTestNamespace, cols[1], "%s namespace must match", cols[0])
-					require.Equal(t, "True", cols[2], "%s healthy field must be true", cols[0])
-					require.Equal(t, "Running", cols[3], "%s pods must be Running", cols[0])
-					require.Equal(t, toVerify[1], cols[4], "%s replicas must be equal", cols[0])
+					require.Equal(t, DaprTestNamespace, cols[1], "namespace must match")
+					require.Equal(t, "True", cols[2], "healthly field must be true")
+					require.Equal(t, "Running", cols[3], "pods must be Running")
+					require.Equal(t, toVerify[1], cols[4], "replicas must be equal")
 					// TODO: Skip the dashboard version check for now until the helm chart is updated.
 					if cols[0] != "dapr-dashboard" {
-						require.Equal(t, toVerify[0], cols[5], "%s versions must match", cols[0])
+						require.Equal(t, toVerify[0], cols[5], "versions must match")
 					}
 					delete(notFound, cols[0])
 				}
@ -609,7 +544,7 @@ func GenerateNewCertAndRenew(details VersionDetails, opts TestOptions) func(t *t
 		done := make(chan struct{})
 		podsRunning := make(chan struct{})

-		go waitAllPodsRunning(t, DaprTestNamespace, opts.HAEnabled, done, podsRunning, details)
+		go waitAllPodsRunning(t, DaprTestNamespace, opts.HAEnabled, done, podsRunning)
 		select {
 		case <-podsRunning:
 			t.Logf("verified all pods running in namespace %s are running after certficate change", DaprTestNamespace)
@ -640,7 +575,7 @@ func UseProvidedPrivateKeyAndRenewCerts(details VersionDetails, opts TestOptions
 		done := make(chan struct{})
 		podsRunning := make(chan struct{})

-		go waitAllPodsRunning(t, DaprTestNamespace, opts.HAEnabled, done, podsRunning, details)
+		go waitAllPodsRunning(t, DaprTestNamespace, opts.HAEnabled, done, podsRunning)
 		select {
 		case <-podsRunning:
 			t.Logf("verified all pods running in namespace %s are running after certficate change", DaprTestNamespace)
@ -673,7 +608,7 @@ func UseProvidedNewCertAndRenew(details VersionDetails, opts TestOptions) func(t
 		done := make(chan struct{})
 		podsRunning := make(chan struct{})

-		go waitAllPodsRunning(t, DaprTestNamespace, opts.HAEnabled, done, podsRunning, details)
+		go waitAllPodsRunning(t, DaprTestNamespace, opts.HAEnabled, done, podsRunning)
 		select {
 		case <-podsRunning:
 			t.Logf("verified all pods running in namespace %s are running after certficate change", DaprTestNamespace)
@ -880,11 +815,8 @@ func uninstallTest(all bool, devEnabled bool) func(t *testing.T) {
 		require.NoError(t, err, "uninstall failed")
 		// wait for pods to be deleted completely.
 		// needed to verify status checks fails correctly.
-		done := make(chan struct{})
-		defer close(done)
 		podsDeleted := make(chan struct{})
-		defer close(podsDeleted)
-
+		done := make(chan struct{})
 		t.Log("waiting for pods to be deleted completely")
 		go waitPodDeletion(t, done, podsDeleted)
 		select {
@ -962,7 +894,7 @@ func componentsTestOnUninstall(opts TestOptions) func(t *testing.T) {
 		lines := strings.Split(output, "\n")

 		// An extra empty line is there in output.
-		require.Len(t, lines, 3, "expected header and warning message of the output to remain")
+		require.Equal(t, 3, len(lines), "expected header and warning message of the output to remain")
 	}
 }

@ -992,7 +924,7 @@ func httpEndpointsTestOnUninstall(opts TestOptions) func(t *testing.T) {
 			lines := strings.Split(output, "\n")

 			// An extra empty line is there in output.
-			require.Len(t, lines, 2, "expected kubernetes response message to remain")
+			require.Equal(t, 2, len(lines), "expected kubernetes response message to remain")
 		}
 	}
 }
@ -1015,19 +947,19 @@ func componentOutputCheck(t *testing.T, opts TestOptions, output string) {
 	}

 	if opts.UninstallAll {
-		assert.Len(t, lines, 2, "expected at 0 components and 2 output lines")
+		assert.Equal(t, 2, len(lines), "expected at 0 components and 2 output lines")
 		return
 	}

-	lines = lines[2:] // remove header and warning message.
+	lines = strings.Split(output, "\n")[2:] // remove header and warning message.

 	if opts.DevEnabled {
 		// default, test statestore.
 		// default pubsub.
 		// 3 components.
-		assert.Len(t, lines, 3, "expected 3 components")
+		assert.Equal(t, 3, len(lines), "expected 3 components")
 	} else {
-		assert.Len(t, lines, 2, "expected 2 components") // default and test namespace components.
+		assert.Equal(t, 2, len(lines), "expected 2 components") // default and test namespace components.

 		// for fresh cluster only one component yaml has been applied.
 		testNsFields := strings.Fields(lines[0])
@ -1187,8 +1119,6 @@ func waitPodDeletionDev(t *testing.T, done, podsDeleted chan struct{}) {
 			devRedisReleaseName:  "dapr-dev-redis-master-",
 			devZipkinReleaseName: "dapr-dev-zipkin-",
 		}
-
-		t.Logf("dev pods waiting to be deleted: %d", len(list.Items))
 		for _, pod := range list.Items {
 			t.Log(pod.ObjectMeta.Name)
 			for component, prefix := range prefixes {
@ -1206,7 +1136,7 @@ func waitPodDeletionDev(t *testing.T, done, podsDeleted chan struct{}) {
 		if len(found) == 2 {
 			podsDeleted <- struct{}{}
 		}
-		time.Sleep(10 * time.Second)
+		time.Sleep(15 * time.Second)
 	}
 }

@ -1218,32 +1148,23 @@ func waitPodDeletion(t *testing.T, done, podsDeleted chan struct{}) {
 		default:
 			break
 		}
-
 		ctx := context.Background()
 		ctxt, cancel := context.WithTimeout(ctx, 10*time.Second)
 		defer cancel()
-
 		k8sClient, err := getClient()
 		require.NoError(t, err, "error getting k8s client for pods check")
-
 		list, err := k8sClient.CoreV1().Pods(DaprTestNamespace).List(ctxt, v1.ListOptions{
 			Limit: 100,
 		})
 		require.NoError(t, err, "error getting pods list from k8s")
-
 		if len(list.Items) == 0 {
 			podsDeleted <- struct{}{}
-		} else {
-			t.Logf("pods waiting to be deleted: %d", len(list.Items))
-			for _, pod := range list.Items {
-				t.Log(pod.ObjectMeta.Name)
-			}
 		}
-		time.Sleep(5 * time.Second)
+		time.Sleep(15 * time.Second)
 	}
 }

-func waitAllPodsRunning(t *testing.T, namespace string, haEnabled bool, done, podsRunning chan struct{}, details VersionDetails) {
+func waitAllPodsRunning(t *testing.T, namespace string, haEnabled bool, done, podsRunning chan struct{}) {
 	for {
 		select {
 		case <-done: // if timeout was reached.
@ -1253,18 +1174,15 @@ func waitAllPodsRunning(t *testing.T, namespace string, haEnabled bool, done, po
 		}
 		ctx := context.Background()
 		ctxt, cancel := context.WithTimeout(ctx, 10*time.Second)
-
+		defer cancel()
 		k8sClient, err := getClient()
 		require.NoError(t, err, "error getting k8s client for pods check")
 		list, err := k8sClient.CoreV1().Pods(namespace).List(ctxt, v1.ListOptions{
 			Limit: 100,
 		})
 		require.NoError(t, err, "error getting pods list from k8s")
-
-		t.Logf("waiting for pods to be running, current count: %d", len(list.Items))
 		countOfReadyPods := 0
 		for _, item := range list.Items {
-			t.Log(item.ObjectMeta.Name)
 			// Check pods running, and containers ready.
 			if item.Status.Phase == core_v1.PodRunning && len(item.Status.ContainerStatuses) != 0 {
 				size := len(item.Status.ContainerStatuses)
@ -1278,50 +1196,11 @@ func waitAllPodsRunning(t *testing.T, namespace string, haEnabled bool, done, po
 				}
 			}
 		}
-		pods, err := getVersionedNumberOfPods(haEnabled, details)
-		if err != nil {
-			t.Error(err)
-		}
-		if len(list.Items) == countOfReadyPods && countOfReadyPods == pods {
+		if len(list.Items) == countOfReadyPods && ((haEnabled && countOfReadyPods == numHAPods) || (!haEnabled && countOfReadyPods == numNonHAPods)) {
 			podsRunning <- struct{}{}
 		}

-		time.Sleep(5 * time.Second)
-
-		cancel()
-	}
-}
-
-func getVersionedNumberOfPods(isHAEnabled bool, details VersionDetails) (int, error) {
-	if isHAEnabled {
-		if details.UseDaprLatestVersion {
-			return numHAPodsWithScheduler, nil
-		}
-		rv, err := semver.NewVersion(details.RuntimeVersion)
-		if err != nil {
-			return 0, err
-		}
-
-		if rv.GreaterThanEqual(VersionWithScheduler) {
-			return numHAPodsWithScheduler, nil
-		}
-		return numHAPodsOld, nil
-	} else {
-		if details.UseDaprLatestVersion {
-			return numNonHAPodsWithHAScheduler, nil
-		}
-		rv, err := semver.NewVersion(details.RuntimeVersion)
-		if err != nil {
-			return 0, err
-		}
-
-		if rv.GreaterThanEqual(VersionWithHAScheduler) {
-			return numNonHAPodsWithHAScheduler, nil
-		}
-		if rv.GreaterThanEqual(VersionWithScheduler) {
-			return numNonHAPodsWithScheduler, nil
-		}
-		return numNonHAPodsOld, nil
+		time.Sleep(15 * time.Second)
 	}
 }

--- a/tests/e2e/common/common_test.go
+++ b/tests/e2e/common/common_test.go
@ -1,113 +0,0 @@
-/*
-Copyright 2024 The Dapr Authors
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package common
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGetVersionedNumberOfPods(t *testing.T) {
-	tests := []struct {
-		name           string
-		isHAEnabled    bool
-		details        VersionDetails
-		expectedNumber int
-		expectedError  bool
-	}{
-		{
-			name:           "HA enabled with latest version",
-			isHAEnabled:    true,
-			details:        VersionDetails{UseDaprLatestVersion: true},
-			expectedNumber: numHAPodsWithScheduler,
-			expectedError:  false,
-		},
-		{
-			name:           "HA enabled with old version",
-			isHAEnabled:    true,
-			details:        VersionDetails{UseDaprLatestVersion: false, RuntimeVersion: "1.13.0"},
-			expectedNumber: numHAPodsOld,
-			expectedError:  false,
-		},
-		{
-			name:           "HA disabled with latest version",
-			isHAEnabled:    false,
-			details:        VersionDetails{UseDaprLatestVersion: true},
-			expectedNumber: numNonHAPodsWithScheduler,
-			expectedError:  false,
-		},
-		{
-			name:           "HA disabled with old version",
-			isHAEnabled:    false,
-			details:        VersionDetails{UseDaprLatestVersion: false, RuntimeVersion: "1.13.0"},
-			expectedNumber: numNonHAPodsOld,
-			expectedError:  false,
-		},
-		{
-			name:           "HA enabled with new version",
-			isHAEnabled:    true,
-			details:        VersionDetails{UseDaprLatestVersion: false, RuntimeVersion: "1.14.4"},
-			expectedNumber: numHAPodsWithScheduler,
-			expectedError:  false,
-		},
-		{
-			name:           "HA disabled with new version",
-			isHAEnabled:    false,
-			details:        VersionDetails{UseDaprLatestVersion: false, RuntimeVersion: "1.14.4"},
-			expectedNumber: numNonHAPodsWithScheduler,
-			expectedError:  false,
-		},
-		{
-			name:           "HA enabled with invalid version",
-			isHAEnabled:    true,
-			details:        VersionDetails{UseDaprLatestVersion: false, RuntimeVersion: "invalid version"},
-			expectedNumber: 0,
-			expectedError:  true,
-		},
-		{
-			name:           "HA disabled with invalid version",
-			isHAEnabled:    false,
-			details:        VersionDetails{UseDaprLatestVersion: false, RuntimeVersion: "invalid version"},
-			expectedNumber: 0,
-			expectedError:  true,
-		},
-		{
-			name:           "HA enabled with new RC version",
-			isHAEnabled:    true,
-			details:        VersionDetails{UseDaprLatestVersion: false, RuntimeVersion: "1.15.0-rc.1"},
-			expectedNumber: numHAPodsWithScheduler,
-			expectedError:  false,
-		},
-		{
-			name:           "HA disabled with new RC version",
-			isHAEnabled:    false,
-			details:        VersionDetails{UseDaprLatestVersion: false, RuntimeVersion: "1.15.0-rc.1"},
-			expectedNumber: numNonHAPodsWithScheduler,
-			expectedError:  false,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			number, err := getVersionedNumberOfPods(tc.isHAEnabled, tc.details)
-			if tc.expectedError {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				assert.Equal(t, tc.expectedNumber, number)
-			}
-		})
-	}
-}
--- a/tests/e2e/kubernetes/kubernetes_test.go
+++ b/tests/e2e/kubernetes/kubernetes_test.go
@ -17,17 +17,12 @@ limitations under the License.
 package kubernetes_test

 import (
-	"fmt"
 	"testing"

 	"github.com/dapr/cli/tests/e2e/common"
 )

 func TestKubernetesNonHAModeMTLSDisabled(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, false)

@ -59,10 +54,6 @@ func TestKubernetesNonHAModeMTLSDisabled(t *testing.T) {
 }

 func TestKubernetesHAModeMTLSDisabled(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, false)

@ -94,10 +85,6 @@ func TestKubernetesHAModeMTLSDisabled(t *testing.T) {
 }

 func TestKubernetesDev(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, false)

@ -132,10 +119,6 @@ func TestKubernetesDev(t *testing.T) {
 }

 func TestKubernetesNonHAModeMTLSEnabled(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, false)

@ -167,10 +150,6 @@ func TestKubernetesNonHAModeMTLSEnabled(t *testing.T) {
 }

 func TestKubernetesHAModeMTLSEnabled(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, false)

@ -203,10 +182,6 @@ func TestKubernetesHAModeMTLSEnabled(t *testing.T) {
 }

 func TestKubernetesInitWithCustomCert(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, false)

@ -241,10 +216,6 @@ func TestKubernetesInitWithCustomCert(t *testing.T) {
 // Test for certificate renewal

 func TestRenewCertificateMTLSEnabled(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, false)

@ -280,10 +251,6 @@ func TestRenewCertificateMTLSEnabled(t *testing.T) {
 }

 func TestRenewCertificateMTLSDisabled(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, false)

@ -319,10 +286,6 @@ func TestRenewCertificateMTLSDisabled(t *testing.T) {
 }

 func TestRenewCertWithPrivateKey(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, false)

@ -365,10 +328,6 @@ func TestRenewCertWithPrivateKey(t *testing.T) {
 }

 func TestKubernetesUninstall(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, false)

@ -400,10 +359,6 @@ func TestKubernetesUninstall(t *testing.T) {
 }

 func TestRenewCertWithIncorrectFlags(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	common.EnsureUninstall(true, true)

 	tests := []common.TestCase{}
@ -442,10 +397,6 @@ func TestRenewCertWithIncorrectFlags(t *testing.T) {
 // install dapr control plane with mariner docker images.
 // Renew the certificate of this control plane.
 func TestK8sInstallwithMarinerImagesAndRenewCertificate(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, false)

@ -484,10 +435,6 @@ func TestK8sInstallwithMarinerImagesAndRenewCertificate(t *testing.T) {
 }

 func TestKubernetesInstallwithoutRuntimeVersionFlag(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, true)

@ -520,10 +467,6 @@ func TestKubernetesInstallwithoutRuntimeVersionFlag(t *testing.T) {
 }

 func TestK8sInstallwithoutRuntimeVersionwithMarinerImagesFlag(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// ensure clean env for test
 	ensureCleanEnv(t, true)

--- a/tests/e2e/kubernetes/run_template_test.go
+++ b/tests/e2e/kubernetes/run_template_test.go
@ -47,10 +47,6 @@ var (
 )

 func TestKubernetesRunFile(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	ensureCleanEnv(t, false)

 	// setup tests
--- a/tests/e2e/standalone/commands.go
+++ b/tests/e2e/standalone/commands.go
@ -1,4 +1,5 @@
 //go:build e2e || template
+// +build e2e template

 /*
 Copyright 2022 The Dapr Authors
@ -18,10 +19,8 @@ package standalone_test
 import (
 	"context"
 	"fmt"
-	"path/filepath"
 	"strings"

-	"github.com/dapr/cli/pkg/standalone"
 	"github.com/dapr/cli/tests/e2e/common"
 	"github.com/dapr/cli/tests/e2e/spawn"
 	"github.com/dapr/cli/utils"
@ -48,47 +47,6 @@ func cmdDashboard(ctx context.Context, port string) error {
 	return fmt.Errorf("Dashboard could not be started: %s", errOutput)
 }

-func cmdProcess(ctx context.Context, executable string, log func(args ...any), args ...string) (string, error) {
-	path, err := GetExecutablePath(executable)
-	if err != nil {
-		return "", err
-	}
-
-	stdOutChan, stdErrChan, err := spawn.CommandWithContext(ctx, path, args...)
-	if err != nil {
-		return "", err
-	}
-
-	if log != nil {
-		go func() {
-			for {
-				select {
-				case output := <-stdOutChan:
-					if output != "" {
-						log(executable + ": " + output)
-					}
-				case output := <-stdErrChan:
-					if output != "" {
-						log(executable + ": " + output)
-					}
-				case <-ctx.Done():
-					return
-				}
-			}
-		}()
-	}
-
-	return "", nil
-}
-
-func GetExecutablePath(executable string) (string, error) {
-	path, err := standalone.GetDaprRuntimePath("")
-	if err != nil {
-		return "", err
-	}
-	return filepath.Join(path, "bin", executable), nil
-}
-
 // cmdInit installs Dapr with the init command and returns the command output and error.
 //
 // When DAPR_E2E_INIT_SLIM is true, it will install Dapr without Docker containers.
--- a/tests/e2e/standalone/init_negative_test.go
+++ b/tests/e2e/standalone/init_negative_test.go
@ -1,4 +1,5 @@
 //go:build e2e && !template
+// +build e2e,!template

 /*
 Copyright 2022 The Dapr Authors
@ -32,6 +33,7 @@ func TestStandaloneInitNegatives(t *testing.T) {
 	require.NoError(t, err, "expected no error on querying for os home dir")

 	t.Run("run without install", func(t *testing.T) {
+		t.Parallel()
 		output, err := cmdRun("")
 		require.Error(t, err, "expected error status on run without install")
 		path := filepath.Join(homeDir, ".dapr", "components")
@ -43,18 +45,21 @@ func TestStandaloneInitNegatives(t *testing.T) {
 	})

 	t.Run("list without install", func(t *testing.T) {
+		t.Parallel()
 		output, err := cmdList("")
 		require.NoError(t, err, "expected no error status on list without install")
 		require.Equal(t, "No Dapr instances found.\n", output)
 	})

 	t.Run("stop without install", func(t *testing.T) {
+		t.Parallel()
 		output, err := cmdStopWithAppID("test")
 		require.NoError(t, err, "expected no error on stop without install")
 		require.Contains(t, output, "failed to stop app id test: couldn't find app id test", "expected output to match")
 	})

 	t.Run("uninstall without install", func(t *testing.T) {
+		t.Parallel()
 		output, err := cmdUninstall()
 		require.NoError(t, err, "expected no error on uninstall without install")
 		require.Contains(t, output, "Removing Dapr from your machine...", "expected output to contain message")
--- a/tests/e2e/standalone/init_run_custom_path_test.go
+++ b/tests/e2e/standalone/init_run_custom_path_test.go
@ -1,4 +1,5 @@
 //go:build e2e && !template
+// +build e2e,!template

 /*
 Copyright 2022 The Dapr Authors
--- a/tests/e2e/standalone/init_test.go
+++ b/tests/e2e/standalone/init_test.go
@ -1,4 +1,5 @@
 //go:build e2e && !template
+// +build e2e,!template

 /*
 Copyright 2022 The Dapr Authors
@ -27,7 +28,6 @@ import (
 	"time"

 	"github.com/Masterminds/semver"
-	"github.com/dapr/cli/pkg/version"
 	"github.com/dapr/cli/tests/e2e/common"
 	"github.com/dapr/cli/tests/e2e/spawn"
 	"github.com/docker/docker/api/types"
@ -157,11 +157,7 @@ func TestStandaloneInit(t *testing.T) {
 		daprPath := filepath.Join(homeDir, ".dapr")
 		require.DirExists(t, daprPath, "Directory %s does not exist", daprPath)

-		latestDaprRuntimeVersion, err := version.GetDaprVersion()
-		require.NoError(t, err)
-		latestDaprDashboardVersion, err := version.GetDashboardVersion()
-		require.NoError(t, err)
-
+		latestDaprRuntimeVersion, latestDaprDashboardVersion := common.GetVersionsFromEnv(t, true)
 		verifyContainers(t, latestDaprRuntimeVersion)
 		verifyBinaries(t, daprPath, latestDaprRuntimeVersion, latestDaprDashboardVersion)
 		verifyConfigs(t, daprPath)
@ -171,17 +167,15 @@ func TestStandaloneInit(t *testing.T) {
 			placementPort = 6050
 		}

-		verifyTCPLocalhost(t, placementPort)
+		verifyTCPLocalhost(t,  placementPort)
 	})

 	t.Run("init version with scheduler", func(t *testing.T) {
 		// Ensure a clean environment
 		must(t, cmdUninstall, "failed to uninstall Dapr")

-		latestDaprRuntimeVersion, latestDaprDashboardVersion := common.GetVersionsFromEnv(t, true)
-
 		args := []string{
-			"--runtime-version", latestDaprRuntimeVersion,
+			"--runtime-version", "1.14.0-rc.3",
 			"--dev",
 		}
 		output, err := cmdInit(args...)
@ -195,8 +189,9 @@ func TestStandaloneInit(t *testing.T) {
 		daprPath := filepath.Join(homeDir, ".dapr")
 		require.DirExists(t, daprPath, "Directory %s does not exist", daprPath)

-		verifyContainers(t, latestDaprRuntimeVersion)
-		verifyBinaries(t, daprPath, latestDaprRuntimeVersion, latestDaprDashboardVersion)
+		_, latestDaprDashboardVersion := common.GetVersionsFromEnv(t, true)
+		verifyContainers(t, "1.14.0-rc.3")
+		verifyBinaries(t, daprPath, "1.14.0-rc.3", latestDaprDashboardVersion)
 		verifyConfigs(t, daprPath)

 		placementPort := 50005
@ -206,8 +201,8 @@ func TestStandaloneInit(t *testing.T) {
 			schedulerPort = 6060
 		}

-		verifyTCPLocalhost(t, placementPort)
-		verifyTCPLocalhost(t, schedulerPort)
+		verifyTCPLocalhost(t,  placementPort)
+		verifyTCPLocalhost(t,  schedulerPort)
 	})

 	t.Run("init without runtime-version flag with mariner images", func(t *testing.T) {
@ -227,11 +222,7 @@ func TestStandaloneInit(t *testing.T) {
 		daprPath := filepath.Join(homeDir, ".dapr")
 		require.DirExists(t, daprPath, "Directory %s does not exist", daprPath)

-		latestDaprRuntimeVersion, err := version.GetDaprVersion()
-		require.NoError(t, err)
-		latestDaprDashboardVersion, err := version.GetDashboardVersion()
-		require.NoError(t, err)
-
+		latestDaprRuntimeVersion, latestDaprDashboardVersion := common.GetVersionsFromEnv(t, true)
 		verifyContainers(t, latestDaprRuntimeVersion+"-mariner")
 		verifyBinaries(t, daprPath, latestDaprRuntimeVersion, latestDaprDashboardVersion)
 		verifyConfigs(t, daprPath)
--- a/tests/e2e/standalone/invoke_test.go
+++ b/tests/e2e/standalone/invoke_test.go
@ -1,4 +1,5 @@
 //go:build e2e && !template
+// +build e2e,!template

 /*
 Copyright 2022 The Dapr Authors
--- a/tests/e2e/standalone/list_test.go
+++ b/tests/e2e/standalone/list_test.go
@ -1,4 +1,5 @@
 //go:build e2e && !template
+// +build e2e,!template

 /*
 Copyright 2022 The Dapr Authors
@ -136,13 +137,6 @@ func TestStandaloneList(t *testing.T) {
 		t.Log(output)
 		require.NoError(t, err, "expected no error status on list")
 		require.Equal(t, "No Dapr instances found.\n", output)
-
-		// This test is skipped on Windows, but just in case, try to terminate dashboard process only on non-Windows OSs
-		// stopProcess uses kill command, won't work on windows
-		if runtime.GOOS != "windows" {
-			err = stopProcess("dashboard", "--port", "5555")
-			require.NoError(t, err, "failed to stop dashboard process")
-		}
 	})
 }

--- a/tests/e2e/standalone/publish_test.go
+++ b/tests/e2e/standalone/publish_test.go
@ -1,4 +1,5 @@
 //go:build e2e && !template
+// +build e2e,!template

 /*
 Copyright 2022 The Dapr Authors
--- a/tests/e2e/standalone/run_template_test.go
+++ b/tests/e2e/standalone/run_template_test.go
@ -1,4 +1,6 @@
 //go:build !windows && (e2e || template)
+// +build !windows
+// +build e2e template

 /*
 Copyright 2023 The Dapr Authors
@ -21,6 +23,7 @@ import (
 	"context"
 	"fmt"
 	"io/ioutil"
+	"os"
 	"path/filepath"
 	"strings"
 	"testing"
@ -40,7 +43,6 @@ type AppTestOutput struct {
 }

 func TestRunWithTemplateFile(t *testing.T) {
-	cleanUpLogs()
 	ensureDaprInstallation(t)
 	t.Cleanup(func() {
 		// remove dapr installation after all tests in this function.
@ -52,7 +54,8 @@ func TestRunWithTemplateFile(t *testing.T) {
 		runFilePath := "../testdata/run-template-files/wrong_emit_metrics_app_dapr.yaml"
 		t.Cleanup(func() {
 			// assumption in the test is that there is only one set of app and daprd logs in the logs directory.
-			cleanUpLogs()
+			os.RemoveAll("../../apps/emit-metrics/.dapr/logs")
+			os.RemoveAll("../../apps/processor/.dapr/logs")
 			stopAllApps(t, runFilePath)
 		})
 		args := []string{
@ -101,7 +104,8 @@ func TestRunWithTemplateFile(t *testing.T) {
 		runFilePath := "../testdata/run-template-files/dapr.yaml"
 		t.Cleanup(func() {
 			// assumption in the test is that there is only one set of app and daprd logs in the logs directory.
-			cleanUpLogs()
+			os.RemoveAll("../../apps/emit-metrics/.dapr/logs")
+			os.RemoveAll("../../apps/processor/.dapr/logs")
 			stopAllApps(t, runFilePath)
 		})
 		args := []string{
@ -157,7 +161,8 @@ func TestRunWithTemplateFile(t *testing.T) {
 		runFilePath := "../testdata/run-template-files/env_var_not_set_dapr.yaml"
 		t.Cleanup(func() {
 			// assumption in the test is that there is only one set of app and daprd logs in the logs directory.
-			cleanUpLogs()
+			os.RemoveAll("../../apps/emit-metrics/.dapr/logs")
+			os.RemoveAll("../../apps/processor/.dapr/logs")
 			stopAllApps(t, runFilePath)
 		})
 		args := []string{
@ -207,7 +212,8 @@ func TestRunWithTemplateFile(t *testing.T) {
 		runFilePath := "../testdata/run-template-files/no_app_command.yaml"
 		t.Cleanup(func() {
 			// assumption in the test is that there is only one set of app and daprd logs in the logs directory.
-			cleanUpLogs()
+			os.RemoveAll("../../apps/emit-metrics/.dapr/logs")
+			os.RemoveAll("../../apps/processor/.dapr/logs")
 			stopAllApps(t, runFilePath)
 		})
 		args := []string{
@ -258,7 +264,8 @@ func TestRunWithTemplateFile(t *testing.T) {
 		runFilePath := "../testdata/run-template-files/empty_app_command.yaml"
 		t.Cleanup(func() {
 			// assumption in the test is that there is only one set of app and daprd logs in the logs directory.
-			cleanUpLogs()
+			os.RemoveAll("../../apps/emit-metrics/.dapr/logs")
+			os.RemoveAll("../../apps/processor/.dapr/logs")
 			stopAllApps(t, runFilePath)
 		})
 		args := []string{
@ -306,7 +313,8 @@ func TestRunWithTemplateFile(t *testing.T) {
 		runFilePath := "../testdata/run-template-files/app_output_to_file_and_console.yaml"
 		t.Cleanup(func() {
 			// assumption in the test is that there is only one set of app and daprd logs in the logs directory.
-			cleanUpLogs()
+			os.RemoveAll("../../apps/emit-metrics/.dapr/logs")
+			os.RemoveAll("../../apps/processor/.dapr/logs")
 			stopAllApps(t, runFilePath)
 		})
 		args := []string{
@ -364,10 +372,6 @@ func TestRunTemplateFileWithoutDaprInit(t *testing.T) {
 	// remove any dapr installation before this test.
 	must(t, cmdUninstall, "failed to uninstall Dapr")
 	t.Run("valid template file without dapr init", func(t *testing.T) {
-		t.Cleanup(func() {
-			// assumption in the test is that there is only one set of app and daprd logs in the logs directory.
-			cleanUpLogs()
-		})
 		args := []string{
 			"-f", "../testdata/run-template-files/no_app_command.yaml",
 		}
--- a/tests/e2e/standalone/run_test.go
+++ b/tests/e2e/standalone/run_test.go
@ -1,4 +1,5 @@
 //go:build e2e && !template
+// +build e2e,!template

 /*
 Copyright 2022 The Dapr Authors
@ -16,39 +17,19 @@ limitations under the License.
 package standalone_test

 import (
-	"context"
 	"fmt"
 	"runtime"
 	"testing"

-	"github.com/dapr/cli/tests/e2e/common"
-
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )

 func TestStandaloneRun(t *testing.T) {
 	ensureDaprInstallation(t)
-
-	ctx, cancelFunc := context.WithCancel(context.Background())
-	defer cancelFunc()
-
-	if isSlimMode() {
-		output, err := cmdProcess(ctx, "placement", t.Log, "--metrics-port", "9091", "--healthz-port", "8081")
-		require.NoError(t, err)
-		t.Log(output)
-
-		if common.GetRuntimeVersion(t, false).GreaterThan(common.VersionWithScheduler) {
-			output, err = cmdProcess(ctx, "scheduler", t.Log, "--metrics-port", "9092", "--healthz-port", "8082")
-			require.NoError(t, err)
-			t.Log(output)
-		}
-	}
 	t.Cleanup(func() {
 		// remove dapr installation after all tests in this function.
 		must(t, cmdUninstall, "failed to uninstall Dapr")
-		// Call cancelFunc to stop the processes
-		cancelFunc()
 	})
 	for _, path := range getSocketCases() {
 		t.Run(fmt.Sprintf("normal exit, socket: %s", path), func(t *testing.T) {
@ -73,11 +54,7 @@ func TestStandaloneRun(t *testing.T) {
 			output, err := cmdRun(path, "--dapr-internal-grpc-port", "9999", "--", "bash", "-c", "echo test")
 			t.Log(output)
 			require.NoError(t, err, "run failed")
-			if common.GetRuntimeVersion(t, false).GreaterThan(common.VersionWithScheduler) {
-				assert.Contains(t, output, "Internal gRPC server is running on :9999")
-			} else {
-				assert.Contains(t, output, "Internal gRPC server is running on port 9999")
-			}
+			assert.Contains(t, output, "Internal gRPC server is running on port 9999")
 			assert.Contains(t, output, "Exited App successfully")
 			assert.Contains(t, output, "Exited Dapr successfully")
 			assert.NotContains(t, output, "Could not update sidecar metadata for cliPID")
--- a/tests/e2e/standalone/stop_test.go
+++ b/tests/e2e/standalone/stop_test.go
@ -1,4 +1,5 @@
 //go:build e2e && !template
+// +build e2e,!template

 /*
 Copyright 2022 The Dapr Authors
@ -17,7 +18,6 @@ package standalone_test

 import (
 	"testing"
-	"time"

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@ -25,14 +25,6 @@ import (

 func TestStandaloneStop(t *testing.T) {
 	ensureDaprInstallation(t)
-
-	time.Sleep(5 * time.Second)
-
-	t.Cleanup(func() {
-		// remove dapr installation after all tests in this function.
-		must(t, cmdUninstall, "failed to uninstall Dapr")
-	})
-
 	executeAgainstRunningDapr(t, func() {
 		t.Run("stop", func(t *testing.T) {
 			output, err := cmdStopWithAppID("dapr_e2e_stop")
--- a/tests/e2e/standalone/stop_with_run_template_test.go
+++ b/tests/e2e/standalone/stop_with_run_template_test.go
@ -1,4 +1,6 @@
 //go:build !windows && (e2e || template)
+// +build !windows
+// +build e2e template

 /*
 Copyright 2023 The Dapr Authors
@ -20,6 +22,7 @@ package standalone_test
 import (
 	"encoding/json"
 	"fmt"
+	"os"
 	"testing"
 	"time"

@ -28,9 +31,6 @@ import (
 )

 func TestStopAppsStartedWithRunTemplate(t *testing.T) {
-	// clean up logs before starting the tests
-	cleanUpLogs()
-
 	ensureDaprInstallation(t)
 	t.Cleanup(func() {
 		// remove dapr installation after all tests in this function.
@ -38,9 +38,6 @@ func TestStopAppsStartedWithRunTemplate(t *testing.T) {
 	})

 	t.Run("stop apps by passing run template file", func(t *testing.T) {
-		t.Cleanup(func() {
-			cleanUpLogs()
-		})
 		go ensureAllAppsStartedWithRunTemplate(t)
 		time.Sleep(10 * time.Second)
 		cliPID := getCLIPID(t)
@ -53,9 +50,6 @@ func TestStopAppsStartedWithRunTemplate(t *testing.T) {
 	})

 	t.Run("stop apps by passing a directory containing dapr.yaml", func(t *testing.T) {
-		t.Cleanup(func() {
-			cleanUpLogs()
-		})
 		go ensureAllAppsStartedWithRunTemplate(t)
 		time.Sleep(10 * time.Second)
 		cliPID := getCLIPID(t)
@ -66,9 +60,6 @@ func TestStopAppsStartedWithRunTemplate(t *testing.T) {
 	})

 	t.Run("stop apps by passing an invalid directory", func(t *testing.T) {
-		t.Cleanup(func() {
-			cleanUpLogs()
-		})
 		go ensureAllAppsStartedWithRunTemplate(t)
 		time.Sleep(10 * time.Second)
 		output, err := cmdStopWithRunTemplate("../testdata/invalid-dir")
@ -81,9 +72,6 @@ func TestStopAppsStartedWithRunTemplate(t *testing.T) {
 	})

 	t.Run("stop apps started with run template", func(t *testing.T) {
-		t.Cleanup(func() {
-			cleanUpLogs()
-		})
 		go ensureAllAppsStartedWithRunTemplate(t)
 		time.Sleep(10 * time.Second)
 		cliPID := getCLIPID(t)
@ -107,7 +95,8 @@ func ensureAllAppsStartedWithRunTemplate(t *testing.T) {
 func tearDownTestSetup(t *testing.T) {
 	// remove dapr installation after all tests in this function.
 	must(t, cmdUninstall, "failed to uninstall Dapr")
-	cleanUpLogs()
+	os.RemoveAll("../../apps/emit-metrics/.dapr/logs")
+	os.RemoveAll("../../apps/processor/.dapr/logs")
 }

 func getCLIPID(t *testing.T) string {
--- a/tests/e2e/standalone/uninstall_test.go
+++ b/tests/e2e/standalone/uninstall_test.go
@ -1,4 +1,5 @@
 //go:build e2e && !template
+// +build e2e,!template

 /*
 Copyright 2022 The Dapr Authors
--- a/tests/e2e/standalone/utils.go
+++ b/tests/e2e/standalone/utils.go
@ -1,4 +1,5 @@
 //go:build e2e || template
+// +build e2e template

 /*
 Copyright 2022 The Dapr Authors
@ -156,40 +157,3 @@ func containerRuntime() string {
 	}
 	return ""
 }
-
-func getRunningProcesses() []string {
-	cmd := exec.Command("ps", "-o", "pid,command")
-	output, err := cmd.Output()
-	if err != nil {
-		return nil
-	}
-
-	processes := strings.Split(string(output), "\n")
-
-	// clean the process output whitespace
-	for i, process := range processes {
-		processes[i] = strings.TrimSpace(process)
-	}
-	return processes
-}
-
-func stopProcess(args ...string) error {
-	processCommand := strings.Join(args, " ")
-	processes := getRunningProcesses()
-	for _, process := range processes {
-		if strings.Contains(process, processCommand) {
-			processSplit := strings.SplitN(process, " ", 2)
-			cmd := exec.Command("kill", "-9", processSplit[0])
-			err := cmd.Run()
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func cleanUpLogs() {
-	os.RemoveAll("../../apps/emit-metrics/.dapr/logs")
-	os.RemoveAll("../../apps/processor/.dapr/logs")
-}
--- a/tests/e2e/standalone/version_test.go
+++ b/tests/e2e/standalone/version_test.go
@ -1,4 +1,5 @@
 //go:build e2e && !template
+// +build e2e,!template

 /*
 Copyright 2022 The Dapr Authors
--- a/tests/e2e/standalone/windows_run_template_test.go
+++ b/tests/e2e/standalone/windows_run_template_test.go
@ -1,4 +1,6 @@
 //go:build windows && (e2e || template)
+// +build windows
+// +build e2e template

 /*
 Copyright 2023 The Dapr Authors
--- a/tests/e2e/upgrade/upgrade_test.go
+++ b/tests/e2e/upgrade/upgrade_test.go
@ -33,30 +33,48 @@ var supportedUpgradePaths = []upgradePath{
 	{
 		// test upgrade on mariner images.
 		previous: common.VersionDetails{
-			RuntimeVersion:      "1.14.4",
-			DashboardVersion:    "0.15.0",
-			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
-			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
-			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io", "httpendpoints.dapr.io"},
+			RuntimeVersion:      "1.8.0",
+			DashboardVersion:    "0.10.0",
+			ImageVariant:        "mariner",
+			ClusterRoles:        []string{"dapr-operator-admin", "dashboard-reader"},
+			ClusterRoleBindings: []string{"dapr-operator", "dapr-role-tokenreview-binding", "dashboard-reader-global"},
+			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io"},
 		},
 		next: common.VersionDetails{
-			RuntimeVersion:      "1.15.2",
-			DashboardVersion:    "0.15.0",
-			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
-			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
-			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io", "httpendpoints.dapr.io"},
+			RuntimeVersion:      "1.8.7",
+			DashboardVersion:    "0.10.0",
+			ImageVariant:        "mariner",
+			ClusterRoles:        []string{"dapr-operator-admin", "dashboard-reader"},
+			ClusterRoleBindings: []string{"dapr-operator", "dapr-role-tokenreview-binding", "dashboard-reader-global"},
+			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io"},
 		},
 	},
 	{
 		previous: common.VersionDetails{
-			RuntimeVersion:      "1.13.6",
+			RuntimeVersion:      "1.9.5",
+			DashboardVersion:    "0.11.0",
+			ClusterRoles:        []string{"dapr-operator-admin", "dashboard-reader"},
+			ClusterRoleBindings: []string{"dapr-operator", "dapr-role-tokenreview-binding", "dashboard-reader-global"},
+			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io"},
+		},
+		next: common.VersionDetails{
+			RuntimeVersion:      "1.10.7",
+			DashboardVersion:    "0.12.0",
+			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
+			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
+			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io"},
+		},
+	},
+	{
+		previous: common.VersionDetails{
+			RuntimeVersion:      "1.11.0",
 			DashboardVersion:    "0.14.0",
 			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
 			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
 			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io", "httpendpoints.dapr.io"},
 		},
 		next: common.VersionDetails{
-			RuntimeVersion:      "1.14.4",
+			RuntimeVersion:      "1.12.0",
 			DashboardVersion:    "0.14.0",
 			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
 			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
@ -65,30 +83,14 @@ var supportedUpgradePaths = []upgradePath{
 	},
 	{
 		previous: common.VersionDetails{
-			RuntimeVersion:      "1.13.6",
+			RuntimeVersion:      "1.12.0",
 			DashboardVersion:    "0.14.0",
 			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
 			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
 			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io", "httpendpoints.dapr.io"},
 		},
 		next: common.VersionDetails{
-			RuntimeVersion:      "1.15.2",
-			DashboardVersion:    "0.14.0",
-			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
-			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
-			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io", "httpendpoints.dapr.io"},
-		},
-	},
-	{
-		previous: common.VersionDetails{
-			RuntimeVersion:      "1.14.4",
-			DashboardVersion:    "0.14.0",
-			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
-			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
-			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io", "httpendpoints.dapr.io"},
-		},
-		next: common.VersionDetails{
-			RuntimeVersion:      "1.15.2",
+			RuntimeVersion:      "1.13.0-rc.2",
 			DashboardVersion:    "0.14.0",
 			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
 			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
@ -98,14 +100,14 @@ var supportedUpgradePaths = []upgradePath{
 	// test downgrade.
 	{
 		previous: common.VersionDetails{
-			RuntimeVersion:      "1.15.2",
+			RuntimeVersion:      "1.13.0-rc.2",
 			DashboardVersion:    "0.14.0",
 			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
 			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
 			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io", "httpendpoints.dapr.io"},
 		},
 		next: common.VersionDetails{
-			RuntimeVersion:      "1.14.4",
+			RuntimeVersion:      "1.12.0",
 			DashboardVersion:    "0.14.0",
 			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
 			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
@ -114,30 +116,14 @@ var supportedUpgradePaths = []upgradePath{
 	},
 	{
 		previous: common.VersionDetails{
-			RuntimeVersion:      "1.15.2",
+			RuntimeVersion:      "1.12.0",
 			DashboardVersion:    "0.14.0",
 			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
 			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
 			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io", "httpendpoints.dapr.io"},
 		},
 		next: common.VersionDetails{
-			RuntimeVersion:      "1.13.6",
-			DashboardVersion:    "0.14.0",
-			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
-			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
-			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io", "httpendpoints.dapr.io"},
-		},
-	},
-	{
-		previous: common.VersionDetails{
-			RuntimeVersion:      "1.14.4",
-			DashboardVersion:    "0.14.0",
-			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
-			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
-			CustomResourceDefs:  []string{"components.dapr.io", "configurations.dapr.io", "subscriptions.dapr.io", "resiliencies.dapr.io", "httpendpoints.dapr.io"},
-		},
-		next: common.VersionDetails{
-			RuntimeVersion:      "1.13.6",
+			RuntimeVersion:      "1.11.0",
 			DashboardVersion:    "0.14.0",
 			ClusterRoles:        []string{"dapr-dashboard", "dapr-injector", "dapr-operator-admin", "dapr-placement", "dapr-sentry"},
 			ClusterRoleBindings: []string{"dapr-operator-admin", "dapr-dashboard", "dapr-injector", "dapr-placement", "dapr-sentry"},
@ -160,7 +146,7 @@ func getTestsOnUpgrade(p upgradePath, installOpts, upgradeOpts common.TestOption
 		{Name: "clusterroles exist " + details.RuntimeVersion, Callable: common.ClusterRolesTest(details, upgradeOpts)},
 		{Name: "clusterrolebindings exist " + details.RuntimeVersion, Callable: common.ClusterRoleBindingsTest(details, upgradeOpts)},
 		{Name: "previously applied components exist " + details.RuntimeVersion, Callable: common.ComponentsTestOnInstallUpgrade(upgradeOpts)},
-		{Name: "previously applied http endpoints exist " + details.RuntimeVersion, Callable: common.HTTPEndpointsTestOnInstallUpgrade(installOpts, upgradeOpts)},
+		{Name: "previously applied http endpoints exist " + details.RuntimeVersion, Callable: common.HTTPEndpointsTestOnInstallUpgrade(upgradeOpts)},
 		{Name: "check mtls " + details.RuntimeVersion, Callable: common.MTLSTestOnInstallUpgrade(upgradeOpts)},
 		{Name: "status check " + details.RuntimeVersion, Callable: common.StatusTestOnInstallUpgrade(details, upgradeOpts)},
 	}...)
@ -186,19 +172,16 @@ func getTestsOnUpgrade(p upgradePath, installOpts, upgradeOpts common.TestOption
 // Upgrade path tests.

 func TestUpgradePathNonHAModeMTLSDisabled(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// Ensure a clean environment.
 	common.EnsureUninstall(false, false) // does not wait for pod deletion.
-
 	for _, p := range supportedUpgradePaths {
 		t.Run(fmt.Sprintf("setup v%s to v%s", p.previous.RuntimeVersion, p.next.RuntimeVersion), func(t *testing.T) {
 			t.Run(deleteCRDs+p.previous.RuntimeVersion, common.DeleteCRD(p.previous.CustomResourceDefs))
 			t.Run(deleteCRDs+p.next.RuntimeVersion, common.DeleteCRD(p.next.CustomResourceDefs))
 		})
+	}

+	for _, p := range supportedUpgradePaths {
 		t.Run(fmt.Sprintf("v%s to v%s", p.previous.RuntimeVersion, p.next.RuntimeVersion), func(t *testing.T) {
 			installOpts := common.TestOptions{
 				HAEnabled:                false,
@ -223,7 +206,6 @@ func TestUpgradePathNonHAModeMTLSDisabled(t *testing.T) {
 					common.ClusterRoles:        true,
 					common.ClusterRoleBindings: true,
 				},
-				TimeoutSeconds: 120,
 			}
 			tests := getTestsOnUpgrade(p, installOpts, upgradeOpts)

@ -235,19 +217,16 @@ func TestUpgradePathNonHAModeMTLSDisabled(t *testing.T) {
 }

 func TestUpgradePathNonHAModeMTLSEnabled(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeNonHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeNonHA))
-	}
-
 	// Ensure a clean environment.
 	common.EnsureUninstall(false, false) // does not wait for pod deletion.
-
 	for _, p := range supportedUpgradePaths {
 		t.Run(fmt.Sprintf("setup v%s to v%s", p.previous.RuntimeVersion, p.next.RuntimeVersion), func(t *testing.T) {
 			t.Run(deleteCRDs+p.previous.RuntimeVersion, common.DeleteCRD(p.previous.CustomResourceDefs))
 			t.Run(deleteCRDs+p.next.RuntimeVersion, common.DeleteCRD(p.next.CustomResourceDefs))
 		})
+	}

+	for _, p := range supportedUpgradePaths {
 		t.Run(fmt.Sprintf("v%s to v%s", p.previous.RuntimeVersion, p.next.RuntimeVersion), func(t *testing.T) {
 			installOpts := common.TestOptions{
 				HAEnabled:                false,
@ -272,7 +251,6 @@ func TestUpgradePathNonHAModeMTLSEnabled(t *testing.T) {
 					common.ClusterRoles:        true,
 					common.ClusterRoleBindings: true,
 				},
-				TimeoutSeconds: 120,
 			}
 			tests := getTestsOnUpgrade(p, installOpts, upgradeOpts)

@ -284,18 +262,16 @@ func TestUpgradePathNonHAModeMTLSEnabled(t *testing.T) {
 }

 func TestUpgradePathHAModeMTLSDisabled(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeHA))
-	}
-
 	// Ensure a clean environment.
 	common.EnsureUninstall(false, false) // does not wait for pod deletion.
-
 	for _, p := range supportedUpgradePaths {
 		t.Run(fmt.Sprintf("setup v%s to v%s", p.previous.RuntimeVersion, p.next.RuntimeVersion), func(t *testing.T) {
 			t.Run(deleteCRDs+p.previous.RuntimeVersion, common.DeleteCRD(p.previous.CustomResourceDefs))
 			t.Run(deleteCRDs+p.next.RuntimeVersion, common.DeleteCRD(p.next.CustomResourceDefs))
 		})
+	}
+
+	for _, p := range supportedUpgradePaths {
 		t.Run(fmt.Sprintf("v%s to v%s", p.previous.RuntimeVersion, p.next.RuntimeVersion), func(t *testing.T) {
 			installOpts := common.TestOptions{
 				HAEnabled:                true,
@ -320,7 +296,6 @@ func TestUpgradePathHAModeMTLSDisabled(t *testing.T) {
 					common.ClusterRoles:        true,
 					common.ClusterRoleBindings: true,
 				},
-				TimeoutSeconds: 120,
 			}
 			tests := getTestsOnUpgrade(p, installOpts, upgradeOpts)

@ -332,19 +307,16 @@ func TestUpgradePathHAModeMTLSDisabled(t *testing.T) {
 }

 func TestUpgradePathHAModeMTLSEnabled(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeHA))
-	}
-
 	// Ensure a clean environment.
 	common.EnsureUninstall(false, false) // does not wait for pod deletion.
-
 	for _, p := range supportedUpgradePaths {
 		t.Run(fmt.Sprintf("setup v%s to v%s", p.previous.RuntimeVersion, p.next.RuntimeVersion), func(t *testing.T) {
 			t.Run(deleteCRDs+p.previous.RuntimeVersion, common.DeleteCRD(p.previous.CustomResourceDefs))
 			t.Run(deleteCRDs+p.next.RuntimeVersion, common.DeleteCRD(p.next.CustomResourceDefs))
 		})
+	}

+	for _, p := range supportedUpgradePaths {
 		t.Run(fmt.Sprintf("v%s to v%s", p.previous.RuntimeVersion, p.next.RuntimeVersion), func(t *testing.T) {
 			installOpts := common.TestOptions{
 				HAEnabled:                true,
@ -369,7 +341,6 @@ func TestUpgradePathHAModeMTLSEnabled(t *testing.T) {
 					common.ClusterRoles:        true,
 					common.ClusterRoleBindings: true,
 				},
-				TimeoutSeconds: 120,
 			}
 			tests := getTestsOnUpgrade(p, installOpts, upgradeOpts)

@ -383,12 +354,14 @@ func TestUpgradePathHAModeMTLSEnabled(t *testing.T) {
 // HTTPEndpoint Dapr resource is a new type as of v1.11.
 // This test verifies install/upgrade functionality with this additional resource.
 func TestUpgradeWithHTTPEndpoint(t *testing.T) {
-	if common.ShouldSkipTest(common.DaprModeHA) {
-		t.Skip(fmt.Sprintf("Skipping %s mode test", common.DaprModeHA))
-	}
-
 	// Ensure a clean environment.
 	common.EnsureUninstall(false, false) // does not wait for pod deletion.
+	for _, p := range supportedUpgradePaths {
+		t.Run(fmt.Sprintf("setup v%s to v%s", p.previous.RuntimeVersion, p.next.RuntimeVersion), func(t *testing.T) {
+			t.Run(deleteCRDs+p.previous.RuntimeVersion, common.DeleteCRD(p.previous.CustomResourceDefs))
+			t.Run(deleteCRDs+p.next.RuntimeVersion, common.DeleteCRD(p.next.CustomResourceDefs))
+		})
+	}

 	for _, p := range supportedUpgradePaths {
 		ver, err := semver.NewVersion(p.previous.RuntimeVersion)
@ -400,17 +373,11 @@ func TestUpgradeWithHTTPEndpoint(t *testing.T) {
 		if ver.Major() != 1 || ver.Minor() < 11 {
 			return
 		}
-
-		t.Run(fmt.Sprintf("setup v%s to v%s", p.previous.RuntimeVersion, p.next.RuntimeVersion), func(t *testing.T) {
-			t.Run(deleteCRDs+p.previous.RuntimeVersion, common.DeleteCRD(p.previous.CustomResourceDefs))
-			t.Run(deleteCRDs+p.next.RuntimeVersion, common.DeleteCRD(p.next.CustomResourceDefs))
-		})
-
 		t.Run(fmt.Sprintf("v%s to v%s", p.previous.RuntimeVersion, p.next.RuntimeVersion), func(t *testing.T) {
 			installOpts := common.TestOptions{
 				HAEnabled:                true,
 				MTLSEnabled:              true,
-				ApplyComponentChanges:    true,
+				ApplyComponentChanges:    false,
 				ApplyHTTPEndpointChanges: true,
 				CheckResourceExists: map[common.Resource]bool{
 					common.CustomResourceDefs:  true,
@ -430,7 +397,6 @@ func TestUpgradeWithHTTPEndpoint(t *testing.T) {
 					common.ClusterRoles:        true,
 					common.ClusterRoleBindings: true,
 				},
-				TimeoutSeconds: 120,
 			}
 			tests := getTestsOnUpgrade(p, installOpts, upgradeOpts)

--- a/utils/utils_test.go
+++ b/utils/utils_test.go
@ -76,6 +76,7 @@ func TestContainerRuntimeUtils(t *testing.T) {
 	}

 	for _, tc := range testcases {
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			actualValid := IsValidContainerRuntime(tc.input)
@ -119,6 +120,7 @@ func TestContains(t *testing.T) {
 	}

 	for _, tc := range testcases {
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			actualValid := Contains(tc.input, tc.expected)
@ -163,6 +165,7 @@ func TestGetVersionAndImageVariant(t *testing.T) {
 	}

 	for _, tc := range testcases {
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			version, imageVariant := GetVersionAndImageVariant(tc.input)
@ -199,6 +202,7 @@ func TestValidateFilePaths(t *testing.T) {
 	}

 	for _, tc := range testcases {
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			actual := ValidateFilePath(tc.input)
@ -240,6 +244,7 @@ func TestGetAbsPath(t *testing.T) {
 	}

 	for _, tc := range testcases {
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			actual := GetAbsPath(baseDir, tc.input)
@ -297,6 +302,7 @@ func TestResolveHomeDir(t *testing.T) {
 	}

 	for _, tc := range testcases {
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			if tc.skipWindows && runtime.GOOS == "windows" {
 				t.Skip("Skipping test on Windows")
@ -329,6 +335,7 @@ func TestReadFile(t *testing.T) {
 		},
 	}
 	for _, tc := range testcases {
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			_, actual := ReadFile(tc.input)
@ -391,6 +398,7 @@ func TestFindFileInDir(t *testing.T) {
 		},
 	}
 	for _, tc := range testcases {
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			filePath, err := FindFileInDir(tc.input, "dapr.yaml")
@ -472,6 +480,7 @@ func TestPrintDetail(t *testing.T) {
 	}

 	for _, tc := range testcases {
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			var buf bytes.Buffer
@ -543,6 +552,7 @@ func TestSanitizeDir(t *testing.T) {
 	}

 	for _, tc := range testcases {
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			actual := SanitizeDir(tc.input)