assets

Signed-off-by: Daniel Valdivia <18384552+dvaldivia@users.noreply.github.com>
Release v0.9.7
2021-09-04 22:21:24 -07:00 · 2021-09-04 21:38:49 -07:00
2839 changed files with 71336 additions and 458535 deletions
--- a/.github/workflows/compiles.yml
+++ b/.github/workflows/compiles.yml
@@ -0,0 +1,34 @@
+name: Go
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Compiles on Go ${{ matrix.go-version }} and ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        go-version: [1.16.x]
+        os: [ubuntu-latest]
+    steps:
+      - name: Set up Go ${{ matrix.go-version }} on ${{ matrix.os }}
+        uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go-version }}
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Build on ${{ matrix.os }}
+        env:
+          GO111MODULE: on
+          GOOS: linux
+        run: |
+          make console
--- a/.github/workflows/crosscompile-1.yml
+++ b/.github/workflows/crosscompile-1.yml
@@ -0,0 +1,34 @@
+name: Go
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Cross compile
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        go-version: [1.16.x]
+        os: [ubuntu-latest]
+    steps:
+      - name: Set up Go ${{ matrix.go-version }} on ${{ matrix.os }}
+        uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go-version }}
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Build on ${{ matrix.os }}
+        env:
+          GO111MODULE: on
+          GOOS: linux
+        run: |
+          make crosscompile arg1="'linux/ppc64le linux/mips64'"
--- a/.github/workflows/crosscompile-2.yml
+++ b/.github/workflows/crosscompile-2.yml
@@ -0,0 +1,34 @@
+name: Go
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Cross compile
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        go-version: [1.16.x]
+        os: [ubuntu-latest]
+    steps:
+      - name: Set up Go ${{ matrix.go-version }} on ${{ matrix.os }}
+        uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go-version }}
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Build on ${{ matrix.os }}
+        env:
+          GO111MODULE: on
+          GOOS: linux
+        run: |
+          make crosscompile arg1="'linux/arm64 linux/s390x'"
--- a/.github/workflows/crosscompile-3.yml
+++ b/.github/workflows/crosscompile-3.yml
@@ -0,0 +1,34 @@
+name: Go
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Cross compile
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        go-version: [1.16.x]
+        os: [ubuntu-latest]
+    steps:
+      - name: Set up Go ${{ matrix.go-version }} on ${{ matrix.os }}
+        uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go-version }}
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Build on ${{ matrix.os }}
+        env:
+          GO111MODULE: on
+          GOOS: linux
+        run: |
+          make crosscompile arg1="'darwin/amd64 freebsd/amd64'"
--- a/.github/workflows/crosscompile-4.yml
+++ b/.github/workflows/crosscompile-4.yml
@@ -0,0 +1,34 @@
+name: Go
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Cross compile
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        go-version: [1.16.x]
+        os: [ubuntu-latest]
+    steps:
+      - name: Set up Go ${{ matrix.go-version }} on ${{ matrix.os }}
+        uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go-version }}
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Build on ${{ matrix.os }}
+        env:
+          GO111MODULE: on
+          GOOS: linux
+        run: |
+          make crosscompile arg1="'windows/amd64 linux/arm'"
--- a/.github/workflows/crosscompile-5.yml
+++ b/.github/workflows/crosscompile-5.yml
@@ -0,0 +1,34 @@
+name: Go
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Cross compile
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        go-version: [1.16.x]
+        os: [ubuntu-latest]
+    steps:
+      - name: Set up Go ${{ matrix.go-version }} on ${{ matrix.os }}
+        uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go-version }}
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Build on ${{ matrix.os }}
+        env:
+          GO111MODULE: on
+          GOOS: linux
+        run: |
+          make crosscompile arg1="'linux/386 netbsd/amd64'"
--- a/.github/workflows/go-test-pkg.yml
+++ b/.github/workflows/go-test-pkg.yml
@@ -0,0 +1,34 @@
+name: Go
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Test Pkg on Go ${{ matrix.go-version }} and ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        go-version: [1.16.x]
+        os: [ubuntu-latest]
+    steps:
+      - name: Set up Go ${{ matrix.go-version }} on ${{ matrix.os }}
+        uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go-version }}
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Build on ${{ matrix.os }}
+        env:
+          GO111MODULE: on
+          GOOS: linux
+        run: |
+          make test-pkg
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -0,0 +1,34 @@
+name: Go
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Test Restapi on Go ${{ matrix.go-version }} and ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        go-version: [1.16.x]
+        os: [ubuntu-latest]
+    steps:
+      - name: Set up Go ${{ matrix.go-version }} on ${{ matrix.os }}
+        uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go-version }}
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Build on ${{ matrix.os }}
+        env:
+          GO111MODULE: on
+          GOOS: linux
+        run: |
+          make test
--- a/.github/workflows/jobs.yaml
+++ b/.github/workflows/jobs.yaml
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -0,0 +1,34 @@
+name: Go
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Checking Lint
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        go-version: [1.16.x]
+        os: [ubuntu-latest]
+    steps:
+      - name: Set up Go ${{ matrix.go-version }} on ${{ matrix.os }}
+        uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go-version }}
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Build on ${{ matrix.os }}
+        env:
+          GO111MODULE: on
+          GOOS: linux
+        run: |
+          make verifiers
--- a/.github/workflows/react.yml
+++ b/.github/workflows/react.yml
@@ -0,0 +1,15 @@
+name: "React Tests"
+on:
+  push:
+  pull_request:
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install modules
+        working-directory: ./portal-ui
+        run: yarn
+      - name: Run tests
+        working-directory: ./portal-ui
+        run: yarn test
--- a/.gitignore
+++ b/.gitignore
@@ -19,7 +19,6 @@ vendor/

 # Ignore executables
 target/
-!pkg/logger/target/
 console
 !console/

--- a/.golangci.yml
+++ b/.golangci.yml
@@ -5,45 +5,34 @@ linters-settings:
  misspell:
    locale: US

-  goheader:
-    values:
-      regexp:
-        copyright-holder: Copyright \(c\) (20\d\d\-20\d\d)|2021|({{year}})
-    template-path: .license.tmpl
-
 linters:
  disable-all: true
  enable:
+    - typecheck
    - goimports
    - misspell
    - govet
    - revive
    - ineffassign
    - gosimple
-    - gomodguard
-    - gofmt
+    - deadcode
+    - unparam
    - unused
-    - unconvert
-    - varcheck
-    - gocritic
-    - gofumpt
-    - durationcheck
+    - structcheck

 service:
-  golangci-lint-version: 1.43.0 # use the fixed version to not introduce new linters unexpectedly
+  golangci-lint-version: 1.27.0 # use the fixed version to not introduce new linters unexpectedly

 issues:
  exclude-use-default: false
  exclude:
-    - should have a package comment
-    # TODO(y4m4): Remove once all exported ident. have comments!
-    - comment on exported function
-    - comment on exported type
-    - should have comment
-    - use leading k in Go names
-    - comment on exported const
+      - should have a package comment
+      # TODO(y4m4): Remove once all exported ident. have comments!      
+      - comment on exported function
+      - comment on exported type
+      - should have comment
+      - use leading k in Go names
+      - comment on exported const
 run:
  skip-dirs:
    - pkg/clientgen
-    - pkg/apis/networking.gke.io
-    - restapi/operations
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -13,7 +13,7 @@ release:
 before:
  hooks:
    # you may remove this if you don't use vgo
-    - go mod tidy -compat=1.18
+    - go mod tidy

 builds:
  -
@@ -41,7 +41,7 @@ builds:

    flags:
      - -trimpath
-      - --tags=kqueue,operator
+      - --tags=kqueue

    ldflags:
      - -s -w -X github.com/minio/console/pkg.ReleaseTag={{.Tag}} -X github.com/minio/console/pkg.CommitID={{.FullCommit}} -X github.com/minio/console/pkg.Version={{.Version}} -X github.com/minio/console/pkg.ShortCommitID={{.ShortCommit}} -X github.com/minio/console/pkg.ReleaseTime={{.Date}}
@@ -86,7 +86,7 @@ nfpms:
 dockers:
 - image_templates:
  - "minio/console:{{ .Tag }}-amd64"
-  use: buildx
+  use_buildx: true
  goarch: amd64
  dockerfile: Dockerfile.release
  extra_files:
@@ -97,7 +97,7 @@ dockers:
  - "--build-arg=TAG={{ .Tag }}"
 - image_templates:
  - "minio/console:{{ .Tag }}-ppc64le"
-  use: buildx
+  use_buildx: true
  goarch: ppc64le
  dockerfile: Dockerfile.release
  extra_files:
@@ -108,7 +108,7 @@ dockers:
  - "--build-arg=TAG={{ .Tag }}"
 - image_templates:
  - "minio/console:{{ .Tag }}-s390x"
-  use: buildx
+  use_buildx: true
  goarch: s390x
  dockerfile: Dockerfile.release
  extra_files:
@@ -119,7 +119,7 @@ dockers:
  - "--build-arg=TAG={{ .Tag }}"
 - image_templates:
  - "minio/console:{{ .Tag }}-arm64"
-  use: buildx
+  use_buildx: true
  goarch: arm64
  goos: linux
  dockerfile: Dockerfile.release
@@ -131,7 +131,7 @@ dockers:
  - "--build-arg=TAG={{ .Tag }}"
 - image_templates:
  - "quay.io/minio/console:{{ .Tag }}-amd64"
-  use: buildx
+  use_buildx: true
  goarch: amd64
  dockerfile: Dockerfile.release
  extra_files:
@@ -142,7 +142,7 @@ dockers:
  - "--build-arg=TAG={{ .Tag }}"
 - image_templates:
  - "quay.io/minio/console:{{ .Tag }}-ppc64le"
-  use: buildx
+  use_buildx: true
  goarch: ppc64le
  dockerfile: Dockerfile.release
  extra_files:
@@ -153,7 +153,7 @@ dockers:
  - "--build-arg=TAG={{ .Tag }}"
 - image_templates:
  - "quay.io/minio/console:{{ .Tag }}-s390x"
-  use: buildx
+  use_buildx: true
  goarch: s390x
  dockerfile: Dockerfile.release
  extra_files:
@@ -164,7 +164,7 @@ dockers:
  - "--build-arg=TAG={{ .Tag }}"
 - image_templates:
  - "quay.io/minio/console:{{ .Tag }}-arm64"
-  use: buildx
+  use_buildx: true
  goarch: arm64
  goos: linux
  dockerfile: Dockerfile.release
--- a/.license.tmpl
+++ b/.license.tmpl
@@ -1,15 +0,0 @@
-This file is part of MinIO Console Server
-{{copyright-holder}} MinIO, Inc.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU Affero General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Affero General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +0,0 @@
-17
--- a/.semgrepignore
+++ b/.semgrepignore
@@ -1,33 +0,0 @@
-# Ignore git items
-.gitignore
-.git/
-:include .gitignore
-
-# Common large paths
-node_modules/
-portal-ui/node_modules/
-build/
-dist/
-.idea/
-vendor/
-.env/
-.venv/
-.tox/
-*.min.js
-
-# Common test paths
-test/
-tests/
-*_test.go
-
-# Semgrep rules folder
-.semgrep
-
-# Semgrep-action log folder
-.semgrep_logs/
-
-# Ignore VsCode files
-.vscode/
-*.code-workspace
-*~
-.eslintcache
--- a/17456
+++ b/17456
--- a/11
+++ b/11
@@ -1,5 +1,4 @@
-ARG NODE_VERSION
-FROM node:$NODE_VERSION as uilayer
+FROM node:10 as uilayer

 WORKDIR /app

@@ -9,11 +8,11 @@ RUN yarn install

 COPY ./portal-ui .

-RUN make build-static
+RUN yarn install && make build-static

 USER node

-FROM golang:1.18 as golayer
+FROM golang:1.16 as golayer

 RUN apt-get update -y && apt-get install -y ca-certificates

@@ -30,9 +29,9 @@ WORKDIR /go/src/github.com/minio/console/
 ENV CGO_ENABLED=0

 COPY --from=uilayer /app/build /go/src/github.com/minio/console/portal-ui/build
-RUN go build --tags=kqueue,operator -ldflags "-w -s" -a -o console ./cmd/console
+RUN go build -ldflags "-w -s" -a -o console ./cmd/console

-FROM registry.access.redhat.com/ubi8/ubi-minimal:8.6
+FROM registry.access.redhat.com/ubi8/ubi-minimal:8.3
 MAINTAINER MinIO Development "dev@min.io"
 EXPOSE 9090

--- a/Dockerfile.assets
+++ b/Dockerfile.assets
@@ -1,5 +1,4 @@
-ARG NODE_VERSION
-FROM node:$NODE_VERSION as uilayer
+FROM node:10 as uilayer

 WORKDIR /app

--- a/Dockerfile.release
+++ b/Dockerfile.release
@@ -1,4 +1,4 @@
-FROM registry.access.redhat.com/ubi8/ubi-minimal:8.6
+FROM registry.access.redhat.com/ubi8/ubi-minimal:8.4

 ARG TAG

--- a/217
+++ b/217
@@ -4,31 +4,31 @@ GOPATH := $(shell go env GOPATH)
 BUILD_VERSION:=$(shell git describe --exact-match --tags $(git log -n1 --pretty='%h') 2>/dev/null || git rev-parse --abbrev-ref HEAD 2>/dev/null)
 BUILD_TIME:=$(shell date 2>/dev/null)
 TAG ?= "minio/console:$(BUILD_VERSION)-dev"
-MINIO_VERSION ?= "quay.io/minio/minio:latest"
-TARGET_BUCKET ?= "target"
-NODE_VERSION := $(shell cat .nvmrc)

 default: console

 .PHONY: console
 console:
 	@echo "Building Console binary to './console'"
-	@(GO111MODULE=on CGO_ENABLED=0 go build -trimpath --tags=kqueue,operator --ldflags "-s -w" -o console ./cmd/console)
+	@(GO111MODULE=on CGO_ENABLED=0 go build -trimpath --tags=kqueue --ldflags "-s -w" -o console ./cmd/console)

 k8sdev:
-	@docker build -t $(TAG) --build-arg build_version=$(BUILD_VERSION) --build-arg build_time='$(BUILD_TIME)' --build-arg NODE_VERSION='$(NODE_VERSION)' .
+	@docker build -t $(TAG) --build-arg build_version=$(BUILD_VERSION) --build-arg build_time='$(BUILD_TIME)' .
 	@kind load docker-image $(TAG)
 	@echo "Done, now restart your console deployment"

 getdeps:
 	@mkdir -p ${GOPATH}/bin
-	@echo "Installing golangci-lint" && curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(GOPATH)/bin
+	@which golangci-lint 1>/dev/null || (echo "Installing golangci-lint" && curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(GOPATH)/bin v1.40.1)

 verifiers: getdeps fmt lint

 fmt:
 	@echo "Running $@ check"
-	@(env bash $(PWD)/verify-gofmt.sh)
+	@GO111MODULE=on gofmt -d restapi/
+	@GO111MODULE=on gofmt -d pkg/
+	@GO111MODULE=on gofmt -d cmd/
+	@GO111MODULE=on gofmt -d cluster/

 crosscompile:
 	@(env bash $(PWD)/cross-compile.sh $(arg1))
@@ -43,13 +43,9 @@ install: console
 	@mkdir -p $(GOPATH)/bin && cp -f $(PWD)/console $(GOPATH)/bin/console
 	@echo "Installation successful. To learn more, try \"console --help\"."

-swagger-gen: clean-swagger swagger-console swagger-operator apply-gofmt
+swagger-gen: clean-swagger swagger-console swagger-operator
 	@echo "Done Generating swagger server code from yaml"

-apply-gofmt:
-	@echo "Applying gofmt to all generated an existing files"
-	@GO111MODULE=on gofmt -w .
-
 clean-swagger:
 	@echo "cleaning"
 	@rm -rf models
@@ -65,194 +61,13 @@ swagger-operator:
 	@swagger generate server -A operator --main-package=operator --server-package=operatorapi --exclude-main -P models.Principal -f ./swagger-operator.yml -r NOTICE

 assets:
-	@(if [ -f "${NVM_DIR}/nvm.sh" ]; then \. "${NVM_DIR}/nvm.sh" && nvm install && nvm use && npm install -g yarn ; fi &&\
-	  cd portal-ui; yarn install --prefer-offline; make build-static; yarn prettier --write . --loglevel warn; cd ..)
-
-test-integration:
-	@(docker stop pgsqlcontainer || true)
-	@(docker stop minio || true)
-	@(docker network rm mynet123 || true)
-	@echo "create docker network to communicate containers MinIO & PostgreSQL"
-	@(docker network create --subnet=173.18.0.0/29 mynet123)
-	@echo "docker run with MinIO Version below:"
-	@echo $(MINIO_VERSION)
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 --net=mynet123 -d --name minio --rm -p 9000:9000 -p 9001:9001 -e MINIO_KMS_SECRET_KEY=my-minio-key:OSMM+vkKUTCvQs9YL/CVMIMt43HFhkUpqJxTmGl6rYw= $(MINIO_VERSION) server /data{1...4} --console-address ':9001' && sleep 5)
-	@(docker run --net=mynet123 --ip=173.18.0.3 --name pgsqlcontainer --rm -p 5432:5432 -e POSTGRES_PASSWORD=password -d postgres && sleep 5)
-	@echo "execute test and get coverage for test-integration:"
-	@(cd integration && go test -coverpkg=../restapi -c -tags testrunmain . && mkdir -p coverage && export THETARGET=$(TARGET_BUCKET) && echo "THETARGET: ${THETARGET}" && ./integration.test -test.v -test.run "^Test*" -test.coverprofile=coverage/system.out)
-	@(docker stop pgsqlcontainer)
-	@(docker stop minio)
-	@(docker network rm mynet123)
-
-test-replication:
-	@(docker stop minio || true)
-	@(docker stop minio1 || true)
-	@(docker stop minio2 || true)
-	@(docker network rm mynet123 || true)
-	@(docker network create mynet123)
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 \
-	  --net=mynet123 -d \
-	  --name minio \
-	  --rm \
-	  -p 9000:9000 \
-	  -p 6000:6000 \
-	  -e MINIO_KMS_SECRET_KEY=my-minio-key:OSMM+vkKUTCvQs9YL/CVMIMt43HFhkUpqJxTmGl6rYw= \
-	  -e MINIO_ROOT_USER="minioadmin" \
-	  -e MINIO_ROOT_PASSWORD="minioadmin" \
-	  $(MINIO_VERSION) server /data{1...4} \
-	  --address :9000 \
-	  --console-address :6000)
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 \
-	  --net=mynet123 -d \
-	  --name minio1 \
-	  --rm \
-	  -p 9001:9001 \
-	  -p 6001:6001 \
-	  -e MINIO_KMS_SECRET_KEY=my-minio-key:OSMM+vkKUTCvQs9YL/CVMIMt43HFhkUpqJxTmGl6rYw= \
-	  -e MINIO_ROOT_USER="minioadmin" \
-	  -e MINIO_ROOT_PASSWORD="minioadmin" \
-	  $(MINIO_VERSION) server /data{1...4} \
-	  --address :9001 \
-	  --console-address :6001)
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 \
-	  --net=mynet123 -d \
-	  --name minio2 \
-	  --rm \
-	  -p 9002:9002 \
-	  -p 6002:6002 \
-	  -e MINIO_KMS_SECRET_KEY=my-minio-key:OSMM+vkKUTCvQs9YL/CVMIMt43HFhkUpqJxTmGl6rYw= \
-	  -e MINIO_ROOT_USER="minioadmin" \
-	  -e MINIO_ROOT_PASSWORD="minioadmin" \
-	  $(MINIO_VERSION) server /data{1...4} \
-	  --address :9002 \
-	  --console-address :6002)
-	@(cd replication && go test -coverpkg=../restapi -c -tags testrunmain . && mkdir -p coverage && ./replication.test -test.v -test.run "^Test*" -test.coverprofile=coverage/replication.out)
-	@(docker stop minio || true)
-	@(docker stop minio1 || true)
-	@(docker stop minio2 || true)
-	@(docker network rm mynet123 || true)
-
-test-sso-integration:
-	@echo "create the network in bridge mode to communicate all containers"
-	@(docker network create my-net)
-	@echo "run openldap container using MinIO Image: quay.io/minio/openldap:latest"
-	@(docker run \
-		-e LDAP_ORGANIZATION="MinIO Inc" \
-		-e LDAP_DOMAIN="min.io" \
-		-e LDAP_ADMIN_PASSWORD="admin" \
-		--network my-net \
-		-p 389:389 \
-		-p 636:636 \
-		--name openldap \
-		--detach quay.io/minio/openldap:latest)
-	@echo "Run Dex container using MinIO Image: quay.io/minio/dex:latest"
-	@(docker run \
-		-e DEX_ISSUER=http://dex:5556/dex \
-		-e DEX_CLIENT_REDIRECT_URI=http://127.0.0.1:9090/oauth_callback \
-		-e DEX_LDAP_SERVER=openldap:389 \
-		--network my-net \
-		-p 5556:5556 \
-		--name dex \
-		--detach quay.io/minio/dex:latest)
-	@echo "running minio server"
-	@(docker run \
-	-v /data1 -v /data2 -v /data3 -v /data4 \
-	--network my-net \
-	-d \
-	--name minio \
-	--rm \
-	-p 9000:9000 \
-	-p 9001:9001 \
-	-e MINIO_IDENTITY_OPENID_CLIENT_ID="minio-client-app" \
-	-e MINIO_IDENTITY_OPENID_CLIENT_SECRET="minio-client-app-secret" \
-	-e MINIO_IDENTITY_OPENID_CLAIM_NAME=name \
-	-e MINIO_IDENTITY_OPENID_CONFIG_URL=http://dex:5556/dex/.well-known/openid-configuration \
-	-e MINIO_IDENTITY_OPENID_REDIRECT_URI=http://127.0.0.1:9090/oauth_callback \
-	-e MINIO_ROOT_USER=minio \
-	-e MINIO_ROOT_PASSWORD=minio123 $(MINIO_VERSION) server /data{1...4} --address :9000 --console-address :9001)
-	@echo "run mc commands to set the policy"
-	@(docker run --name minio-client --network my-net -dit --entrypoint=/bin/sh minio/mc)
-	@(docker exec minio-client mc alias set myminio/ http://minio:9000 minio minio123)
-	@echo "adding policy to Dillon Harper to be able to login:"
-	@(cd sso-integration && docker cp allaccess.json minio-client:/ && docker exec minio-client mc admin policy add myminio "Dillon Harper" allaccess.json)
-	@echo "starting bash script"
-	@(env bash $(PWD)/sso-integration/set-sso.sh)
-	@echo "add python module"
-	@(pip3 install bs4)
-	@echo "Executing the test:"
-	@(cd sso-integration && go test -coverpkg=../restapi -c -tags testrunmain . && mkdir -p coverage && ./sso-integration.test -test.v -test.run "^Test*" -test.coverprofile=coverage/sso-system.out)
-
-test-operator-integration:
-	@(echo "Start cd operator-integration && go test:")
-	@(pwd)
-	@(cd operator-integration && go test -coverpkg=../operatorapi -c -tags testrunmain . && mkdir -p coverage && ./operator-integration.test -test.v -test.run "^Test*" -test.coverprofile=coverage/operator-api.out)
-
-test-operator:
-	@(env bash $(PWD)/portal-ui/tests/scripts/operator.sh)
-	@(docker stop minio)
-
-test-permissions-1:
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 -d --name minio --rm -p 9000:9000 quay.io/minio/minio:latest server /data{1...4})
-	@(env bash $(PWD)/portal-ui/tests/scripts/permissions.sh "portal-ui/tests/permissions-1/")
-	@(docker stop minio)
-
-test-permissions-2:
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 -d --name minio --rm -p 9000:9000 quay.io/minio/minio:latest server /data{1...4})
-	@(env bash $(PWD)/portal-ui/tests/scripts/permissions.sh "portal-ui/tests/permissions-2/")
-	@(docker stop minio)
-
-test-permissions-3:
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 -d --name minio --rm -p 9000:9000 quay.io/minio/minio:latest server /data{1...4})
-	@(env bash $(PWD)/portal-ui/tests/scripts/permissions.sh "portal-ui/tests/permissions-3/")
-	@(docker stop minio)
-
-test-permissions-4:
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 -d --name minio --rm -p 9000:9000 quay.io/minio/minio:latest server /data{1...4})
-	@(env bash $(PWD)/portal-ui/tests/scripts/permissions.sh "portal-ui/tests/permissions-4/")
-	@(docker stop minio)
-
-test-permissions-5:
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 -d --name minio --rm -p 9000:9000 quay.io/minio/minio:latest server /data{1...4})
-	@(env bash $(PWD)/portal-ui/tests/scripts/permissions.sh "portal-ui/tests/permissions-5/")
-	@(docker stop minio)
-
-test-permissions-6:
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 -d --name minio --rm -p 9000:9000 quay.io/minio/minio:latest server /data{1...4})
-	@(env bash $(PWD)/portal-ui/tests/scripts/permissions.sh "portal-ui/tests/permissions-6/")
-	@(docker stop minio)
-
-test-permissions-7:
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 -d --name minio --rm -p 9000:9000 quay.io/minio/minio:latest server /data{1...4})
-	@(env bash $(PWD)/portal-ui/tests/scripts/permissions.sh "portal-ui/tests/permissions-7/")
-	@(docker stop minio)
-
-test-apply-permissions:
-	@(env bash $(PWD)/portal-ui/tests/scripts/initialize-env.sh)
-
-test-start-docker-minio:
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 -d --name minio --rm -p 9000:9000 quay.io/minio/minio:latest server /data{1...4})
-
-initialize-operator:
-	@echo "Done initializing operator test"
-
-initialize-permissions: test-start-docker-minio test-apply-permissions
-	@echo "Done initializing permissions test"
-
-cleanup-permissions:
-	@(env bash $(PWD)/portal-ui/tests/scripts/cleanup-env.sh)
-	@(docker stop minio)
+	@(cd portal-ui; yarn install; make build-static; yarn prettier --write . --loglevel warn;  cd ..)

 test:
-	@echo "execute test and get coverage"
-	@(cd restapi && mkdir coverage && GO111MODULE=on go test -test.v -coverprofile=coverage/coverage.out)
-
-test-unit-test-operator:
-	@echo "execute unit test and get coverage for operatorapi"
-	@(cd operatorapi && mkdir coverage && GO111MODULE=on go test -test.v -coverprofile=coverage/coverage-unit-test-operatorapi.out)
+	@(GO111MODULE=on go test -race -v github.com/minio/console/restapi/...)

 test-pkg:
-	@echo "execute test and get coverage"
-	@(cd pkg && mkdir coverage && GO111MODULE=on go test -test.v -coverprofile=coverage/coverage-pkg.out)
+	@(GO111MODULE=on go test -race -v github.com/minio/console/pkg/...)

 coverage:
 	@(GO111MODULE=on go test -v -coverprofile=coverage.out github.com/minio/console/restapi/... && go tool cover -html=coverage.out && open coverage.html)
@@ -264,12 +79,4 @@ clean:
 	@rm -vf console

 docker:
-	@docker buildx build --output=type=docker --platform linux/amd64 -t $(TAG) --build-arg build_version=$(BUILD_VERSION) --build-arg build_time='$(BUILD_TIME)' --build-arg NODE_VERSION='$(NODE_VERSION)' .
-
-release: swagger-gen
-	@echo "Generating Release: $(RELEASE)"
-	@make assets
-	@yq -i e '.spec.template.spec.containers[0].image |= "minio/console:$(RELEASE)"' k8s/operator-console/base/console-deployment.yaml
-	@yq -i e 'select(.kind == "Deployment").spec.template.spec.containers[0].image |= "minio/console:$(RELEASE)"' k8s/operator-console/standalone/console-deployment.yaml
-	@git add -u .
-	@git add portal-ui/build/
+	@docker build -t $(TAG) --build-arg build_version=$(BUILD_VERSION) --build-arg build_time='$(BUILD_TIME)' .
--- a/2
+++ b/2
@@ -1,5 +1,5 @@
 This file is part of MinIO Console Server
-Copyright (c) 2022 MinIO, Inc.
+Copyright (c) 2021 MinIO, Inc.

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by
--- a/README.md
+++ b/README.md
@@ -53,12 +53,12 @@ docker pull minio/console
 ```

 ### Build from source
-> You will need a working Go environment. Therefore, please follow [How to install Go](https://golang.org/doc/install).
-> Minimum version required is go1.18

 ```
-go install github.com/minio/console/cmd/console@latest
+GO111MODULE=on go install github.com/minio/console/cmd/console@latest
 ```
+> You will need a working Go environment. Therefore, please follow [How to install Go](https://golang.org/doc/install).
+> Minimum version required is go1.16

 ## Setup

--- a/cluster/cluster.go
+++ b/cluster/cluster.go
@@ -1,4 +1,4 @@
-// This file is part of MinIO Console Server
+// This file is part of MinIO Kubernetes Cloud
 // Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -17,7 +17,7 @@
 package cluster

 import (
-	directpvclient "github.com/minio/directpv/pkg/client"
+	direct "github.com/minio/direct-csi/pkg/clientset"
 	operator "github.com/minio/operator/pkg/client/clientset/versioned"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
@@ -26,8 +26,8 @@ import (

 // getTLSClientConfig will return the right TLS configuration for the K8S client based on the configured TLS certificate
 func getTLSClientConfig() rest.TLSClientConfig {
-	defaultRootCAFile := "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"
-	customRootCAFile := getK8sAPIServerTLSRootCA()
+	var defaultRootCAFile = "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"
+	var customRootCAFile = getK8sAPIServerTLSRootCA()
 	tlsClientConfig := rest.TLSClientConfig{}
 	// if console is running inside k8s by default he will have access to the CA Cert from the k8s local authority
 	if _, err := certutil.NewPool(defaultRootCAFile); err == nil {
@@ -65,12 +65,7 @@ func K8sClient(token string) (*kubernetes.Clientset, error) {
 	return kubernetes.NewForConfig(GetK8sConfig(token))
 }

-// DirectPV interfaces  required to fetch information
-
-func DirectPVDriveInterface(token string) (*directpvclient.DirectCSIDriveInterface, error) {
-	return directpvclient.DirectCSIDriveInterfaceForConfig(GetK8sConfig(token))
-}
-
-func DirectPVVolumeInterface(token string) (*directpvclient.DirectCSIVolumeInterface, error) {
-	return directpvclient.DirectCSIVolumeInterfaceForConfig(GetK8sConfig(token))
+// DirectCSIClient returns Direct CSI client using GetK8sConfig for its config
+func DirectCSIClient(token string) (*direct.Clientset, error) {
+	return direct.NewForConfig(GetK8sConfig(token))
 }
--- a/cluster/config.go
+++ b/cluster/config.go
@@ -1,4 +1,4 @@
-// This file is part of MinIO Console Server
+// This file is part of MinIO Kubernetes Cloud
 // Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -17,19 +17,22 @@
 package cluster

 import (
+	"errors"
+	"fmt"
 	"io/ioutil"
 	"net"
 	"net/http"
+	"regexp"
 	"strings"
 	"time"

-	xhttp "github.com/minio/console/pkg/http"
-
-	"github.com/minio/console/pkg/utils"
-
 	"github.com/minio/pkg/env"
 )

+var (
+	errCantDetermineMinIOImage = errors.New("can't determine MinIO Image")
+)
+
 func GetK8sAPIServer() string {
 	// if console is running inside a k8s pod KUBERNETES_SERVICE_HOST and KUBERNETES_SERVICE_PORT will contain the k8s api server apiServerAddress
 	// if console is not running inside k8s by default will look for the k8s api server on localhost:8001 (kubectl proxy)
@@ -60,6 +63,39 @@ func GetNsFromFile() string {
 	return string(dat)
 }

+// Namespace will run only once at console startup
+var Namespace = GetNsFromFile()
+
+// getLatestMinIOImage returns the latest docker image for MinIO if found on the internet
+func getLatestMinIOImage(client HTTPClientI) (*string, error) {
+	resp, err := client.Get("https://dl.min.io/server/minio/release/linux-amd64/")
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	var re = regexp.MustCompile(`(?m)\.\/minio\.(RELEASE.*?Z)"`)
+	// look for a single match
+	matches := re.FindAllStringSubmatch(string(body), 1)
+	for i := range matches {
+		release := matches[i][1]
+		dockerImage := fmt.Sprintf("minio/minio:%s", release)
+		return &dockerImage, nil
+	}
+	return nil, errCantDetermineMinIOImage
+}
+
+var latestMinIOImage, errLatestMinIOImage = getLatestMinIOImage(
+	&HTTPClient{
+		Client: &http.Client{
+			Timeout: 15 * time.Second,
+		},
+	})
+
 // GetMinioImage returns the image URL to be used when deploying a MinIO instance, if there is
 // a preferred image to be used (configured via ENVIRONMENT VARIABLES) GetMinioImage will return that
 // if not, GetMinioImage will try to obtain the image URL for the latest version of MinIO and return that
@@ -69,15 +105,17 @@ func GetMinioImage() (*string, error) {
 	if image != "" {
 		return &image, nil
 	}
-	latestMinIOImage, errLatestMinIOImage := utils.GetLatestMinIOImage(
-		&xhttp.Client{
-			Client: &http.Client{
-				Timeout: 5 * time.Second,
-			},
-		})
-
 	if errLatestMinIOImage != nil {
 		return nil, errLatestMinIOImage
 	}
 	return latestMinIOImage, nil
 }
+
+// GetLatestMinioImage returns the latest image URL on minio repository
+func GetLatestMinioImage(client HTTPClientI) (*string, error) {
+	latestMinIOImage, err := getLatestMinIOImage(client)
+	if err != nil {
+		return nil, err
+	}
+	return latestMinIOImage, nil
+}
--- a/cluster/const.go
+++ b/cluster/const.go
@@ -1,4 +1,4 @@
-// This file is part of MinIO Console Server
+// This file is part of MinIO Kubernetes Cloud
 // Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -20,4 +20,5 @@ const (
 	ConsoleK8sAPIServer          = "CONSOLE_K8S_API_SERVER"
 	ConsoleK8SAPIServerTLSRootCA = "CONSOLE_K8S_API_SERVER_TLS_ROOT_CA"
 	ConsoleMinioImage            = "CONSOLE_MINIO_IMAGE"
+	ConsoleMCImage               = "CONSOLE_MC_IMAGE"
 )
--- a/cluster/http_client.go
+++ b/cluster/http_client.go
@@ -0,0 +1,53 @@
+// This file is part of MinIO Kubernetes Cloud
+// Copyright (c) 2021 MinIO, Inc.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package cluster
+
+import (
+	"io"
+	"net/http"
+)
+
+// HTTPClientI interface with all functions to be implemented
+// by mock when testing, it should include all HttpClient respective api calls
+// that are used within this project.
+type HTTPClientI interface {
+	Get(url string) (resp *http.Response, err error)
+	Post(url, contentType string, body io.Reader) (resp *http.Response, err error)
+	Do(req *http.Request) (*http.Response, error)
+}
+
+// HTTPClient Interface implementation
+//
+// Define the structure of a http client and define the functions that are actually used
+type HTTPClient struct {
+	Client *http.Client
+}
+
+// Get implements http.Client.Get()
+func (c *HTTPClient) Get(url string) (resp *http.Response, err error) {
+	return c.Client.Get(url)
+}
+
+// Post implements http.Client.Post()
+func (c *HTTPClient) Post(url, contentType string, body io.Reader) (resp *http.Response, err error) {
+	return c.Client.Post(url, contentType, body)
+}
+
+// Do implements http.Client.Do()
+func (c *HTTPClient) Do(req *http.Request) (*http.Response, error) {
+	return c.Client.Do(req)
+}
--- a/cmd/console/app_commands.go
+++ b/cmd/console/app_commands.go
@@ -1,99 +0,0 @@
-//go:build operator
-// +build operator
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2021 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"strconv"
-	"time"
-
-	"github.com/minio/console/pkg/logger"
-
-	"github.com/minio/cli"
-	"github.com/minio/console/restapi"
-)
-
-var appCmds = []cli.Command{
-	serverCmd,
-	updateCmd,
-	operatorCmd,
-}
-
-// StartServer starts the console service
-func StartServer(ctx *cli.Context) error {
-	// Load all certificates
-	if err := loadAllCerts(ctx); err != nil {
-		// Log this as a warning and continue running console without TLS certificates
-		restapi.LogError("Unable to load certs: %v", err)
-	}
-
-	xctx := context.Background()
-	transport := restapi.PrepareSTSClientTransport(false)
-	if err := logger.InitializeLogger(xctx, transport); err != nil {
-		fmt.Println("error InitializeLogger", err)
-		logger.CriticalIf(xctx, err)
-	}
-	// custom error configuration
-	restapi.LogInfo = logger.Info
-	restapi.LogError = logger.Error
-	restapi.LogIf = logger.LogIf
-
-	if os.Getenv("CONSOLE_OPERATOR_MODE") != "" && os.Getenv("CONSOLE_OPERATOR_MODE") == "on" {
-		return startOperatorServer(ctx)
-	}
-
-	var rctx restapi.Context
-	if err := rctx.Load(ctx); err != nil {
-		restapi.LogError("argument validation failed: %v", err)
-		return err
-	}
-
-	server, err := buildServer()
-	if err != nil {
-		restapi.LogError("Unable to initialize console server: %v", err)
-		return err
-	}
-
-	server.Host = rctx.Host
-	server.Port = rctx.HTTPPort
-	// set conservative timesout for uploads
-	server.ReadTimeout = 1 * time.Hour
-	// no timeouts for response for downloads
-	server.WriteTimeout = 0
-	restapi.Port = strconv.Itoa(server.Port)
-	restapi.Hostname = server.Host
-
-	if len(restapi.GlobalPublicCerts) > 0 {
-		// If TLS certificates are provided enforce the HTTPS schema, meaning console will redirect
-		// plain HTTP connections to HTTPS server
-		server.EnabledListeners = []string{"http", "https"}
-		server.TLSPort = rctx.HTTPSPort
-		// Need to store tls-port, tls-host un config variables so secure.middleware can read from there
-		restapi.TLSPort = strconv.Itoa(server.TLSPort)
-		restapi.Hostname = rctx.Host
-		restapi.TLSRedirect = rctx.TLSRedirect
-	}
-
-	defer server.Shutdown()
-
-	return server.Serve()
-}
--- a/cmd/console/app_commands_noop.go
+++ b/cmd/console/app_commands_noop.go
@@ -1,92 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2021 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-//go:build !operator
-// +build !operator
-
-package main
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-	"time"
-
-	"github.com/minio/console/pkg/logger"
-
-	"github.com/minio/cli"
-	"github.com/minio/console/restapi"
-)
-
-var appCmds = []cli.Command{
-	serverCmd,
-	updateCmd,
-}
-
-// StartServer starts the console service
-func StartServer(ctx *cli.Context) error {
-	if err := loadAllCerts(ctx); err != nil {
-		// Log this as a warning and continue running console without TLS certificates
-		restapi.LogError("Unable to load certs: %v", err)
-	}
-
-	xctx := context.Background()
-	transport := restapi.PrepareSTSClientTransport(false)
-	if err := logger.InitializeLogger(xctx, transport); err != nil {
-		fmt.Println("error InitializeLogger", err)
-		logger.CriticalIf(xctx, err)
-	}
-	// custom error configuration
-	restapi.LogInfo = logger.Info
-	restapi.LogError = logger.Error
-	restapi.LogIf = logger.LogIf
-
-	var rctx restapi.Context
-	if err := rctx.Load(ctx); err != nil {
-		restapi.LogError("argument validation failed: %v", err)
-		return err
-	}
-
-	server, err := buildServer()
-	if err != nil {
-		restapi.LogError("Unable to initialize console server: %v", err)
-		return err
-	}
-
-	server.Host = rctx.Host
-	server.Port = rctx.HTTPPort
-	// set conservative timesout for uploads
-	server.ReadTimeout = 1 * time.Hour
-	// no timeouts for response for downloads
-	server.WriteTimeout = 0
-	restapi.Port = strconv.Itoa(server.Port)
-	restapi.Hostname = server.Host
-
-	if len(restapi.GlobalPublicCerts) > 0 {
-		// If TLS certificates are provided enforce the HTTPS schema, meaning console will redirect
-		// plain HTTP connections to HTTPS server
-		server.EnabledListeners = []string{"http", "https"}
-		server.TLSPort = rctx.HTTPSPort
-		// Need to store tls-port, tls-host un config variables so secure.middleware can read from there
-		restapi.TLSPort = strconv.Itoa(server.TLSPort)
-		restapi.Hostname = rctx.Host
-		restapi.TLSRedirect = rctx.TLSRedirect
-	}
-
-	defer server.Shutdown()
-
-	return server.Serve()
-}
--- a/cmd/console/main.go
+++ b/cmd/console/main.go
@@ -32,24 +32,30 @@ import (

 // Help template for Console.
 var consoleHelpTemplate = `NAME:
- {{.Name}} - {{.Usage}}
+  {{.Name}} - {{.Usage}}

 DESCRIPTION:
- {{.Description}}
+  {{.Description}}

 USAGE:
- {{.HelpName}} {{if .VisibleFlags}}[FLAGS] {{end}}COMMAND{{if .VisibleFlags}}{{end}} [ARGS...]
+  {{.HelpName}} {{if .VisibleFlags}}[FLAGS] {{end}}COMMAND{{if .VisibleFlags}}{{end}} [ARGS...]

 COMMANDS:
- {{range .VisibleCommands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
- {{end}}{{if .VisibleFlags}}
+  {{range .VisibleCommands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
+  {{end}}{{if .VisibleFlags}}
 FLAGS:
- {{range .VisibleFlags}}{{.}}
- {{end}}{{end}}
+  {{range .VisibleFlags}}{{.}}
+  {{end}}{{end}}
 VERSION:
- {{.Version}}
+  {{.Version}}
 `

+var appCmds = []cli.Command{
+	serverCmd,
+	updateCmd,
+	operatorCmd,
+}
+
 func newApp(name string) *cli.App {
 	// Collection of console commands currently supported are.
 	var commands []cli.Command
--- a/cmd/console/operator.go
+++ b/cmd/console/operator.go
@@ -1,8 +1,5 @@
-//go:build operator
-// +build operator
-
 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -20,16 +17,12 @@
 package main

 import (
-	"context"
 	"fmt"
 	"io/ioutil"
 	"path/filepath"
 	"strconv"
-	"syscall"
 	"time"

-	"github.com/minio/console/pkg/logger"
-
 	"github.com/minio/console/restapi"

 	"github.com/go-openapi/loads"
@@ -109,7 +102,7 @@ func buildOperatorServer() (*operatorapi.Server, error) {
 	}

 	api := operations.NewOperatorAPI(swaggerSpec)
-	api.Logger = restapi.LogInfo
+	api.Logger = operatorapi.LogInfo
 	server := operatorapi.NewServer(api)

 	parser := flags.NewParser(server, flags.Default)
@@ -150,7 +143,7 @@ func loadOperatorAllCerts(ctx *cli.Context) error {
 	}

 	// load the certificates and the CAs
-	restapi.GlobalRootCAs, restapi.GlobalPublicCerts, restapi.GlobalTLSCertsManager, err = certs.GetAllCertificatesAndCAs()
+	operatorapi.GlobalRootCAs, operatorapi.GlobalPublicCerts, operatorapi.GlobalTLSCertsManager, err = certs.GetAllCertificatesAndCAs()
 	if err != nil {
 		return fmt.Errorf("unable to load certificates at %s: failed with %w", certs.GlobalCertsDir.Get(), err)
 	}
@@ -162,12 +155,12 @@ func loadOperatorAllCerts(ctx *cli.Context) error {
 		swaggerServerCACertificate := ctx.String("tls-ca")
 		// load tls cert and key from swagger server tls-certificate and tls-key flags
 		if swaggerServerCertificate != "" && swaggerServerCertificateKey != "" {
-			if err = restapi.GlobalTLSCertsManager.AddCertificate(swaggerServerCertificate, swaggerServerCertificateKey); err != nil {
+			if err = operatorapi.GlobalTLSCertsManager.AddCertificate(swaggerServerCertificate, swaggerServerCertificateKey); err != nil {
 				return err
 			}
 			x509Certs, err := certs.ParsePublicCertFile(swaggerServerCertificate)
 			if err == nil {
-				restapi.GlobalPublicCerts = append(restapi.GlobalPublicCerts, x509Certs...)
+				operatorapi.GlobalPublicCerts = append(operatorapi.GlobalPublicCerts, x509Certs...)
 			}
 		}

@@ -175,45 +168,30 @@ func loadOperatorAllCerts(ctx *cli.Context) error {
 		if swaggerServerCACertificate != "" {
 			caCert, caCertErr := ioutil.ReadFile(swaggerServerCACertificate)
 			if caCertErr == nil {
-				restapi.GlobalRootCAs.AppendCertsFromPEM(caCert)
+				operatorapi.GlobalRootCAs.AppendCertsFromPEM(caCert)
 			}
 		}
 	}

-	if restapi.GlobalTLSCertsManager != nil {
-		restapi.GlobalTLSCertsManager.ReloadOnSignal(syscall.SIGHUP)
-	}
-
 	return nil
 }

 // StartServer starts the console service
 func startOperatorServer(ctx *cli.Context) error {
-	if err := loadAllCerts(ctx); err != nil {
+	if err := loadOperatorAllCerts(ctx); err != nil {
 		// Log this as a warning and continue running console without TLS certificates
-		restapi.LogError("Unable to load certs: %v", err)
+		operatorapi.LogError("Unable to load certs: %v", err)
 	}

-	xctx := context.Background()
-	transport := restapi.PrepareSTSClientTransport(false)
-	if err := logger.InitializeLogger(xctx, transport); err != nil {
-		fmt.Println("error InitializeLogger", err)
-		logger.CriticalIf(xctx, err)
-	}
-	// custom error configuration
-	restapi.LogInfo = logger.Info
-	restapi.LogError = logger.Error
-	restapi.LogIf = logger.LogIf
-
 	var rctx operatorapi.Context
 	if err := rctx.Load(ctx); err != nil {
-		restapi.LogError("argument validation failed: %v", err)
+		operatorapi.LogError("argument validation failed: %v", err)
 		return err
 	}

 	server, err := buildOperatorServer()
 	if err != nil {
-		restapi.LogError("Unable to initialize console server: %v", err)
+		operatorapi.LogError("Unable to initialize console server: %v", err)
 		return err
 	}

@@ -226,7 +204,7 @@ func startOperatorServer(ctx *cli.Context) error {
 	operatorapi.Port = strconv.Itoa(server.Port)
 	operatorapi.Hostname = server.Host

-	if len(restapi.GlobalPublicCerts) > 0 {
+	if len(operatorapi.GlobalPublicCerts) > 0 {
 		// If TLS certificates are provided enforce the HTTPS schema, meaning console will redirect
 		// plain HTTP connections to HTTPS server
 		server.EnabledListeners = []string{"http", "https"}
@@ -239,5 +217,30 @@ func startOperatorServer(ctx *cli.Context) error {

 	defer server.Shutdown()

+	// subnet license refresh process
+	go func() {
+		// start refreshing subnet license after 5 seconds..
+		time.Sleep(time.Second * 5)
+
+		failedAttempts := 0
+		for {
+			if err := operatorapi.RefreshLicense(); err != nil {
+				operatorapi.LogError("Refreshing subnet license failed: %v", err)
+				failedAttempts++
+				// end license refresh after 3 consecutive failed attempts
+				if failedAttempts >= 3 {
+					return
+				}
+				// wait 5 minutes and retry again
+				time.Sleep(time.Minute * 5)
+				continue
+			}
+			// if license refreshed successfully reset the counter
+			failedAttempts = 0
+			// try to refresh license every 24 hrs
+			time.Sleep(time.Hour * 24)
+		}
+	}()
+
 	return server.Serve()
 }
--- a/cmd/console/server.go
+++ b/cmd/console/server.go
@@ -19,8 +19,10 @@ package main
 import (
 	"fmt"
 	"io/ioutil"
+	"os"
 	"path/filepath"
-	"syscall"
+	"strconv"
+	"time"

 	"github.com/go-openapi/loads"
 	"github.com/jessevdk/go-flags"
@@ -170,9 +172,53 @@ func loadAllCerts(ctx *cli.Context) error {
 		}
 	}

-	if restapi.GlobalTLSCertsManager != nil {
-		restapi.GlobalTLSCertsManager.ReloadOnSignal(syscall.SIGHUP)
-	}
-
 	return nil
 }
+
+// StartServer starts the console service
+func StartServer(ctx *cli.Context) error {
+	if os.Getenv("CONSOLE_OPERATOR_MODE") != "" && os.Getenv("CONSOLE_OPERATOR_MODE") == "on" {
+		return startOperatorServer(ctx)
+	}
+
+	if err := loadAllCerts(ctx); err != nil {
+		// Log this as a warning and continue running console without TLS certificates
+		restapi.LogError("Unable to load certs: %v", err)
+	}
+
+	var rctx restapi.Context
+	if err := rctx.Load(ctx); err != nil {
+		restapi.LogError("argument validation failed: %v", err)
+		return err
+	}
+
+	server, err := buildServer()
+	if err != nil {
+		restapi.LogError("Unable to initialize console server: %v", err)
+		return err
+	}
+
+	server.Host = rctx.Host
+	server.Port = rctx.HTTPPort
+	// set conservative timesout for uploads
+	server.ReadTimeout = 1 * time.Hour
+	// no timeouts for response for downloads
+	server.WriteTimeout = 0
+	restapi.Port = strconv.Itoa(server.Port)
+	restapi.Hostname = server.Host
+
+	if len(restapi.GlobalPublicCerts) > 0 {
+		// If TLS certificates are provided enforce the HTTPS schema, meaning console will redirect
+		// plain HTTP connections to HTTPS server
+		server.EnabledListeners = []string{"http", "https"}
+		server.TLSPort = rctx.HTTPSPort
+		// Need to store tls-port, tls-host un config variables so secure.middleware can read from there
+		restapi.TLSPort = strconv.Itoa(server.TLSPort)
+		restapi.Hostname = rctx.Host
+		restapi.TLSRedirect = rctx.TLSRedirect
+	}
+
+	defer server.Shutdown()
+
+	return server.Serve()
+}
--- a/go.mod
+++ b/go.mod
@@ -1,197 +1,44 @@
 module github.com/minio/console

-go 1.18
+go 1.16

 require (
 	github.com/blang/semver/v4 v4.0.0
-	github.com/cheggaaa/pb/v3 v3.1.0
+	github.com/cheggaaa/pb/v3 v3.0.6
+	github.com/coreos/go-oidc v2.2.1+incompatible
 	github.com/dustin/go-humanize v1.0.0
-	github.com/fatih/color v1.13.0
-	github.com/go-openapi/errors v0.20.3
-	github.com/go-openapi/loads v0.21.2
-	github.com/go-openapi/runtime v0.24.2
-	github.com/go-openapi/spec v0.20.7
-	github.com/go-openapi/strfmt v0.21.3
-	github.com/go-openapi/swag v0.22.3
-	github.com/go-openapi/validate v0.22.0
-	github.com/golang-jwt/jwt/v4 v4.4.2
-	github.com/google/uuid v1.3.0
-	github.com/gorilla/websocket v1.5.0
-	github.com/jessevdk/go-flags v1.5.0
-	github.com/klauspost/compress v1.15.12
-	github.com/minio/cli v1.24.0
-	github.com/minio/directpv v1.4.4-0.20220805090942-948ca4731651
-	github.com/minio/highwayhash v1.0.2
-	github.com/minio/kes v0.22.0
-	github.com/minio/madmin-go/v2 v2.0.0
-	github.com/minio/mc v0.0.0-20221201184114-854b4f123f03
-	github.com/minio/minio-go/v7 v7.0.44
-	github.com/minio/operator v0.0.0-20220902184351-21e4073132b0
-	github.com/minio/pkg v1.5.5
-	github.com/minio/selfupdate v0.5.0
+	github.com/go-openapi/errors v0.19.9
+	github.com/go-openapi/loads v0.20.2
+	github.com/go-openapi/runtime v0.19.24
+	github.com/go-openapi/spec v0.20.3
+	github.com/go-openapi/strfmt v0.20.0
+	github.com/go-openapi/swag v0.19.14
+	github.com/go-openapi/validate v0.20.2
+	github.com/gorilla/websocket v1.4.2
+	github.com/jessevdk/go-flags v1.4.0
+	github.com/minio/cli v1.22.0
+	github.com/minio/direct-csi v1.3.5-0.20210601185811-f7776f7961bf
+	github.com/minio/kes v0.11.0
+	github.com/minio/madmin-go v1.0.17
+	github.com/minio/mc v0.0.0-20210626002108-cebf3318546f
+	github.com/minio/minio-go/v7 v7.0.13-0.20210715203016-9e713532886e
+	github.com/minio/operator v0.0.0-20210812082324-26350f153661
+	github.com/minio/operator/logsearchapi v0.0.0-20210812082324-26350f153661
+	github.com/minio/pkg v1.0.8
+	github.com/minio/selfupdate v0.3.1
 	github.com/mitchellh/go-homedir v1.1.0
-	github.com/rs/xid v1.4.0
+	github.com/pquerna/cachecontrol v0.0.0-20180517163645-1555304b9b35 // indirect
+	github.com/rs/xid v1.2.1
 	github.com/secure-io/sio-go v0.3.1
-	github.com/stretchr/testify v1.8.1
-	github.com/tidwall/gjson v1.14.3
-	github.com/unrolled/secure v1.13.0
-	golang.org/x/crypto v0.3.0
-	golang.org/x/net v0.2.0
-	golang.org/x/oauth2 v0.2.0
-	// Added to include security fix for
-	// https://github.com/golang/go/issues/56152
-	golang.org/x/text v0.4.0 // indirect
+	github.com/stretchr/testify v1.7.0
+	github.com/unrolled/secure v1.0.7
+	golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b
+	golang.org/x/net v0.0.0-20210421230115-4e50805a0758
+	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d
 	gopkg.in/yaml.v2 v2.4.0
-	k8s.io/api v0.25.4
-	k8s.io/apimachinery v0.25.4
-	k8s.io/client-go v0.25.4
-	k8s.io/utils v0.0.0-20221108210102-8e77b1f39fe2
+	k8s.io/api v0.21.1
+	k8s.io/apimachinery v0.21.1
+	k8s.io/client-go v0.21.1
 )

-require (
-	aead.dev/mem v0.2.0 // indirect
-	cloud.google.com/go/compute v1.7.0 // indirect
-	github.com/Azure/go-autorest v14.2.0+incompatible // indirect
-	github.com/Azure/go-autorest/autorest v0.11.27 // indirect
-	github.com/Azure/go-autorest/autorest/adal v0.9.20 // 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/VividCortex/ewma v1.2.0 // indirect
-	github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d // indirect
-	github.com/aymanbagabas/go-osc52 v1.2.1 // indirect
-	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.1.2 // indirect
-	github.com/charmbracelet/bubbles v0.14.0 // indirect
-	github.com/charmbracelet/bubbletea v0.22.1 // indirect
-	github.com/charmbracelet/lipgloss v0.6.0 // indirect
-	github.com/cheggaaa/pb v1.0.29 // indirect
-	github.com/containerd/console v1.0.3 // indirect
-	github.com/coreos/go-semver v0.3.0 // indirect
-	github.com/coreos/go-systemd/v22 v22.4.0 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect
-	github.com/docker/go-units v0.4.0 // indirect
-	github.com/emicklei/go-restful/v3 v3.8.0 // indirect
-	github.com/evanphx/json-patch v5.6.0+incompatible // indirect
-	github.com/fatih/structs v1.1.0 // indirect
-	github.com/fsnotify/fsnotify v1.5.1 // indirect
-	github.com/gdamore/encoding v1.0.0 // indirect
-	github.com/gdamore/tcell/v2 v2.5.3 // indirect
-	github.com/go-logr/logr v1.2.3 // indirect
-	github.com/go-ole/go-ole v1.2.6 // indirect
-	github.com/go-openapi/analysis v0.21.4 // indirect
-	github.com/go-openapi/jsonpointer v0.19.5 // indirect
-	github.com/go-openapi/jsonreference v0.20.0 // indirect
-	github.com/goccy/go-json v0.9.11 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang-jwt/jwt v3.2.2+incompatible // indirect
-	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/google/gnostic v0.5.7-v3refs // indirect
-	github.com/google/go-cmp v0.5.9 // indirect
-	github.com/google/gofuzz v1.2.0 // indirect
-	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
-	github.com/hashicorp/errwrap v1.1.0 // indirect
-	github.com/hashicorp/go-multierror v1.1.1 // indirect
-	github.com/hashicorp/hcl v1.0.0 // indirect
-	github.com/imdario/mergo v0.3.12 // indirect
-	github.com/inconshreveable/mousetrap v1.0.1 // indirect
-	github.com/jedib0t/go-pretty/v6 v6.3.8 // indirect
-	github.com/josharian/intern v1.0.0 // indirect
-	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.1 // indirect
-	github.com/kr/pretty v0.2.1 // indirect
-	github.com/lestrrat-go/backoff/v2 v2.0.8 // indirect
-	github.com/lestrrat-go/blackmagic v1.0.1 // indirect
-	github.com/lestrrat-go/httpcc v1.0.1 // indirect
-	github.com/lestrrat-go/iter v1.0.2 // indirect
-	github.com/lestrrat-go/jwx v1.2.25 // indirect
-	github.com/lestrrat-go/option v1.0.0 // indirect
-	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
-	github.com/lufia/plan9stats v0.0.0-20220913051719-115f729f3c8c // indirect
-	github.com/magiconair/properties v1.8.5 // indirect
-	github.com/mailru/easyjson v0.7.7 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-ieproxy v0.0.1 // indirect
-	github.com/mattn/go-isatty v0.0.16 // indirect
-	github.com/mattn/go-localereader v0.0.1 // indirect
-	github.com/mattn/go-runewidth v0.0.14 // indirect
-	github.com/matttproud/golang_protobuf_extensions v1.0.2 // indirect
-	github.com/mb0/glob v0.0.0-20160210091149-1eb79d2de6c4 // indirect
-	github.com/miekg/dns v1.1.48 // indirect
-	github.com/minio/colorjson v1.0.4 // indirect
-	github.com/minio/filepath v1.0.0 // indirect
-	github.com/minio/madmin-go v1.7.5 // indirect
-	github.com/minio/md5-simd v1.1.2 // indirect
-	github.com/minio/sha256-simd v1.0.0 // indirect
-	github.com/mitchellh/mapstructure v1.4.3 // indirect
-	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/montanaflynn/stats v0.6.6 // indirect
-	github.com/muesli/ansi v0.0.0-20211031195517-c9f0611b6c70 // indirect
-	github.com/muesli/cancelreader v0.2.2 // indirect
-	github.com/muesli/reflow v0.3.0 // indirect
-	github.com/muesli/termenv v0.13.0 // indirect
-	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
-	github.com/navidys/tvxwidgets v0.1.1 // indirect
-	github.com/oklog/ulid v1.3.1 // indirect
-	github.com/olekukonko/tablewriter v0.0.5 // indirect
-	github.com/pelletier/go-toml v1.9.4 // indirect
-	github.com/philhofer/fwd v1.1.2-0.20210722190033-5c56ac6d0bb9 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
-	github.com/pkg/xattr v0.4.9 // indirect
-	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
-	github.com/posener/complete v1.2.3 // indirect
-	github.com/power-devops/perfstat v0.0.0-20220216144756-c35f1ee13d7c // indirect
-	github.com/prometheus/client_golang v1.13.0 // indirect
-	github.com/prometheus/client_model v0.3.0 // indirect
-	github.com/prometheus/common v0.37.0 // indirect
-	github.com/prometheus/procfs v0.8.0 // indirect
-	github.com/prometheus/prom2json v1.3.2 // indirect
-	github.com/rivo/tview v0.0.0-20220916081518-2e69b7385a37 // indirect
-	github.com/rivo/uniseg v0.4.2 // indirect
-	github.com/rjeczalik/notify v0.9.2 // indirect
-	github.com/shirou/gopsutil/v3 v3.22.9 // indirect
-	github.com/sirupsen/logrus v1.9.0 // indirect
-	github.com/spf13/afero v1.6.0 // indirect
-	github.com/spf13/cast v1.4.1 // indirect
-	github.com/spf13/jwalterweatherman v1.1.0 // indirect
-	github.com/spf13/pflag v1.0.5 // indirect
-	github.com/spf13/viper v1.10.0 // indirect
-	github.com/subosito/gotenv v1.2.0 // indirect
-	github.com/tidwall/match v1.1.1 // indirect
-	github.com/tidwall/pretty v1.2.1 // indirect
-	github.com/tinylib/msgp v1.1.7-0.20211026165309-e818a1881b0e // indirect
-	github.com/tklauser/go-sysconf v0.3.11 // indirect
-	github.com/tklauser/numcpus v0.6.0 // indirect
-	github.com/yusufpapurcu/wmi v1.2.2 // indirect
-	go.etcd.io/etcd/api/v3 v3.5.5 // indirect
-	go.etcd.io/etcd/client/pkg/v3 v3.5.5 // indirect
-	go.etcd.io/etcd/client/v3 v3.5.5 // indirect
-	go.mongodb.org/mongo-driver v1.10.0 // indirect
-	go.uber.org/atomic v1.10.0 // indirect
-	go.uber.org/multierr v1.8.0 // indirect
-	go.uber.org/zap v1.23.0 // indirect
-	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
-	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/sys v0.2.0 // indirect
-	golang.org/x/term v0.2.0 // indirect
-	golang.org/x/time v0.0.0-20220224211638-0e9765cccd65 // indirect
-	golang.org/x/tools v0.1.12 // indirect
-	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto v0.0.0-20221018160656-63c7b68cfc55 // indirect
-	google.golang.org/grpc v1.50.1 // indirect
-	google.golang.org/protobuf v1.28.1 // indirect
-	gopkg.in/h2non/filetype.v1 v1.0.5 // 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/apiextensions-apiserver v0.24.3 // indirect
-	k8s.io/klog/v2 v2.80.1 // indirect
-	k8s.io/kube-openapi v0.0.0-20220803162953-67bda5d908f1 // indirect
-	sigs.k8s.io/controller-runtime v0.11.1 // indirect
-	sigs.k8s.io/json v0.0.0-20220713155537-f223a00ba0e2 // indirect
-	sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect
-	sigs.k8s.io/yaml v1.3.0 // indirect
-)
+replace google.golang.org/grpc => google.golang.org/grpc v1.29.1
--- a/go.sum
+++ b/go.sum
--- a/hack/update-codegen.sh
+++ b/hack/update-codegen.sh
@@ -1,4 +1,18 @@
 #!/bin/bash
+#
+# Copyright 2020 Google LLC
+#
+# 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
+#
+#     https://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.

 set -o errexit
 set -o nounset
@@ -6,7 +20,10 @@ set -o pipefail

 SCRIPT_ROOT=$(dirname ${BASH_SOURCE})/..

-GO111MODULE=off go get -d k8s.io/code-generator/...
+go get -d k8s.io/code-generator/...
+
+# Checkout code-generator to compatible version
+#(cd $GOPATH/src/k8s.io/code-generator && git checkout origin/release-1.14 -B release-1.14)

 REPOSITORY=github.com/minio/console
 $GOPATH/src/k8s.io/code-generator/generate-groups.sh all \
--- a/images/pic1.png
+++ b/images/pic1.png
--- a/images/pic2.png
+++ b/images/pic2.png
--- a/integration/access_rules_test.go
+++ b/integration/access_rules_test.go
@@ -1,216 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package integration
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_AddAccessRuleAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddBucket("testaccessruleadd", false, false, nil, nil)
-
-	type args struct {
-		bucket string
-		prefix string
-		access string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Create Access Rule - Valid",
-			args: args{
-				bucket: "testaccessruleadd",
-				prefix: "/test/",
-				access: "readonly",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "Add Access Rule - Invalid",
-			args: args{
-				bucket: "testaccessruleadd",
-				prefix: "/test/",
-				access: "readonl",
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-		{
-			name: "Add Access Rule - Invalid Bucket",
-			args: args{
-				bucket: "fakebucket",
-				prefix: "/test/",
-				access: "readonl",
-			},
-			expectedStatus: 404,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			requestDataPolicy := map[string]interface{}{}
-			requestDataPolicy["prefix"] = tt.args.prefix
-			requestDataPolicy["access"] = tt.args.access
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				"PUT", fmt.Sprintf("http://localhost:9090/api/v1/bucket/%s/access-rules", tt.args.bucket), requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, "Status Code is incorrect")
-			}
-		})
-	}
-}
-
-func Test_GetAccessRulesAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddBucket("testaccessruleget", false, false, nil, nil)
-
-	type args struct {
-		bucket string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Get Access Rule - Valid",
-			args: args{
-				bucket: "testaccessruleget",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			request, err := http.NewRequest(
-				"GET", fmt.Sprintf("http://localhost:9090/api/v1/bucket/%s/access-rules", tt.args.bucket), nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, "Status Code is incorrect")
-			}
-		})
-	}
-}
-
-func Test_DeleteAccessRuleAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddBucket("testaccessruledelete", false, false, nil, nil)
-
-	type args struct {
-		prefix string
-		access string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Delete Access Rule - Valid",
-			args: args{
-				prefix: "/test/",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			requestDataPolicy := map[string]interface{}{}
-			requestDataPolicy["prefix"] = tt.args.prefix
-			requestDataPolicy["access"] = tt.args.access
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				"DELETE", "http://localhost:9090/api/v1/bucket/testaccessruledelete/access-rules", requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, "Status Code is incorrect")
-			}
-		})
-	}
-}
--- a/integration/admin_api_integration_test.go
+++ b/integration/admin_api_integration_test.go
@@ -1,330 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2021 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-// These tests are for AdminAPI Tag based on swagger-console.yml
-
-package integration
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/minio/console/models"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func RestartService() (*http.Response, error) {
-	/*
-		Helper function to restart service
-		HTTP Verb: POST
-		URL: /api/v1/service/restart
-	*/
-	request, err := http.NewRequest(
-		"POST",
-		"http://localhost:9090/api/v1/service/restart",
-		nil,
-	)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	client := &http.Client{
-		Timeout: 2000 * time.Second, // increased timeout since restart takes time, more than other APIs.
-	}
-	response, err := client.Do(request)
-	return response, err
-}
-
-func GetNodes() (*http.Response, error) {
-	/*
-		Helper function to get nodes
-		HTTP Verb: GET
-		URL: /api/v1/nodes
-	*/
-	request, err := http.NewRequest(
-		"GET",
-		"http://localhost:9090/api/v1/nodes",
-		nil,
-	)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	client := &http.Client{
-		Timeout: 2000 * time.Second, // increased timeout since restart takes time, more than other APIs.
-	}
-	response, err := client.Do(request)
-	return response, err
-}
-
-func NotifyPostgres() (*http.Response, error) {
-	/*
-		Helper function to add Postgres Notification
-		HTTP Verb: PUT
-		URL: api/v1/configs/notify_postgres
-		Body:
-		{
-			"key_values":[
-				{
-					"key":"connection_string",
-					"value":"user=postgres password=password host=localhost dbname=postgres port=5432 sslmode=disable"
-				},
-				{
-					"key":"table",
-					"value":"accountsssss"
-				},
-				{
-					"key":"format",
-					"value":"namespace"
-				},
-				{
-					"key":"queue_limit",
-					"value":"10000"
-				},
-				{
-					"key":"comment",
-					"value":"comment"
-				}
-			]
-		}
-	*/
-	Body := models.SetConfigRequest{
-		KeyValues: []*models.ConfigurationKV{
-			{
-				Key:   "connection_string",
-				Value: "user=postgres password=password host=173.18.0.3 dbname=postgres port=5432 sslmode=disable",
-			},
-			{
-				Key:   "table",
-				Value: "accountsssss",
-			},
-			{
-				Key:   "format",
-				Value: "namespace",
-			},
-			{
-				Key:   "queue_limit",
-				Value: "10000",
-			},
-			{
-				Key:   "comment",
-				Value: "comment",
-			},
-		},
-	}
-
-	requestDataJSON, _ := json.Marshal(Body)
-	requestDataBody := bytes.NewReader(requestDataJSON)
-	request, err := http.NewRequest(
-		"PUT",
-		"http://localhost:9090/api/v1/configs/notify_postgres",
-		requestDataBody,
-	)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	client := &http.Client{
-		Timeout: 2 * time.Second,
-	}
-	response, err := client.Do(request)
-	return response, err
-}
-
-func TestNotifyPostgres(t *testing.T) {
-	// Variables
-	assert := assert.New(t)
-
-	// Test
-	response, err := NotifyPostgres()
-	finalResponse := inspectHTTPResponse(response)
-	assert.Nil(err)
-	if err != nil {
-		log.Println(err)
-		assert.Fail(finalResponse)
-		return
-	}
-	if response != nil {
-		assert.Equal(200, response.StatusCode, finalResponse)
-	}
-}
-
-func TestRestartService(t *testing.T) {
-	assert := assert.New(t)
-	restartResponse, restartError := RestartService()
-	assert.Nil(restartError)
-	if restartError != nil {
-		log.Println(restartError)
-		return
-	}
-	addObjRsp := inspectHTTPResponse(restartResponse)
-	if restartResponse != nil {
-		assert.Equal(
-			204,
-			restartResponse.StatusCode,
-			addObjRsp,
-		)
-	}
-}
-
-func ListPoliciesWithBucket(bucketName string) (*http.Response, error) {
-	/*
-		Helper function to List Policies With Given Bucket
-		HTTP Verb: GET
-		URL: /bucket-policy/{bucket}
-	*/
-	request, err := http.NewRequest(
-		"GET", "http://localhost:9090/api/v1/bucket-policy/"+bucketName, nil)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	client := &http.Client{
-		Timeout: 2 * time.Second,
-	}
-	response, err := client.Do(request)
-	return response, err
-}
-
-func TestListPoliciesWithBucket(t *testing.T) {
-	// Test Variables
-	bucketName := "testlistpolicieswithbucket"
-	assert := assert.New(t)
-
-	// Test
-	response, err := ListPoliciesWithBucket(bucketName)
-	assert.Nil(err)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	parsedResponse := inspectHTTPResponse(response)
-	if response != nil {
-		assert.Equal(
-			200,
-			response.StatusCode,
-			parsedResponse,
-		)
-	}
-}
-
-func ListUsersWithAccessToBucket(bucketName string) (*http.Response, error) {
-	/*
-		Helper function to List Users With Access to a Given Bucket
-		HTTP Verb: GET
-		URL: /bucket-users/{bucket}
-	*/
-	request, err := http.NewRequest(
-		"GET", "http://localhost:9090/api/v1/bucket-users/"+bucketName, nil)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	client := &http.Client{
-		Timeout: 2 * time.Second,
-	}
-	response, err := client.Do(request)
-	return response, err
-}
-
-func TestListUsersWithAccessToBucket(t *testing.T) {
-	// Test Variables
-	bucketName := "testlistuserswithaccesstobucket1"
-	assert := assert.New(t)
-
-	// Test
-	response, err := ListUsersWithAccessToBucket(bucketName)
-	assert.Nil(err)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	parsedResponse := inspectHTTPResponse(response)
-	if response != nil {
-		assert.Equal(
-			200,
-			response.StatusCode,
-			parsedResponse,
-		)
-	}
-}
-
-func TestGetNodes(t *testing.T) {
-	assert := assert.New(t)
-	getNodesResponse, getNodesError := GetNodes()
-	assert.Nil(getNodesError)
-	if getNodesError != nil {
-		log.Println(getNodesError)
-		return
-	}
-	addObjRsp := inspectHTTPResponse(getNodesResponse)
-	if getNodesResponse != nil {
-		assert.Equal(
-			200,
-			getNodesResponse.StatusCode,
-			addObjRsp,
-		)
-	}
-}
-
-func ArnList() (*http.Response, error) {
-	/*
-		Helper function to get arn list
-		HTTP Verb: GET
-		URL: /api/v1/admin/arns
-	*/
-	request, err := http.NewRequest(
-		"GET", "http://localhost:9090/api/v1/admin/arns", nil)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	client := &http.Client{
-		Timeout: 2 * time.Second,
-	}
-	response, err := client.Do(request)
-	return response, err
-}
-
-func TestArnList(t *testing.T) {
-	assert := assert.New(t)
-	resp, err := ArnList()
-	assert.Nil(err)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	objRsp := inspectHTTPResponse(resp)
-	if resp != nil {
-		assert.Equal(
-			200,
-			resp.StatusCode,
-			objRsp,
-		)
-	}
-}
--- a/integration/buckets_test.go
+++ b/integration/buckets_test.go
@@ -1,182 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2021 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package integration
-
-import (
-	"bytes"
-	b64 "encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"os"
-	"strconv"
-	"testing"
-	"time"
-
-	"github.com/go-openapi/loads"
-	"github.com/minio/console/restapi"
-	"github.com/minio/console/restapi/operations"
-)
-
-var token string
-
-func encodeBase64(fileName string) string {
-	/*
-		Helper function to encode in base64 the file name so we can get the path
-	*/
-	path := b64.StdEncoding.EncodeToString([]byte(fileName))
-	return path
-}
-
-func inspectHTTPResponse(httpResponse *http.Response) string {
-	/*
-		Helper function to inspect the content of a HTTP response.
-	*/
-	b, err := io.ReadAll(httpResponse.Body)
-	if err != nil {
-		log.Fatalln(err)
-	}
-	return "Http Response: " + string(b)
-}
-
-func initConsoleServer() (*restapi.Server, error) {
-	// os.Setenv("CONSOLE_MINIO_SERVER", "localhost:9000")
-
-	swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwaggerJSON)
-	if err != nil {
-		return nil, err
-	}
-
-	noLog := func(string, ...interface{}) {
-		// nothing to log
-	}
-
-	// Initialize MinIO loggers
-	restapi.LogInfo = noLog
-	restapi.LogError = noLog
-
-	api := operations.NewConsoleAPI(swaggerSpec)
-	api.Logger = noLog
-
-	server := restapi.NewServer(api)
-	// register all APIs
-	server.ConfigureAPI()
-
-	// restapi.GlobalRootCAs, restapi.GlobalPublicCerts, restapi.GlobalTLSCertsManager = globalRootCAs, globalPublicCerts, globalTLSCerts
-
-	consolePort, _ := strconv.Atoi("9090")
-
-	server.Host = "0.0.0.0"
-	server.Port = consolePort
-	restapi.Port = "9090"
-	restapi.Hostname = "0.0.0.0"
-
-	return server, nil
-}
-
-func TestMain(m *testing.M) {
-	// start console server
-	go func() {
-		fmt.Println("start server")
-		srv, err := initConsoleServer()
-		if err != nil {
-			log.Println(err)
-			log.Println("init fail")
-			return
-		}
-		srv.Serve()
-	}()
-
-	fmt.Println("sleeping")
-	time.Sleep(2 * time.Second)
-
-	client := &http.Client{
-		Timeout: 2 * time.Second,
-	}
-	// get login credentials
-
-	requestData := map[string]string{
-		"accessKey": "minioadmin",
-		"secretKey": "minioadmin",
-	}
-
-	requestDataJSON, _ := json.Marshal(requestData)
-
-	requestDataBody := bytes.NewReader(requestDataJSON)
-
-	request, err := http.NewRequest("POST", "http://localhost:9090/api/v1/login", requestDataBody)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-
-	request.Header.Add("Content-Type", "application/json")
-
-	response, err := client.Do(request)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-
-	if response != nil {
-		for _, cookie := range response.Cookies() {
-			if cookie.Name == "token" {
-				token = cookie.Value
-				break
-			}
-		}
-	}
-
-	if token == "" {
-		log.Println("authentication token not found in cookies response")
-		return
-	}
-
-	code := m.Run()
-
-	requestDataAdd := map[string]interface{}{
-		"name": "test1",
-	}
-
-	requestDataJSON, _ = json.Marshal(requestDataAdd)
-
-	requestDataBody = bytes.NewReader(requestDataJSON)
-
-	// delete bucket
-	request, err = http.NewRequest("DELETE", "http://localhost:9090/api/v1/buckets/test1", requestDataBody)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-
-	response, err = client.Do(request)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-
-	if response != nil {
-		fmt.Println("DELETE StatusCode:", response.StatusCode)
-	}
-
-	os.Exit(code)
-}
--- a/integration/config_test.go
+++ b/integration/config_test.go
@@ -1,250 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package integration
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_ConfigAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	tests := []struct {
-		name           string
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name:           "Config - Valid",
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-	}
-
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			request, err := http.NewRequest("GET", "http://localhost:9090/api/v1/configs", nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-			}
-		})
-	}
-}
-
-func Test_GetConfigAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	type args struct {
-		name string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Get Config - Valid",
-			args: args{
-				name: "storage_class",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "Get Config - Invalid",
-			args: args{
-				name: "asdf",
-			},
-			expectedStatus: 404,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			request, err := http.NewRequest(
-				"GET", fmt.Sprintf("http://localhost:9090/api/v1/configs/%s", tt.args.name), nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-			}
-		})
-	}
-}
-
-func Test_SetConfigAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	type args struct {
-		name      string
-		keyValues []map[string]interface{}
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Set Config - Valid",
-			args: args{
-				name:      "region",
-				keyValues: []map[string]interface{}{{"key": "name", "value": "testServer"}, {"key": "region", "value": "us-west-1"}},
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "Set Config - Invalid",
-			args: args{
-				name:      "regiontest",
-				keyValues: []map[string]interface{}{{"key": "name", "value": "testServer"}, {"key": "region", "value": "us-west-1"}},
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			requestDataPolicy := map[string]interface{}{}
-
-			requestDataPolicy["key_values"] = tt.args.keyValues
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				"PUT", fmt.Sprintf("http://localhost:9090/api/v1/configs/%s", tt.args.name), requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-			}
-		})
-	}
-}
-
-func Test_ResetConfigAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	type args struct {
-		name string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Reset Config - Valid",
-			args: args{
-				name: "region",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "Reset Config - Invalid",
-			args: args{
-				name: "regiontest",
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			requestDataPolicy := map[string]interface{}{}
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				"POST", fmt.Sprintf("http://localhost:9090/api/v1/configs/%s/reset", tt.args.name), requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-			}
-		})
-	}
-}
--- a/integration/groups_test.go
+++ b/integration/groups_test.go
@@ -1,351 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package integration
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_AddGroupAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddUser("member1", "testtest", []string{}, []string{"consoleAdmin"})
-
-	type args struct {
-		group   string
-		members []string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Create Group - Valid",
-			args: args{
-				group:   "test",
-				members: []string{"member1"},
-			},
-			expectedStatus: 201,
-			expectedError:  nil,
-		},
-		{
-			name: "Create Group - Invalid",
-			args: args{
-				group:   "test",
-				members: []string{},
-			},
-			expectedStatus: 400,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			requestDataPolicy := map[string]interface{}{}
-			requestDataPolicy["group"] = tt.args.group
-			requestDataPolicy["members"] = tt.args.members
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				"POST", "http://localhost:9090/api/v1/groups", requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, "Status Code is incorrect")
-			}
-		})
-	}
-}
-
-func Test_GetGroupAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddUser("member2", "testtest", []string{}, []string{"consoleAdmin"})
-	AddGroup("getgroup1", []string{"member2"})
-
-	type args struct {
-		api string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Get Group - Valid",
-			args: args{
-				api: base64.StdEncoding.EncodeToString([]byte("getgroup1")),
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "Get Group - Invalid",
-			args: args{
-				api: base64.StdEncoding.EncodeToString([]byte("askfjalkd")),
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			requestDataPolicy := map[string]interface{}{}
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				"GET", fmt.Sprintf("http://localhost:9090/api/v1/group/%s", tt.args.api), requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, "Status Code is incorrect")
-			}
-		})
-	}
-}
-
-func Test_ListGroupsAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	tests := []struct {
-		name           string
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name:           "Get Group - Valid",
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			requestDataPolicy := map[string]interface{}{}
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				"GET", "http://localhost:9090/api/v1/groups", requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, "Status Code is incorrect")
-			}
-		})
-	}
-}
-
-func Test_PutGroupsAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddUser("member3", "testtest", []string{}, []string{"consoleAdmin"})
-	AddGroup("putgroup1", []string{})
-
-	type args struct {
-		api     string
-		members []string
-		status  string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Put Group - Valid",
-			args: args{
-				api:     base64.StdEncoding.EncodeToString([]byte("putgroup1")),
-				members: []string{"member3"},
-				status:  "enabled",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "Put Group - Invalid",
-			args: args{
-				api:     base64.StdEncoding.EncodeToString([]byte("gdgfdfgd")),
-				members: []string{"member3"},
-				status:  "enabled",
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			requestDataPolicy := map[string]interface{}{}
-
-			requestDataPolicy["members"] = tt.args.members
-			requestDataPolicy["status"] = tt.args.status
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				"PUT", fmt.Sprintf("http://localhost:9090/api/v1/group/%s", tt.args.api), requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, "Status Code is incorrect")
-			}
-		})
-	}
-}
-
-func Test_DeleteGroupAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddGroup("grouptests1", []string{})
-
-	type args struct {
-		api string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-		verb           string
-	}{
-		{
-			name: "Delete Group - Valid",
-			args: args{
-				api: base64.StdEncoding.EncodeToString([]byte("grouptests1")),
-			},
-			verb:           "DELETE",
-			expectedStatus: 204,
-			expectedError:  nil,
-		},
-		{
-			name: "Delete Group - Invalid",
-			args: args{
-				api: base64.StdEncoding.EncodeToString([]byte("grouptests12345")),
-			},
-			verb:           "DELETE",
-			expectedStatus: 404,
-			expectedError:  nil,
-		},
-		{
-			name: "Access Group After Delete - Invalid",
-			args: args{
-				api: base64.StdEncoding.EncodeToString([]byte("grouptests1")),
-			},
-			verb:           "GET",
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			requestDataPolicy := map[string]interface{}{}
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				tt.verb, fmt.Sprintf("http://localhost:9090/api/v1/group/%s", tt.args.api), requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, "Status Code is incorrect")
-			}
-		})
-	}
-}
--- a/integration/inspect_test.go
+++ b/integration/inspect_test.go
@@ -1,106 +0,0 @@
-package integration
-
-import (
-	"fmt"
-	"log"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func Inspect(volume string, file string, enc bool) (*http.Response, error) {
-	requestURL := fmt.Sprintf("http://localhost:9090/api/v1/admin/inspect?volume=%s&file=%s&encrypt=%t", volume, file, enc)
-	request, err := http.NewRequest(
-		"GET", requestURL, nil)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	client := &http.Client{
-		Timeout: 2 * time.Second,
-	}
-	response, err := client.Do(request)
-	return response, err
-}
-
-func TestInspect(t *testing.T) {
-	assert := assert.New(t)
-
-	type args struct {
-		volume  string
-		file    string
-		encrypt bool
-	}
-
-	// Inspect returns successful response always
-	tests := []struct {
-		name          string
-		args          args
-		expStatusCode int
-		expectedError bool
-	}{
-		{
-			name: "Test Invalid Path",
-			args: args{
-				volume:  "/test-with-slash",
-				file:    "/test-with-slash",
-				encrypt: false,
-			},
-			expStatusCode: 200,
-			expectedError: false,
-		},
-
-		{
-			name: "Test Invalid characters in Path",
-			args: args{
-				volume:  "//test",
-				file:    "//bucket",
-				encrypt: false,
-			},
-			expStatusCode: 200,
-			expectedError: true,
-		},
-		{
-			name: "Test valid bucket",
-			args: args{
-				volume:  "test-bucket",
-				file:    "test.txt",
-				encrypt: true,
-			},
-			expStatusCode: 200,
-			expectedError: false,
-		},
-		{
-			name: "Test Empty Path", // Un processable entity error
-			args: args{
-				volume:  "",
-				file:    "",
-				encrypt: false,
-			},
-			expStatusCode: 422,
-			expectedError: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			resp, err := Inspect(tt.args.volume, tt.args.file, tt.args.encrypt)
-			if tt.expectedError {
-				assert.Nil(err)
-				if err != nil {
-					log.Println(err)
-					return
-				}
-			}
-			if resp != nil {
-				assert.Equal(
-					tt.expStatusCode,
-					resp.StatusCode,
-				)
-			}
-		})
-	}
-}
--- a/integration/login_test.go
+++ b/integration/login_test.go
@@ -1,162 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2021 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package integration
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/minio/console/models"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestLoginStrategy(t *testing.T) {
-	assert := assert.New(t)
-
-	// image for now:
-	// minio: 9000
-	// console: 9090
-
-	client := &http.Client{
-		Timeout: 2 * time.Second,
-	}
-	// copy query params
-	request, err := http.NewRequest("GET", "http://localhost:9090/api/v1/login", nil)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-
-	response, err := client.Do(request)
-	assert.Nil(err)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-
-	if response != nil {
-		bodyBytes, _ := ioutil.ReadAll(response.Body)
-
-		loginDetails := models.LoginDetails{}
-
-		err = json.Unmarshal(bodyBytes, &loginDetails)
-		if err != nil {
-			log.Println(err)
-		}
-		assert.Nil(err)
-
-		assert.Equal(models.LoginDetailsLoginStrategyForm, loginDetails.LoginStrategy, "Login Details don't match")
-
-	}
-}
-
-func TestLogout(t *testing.T) {
-	assert := assert.New(t)
-
-	// image for now:
-	// minio: 9000
-	// console: 9090
-
-	client := &http.Client{
-		Timeout: 2 * time.Second,
-	}
-	requestData := map[string]string{
-		"accessKey": "minioadmin",
-		"secretKey": "minioadmin",
-	}
-
-	requestDataJSON, _ := json.Marshal(requestData)
-
-	requestDataBody := bytes.NewReader(requestDataJSON)
-
-	request, err := http.NewRequest("POST", "http://localhost:9090/api/v1/login", requestDataBody)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-
-	request.Header.Add("Content-Type", "application/json")
-
-	response, err := client.Do(request)
-
-	assert.NotNil(response, "Login response is nil")
-	assert.Nil(err, "Login errored out")
-
-	var loginToken string
-
-	for _, cookie := range response.Cookies() {
-		if cookie.Name == "token" {
-			loginToken = cookie.Value
-			break
-		}
-	}
-
-	if loginToken == "" {
-		log.Println("authentication token not found in cookies response")
-		return
-	}
-	logoutRequest := bytes.NewReader([]byte("{}"))
-	request, err = http.NewRequest("POST", "http://localhost:9090/api/v1/logout", logoutRequest)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", loginToken))
-	request.Header.Add("Content-Type", "application/json")
-
-	response, err = client.Do(request)
-	assert.NotNil(response, "Logout response is nil")
-	assert.Nil(err, "Logout errored out")
-	assert.Equal(response.StatusCode, 200)
-}
-
-func TestBadLogin(t *testing.T) {
-	assert := assert.New(t)
-
-	client := &http.Client{
-		Timeout: 2 * time.Second,
-	}
-	requestData := map[string]string{
-		"accessKey": "minioadmin",
-		"secretKey": "minioadminbad",
-	}
-
-	requestDataJSON, _ := json.Marshal(requestData)
-
-	requestDataBody := bytes.NewReader(requestDataJSON)
-
-	request, err := http.NewRequest("POST", "http://localhost:9090/api/v1/login", requestDataBody)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-
-	request.Header.Add("Content-Type", "application/json")
-
-	response, err := client.Do(request)
-
-	assert.Equal(401, response.StatusCode, "Login request not rejected")
-	assert.NotNil(response, "Login response is  nil")
-	assert.Nil(err, "Login errored out")
-}
--- a/integration/objects_test.go
+++ b/integration/objects_test.go
@@ -1,196 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package integration
-
-import (
-	"context"
-	"encoding/base64"
-	"fmt"
-	"log"
-	"math/rand"
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/minio/minio-go/v7"
-	"github.com/minio/minio-go/v7/pkg/credentials"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestObjectGet(t *testing.T) {
-	// for setup we'll create a bucket and upload a file
-	endpoint := "localhost:9000"
-	accessKeyID := "minioadmin"
-	secretAccessKey := "minioadmin"
-
-	// Initialize minio client object.
-	minioClient, err := minio.New(endpoint, &minio.Options{
-		Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
-		Secure: false,
-	})
-	if err != nil {
-		log.Fatalln(err)
-	}
-	bucketName := fmt.Sprintf("testbucket-%d", rand.Intn(1000-1)+1)
-	err = minioClient.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
-
-	if err != nil {
-		fmt.Println(err)
-	}
-	// upload a simple file
-	fakeFile := "12345678"
-	fileReader := strings.NewReader(fakeFile)
-
-	_, err = minioClient.PutObject(
-		context.Background(),
-		bucketName,
-		"myobject", fileReader, int64(len(fakeFile)), minio.PutObjectOptions{ContentType: "application/octet-stream"})
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-	_, err = minioClient.PutObject(
-		context.Background(),
-		bucketName,
-		"myobject.jpg", fileReader, int64(len(fakeFile)), minio.PutObjectOptions{ContentType: "application/octet-stream"})
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	assert := assert.New(t)
-	type args struct {
-		encodedPrefix string
-		versionID     string
-		bytesRange    string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Preview Object",
-			args: args{
-				encodedPrefix: base64.StdEncoding.EncodeToString([]byte("myobject")),
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "Preview image",
-			args: args{
-				encodedPrefix: base64.StdEncoding.EncodeToString([]byte("myobject.jpg")),
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "Get Range of bytes",
-			args: args{
-				encodedPrefix: base64.StdEncoding.EncodeToString([]byte("myobject.jpg")),
-				bytesRange:    "bytes=1-4",
-			},
-			expectedStatus: 206,
-			expectedError:  nil,
-		},
-		{
-			name: "Get Range of bytes empty start",
-			args: args{
-				encodedPrefix: base64.StdEncoding.EncodeToString([]byte("myobject.jpg")),
-				bytesRange:    "bytes=-4",
-			},
-			expectedStatus: 206,
-			expectedError:  nil,
-		},
-		{
-			name: "Get Invalid Range of bytes",
-			args: args{
-				encodedPrefix: base64.StdEncoding.EncodeToString([]byte("myobject.jpg")),
-				bytesRange:    "bytes=9-12",
-			},
-			expectedStatus: 400,
-			expectedError:  nil,
-		},
-		{
-			name: "Get Larger Range of bytes empty start",
-			args: args{
-				encodedPrefix: base64.StdEncoding.EncodeToString([]byte("myobject.jpg")),
-				bytesRange:    "bytes=-12",
-			},
-			expectedStatus: 206,
-			expectedError:  nil,
-		},
-		{
-			name: "Get invalid seek start Range of bytes",
-			args: args{
-				encodedPrefix: base64.StdEncoding.EncodeToString([]byte("myobject.jpg")),
-				bytesRange:    "bytes=12-16",
-			},
-			expectedStatus: 400,
-			expectedError:  nil,
-		},
-		{
-			name: "Bad Preview Object",
-			args: args{
-				encodedPrefix: "garble",
-			},
-			expectedStatus: 400,
-			expectedError:  nil,
-		},
-		{
-			name: "Bad Version Preview Object",
-			args: args{
-				encodedPrefix: base64.StdEncoding.EncodeToString([]byte("myobject")),
-				versionID:     "garble",
-			},
-			expectedStatus: 400,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-			destination := fmt.Sprintf("/api/v1/buckets/%s/objects/download?preview=true&prefix=%s&version_id=%s", bucketName, tt.args.encodedPrefix, tt.args.versionID)
-			finalURL := fmt.Sprintf("http://localhost:9090%s", destination)
-			request, err := http.NewRequest("GET", finalURL, nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			if tt.args.bytesRange != "" {
-				request.Header.Add("Range", tt.args.bytesRange)
-			}
-
-			response, err := client.Do(request)
-
-			assert.NotNil(response, fmt.Sprintf("%s response object is nil", tt.name))
-			assert.Nil(err, fmt.Sprintf("%s returned an error: %v", tt.name, err))
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, fmt.Sprintf("%s returned the wrong status code", tt.name))
-			}
-		})
-	}
-}
--- a/integration/policy_test.go
+++ b/integration/policy_test.go
@@ -1,862 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package integration
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/go-openapi/swag"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func AddPolicy(name, definition string) (*http.Response, error) {
-	/*
-		This is an atomic function to add user and can be reused across
-		different functions.
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-
-	requestDataAdd := map[string]interface{}{
-		"name":   name,
-		"policy": definition,
-	}
-
-	requestDataJSON, _ := json.Marshal(requestDataAdd)
-	requestDataBody := bytes.NewReader(requestDataJSON)
-	request, err := http.NewRequest(
-		"POST", "http://localhost:9090/api/v1/policies", requestDataBody)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-
-	response, err := client.Do(request)
-	return response, err
-}
-
-func SetPolicy(policies []string, entityName, entityType string) (*http.Response, error) {
-	/*
-		This is an atomic function to add user and can be reused across
-		different functions.
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-
-	requestDataAdd := map[string]interface{}{
-		"name":       policies,
-		"entityType": entityType,
-		"entityName": entityName,
-	}
-
-	requestDataJSON, _ := json.Marshal(requestDataAdd)
-	requestDataBody := bytes.NewReader(requestDataJSON)
-	request, err := http.NewRequest(
-		"PUT", "http://localhost:9090/api/v1/set-policy", requestDataBody)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-
-	response, err := client.Do(request)
-	return response, err
-}
-
-func Test_AddPolicyAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	type args struct {
-		api    string
-		name   string
-		policy *string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Create Policy - Valid",
-			args: args{
-				api:  "/policies",
-				name: "test",
-				policy: swag.String(`
-  {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetBucketLocation",
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::*"
-      ]
-    }
-  ]
-}`),
-			},
-			expectedStatus: 201,
-			expectedError:  nil,
-		},
-
-		{
-			name: "Create Policy - Invalid",
-			args: args{
-				api:  "/policies",
-				name: "test2",
-				policy: swag.String(`
-  {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetBucketLocation"
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::*"
-      ]
-    }
-  ]
-}`),
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-		{
-			name: "Create Policy - Space in Name",
-			args: args{
-				api:  "/policies",
-				name: "space test",
-				policy: swag.String(`
-  {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetBucketLocation",
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::*"
-      ]
-    }
-  ]
-}`),
-			},
-			expectedStatus: 400,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			requestDataPolicy := map[string]interface{}{}
-			requestDataPolicy["name"] = tt.args.name
-			if tt.args.policy != nil {
-				requestDataPolicy["policy"] = *tt.args.policy
-			}
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				"POST", fmt.Sprintf("http://localhost:9090/api/v1%s", tt.args.api), requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-			}
-		})
-	}
-}
-
-func Test_SetPolicyAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddUser("policyuser1", "testtest", []string{}, []string{"readwrite"})
-	AddGroup("testgroup123", []string{})
-	AddPolicy("setpolicytest", `
-  {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetBucketLocation",
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::*"
-      ]
-    }
-  ]
-  }`)
-
-	type args struct {
-		api        string
-		entityType string
-		entityName string
-		policyName []string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Set Policy - Valid",
-			args: args{
-				api:        "/set-policy",
-				policyName: []string{"setpolicytest"},
-				entityType: "user",
-				entityName: "policyuser1",
-			},
-			expectedStatus: 204,
-			expectedError:  nil,
-		},
-		{
-			name: "Set Policy - Invalid",
-			args: args{
-				api:        "/set-policy",
-				policyName: []string{"test3"},
-				entityType: "user",
-				entityName: "policyuser1",
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-		{
-			name: "Set Policy Group - Valid",
-			args: args{
-				api:        "/set-policy",
-				policyName: []string{"setpolicytest"},
-				entityType: "group",
-				entityName: "testgroup123",
-			},
-			expectedStatus: 204,
-			expectedError:  nil,
-		},
-		{
-			name: "Set Policy Group - Invalid",
-			args: args{
-				api:        "/set-policy",
-				policyName: []string{"test3"},
-				entityType: "group",
-				entityName: "testgroup123",
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			requestDataPolicy := map[string]interface{}{}
-			requestDataPolicy["entityName"] = tt.args.entityName
-			requestDataPolicy["entityType"] = tt.args.entityType
-			if tt.args.policyName != nil {
-				requestDataPolicy["name"] = tt.args.policyName
-			}
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				"PUT", fmt.Sprintf("http://localhost:9090/api/v1%s", tt.args.api), requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-			}
-		})
-	}
-}
-
-func Test_SetPolicyMultipleAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddUser("policyuser2", "testtest", []string{}, []string{"readwrite"})
-	AddUser("policyuser3", "testtest", []string{}, []string{"readwrite"})
-	AddGroup("testgroup1234", []string{})
-	AddPolicy("setpolicytest2", `
-  {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetBucketLocation",
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::*"
-      ]
-    }
-  ]
-  }`)
-
-	type args struct {
-		api    string
-		users  []string
-		groups []string
-		name   []string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Set Policy - Valid",
-			args: args{
-				api:   "/set-policy-multi",
-				name:  []string{"setpolicytest2"},
-				users: []string{"policyuser2", "policyuser3"},
-			},
-			expectedStatus: 204,
-			expectedError:  nil,
-		},
-		{
-			name: "Set Policy - Invalid",
-			args: args{
-				api:   "/set-policy-multi",
-				name:  []string{"test3"},
-				users: []string{"policyuser2", "policyuser3"},
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-		{
-			name: "Set Policy Group - Valid",
-			args: args{
-				api:    "/set-policy-multi",
-				name:   []string{"setpolicytest2"},
-				groups: []string{"testgroup1234"},
-			},
-			expectedStatus: 204,
-			expectedError:  nil,
-		},
-		{
-			name: "Set Policy Group - Valid",
-			args: args{
-				api:    "/set-policy-multi",
-				name:   []string{"setpolicytest23"},
-				groups: []string{"testgroup1234"},
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			requestDataPolicy := map[string]interface{}{}
-			requestDataPolicy["name"] = tt.args.name
-			requestDataPolicy["users"] = tt.args.users
-			requestDataPolicy["groups"] = tt.args.groups
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				"PUT", fmt.Sprintf("http://localhost:9090/api/v1%s", tt.args.api), requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-			}
-		})
-	}
-}
-
-func Test_ListPoliciesAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	type args struct {
-		api string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "List Policies",
-			args: args{
-				api: "/policies",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			request, err := http.NewRequest(
-				"GET", fmt.Sprintf("http://localhost:9090/api/v1%s", tt.args.api), nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-			}
-		})
-	}
-}
-
-func Test_GetPolicyAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddPolicy("getpolicytest", `
-  {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetBucketLocation",
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::*"
-      ]
-    }
-  ]
-  }`)
-
-	type args struct {
-		api string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Get Policies - Invalid",
-			args: args{
-				api: base64.StdEncoding.EncodeToString([]byte("test3")),
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-		{
-			name: "Get Policies - Valid",
-			args: args{
-				api: base64.StdEncoding.EncodeToString([]byte("getpolicytest")),
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			request, err := http.NewRequest(
-				"GET", fmt.Sprintf("http://localhost:9090/api/v1/policy/%s", tt.args.api), nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-			}
-		})
-	}
-}
-
-func Test_PolicyListUsersAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddUser("policyuser4", "testtest", []string{}, []string{"readwrite"})
-	AddPolicy("policylistusers", `
-  {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetBucketLocation",
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::*"
-      ]
-    }
-  ]
-  }`)
-	SetPolicy([]string{"policylistusers"}, "policyuser4", "user")
-
-	type args struct {
-		api string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "List Users for Policy - Valid",
-			args: args{
-				api: "/policies/" + base64.StdEncoding.EncodeToString([]byte("policylistusers")) + "/users",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "List Users for Policy - Invalid",
-			args: args{
-				api: "/policies/" + base64.StdEncoding.EncodeToString([]byte("test2")) + "/users",
-			},
-			expectedStatus: 404,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			request, err := http.NewRequest(
-				"GET", fmt.Sprintf("http://localhost:9090/api/v1%s", tt.args.api), nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				bodyBytes, _ := ioutil.ReadAll(response.Body)
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-				if response.StatusCode == 200 {
-					assert.Equal("[\"policyuser4\"]\n", string(bodyBytes))
-				}
-			}
-		})
-	}
-}
-
-func Test_PolicyListGroupsAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddGroup("testgroup12345", []string{})
-	AddPolicy("policylistgroups", `
-  {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetBucketLocation",
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::*"
-      ]
-    }
-  ]
-  }`)
-	SetPolicy([]string{"policylistgroups"}, "testgroup12345", "group")
-
-	type args struct {
-		api string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "List Users for Policy - Valid",
-			args: args{
-				api: "/policies/" + base64.StdEncoding.EncodeToString([]byte("policylistgroups")) + "/groups",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "List Users for Policy - Invalid",
-			args: args{
-				api: "/policies/" + base64.StdEncoding.EncodeToString([]byte("test3")) + "/groups",
-			},
-			expectedStatus: 404,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			request, err := http.NewRequest(
-				"GET", fmt.Sprintf("http://localhost:9090/api/v1%s", tt.args.api), nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				bodyBytes, _ := ioutil.ReadAll(response.Body)
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-				if response.StatusCode == 200 {
-					assert.Equal("[\"testgroup12345\"]\n", string(bodyBytes))
-				}
-			}
-		})
-	}
-}
-
-func Test_DeletePolicyAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	AddPolicy("testdelete", `
-  {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetBucketLocation",
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::*"
-      ]
-    }
-  ]
-  }`)
-	type args struct {
-		api    string
-		method string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Delete Policies - Valid",
-			args: args{
-				api:    base64.StdEncoding.EncodeToString([]byte("testdelete")),
-				method: "DELETE",
-			},
-			expectedStatus: 204,
-			expectedError:  nil,
-		},
-		{
-			name: "Get Policy After Delete - Invalid",
-			args: args{
-				api:    base64.StdEncoding.EncodeToString([]byte("testdelete")),
-				method: "GET",
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			request, err := http.NewRequest(
-				tt.args.method, fmt.Sprintf("http://localhost:9090/api/v1/policy/%s", tt.args.api), nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-			}
-		})
-	}
-}
-
-func Test_GetAUserPolicyAPI(t *testing.T) {
-	assert := assert.New(t)
-	// Create a User with a Policy to use for testing
-	groups := []string{}
-	policies := []string{"readwrite"}
-	_, err := AddUser("getuserpolicyuser", "secretKey", groups, policies)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	// encode usernames to pass to api
-	bName := []byte("getuserpolicyuser")
-	fName := []byte("failname")
-	encodedName := base64.URLEncoding.EncodeToString(bName)
-	encodedFailName := base64.URLEncoding.EncodeToString(fName)
-
-	type args struct {
-		api string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Get User Policy - Invalid",
-			args: args{
-				api: "/user/" + encodedFailName + "/policies",
-			},
-			expectedStatus: 401,
-			expectedError:  nil,
-		},
-		{
-			name: "Get User Policy - Valid",
-			args: args{
-				api: "/user/" + encodedName + "/policies",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-			request, err := http.NewRequest(
-				"GET", fmt.Sprintf("http://localhost:9090/api/v1%s", tt.args.api), nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-			}
-		})
-	}
-}
--- a/integration/profiling_test.go
+++ b/integration/profiling_test.go
@@ -1,93 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package integration
-
-import (
-	"archive/zip"
-	"bytes"
-	"fmt"
-	"log"
-	"net/http"
-	"testing"
-
-	"github.com/gorilla/websocket"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestStartProfiling(t *testing.T) {
-	testAssert := assert.New(t)
-
-	tests := []struct {
-		name string
-	}{
-		{
-			name: "start/stop profiling",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			files := map[string]bool{
-				"profile-127.0.0.1:9000-goroutines.txt":                false,
-				"profile-127.0.0.1:9000-goroutines-before.txt":         false,
-				"profile-127.0.0.1:9000-goroutines-before,debug=2.txt": false,
-				"profile-127.0.0.1:9000-threads-before.pprof":          false,
-				"profile-127.0.0.1:9000-mem.pprof":                     false,
-				"profile-127.0.0.1:9000-threads.pprof":                 false,
-				"profile-127.0.0.1:9000-cpu.pprof":                     false,
-				"profile-127.0.0.1:9000-mem-before.pprof":              false,
-				"profile-127.0.0.1:9000-block.pprof":                   false,
-				"profile-127.0.0.1:9000-trace.trace":                   false,
-				"profile-127.0.0.1:9000-mutex.pprof":                   false,
-				"profile-127.0.0.1:9000-mutex-before.pprof":            false,
-			}
-
-			wsDestination := "/ws/profile?types=cpu,mem,block,mutex,trace,threads,goroutines"
-			wsFinalURL := fmt.Sprintf("ws://localhost:9090%s", wsDestination)
-
-			ws, _, err := websocket.DefaultDialer.Dial(wsFinalURL, nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			defer ws.Close()
-
-			_, zipFileBytes, err := ws.ReadMessage()
-			if err != nil {
-				log.Println(err)
-				return
-			}
-
-			filetype := http.DetectContentType(zipFileBytes)
-			testAssert.Equal("application/zip", filetype)
-
-			zipReader, err := zip.NewReader(bytes.NewReader(zipFileBytes), int64(len(zipFileBytes)))
-			if err != nil {
-				testAssert.Nil(err, fmt.Sprintf("%s returned an error: %v", tt.name, err))
-			}
-
-			// Read all the files from zip archive
-			for _, zipFile := range zipReader.File {
-				files[zipFile.Name] = true
-			}
-
-			for k, v := range files {
-				testAssert.Equal(true, v, fmt.Sprintf("%s : compressed file expected to have %v file inside", tt.name, k))
-			}
-		})
-	}
-}
--- a/integration/service_account_test.go
+++ b/integration/service_account_test.go
@@ -1,406 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package integration
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/go-openapi/swag"
-
-	iampolicy "github.com/minio/pkg/iam/policy"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestAddServiceAccount(t *testing.T) {
-	/*
-		This is an atomic API Test to add a user service account, the intention
-		is simple, add a user and make sure the response is 201 meaning that the
-		user got added successfully.
-		After test completion, it is expected that user is removed, so other
-		tests like users.ts can run over clean data and we don't collide against
-		it.
-	*/
-
-	assert := assert.New(t)
-
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-
-	// Add service account
-	requestDataAddServiceAccount := map[string]interface{}{
-		"accessKey": "testuser1",
-		"secretKey": "password",
-	}
-
-	requestDataJSON, _ := json.Marshal(requestDataAddServiceAccount)
-	requestDataBody := bytes.NewReader(requestDataJSON)
-	request, err := http.NewRequest(
-		"POST", "http://localhost:9090/api/v1/service-account-credentials", requestDataBody)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-
-	response, err := client.Do(request)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	if response != nil {
-		fmt.Println("POST StatusCode:", response.StatusCode)
-		assert.Equal(201, response.StatusCode, "Status Code is incorrect")
-	}
-
-	requestDataPolicy := map[string]interface{}{
-		"policy": `
-  {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetBucketLocation",
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::*"
-      ]
-    }
-  ]
-}`,
-	}
-	requestDataJSON, _ = json.Marshal(requestDataPolicy)
-	requestDataBody = bytes.NewReader(requestDataJSON)
-	request, err = http.NewRequest(
-		"PUT", "http://localhost:9090/api/v1/service-accounts/"+base64.StdEncoding.EncodeToString([]byte("testuser1"))+"/policy", requestDataBody)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err = client.Do(request)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	if response != nil {
-		fmt.Println("POST StatusCode:", response.StatusCode)
-		assert.Equal(200, response.StatusCode, "Status Code is incorrect")
-	}
-
-	// Test policy
-	request, err = http.NewRequest(
-		"GET", "http://localhost:9090/api/v1/service-accounts/"+base64.StdEncoding.EncodeToString([]byte("testuser1"))+"/policy", nil)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err = client.Do(request)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	if response != nil {
-		fmt.Println("POST StatusCode:", response.StatusCode)
-		assert.Equal(200, response.StatusCode, "Status Code is incorrect")
-		buf := new(bytes.Buffer)
-		buf.ReadFrom(response.Body)
-		var actual *iampolicy.Policy
-		var expected *iampolicy.Policy
-		json.Unmarshal(buf.Bytes(), actual)
-		policy, err := json.Marshal(requestDataAddServiceAccount["policy"])
-		if err != nil {
-			log.Println(err)
-			return
-		}
-		json.Unmarshal(policy, expected)
-		assert.Equal(expected, actual)
-	}
-
-	// {{baseUrl}}/user?name=proident velit
-	// Investiga como se borra en el browser.
-	request, err = http.NewRequest(
-		"DELETE", "http://localhost:9090/api/v1/service-accounts/"+base64.StdEncoding.EncodeToString([]byte("testuser1")), nil)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err = client.Do(request)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	if response != nil {
-		fmt.Println("DELETE StatusCode:", response.StatusCode)
-		assert.Equal(204, response.StatusCode, "has to be 204 when delete user")
-	}
-}
-
-func Test_ServiceAccountsAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	type args struct {
-		api    string
-		policy *string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Create Service Account - Default",
-			args: args{
-				api:    "/service-accounts",
-				policy: nil,
-			},
-			expectedStatus: 201,
-			expectedError:  nil,
-		},
-		{
-			name: "Create Service Account - Valid Policy",
-			args: args{
-				api: "/service-accounts",
-				policy: swag.String(`
-  {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetBucketLocation",
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::*"
-      ]
-    }
-  ]
-}`),
-			},
-			expectedStatus: 201,
-			expectedError:  nil,
-		},
-		{
-			name: "Create Service Account - Invalid Policy",
-			args: args{
-				api: "/service-accounts",
-				policy: swag.String(`
-  {
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetBucketLocation"
-        "s3:GetObject"
-      ],
-      "Resource": [
-        "arn:aws:s3:::*"
-      ]
-    }
-  ]
-}`),
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			// Add service account
-
-			requestDataPolicy := map[string]interface{}{}
-			if tt.args.policy != nil {
-				requestDataPolicy["policy"] = *tt.args.policy
-			}
-
-			requestDataJSON, _ := json.Marshal(requestDataPolicy)
-			requestDataBody := bytes.NewReader(requestDataJSON)
-			request, err := http.NewRequest(
-				"POST", fmt.Sprintf("http://localhost:9090/api/v1%s", tt.args.api), requestDataBody)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, "Status Code is incorrect")
-			}
-		})
-	}
-}
-
-func DeleteMultipleServiceAccounts(serviceAccounts []string) (*http.Response, error) {
-	/*
-		Helper function to delete multiple service accounts
-		URL: http://localhost:9001/api/v1/service-accounts/delete-multi
-		HTTP Verb: DELETE
-		Data: ["U3RADB7J2ZZHELR0WSBB","ZE8H1HYOA6AVGKFCV6YU"]
-		Response: Status Code: 204 No Content
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-	requestDataJSON, _ := json.Marshal(serviceAccounts)
-	requestDataBody := bytes.NewReader(requestDataJSON)
-	request, err := http.NewRequest(
-		"DELETE", "http://localhost:9090/api/v1/service-accounts/delete-multi", requestDataBody)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err := client.Do(request)
-	return response, err
-}
-
-func TestCreateServiceAccountForUserWithCredentials(t *testing.T) {
-	/*
-		To test creation of service account for a user.
-	*/
-
-	// Test's variables
-	userName := "testcreateserviceaccountforuserwithcredentials1"
-	assert := assert.New(t)
-	policy := ""
-	serviceAccountLengthInBytes := 40 // As observed, update as needed
-
-	// 1. Create the user
-	groups := []string{}
-	policies := []string{}
-	secretKey := "testcreateserviceaccountforuserwithcrede"
-	response, err := AddUser(userName, "secretKey", groups, policies)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	if response != nil {
-		fmt.Println("StatusCode:", response.StatusCode)
-		assert.Equal(201, response.StatusCode, "Status Code is incorrect")
-	}
-
-	// Table driven testing part
-	type args struct {
-		accessKey string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-	}{
-		{
-			name:           "Service Account With Valid Credentials",
-			expectedStatus: 201,
-			args: args{
-				accessKey: "testcreateserviceacc",
-			},
-		},
-		{
-			name:           "Service Account With Invalid Credentials",
-			expectedStatus: 500,
-			args: args{
-				accessKey: "tooooooooooooooooooooolongggggggggggggggggg",
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// 2. Create the service account for the user
-			createServiceAccountWithCredentialsResponse,
-				createServiceAccountWithCredentialsError := CreateServiceAccountForUserWithCredentials(
-				userName,
-				policy,
-				tt.args.accessKey,
-				secretKey,
-			)
-			if createServiceAccountWithCredentialsError != nil {
-				log.Println(createServiceAccountWithCredentialsError)
-				assert.Fail("Error in createServiceAccountWithCredentialsError")
-			}
-			if createServiceAccountWithCredentialsResponse != nil {
-				fmt.Println("StatusCode:", createServiceAccountWithCredentialsResponse.StatusCode)
-				assert.Equal(
-					tt.expectedStatus, // different status expected per table's row
-					createServiceAccountWithCredentialsResponse.StatusCode,
-					inspectHTTPResponse(createServiceAccountWithCredentialsResponse),
-				)
-			}
-
-			// 3. Verify the service account for the user
-			listOfAccountsResponse,
-				listOfAccountsError := ReturnsAListOfServiceAccountsForAUser(userName)
-			if listOfAccountsError != nil {
-				log.Println(listOfAccountsError)
-				assert.Fail("Error in listOfAccountsError")
-			}
-			finalResponse := inspectHTTPResponse(listOfAccountsResponse)
-			if listOfAccountsResponse != nil {
-				fmt.Println("StatusCode:", listOfAccountsResponse.StatusCode)
-				assert.Equal(
-					200, listOfAccountsResponse.StatusCode,
-					finalResponse,
-				)
-			}
-			assert.Equal(len(finalResponse), serviceAccountLengthInBytes, finalResponse)
-		})
-	}
-
-	// Delete Multiple Service Accounts
-	serviceAccount := make([]string, 1)
-	serviceAccount[0] = "testcreateserviceacc"
-	response, err = DeleteMultipleServiceAccounts(serviceAccount)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	if response != nil {
-		fmt.Println("StatusCode:", response.StatusCode)
-		assert.Equal(
-			204,
-			response.StatusCode,
-			inspectHTTPResponse(response),
-		)
-	}
-}
--- a/integration/tiers_test.go
+++ b/integration/tiers_test.go
@@ -1,53 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package integration
-
-import (
-	"fmt"
-	"log"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestTiersList(t *testing.T) {
-	assert := assert.New(t)
-
-	// image for now:
-	// minio: 9000
-	// console: 9090
-
-	client := &http.Client{
-		Timeout: 2 * time.Second,
-	}
-
-	request, err := http.NewRequest("GET", "http://localhost:9090/api/v1/admin/tiers", nil)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-
-	response, err := client.Do(request)
-
-	assert.NotNil(response, "Tiers List response is nil")
-	assert.Nil(err, "Tiers List errored out")
-	assert.Equal(response.StatusCode, 200)
-}
--- a/integration/user_api_bucket_test.go
+++ b/integration/user_api_bucket_test.go
--- a/integration/users_test.go
+++ b/integration/users_test.go
@@ -1,922 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package integration
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"strconv"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func AddUser(accessKey, secretKey string, groups, policies []string) (*http.Response, error) {
-	/*
-		This is an atomic function to add user and can be reused across
-		different functions.
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-
-	requestDataAdd := map[string]interface{}{
-		"accessKey": accessKey,
-		"secretKey": secretKey,
-		"groups":    groups,
-		"policies":  policies,
-	}
-
-	requestDataJSON, _ := json.Marshal(requestDataAdd)
-	requestDataBody := bytes.NewReader(requestDataJSON)
-	request, err := http.NewRequest(
-		"POST", "http://localhost:9090/api/v1/users", requestDataBody)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-
-	response, err := client.Do(request)
-	return response, err
-}
-
-func DeleteUser(userName string) (*http.Response, error) {
-	userName = base64.StdEncoding.EncodeToString([]byte(userName))
-	/*
-		This is an atomic function to delete user and can be reused across
-		different functions.
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-	request, err := http.NewRequest(
-		"DELETE", "http://localhost:9090/api/v1/user/"+userName, nil)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err := client.Do(request)
-	return response, err
-}
-
-func ListUsers(offset, limit string) (*http.Response, error) {
-	/*
-		This is an atomic function to list users.
-		{{baseUrl}}/users?offset=-5480083&limit=-5480083
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-	request, err := http.NewRequest(
-		"GET",
-		"http://localhost:9090/api/v1/users?offset="+offset+"&limit="+limit,
-		nil)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err := client.Do(request)
-	return response, err
-}
-
-func GetUserInformation(userName string) (*http.Response, error) {
-	userName = base64.StdEncoding.EncodeToString([]byte(userName))
-	/*
-		Helper function to get user information via API:
-		{{baseUrl}}/user?name=proident velit
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-	request, err := http.NewRequest(
-		"GET",
-		"http://localhost:9090/api/v1/user/"+userName,
-		nil)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err := client.Do(request)
-	return response, err
-}
-
-func UpdateUserInformation(name, status string, groups []string) (*http.Response, error) {
-	name = base64.StdEncoding.EncodeToString([]byte(name))
-	/*
-		Helper function to update user information:
-		PUT: {{baseUrl}}/user?name=proident velit
-		Body:
-		{
-			"status": "nisi voluptate amet ea",
-			"groups": [
-				"ipsum eu cupidatat",
-				"aliquip non nulla"
-			]
-		}
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-	requestDataAdd := map[string]interface{}{
-		"status": status,
-		"groups": groups,
-	}
-	requestDataJSON, _ := json.Marshal(requestDataAdd)
-	requestDataBody := bytes.NewReader(requestDataJSON)
-	request, err := http.NewRequest(
-		"PUT", "http://localhost:9090/api/v1/user/"+name, requestDataBody)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err := client.Do(request)
-	return response, err
-}
-
-func RemoveUser(name string) (*http.Response, error) {
-	name = base64.StdEncoding.EncodeToString([]byte(name))
-	/*
-		Helper function to remove user.
-		DELETE: {{baseUrl}}/user?name=proident velit
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-	request, err := http.NewRequest(
-		"DELETE", "http://localhost:9090/api/v1/user/"+name, nil)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err := client.Do(request)
-	return response, err
-}
-
-func UpdateGroupsForAUser(userName string, groups []string) (*http.Response, error) {
-	userName = base64.StdEncoding.EncodeToString([]byte(userName))
-	/*
-		Helper function to update groups for a user
-		PUT: {{baseUrl}}/user/groups?name=username
-		{
-			"groups":[
-				"groupone",
-				"grouptwo"
-			]
-		}
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-	requestDataAdd := map[string]interface{}{
-		"groups": groups,
-	}
-	requestDataJSON, _ := json.Marshal(requestDataAdd)
-	requestDataBody := bytes.NewReader(requestDataJSON)
-	request, err := http.NewRequest(
-		"PUT",
-		"http://localhost:9090/api/v1/user/"+userName+"/groups",
-		requestDataBody,
-	)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err := client.Do(request)
-	return response, err
-}
-
-func CreateServiceAccountForUser(userName, policy string) (*http.Response, error) {
-	userName = base64.StdEncoding.EncodeToString([]byte(userName))
-	/*
-		Helper function to Create Service Account for user
-		POST: api/v1/user/username/service-accounts
-		{
-			"policy": "ad magna"
-		}
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-	requestDataAdd := map[string]interface{}{
-		"policy": policy,
-	}
-	requestDataJSON, _ := json.Marshal(requestDataAdd)
-	requestDataBody := bytes.NewReader(requestDataJSON)
-	request, err := http.NewRequest(
-		"POST",
-		"http://localhost:9090/api/v1/user/"+userName+"/service-accounts",
-		requestDataBody,
-	)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err := client.Do(request)
-	return response, err
-}
-
-func CreateServiceAccountForUserWithCredentials(userName, policy, accessKey, secretKey string) (*http.Response, error) {
-	userName = base64.StdEncoding.EncodeToString([]byte(userName))
-	// Helper function to test "Create Service Account for User With Credentials" end point.
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-	requestDataAdd := map[string]interface{}{
-		"policy":    policy,
-		"accessKey": accessKey,
-		"secretKey": secretKey,
-	}
-	requestDataJSON, _ := json.Marshal(requestDataAdd)
-	requestDataBody := bytes.NewReader(requestDataJSON)
-	request, err := http.NewRequest(
-		"POST",
-		"http://localhost:9090/api/v1/user/"+userName+"/service-account-credentials",
-		requestDataBody,
-	)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err := client.Do(request)
-	return response, err
-}
-
-func ReturnsAListOfServiceAccountsForAUser(userName string) (*http.Response, error) {
-	userName = base64.StdEncoding.EncodeToString([]byte(userName))
-	/*
-		Helper function to return a list of service accounts for a user.
-		GET: {{baseUrl}}/user/:name/service-accounts
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-	request, err := http.NewRequest(
-		"GET",
-		"http://localhost:9090/api/v1/user/"+userName+"/service-accounts",
-		nil,
-	)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err := client.Do(request)
-	return response, err
-}
-
-func AddGroup(group string, members []string) (*http.Response, error) {
-	/*
-		Helper function to add a group.
-	*/
-	client := &http.Client{
-		Timeout: 3 * time.Second,
-	}
-	requestDataAdd := map[string]interface{}{
-		"group":   group,
-		"members": members,
-	}
-	requestDataJSON, _ := json.Marshal(requestDataAdd)
-	requestDataBody := bytes.NewReader(requestDataJSON)
-	request, err := http.NewRequest(
-		"POST",
-		"http://localhost:9090/api/v1/groups",
-		requestDataBody,
-	)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	response, err := client.Do(request)
-	return response, err
-}
-
-func UsersGroupsBulk(users, groups []string) (*http.Response, error) {
-	/*
-		Helper function to test Bulk functionality to Add Users to Groups.
-		PUT: {{baseUrl}}/users-groups-bulk
-		{
-			"users": [
-				"magna id",
-				"enim sit tempor incididunt"
-			],
-			"groups": [
-				"nisi est esse",
-				"fugiat eu"
-			]
-		}
-	*/
-	requestDataAdd := map[string]interface{}{
-		"users":  users,
-		"groups": groups,
-	}
-	requestDataJSON, _ := json.Marshal(requestDataAdd)
-	requestDataBody := bytes.NewReader(requestDataJSON)
-	request, err := http.NewRequest(
-		"PUT",
-		"http://localhost:9090/api/v1/users-groups-bulk",
-		requestDataBody,
-	)
-	if err != nil {
-		log.Println(err)
-	}
-	request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-	request.Header.Add("Content-Type", "application/json")
-	client := &http.Client{
-		Timeout: 2 * time.Second,
-	}
-	response, err := client.Do(request)
-	return response, err
-}
-
-func TestAddUser(t *testing.T) {
-	/*
-		This is an API Test to add a user via api/v1/users, the intention
-		is simple, add a user and make sure the response is 201 meaning that the
-		user got added successfully.
-		After test completion, it is expected that user is removed, so other
-		tests like users.ts can run over clean data and we don't collide against
-		it.
-	*/
-
-	assert := assert.New(t)
-
-	// With no groups & no policies
-	groups := []string{}
-	policies := []string{}
-	response, err := AddUser("accessKey", "secretKey", groups, policies)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	if response != nil {
-		fmt.Println("POST StatusCode:", response.StatusCode)
-		assert.Equal(201, response.StatusCode, "Status Code is incorrect")
-	}
-
-	response, err = DeleteUser("accessKey")
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	if response != nil {
-		fmt.Println("DELETE StatusCode:", response.StatusCode)
-		assert.Equal(204, response.StatusCode, "has to be 204 when delete user")
-	}
-}
-
-func TestListUsers(t *testing.T) {
-	/*
-		This test is intended to list users via API.
-		1. First, it creates the users
-		2. Then, it lists the users <------ 200 is expected when listing them.
-		3. Finally, it deletes the users
-	*/
-
-	assert := assert.New(t)
-
-	// With no groups & no policies
-	groups := []string{}
-	policies := []string{}
-
-	// 1. Create the users
-	numberOfUsers := 5
-	for i := 1; i < numberOfUsers; i++ {
-		response, err := AddUser(
-			strconv.Itoa(i)+"accessKey"+strconv.Itoa(i),
-			"secretKey"+strconv.Itoa(i), groups, policies)
-		if err != nil {
-			log.Println(err)
-			return
-		}
-		if response != nil {
-			fmt.Println("POST StatusCode:", response.StatusCode)
-			assert.Equal(201, response.StatusCode,
-				"Status Code is incorrect on index: "+strconv.Itoa(i))
-		}
-
-		b, err := io.ReadAll(response.Body)
-		if err != nil {
-			log.Fatalln(err)
-		}
-		fmt.Println(string(b))
-	}
-
-	// 2. List the users
-	listResponse, listError := ListUsers("-5480083", "-5480083")
-	if listError != nil {
-		log.Fatalln(listError)
-	}
-	if listResponse != nil {
-		fmt.Println("POST StatusCode:", listResponse.StatusCode)
-		assert.Equal(200, listResponse.StatusCode,
-			"TestListUsers(): Status Code is incorrect when listing users")
-	}
-	b, err := io.ReadAll(listResponse.Body)
-	if err != nil {
-		log.Fatalln(err)
-	}
-	fmt.Println(string(b))
-
-	// 3. Delete the users
-	for i := 1; i < numberOfUsers; i++ {
-		response, err := DeleteUser(
-			strconv.Itoa(i) + "accessKey" + strconv.Itoa(i))
-		if err != nil {
-			log.Println(err)
-			return
-		}
-		if response != nil {
-			fmt.Println("DELETE StatusCode:", response.StatusCode)
-			assert.Equal(204,
-				response.StatusCode, "has to be 204 when delete user")
-		}
-	}
-}
-
-func TestGetUserInfo(t *testing.T) {
-	/*
-		Test to get the user information via API.
-	*/
-
-	// 1. Create the user
-	fmt.Println("TestGetUserInfo(): 1. Create the user")
-	assert := assert.New(t)
-	groups := []string{}
-	policies := []string{}
-	response, err := AddUser("accessKey", "secretKey", groups, policies)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	if response != nil {
-		fmt.Println("POST StatusCode:", response.StatusCode)
-		assert.Equal(201, response.StatusCode, "Status Code is incorrect")
-	}
-
-	// 2. Get user information
-	fmt.Println("TestGetUserInfo(): 2. Get user information")
-	response, err = GetUserInformation("accessKey")
-	if err != nil {
-		log.Println(err)
-		assert.Fail("There was an error in the response")
-		return
-	}
-
-	// 3. Verify user information
-	fmt.Println("TestGetUserInfo(): 3. Verify user information")
-	if response != nil {
-		fmt.Println("POST StatusCode:", response.StatusCode)
-		assert.Equal(200, response.StatusCode, "Status Code is incorrect")
-	}
-	b, err := io.ReadAll(response.Body)
-	if err != nil {
-		log.Fatalln(err)
-	}
-	fmt.Println(string(b))
-	expected := "{\"accessKey\":\"accessKey\",\"memberOf\":null,\"policy\":[],\"status\":\"enabled\"}\n"
-	obtained := string(b)
-	assert.Equal(expected, obtained, "User Information is wrong")
-}
-
-func TestUpdateUserInfoSuccessfulResponse(t *testing.T) {
-	/*
-		Update User Information Test with Successful Response
-	*/
-
-	assert := assert.New(t)
-
-	// 1. Create an active user
-	groups := []string{}
-	policies := []string{}
-	addUserResponse, addUserError := AddUser(
-		"updateuser", "secretKey", groups, policies)
-	if addUserError != nil {
-		log.Println(addUserError)
-		return
-	}
-	if addUserResponse != nil {
-		fmt.Println("StatusCode:", addUserResponse.StatusCode)
-		assert.Equal(
-			201, addUserResponse.StatusCode, "Status Code is incorrect")
-	}
-
-	// 2. Deactivate the user
-	// '{"status":"disabled","groups":[]}'
-	updateUserResponse, UpdateUserError := UpdateUserInformation(
-		"updateuser", "disabled", groups)
-
-	// 3. Verify user got deactivated
-	if UpdateUserError != nil {
-		log.Println(UpdateUserError)
-		return
-	}
-	if updateUserResponse != nil {
-		fmt.Println("StatusCode:", updateUserResponse.StatusCode)
-		assert.Equal(
-			200, updateUserResponse.StatusCode, "Status Code is incorrect")
-	}
-	b, err := io.ReadAll(updateUserResponse.Body)
-	if err != nil {
-		log.Fatalln(err)
-	}
-	assert.True(strings.Contains(string(b), "disabled"))
-}
-
-func TestUpdateUserInfoGenericErrorResponse(t *testing.T) {
-	/*
-		Update User Information Test with Generic Error Response
-	*/
-
-	assert := assert.New(t)
-
-	// 1. Create an active user
-	groups := []string{}
-	policies := []string{}
-	addUserResponse, addUserError := AddUser(
-		"updateusererror", "secretKey", groups, policies)
-	if addUserError != nil {
-		log.Println(addUserError)
-		return
-	}
-	if addUserResponse != nil {
-		fmt.Println("StatusCode:", addUserResponse.StatusCode)
-		assert.Equal(
-			201, addUserResponse.StatusCode, "Status Code is incorrect")
-	}
-
-	// 2. Deactivate the user with wrong status
-	updateUserResponse, UpdateUserError := UpdateUserInformation(
-		"updateusererror", "inactive", groups)
-
-	// 3. Verify user got deactivated
-	if UpdateUserError != nil {
-		log.Println(UpdateUserError)
-		assert.Fail("There was an error while updating user info")
-		return
-	}
-	if updateUserResponse != nil {
-		fmt.Println("StatusCode:", updateUserResponse.StatusCode)
-		assert.Equal(
-			500, updateUserResponse.StatusCode, "Status Code is incorrect")
-	}
-	b, err := io.ReadAll(updateUserResponse.Body)
-	if err != nil {
-		log.Fatalln(err)
-	}
-	assert.True(strings.Contains(string(b), "status not valid"))
-}
-
-func TestRemoveUserSuccessfulResponse(t *testing.T) {
-	/*
-		To test removing a user from API
-	*/
-
-	assert := assert.New(t)
-
-	// 1. Create an active user
-	groups := []string{}
-	policies := []string{}
-	addUserResponse, addUserError := AddUser(
-		"testremoveuser1", "secretKey", groups, policies)
-	if addUserError != nil {
-		log.Println(addUserError)
-		return
-	}
-	if addUserResponse != nil {
-		fmt.Println("StatusCode:", addUserResponse.StatusCode)
-		assert.Equal(
-			201, addUserResponse.StatusCode, "Status Code is incorrect")
-	}
-
-	// 2. Remove the user
-	removeUserResponse, removeUserError := RemoveUser("testremoveuser1")
-	if removeUserError != nil {
-		log.Println(removeUserError)
-		return
-	}
-	if removeUserResponse != nil {
-		fmt.Println("StatusCode:", removeUserResponse.StatusCode)
-		assert.Equal(
-			204, removeUserResponse.StatusCode, "Status Code is incorrect")
-	}
-
-	// 3. Verify the user got removed
-	getUserInfoResponse, getUserInfoError := GetUserInformation(
-		"testremoveuser1")
-	if getUserInfoError != nil {
-		log.Println(getUserInfoError)
-		assert.Fail("There was an error in the response")
-		return
-	}
-	if getUserInfoResponse != nil {
-		fmt.Println("StatusCode:", getUserInfoResponse.StatusCode)
-		assert.Equal(
-			404, getUserInfoResponse.StatusCode, "Status Code is incorrect")
-	}
-	finalResponse := inspectHTTPResponse(getUserInfoResponse)
-	fmt.Println(finalResponse)
-	assert.True(strings.Contains(
-		finalResponse, "The specified user does not exist"), finalResponse)
-}
-
-func TestUpdateGroupsForAUser(t *testing.T) {
-	/*
-		To test Update Groups For a User End Point.
-	*/
-
-	// 1. Create the user
-	numberOfGroups := 3
-	groupName := "updategroupforausergroup"
-	userName := "updategroupsforauser1"
-	assert := assert.New(t)
-	groups := []string{}
-	policies := []string{}
-	response, err := AddUser(userName, "secretKey", groups, policies)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	if response != nil {
-		fmt.Println("StatusCode:", response.StatusCode)
-		assert.Equal(201, response.StatusCode, "Status Code is incorrect")
-	}
-
-	// 2. Update the groups of the created user with newGroups
-	newGroups := make([]string, 3)
-	for i := 0; i < numberOfGroups; i++ {
-		newGroups[i] = groupName + strconv.Itoa(i)
-	}
-	response, err = UpdateGroupsForAUser(userName, newGroups)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	if response != nil {
-		fmt.Println("StatusCode:", response.StatusCode)
-		assert.Equal(200, response.StatusCode, "Status Code is incorrect")
-	}
-
-	// 3. Verify the newGroups were updated accordingly
-	getUserInfoResponse, getUserInfoErr := GetUserInformation(userName)
-	if getUserInfoErr != nil {
-		log.Println(getUserInfoErr)
-		assert.Fail("There was an error in the response")
-		return
-	}
-	if getUserInfoResponse != nil {
-		fmt.Println("StatusCode:", getUserInfoResponse.StatusCode)
-		assert.Equal(
-			200, getUserInfoResponse.StatusCode, "Status Code is incorrect")
-	}
-	finalResponse := inspectHTTPResponse(getUserInfoResponse)
-	for i := 0; i < numberOfGroups; i++ {
-		assert.True(strings.Contains(
-			finalResponse, groupName+strconv.Itoa(i)), finalResponse)
-	}
-}
-
-func TestCreateServiceAccountForUser(t *testing.T) {
-	/*
-		To test creation of service account for a user.
-	*/
-
-	// Test's variables
-	userName := "testcreateserviceaccountforuser1"
-	assert := assert.New(t)
-	policy := ""
-	serviceAccountLengthInBytes := 40 // As observed, update as needed
-
-	// 1. Create the user
-	groups := []string{}
-	policies := []string{}
-	response, err := AddUser(userName, "secretKey", groups, policies)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-	if response != nil {
-		fmt.Println("StatusCode:", response.StatusCode)
-		assert.Equal(201, response.StatusCode, "Status Code is incorrect")
-	}
-
-	// 2. Create the service account for the user
-	createServiceAccountResponse,
-		createServiceAccountError := CreateServiceAccountForUser(
-		userName,
-		policy,
-	)
-	if createServiceAccountError != nil {
-		log.Println(createServiceAccountError)
-		assert.Fail("Error in createServiceAccountError")
-	}
-	if createServiceAccountResponse != nil {
-		fmt.Println("StatusCode:", createServiceAccountResponse.StatusCode)
-		assert.Equal(
-			201, createServiceAccountResponse.StatusCode,
-			inspectHTTPResponse(createServiceAccountResponse),
-		)
-	}
-
-	// 3. Verify the service account for the user
-	listOfAccountsResponse, listOfAccountsError := ReturnsAListOfServiceAccountsForAUser(userName)
-
-	fmt.Println(listOfAccountsResponse, listOfAccountsError)
-
-	if listOfAccountsError != nil {
-		log.Println(listOfAccountsError)
-		assert.Fail("Error in listOfAccountsError")
-	}
-	finalResponse := inspectHTTPResponse(listOfAccountsResponse)
-	if listOfAccountsResponse != nil {
-		fmt.Println("StatusCode:", listOfAccountsResponse.StatusCode)
-		assert.Equal(
-			200, listOfAccountsResponse.StatusCode,
-			finalResponse,
-		)
-	}
-
-	assert.Equal(len(finalResponse), serviceAccountLengthInBytes, finalResponse)
-}
-
-func TestUsersGroupsBulk(t *testing.T) {
-	/*
-		To test UsersGroupsBulk End Point
-	*/
-
-	// Vars
-	assert := assert.New(t)
-	numberOfUsers := 5
-	numberOfGroups := 1
-	// var groups = []string{}
-	policies := []string{}
-	username := "testusersgroupbulk"
-	groupName := "testusersgroupsbulkgroupone"
-	members := []string{}
-	users := make([]string, numberOfUsers)
-	groups := make([]string, numberOfGroups)
-
-	// 1. Create some users
-	for i := 0; i < numberOfUsers; i++ {
-		users[i] = username + strconv.Itoa(i)
-		response, err := AddUser(
-			users[i],
-			"secretKey"+strconv.Itoa(i), []string{}, policies)
-		if err != nil {
-			log.Println(err)
-			return
-		}
-		if response != nil {
-			fmt.Println("POST StatusCode:", response.StatusCode)
-			assert.Equal(201, response.StatusCode,
-				"Status Code is incorrect on index: "+strconv.Itoa(i))
-		}
-	}
-
-	// 2. Create a group with no members
-	responseAddGroup, errorAddGroup := AddGroup(groupName, members)
-	if errorAddGroup != nil {
-		log.Println(errorAddGroup)
-		return
-	}
-	finalResponse := inspectHTTPResponse(responseAddGroup)
-	if responseAddGroup != nil {
-		fmt.Println("POST StatusCode:", responseAddGroup.StatusCode)
-		assert.Equal(
-			201,
-			responseAddGroup.StatusCode,
-			finalResponse,
-		)
-	}
-
-	// 3. Add users to the group
-	groups[0] = groupName
-	responseUsersGroupsBulk, errorUsersGroupsBulk := UsersGroupsBulk(
-		users,
-		groups,
-	)
-	if errorUsersGroupsBulk != nil {
-		log.Println(errorUsersGroupsBulk)
-		return
-	}
-	finalResponse = inspectHTTPResponse(responseUsersGroupsBulk)
-	if responseUsersGroupsBulk != nil {
-		fmt.Println("POST StatusCode:", responseUsersGroupsBulk.StatusCode)
-		assert.Equal(
-			200,
-			responseUsersGroupsBulk.StatusCode,
-			finalResponse,
-		)
-	}
-
-	// 4. Verify users got added to the group
-	for i := 0; i < numberOfUsers; i++ {
-		responseGetUserInfo, errGetUserInfo := GetUserInformation(
-			username + strconv.Itoa(i),
-		)
-		if errGetUserInfo != nil {
-			log.Println(errGetUserInfo)
-			assert.Fail("There was an error in the response")
-			return
-		}
-		finalResponse = inspectHTTPResponse(responseGetUserInfo)
-		if responseGetUserInfo != nil {
-			assert.Equal(200, responseGetUserInfo.StatusCode, finalResponse)
-		}
-		// Make sure the user belongs to the created group
-		assert.True(strings.Contains(finalResponse, groupName))
-	}
-}
-
-func Test_GetUserPolicyAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	// 1. Create an active user with valid policy
-	groups := []string{}
-	policies := []string{"readwrite"}
-	addUserResponse, addUserError := AddUser(
-		"getpolicyuser", "secretKey", groups, policies)
-	if addUserError != nil {
-		log.Println(addUserError)
-		return
-	}
-	if addUserResponse != nil {
-		fmt.Println("StatusCode:", addUserResponse.StatusCode)
-		assert.Equal(
-			201, addUserResponse.StatusCode, "Status Code is incorrect")
-	}
-
-	type args struct {
-		api string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Get User Policies",
-			args: args{
-				api: "/user/policy",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			request, err := http.NewRequest(
-				"GET", fmt.Sprintf("http://localhost:9090/api/v1%s", tt.args.api), nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Cookie", fmt.Sprintf("token=%s", token))
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, tt.name+" Failed")
-			}
-		})
-	}
-}
--- a/integration/version_test.go
+++ b/integration/version_test.go
@@ -1,73 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package integration
-
-import (
-	"fmt"
-	"log"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_VersionAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	type args struct {
-		api string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Check Version",
-			args: args{
-				api: "/check-version",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-			request, err := http.NewRequest(
-				"GET", fmt.Sprintf("http://localhost:9090/api/v1%s", tt.args.api), nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			request.Header.Add("Content-Type", "application/json")
-			response, err := client.Do(request)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-			if response != nil {
-				assert.Equal(tt.expectedStatus, response.StatusCode, "Status Code is incorrect")
-			}
-		})
-	}
-}
--- a/k8s/metrics-dev.yaml
+++ b/k8s/metrics-dev.yaml
@@ -149,5 +149,5 @@ spec:
            - name: tmp-dir
              mountPath: /tmp
      nodeSelector:
-        kubernetes.io/os: linux
+        beta.kubernetes.io/os: linux
        kubernetes.io/arch: "amd64"
--- a/k8s/operator-console/base/console-deployment.yaml
+++ b/k8s/operator-console/base/console-deployment.yaml
@@ -15,7 +15,7 @@ spec:
      serviceAccountName: console-sa
      containers:
        - name: console
-          image: 'minio/console:v0.22.2'
+          image: minio/console:v0.9.7
          imagePullPolicy: "IfNotPresent"
          env:
            - name: CONSOLE_OPERATOR_MODE
--- a/k8s/operator-console/operator/kustomization.yaml
+++ b/k8s/operator-console/operator/kustomization.yaml
@@ -0,0 +1,9 @@
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+# beginning of customizations
+#namespace: min-ns
+
+resources:
+  - ../base
+  - https://github.com/minio/operator/?ref=v3.0.29
+
--- a/k8s/operator-console/standalone/console-deployment.yaml
+++ b/k8s/operator-console/standalone/console-deployment.yaml
@@ -1,46 +0,0 @@
---
-apiVersion: v1
-kind: Service
-metadata:
-  name: console
-  namespace: default
-  labels:
-    name: console
-spec:
-  ports:
-    - port: 9090
-      name: http
-    - port: 9443
-      name: https
-  selector:
-    app: console-standalone
---
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: console
-  namespace: default
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: console-standalone
-  template:
-    metadata:
-      labels:
-        app: console-standalone
-    spec:
-      containers:
-        - name: console
-          image: 'minio/console:v0.22.2'
-          imagePullPolicy: "IfNotPresent"
-          env:
-            - name: CONSOLE_MINIO_SERVER
-              value: "https://minio.default.svc.cluster.local"
-          args:
-            - server
-          ports:
-            - containerPort: 9090
-              name: http
-            - containerPort: 9433
-              name: https
--- a/k8s/tools.go
+++ b/k8s/tools.go
@@ -1,4 +1,4 @@
-// This file is part of MinIO Console Server
+// This file is part of MinIO Kubernetes Cloud
 // Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
--- a/models/a_user_policy_response.go
+++ b/models/a_user_policy_response.go
@@ -1,67 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-)
-
-// AUserPolicyResponse a user policy response
-//
-// swagger:model aUserPolicyResponse
-type AUserPolicyResponse struct {
-
-	// policy
-	Policy string `json:"policy,omitempty"`
-}
-
-// Validate validates this a user policy response
-func (m *AUserPolicyResponse) Validate(formats strfmt.Registry) error {
-	return nil
-}
-
-// ContextValidate validates this a user policy response based on context it is used
-func (m *AUserPolicyResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *AUserPolicyResponse) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *AUserPolicyResponse) UnmarshalBinary(b []byte) error {
-	var res AUserPolicyResponse
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/access_rule.go
+++ b/models/access_rule.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/account_change_password_request.go
+++ b/models/account_change_password_request.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/add_bucket_lifecycle.go
+++ b/models/add_bucket_lifecycle.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -24,12 +24,9 @@ package models

 import (
 	"context"
-	"encoding/json"

-	"github.com/go-openapi/errors"
 	"github.com/go-openapi/strfmt"
 	"github.com/go-openapi/swag"
-	"github.com/go-openapi/validate"
 )

 // AddBucketLifecycle add bucket lifecycle
@@ -43,6 +40,9 @@ type AddBucketLifecycle struct {
 	// Non required, toggle to disable or enable rule
 	ExpiredObjectDeleteMarker bool `json:"expired_object_delete_marker,omitempty"`

+	// Required in case of expiry_days or transition fields are not set. it defines an expiry date for ILM
+	ExpiryDate string `json:"expiry_date,omitempty"`
+
 	// Required in case of expiry_date or transition fields are not set. it defines an expiry days for ILM
 	ExpiryDays int32 `json:"expiry_days,omitempty"`

@@ -64,67 +64,15 @@ type AddBucketLifecycle struct {
 	// Non required field, tags to match ILM files
 	Tags string `json:"tags,omitempty"`

+	// Required in case of transition_days or expiry fields are not set. it defines a transition date for ILM
+	TransitionDate string `json:"transition_date,omitempty"`
+
 	// Required in case of transition_date or expiry fields are not set. it defines a transition days for ILM
 	TransitionDays int32 `json:"transition_days,omitempty"`
-
-	// ILM Rule type (Expiry or transition)
-	// Enum: [expiry transition]
-	Type string `json:"type,omitempty"`
 }

 // Validate validates this add bucket lifecycle
 func (m *AddBucketLifecycle) Validate(formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.validateType(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-var addBucketLifecycleTypeTypePropEnum []interface{}
-
-func init() {
-	var res []string
-	if err := json.Unmarshal([]byte(`["expiry","transition"]`), &res); err != nil {
-		panic(err)
-	}
-	for _, v := range res {
-		addBucketLifecycleTypeTypePropEnum = append(addBucketLifecycleTypeTypePropEnum, v)
-	}
-}
-
-const (
-
-	// AddBucketLifecycleTypeExpiry captures enum value "expiry"
-	AddBucketLifecycleTypeExpiry string = "expiry"
-
-	// AddBucketLifecycleTypeTransition captures enum value "transition"
-	AddBucketLifecycleTypeTransition string = "transition"
-)
-
-// prop value enum
-func (m *AddBucketLifecycle) validateTypeEnum(path, location string, value string) error {
-	if err := validate.EnumCase(path, location, value, addBucketLifecycleTypeTypePropEnum, true); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (m *AddBucketLifecycle) validateType(formats strfmt.Registry) error {
-	if swag.IsZero(m.Type) { // not required
-		return nil
-	}
-
-	// value enum
-	if err := m.validateTypeEnum("type", "body", m.Type); err != nil {
-		return err
-	}
-
 	return nil
 }

--- a/models/add_bucket_replication.go
+++ b/models/add_bucket_replication.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/add_group_request.go
+++ b/models/add_group_request.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/add_multi_bucket_lifecycle.go
+++ b/models/add_multi_bucket_lifecycle.go
@@ -1,168 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-	"encoding/json"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-	"github.com/go-openapi/validate"
-)
-
-// AddMultiBucketLifecycle add multi bucket lifecycle
-//
-// swagger:model addMultiBucketLifecycle
-type AddMultiBucketLifecycle struct {
-
-	// buckets
-	// Required: true
-	Buckets []string `json:"buckets"`
-
-	// Non required, toggle to disable or enable rule
-	ExpiredObjectDeleteMarker bool `json:"expired_object_delete_marker,omitempty"`
-
-	// Required in case of expiry_date or transition fields are not set. it defines an expiry days for ILM
-	ExpiryDays int32 `json:"expiry_days,omitempty"`
-
-	// Non required, can be set in case of expiration is enabled
-	NoncurrentversionExpirationDays int32 `json:"noncurrentversion_expiration_days,omitempty"`
-
-	// Non required, can be set in case of transition is enabled
-	NoncurrentversionTransitionDays int32 `json:"noncurrentversion_transition_days,omitempty"`
-
-	// Non required, can be set in case of transition is enabled
-	NoncurrentversionTransitionStorageClass string `json:"noncurrentversion_transition_storage_class,omitempty"`
-
-	// Non required field, it matches a prefix to perform ILM operations on it
-	Prefix string `json:"prefix,omitempty"`
-
-	// Required only in case of transition is set. it refers to a tier
-	StorageClass string `json:"storage_class,omitempty"`
-
-	// Non required field, tags to match ILM files
-	Tags string `json:"tags,omitempty"`
-
-	// Required in case of transition_date or expiry fields are not set. it defines a transition days for ILM
-	TransitionDays int32 `json:"transition_days,omitempty"`
-
-	// ILM Rule type (Expiry or transition)
-	// Required: true
-	// Enum: [expiry transition]
-	Type *string `json:"type"`
-}
-
-// Validate validates this add multi bucket lifecycle
-func (m *AddMultiBucketLifecycle) Validate(formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.validateBuckets(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.validateType(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *AddMultiBucketLifecycle) validateBuckets(formats strfmt.Registry) error {
-
-	if err := validate.Required("buckets", "body", m.Buckets); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-var addMultiBucketLifecycleTypeTypePropEnum []interface{}
-
-func init() {
-	var res []string
-	if err := json.Unmarshal([]byte(`["expiry","transition"]`), &res); err != nil {
-		panic(err)
-	}
-	for _, v := range res {
-		addMultiBucketLifecycleTypeTypePropEnum = append(addMultiBucketLifecycleTypeTypePropEnum, v)
-	}
-}
-
-const (
-
-	// AddMultiBucketLifecycleTypeExpiry captures enum value "expiry"
-	AddMultiBucketLifecycleTypeExpiry string = "expiry"
-
-	// AddMultiBucketLifecycleTypeTransition captures enum value "transition"
-	AddMultiBucketLifecycleTypeTransition string = "transition"
-)
-
-// prop value enum
-func (m *AddMultiBucketLifecycle) validateTypeEnum(path, location string, value string) error {
-	if err := validate.EnumCase(path, location, value, addMultiBucketLifecycleTypeTypePropEnum, true); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (m *AddMultiBucketLifecycle) validateType(formats strfmt.Registry) error {
-
-	if err := validate.Required("type", "body", m.Type); err != nil {
-		return err
-	}
-
-	// value enum
-	if err := m.validateTypeEnum("type", "body", *m.Type); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// ContextValidate validates this add multi bucket lifecycle based on context it is used
-func (m *AddMultiBucketLifecycle) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *AddMultiBucketLifecycle) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *AddMultiBucketLifecycle) UnmarshalBinary(b []byte) error {
-	var res AddMultiBucketLifecycle
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/add_policy_request.go
+++ b/models/add_policy_request.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/add_service_account_policy_request.go
+++ b/models/add_service_account_policy_request.go
@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-	"github.com/go-openapi/validate"
-)
-
-// AddServiceAccountPolicyRequest add service account policy request
-//
-// swagger:model addServiceAccountPolicyRequest
-type AddServiceAccountPolicyRequest struct {
-
-	// policy
-	// Required: true
-	Policy *string `json:"policy"`
-}
-
-// Validate validates this add service account policy request
-func (m *AddServiceAccountPolicyRequest) Validate(formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.validatePolicy(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *AddServiceAccountPolicyRequest) validatePolicy(formats strfmt.Registry) error {
-
-	if err := validate.Required("policy", "body", m.Policy); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// ContextValidate validates this add service account policy request based on context it is used
-func (m *AddServiceAccountPolicyRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *AddServiceAccountPolicyRequest) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *AddServiceAccountPolicyRequest) UnmarshalBinary(b []byte) error {
-	var res AddServiceAccountPolicyRequest
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/add_user_request.go
+++ b/models/add_user_request.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/admin_info_response.go
+++ b/models/admin_info_response.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -24,13 +24,11 @@ package models

 import (
 	"context"
-	"encoding/json"
 	"strconv"

 	"github.com/go-openapi/errors"
 	"github.com/go-openapi/strfmt"
 	"github.com/go-openapi/swag"
-	"github.com/go-openapi/validate"
 )

 // AdminInfoResponse admin info response
@@ -38,13 +36,6 @@ import (
 // swagger:model adminInfoResponse
 type AdminInfoResponse struct {

-	// advanced metrics status
-	// Enum: [not configured available unavailable]
-	AdvancedMetricsStatus string `json:"advancedMetricsStatus,omitempty"`
-
-	// backend
-	Backend *BackendProperties `json:"backend,omitempty"`
-
 	// buckets
 	Buckets int64 `json:"buckets,omitempty"`

@@ -65,14 +56,6 @@ type AdminInfoResponse struct {
 func (m *AdminInfoResponse) Validate(formats strfmt.Registry) error {
 	var res []error

-	if err := m.validateAdvancedMetricsStatus(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.validateBackend(formats); err != nil {
-		res = append(res, err)
-	}
-
 	if err := m.validateServers(formats); err != nil {
 		res = append(res, err)
 	}
@@ -87,70 +70,6 @@ func (m *AdminInfoResponse) Validate(formats strfmt.Registry) error {
 	return nil
 }

-var adminInfoResponseTypeAdvancedMetricsStatusPropEnum []interface{}
-
-func init() {
-	var res []string
-	if err := json.Unmarshal([]byte(`["not configured","available","unavailable"]`), &res); err != nil {
-		panic(err)
-	}
-	for _, v := range res {
-		adminInfoResponseTypeAdvancedMetricsStatusPropEnum = append(adminInfoResponseTypeAdvancedMetricsStatusPropEnum, v)
-	}
-}
-
-const (
-
-	// AdminInfoResponseAdvancedMetricsStatusNotConfigured captures enum value "not configured"
-	AdminInfoResponseAdvancedMetricsStatusNotConfigured string = "not configured"
-
-	// AdminInfoResponseAdvancedMetricsStatusAvailable captures enum value "available"
-	AdminInfoResponseAdvancedMetricsStatusAvailable string = "available"
-
-	// AdminInfoResponseAdvancedMetricsStatusUnavailable captures enum value "unavailable"
-	AdminInfoResponseAdvancedMetricsStatusUnavailable string = "unavailable"
-)
-
-// prop value enum
-func (m *AdminInfoResponse) validateAdvancedMetricsStatusEnum(path, location string, value string) error {
-	if err := validate.EnumCase(path, location, value, adminInfoResponseTypeAdvancedMetricsStatusPropEnum, true); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (m *AdminInfoResponse) validateAdvancedMetricsStatus(formats strfmt.Registry) error {
-	if swag.IsZero(m.AdvancedMetricsStatus) { // not required
-		return nil
-	}
-
-	// value enum
-	if err := m.validateAdvancedMetricsStatusEnum("advancedMetricsStatus", "body", m.AdvancedMetricsStatus); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (m *AdminInfoResponse) validateBackend(formats strfmt.Registry) error {
-	if swag.IsZero(m.Backend) { // not required
-		return nil
-	}
-
-	if m.Backend != nil {
-		if err := m.Backend.Validate(formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("backend")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("backend")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
 func (m *AdminInfoResponse) validateServers(formats strfmt.Registry) error {
 	if swag.IsZero(m.Servers) { // not required
 		return nil
@@ -165,8 +84,6 @@ func (m *AdminInfoResponse) validateServers(formats strfmt.Registry) error {
 			if err := m.Servers[i].Validate(formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("servers" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("servers" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
@@ -191,8 +108,6 @@ func (m *AdminInfoResponse) validateWidgets(formats strfmt.Registry) error {
 			if err := m.Widgets[i].Validate(formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("widgets" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("widgets" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
@@ -207,10 +122,6 @@ func (m *AdminInfoResponse) validateWidgets(formats strfmt.Registry) error {
 func (m *AdminInfoResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
 	var res []error

-	if err := m.contextValidateBackend(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
 	if err := m.contextValidateServers(ctx, formats); err != nil {
 		res = append(res, err)
 	}
@@ -225,22 +136,6 @@ func (m *AdminInfoResponse) ContextValidate(ctx context.Context, formats strfmt.
 	return nil
 }

-func (m *AdminInfoResponse) contextValidateBackend(ctx context.Context, formats strfmt.Registry) error {
-
-	if m.Backend != nil {
-		if err := m.Backend.ContextValidate(ctx, formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("backend")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("backend")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
 func (m *AdminInfoResponse) contextValidateServers(ctx context.Context, formats strfmt.Registry) error {

 	for i := 0; i < len(m.Servers); i++ {
@@ -249,8 +144,6 @@ func (m *AdminInfoResponse) contextValidateServers(ctx context.Context, formats
 			if err := m.Servers[i].ContextValidate(ctx, formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("servers" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("servers" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
@@ -269,8 +162,6 @@ func (m *AdminInfoResponse) contextValidateWidgets(ctx context.Context, formats
 			if err := m.Widgets[i].ContextValidate(ctx, formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("widgets" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("widgets" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
--- a/models/allocatable_resources_response.go
+++ b/models/allocatable_resources_response.go
@@ -1,173 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-)
-
-// AllocatableResourcesResponse allocatable resources response
-//
-// swagger:model allocatableResourcesResponse
-type AllocatableResourcesResponse struct {
-
-	// cpu priority
-	CPUPriority *NodeMaxAllocatableResources `json:"cpu_priority,omitempty"`
-
-	// mem priority
-	MemPriority *NodeMaxAllocatableResources `json:"mem_priority,omitempty"`
-
-	// min allocatable cpu
-	MinAllocatableCPU int64 `json:"min_allocatable_cpu,omitempty"`
-
-	// min allocatable mem
-	MinAllocatableMem int64 `json:"min_allocatable_mem,omitempty"`
-}
-
-// Validate validates this allocatable resources response
-func (m *AllocatableResourcesResponse) Validate(formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.validateCPUPriority(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.validateMemPriority(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *AllocatableResourcesResponse) validateCPUPriority(formats strfmt.Registry) error {
-	if swag.IsZero(m.CPUPriority) { // not required
-		return nil
-	}
-
-	if m.CPUPriority != nil {
-		if err := m.CPUPriority.Validate(formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("cpu_priority")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("cpu_priority")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *AllocatableResourcesResponse) validateMemPriority(formats strfmt.Registry) error {
-	if swag.IsZero(m.MemPriority) { // not required
-		return nil
-	}
-
-	if m.MemPriority != nil {
-		if err := m.MemPriority.Validate(formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("mem_priority")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("mem_priority")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-// ContextValidate validate this allocatable resources response based on the context it is used
-func (m *AllocatableResourcesResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.contextValidateCPUPriority(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.contextValidateMemPriority(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *AllocatableResourcesResponse) contextValidateCPUPriority(ctx context.Context, formats strfmt.Registry) error {
-
-	if m.CPUPriority != nil {
-		if err := m.CPUPriority.ContextValidate(ctx, formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("cpu_priority")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("cpu_priority")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *AllocatableResourcesResponse) contextValidateMemPriority(ctx context.Context, formats strfmt.Registry) error {
-
-	if m.MemPriority != nil {
-		if err := m.MemPriority.ContextValidate(ctx, formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("mem_priority")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("mem_priority")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *AllocatableResourcesResponse) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *AllocatableResourcesResponse) UnmarshalBinary(b []byte) error {
-	var res AllocatableResourcesResponse
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/annotation.go
+++ b/models/annotation.go
@@ -1,70 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-)
-
-// Annotation annotation
-//
-// swagger:model annotation
-type Annotation struct {
-
-	// key
-	Key string `json:"key,omitempty"`
-
-	// value
-	Value string `json:"value,omitempty"`
-}
-
-// Validate validates this annotation
-func (m *Annotation) Validate(formats strfmt.Registry) error {
-	return nil
-}
-
-// ContextValidate validates this annotation based on context it is used
-func (m *Annotation) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *Annotation) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *Annotation) UnmarshalBinary(b []byte) error {
-	var res Annotation
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/api_key.go
+++ b/models/api_key.go
@@ -1,67 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-)
-
-// APIKey api key
-//
-// swagger:model apiKey
-type APIKey struct {
-
-	// api key
-	APIKey string `json:"apiKey,omitempty"`
-}
-
-// Validate validates this api key
-func (m *APIKey) Validate(formats strfmt.Registry) error {
-	return nil
-}
-
-// ContextValidate validates this api key based on context it is used
-func (m *APIKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *APIKey) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *APIKey) UnmarshalBinary(b []byte) error {
-	var res APIKey
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/arns_response.go
+++ b/models/arns_response.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/aws_configuration.go
+++ b/models/aws_configuration.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -65,8 +65,6 @@ func (m *AwsConfiguration) validateSecretsmanager(formats strfmt.Registry) error
 		if err := m.Secretsmanager.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("secretsmanager")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("secretsmanager")
 			}
 			return err
 		}
@@ -95,8 +93,6 @@ func (m *AwsConfiguration) contextValidateSecretsmanager(ctx context.Context, fo
 		if err := m.Secretsmanager.ContextValidate(ctx, formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("secretsmanager")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("secretsmanager")
 			}
 			return err
 		}
@@ -176,8 +172,6 @@ func (m *AwsConfigurationSecretsmanager) validateCredentials(formats strfmt.Regi
 		if err := m.Credentials.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("secretsmanager" + "." + "credentials")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("secretsmanager" + "." + "credentials")
 			}
 			return err
 		}
@@ -224,8 +218,6 @@ func (m *AwsConfigurationSecretsmanager) contextValidateCredentials(ctx context.
 		if err := m.Credentials.ContextValidate(ctx, formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("secretsmanager" + "." + "credentials")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("secretsmanager" + "." + "credentials")
 			}
 			return err
 		}
--- a/models/azure_configuration.go
+++ b/models/azure_configuration.go
@@ -1,321 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-	"github.com/go-openapi/validate"
-)
-
-// AzureConfiguration azure configuration
-//
-// swagger:model azureConfiguration
-type AzureConfiguration struct {
-
-	// keyvault
-	// Required: true
-	Keyvault *AzureConfigurationKeyvault `json:"keyvault"`
-}
-
-// Validate validates this azure configuration
-func (m *AzureConfiguration) Validate(formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.validateKeyvault(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *AzureConfiguration) validateKeyvault(formats strfmt.Registry) error {
-
-	if err := validate.Required("keyvault", "body", m.Keyvault); err != nil {
-		return err
-	}
-
-	if m.Keyvault != nil {
-		if err := m.Keyvault.Validate(formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("keyvault")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("keyvault")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-// ContextValidate validate this azure configuration based on the context it is used
-func (m *AzureConfiguration) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.contextValidateKeyvault(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *AzureConfiguration) contextValidateKeyvault(ctx context.Context, formats strfmt.Registry) error {
-
-	if m.Keyvault != nil {
-		if err := m.Keyvault.ContextValidate(ctx, formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("keyvault")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("keyvault")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *AzureConfiguration) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *AzureConfiguration) UnmarshalBinary(b []byte) error {
-	var res AzureConfiguration
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
-
-// AzureConfigurationKeyvault azure configuration keyvault
-//
-// swagger:model AzureConfigurationKeyvault
-type AzureConfigurationKeyvault struct {
-
-	// credentials
-	Credentials *AzureConfigurationKeyvaultCredentials `json:"credentials,omitempty"`
-
-	// endpoint
-	// Required: true
-	Endpoint *string `json:"endpoint"`
-}
-
-// Validate validates this azure configuration keyvault
-func (m *AzureConfigurationKeyvault) Validate(formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.validateCredentials(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.validateEndpoint(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *AzureConfigurationKeyvault) validateCredentials(formats strfmt.Registry) error {
-	if swag.IsZero(m.Credentials) { // not required
-		return nil
-	}
-
-	if m.Credentials != nil {
-		if err := m.Credentials.Validate(formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("keyvault" + "." + "credentials")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("keyvault" + "." + "credentials")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *AzureConfigurationKeyvault) validateEndpoint(formats strfmt.Registry) error {
-
-	if err := validate.Required("keyvault"+"."+"endpoint", "body", m.Endpoint); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// ContextValidate validate this azure configuration keyvault based on the context it is used
-func (m *AzureConfigurationKeyvault) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.contextValidateCredentials(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *AzureConfigurationKeyvault) contextValidateCredentials(ctx context.Context, formats strfmt.Registry) error {
-
-	if m.Credentials != nil {
-		if err := m.Credentials.ContextValidate(ctx, formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("keyvault" + "." + "credentials")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("keyvault" + "." + "credentials")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *AzureConfigurationKeyvault) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *AzureConfigurationKeyvault) UnmarshalBinary(b []byte) error {
-	var res AzureConfigurationKeyvault
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
-
-// AzureConfigurationKeyvaultCredentials azure configuration keyvault credentials
-//
-// swagger:model AzureConfigurationKeyvaultCredentials
-type AzureConfigurationKeyvaultCredentials struct {
-
-	// client id
-	// Required: true
-	ClientID *string `json:"client_id"`
-
-	// client secret
-	// Required: true
-	ClientSecret *string `json:"client_secret"`
-
-	// tenant id
-	// Required: true
-	TenantID *string `json:"tenant_id"`
-}
-
-// Validate validates this azure configuration keyvault credentials
-func (m *AzureConfigurationKeyvaultCredentials) Validate(formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.validateClientID(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.validateClientSecret(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.validateTenantID(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *AzureConfigurationKeyvaultCredentials) validateClientID(formats strfmt.Registry) error {
-
-	if err := validate.Required("keyvault"+"."+"credentials"+"."+"client_id", "body", m.ClientID); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (m *AzureConfigurationKeyvaultCredentials) validateClientSecret(formats strfmt.Registry) error {
-
-	if err := validate.Required("keyvault"+"."+"credentials"+"."+"client_secret", "body", m.ClientSecret); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (m *AzureConfigurationKeyvaultCredentials) validateTenantID(formats strfmt.Registry) error {
-
-	if err := validate.Required("keyvault"+"."+"credentials"+"."+"tenant_id", "body", m.TenantID); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// ContextValidate validates this azure configuration keyvault credentials based on context it is used
-func (m *AzureConfigurationKeyvaultCredentials) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *AzureConfigurationKeyvaultCredentials) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *AzureConfigurationKeyvaultCredentials) UnmarshalBinary(b []byte) error {
-	var res AzureConfigurationKeyvaultCredentials
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/backend_properties.go
+++ b/models/backend_properties.go
@@ -1,73 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-)
-
-// BackendProperties backend properties
-//
-// swagger:model BackendProperties
-type BackendProperties struct {
-
-	// backend type
-	BackendType string `json:"backendType,omitempty"`
-
-	// rr s c parity
-	RrSCParity int64 `json:"rrSCParity,omitempty"`
-
-	// standard s c parity
-	StandardSCParity int64 `json:"standardSCParity,omitempty"`
-}
-
-// Validate validates this backend properties
-func (m *BackendProperties) Validate(formats strfmt.Registry) error {
-	return nil
-}
-
-// ContextValidate validates this backend properties based on context it is used
-func (m *BackendProperties) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *BackendProperties) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *BackendProperties) UnmarshalBinary(b []byte) error {
-	var res BackendProperties
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/bucket.go
+++ b/models/bucket.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -24,7 +24,6 @@ package models

 import (
 	"context"
-	"encoding/json"

 	"github.com/go-openapi/errors"
 	"github.com/go-openapi/strfmt"
@@ -43,23 +42,11 @@ type Bucket struct {
 	// creation date
 	CreationDate string `json:"creation_date,omitempty"`

-	// definition
-	Definition string `json:"definition,omitempty"`
-
-	// details
-	Details *BucketDetails `json:"details,omitempty"`
-
 	// name
 	// Required: true
 	// Min Length: 3
 	Name *string `json:"name"`

-	// objects
-	Objects int64 `json:"objects,omitempty"`
-
-	// rw access
-	RwAccess *BucketRwAccess `json:"rw_access,omitempty"`
-
 	// size
 	Size int64 `json:"size,omitempty"`
 }
@@ -72,18 +59,10 @@ func (m *Bucket) Validate(formats strfmt.Registry) error {
 		res = append(res, err)
 	}

-	if err := m.validateDetails(formats); err != nil {
-		res = append(res, err)
-	}
-
 	if err := m.validateName(formats); err != nil {
 		res = append(res, err)
 	}

-	if err := m.validateRwAccess(formats); err != nil {
-		res = append(res, err)
-	}
-
 	if len(res) > 0 {
 		return errors.CompositeValidationError(res...)
 	}
@@ -99,27 +78,6 @@ func (m *Bucket) validateAccess(formats strfmt.Registry) error {
 		if err := m.Access.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("access")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("access")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Bucket) validateDetails(formats strfmt.Registry) error {
-	if swag.IsZero(m.Details) { // not required
-		return nil
-	}
-
-	if m.Details != nil {
-		if err := m.Details.Validate(formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("details")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("details")
 			}
 			return err
 		}
@@ -141,25 +99,6 @@ func (m *Bucket) validateName(formats strfmt.Registry) error {
 	return nil
 }

-func (m *Bucket) validateRwAccess(formats strfmt.Registry) error {
-	if swag.IsZero(m.RwAccess) { // not required
-		return nil
-	}
-
-	if m.RwAccess != nil {
-		if err := m.RwAccess.Validate(formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("rw_access")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("rw_access")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
 // ContextValidate validate this bucket based on the context it is used
 func (m *Bucket) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
 	var res []error
@@ -168,14 +107,6 @@ func (m *Bucket) ContextValidate(ctx context.Context, formats strfmt.Registry) e
 		res = append(res, err)
 	}

-	if err := m.contextValidateDetails(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.contextValidateRwAccess(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
 	if len(res) > 0 {
 		return errors.CompositeValidationError(res...)
 	}
@@ -188,40 +119,6 @@ func (m *Bucket) contextValidateAccess(ctx context.Context, formats strfmt.Regis
 		if err := m.Access.ContextValidate(ctx, formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("access")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("access")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Bucket) contextValidateDetails(ctx context.Context, formats strfmt.Registry) error {
-
-	if m.Details != nil {
-		if err := m.Details.ContextValidate(ctx, formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("details")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("details")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Bucket) contextValidateRwAccess(ctx context.Context, formats strfmt.Registry) error {
-
-	if m.RwAccess != nil {
-		if err := m.RwAccess.ContextValidate(ctx, formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("rw_access")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("rw_access")
 			}
 			return err
 		}
@@ -247,237 +144,3 @@ func (m *Bucket) UnmarshalBinary(b []byte) error {
 	*m = res
 	return nil
 }
-
-// BucketDetails bucket details
-//
-// swagger:model BucketDetails
-type BucketDetails struct {
-
-	// locking
-	Locking bool `json:"locking,omitempty"`
-
-	// quota
-	Quota *BucketDetailsQuota `json:"quota,omitempty"`
-
-	// replication
-	Replication bool `json:"replication,omitempty"`
-
-	// tags
-	Tags map[string]string `json:"tags,omitempty"`
-
-	// versioning
-	Versioning bool `json:"versioning,omitempty"`
-
-	// versioning suspended
-	VersioningSuspended bool `json:"versioningSuspended,omitempty"`
-}
-
-// Validate validates this bucket details
-func (m *BucketDetails) Validate(formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.validateQuota(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *BucketDetails) validateQuota(formats strfmt.Registry) error {
-	if swag.IsZero(m.Quota) { // not required
-		return nil
-	}
-
-	if m.Quota != nil {
-		if err := m.Quota.Validate(formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("details" + "." + "quota")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("details" + "." + "quota")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-// ContextValidate validate this bucket details based on the context it is used
-func (m *BucketDetails) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.contextValidateQuota(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *BucketDetails) contextValidateQuota(ctx context.Context, formats strfmt.Registry) error {
-
-	if m.Quota != nil {
-		if err := m.Quota.ContextValidate(ctx, formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("details" + "." + "quota")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("details" + "." + "quota")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *BucketDetails) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *BucketDetails) UnmarshalBinary(b []byte) error {
-	var res BucketDetails
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
-
-// BucketDetailsQuota bucket details quota
-//
-// swagger:model BucketDetailsQuota
-type BucketDetailsQuota struct {
-
-	// quota
-	Quota int64 `json:"quota,omitempty"`
-
-	// type
-	// Enum: [hard]
-	Type string `json:"type,omitempty"`
-}
-
-// Validate validates this bucket details quota
-func (m *BucketDetailsQuota) Validate(formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.validateType(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-var bucketDetailsQuotaTypeTypePropEnum []interface{}
-
-func init() {
-	var res []string
-	if err := json.Unmarshal([]byte(`["hard"]`), &res); err != nil {
-		panic(err)
-	}
-	for _, v := range res {
-		bucketDetailsQuotaTypeTypePropEnum = append(bucketDetailsQuotaTypeTypePropEnum, v)
-	}
-}
-
-const (
-
-	// BucketDetailsQuotaTypeHard captures enum value "hard"
-	BucketDetailsQuotaTypeHard string = "hard"
-)
-
-// prop value enum
-func (m *BucketDetailsQuota) validateTypeEnum(path, location string, value string) error {
-	if err := validate.EnumCase(path, location, value, bucketDetailsQuotaTypeTypePropEnum, true); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (m *BucketDetailsQuota) validateType(formats strfmt.Registry) error {
-	if swag.IsZero(m.Type) { // not required
-		return nil
-	}
-
-	// value enum
-	if err := m.validateTypeEnum("details"+"."+"quota"+"."+"type", "body", m.Type); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// ContextValidate validates this bucket details quota based on context it is used
-func (m *BucketDetailsQuota) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *BucketDetailsQuota) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *BucketDetailsQuota) UnmarshalBinary(b []byte) error {
-	var res BucketDetailsQuota
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
-
-// BucketRwAccess bucket rw access
-//
-// swagger:model BucketRwAccess
-type BucketRwAccess struct {
-
-	// read
-	Read bool `json:"read,omitempty"`
-
-	// write
-	Write bool `json:"write,omitempty"`
-}
-
-// Validate validates this bucket rw access
-func (m *BucketRwAccess) Validate(formats strfmt.Registry) error {
-	return nil
-}
-
-// ContextValidate validates this bucket rw access based on context it is used
-func (m *BucketRwAccess) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *BucketRwAccess) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *BucketRwAccess) UnmarshalBinary(b []byte) error {
-	var res BucketRwAccess
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/bucket_access.go
+++ b/models/bucket_access.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -37,12 +37,8 @@ import (
 type BucketAccess string

 func NewBucketAccess(value BucketAccess) *BucketAccess {
-	return &value
-}
-
-// Pointer returns a pointer to a freshly-allocated BucketAccess.
-func (m BucketAccess) Pointer() *BucketAccess {
-	return &m
+	v := value
+	return &v
 }

 const (
--- a/models/bucket_encryption_info.go
+++ b/models/bucket_encryption_info.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/bucket_encryption_request.go
+++ b/models/bucket_encryption_request.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -65,8 +65,6 @@ func (m *BucketEncryptionRequest) validateEncType(formats strfmt.Registry) error
 		if err := m.EncType.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("encType")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("encType")
 			}
 			return err
 		}
@@ -95,8 +93,6 @@ func (m *BucketEncryptionRequest) contextValidateEncType(ctx context.Context, fo
 		if err := m.EncType.ContextValidate(ctx, formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("encType")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("encType")
 			}
 			return err
 		}
--- a/models/bucket_encryption_type.go
+++ b/models/bucket_encryption_type.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -37,12 +37,8 @@ import (
 type BucketEncryptionType string

 func NewBucketEncryptionType(value BucketEncryptionType) *BucketEncryptionType {
-	return &value
-}
-
-// Pointer returns a pointer to a freshly-allocated BucketEncryptionType.
-func (m BucketEncryptionType) Pointer() *BucketEncryptionType {
-	return &m
+	v := value
+	return &v
 }

 const (
--- a/models/bucket_event_request.go
+++ b/models/bucket_event_request.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -68,8 +68,6 @@ func (m *BucketEventRequest) validateConfiguration(formats strfmt.Registry) erro
 		if err := m.Configuration.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("configuration")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("configuration")
 			}
 			return err
 		}
@@ -98,8 +96,6 @@ func (m *BucketEventRequest) contextValidateConfiguration(ctx context.Context, f
 		if err := m.Configuration.ContextValidate(ctx, formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("configuration")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("configuration")
 			}
 			return err
 		}
--- a/models/bucket_lifecycle_response.go
+++ b/models/bucket_lifecycle_response.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -68,8 +68,6 @@ func (m *BucketLifecycleResponse) validateLifecycle(formats strfmt.Registry) err
 			if err := m.Lifecycle[i].Validate(formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("lifecycle" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("lifecycle" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
@@ -102,8 +100,6 @@ func (m *BucketLifecycleResponse) contextValidateLifecycle(ctx context.Context,
 			if err := m.Lifecycle[i].ContextValidate(ctx, formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("lifecycle" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("lifecycle" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
--- a/models/bucket_ob_locking_response.go
+++ b/models/bucket_ob_locking_response.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/bucket_object.go
+++ b/models/bucket_object.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -37,9 +37,6 @@ type BucketObject struct {
 	// content type
 	ContentType string `json:"content_type,omitempty"`

-	// etag
-	Etag string `json:"etag,omitempty"`
-
 	// expiration
 	Expiration string `json:"expiration,omitempty"`

--- a/models/bucket_quota.go
+++ b/models/bucket_quota.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -41,7 +41,7 @@ type BucketQuota struct {
 	Quota int64 `json:"quota,omitempty"`

 	// type
-	// Enum: [hard]
+	// Enum: [hard fifo]
 	Type string `json:"type,omitempty"`
 }

@@ -63,7 +63,7 @@ var bucketQuotaTypeTypePropEnum []interface{}

 func init() {
 	var res []string
-	if err := json.Unmarshal([]byte(`["hard"]`), &res); err != nil {
+	if err := json.Unmarshal([]byte(`["hard","fifo"]`), &res); err != nil {
 		panic(err)
 	}
 	for _, v := range res {
@@ -75,6 +75,9 @@ const (

 	// BucketQuotaTypeHard captures enum value "hard"
 	BucketQuotaTypeHard string = "hard"
+
+	// BucketQuotaTypeFifo captures enum value "fifo"
+	BucketQuotaTypeFifo string = "fifo"
 )

 // prop value enum
--- a/models/bucket_replication_destination.go
+++ b/models/bucket_replication_destination.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/bucket_replication_response.go
+++ b/models/bucket_replication_response.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -68,8 +68,6 @@ func (m *BucketReplicationResponse) validateRules(formats strfmt.Registry) error
 			if err := m.Rules[i].Validate(formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("rules" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("rules" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
@@ -102,8 +100,6 @@ func (m *BucketReplicationResponse) contextValidateRules(ctx context.Context, fo
 			if err := m.Rules[i].ContextValidate(ctx, formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("rules" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("rules" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
--- a/models/bucket_replication_rule.go
+++ b/models/bucket_replication_rule.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -49,9 +49,6 @@ type BucketReplicationRule struct {
 	// destination
 	Destination *BucketReplicationDestination `json:"destination,omitempty"`

-	// existing objects
-	ExistingObjects bool `json:"existingObjects,omitempty"`
-
 	// health check period
 	HealthCheckPeriod int64 `json:"healthCheckPeriod,omitempty"`

@@ -71,9 +68,6 @@ type BucketReplicationRule struct {
 	// Enum: [Enabled Disabled]
 	Status string `json:"status,omitempty"`

-	// storage class
-	StorageClass string `json:"storageClass,omitempty"`
-
 	// sync mode
 	// Enum: [async sync]
 	SyncMode *string `json:"syncMode,omitempty"`
@@ -113,8 +107,6 @@ func (m *BucketReplicationRule) validateDestination(formats strfmt.Registry) err
 		if err := m.Destination.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("destination")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("destination")
 			}
 			return err
 		}
@@ -227,8 +219,6 @@ func (m *BucketReplicationRule) contextValidateDestination(ctx context.Context,
 		if err := m.Destination.ContextValidate(ctx, formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("destination")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("destination")
 			}
 			return err
 		}
--- a/models/bucket_replication_rule_list.go
+++ b/models/bucket_replication_rule_list.go
@@ -1,67 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-)
-
-// BucketReplicationRuleList bucket replication rule list
-//
-// swagger:model bucketReplicationRuleList
-type BucketReplicationRuleList struct {
-
-	// rules
-	Rules []string `json:"rules"`
-}
-
-// Validate validates this bucket replication rule list
-func (m *BucketReplicationRuleList) Validate(formats strfmt.Registry) error {
-	return nil
-}
-
-// ContextValidate validates this bucket replication rule list based on context it is used
-func (m *BucketReplicationRuleList) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *BucketReplicationRuleList) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *BucketReplicationRuleList) UnmarshalBinary(b []byte) error {
-	var res BucketReplicationRuleList
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/bucket_versioning_response.go
+++ b/models/bucket_versioning_response.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/bulk_user_groups.go
+++ b/models/bulk_user_groups.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/certificate_info.go
+++ b/models/certificate_info.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/change_user_password_request.go
+++ b/models/change_user_password_request.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/check_operator_version_response.go
+++ b/models/check_operator_version_response.go
@@ -1,70 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-)
-
-// CheckOperatorVersionResponse check operator version response
-//
-// swagger:model checkOperatorVersionResponse
-type CheckOperatorVersionResponse struct {
-
-	// current version
-	CurrentVersion string `json:"current_version,omitempty"`
-
-	// latest version
-	LatestVersion string `json:"latest_version,omitempty"`
-}
-
-// Validate validates this check operator version response
-func (m *CheckOperatorVersionResponse) Validate(formats strfmt.Registry) error {
-	return nil
-}
-
-// ContextValidate validates this check operator version response based on context it is used
-func (m *CheckOperatorVersionResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *CheckOperatorVersionResponse) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *CheckOperatorVersionResponse) UnmarshalBinary(b []byte) error {
-	var res CheckOperatorVersionResponse
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/check_version_response.go
+++ b/models/check_version_response.go
@@ -1,70 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-)
-
-// CheckVersionResponse check version response
-//
-// swagger:model checkVersionResponse
-type CheckVersionResponse struct {
-
-	// current version
-	CurrentVersion string `json:"current_version,omitempty"`
-
-	// latest version
-	LatestVersion string `json:"latest_version,omitempty"`
-}
-
-// Validate validates this check version response
-func (m *CheckVersionResponse) Validate(formats strfmt.Registry) error {
-	return nil
-}
-
-// ContextValidate validates this check version response based on context it is used
-func (m *CheckVersionResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *CheckVersionResponse) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *CheckVersionResponse) UnmarshalBinary(b []byte) error {
-	var res CheckVersionResponse
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/condition.go
+++ b/models/condition.go
@@ -1,70 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-)
-
-// Condition condition
-//
-// swagger:model condition
-type Condition struct {
-
-	// status
-	Status string `json:"status,omitempty"`
-
-	// type
-	Type string `json:"type,omitempty"`
-}
-
-// Validate validates this condition
-func (m *Condition) Validate(formats strfmt.Registry) error {
-	return nil
-}
-
-// ContextValidate validates this condition based on context it is used
-func (m *Condition) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *Condition) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *Condition) UnmarshalBinary(b []byte) error {
-	var res Condition
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/config_description.go
+++ b/models/config_description.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
--- a/models/config_map.go
+++ b/models/config_map.go
@@ -1,70 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-package models
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-)
-
-// ConfigMap config map
-//
-// swagger:model configMap
-type ConfigMap struct {
-
-	// name
-	Name string `json:"name,omitempty"`
-
-	// optional
-	Optional bool `json:"optional,omitempty"`
-}
-
-// Validate validates this config map
-func (m *ConfigMap) Validate(formats strfmt.Registry) error {
-	return nil
-}
-
-// ContextValidate validates this config map based on context it is used
-func (m *ConfigMap) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *ConfigMap) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *ConfigMap) UnmarshalBinary(b []byte) error {
-	var res ConfigMap
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}
--- a/models/configuration.go
+++ b/models/configuration.go
@@ -1,7 +1,7 @@
 // Code generated by go-swagger; DO NOT EDIT.

 // This file is part of MinIO Console Server
-// Copyright (c) 2022 MinIO, Inc.
+// Copyright (c) 2021 MinIO, Inc.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -71,8 +71,6 @@ func (m *Configuration) validateKeyValues(formats strfmt.Registry) error {
 			if err := m.KeyValues[i].Validate(formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("key_values" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("key_values" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
@@ -105,8 +103,6 @@ func (m *Configuration) contextValidateKeyValues(ctx context.Context, formats st
 			if err := m.KeyValues[i].ContextValidate(ctx, formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("key_values" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("key_values" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Daniel Valdivia	219337ff78	assets Signed-off-by: Daniel Valdivia <18384552+dvaldivia@users.noreply.github.com>	2021-09-04 22:21:24 -07:00
Daniel Valdivia	f02609b3b6	Release v0.9.7 Signed-off-by: Daniel Valdivia <18384552+dvaldivia@users.noreply.github.com>	2021-09-04 21:38:49 -07:00