assets

Signed-off-by: Daniel Valdivia <18384552+dvaldivia@users.noreply.github.com>

.github/workflows/common.sh

@@ -1,94 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (C) 2022, MinIO, Inc.
-#
-# This code is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License, version 3,
-# as published by the Free Software Foundation.
-#
-# 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, version 3,
-# along with this program.  If not, see <http://www.gnu.org/licenses/>
-
-yell() { echo "$0: $*" >&2; }
-
-die() {
-  yell "$*"
-  (kind delete cluster || true ) && exit 111
-}
-
-try() { "$@" || die "cannot $*"; }
-
-function setup_kind() {
-	# TODO once feature is added: https://github.com/kubernetes-sigs/kind/issues/1300
-	echo "kind: Cluster" > kind-config.yaml
-	echo "apiVersion: kind.x-k8s.io/v1alpha4" >> kind-config.yaml
-	echo "nodes:" >> kind-config.yaml
-	echo "  - role: control-plane" >> kind-config.yaml
-	echo "  - role: worker" >> kind-config.yaml
-	echo "  - role: worker" >> kind-config.yaml
-	echo "  - role: worker" >> kind-config.yaml
-	echo "  - role: worker" >> kind-config.yaml
-	try kind create cluster --config kind-config.yaml
-	echo "Kind is ready"
-	try kubectl get nodes
-}
-
-function install_operator() {
-    echo "Installing Current Operator"
-
-    # TODO: Compile the current branch and create an overlay to use that image version
-    try kubectl apply -k "${SCRIPT_DIR}/../../portal-ui/tests/scripts/resources"
-
-    echo "Waiting for k8s api"
-    sleep 10
-    echo "Waiting for Operator Pods to come online (2m timeout)"
-
-    try kubectl wait --namespace minio-operator \
-	--for=condition=ready pod \
-	--selector=name=minio-operator \
-	--timeout=120s
-}
-
-function destroy_kind() {
-    kind delete cluster
-}
-
-function check_tenant_status() {
-    # Check MinIO is accessible
-
-    waitdone=0
-    totalwait=0
-    while true; do
-	waitdone=$(kubectl -n $1 get pods -l v1.min.io/tenant=$2 --no-headers | wc -l)
-	if [ "$waitdone" -ne 0 ]; then
-	    echo "Found $waitdone pods"
-	    break
-	fi
-	sleep 5
-	totalwait=$((totalwait + 5))
-	if [ "$totalwait" -gt 305 ]; then
-	    echo "Unable to create tenant after 5 minutes, exiting."
-	    try false
-	fi
-    done
-
-    echo "Waiting for pods to be ready. (5m timeout)"
-
-    USER=$(kubectl -n $1 get secrets $2-env-configuration -o go-template='{{index .data "config.env"|base64decode }}' | grep 'export MINIO_ROOT_USER="' | sed -e 's/export MINIO_ROOT_USER="//g' | sed -e 's/"//g')
-    PASSWORD=$(kubectl -n $1 get secrets $2-env-configuration -o go-template='{{index .data "config.env"|base64decode }}' | grep 'export MINIO_ROOT_PASSWORD="' | sed -e 's/export MINIO_ROOT_PASSWORD="//g' | sed -e 's/"//g')
-
-    try kubectl wait --namespace $1 \
-        --for=condition=ready pod \
-        --selector=v1.min.io/tenant=$2 \
-        --timeout=300s
-
-    echo "Tenant is created successfully, proceeding to validate 'mc admin info minio/'"
-
-    kubectl run admin-mc -i --tty --image minio/mc --command -- bash -c "until (mc alias set minio/ https://minio.$1.svc.cluster.local $USER $PASSWORD); do echo \"...waiting... for 5secs\" && sleep 5; done; mc admin info minio/;"
-
-    echo "Done."
-}

.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

.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'"

.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'"

.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'"

.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'"

.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'"

.github/workflows/deploy-tenant.sh

@@ -1,71 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (C) 2022, MinIO, Inc.
-#
-# This code is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License, version 3,
-# as published by the Free Software Foundation.
-#
-# 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, version 3,
-# along with this program.  If not, see <http://www.gnu.org/licenses/>
-
-# This script requires: kubectl, kind
-
-SCRIPT_DIR=$(dirname "$0")
-export SCRIPT_DIR
-
-source "${SCRIPT_DIR}/common.sh"
-
-
-
-function install_tenant() {
-    echo "Installing lite tenant"
-
-	try kubectl apply -k "${SCRIPT_DIR}/../../portal-ui/tests/scripts/tenant"
-
-    echo "Waiting for the tenant statefulset, this indicates the tenant is being fulfilled"
-    waitdone=0
-    totalwait=0
-    while true; do
-	waitdone=$(kubectl -n tenant-lite get pods -l v1.min.io/tenant=storage-lite --no-headers | wc -l)
-	if [ "$waitdone" -ne 0 ]; then
-	    echo "Found $waitdone pods"
-	    break
-	fi
-	sleep 5
-	totalwait=$((totalwait + 5))
-	if [ "$totalwait" -gt 300 ]; then
-	    echo "Tenant never created statefulset after 5 minutes"
-	    try false
-	fi
-    done
-
-    echo "Waiting for tenant pods to come online (5m timeout)"
-    try kubectl wait --namespace tenant-lite \
-	--for=condition=ready pod \
-	--selector="v1.min.io/tenant=storage-lite" \
-	--timeout=300s
-
-    echo "Build passes basic tenant creation"
-}
-
-
-function main() {
-    destroy_kind
-
-    setup_kind
-
-    install_operator
-
-    install_tenant
-
-    check_tenant_status tenant-lite storage-lite
-
-    kubectl proxy &
-}
-
-main "$@"

.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

.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

.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

.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

.gitignore

@@ -19,7 +19,6 @@ vendor/
 
 # Ignore executables
 target/
-!pkg/logger/target/
 console
 !console/
 

.golangci.yml

@@ -19,17 +19,9 @@ linters:
     - unparam
     - unused
     - structcheck
-    - goheader
-
-linters-settings:
-  goheader:
-    values:
-      regexp:
-        copyright-holder: Copyright \(c\) (20\d\d\-20\d\d)|2021|({{year}})
-    template-path: .license.tmpl
 
 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
@@ -44,4 +36,3 @@ issues:
 run:
   skip-dirs:
     - pkg/clientgen
-    - pkg/apis/networking.gke.io

.goreleaser.yml

@@ -13,7 +13,7 @@ release:
 before:
   hooks:
     # you may remove this if you don't use vgo
-    - go mod tidy -compat=1.17
+    - 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

.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/>.

Dockerfile

@@ -1,4 +1,4 @@
-FROM node:17 as uilayer
+FROM node:10 as uilayer
 
 WORKDIR /app
 
@@ -8,11 +8,11 @@ RUN yarn install
 
 COPY ./portal-ui .
 
-RUN make build-static
+RUN yarn install && make build-static
 
 USER node
 
-FROM golang:1.17 as golayer
+FROM golang:1.16 as golayer
 
 RUN apt-get update -y && apt-get install -y ca-certificates
 
@@ -29,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.5
+FROM registry.access.redhat.com/ubi8/ubi-minimal:8.3
 MAINTAINER MinIO Development "dev@min.io"
 EXPOSE 9090
 

Dockerfile.assets

@@ -1,4 +1,4 @@
-FROM node:17 as uilayer
+FROM node:10 as uilayer
 
 WORKDIR /app
 

Dockerfile.release

@@ -1,4 +1,4 @@
-FROM registry.access.redhat.com/ubi8/ubi-minimal:8.5
+FROM registry.access.redhat.com/ubi8/ubi-minimal:8.4
 
 ARG TAG
 

Makefile

@@ -4,14 +4,13 @@ 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"
 
 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)' .
@@ -20,7 +19,7 @@ k8sdev:
 
 getdeps:
 	@mkdir -p ${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.43.0)
+	@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
 
@@ -62,164 +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:
-	@(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"
-	@(cd integration && go test -coverpkg=../restapi -c -tags testrunmain . && mkdir -p coverage && ./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 "execute latest keycloak container"
-	@(docker run \
-	--rm \
-	--name keycloak-container \
-	--network my-net \
-	-p 8080:8080 \
-	-e KEYCLOAK_USER=admin \
-	-e KEYCLOAK_PASSWORD=admin jboss/keycloak:latest -b 0.0.0.0 -bprivate 127.0.0.1 &)
-	@echo "wait 60 sec until keycloak is listenning on port, then go for minio server"
-	@(sleep 60)
-	@echo "execute keycloak-config-cli container to configure keycloak for Single Sign On with MinIO"
-	@(docker run \
-	--rm \
-	--network my-net \
-	--name keycloak-config-cli \
-	-e KEYCLOAK_URL=http://keycloak-container:8080/auth \
-	-e KEYCLOAK_USER="admin" \
-	-e KEYCLOAK_PASSWORD="admin" \
-	-e KEYCLOAK_AVAILABILITYCHECK_ENABLED=true \
-	-e KEYCLOAK_AVAILABILITYCHECK_TIMEOUT=120s \
-	-e IMPORT_FILES_LOCATIONS='/config/realm-export.json' \
-	-v /home/runner/work/console/console/sso-integration/config:/config \
-	adorsys/keycloak-config-cli: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_SECRET=0nfJuqIt0iPnRIUJkvetve5l38C6gi9W \
-	-e MINIO_IDENTITY_OPENID_CONFIG_URL=http://keycloak-container:8080/auth/realms/myrealm/.well-known/openid-configuration \
-	-e MINIO_IDENTITY_OPENID_CLIENT_ID="account" \
-	-e MINIO_ROOT_USER=minio \
-	-e MINIO_ROOT_PASSWORD=minio123 $(MINIO_VERSION) server /data{1...4} --address :9000 --console-address :9001)
-	@echo "starting bash script"
-	@(env bash $(PWD)/sso-integration/set-sso.sh)
-	@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-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)
+	@(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)
@@ -231,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)' .
-
-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)' .

NOTICE

@@ -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

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.17
 
 ```
-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
 

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,6 +17,7 @@
 package cluster
 
 import (
+	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"
@@ -63,3 +64,8 @@ func OperatorClient(token string) (*operator.Clientset, error) {
 func K8sClient(token string) (*kubernetes.Clientset, error) {
 	return kubernetes.NewForConfig(GetK8sConfig(token))
 }
+
+// DirectCSIClient returns Direct CSI client using GetK8sConfig for its config
+func DirectCSIClient(token string) (*direct.Clientset, error) {
+	return direct.NewForConfig(GetK8sConfig(token))
+}

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
+}

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"
 )

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)
+}

cmd/console/app_commands.go

@@ -1,100 +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()
-}

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()
-}

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

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,46 +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
 	}
 
@@ -227,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"}
@@ -240,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()
 }

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()
+}

go.mod

@@ -1,162 +1,44 @@
 module github.com/minio/console
 
-go 1.17
+go 1.16
 
 require (
 	github.com/blang/semver/v4 v4.0.0
-	github.com/cheggaaa/pb/v3 v3.0.8
+	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.2
-	github.com/go-openapi/loads v0.21.1
-	github.com/go-openapi/runtime v0.23.3
-	github.com/go-openapi/spec v0.20.5
-	github.com/go-openapi/strfmt v0.21.2
-	github.com/go-openapi/swag v0.21.1
-	github.com/go-openapi/validate v0.21.0
-	github.com/golang-jwt/jwt/v4 v4.4.1
-	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.1
+	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/highwayhash v1.0.2
-	github.com/minio/kes v0.19.2
-	github.com/minio/madmin-go v1.3.12
-	github.com/minio/mc v0.0.0-20220419155441-cc4ff3a0cc82
-	github.com/minio/minio-go/v7 v7.0.24
-	github.com/minio/operator v0.0.0-20220414212219-ba4c097324b2
-	github.com/minio/pkg v1.1.21
-	github.com/minio/selfupdate v0.4.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.7.1
-	github.com/tidwall/gjson v1.14.0
-	github.com/unrolled/secure v1.10.0
-	golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4
-	golang.org/x/net v0.0.0-20220421235706-1d1ef9303861
-	golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5
+	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.23.5
-	k8s.io/apimachinery v0.23.5
-	k8s.io/client-go v0.23.5
+	k8s.io/api v0.21.1
+	k8s.io/apimachinery v0.21.1
+	k8s.io/client-go v0.21.1
 )
 
-require (
-	github.com/VividCortex/ewma v1.2.0 // indirect
-	github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d // indirect
-	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/briandowns/spinner v1.18.1 // indirect
-	github.com/cespare/xxhash/v2 v2.1.2 // indirect
-	github.com/charmbracelet/bubbles v0.10.3 // indirect
-	github.com/charmbracelet/bubbletea v0.20.0 // indirect
-	github.com/charmbracelet/lipgloss v0.5.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.3.2 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect
-	github.com/docker/go-units v0.4.0 // indirect
-	github.com/evanphx/json-patch v5.6.0+incompatible // indirect
-	github.com/fatih/structs v1.1.0 // indirect
-	github.com/gdamore/encoding v1.0.0 // indirect
-	github.com/gdamore/tcell/v2 v2.4.1-0.20210905002822-f057f0a857a1 // indirect
-	github.com/go-logr/logr v1.2.2 // indirect
-	github.com/go-ole/go-ole v1.2.6 // indirect
-	github.com/go-openapi/analysis v0.21.2 // indirect
-	github.com/go-openapi/jsonpointer v0.19.5 // indirect
-	github.com/go-openapi/jsonreference v0.20.0 // indirect
-	github.com/go-stack/stack v1.8.1 // indirect
-	github.com/goccy/go-json v0.9.4 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang-jwt/jwt v3.2.2+incompatible // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/google/go-cmp v0.5.7 // indirect
-	github.com/google/gofuzz v1.2.0 // indirect
-	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
-	github.com/googleapis/gnostic v0.5.5 // indirect
-	github.com/hashicorp/errwrap v1.1.0 // indirect
-	github.com/hashicorp/go-multierror v1.1.1 // indirect
-	github.com/inconshreveable/mousetrap v1.0.0 // indirect
-	github.com/josharian/intern v1.0.0 // indirect
-	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.0.11 // indirect
-	github.com/lestrrat-go/backoff/v2 v2.0.8 // indirect
-	github.com/lestrrat-go/blackmagic v1.0.0 // indirect
-	github.com/lestrrat-go/httpcc v1.0.0 // indirect
-	github.com/lestrrat-go/iter v1.0.1 // indirect
-	github.com/lestrrat-go/jwx v1.2.19 // 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-20211012122336-39d0f177ccd0 // indirect
-	github.com/mailru/easyjson v0.7.7 // indirect
-	github.com/mattn/go-colorable v0.1.12 // indirect
-	github.com/mattn/go-ieproxy v0.0.1 // indirect
-	github.com/mattn/go-isatty v0.0.14 // indirect
-	github.com/mattn/go-runewidth v0.0.13 // indirect
-	github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect
-	github.com/minio/colorjson v1.0.2 // indirect
-	github.com/minio/filepath v1.0.0 // 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/muesli/ansi v0.0.0-20211031195517-c9f0611b6c70 // indirect
-	github.com/muesli/reflow v0.3.0 // indirect
-	github.com/muesli/termenv v0.11.1-0.20220212125758-44cd13922739 // indirect
-	github.com/navidys/tvxwidgets v0.1.0 // indirect
-	github.com/oklog/ulid v1.3.1 // indirect
-	github.com/olekukonko/tablewriter v0.0.5 // 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.5 // 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.12.1 // indirect
-	github.com/prometheus/client_model v0.2.0 // indirect
-	github.com/prometheus/common v0.32.1 // indirect
-	github.com/prometheus/procfs v0.7.3 // indirect
-	github.com/rivo/tview v0.0.0-20220216162559-96063d6082f3 // indirect
-	github.com/rivo/uniseg v0.2.0 // indirect
-	github.com/rjeczalik/notify v0.9.2 // indirect
-	github.com/shirou/gopsutil/v3 v3.22.2 // indirect
-	github.com/sirupsen/logrus v1.8.1 // indirect
-	github.com/tidwall/match v1.1.1 // indirect
-	github.com/tidwall/pretty v1.2.0 // indirect
-	github.com/tinylib/msgp v1.1.7-0.20211026165309-e818a1881b0e // indirect
-	github.com/tklauser/go-sysconf v0.3.10 // indirect
-	github.com/tklauser/numcpus v0.4.0 // indirect
-	github.com/yusufpapurcu/wmi v1.2.2 // indirect
-	go.etcd.io/etcd/api/v3 v3.5.2 // indirect
-	go.etcd.io/etcd/client/pkg/v3 v3.5.2 // indirect
-	go.etcd.io/etcd/client/v3 v3.5.2 // indirect
-	go.mongodb.org/mongo-driver v1.8.4 // indirect
-	go.uber.org/atomic v1.9.0 // indirect
-	go.uber.org/multierr v1.8.0 // indirect
-	go.uber.org/zap v1.21.0 // indirect
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
-	golang.org/x/sys v0.0.0-20220412211240-33da011f77ad // indirect
-	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
-	golang.org/x/text v0.3.7 // indirect
-	golang.org/x/time v0.0.0-20220224211638-0e9765cccd65 // indirect
-	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto v0.0.0-20220302033224-9aa15565e42a // indirect
-	google.golang.org/grpc v1.44.0 // indirect
-	google.golang.org/protobuf v1.27.1 // indirect
-	gopkg.in/h2non/filetype.v1 v1.0.5 // indirect
-	gopkg.in/inf.v0 v0.9.1 // indirect
-	gopkg.in/ini.v1 v1.66.4 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
-	k8s.io/klog/v2 v2.40.1 // indirect
-	k8s.io/kube-openapi v0.0.0-20220124234850-424119656bbf // indirect
-	k8s.io/utils v0.0.0-20220210201930-3a6ce19ff2f9 // indirect
-	maze.io/x/duration v0.0.0-20160924141736-faac084b6075 // indirect
-	sigs.k8s.io/controller-runtime v0.11.1 // indirect
-	sigs.k8s.io/json v0.0.0-20211208200746-9f7c6b3444d2 // indirect
-	sigs.k8s.io/structured-merge-diff/v4 v4.2.1 // indirect
-	sigs.k8s.io/yaml v1.3.0 // indirect
-)
+replace google.golang.org/grpc => google.golang.org/grpc v1.29.1

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 \

integration/admin_api_integration_test.go

@@ -1,340 +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,
-		)
-	}
-}

integration/buckets_test.go

@@ -1,186 +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)
-
-	// get list of buckets
-	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)
-}

integration/config_test.go

@@ -1,83 +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)
-
-	type args struct {
-		api string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		expectedStatus int
-		expectedError  error
-	}{
-		{
-			name: "Config - Valid",
-			args: args{
-				api: "/configs",
-			},
-			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", 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")
-			}
-		})
-	}
-
-}

integration/groups_test.go

@@ -1,365 +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_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: "?name=getgroup1",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "Get Group - Invalid",
-			args: args{
-				api: "?name=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:     "?name=putgroup1",
-				members: []string{"member3"},
-				status:  "enabled",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "Put Group - Invalid",
-			args: args{
-				api:     "?name=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: "?name=grouptests1",
-			},
-			verb:           "DELETE",
-			expectedStatus: 204,
-			expectedError:  nil,
-		},
-		{
-			name: "Delete Group - Invalid",
-			args: args{
-				api: "?name=grouptests12345",
-			},
-			verb:           "DELETE",
-			expectedStatus: 404,
-			expectedError:  nil,
-		},
-		{
-			name: "Access Group After Delete - Invalid",
-			args: args{
-				api: "?name=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")
-			}
-
-		})
-	}
-
-}

integration/login_test.go

@@ -1,137 +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
-	}
-
-	request, err = http.NewRequest("POST", "http://localhost:9090/api/v1/logout", requestDataBody)
-	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)
-
-}

integration/objects_test.go

@@ -1,198 +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))
-			}
-		})
-	}
-
-}

integration/policy_test.go

@@ -1,812 +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"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/go-openapi/swag"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func AddPolicy(name string, 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 string, 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: "/policy?name=test3",
-			},
-			expectedStatus: 500,
-			expectedError:  nil,
-		},
-		{
-			name: "Get Policies - Valid",
-			args: args{
-				api: "/policy?name=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%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/policylistusers/users",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "List Users for Policy - Invalid",
-			args: args{
-				api: "/policies/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/policylistgroups/groups",
-			},
-			expectedStatus: 200,
-			expectedError:  nil,
-		},
-		{
-			name: "List Users for Policy - Invalid",
-			args: args{
-				api: "/policies/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:    "/policy?name=testdelete",
-				method: "DELETE",
-			},
-			expectedStatus: 204,
-			expectedError:  nil,
-		},
-		{
-			name: "Get Policy After Delete - Invalid",
-			args: args{
-				api:    "/policy?name=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%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")
-			}
-		})
-	}
-
-}

integration/profiling_test.go

@@ -1,121 +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"
-	"io"
-	"log"
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestStartProfiling(t *testing.T) {
-	testAsser := 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,
-			}
-
-			client := &http.Client{
-				Timeout: 3 * time.Second,
-			}
-
-			destination := "/api/v1/profiling/start"
-			finalURL := fmt.Sprintf("http://localhost:9090%s", destination)
-			request, err := http.NewRequest("POST", finalURL, strings.NewReader("{\"type\":\"cpu,mem,block,mutex,trace,threads,goroutines\"}"))
-			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)
-
-			testAsser.Nil(err, fmt.Sprintf("%s returned an error: %v", tt.name, err))
-			testAsser.Equal(201, response.StatusCode)
-
-			time.Sleep(5 * time.Second)
-
-			destination = "/api/v1/profiling/stop"
-			finalURL = fmt.Sprintf("http://localhost:9090%s", destination)
-			request, err = http.NewRequest("POST", 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")
-
-			response, err = client.Do(request)
-
-			testAsser.Nil(err, fmt.Sprintf("%s returned an error: %v", tt.name, err))
-			testAsser.Equal(200, response.StatusCode)
-			zipFileBytes, err := io.ReadAll(response.Body)
-			if err != nil {
-				testAsser.Nil(err, fmt.Sprintf("%s returned an error: %v", tt.name, err))
-			}
-			filetype := http.DetectContentType(zipFileBytes)
-			testAsser.Equal("application/zip", filetype)
-
-			zipReader, err := zip.NewReader(bytes.NewReader(zipFileBytes), int64(len(zipFileBytes)))
-			if err != nil {
-				testAsser.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 {
-				testAsser.Equal(true, v, fmt.Sprintf("%s : compressed file expected to have %v file inside", tt.name, k))
-			}
-		})
-	}
-}

integration/service_account_test.go

@@ -1,409 +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/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/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/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/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
-	var groups = []string{}
-	var policies = []string{}
-	var 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),
-		)
-	}
-
-}

integration/tiers_test.go

@@ -1,55 +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)
-
-}

integration/users_test.go

@@ -1,921 +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"
-	"io"
-	"log"
-	"net/http"
-	"strconv"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func AddUser(accessKey string, secretKey string, groups []string, 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) {
-	/*
-		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?name="+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 string, 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) {
-	/*
-		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?name="+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 string, status string, groups []string) (*http.Response, error) {
-	/*
-		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="+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) {
-	/*
-		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="+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) {
-	/*
-		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/groups?name="+userName,
-		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 string, policy string) (*http.Response, error) {
-	/*
-		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 string, policy string, accessKey string, secretKey string) (*http.Response, error) {
-	// 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) {
-	/*
-		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 []string, 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
-	var groups = []string{}
-	var 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
-	var groups = []string{}
-	var 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)
-	var groups = []string{}
-	var 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
-	var groups = []string{}
-	var 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
-	var groups = []string{}
-	var 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
-	var groups = []string{}
-	var 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)
-	var groups = []string{}
-	var 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
-	var 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
-	var groups = []string{}
-	var 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)
-	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{}
-	var policies = []string{}
-	username := "testusersgroupbulk"
-	groupName := "testusersgroupsbulkgroupone"
-	var 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(string(finalResponse), groupName))
-	}
-
-}
-
-func Test_GetUserPolicyAPI(t *testing.T) {
-	assert := assert.New(t)
-
-	// 1. Create an active user with valid policy
-	var groups = []string{}
-	var 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")
-			}
-		})
-	}
-
-}

integration/version_test.go

@@ -1,75 +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")
-			}
-
-		})
-	}
-
-}

k8s/operator-console/base/console-deployment.yaml

@@ -15,7 +15,7 @@ spec:
       serviceAccountName: console-sa
       containers:
         - name: console
-          image: 'minio/console:v0.16.2'
+          image: minio/console:v0.9.7
           imagePullPolicy: "IfNotPresent"
           env:
             - name: CONSOLE_OPERATOR_MODE

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
+

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.16.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

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

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

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

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
 }
 

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

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

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
-}

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

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
-}

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

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
@@ -42,9 +42,6 @@ type AdminInfoResponse struct {
 	// objects
 	Objects int64 `json:"objects,omitempty"`
 
-	// prometheus not ready
-	PrometheusNotReady bool `json:"prometheusNotReady,omitempty"`
-
 	// servers
 	Servers []*ServerProperties `json:"servers"`
 
@@ -87,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
 			}
@@ -113,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
 			}
@@ -151,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
 			}
@@ -171,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
 			}

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
-}

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

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
 		}

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
-}

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
-}

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 (

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

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
 		}

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 (

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
 		}

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
 			}

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

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"`
 

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

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

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
 			}

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
 		}

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
-}

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

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

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

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

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
-}

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
-}

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
-}

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

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
-}

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
 			}

models/configuration_k_v.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

models/configure_tenant_request.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"
-)
-
-// ConfigureTenantRequest configure tenant request
-//
-// swagger:model configureTenantRequest
-type ConfigureTenantRequest struct {
-
-	// prometheus enabled
-	PrometheusEnabled bool `json:"prometheusEnabled,omitempty"`
-}
-
-// Validate validates this configure tenant request
-func (m *ConfigureTenantRequest) Validate(formats strfmt.Registry) error {
-	return nil
-}
-
-// ContextValidate validates this configure tenant request based on context it is used
-func (m *ConfigureTenantRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *ConfigureTenantRequest) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *ConfigureTenantRequest) UnmarshalBinary(b []byte) error {
-	var res ConfigureTenantRequest
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}

models/container.go

@@ -1,309 +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"
-	"strconv"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/swag"
-)
-
-// Container container
-//
-// swagger:model container
-type Container struct {
-
-	// args
-	Args []string `json:"args"`
-
-	// container ID
-	ContainerID string `json:"containerID,omitempty"`
-
-	// environment variables
-	EnvironmentVariables []*EnvironmentVariable `json:"environmentVariables"`
-
-	// host ports
-	HostPorts []string `json:"hostPorts"`
-
-	// image
-	Image string `json:"image,omitempty"`
-
-	// image ID
-	ImageID string `json:"imageID,omitempty"`
-
-	// last state
-	LastState *State `json:"lastState,omitempty"`
-
-	// mounts
-	Mounts []*Mount `json:"mounts"`
-
-	// name
-	Name string `json:"name,omitempty"`
-
-	// ports
-	Ports []string `json:"ports"`
-
-	// ready
-	Ready bool `json:"ready,omitempty"`
-
-	// restart count
-	RestartCount int64 `json:"restartCount,omitempty"`
-
-	// state
-	State *State `json:"state,omitempty"`
-}
-
-// Validate validates this container
-func (m *Container) Validate(formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.validateEnvironmentVariables(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.validateLastState(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.validateMounts(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.validateState(formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *Container) validateEnvironmentVariables(formats strfmt.Registry) error {
-	if swag.IsZero(m.EnvironmentVariables) { // not required
-		return nil
-	}
-
-	for i := 0; i < len(m.EnvironmentVariables); i++ {
-		if swag.IsZero(m.EnvironmentVariables[i]) { // not required
-			continue
-		}
-
-		if m.EnvironmentVariables[i] != nil {
-			if err := m.EnvironmentVariables[i].Validate(formats); err != nil {
-				if ve, ok := err.(*errors.Validation); ok {
-					return ve.ValidateName("environmentVariables" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("environmentVariables" + "." + strconv.Itoa(i))
-				}
-				return err
-			}
-		}
-
-	}
-
-	return nil
-}
-
-func (m *Container) validateLastState(formats strfmt.Registry) error {
-	if swag.IsZero(m.LastState) { // not required
-		return nil
-	}
-
-	if m.LastState != nil {
-		if err := m.LastState.Validate(formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("lastState")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("lastState")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Container) validateMounts(formats strfmt.Registry) error {
-	if swag.IsZero(m.Mounts) { // not required
-		return nil
-	}
-
-	for i := 0; i < len(m.Mounts); i++ {
-		if swag.IsZero(m.Mounts[i]) { // not required
-			continue
-		}
-
-		if m.Mounts[i] != nil {
-			if err := m.Mounts[i].Validate(formats); err != nil {
-				if ve, ok := err.(*errors.Validation); ok {
-					return ve.ValidateName("mounts" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("mounts" + "." + strconv.Itoa(i))
-				}
-				return err
-			}
-		}
-
-	}
-
-	return nil
-}
-
-func (m *Container) validateState(formats strfmt.Registry) error {
-	if swag.IsZero(m.State) { // not required
-		return nil
-	}
-
-	if m.State != nil {
-		if err := m.State.Validate(formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("state")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("state")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-// ContextValidate validate this container based on the context it is used
-func (m *Container) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
-	var res []error
-
-	if err := m.contextValidateEnvironmentVariables(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.contextValidateLastState(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.contextValidateMounts(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
-	if err := m.contextValidateState(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-func (m *Container) contextValidateEnvironmentVariables(ctx context.Context, formats strfmt.Registry) error {
-
-	for i := 0; i < len(m.EnvironmentVariables); i++ {
-
-		if m.EnvironmentVariables[i] != nil {
-			if err := m.EnvironmentVariables[i].ContextValidate(ctx, formats); err != nil {
-				if ve, ok := err.(*errors.Validation); ok {
-					return ve.ValidateName("environmentVariables" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("environmentVariables" + "." + strconv.Itoa(i))
-				}
-				return err
-			}
-		}
-
-	}
-
-	return nil
-}
-
-func (m *Container) contextValidateLastState(ctx context.Context, formats strfmt.Registry) error {
-
-	if m.LastState != nil {
-		if err := m.LastState.ContextValidate(ctx, formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("lastState")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("lastState")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *Container) contextValidateMounts(ctx context.Context, formats strfmt.Registry) error {
-
-	for i := 0; i < len(m.Mounts); i++ {
-
-		if m.Mounts[i] != nil {
-			if err := m.Mounts[i].ContextValidate(ctx, formats); err != nil {
-				if ve, ok := err.(*errors.Validation); ok {
-					return ve.ValidateName("mounts" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("mounts" + "." + strconv.Itoa(i))
-				}
-				return err
-			}
-		}
-
-	}
-
-	return nil
-}
-
-func (m *Container) contextValidateState(ctx context.Context, formats strfmt.Registry) error {
-
-	if m.State != nil {
-		if err := m.State.ContextValidate(ctx, formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("state")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("state")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
-// MarshalBinary interface implementation
-func (m *Container) MarshalBinary() ([]byte, error) {
-	if m == nil {
-		return nil, nil
-	}
-	return swag.WriteJSON(m)
-}
-
-// UnmarshalBinary interface implementation
-func (m *Container) UnmarshalBinary(b []byte) error {
-	var res Container
-	if err := swag.ReadJSON(b, &res); err != nil {
-		return err
-	}
-	*m = res
-	return nil
-}

models/create_remote_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

models/create_tenant_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
@@ -43,9 +43,6 @@ type CreateTenantRequest struct {
 	// annotations
 	Annotations map[string]string `json:"annotations,omitempty"`
 
-	// domains
-	Domains *DomainsConfiguration `json:"domains,omitempty"`
-
 	// enable console
 	EnableConsole *bool `json:"enable_console,omitempty"`
 
@@ -115,10 +112,6 @@ type CreateTenantRequest struct {
 func (m *CreateTenantRequest) Validate(formats strfmt.Registry) error {
 	var res []error
 
-	if err := m.validateDomains(formats); err != nil {
-		res = append(res, err)
-	}
-
 	if err := m.validateEncryption(formats); err != nil {
 		res = append(res, err)
 	}
@@ -161,25 +154,6 @@ func (m *CreateTenantRequest) Validate(formats strfmt.Registry) error {
 	return nil
 }
 
-func (m *CreateTenantRequest) validateDomains(formats strfmt.Registry) error {
-	if swag.IsZero(m.Domains) { // not required
-		return nil
-	}
-
-	if m.Domains != nil {
-		if err := m.Domains.Validate(formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("domains")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("domains")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
 func (m *CreateTenantRequest) validateEncryption(formats strfmt.Registry) error {
 	if swag.IsZero(m.Encryption) { // not required
 		return nil
@@ -189,8 +163,6 @@ func (m *CreateTenantRequest) validateEncryption(formats strfmt.Registry) error
 		if err := m.Encryption.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("encryption")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("encryption")
 			}
 			return err
 		}
@@ -208,8 +180,6 @@ func (m *CreateTenantRequest) validateIdp(formats strfmt.Registry) error {
 		if err := m.Idp.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("idp")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("idp")
 			}
 			return err
 		}
@@ -227,8 +197,6 @@ func (m *CreateTenantRequest) validateImageRegistry(formats strfmt.Registry) err
 		if err := m.ImageRegistry.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("image_registry")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("image_registry")
 			}
 			return err
 		}
@@ -246,8 +214,6 @@ func (m *CreateTenantRequest) validateLogSearchConfiguration(formats strfmt.Regi
 		if err := m.LogSearchConfiguration.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("logSearchConfiguration")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("logSearchConfiguration")
 			}
 			return err
 		}
@@ -293,8 +259,6 @@ func (m *CreateTenantRequest) validatePools(formats strfmt.Registry) error {
 			if err := m.Pools[i].Validate(formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("pools" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("pools" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
@@ -314,8 +278,6 @@ func (m *CreateTenantRequest) validatePrometheusConfiguration(formats strfmt.Reg
 		if err := m.PrometheusConfiguration.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("prometheusConfiguration")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("prometheusConfiguration")
 			}
 			return err
 		}
@@ -333,8 +295,6 @@ func (m *CreateTenantRequest) validateTLS(formats strfmt.Registry) error {
 		if err := m.TLS.Validate(formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("tls")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("tls")
 			}
 			return err
 		}
@@ -347,10 +307,6 @@ func (m *CreateTenantRequest) validateTLS(formats strfmt.Registry) error {
 func (m *CreateTenantRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
 	var res []error
 
-	if err := m.contextValidateDomains(ctx, formats); err != nil {
-		res = append(res, err)
-	}
-
 	if err := m.contextValidateEncryption(ctx, formats); err != nil {
 		res = append(res, err)
 	}
@@ -385,30 +341,12 @@ func (m *CreateTenantRequest) ContextValidate(ctx context.Context, formats strfm
 	return nil
 }
 
-func (m *CreateTenantRequest) contextValidateDomains(ctx context.Context, formats strfmt.Registry) error {
-
-	if m.Domains != nil {
-		if err := m.Domains.ContextValidate(ctx, formats); err != nil {
-			if ve, ok := err.(*errors.Validation); ok {
-				return ve.ValidateName("domains")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("domains")
-			}
-			return err
-		}
-	}
-
-	return nil
-}
-
 func (m *CreateTenantRequest) contextValidateEncryption(ctx context.Context, formats strfmt.Registry) error {
 
 	if m.Encryption != nil {
 		if err := m.Encryption.ContextValidate(ctx, formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("encryption")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("encryption")
 			}
 			return err
 		}
@@ -423,8 +361,6 @@ func (m *CreateTenantRequest) contextValidateIdp(ctx context.Context, formats st
 		if err := m.Idp.ContextValidate(ctx, formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("idp")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("idp")
 			}
 			return err
 		}
@@ -439,8 +375,6 @@ func (m *CreateTenantRequest) contextValidateImageRegistry(ctx context.Context,
 		if err := m.ImageRegistry.ContextValidate(ctx, formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("image_registry")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("image_registry")
 			}
 			return err
 		}
@@ -455,8 +389,6 @@ func (m *CreateTenantRequest) contextValidateLogSearchConfiguration(ctx context.
 		if err := m.LogSearchConfiguration.ContextValidate(ctx, formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("logSearchConfiguration")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("logSearchConfiguration")
 			}
 			return err
 		}
@@ -473,8 +405,6 @@ func (m *CreateTenantRequest) contextValidatePools(ctx context.Context, formats
 			if err := m.Pools[i].ContextValidate(ctx, formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("pools" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("pools" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
@@ -491,8 +421,6 @@ func (m *CreateTenantRequest) contextValidatePrometheusConfiguration(ctx context
 		if err := m.PrometheusConfiguration.ContextValidate(ctx, formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("prometheusConfiguration")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("prometheusConfiguration")
 			}
 			return err
 		}
@@ -507,8 +435,6 @@ func (m *CreateTenantRequest) contextValidateTLS(ctx context.Context, formats st
 		if err := m.TLS.ContextValidate(ctx, formats); err != nil {
 			if ve, ok := err.(*errors.Validation); ok {
 				return ve.ValidateName("tls")
-			} else if ce, ok := err.(*errors.CompositeError); ok {
-				return ce.ValidateName("tls")
 			}
 			return err
 		}

models/create_tenant_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
@@ -71,8 +71,6 @@ func (m *CreateTenantResponse) validateConsole(formats strfmt.Registry) error {
 			if err := m.Console[i].Validate(formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("console" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("console" + "." + strconv.Itoa(i))
 				}
 				return err
 			}
@@ -105,8 +103,6 @@ func (m *CreateTenantResponse) contextValidateConsole(ctx context.Context, forma
 			if err := m.Console[i].ContextValidate(ctx, formats); err != nil {
 				if ve, ok := err.(*errors.Validation); ok {
 					return ve.ValidateName("console" + "." + strconv.Itoa(i))
-				} else if ce, ok := err.(*errors.CompositeError); ok {
-					return ce.ValidateName("console" + "." + strconv.Itoa(i))
 				}
 				return err
 			}

models/csi_format_error_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