Merge pull request #14 from jasjastone/openMaxIO-main

Update README.md

.github/workflows/jobs.yaml

@@ -441,54 +441,6 @@ jobs:
         timeout-minutes: 10
         run: npx testcafe "firefox:headless" web-app/tests/permissions-4/ --skip-js-errors
 
-  all-permissions-5:
-    name: Permissions Tests Part 5
-    needs:
-      - compile-binary
-    runs-on: [ubuntu-latest]
-    strategy:
-      matrix:
-        go-version: [1.23.x]
-        os: [ubuntu-latest]
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v3
-      - name: Read .nvmrc
-        id: node_version
-        run: echo "$(cat .nvmrc)" && echo "NVMRC=$(cat .nvmrc)" >> $GITHUB_ENV
-      - name: Enable Corepack
-        run: corepack enable
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NVMRC }}
-      - name: Install MinIO JS
-        working-directory: ./
-        continue-on-error: false
-        run: |
-          yarn add minio
-      - uses: actions/cache@v4
-        name: Console Binary Cache
-        with:
-          path: |
-            ./console
-          key: ${{ runner.os }}-binary-${{ github.run_id }}
-
-      - name: clean-previous-containers-if-any
-        run: |
-          docker stop minio || true;
-          docker container prune -f || true;
-
-      - name: Start Console, front-end app and initialize users/policies
-        run: |
-          (./console server) & (make initialize-permissions)
-
-      - name: Install TestCafe
-        run: npm install testcafe@3.5.0
-
-      - name: Run TestCafe Tests
-        timeout-minutes: 5
-        run: npx testcafe "firefox:headless" web-app/tests/permissions-5/ --skip-js-errors
-
   all-permissions-6:
     name: Permissions Tests Part 6
     needs:
@@ -537,57 +489,6 @@ jobs:
         timeout-minutes: 5
         run: npx testcafe "firefox:headless" web-app/tests/permissions-6/ --skip-js-errors
 
-  all-permissions-A:
-    name: Permissions Tests Part A
-    needs:
-      - compile-binary
-    runs-on: [ubuntu-latest]
-    strategy:
-      matrix:
-        go-version: [1.23.x]
-        os: [ubuntu-latest]
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v3
-      - name: Read .nvmrc
-        id: node_version
-        run: echo "$(cat .nvmrc)" && echo "NVMRC=$(cat .nvmrc)" >> $GITHUB_ENV
-      - name: Enable Corepack
-        run: corepack enable
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NVMRC }}
-      - name: Install MinIO JS
-        working-directory: ./
-        continue-on-error: false
-        run: |
-          yarn add minio
-      - uses: actions/cache@v4
-        name: Console Binary Cache
-        with:
-          path: |
-            ./console
-          key: ${{ runner.os }}-binary-${{ github.run_id }}
-
-      - name: clean-previous-containers-if-any
-        run: |
-          docker stop minio || true;
-          docker container prune -f || true;
-
-      - name: Start Console, front-end app and initialize users/policies
-        run: |
-          (./console server) & (make initialize-permissions)
-
-      - name: Install TestCafe
-        run: npm install testcafe@3.5.0
-
-      - name: Run TestCafe Tests
-        run: npx testcafe "firefox:headless" web-app/tests/permissions-A/ --skip-js-errors -c 3
-
-      - name: Clean up users & policies
-        run: |
-          make cleanup-permissions
-
   all-permissions-B:
     name: Permissions Tests Part B
     needs:
@@ -1282,20 +1183,4 @@ jobs:
           yarn remove playwright
           yarn add --dev @playwright/test
           echo "npx playwright test"
-          npx playwright test # To run the tests
+          npx playwright test --reporter github # To run the tests
-          echo "npx nyc report"
-          npx nyc report # To see report printed in logs as text
-          echo "npx nyc report --reporter=html"
-          npx nyc report --reporter=html # to see report in ./coverage/index.html
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: playwright-report
-          path: playwright-report/
-          retention-days: 30
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: coverage
-          path: coverage/
-          retention-days: 30

.github/workflows/vulncheck.yaml

@@ -15,11 +15,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: 1.23.3
+          go-version: 1.23.8
           check-latest: true
       - name: Get official govulncheck
         run: go install golang.org/x/vuln/cmd/govulncheck@latest
@@ -37,7 +37,7 @@ jobs:
         os: [ ubuntu-latest ]
     steps:
       - name: Check out code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Read .nvmrc
         id: node_version
         run: echo "$(cat .nvmrc)" && echo "NVMRC=$(cat .nvmrc)" >> $GITHUB_ENV

.gitignore

@@ -48,3 +48,6 @@ public.crt
 *.code-workspace
 *~
 .eslintcache
+
+# Ignore Bin files
+bin/

.golangci.bck.yml

@@ -0,0 +1,55 @@
+linters-settings:
+  misspell:
+    locale: US
+  testifylint:
+    disable:
+      - go-require
+  staticcheck:
+    checks:
+      [
+        "all",
+        "-ST1005",
+        "-ST1000",
+        "-SA4000",
+        "-SA9004",
+        "-SA1019",
+        "-SA1008",
+        "-U1000",
+        "-ST1016",
+      ]
+  goheader:
+    values:
+      regexp:
+        copyright-holder: Copyright \(c\) (20\d\d\-20\d\d)|2021|({{year}})
+    template-path: .license.tmpl
+
+linters:
+  disable-all: true
+  enable:
+    - goimports
+    - misspell
+    - govet
+    - revive
+    - ineffassign
+    - gosimple
+    - gomodguard
+    - gofmt
+    - unused
+    - staticcheck
+    - unconvert
+    - gocritic
+    - gofumpt
+    - durationcheck
+
+issues:
+  exclude-use-default: false
+  exclude:
+    - should have a package comment
+    # TODO(y4m4): Remove once all exported ident. have comments!
+    - comment on exported function
+    - comment on exported type
+    - should have comment
+    - use leading k in Go names
+    - comment on exported const
+  exclude-dirs:
+    - api/operations

.golangci.yml

@@ -1,49 +1,73 @@
-linters-settings:
+version: "2"
-  golint:
-    min-confidence: 0
-
-  misspell:
-    locale: US
-
-  goheader:
-    values:
-      regexp:
-        copyright-holder: Copyright \(c\) (20\d\d\-20\d\d)|2021|({{year}})
-    template-path: .license.tmpl
-
 linters:
-  disable-all: true
+  default: none
   enable:
-    - goimports
+    - durationcheck
-    - misspell
+    - gocritic
-    - govet
-    - revive
-    - ineffassign
-    - gosimple
     - gomodguard
-    - gofmt
+    - govet
-    - unused
+    - ineffassign
+    - misspell
+    - revive
     - staticcheck
     - unconvert
-    - gocritic
+    - unused
+  settings:
+    goheader:
+      values:
+        regexp:
+          copyright-holder: Copyright \(c\) (20\d\d\-20\d\d)|2021|({{year}})
+      template-path: .license.tmpl
+    misspell:
+      locale: US
+    staticcheck:
+      checks:
+        - all
+        - -QF1001
+        - -QF1008
+        - -QF1010
+        - -QF1012
+        - -SA1008
+        - -SA1019
+        - -SA4000
+        - -SA9004
+        - -ST1000
+        - -ST1005
+        - -ST1016
+        - -ST1019
+        - -U1000
+    testifylint:
+      disable:
+        - go-require
+  exclusions:
+    generated: lax
+    rules:
+      - path: (.+)\.go$
+        text: should have a package comment
+      - path: (.+)\.go$
+        text: comment on exported function
+      - path: (.+)\.go$
+        text: comment on exported type
+      - path: (.+)\.go$
+        text: should have comment
+      - path: (.+)\.go$
+        text: use leading k in Go names
+      - path: (.+)\.go$
+        text: comment on exported const
+    paths:
+      - api/operations
+      - third_party$
+      - builtin$
+      - examples$
+formatters:
+  enable:
+    - gofmt
     - gofumpt
-    - durationcheck
+    - goimports
-
+  exclusions:
-service:
+    generated: lax
-  golangci-lint-version: 1.43.0 # use the fixed version to not introduce new linters unexpectedly
+    paths:
-
+      - api/operations
-issues:
+      - third_party$
-  exclude-use-default: false
+      - builtin$
-  exclude:
+      - examples$
-    - should have a package comment
-    # TODO(y4m4): Remove once all exported ident. have comments!
-    - comment on exported function
-    - comment on exported type
-    - should have comment
-    - use leading k in Go names
-    - comment on exported const
-run:
-  skip-dirs:
-    - pkg/clientgen
-    - pkg/apis/networking.gke.io
-    - api/operations

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## Release v1.7.6
+
+Bug Fix:
+
+- Fix null pointer exception in Admin Info
+- Ignore leading or trailing spaces in login request
+- Fix file path on drag and drop
+- Fix typo in User DN Search Filter example
+
 ## Release v1.7.5
 
 Bug Fix:

Makefile

@@ -64,7 +64,7 @@ swagger-console:
 
 assets:
 	@(if [ -f "${NVM_DIR}/nvm.sh" ]; then \. "${NVM_DIR}/nvm.sh" && nvm install && nvm use && npm install -g yarn ; fi &&\
-	  cd web-app; corepack enable; yarn install --prefer-offline; make build-static; yarn prettier --write . --loglevel warn; cd ..)
+	  cd web-app; corepack enable; yarn install --prefer-offline; make build-static; yarn prettier --write . --log-level warn; cd ..)
 
 test-integration:
 	@(docker stop pgsqlcontainer || true)
@@ -206,11 +206,6 @@ test-permissions-4:
 	@(env bash $(PWD)/web-app/tests/scripts/permissions.sh "web-app/tests/permissions-4/")
 	@(docker stop minio)
 
-test-permissions-5:
-	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 -d --name minio --rm -p 9000:9000 quay.io/minio/minio:latest server /data{1...4})
-	@(env bash $(PWD)/web-app/tests/scripts/permissions.sh "web-app/tests/permissions-5/")
-	@(docker stop minio)
-
 test-permissions-6:
 	@(docker run -v /data1 -v /data2 -v /data3 -v /data4 -d --name minio --rm -p 9000:9000 quay.io/minio/minio:latest server /data{1...4})
 	@(env bash $(PWD)/web-app/tests/scripts/permissions.sh "web-app/tests/permissions-6/")

README.md

@@ -1,4 +1,40 @@
-# MinIO Console
+# To build you own OpenMaxIO UI: 
+
+```bash
+git clone https://github.com/OpenMaxIO/openmaxio-object-browser 
+cd openmaxio-object-browser/web-app
+git checkout v1.7.6
+yarn install 
+yarn build 
+cd ../
+make console 
+./console server 
+```
+
+# To connect OpenMaxIO UI to an existing Minio server run this command (replace 1.2.3.4:9000 to your address)
+
+```bash
+CONSOLE_MINIO_SERVER=http://1.2.3.4:9000 ./console server 
+```
+
+# OpenMaxIO Console
+
+This is a fork of MinIO Console. 
+This is a communitty driven project and is not affiliated with MinIO, Inc. 
+
+OpenMaxIO is a community-maintained fork of MinIO, created in response to the removal of key features from the MinIO open-source distribution. Our goal is simple:
+to preserve a fully open, fully functional, and production-grade object storage server that stays true to the original spirit of minimalism, performance, and freedom.
+
+MinIO once stood for minimal, high-performance, open-source object storage. But recent changes have shifted core capabilities behind a commercial license. We believe the open-source ecosystem deserves better.
+
+OpenMaxIO brings back what was removed and keeps it open for good.
+
+
+## Contributing
+
+We welcome contributions to OpenMaxIO Console. These are still early days, so please be patient as we work to restore and enhance the features you love.
+
+
 
 ![build](https://github.com/minio/console/workflows/Go/badge.svg) ![license](https://img.shields.io/badge/license-AGPL%20V3-blue)
 
@@ -215,3 +251,4 @@ The detailed logging also includes all request and response headers (if any).
 # Contribute to console Project
 
 Please follow console [Contributor's Guide](https://github.com/minio/console/blob/master/CONTRIBUTING.md)
+

api/admin_arns.go

@@ -1,70 +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 api
-
-import (
-	"context"
-
-	systemApi "github.com/minio/console/api/operations/system"
-
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/minio/console/api/operations"
-	"github.com/minio/console/models"
-)
-
-func registerAdminArnsHandlers(api *operations.ConsoleAPI) {
-	// return a list of arns
-	api.SystemArnListHandler = systemApi.ArnListHandlerFunc(func(params systemApi.ArnListParams, session *models.Principal) middleware.Responder {
-		arnsResp, err := getArnsResponse(session, params)
-		if err != nil {
-			return systemApi.NewArnListDefault(err.Code).WithPayload(err.APIError)
-		}
-		return systemApi.NewArnListOK().WithPayload(arnsResp)
-	})
-}
-
-// getArns invokes admin info and returns a list of arns
-func getArns(ctx context.Context, client MinioAdmin) (*models.ArnsResponse, error) {
-	serverInfo, err := client.serverInfo(ctx)
-	if err != nil {
-		return nil, err
-	}
-	// build response
-	return &models.ArnsResponse{
-		Arns: serverInfo.SQSARN,
-	}, nil
-}
-
-// getArnsResponse returns a list of active arns in the instance
-func getArnsResponse(session *models.Principal, params systemApi.ArnListParams) (*models.ArnsResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	// serialize output
-	arnsList, err := getArns(ctx, adminClient)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return arnsList, nil
-}

api/admin_arns_test.go

@@ -1,97 +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 api
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"strings"
-	"testing"
-
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/minio/console/api/operations/system"
-	"github.com/minio/console/models"
-
-	"github.com/go-openapi/loads"
-	"github.com/minio/console/api/operations"
-	"github.com/minio/madmin-go/v3"
-
-	asrt "github.com/stretchr/testify/assert"
-)
-
-func TestArnsList(t *testing.T) {
-	assert := asrt.New(t)
-	adminClient := AdminClientMock{}
-	// Test-1 : getArns() returns proper arn list
-	MinioServerInfoMock = func(_ context.Context) (madmin.InfoMessage, error) {
-		return madmin.InfoMessage{
-			SQSARN: []string{"uno"},
-		}, nil
-	}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	arnsList, err := getArns(ctx, adminClient)
-	assert.NotNil(arnsList, "arn list was returned nil")
-	if arnsList != nil {
-		assert.Equal(len(arnsList.Arns), 1, "Incorrect arns count")
-	}
-	assert.Nil(err, "Error should have been nil")
-
-	// Test-2 : getArns(ctx) fails for whatever reason
-	MinioServerInfoMock = func(_ context.Context) (madmin.InfoMessage, error) {
-		return madmin.InfoMessage{}, errors.New("some reason")
-	}
-
-	arnsList, err = getArns(ctx, adminClient)
-	assert.Nil(arnsList, "arn list was not returned nil")
-	assert.NotNil(err, "An error should have been returned")
-}
-
-func TestRegisterAdminArnsHandlers(t *testing.T) {
-	assert := asrt.New(t)
-	swaggerSpec, err := loads.Embedded(SwaggerJSON, FlatSwaggerJSON)
-	if err != nil {
-		assert.Fail("Error")
-	}
-	api := operations.NewConsoleAPI(swaggerSpec)
-	api.SystemArnListHandler = nil
-	registerAdminArnsHandlers(api)
-	if api.SystemArnListHandler == nil {
-		assert.Fail("Assignment should happen")
-	} else {
-		fmt.Println("Function got assigned: ", api.SystemArnListHandler)
-	}
-
-	// To test error case in registerAdminArnsHandlers
-	request, _ := http.NewRequest(
-		"GET",
-		"http://localhost:9090/api/v1/buckets/",
-		nil,
-	)
-	ArnListParamsStruct := system.ArnListParams{
-		HTTPRequest: request,
-	}
-	modelsPrincipal := models.Principal{
-		STSAccessKeyID: "accesskey",
-	}
-	var value middleware.Responder = api.SystemArnListHandler.Handle(ArnListParamsStruct, &modelsPrincipal)
-	str := fmt.Sprintf("%#v", value)
-	fmt.Println("value: ", str)
-	assert.Equal(strings.Contains(str, "_statusCode:500"), true)
-}

api/admin_client_mock.go

@@ -18,338 +18,18 @@ package api
 
 import (
 	"context"
-	"io"
-	"time"
 
 	"github.com/minio/madmin-go/v3"
-	iampolicy "github.com/minio/pkg/v3/policy"
 )
 
-type AdminClientMock struct{}
+type AdminClientMock struct {
-
+	minioAccountInfoMock func(ctx context.Context) (madmin.AccountInfo, error)
-var (
-	MinioServerInfoMock     func(ctx context.Context) (madmin.InfoMessage, error)
-	minioChangePasswordMock func(ctx context.Context, accessKey, secretKey string) error
-
-	minioHelpConfigKVMock       func(subSys, key string, envOnly bool) (madmin.Help, error)
-	minioGetConfigKVMock        func(key string) ([]byte, error)
-	minioSetConfigKVMock        func(kv string) (restart bool, err error)
-	minioDelConfigKVMock        func(name string) (err error)
-	minioHelpConfigKVGlobalMock func(envOnly bool) (madmin.Help, error)
-
-	minioGetLogsMock func(ctx context.Context, node string, lineCnt int, logKind string) <-chan madmin.LogInfo
-
-	minioListGroupsMock          func() ([]string, error)
-	minioUpdateGroupMembersMock  func(madmin.GroupAddRemove) error
-	minioGetGroupDescriptionMock func(group string) (*madmin.GroupDesc, error)
-	minioSetGroupStatusMock      func(group string, status madmin.GroupStatus) error
-
-	minioHealMock func(ctx context.Context, bucket, prefix string, healOpts madmin.HealOpts, clientToken string,
-		forceStart, forceStop bool) (healStart madmin.HealStartSuccess, healTaskStatus madmin.HealTaskStatus, err error)
-
-	minioServerHealthInfoMock func(ctx context.Context, deadline time.Duration) (interface{}, string, error)
-
-	minioListPoliciesMock func() (map[string]*iampolicy.Policy, error)
-	minioGetPolicyMock    func(name string) (*iampolicy.Policy, error)
-	minioRemovePolicyMock func(name string) error
-	minioAddPolicyMock    func(name string, policy *iampolicy.Policy) error
-	minioSetPolicyMock    func(policyName, entityName string, isGroup bool) error
-
-	minioStartProfiling func(profiler madmin.ProfilerType) ([]madmin.StartProfilingResult, error)
-	minioStopProfiling  func() (io.ReadCloser, error)
-
-	minioServiceRestartMock func(ctx context.Context) error
-
-	getSiteReplicationInfo        func(ctx context.Context) (*madmin.SiteReplicationInfo, error)
-	addSiteReplicationInfo        func(ctx context.Context, sites []madmin.PeerSite) (*madmin.ReplicateAddStatus, error)
-	editSiteReplicationInfo       func(ctx context.Context, site madmin.PeerInfo) (*madmin.ReplicateEditStatus, error)
-	deleteSiteReplicationInfoMock func(ctx context.Context, removeReq madmin.SRRemoveReq) (*madmin.ReplicateRemoveStatus, error)
-	getSiteReplicationStatus      func(ctx context.Context, params madmin.SRStatusOptions) (*madmin.SRStatusInfo, error)
-
-	minioListTiersMock        func(ctx context.Context) ([]*madmin.TierConfig, error)
-	minioTierStatsMock        func(ctx context.Context) ([]madmin.TierInfo, error)
-	minioAddTiersMock         func(ctx context.Context, tier *madmin.TierConfig) error
-	minioRemoveTierMock       func(ctx context.Context, tierName string) error
-	minioEditTiersMock        func(ctx context.Context, tierName string, creds madmin.TierCreds) error
-	minioVerifyTierStatusMock func(ctx context.Context, tierName string) error
-
-	minioServiceTraceMock func(ctx context.Context, threshold int64, s3, internal, storage, os, errTrace bool) <-chan madmin.ServiceTraceInfo
-
-	minioListUsersMock     func() (map[string]madmin.UserInfo, error)
-	minioAddUserMock       func(accessKey, secreyKey string) error
-	minioRemoveUserMock    func(accessKey string) error
-	minioGetUserInfoMock   func(accessKey string) (madmin.UserInfo, error)
-	minioSetUserStatusMock func(accessKey string, status madmin.AccountStatus) error
-
-	minioAccountInfoMock           func(ctx context.Context) (madmin.AccountInfo, error)
-	minioAddServiceAccountMock     func(ctx context.Context, policy string, user string, accessKey string, secretKey string, description string, name string, expiry *time.Time, status string) (madmin.Credentials, error)
-	minioListServiceAccountsMock   func(ctx context.Context, user string) (madmin.ListServiceAccountsResp, error)
-	minioDeleteServiceAccountMock  func(ctx context.Context, serviceAccount string) error
-	minioInfoServiceAccountMock    func(ctx context.Context, serviceAccount string) (madmin.InfoServiceAccountResp, error)
-	minioUpdateServiceAccountMock  func(ctx context.Context, serviceAccount string, opts madmin.UpdateServiceAccountReq) error
-	minioGetLDAPPolicyEntitiesMock func(ctx context.Context, query madmin.PolicyEntitiesQuery) (madmin.PolicyEntitiesResult, error)
-
-	minioListRemoteBucketsMock func(ctx context.Context, bucket, arnType string) (targets []madmin.BucketTarget, err error)
-	minioGetRemoteBucketMock   func(ctx context.Context, bucket, arnType string) (targets *madmin.BucketTarget, err error)
-	minioAddRemoteBucketMock   func(ctx context.Context, bucket string, target *madmin.BucketTarget) (string, error)
-)
-
-func (ac AdminClientMock) serverInfo(ctx context.Context) (madmin.InfoMessage, error) {
-	return MinioServerInfoMock(ctx)
-}
-
-func (ac AdminClientMock) listRemoteBuckets(ctx context.Context, bucket, arnType string) (targets []madmin.BucketTarget, err error) {
-	return minioListRemoteBucketsMock(ctx, bucket, arnType)
-}
-
-func (ac AdminClientMock) getRemoteBucket(ctx context.Context, bucket, arnType string) (targets *madmin.BucketTarget, err error) {
-	return minioGetRemoteBucketMock(ctx, bucket, arnType)
-}
-
-func (ac AdminClientMock) removeRemoteBucket(_ context.Context, _, _ string) error {
-	return nil
-}
-
-func (ac AdminClientMock) addRemoteBucket(ctx context.Context, bucket string, target *madmin.BucketTarget) (string, error) {
-	return minioAddRemoteBucketMock(ctx, bucket, target)
-}
-
-func (ac AdminClientMock) changePassword(ctx context.Context, accessKey, secretKey string) error {
-	return minioChangePasswordMock(ctx, accessKey, secretKey)
-}
-
-func (ac AdminClientMock) speedtest(_ context.Context, _ madmin.SpeedtestOpts) (chan madmin.SpeedTestResult, error) {
-	return nil, nil
-}
-
-func (ac AdminClientMock) verifyTierStatus(ctx context.Context, tier string) error {
-	return minioVerifyTierStatusMock(ctx, tier)
-}
-
-// mock function helpConfigKV()
-func (ac AdminClientMock) helpConfigKV(_ context.Context, subSys, key string, envOnly bool) (madmin.Help, error) {
-	return minioHelpConfigKVMock(subSys, key, envOnly)
-}
-
-// mock function getConfigKV()
-func (ac AdminClientMock) getConfigKV(_ context.Context, name string) ([]byte, error) {
-	return minioGetConfigKVMock(name)
-}
-
-// mock function setConfigKV()
-func (ac AdminClientMock) setConfigKV(_ context.Context, kv string) (restart bool, err error) {
-	return minioSetConfigKVMock(kv)
-}
-
-// mock function helpConfigKV()
-func (ac AdminClientMock) helpConfigKVGlobal(_ context.Context, envOnly bool) (madmin.Help, error) {
-	return minioHelpConfigKVGlobalMock(envOnly)
-}
-
-func (ac AdminClientMock) delConfigKV(_ context.Context, name string) (err error) {
-	return minioDelConfigKVMock(name)
-}
-
-func (ac AdminClientMock) getLogs(ctx context.Context, node string, lineCnt int, logKind string) <-chan madmin.LogInfo {
-	return minioGetLogsMock(ctx, node, lineCnt, logKind)
-}
-
-func (ac AdminClientMock) listGroups(_ context.Context) ([]string, error) {
-	return minioListGroupsMock()
-}
-
-func (ac AdminClientMock) updateGroupMembers(_ context.Context, req madmin.GroupAddRemove) error {
-	return minioUpdateGroupMembersMock(req)
-}
-
-func (ac AdminClientMock) getGroupDescription(_ context.Context, group string) (*madmin.GroupDesc, error) {
-	return minioGetGroupDescriptionMock(group)
-}
-
-func (ac AdminClientMock) setGroupStatus(_ context.Context, group string, status madmin.GroupStatus) error {
-	return minioSetGroupStatusMock(group, status)
-}
-
-func (ac AdminClientMock) heal(ctx context.Context, bucket, prefix string, healOpts madmin.HealOpts, clientToken string,
-	forceStart, forceStop bool,
-) (healStart madmin.HealStartSuccess, healTaskStatus madmin.HealTaskStatus, err error) {
-	return minioHealMock(ctx, bucket, prefix, healOpts, clientToken, forceStart, forceStop)
-}
-
-func (ac AdminClientMock) serverHealthInfo(ctx context.Context, deadline time.Duration) (interface{}, string, error) {
-	return minioServerHealthInfoMock(ctx, deadline)
-}
-
-func (ac AdminClientMock) addOrUpdateIDPConfig(_ context.Context, _, _, _ string, _ bool) (restart bool, err error) {
-	return true, nil
-}
-
-func (ac AdminClientMock) listIDPConfig(_ context.Context, _ string) ([]madmin.IDPListItem, error) {
-	return []madmin.IDPListItem{{Name: "mock"}}, nil
-}
-
-func (ac AdminClientMock) deleteIDPConfig(_ context.Context, _, _ string) (restart bool, err error) {
-	return true, nil
-}
-
-func (ac AdminClientMock) getIDPConfig(_ context.Context, _, _ string) (c madmin.IDPConfig, err error) {
-	return madmin.IDPConfig{Info: []madmin.IDPCfgInfo{{Key: "mock", Value: "mock"}}}, nil
 }
 
 func (ac AdminClientMock) kmsStatus(_ context.Context) (madmin.KMSStatus, error) {
 	return madmin.KMSStatus{Name: "name", DefaultKeyID: "key", Endpoints: map[string]madmin.ItemState{"localhost": madmin.ItemState("online")}}, nil
 }
 
-func (ac AdminClientMock) kmsAPIs(_ context.Context) ([]madmin.KMSAPI, error) {
-	return []madmin.KMSAPI{{Method: "GET", Path: "/mock"}}, nil
-}
-
-func (ac AdminClientMock) kmsMetrics(_ context.Context) (*madmin.KMSMetrics, error) {
-	return &madmin.KMSMetrics{}, nil
-}
-
-func (ac AdminClientMock) kmsVersion(_ context.Context) (*madmin.KMSVersion, error) {
-	return &madmin.KMSVersion{Version: "test-version"}, nil
-}
-
-func (ac AdminClientMock) createKey(_ context.Context, _ string) error {
-	return nil
-}
-
-func (ac AdminClientMock) listKeys(_ context.Context, _ string) ([]madmin.KMSKeyInfo, error) {
-	return []madmin.KMSKeyInfo{{
-		Name:      "name",
-		CreatedBy: "by",
-	}}, nil
-}
-
-func (ac AdminClientMock) keyStatus(_ context.Context, _ string) (*madmin.KMSKeyStatus, error) {
-	return &madmin.KMSKeyStatus{KeyID: "key"}, nil
-}
-
-func (ac AdminClientMock) listPolicies(_ context.Context) (map[string]*iampolicy.Policy, error) {
-	return minioListPoliciesMock()
-}
-
-func (ac AdminClientMock) getPolicy(_ context.Context, name string) (*iampolicy.Policy, error) {
-	return minioGetPolicyMock(name)
-}
-
-func (ac AdminClientMock) removePolicy(_ context.Context, name string) error {
-	return minioRemovePolicyMock(name)
-}
-
-func (ac AdminClientMock) addPolicy(_ context.Context, name string, policy *iampolicy.Policy) error {
-	return minioAddPolicyMock(name, policy)
-}
-
-func (ac AdminClientMock) setPolicy(_ context.Context, policyName, entityName string, isGroup bool) error {
-	return minioSetPolicyMock(policyName, entityName, isGroup)
-}
-
-// mock function for startProfiling()
-func (ac AdminClientMock) startProfiling(_ context.Context, profiler madmin.ProfilerType) ([]madmin.StartProfilingResult, error) {
-	return minioStartProfiling(profiler)
-}
-
-// mock function for stopProfiling()
-func (ac AdminClientMock) stopProfiling(_ context.Context) (io.ReadCloser, error) {
-	return minioStopProfiling()
-}
-
-// mock function of serviceRestart()
-func (ac AdminClientMock) serviceRestart(ctx context.Context) error {
-	return minioServiceRestartMock(ctx)
-}
-
-func (ac AdminClientMock) getSiteReplicationInfo(ctx context.Context) (*madmin.SiteReplicationInfo, error) {
-	return getSiteReplicationInfo(ctx)
-}
-
-func (ac AdminClientMock) addSiteReplicationInfo(ctx context.Context, sites []madmin.PeerSite, _ madmin.SRAddOptions) (*madmin.ReplicateAddStatus, error) {
-	return addSiteReplicationInfo(ctx, sites)
-}
-
-func (ac AdminClientMock) editSiteReplicationInfo(ctx context.Context, site madmin.PeerInfo, _ madmin.SREditOptions) (*madmin.ReplicateEditStatus, error) {
-	return editSiteReplicationInfo(ctx, site)
-}
-
-func (ac AdminClientMock) deleteSiteReplicationInfo(ctx context.Context, removeReq madmin.SRRemoveReq) (*madmin.ReplicateRemoveStatus, error) {
-	return deleteSiteReplicationInfoMock(ctx, removeReq)
-}
-
-func (ac AdminClientMock) getSiteReplicationStatus(ctx context.Context, params madmin.SRStatusOptions) (*madmin.SRStatusInfo, error) {
-	return getSiteReplicationStatus(ctx, params)
-}
-
-func (ac AdminClientMock) listTiers(ctx context.Context) ([]*madmin.TierConfig, error) {
-	return minioListTiersMock(ctx)
-}
-
-func (ac AdminClientMock) tierStats(ctx context.Context) ([]madmin.TierInfo, error) {
-	return minioTierStatsMock(ctx)
-}
-
-func (ac AdminClientMock) addTier(ctx context.Context, tier *madmin.TierConfig) error {
-	return minioAddTiersMock(ctx, tier)
-}
-
-func (ac AdminClientMock) removeTier(ctx context.Context, tierName string) error {
-	return minioRemoveTierMock(ctx, tierName)
-}
-
-func (ac AdminClientMock) editTierCreds(ctx context.Context, tierName string, creds madmin.TierCreds) error {
-	return minioEditTiersMock(ctx, tierName, creds)
-}
-
-func (ac AdminClientMock) serviceTrace(ctx context.Context, threshold int64, s3, internal, storage, os, errTrace bool) <-chan madmin.ServiceTraceInfo {
-	return minioServiceTraceMock(ctx, threshold, s3, internal, storage, os, errTrace)
-}
-
-func (ac AdminClientMock) listUsers(_ context.Context) (map[string]madmin.UserInfo, error) {
-	return minioListUsersMock()
-}
-
-func (ac AdminClientMock) addUser(_ context.Context, accessKey, secretKey string) error {
-	return minioAddUserMock(accessKey, secretKey)
-}
-
-func (ac AdminClientMock) removeUser(_ context.Context, accessKey string) error {
-	return minioRemoveUserMock(accessKey)
-}
-
-func (ac AdminClientMock) getUserInfo(_ context.Context, accessKey string) (madmin.UserInfo, error) {
-	return minioGetUserInfoMock(accessKey)
-}
-
-func (ac AdminClientMock) setUserStatus(_ context.Context, accessKey string, status madmin.AccountStatus) error {
-	return minioSetUserStatusMock(accessKey, status)
-}
-
 func (ac AdminClientMock) AccountInfo(ctx context.Context) (madmin.AccountInfo, error) {
-	return minioAccountInfoMock(ctx)
+	return ac.minioAccountInfoMock(ctx)
-}
-
-func (ac AdminClientMock) addServiceAccount(ctx context.Context, policy string, user string, accessKey string, secretKey string, description string, name string, expiry *time.Time, status string) (madmin.Credentials, error) {
-	return minioAddServiceAccountMock(ctx, policy, user, accessKey, secretKey, description, name, expiry, status)
-}
-
-func (ac AdminClientMock) listServiceAccounts(ctx context.Context, user string) (madmin.ListServiceAccountsResp, error) {
-	return minioListServiceAccountsMock(ctx, user)
-}
-
-func (ac AdminClientMock) deleteServiceAccount(ctx context.Context, serviceAccount string) error {
-	return minioDeleteServiceAccountMock(ctx, serviceAccount)
-}
-
-func (ac AdminClientMock) infoServiceAccount(ctx context.Context, serviceAccount string) (madmin.InfoServiceAccountResp, error) {
-	return minioInfoServiceAccountMock(ctx, serviceAccount)
-}
-
-func (ac AdminClientMock) updateServiceAccount(ctx context.Context, serviceAccount string, opts madmin.UpdateServiceAccountReq) error {
-	return minioUpdateServiceAccountMock(ctx, serviceAccount, opts)
-}
-
-func (ac AdminClientMock) getLDAPPolicyEntities(ctx context.Context, query madmin.PolicyEntitiesQuery) (madmin.PolicyEntitiesResult, error) {
-	return minioGetLDAPPolicyEntitiesMock(ctx, query)
 }

api/admin_config.go

@@ -1,316 +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 api
-
-import (
-	"context"
-	"encoding/base64"
-	"fmt"
-	"strings"
-
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/swag"
-	"github.com/minio/console/api/operations"
-	"github.com/minio/console/models"
-	madmin "github.com/minio/madmin-go/v3"
-
-	cfgApi "github.com/minio/console/api/operations/configuration"
-)
-
-func registerConfigHandlers(api *operations.ConsoleAPI) {
-	// List Configurations
-	api.ConfigurationListConfigHandler = cfgApi.ListConfigHandlerFunc(func(params cfgApi.ListConfigParams, session *models.Principal) middleware.Responder {
-		configListResp, err := getListConfigResponse(session, params)
-		if err != nil {
-			return cfgApi.NewListConfigDefault(err.Code).WithPayload(err.APIError)
-		}
-		return cfgApi.NewListConfigOK().WithPayload(configListResp)
-	})
-	// Configuration Info
-	api.ConfigurationConfigInfoHandler = cfgApi.ConfigInfoHandlerFunc(func(params cfgApi.ConfigInfoParams, session *models.Principal) middleware.Responder {
-		config, err := getConfigResponse(session, params)
-		if err != nil {
-			return cfgApi.NewConfigInfoDefault(err.Code).WithPayload(err.APIError)
-		}
-		return cfgApi.NewConfigInfoOK().WithPayload(config)
-	})
-	// Set Configuration
-	api.ConfigurationSetConfigHandler = cfgApi.SetConfigHandlerFunc(func(params cfgApi.SetConfigParams, session *models.Principal) middleware.Responder {
-		resp, err := setConfigResponse(session, params)
-		if err != nil {
-			return cfgApi.NewSetConfigDefault(err.Code).WithPayload(err.APIError)
-		}
-		return cfgApi.NewSetConfigOK().WithPayload(resp)
-	})
-	// Reset Configuration
-	api.ConfigurationResetConfigHandler = cfgApi.ResetConfigHandlerFunc(func(params cfgApi.ResetConfigParams, session *models.Principal) middleware.Responder {
-		resp, err := resetConfigResponse(session, params)
-		if err != nil {
-			return cfgApi.NewResetConfigDefault(err.Code).WithPayload(err.APIError)
-		}
-		return cfgApi.NewResetConfigOK().WithPayload(resp)
-	})
-	// Export Configuration as base64 string.
-	api.ConfigurationExportConfigHandler = cfgApi.ExportConfigHandlerFunc(func(params cfgApi.ExportConfigParams, session *models.Principal) middleware.Responder {
-		resp, err := exportConfigResponse(session, params)
-		if err != nil {
-			return cfgApi.NewExportConfigDefault(err.Code).WithPayload(err.APIError)
-		}
-		return cfgApi.NewExportConfigOK().WithPayload(resp)
-	})
-	api.ConfigurationPostConfigsImportHandler = cfgApi.PostConfigsImportHandlerFunc(func(params cfgApi.PostConfigsImportParams, session *models.Principal) middleware.Responder {
-		_, err := importConfigResponse(session, params)
-		if err != nil {
-			return cfgApi.NewPostConfigsImportDefault(err.Code).WithPayload(err.APIError)
-		}
-		return cfgApi.NewPostConfigsImportDefault(200)
-	})
-}
-
-// listConfig gets all configurations' names and their descriptions
-func listConfig(client MinioAdmin) ([]*models.ConfigDescription, error) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	configKeysHelp, err := client.helpConfigKV(ctx, "", "", false)
-	if err != nil {
-		return nil, err
-	}
-	var configDescs []*models.ConfigDescription
-	for _, c := range configKeysHelp.KeysHelp {
-		desc := &models.ConfigDescription{
-			Key:         c.Key,
-			Description: c.Description,
-		}
-		configDescs = append(configDescs, desc)
-	}
-	return configDescs, nil
-}
-
-// getListConfigResponse performs listConfig() and serializes it to the handler's output
-func getListConfigResponse(session *models.Principal, params cfgApi.ListConfigParams) (*models.ListConfigResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	configDescs, err := listConfig(adminClient)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	listGroupsResponse := &models.ListConfigResponse{
-		Configurations: configDescs,
-		Total:          int64(len(configDescs)),
-	}
-	return listGroupsResponse, nil
-}
-
-// getConfig gets the key values for a defined configuration.
-func getConfig(ctx context.Context, client MinioAdmin, name string) ([]*models.Configuration, error) {
-	configBytes, err := client.getConfigKV(ctx, name)
-	if err != nil {
-		return nil, err
-	}
-	subSysConfigs, err := madmin.ParseServerConfigOutput(string(configBytes))
-	if err != nil {
-		return nil, err
-	}
-	var configSubSysList []*models.Configuration
-	for _, scfg := range subSysConfigs {
-		if !madmin.SubSystems.Contains(scfg.SubSystem) {
-			return nil, fmt.Errorf("no sub-systems found")
-		}
-		var confkv []*models.ConfigurationKV
-		for _, kv := range scfg.KV {
-			var envOverride *models.EnvOverride
-
-			if kv.EnvOverride != nil {
-				envOverride = &models.EnvOverride{
-					Name:  kv.EnvOverride.Name,
-					Value: kv.EnvOverride.Value,
-				}
-			}
-
-			confkv = append(confkv, &models.ConfigurationKV{Key: kv.Key, Value: kv.Value, EnvOverride: envOverride})
-		}
-		if len(confkv) == 0 {
-			continue
-		}
-		var fullConfigName string
-		if scfg.Target == "" {
-			fullConfigName = scfg.SubSystem
-		} else {
-			fullConfigName = scfg.SubSystem + ":" + scfg.Target
-		}
-		configSubSysList = append(configSubSysList, &models.Configuration{KeyValues: confkv, Name: fullConfigName})
-	}
-	return configSubSysList, nil
-}
-
-// getConfigResponse performs getConfig() and serializes it to the handler's output
-func getConfigResponse(session *models.Principal, params cfgApi.ConfigInfoParams) ([]*models.Configuration, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	configurations, err := getConfig(ctx, adminClient, params.Name)
-	if err != nil {
-		errorVal := ErrorWithContext(ctx, err)
-		minioError := madmin.ToErrorResponse(err)
-		if minioError.Code == "XMinioConfigError" {
-			errorVal.Code = 404
-		}
-		return nil, errorVal
-	}
-	return configurations, nil
-}
-
-// setConfig sets a configuration with the defined key values
-func setConfig(ctx context.Context, client MinioAdmin, configName *string, kvs []*models.ConfigurationKV) (restart bool, err error) {
-	config := buildConfig(configName, kvs)
-	restart, err = client.setConfigKV(ctx, *config)
-	if err != nil {
-		return false, err
-	}
-	return restart, nil
-}
-
-func setConfigWithARNAccountID(ctx context.Context, client MinioAdmin, configName *string, kvs []*models.ConfigurationKV, arnAccountID string) (restart bool, err error) {
-	// if arnAccountID is not empty the configuration will be treated as a notification target
-	// arnAccountID will be used as an identifier for that specific target
-	// docs: https://min.io/docs/minio/linux/administration/monitoring/bucket-notifications.html
-	if arnAccountID != "" {
-		configName = swag.String(fmt.Sprintf("%s:%s", *configName, arnAccountID))
-	}
-	return setConfig(ctx, client, configName, kvs)
-}
-
-// buildConfig builds a concatenated string including name and keyvalues
-// e.g. `region name=us-west-1`
-func buildConfig(configName *string, kvs []*models.ConfigurationKV) *string {
-	var builder strings.Builder
-	builder.WriteString(*configName)
-	for _, kv := range kvs {
-		key := strings.TrimSpace(kv.Key)
-		if key == "" {
-			continue
-		}
-		builder.WriteString(" ")
-		builder.WriteString(key)
-		builder.WriteString("=")
-		// All newlines must be converted to ','
-		builder.WriteString(strings.ReplaceAll(strings.TrimSpace(fmt.Sprintf("\"%s\"", kv.Value)), "\n", ","))
-	}
-	config := builder.String()
-	return &config
-}
-
-// setConfigResponse implements setConfig() to be used by handler
-func setConfigResponse(session *models.Principal, params cfgApi.SetConfigParams) (*models.SetConfigResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-	configName := params.Name
-
-	needsRestart, err := setConfigWithARNAccountID(ctx, adminClient, &configName, params.Body.KeyValues, params.Body.ArnResourceID)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return &models.SetConfigResponse{Restart: needsRestart}, nil
-}
-
-func resetConfig(ctx context.Context, client MinioAdmin, configName *string) (err error) {
-	err = client.delConfigKV(ctx, *configName)
-	return err
-}
-
-// resetConfigResponse implements resetConfig() to be used by handler
-func resetConfigResponse(session *models.Principal, params cfgApi.ResetConfigParams) (*models.SetConfigResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	err = resetConfig(ctx, adminClient, &params.Name)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	return &models.SetConfigResponse{Restart: true}, nil
-}
-
-func exportConfigResponse(session *models.Principal, params cfgApi.ExportConfigParams) (*models.ConfigExportResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	configRes, err := mAdmin.GetConfig(ctx)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// may contain sensitive information so unpack only when required.
-	return &models.ConfigExportResponse{
-		Status: "success",
-		Value:  base64.StdEncoding.EncodeToString(configRes),
-	}, nil
-}
-
-func importConfigResponse(session *models.Principal, params cfgApi.PostConfigsImportParams) (*cfgApi.PostConfigsImportDefault, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	file, _, err := params.HTTPRequest.FormFile("file")
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	defer file.Close()
-
-	err = mAdmin.SetConfig(ctx, file)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return &cfgApi.PostConfigsImportDefault{}, nil
-}

api/admin_config_test.go

@@ -1,609 +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 api
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"reflect"
-	"testing"
-
-	"github.com/go-openapi/swag"
-	"github.com/stretchr/testify/assert"
-
-	"github.com/minio/console/models"
-	"github.com/minio/madmin-go/v3"
-)
-
-const (
-	NotifyPostgresSubSys     = "notify_postgres"
-	PostgresFormat           = "format"
-	PostgresConnectionString = "connection_string"
-	PostgresTable            = "table"
-	PostgresQueueDir         = "queue_dir"
-	PostgresQueueLimit       = "queue_limit"
-)
-
-func TestListConfig(t *testing.T) {
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	function := "listConfig()"
-	// Test-1 : listConfig() get list of two configurations and ensure is output correctly
-	configListMock := []madmin.HelpKV{
-		{
-			Key:         "region",
-			Description: "label the location of the server",
-		},
-		{
-			Key:         "notify_nsq",
-			Description: "publish bucket notifications to NSQ endpoints",
-		},
-	}
-	mockConfigList := madmin.Help{
-		SubSys:          "sys",
-		Description:     "desc",
-		MultipleTargets: false,
-		KeysHelp:        configListMock,
-	}
-	expectedKeysDesc := mockConfigList.KeysHelp
-	// mock function response from listConfig()
-	minioHelpConfigKVMock = func(_, _ string, _ bool) (madmin.Help, error) {
-		return mockConfigList, nil
-	}
-	configList, err := listConfig(adminClient)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// verify length of keys is correct
-	assert.Equal(len(expectedKeysDesc), len(configList), fmt.Sprintf("Failed on %s: length of Configs's lists is not the same", function))
-	// verify KeysHelp content
-	for i, kv := range configList {
-		assert.Equal(expectedKeysDesc[i].Key, kv.Key)
-		assert.Equal(expectedKeysDesc[i].Description, kv.Description)
-	}
-
-	// Test-2 : listConfig() Return error and see that the error is handled correctly and returned
-	// mock function response from listConfig()
-	minioHelpConfigKVMock = func(_, _ string, _ bool) (madmin.Help, error) {
-		return madmin.Help{}, errors.New("error")
-	}
-	_, err = listConfig(adminClient)
-	if assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}
-
-func TestSetConfig(t *testing.T) {
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	function := "setConfig()"
-	// mock function response from setConfig()
-	minioSetConfigKVMock = func(_ string) (restart bool, err error) {
-		return false, nil
-	}
-	configName := "notify_postgres"
-	kvs := []*models.ConfigurationKV{
-		{
-			Key:   "enable",
-			Value: "off",
-		},
-		{
-			Key:   "connection_string",
-			Value: "",
-		},
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	// Test-1 : setConfig() sets a config with two key value pairs
-	restart, err := setConfig(ctx, adminClient, &configName, kvs)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	assert.Equal(restart, false)
-
-	// Test-2 : setConfig() returns error, handle properly
-	minioSetConfigKVMock = func(_ string) (restart bool, err error) {
-		return false, errors.New("error")
-	}
-	restart, err = setConfig(ctx, adminClient, &configName, kvs)
-	if assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-	assert.Equal(restart, false)
-
-	// Test-4 : setConfig() set config, need restart
-	minioSetConfigKVMock = func(_ string) (restart bool, err error) {
-		return true, nil
-	}
-	restart, err = setConfig(ctx, adminClient, &configName, kvs)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	assert.Equal(restart, true)
-}
-
-func TestDelConfig(t *testing.T) {
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	function := "resetConfig()"
-	// mock function response from setConfig()
-	minioDelConfigKVMock = func(_ string) (err error) {
-		return nil
-	}
-	configName := "region"
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	// Test-1 : resetConfig() resets a config with the config name
-	err := resetConfig(ctx, adminClient, &configName)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-
-	// Test-2 : resetConfig() returns error, handle properly
-	minioDelConfigKVMock = func(_ string) (err error) {
-		return errors.New("error")
-	}
-
-	err = resetConfig(ctx, adminClient, &configName)
-	if assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}
-
-func Test_buildConfig(t *testing.T) {
-	type args struct {
-		configName *string
-		kvs        []*models.ConfigurationKV
-	}
-	tests := []struct {
-		name string
-		args args
-		want *string
-	}{
-		// Test-1: buildConfig() format correctly configuration as "config_name k=v k2=v2"
-		{
-			name: "format correctly",
-			args: args{
-				configName: swag.String("notify_postgres"),
-				kvs: []*models.ConfigurationKV{
-					{
-						Key:   "enable",
-						Value: "off",
-					},
-					{
-						Key:   "connection_string",
-						Value: "",
-					},
-				},
-			},
-			want: swag.String("notify_postgres enable=\"off\" connection_string=\"\""),
-		},
-		// Test-2: buildConfig() format correctly configuration as "config_name k=v k2=v2 k2=v3" with duplicate keys
-		{
-			name: "duplicated keys in config",
-			args: args{
-				configName: swag.String("notify_postgres"),
-				kvs: []*models.ConfigurationKV{
-					{
-						Key:   "enable",
-						Value: "off",
-					},
-					{
-						Key:   "connection_string",
-						Value: "",
-					},
-					{
-						Key:   "connection_string",
-						Value: "x",
-					},
-				},
-			},
-			want: swag.String("notify_postgres enable=\"off\" connection_string=\"\" connection_string=\"x\""),
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(_ *testing.T) {
-			if got := buildConfig(tt.args.configName, tt.args.kvs); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("buildConfig() = %s, want %s", *got, *tt.want)
-			}
-		})
-	}
-}
-
-func Test_setConfigWithARN(t *testing.T) {
-	assert := assert.New(t)
-	client := AdminClientMock{}
-
-	type args struct {
-		ctx        context.Context
-		client     MinioAdmin
-		configName *string
-		kvs        []*models.ConfigurationKV
-		arn        string
-	}
-	tests := []struct {
-		name          string
-		args          args
-		mockSetConfig func(kv string) (restart bool, err error)
-		wantErr       bool
-		expected      bool
-	}{
-		{
-			name: "Set valid config with arn",
-			args: args{
-				ctx:        context.Background(),
-				client:     client,
-				configName: swag.String("notify_kafka"),
-				kvs: []*models.ConfigurationKV{
-					{
-						Key:   "brokers",
-						Value: "http://localhost:8080/broker1,http://localhost:8080/broker2",
-					},
-				},
-				arn: "1",
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, nil
-			},
-			wantErr:  false,
-			expected: false,
-		},
-		{
-			name: "Set valid config, expect restart",
-			args: args{
-				ctx:        context.Background(),
-				client:     client,
-				configName: swag.String("notify_kafka"),
-				kvs: []*models.ConfigurationKV{
-					{
-						Key:   "brokers",
-						Value: "http://localhost:8080/broker1,http://localhost:8080/broker2",
-					},
-				},
-				arn: "1",
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return true, nil
-			},
-			wantErr:  false,
-			expected: true,
-		},
-		{
-			name: "Set valid config without arn",
-			args: args{
-				ctx:        context.Background(),
-				client:     client,
-				configName: swag.String("region"),
-				kvs: []*models.ConfigurationKV{
-					{
-						Key:   "name",
-						Value: "us-west-1",
-					},
-				},
-				arn: "",
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, nil
-			},
-			wantErr:  false,
-			expected: false,
-		},
-		{
-			name: "Setting an incorrect config",
-			args: args{
-				ctx:        context.Background(),
-				client:     client,
-				configName: swag.String("oorgle"),
-				kvs: []*models.ConfigurationKV{
-					{
-						Key:   "name",
-						Value: "us-west-1",
-					},
-				},
-				arn: "",
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, errors.New("error")
-			},
-			wantErr:  true,
-			expected: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(_ *testing.T) {
-			// mock function response from setConfig()
-			minioSetConfigKVMock = tt.mockSetConfig
-			restart, err := setConfigWithARNAccountID(tt.args.ctx, tt.args.client, tt.args.configName, tt.args.kvs, tt.args.arn)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("setConfigWithARNAccountID() error = %v, wantErr %v", err, tt.wantErr)
-			}
-			assert.Equal(restart, tt.expected)
-		})
-	}
-}
-
-func Test_getConfig(t *testing.T) {
-	client := AdminClientMock{}
-	type args struct {
-		client MinioAdmin
-		name   string
-	}
-	tests := []struct {
-		name    string
-		args    args
-		mock    func()
-		want    []*models.Configuration
-		wantErr bool
-	}{
-		{
-			name: "get config",
-			args: args{
-				client: client,
-				name:   "notify_postgres",
-			},
-			mock: func() {
-				// mock function response from getConfig()
-				minioGetConfigKVMock = func(_ string) ([]byte, error) {
-					return []byte(`notify_postgres:_ connection_string="host=localhost dbname=minio_events user=postgres password=password port=5432 sslmode=disable" table=bucketevents`), nil
-				}
-
-				configListMock := []madmin.HelpKV{
-					{
-						Key:         PostgresConnectionString,
-						Description: `Postgres server connection-string e.g. "host=localhost port=5432 dbname=minio_events user=postgres password=password sslmode=disable"`,
-						Type:        "string",
-					},
-					{
-						Key:         PostgresTable,
-						Description: "DB table name to store/update events, table is auto-created",
-						Type:        "string",
-					},
-					{
-						Key:         PostgresFormat,
-						Description: "desc",
-						Type:        "namespace*|access",
-					},
-					{
-						Key:         PostgresQueueDir,
-						Description: "des",
-						Optional:    true,
-						Type:        "path",
-					},
-					{
-						Key:         PostgresQueueLimit,
-						Description: "desc",
-						Optional:    true,
-						Type:        "number",
-					},
-					{
-						Key:         madmin.CommentKey,
-						Description: "",
-						Optional:    true,
-						Type:        "sentence",
-					},
-				}
-				mockConfigList := madmin.Help{
-					SubSys:          NotifyPostgresSubSys,
-					Description:     "publish bucket notifications to Postgres databases",
-					MultipleTargets: true,
-					KeysHelp:        configListMock,
-				}
-				// mock function response from listConfig()
-				minioHelpConfigKVMock = func(_, _ string, _ bool) (madmin.Help, error) {
-					return mockConfigList, nil
-				}
-			},
-			want: []*models.Configuration{
-				{
-					KeyValues: []*models.ConfigurationKV{
-						{
-							Key:   PostgresConnectionString,
-							Value: "host=localhost dbname=minio_events user=postgres password=password port=5432 sslmode=disable",
-						},
-						{
-							Key:   PostgresTable,
-							Value: "bucketevents",
-						},
-					}, Name: "notify_postgres",
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "valid config, but server returned empty",
-			args: args{
-				client: client,
-				name:   NotifyPostgresSubSys,
-			},
-			mock: func() {
-				// mock function response from getConfig()
-				minioGetConfigKVMock = func(_ string) ([]byte, error) {
-					return []byte(`notify_postgres:_`), nil
-				}
-
-				configListMock := []madmin.HelpKV{
-					{
-						Key:         PostgresConnectionString,
-						Description: `Postgres server connection-string e.g. "host=localhost port=5432 dbname=minio_events user=postgres password=password sslmode=disable"`,
-						Type:        "string",
-					},
-					{
-						Key:         PostgresTable,
-						Description: "DB table name to store/update events, table is auto-created",
-						Type:        "string",
-					},
-					{
-						Key:         PostgresFormat,
-						Description: "desc",
-						Type:        "namespace*|access",
-					},
-					{
-						Key:         PostgresQueueDir,
-						Description: "des",
-						Optional:    true,
-						Type:        "path",
-					},
-					{
-						Key:         PostgresQueueLimit,
-						Description: "desc",
-						Optional:    true,
-						Type:        "number",
-					},
-					{
-						Key:         madmin.CommentKey,
-						Description: "optionally add a comment to this setting",
-						Optional:    true,
-						Type:        "sentence",
-					},
-				}
-				mockConfigList := madmin.Help{
-					SubSys:          NotifyPostgresSubSys,
-					Description:     "publish bucket notifications to Postgres databases",
-					MultipleTargets: true,
-					KeysHelp:        configListMock,
-				}
-				// mock function response from listConfig()
-				minioHelpConfigKVMock = func(_, _ string, _ bool) (madmin.Help, error) {
-					return mockConfigList, nil
-				}
-			},
-			want:    nil,
-			wantErr: false,
-		},
-		{
-			name: "random bytes coming out of getConfigKv",
-			args: args{
-				client: client,
-				name:   "notify_postgres",
-			},
-			mock: func() {
-				// mock function response from getConfig()
-				minioGetConfigKVMock = func(_ string) ([]byte, error) {
-					x := make(map[string]string)
-					x["x"] = "x"
-					j, _ := json.Marshal(x)
-					return j, nil
-				}
-
-				configListMock := []madmin.HelpKV{
-					{
-						Key:         PostgresConnectionString,
-						Description: `Postgres server connection-string e.g. "host=localhost port=5432 dbname=minio_events user=postgres password=password sslmode=disable"`,
-						Type:        "string",
-					},
-					{
-						Key:         PostgresTable,
-						Description: "DB table name to store/update events, table is auto-created",
-						Type:        "string",
-					},
-					{
-						Key:         PostgresFormat,
-						Description: "desc",
-						Type:        "namespace*|access",
-					},
-					{
-						Key:         PostgresQueueDir,
-						Description: "des",
-						Optional:    true,
-						Type:        "path",
-					},
-					{
-						Key:         PostgresQueueLimit,
-						Description: "desc",
-						Optional:    true,
-						Type:        "number",
-					},
-					{
-						Key:         madmin.CommentKey,
-						Description: "optionally add a comment to this setting",
-						Optional:    true,
-						Type:        "sentence",
-					},
-				}
-				mockConfigList := madmin.Help{
-					SubSys:          NotifyPostgresSubSys,
-					Description:     "publish bucket notifications to Postgres databases",
-					MultipleTargets: true,
-					KeysHelp:        configListMock,
-				}
-				// mock function response from listConfig()
-				minioHelpConfigKVMock = func(_, _ string, _ bool) (madmin.Help, error) {
-					return mockConfigList, nil
-				}
-			},
-			want:    nil,
-			wantErr: true,
-		},
-		{
-			name: "bad config",
-			args: args{
-				client: client,
-				name:   "notify_postgresx",
-			},
-			mock: func() {
-				// mock function response from getConfig()
-				minioGetConfigKVMock = func(_ string) ([]byte, error) {
-					return nil, errors.New("invalid config")
-				}
-
-				mockConfigList := madmin.Help{}
-				// mock function response from listConfig()
-				minioHelpConfigKVMock = func(_, _ string, _ bool) (madmin.Help, error) {
-					return mockConfigList, nil
-				}
-			},
-			want:    nil,
-			wantErr: true,
-		},
-		{
-			name: "no help",
-			args: args{
-				client: client,
-				name:   "notify_postgresx",
-			},
-			mock: func() {
-				// mock function response from getConfig()
-				minioGetConfigKVMock = func(_ string) ([]byte, error) {
-					return nil, errors.New("invalid config")
-				}
-				// mock function response from listConfig()
-				minioHelpConfigKVMock = func(_, _ string, _ bool) (madmin.Help, error) {
-					return madmin.Help{}, errors.New("no help")
-				}
-			},
-			want:    nil,
-			wantErr: true,
-		},
-	}
-	for _, tt := range tests {
-		tt.mock()
-		t.Run(tt.name, func(_ *testing.T) {
-			got, err := getConfig(context.Background(), tt.args.client, tt.args.name)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("getConfig() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("getConfig() got = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}

api/admin_console.go

@@ -1,104 +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 api
-
-import (
-	"context"
-	"encoding/json"
-	"strings"
-	"time"
-
-	"github.com/minio/madmin-go/v3"
-	"github.com/minio/websocket"
-)
-
-const logTimeFormat string = "15:04:05 MST 01/02/2006"
-
-// startConsoleLog starts log of the servers
-func startConsoleLog(ctx context.Context, conn WSConn, client MinioAdmin, logRequest LogRequest) error {
-	var node string
-	// name of node, default = "" (all)
-	if logRequest.node == "all" {
-		node = ""
-	} else {
-		node = logRequest.node
-	}
-
-	trimNode := strings.Split(node, ":")
-	// number of log lines
-	lineCount := 100
-	// type of logs "minio"|"application"|"all" default = "all"
-	var logKind string
-	if logRequest.logType == "minio" || logRequest.logType == "application" || logRequest.logType == "all" {
-		logKind = logRequest.logType
-	} else {
-		logKind = "all"
-	}
-
-	// Start listening on all Console Log activity.
-	logCh := client.getLogs(ctx, trimNode[0], lineCount, logKind)
-
-	for {
-		select {
-		case <-ctx.Done():
-			return nil
-		case logInfo, ok := <-logCh:
-
-			// zero value returned because the channel is closed and empty
-			if !ok {
-				return nil
-			}
-			if logInfo.Err != nil {
-				LogError("error on console logs: %v", logInfo.Err)
-				return logInfo.Err
-			}
-
-			// Serialize message to be sent
-			bytes, err := json.Marshal(serializeConsoleLogInfo(&logInfo))
-			if err != nil {
-				LogError("error on json.Marshal: %v", err)
-				return err
-			}
-
-			// Send Message through websocket connection
-			err = conn.writeMessage(websocket.TextMessage, bytes)
-			if err != nil {
-				LogError("error writeMessage: %v", err)
-				return err
-			}
-		}
-	}
-}
-
-func serializeConsoleLogInfo(l *madmin.LogInfo) (logInfo madmin.LogInfo) {
-	logInfo = *l
-	if logInfo.ConsoleMsg != "" {
-		logInfo.ConsoleMsg = strings.TrimPrefix(logInfo.ConsoleMsg, "\n")
-	}
-	if logInfo.Time != "" {
-		logInfo.Time = getLogTime(logInfo.Time)
-	}
-	return logInfo
-}
-
-func getLogTime(lt string) string {
-	tm, err := time.Parse(time.RFC3339Nano, lt)
-	if err != nil {
-		return lt
-	}
-	return tm.Format(logTimeFormat)
-}

api/admin_console_test.go

@@ -1,117 +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 api
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"testing"
-
-	"github.com/minio/madmin-go/v3"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestAdminConsoleLog(t *testing.T) {
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	mockWSConn := mockConn{}
-	function := "startConsoleLog(ctx, )"
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	testReceiver := make(chan madmin.LogInfo, 5)
-	textToReceive := "test message"
-	testStreamSize := 5
-	isClosed := false // testReceiver is closed?
-
-	// Test-1: Serve Console with no errors until Console finishes sending
-	// define mock function behavior for minio server Console
-	minioGetLogsMock = func(_ context.Context, _ string, _ int, _ string) <-chan madmin.LogInfo {
-		ch := make(chan madmin.LogInfo)
-		// Only success, start a routine to start reading line by line.
-		go func(ch chan<- madmin.LogInfo) {
-			defer close(ch)
-			lines := make([]int, testStreamSize)
-			// mocking sending 5 lines of info
-			for range lines {
-				info := madmin.LogInfo{
-					ConsoleMsg: textToReceive,
-				}
-				ch <- info
-			}
-		}(ch)
-		return ch
-	}
-	writesCount := 1
-	// mock connection WriteMessage() no error
-	connWriteMessageMock = func(_ int, data []byte) error {
-		// emulate that receiver gets the message written
-		var t madmin.LogInfo
-		_ = json.Unmarshal(data, &t)
-		if writesCount == testStreamSize {
-			if !isClosed {
-				close(testReceiver)
-				isClosed = true
-			}
-			return nil
-		}
-		testReceiver <- t
-		writesCount++
-		return nil
-	}
-	if err := startConsoleLog(ctx, mockWSConn, adminClient, LogRequest{node: "", logType: "all"}); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// check that the TestReceiver got the same number of data from Console.
-	for i := range testReceiver {
-		assert.Equal(textToReceive, i.ConsoleMsg)
-	}
-
-	// Test-2: if error happens while writing, return error
-	connWriteMessageMock = func(_ int, _ []byte) error {
-		return fmt.Errorf("error on write")
-	}
-	if err := startConsoleLog(ctx, mockWSConn, adminClient, LogRequest{node: "", logType: "all"}); assert.Error(err) {
-		assert.Equal("error on write", err.Error())
-	}
-
-	// Test-3: error happens on GetLogs Minio, Console should stop
-	// and error shall be returned.
-	minioGetLogsMock = func(_ context.Context, _ string, _ int, _ string) <-chan madmin.LogInfo {
-		ch := make(chan madmin.LogInfo)
-		// Only success, start a routine to start reading line by line.
-		go func(ch chan<- madmin.LogInfo) {
-			defer close(ch)
-			lines := make([]int, 2)
-			// mocking sending 5 lines of info
-			for range lines {
-				info := madmin.LogInfo{
-					ConsoleMsg: textToReceive,
-				}
-				ch <- info
-			}
-			ch <- madmin.LogInfo{Err: fmt.Errorf("error on Console")}
-		}(ch)
-		return ch
-	}
-	connWriteMessageMock = func(_ int, _ []byte) error {
-		return nil
-	}
-	if err := startConsoleLog(ctx, mockWSConn, adminClient, LogRequest{node: "", logType: "all"}); assert.Error(err) {
-		assert.Equal("error on Console", err.Error())
-	}
-}

api/admin_groups.go

@@ -1,339 +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 api
-
-import (
-	"context"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/minio/console/api/operations"
-	"github.com/minio/madmin-go/v3"
-
-	groupApi "github.com/minio/console/api/operations/group"
-
-	"github.com/minio/console/models"
-)
-
-func registerGroupsHandlers(api *operations.ConsoleAPI) {
-	// List Groups
-	api.GroupListGroupsHandler = groupApi.ListGroupsHandlerFunc(func(params groupApi.ListGroupsParams, session *models.Principal) middleware.Responder {
-		listGroupsResponse, err := getListGroupsResponse(session, params)
-		if err != nil {
-			return groupApi.NewListGroupsDefault(err.Code).WithPayload(err.APIError)
-		}
-		return groupApi.NewListGroupsOK().WithPayload(listGroupsResponse)
-	})
-	// Group Info
-	api.GroupGroupInfoHandler = groupApi.GroupInfoHandlerFunc(func(params groupApi.GroupInfoParams, session *models.Principal) middleware.Responder {
-		groupInfo, err := getGroupInfoResponse(session, params)
-		if err != nil {
-			return groupApi.NewGroupInfoDefault(err.Code).WithPayload(err.APIError)
-		}
-		return groupApi.NewGroupInfoOK().WithPayload(groupInfo)
-	})
-	// Add Group
-	api.GroupAddGroupHandler = groupApi.AddGroupHandlerFunc(func(params groupApi.AddGroupParams, session *models.Principal) middleware.Responder {
-		if err := getAddGroupResponse(session, params); err != nil {
-			return groupApi.NewAddGroupDefault(err.Code).WithPayload(err.APIError)
-		}
-		return groupApi.NewAddGroupCreated()
-	})
-	// Remove Group
-	api.GroupRemoveGroupHandler = groupApi.RemoveGroupHandlerFunc(func(params groupApi.RemoveGroupParams, session *models.Principal) middleware.Responder {
-		if err := getRemoveGroupResponse(session, params); err != nil {
-			return groupApi.NewRemoveGroupDefault(err.Code).WithPayload(err.APIError)
-		}
-		return groupApi.NewRemoveGroupNoContent()
-	})
-	// Update Group
-	api.GroupUpdateGroupHandler = groupApi.UpdateGroupHandlerFunc(func(params groupApi.UpdateGroupParams, session *models.Principal) middleware.Responder {
-		groupUpdateResp, err := getUpdateGroupResponse(session, params)
-		if err != nil {
-			return groupApi.NewUpdateGroupDefault(err.Code).WithPayload(err.APIError)
-		}
-		return groupApi.NewUpdateGroupOK().WithPayload(groupUpdateResp)
-	})
-}
-
-// getListGroupsResponse performs listGroups() and serializes it to the handler's output
-func getListGroupsResponse(session *models.Principal, params groupApi.ListGroupsParams) (*models.ListGroupsResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	groups, err := adminClient.listGroups(ctx)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	// serialize output
-	listGroupsResponse := &models.ListGroupsResponse{
-		Groups: groups,
-		Total:  int64(len(groups)),
-	}
-
-	return listGroupsResponse, nil
-}
-
-// groupInfo calls MinIO server get Group's info
-func groupInfo(ctx context.Context, client MinioAdmin, group string) (*madmin.GroupDesc, error) {
-	groupDesc, err := client.getGroupDescription(ctx, group)
-	if err != nil {
-		return nil, err
-	}
-	return groupDesc, nil
-}
-
-// getGroupInfoResponse performs groupInfo() and serializes it to the handler's output
-func getGroupInfoResponse(session *models.Principal, params groupApi.GroupInfoParams) (*models.Group, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	groupDesc, err := groupInfo(ctx, adminClient, params.Name)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	groupResponse := &models.Group{
-		Members: groupDesc.Members,
-		Name:    groupDesc.Name,
-		Policy:  groupDesc.Policy,
-		Status:  groupDesc.Status,
-	}
-
-	return groupResponse, nil
-}
-
-// addGroupAdd a MinIO group with the defined members
-func addGroup(ctx context.Context, client MinioAdmin, group string, members []string) error {
-	gAddRemove := madmin.GroupAddRemove{
-		Group:    group,
-		Members:  members,
-		IsRemove: false,
-	}
-	err := client.updateGroupMembers(ctx, gAddRemove)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// getAddGroupResponse performs addGroup() and serializes it to the handler's output
-func getAddGroupResponse(session *models.Principal, params groupApi.AddGroupParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	// AddGroup request needed to proceed
-	if params.Body == nil {
-		return ErrorWithContext(ctx, ErrGroupBodyNotInRequest)
-	}
-	groupRequest := params.Body
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	groupList, _ := adminClient.listGroups(ctx)
-
-	for _, b := range groupList {
-		if b == *groupRequest.Group {
-			return ErrorWithContext(ctx, ErrGroupAlreadyExists)
-		}
-	}
-
-	if err := addGroup(ctx, adminClient, *groupRequest.Group, groupRequest.Members); err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	return nil
-}
-
-// removeGroup deletes a minIO group only if it has no members
-func removeGroup(ctx context.Context, client MinioAdmin, group string) error {
-	gAddRemove := madmin.GroupAddRemove{
-		Group:    group,
-		Members:  []string{},
-		IsRemove: true,
-	}
-	err := client.updateGroupMembers(ctx, gAddRemove)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// getRemoveGroupResponse performs removeGroup() and serializes it to the handler's output
-func getRemoveGroupResponse(session *models.Principal, params groupApi.RemoveGroupParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	if params.Name == "" {
-		return ErrorWithContext(ctx, ErrGroupNameNotInRequest)
-	}
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	// Create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	if err := removeGroup(ctx, adminClient, params.Name); err != nil {
-		minioError := madmin.ToErrorResponse(err)
-		err2 := ErrorWithContext(ctx, err)
-		if minioError.Code == "XMinioAdminNoSuchGroup" {
-			err2.Code = 404
-		}
-		return err2
-	}
-	return nil
-}
-
-// updateGroup updates a group by adding/removing members and setting the status to the desired one
-//
-// isRemove: whether remove members or not
-func updateGroupMembers(ctx context.Context, client MinioAdmin, group string, members []string, isRemove bool) error {
-	gAddRemove := madmin.GroupAddRemove{
-		Group:    group,
-		Members:  members,
-		IsRemove: isRemove,
-	}
-	err := client.updateGroupMembers(ctx, gAddRemove)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// addOrDeleteMembers updates a group members by adding or deleting them based on the expectedMembers
-func addOrDeleteMembers(ctx context.Context, client MinioAdmin, group *madmin.GroupDesc, expectedMembers []string) error {
-	// get members to delete/add
-	membersToDelete := DifferenceArrays(group.Members, expectedMembers)
-	membersToAdd := DifferenceArrays(expectedMembers, group.Members)
-	// delete members if any to be deleted
-	if len(membersToDelete) > 0 {
-		err := updateGroupMembers(ctx, client, group.Name, membersToDelete, true)
-		if err != nil {
-			return err
-		}
-	}
-	// add members if any to be added
-	if len(membersToAdd) > 0 {
-		err := updateGroupMembers(ctx, client, group.Name, membersToAdd, false)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func setGroupStatus(ctx context.Context, client MinioAdmin, group, status string) error {
-	var setStatus madmin.GroupStatus
-	switch status {
-	case "enabled":
-		setStatus = madmin.GroupEnabled
-	case "disabled":
-		setStatus = madmin.GroupDisabled
-	default:
-		return errors.New(500, "status not valid")
-	}
-	return client.setGroupStatus(ctx, group, setStatus)
-}
-
-// getUpdateGroupResponse updates a group by adding or removing it's members depending on the request,
-// also sets the group's status if status in the request is different than the current one.
-// Then serializes the output to be used by the handler.
-func getUpdateGroupResponse(session *models.Principal, params groupApi.UpdateGroupParams) (*models.Group, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	if params.Name == "" {
-		return nil, ErrorWithContext(ctx, ErrGroupNameNotInRequest)
-	}
-	if params.Body == nil {
-		return nil, ErrorWithContext(ctx, ErrGroupBodyNotInRequest)
-	}
-	expectedGroupUpdate := params.Body
-
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	groupUpdated, err := groupUpdate(ctx, adminClient, params.Name, expectedGroupUpdate)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	groupResponse := &models.Group{
-		Name:    groupUpdated.Name,
-		Members: groupUpdated.Members,
-		Policy:  groupUpdated.Policy,
-		Status:  groupUpdated.Status,
-	}
-	return groupResponse, nil
-}
-
-// groupUpdate updates a group given the expected parameters, compares the expected parameters against the current ones
-// and updates them accordingly, status is only updated if the expected status is different than the current one.
-// Then fetches the group again to return the object updated.
-func groupUpdate(ctx context.Context, client MinioAdmin, groupName string, expectedGroup *models.UpdateGroupRequest) (*madmin.GroupDesc, error) {
-	expectedMembers := expectedGroup.Members
-	expectedStatus := *expectedGroup.Status
-	// get current members and status
-	groupDescription, err := groupInfo(ctx, client, groupName)
-	if err != nil {
-		LogInfo("error getting group info: %v", err)
-		return nil, err
-	}
-	// update group members
-	err = addOrDeleteMembers(ctx, client, groupDescription, expectedMembers)
-	if err != nil {
-		LogInfo("error updating group: %v", err)
-		return nil, err
-	}
-	// update group status only if different from current status
-	if expectedStatus != groupDescription.Status {
-		err = setGroupStatus(ctx, client, groupDescription.Name, expectedStatus)
-		if err != nil {
-			LogInfo("error updating group's status: %v", err)
-			return nil, err
-		}
-	}
-	// return latest group info to verify that changes were applied correctly
-	groupDescription, err = groupInfo(ctx, client, groupName)
-	if err != nil {
-		LogInfo("error getting group info: %v", err)
-		return nil, err
-	}
-	return groupDescription, nil
-}

api/admin_groups_test.go

@@ -1,291 +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 api
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"testing"
-
-	"github.com/go-openapi/swag"
-	"github.com/minio/console/models"
-	"github.com/minio/madmin-go/v3"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestListGroups(t *testing.T) {
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	// Test-1 : listGroups() Get response from minio client with two Groups and return the same number on listGroups()
-	mockGroupsList := []string{"group1", "group2"}
-
-	// mock function response from listGroups()
-	minioListGroupsMock = func() ([]string, error) {
-		return mockGroupsList, nil
-	}
-	// get list Groups response this response should have Name, CreationDate, Size and Access
-	// as part of of each Groups
-	function := "listGroups()"
-	groupsList, err := adminClient.listGroups(ctx)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// verify length of Groupss is correct
-	assert.Equal(len(mockGroupsList), len(groupsList), fmt.Sprintf("Failed on %s: length of Groups's lists is not the same", function))
-
-	for i, g := range groupsList {
-		assert.Equal(mockGroupsList[i], g)
-	}
-
-	// Test-2 : listGroups() Return error and see that the error is handled correctly and returned
-	minioListGroupsMock = func() ([]string, error) {
-		return nil, errors.New("error")
-	}
-	_, err = adminClient.listGroups(ctx)
-	if assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}
-
-func TestAddGroup(t *testing.T) {
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	// Test-1 : addGroup() add a new group with two members
-	newGroup := "acmeGroup"
-	groupMembers := []string{"user1", "user2"}
-	// mock function response from updateGroupMembers()
-	minioUpdateGroupMembersMock = func(madmin.GroupAddRemove) error {
-		return nil
-	}
-	function := "addGroup()"
-	if err := addGroup(ctx, adminClient, newGroup, groupMembers); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-
-	// Test-2 : addGroup() Return error and see that the error is handled correctly and returned
-	minioUpdateGroupMembersMock = func(madmin.GroupAddRemove) error {
-		return errors.New("error")
-	}
-
-	if err := addGroup(ctx, adminClient, newGroup, groupMembers); assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}
-
-func TestRemoveGroup(t *testing.T) {
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	// Test-1 : removeGroup() remove group assume it has no members
-	groupToRemove := "acmeGroup"
-	// mock function response from updateGroupMembers()
-	minioUpdateGroupMembersMock = func(madmin.GroupAddRemove) error {
-		return nil
-	}
-	function := "removeGroup()"
-	if err := removeGroup(ctx, adminClient, groupToRemove); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-
-	// Test-2 : removeGroup() Return error and see that the error is handled correctly and returned
-	minioUpdateGroupMembersMock = func(madmin.GroupAddRemove) error {
-		return errors.New("error")
-	}
-	if err := removeGroup(ctx, adminClient, groupToRemove); assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}
-
-func TestGroupInfo(t *testing.T) {
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	// Test-1 : groupInfo() get group info
-	groupName := "acmeGroup"
-	mockResponse := &madmin.GroupDesc{
-		Name:    groupName,
-		Policy:  "policyTest",
-		Members: []string{"user1", "user2"},
-		Status:  "enabled",
-	}
-	// mock function response from updateGroupMembers()
-	minioGetGroupDescriptionMock = func(_ string) (*madmin.GroupDesc, error) {
-		return mockResponse, nil
-	}
-	function := "groupInfo()"
-	info, err := groupInfo(ctx, adminClient, groupName)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	assert.Equal(groupName, info.Name)
-	assert.Equal("policyTest", info.Policy)
-	assert.ElementsMatch([]string{"user1", "user2"}, info.Members)
-	assert.Equal("enabled", info.Status)
-
-	// Test-2 : groupInfo() Return error and see that the error is handled correctly and returned
-	minioGetGroupDescriptionMock = func(_ string) (*madmin.GroupDesc, error) {
-		return nil, errors.New("error")
-	}
-	_, err = groupInfo(ctx, adminClient, groupName)
-	if assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}
-
-func TestUpdateGroup(t *testing.T) {
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	// Test-1 : addOrDeleteMembers()  update group members add user3 and delete user2
-	function := "addOrDeleteMembers()"
-	groupName := "acmeGroup"
-	mockGroupDesc := &madmin.GroupDesc{
-		Name:    groupName,
-		Policy:  "policyTest",
-		Members: []string{"user1", "user2"},
-		Status:  "enabled",
-	}
-	membersDesired := []string{"user3", "user1"}
-	minioUpdateGroupMembersMock = func(madmin.GroupAddRemove) error {
-		return nil
-	}
-	if err := addOrDeleteMembers(ctx, adminClient, mockGroupDesc, membersDesired); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-
-	// Test-2 : addOrDeleteMembers()  handle error correctly
-	minioUpdateGroupMembersMock = func(madmin.GroupAddRemove) error {
-		return errors.New("error")
-	}
-	if err := addOrDeleteMembers(ctx, adminClient, mockGroupDesc, membersDesired); assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-
-	// Test-3 : addOrDeleteMembers()  only add members but handle error on adding
-	minioUpdateGroupMembersMock = func(madmin.GroupAddRemove) error {
-		return errors.New("error")
-	}
-	membersDesired = []string{"user3", "user1", "user2"}
-	if err := addOrDeleteMembers(ctx, adminClient, mockGroupDesc, membersDesired); assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-
-	// Test-4: addOrDeleteMembers() no updates needed so error shall not be triggered or handled.
-	minioUpdateGroupMembersMock = func(madmin.GroupAddRemove) error {
-		return errors.New("error")
-	}
-	membersDesired = []string{"user1", "user2"}
-	if err := addOrDeleteMembers(ctx, adminClient, mockGroupDesc, membersDesired); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-
-	// Test-5 : groupUpdate() integrate all from getting current group to update it and see if it changed.
-	// This test mocks one function twice and makes sure it returns different content on each call.
-	function = "groupUpdate()"
-	groupName = "acmeGroup"
-	membersDesired = []string{"user1", "user2", "user3"}
-	expectedGroupUpdate := &models.UpdateGroupRequest{
-		Members: membersDesired,
-		Status:  swag.String("disabled"),
-	}
-	mockResponseBeforeUpdate := &madmin.GroupDesc{
-		Name:    groupName,
-		Policy:  "policyTest",
-		Members: []string{"user1", "user2"},
-		Status:  "enabled",
-	}
-	mockResponseAfterUpdate := &madmin.GroupDesc{
-		Name:    groupName,
-		Policy:  "policyTest",
-		Members: []string{"user1", "user2", "user3"},
-		Status:  "disabled",
-	}
-	// groupUpdate uses getInfo() twice which uses getGroupDescription() so we need to mock as if it called
-	// the function twice but the second time returned an error
-	is2ndRunGroupInfo := false
-	// mock function response from updateGroupMembers()
-	minioGetGroupDescriptionMock = func(_ string) (*madmin.GroupDesc, error) {
-		if is2ndRunGroupInfo {
-			return mockResponseAfterUpdate, nil
-		}
-		is2ndRunGroupInfo = true
-		return mockResponseBeforeUpdate, nil
-	}
-	minioUpdateGroupMembersMock = func(madmin.GroupAddRemove) error {
-		return nil
-	}
-	minioSetGroupStatusMock = func(_ string, _ madmin.GroupStatus) error {
-		return nil
-	}
-	groupUpdated, err := groupUpdate(ctx, adminClient, groupName, expectedGroupUpdate)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// assert elements were updated as expected
-	assert.ElementsMatch(membersDesired, groupUpdated.Members)
-	assert.Equal(groupName, groupUpdated.Name)
-	assert.Equal(*expectedGroupUpdate.Status, groupUpdated.Status)
-}
-
-func TestSetGroupStatus(t *testing.T) {
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	function := "setGroupStatus()"
-	groupName := "acmeGroup"
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	// Test-1: setGroupStatus() update valid disabled status
-	expectedStatus := "disabled"
-	minioSetGroupStatusMock = func(_ string, _ madmin.GroupStatus) error {
-		return nil
-	}
-	if err := setGroupStatus(ctx, adminClient, groupName, expectedStatus); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// Test-2: setGroupStatus() update valid enabled status
-	expectedStatus = "enabled"
-	minioSetGroupStatusMock = func(_ string, _ madmin.GroupStatus) error {
-		return nil
-	}
-	if err := setGroupStatus(ctx, adminClient, groupName, expectedStatus); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// Test-3: setGroupStatus() update invalid status, should send error
-	expectedStatus = "invalid"
-	minioSetGroupStatusMock = func(_ string, _ madmin.GroupStatus) error {
-		return nil
-	}
-	if err := setGroupStatus(ctx, adminClient, groupName, expectedStatus); assert.Error(err) {
-		assert.Equal("status not valid", err.Error())
-	}
-	// Test-4: setGroupStatus() handler error correctly
-	expectedStatus = "enabled"
-	minioSetGroupStatusMock = func(_ string, _ madmin.GroupStatus) error {
-		return errors.New("error")
-	}
-	if err := setGroupStatus(ctx, adminClient, groupName, expectedStatus); assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}

api/admin_idp.go

@@ -1,290 +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 api
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/minio/console/api/operations"
-	"github.com/minio/console/api/operations/idp"
-	"github.com/minio/console/models"
-	"github.com/minio/madmin-go/v3"
-)
-
-var errInvalidIDPType = fmt.Errorf("IDP type must be one of %v", madmin.ValidIDPConfigTypes)
-
-func registerIDPHandlers(api *operations.ConsoleAPI) {
-	api.IdpCreateConfigurationHandler = idp.CreateConfigurationHandlerFunc(func(params idp.CreateConfigurationParams, session *models.Principal) middleware.Responder {
-		response, err := createIDPConfigurationResponse(session, params)
-		if err != nil {
-			return idp.NewCreateConfigurationDefault(err.Code).WithPayload(err.APIError)
-		}
-		return idp.NewCreateConfigurationCreated().WithPayload(response)
-	})
-	api.IdpUpdateConfigurationHandler = idp.UpdateConfigurationHandlerFunc(func(params idp.UpdateConfigurationParams, session *models.Principal) middleware.Responder {
-		response, err := updateIDPConfigurationResponse(session, params)
-		if err != nil {
-			return idp.NewUpdateConfigurationDefault(err.Code).WithPayload(err.APIError)
-		}
-		return idp.NewUpdateConfigurationOK().WithPayload(response)
-	})
-	api.IdpListConfigurationsHandler = idp.ListConfigurationsHandlerFunc(func(params idp.ListConfigurationsParams, session *models.Principal) middleware.Responder {
-		response, err := listIDPConfigurationsResponse(session, params)
-		if err != nil {
-			return idp.NewListConfigurationsDefault(err.Code).WithPayload(err.APIError)
-		}
-		return idp.NewListConfigurationsOK().WithPayload(response)
-	})
-	api.IdpDeleteConfigurationHandler = idp.DeleteConfigurationHandlerFunc(func(params idp.DeleteConfigurationParams, session *models.Principal) middleware.Responder {
-		response, err := deleteIDPConfigurationResponse(session, params)
-		if err != nil {
-			return idp.NewDeleteConfigurationDefault(err.Code).WithPayload(err.APIError)
-		}
-		return idp.NewDeleteConfigurationOK().WithPayload(response)
-	})
-	api.IdpGetConfigurationHandler = idp.GetConfigurationHandlerFunc(func(params idp.GetConfigurationParams, session *models.Principal) middleware.Responder {
-		response, err := getIDPConfigurationsResponse(session, params)
-		if err != nil {
-			return idp.NewGetConfigurationDefault(err.Code).WithPayload(err.APIError)
-		}
-		return idp.NewGetConfigurationOK().WithPayload(response)
-	})
-	api.IdpGetLDAPEntitiesHandler = idp.GetLDAPEntitiesHandlerFunc(func(params idp.GetLDAPEntitiesParams, session *models.Principal) middleware.Responder {
-		response, err := getLDAPEntitiesResponse(session, params)
-		if err != nil {
-			return idp.NewGetLDAPEntitiesDefault(err.Code).WithPayload(err.APIError)
-		}
-		return idp.NewGetLDAPEntitiesOK().WithPayload(response)
-	})
-}
-
-func createIDPConfigurationResponse(session *models.Principal, params idp.CreateConfigurationParams) (*models.SetIDPResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	restart, err := createOrUpdateIDPConfig(ctx, params.Type, params.Body.Name, params.Body.Input, false, AdminClient{Client: mAdmin})
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return &models.SetIDPResponse{Restart: restart}, nil
-}
-
-func updateIDPConfigurationResponse(session *models.Principal, params idp.UpdateConfigurationParams) (*models.SetIDPResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	restart, err := createOrUpdateIDPConfig(ctx, params.Type, params.Name, params.Body.Input, true, AdminClient{Client: mAdmin})
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return &models.SetIDPResponse{Restart: restart}, nil
-}
-
-func createOrUpdateIDPConfig(ctx context.Context, idpType, name, input string, update bool, client MinioAdmin) (bool, error) {
-	if !madmin.ValidIDPConfigTypes.Contains(idpType) {
-		return false, errInvalidIDPType
-	}
-	restart, err := client.addOrUpdateIDPConfig(ctx, idpType, name, input, update)
-	if err != nil {
-		return false, err
-	}
-	return restart, nil
-}
-
-func listIDPConfigurationsResponse(session *models.Principal, params idp.ListConfigurationsParams) (*models.IdpListConfigurationsResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	results, err := listIDPConfigurations(ctx, params.Type, AdminClient{Client: mAdmin})
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return &models.IdpListConfigurationsResponse{Results: results}, nil
-}
-
-func listIDPConfigurations(ctx context.Context, idpType string, client MinioAdmin) ([]*models.IdpServerConfiguration, error) {
-	if !madmin.ValidIDPConfigTypes.Contains(idpType) {
-		return nil, errInvalidIDPType
-	}
-	results, err := client.listIDPConfig(ctx, idpType)
-	if err != nil {
-		return nil, err
-	}
-	return parseIDPConfigurations(results), nil
-}
-
-func parseIDPConfigurations(configs []madmin.IDPListItem) (serverConfigs []*models.IdpServerConfiguration) {
-	for _, c := range configs {
-		serverConfigs = append(serverConfigs, &models.IdpServerConfiguration{
-			Name:    c.Name,
-			Enabled: c.Enabled,
-			Type:    c.Type,
-		})
-	}
-	return serverConfigs
-}
-
-func deleteIDPConfigurationResponse(session *models.Principal, params idp.DeleteConfigurationParams) (*models.SetIDPResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	restart, err := deleteIDPConfig(ctx, params.Type, params.Name, AdminClient{Client: mAdmin})
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return &models.SetIDPResponse{Restart: restart}, nil
-}
-
-func deleteIDPConfig(ctx context.Context, idpType, name string, client MinioAdmin) (bool, error) {
-	if !madmin.ValidIDPConfigTypes.Contains(idpType) {
-		return false, errInvalidIDPType
-	}
-	restart, err := client.deleteIDPConfig(ctx, idpType, name)
-	if err != nil {
-		return false, err
-	}
-	return restart, nil
-}
-
-func getIDPConfigurationsResponse(session *models.Principal, params idp.GetConfigurationParams) (*models.IdpServerConfiguration, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	result, err := getIDPConfiguration(ctx, params.Type, params.Name, AdminClient{Client: mAdmin})
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return result, nil
-}
-
-func getIDPConfiguration(ctx context.Context, idpType, name string, client MinioAdmin) (*models.IdpServerConfiguration, error) {
-	if !madmin.ValidIDPConfigTypes.Contains(idpType) {
-		return nil, errInvalidIDPType
-	}
-	config, err := client.getIDPConfig(ctx, idpType, name)
-	if err != nil {
-		return nil, err
-	}
-
-	return &models.IdpServerConfiguration{
-		Name: config.Name,
-		Type: config.Type,
-		Info: parseIDPConfigurationsInfo(config.Info),
-	}, nil
-}
-
-func parseIDPConfigurationsInfo(infoList []madmin.IDPCfgInfo) (results []*models.IdpServerConfigurationInfo) {
-	for _, info := range infoList {
-		results = append(results, &models.IdpServerConfigurationInfo{
-			Key:   info.Key,
-			Value: info.Value,
-			IsCfg: info.IsCfg,
-			IsEnv: info.IsEnv,
-		})
-	}
-	return results
-}
-
-func getLDAPEntitiesResponse(session *models.Principal, params idp.GetLDAPEntitiesParams) (*models.LdapEntities, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	result, err := getEntitiesResult(ctx, AdminClient{Client: mAdmin}, params.Body.Users, params.Body.Groups, params.Body.Policies)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	return result, nil
-}
-
-func getEntitiesResult(ctx context.Context, client MinioAdmin, users, groups, policies []string) (*models.LdapEntities, error) {
-	entities, err := client.getLDAPPolicyEntities(ctx, madmin.PolicyEntitiesQuery{
-		Users:  users,
-		Groups: groups,
-		Policy: policies,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var result models.LdapEntities
-
-	var usersEntity []*models.LdapUserPolicyEntity
-	var groupsEntity []*models.LdapGroupPolicyEntity
-	var policiesEntity []*models.LdapPolicyEntity
-
-	result.Timestamp = entities.Timestamp.Format(time.RFC3339)
-
-	for _, userMapping := range entities.UserMappings {
-		mapItem := models.LdapUserPolicyEntity{
-			User:     userMapping.User,
-			Policies: userMapping.Policies,
-		}
-
-		usersEntity = append(usersEntity, &mapItem)
-	}
-
-	result.Users = usersEntity
-
-	for _, groupsMapping := range entities.GroupMappings {
-		mapItem := models.LdapGroupPolicyEntity{
-			Group:    groupsMapping.Group,
-			Policies: groupsMapping.Policies,
-		}
-
-		groupsEntity = append(groupsEntity, &mapItem)
-	}
-
-	result.Groups = groupsEntity
-
-	for _, policyMapping := range entities.PolicyMappings {
-		mapItem := models.LdapPolicyEntity{
-			Policy: policyMapping.Policy,
-			Users:  policyMapping.Users,
-			Groups: policyMapping.Groups,
-		}
-
-		policiesEntity = append(policiesEntity, &mapItem)
-	}
-
-	result.Policies = policiesEntity
-
-	return &result, nil
-}

api/admin_idp_test.go

@@ -1,319 +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 api
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-
-	"github.com/minio/madmin-go/v3"
-
-	"github.com/minio/console/api/operations"
-	"github.com/minio/console/api/operations/idp"
-	"github.com/minio/console/models"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type IDPTestSuite struct {
-	suite.Suite
-	assert        *assert.Assertions
-	currentServer string
-	isServerSet   bool
-	server        *httptest.Server
-	adminClient   AdminClientMock
-}
-
-func (suite *IDPTestSuite) SetupSuite() {
-	suite.assert = assert.New(suite.T())
-	suite.adminClient = AdminClientMock{}
-	minioServiceRestartMock = func(_ context.Context) error {
-		return nil
-	}
-}
-
-func (suite *IDPTestSuite) SetupTest() {
-	suite.server = httptest.NewServer(http.HandlerFunc(suite.serverHandler))
-	suite.currentServer, suite.isServerSet = os.LookupEnv(ConsoleMinIOServer)
-	os.Setenv(ConsoleMinIOServer, suite.server.URL)
-}
-
-func (suite *IDPTestSuite) serverHandler(w http.ResponseWriter, _ *http.Request) {
-	w.WriteHeader(400)
-}
-
-func (suite *IDPTestSuite) TearDownSuite() {
-}
-
-func (suite *IDPTestSuite) TearDownTest() {
-	if suite.isServerSet {
-		os.Setenv(ConsoleMinIOServer, suite.currentServer)
-	} else {
-		os.Unsetenv(ConsoleMinIOServer)
-	}
-}
-
-func (suite *IDPTestSuite) TestRegisterIDPHandlers() {
-	api := &operations.ConsoleAPI{}
-	suite.assertHandlersAreNil(api)
-	registerIDPHandlers(api)
-	suite.assertHandlersAreNotNil(api)
-}
-
-func (suite *IDPTestSuite) assertHandlersAreNil(api *operations.ConsoleAPI) {
-	suite.assert.Nil(api.IdpCreateConfigurationHandler)
-	suite.assert.Nil(api.IdpListConfigurationsHandler)
-	suite.assert.Nil(api.IdpUpdateConfigurationHandler)
-	suite.assert.Nil(api.IdpGetConfigurationHandler)
-	suite.assert.Nil(api.IdpGetConfigurationHandler)
-	suite.assert.Nil(api.IdpDeleteConfigurationHandler)
-}
-
-func (suite *IDPTestSuite) assertHandlersAreNotNil(api *operations.ConsoleAPI) {
-	suite.assert.NotNil(api.IdpCreateConfigurationHandler)
-	suite.assert.NotNil(api.IdpListConfigurationsHandler)
-	suite.assert.NotNil(api.IdpUpdateConfigurationHandler)
-	suite.assert.NotNil(api.IdpGetConfigurationHandler)
-	suite.assert.NotNil(api.IdpGetConfigurationHandler)
-	suite.assert.NotNil(api.IdpDeleteConfigurationHandler)
-}
-
-func (suite *IDPTestSuite) TestCreateIDPConfigurationHandlerWithError() {
-	params, api := suite.initCreateIDPConfigurationRequest()
-	response := api.IdpCreateConfigurationHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*idp.CreateConfigurationDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *IDPTestSuite) initCreateIDPConfigurationRequest() (params idp.CreateConfigurationParams, api operations.ConsoleAPI) {
-	registerIDPHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	params.Body = &models.IdpServerConfiguration{}
-	params.Type = "ldap"
-	return params, api
-}
-
-func (suite *IDPTestSuite) TestCreateIDPConfigurationWithoutError() {
-	ctx := context.Background()
-	_, err := createOrUpdateIDPConfig(ctx, "ldap", "", "", false, suite.adminClient)
-	suite.assert.Nil(err)
-}
-
-func (suite *IDPTestSuite) TestCreateIDPConfigurationWithWrongType() {
-	ctx := context.Background()
-	_, err := createOrUpdateIDPConfig(ctx, "", "", "", false, suite.adminClient)
-	suite.assert.NotNil(err)
-}
-
-func (suite *IDPTestSuite) TestUpdateIDPConfigurationHandlerWithError() {
-	params, api := suite.initUpdateIDPConfigurationRequest()
-	response := api.IdpUpdateConfigurationHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*idp.UpdateConfigurationDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *IDPTestSuite) initUpdateIDPConfigurationRequest() (params idp.UpdateConfigurationParams, api operations.ConsoleAPI) {
-	registerIDPHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	params.Body = &models.IdpServerConfiguration{}
-	params.Type = "ldap"
-	return params, api
-}
-
-func (suite *IDPTestSuite) TestUpdateIDPConfigurationWithoutError() {
-	ctx := context.Background()
-	_, err := createOrUpdateIDPConfig(ctx, "ldap", "", "", true, suite.adminClient)
-	suite.assert.Nil(err)
-}
-
-func (suite *IDPTestSuite) TestUpdateIDPConfigurationWithWrongType() {
-	ctx := context.Background()
-	_, err := createOrUpdateIDPConfig(ctx, "", "", "", true, suite.adminClient)
-	suite.assert.NotNil(err)
-}
-
-func (suite *IDPTestSuite) TestListIDPConfigurationHandlerWithError() {
-	params, api := suite.initListIDPConfigurationsRequest()
-	response := api.IdpListConfigurationsHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*idp.ListConfigurationsDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *IDPTestSuite) initListIDPConfigurationsRequest() (params idp.ListConfigurationsParams, api operations.ConsoleAPI) {
-	registerIDPHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	params.Type = "ldap"
-	return params, api
-}
-
-func (suite *IDPTestSuite) TestListIDPConfigurationsWithoutError() {
-	ctx := context.Background()
-	res, err := listIDPConfigurations(ctx, "ldap", suite.adminClient)
-	suite.assert.NotNil(res)
-	suite.assert.Nil(err)
-}
-
-func (suite *IDPTestSuite) TestListIDPConfigurationsWithWrongType() {
-	ctx := context.Background()
-	res, err := listIDPConfigurations(ctx, "", suite.adminClient)
-	suite.assert.Nil(res)
-	suite.assert.NotNil(err)
-}
-
-func (suite *IDPTestSuite) TestDeleteIDPConfigurationHandlerWithError() {
-	params, api := suite.initDeleteIDPConfigurationRequest()
-	response := api.IdpDeleteConfigurationHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*idp.DeleteConfigurationDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *IDPTestSuite) initDeleteIDPConfigurationRequest() (params idp.DeleteConfigurationParams, api operations.ConsoleAPI) {
-	registerIDPHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	params.Type = "ldap"
-	return params, api
-}
-
-func (suite *IDPTestSuite) TestDeleteIDPConfigurationWithoutError() {
-	ctx := context.Background()
-	_, err := deleteIDPConfig(ctx, "ldap", "", suite.adminClient)
-	suite.assert.Nil(err)
-}
-
-func (suite *IDPTestSuite) TestDeleteIDPConfigurationWithWrongType() {
-	ctx := context.Background()
-	_, err := deleteIDPConfig(ctx, "", "", suite.adminClient)
-	suite.assert.NotNil(err)
-}
-
-func (suite *IDPTestSuite) TestGetIDPConfigurationHandlerWithError() {
-	params, api := suite.initGetIDPConfigurationRequest()
-	response := api.IdpGetConfigurationHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*idp.GetConfigurationDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *IDPTestSuite) initGetIDPConfigurationRequest() (params idp.GetConfigurationParams, api operations.ConsoleAPI) {
-	registerIDPHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	params.Type = "ldap"
-	return params, api
-}
-
-func (suite *IDPTestSuite) TestGetIDPConfigurationWithoutError() {
-	ctx := context.Background()
-	res, err := getIDPConfiguration(ctx, "ldap", "", suite.adminClient)
-	suite.assert.NotNil(res)
-	suite.assert.Nil(err)
-}
-
-func (suite *IDPTestSuite) TestGetIDPConfigurationWithWrongType() {
-	ctx := context.Background()
-	res, err := getIDPConfiguration(ctx, "", "", suite.adminClient)
-	suite.assert.Nil(res)
-	suite.assert.NotNil(err)
-}
-
-func TestIDP(t *testing.T) {
-	suite.Run(t, new(IDPTestSuite))
-}
-
-func TestGetEntitiesResult(t *testing.T) {
-	assert := assert.New(t)
-	// mock minIO client
-	client := AdminClientMock{}
-	function := "getEntitiesResult()"
-
-	usersList := []string{"user1", "user2", "user3"}
-	policiesList := []string{"policy1", "policy2", "policy3"}
-	groupsList := []string{"group1", "group3", "group5"}
-
-	policyMap := []madmin.PolicyEntities{
-		{Policy: "testPolicy0", Groups: groupsList, Users: usersList},
-		{Policy: "testPolicy1", Groups: groupsList, Users: usersList},
-	}
-
-	usersMap := []madmin.UserPolicyEntities{
-		{User: "testUser0", Policies: policiesList},
-		{User: "testUser1", Policies: policiesList},
-	}
-
-	groupsMap := []madmin.GroupPolicyEntities{
-		{Group: "group0", Policies: policiesList},
-		{Group: "group1", Policies: policiesList},
-	}
-
-	// Test-1: getEntitiesResult list all information provided
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	mockResponse := madmin.PolicyEntitiesResult{
-		PolicyMappings: policyMap,
-		GroupMappings:  groupsMap,
-		UserMappings:   usersMap,
-	}
-	minioGetLDAPPolicyEntitiesMock = func(_ context.Context, _ madmin.PolicyEntitiesQuery) (madmin.PolicyEntitiesResult, error) {
-		return mockResponse, nil
-	}
-
-	entities, err := getEntitiesResult(ctx, client, usersList, groupsList, policiesList)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-
-	for i, groupIt := range entities.Groups {
-		assert.Equal(fmt.Sprintf("group%d", i), groupIt.Group)
-
-		for i, polItm := range groupIt.Policies {
-			assert.Equal(policiesList[i], polItm)
-		}
-	}
-
-	for i, usrIt := range entities.Users {
-		assert.Equal(fmt.Sprintf("testUser%d", i), usrIt.User)
-
-		for i, polItm := range usrIt.Policies {
-			assert.Equal(policiesList[i], polItm)
-		}
-	}
-
-	for i, policyIt := range entities.Policies {
-		assert.Equal(fmt.Sprintf("testPolicy%d", i), policyIt.Policy)
-
-		for i, userItm := range policyIt.Users {
-			assert.Equal(usersList[i], userItm)
-		}
-
-		for i, grItm := range policyIt.Groups {
-			assert.Equal(groupsList[i], grItm)
-		}
-	}
-
-	// Test-2: getEntitiesResult error is returned from getLDAPPolicyEntities()
-	minioGetLDAPPolicyEntitiesMock = func(_ context.Context, _ madmin.PolicyEntitiesQuery) (madmin.PolicyEntitiesResult, error) {
-		return madmin.PolicyEntitiesResult{}, errors.New("error")
-	}
-
-	_, err = getEntitiesResult(ctx, client, usersList, groupsList, policiesList)
-	if assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}

api/admin_info_test.go

@@ -1,152 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 api
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-
-	"github.com/minio/console/pkg/utils"
-
-	"github.com/minio/console/api/operations"
-	systemApi "github.com/minio/console/api/operations/system"
-	"github.com/minio/console/models"
-	"github.com/minio/madmin-go/v3"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type AdminInfoTestSuite struct {
-	suite.Suite
-	assert              *assert.Assertions
-	currentServer       string
-	isServerSet         bool
-	isPrometheusRequest bool
-	server              *httptest.Server
-	adminClient         AdminClientMock
-}
-
-func (suite *AdminInfoTestSuite) SetupSuite() {
-	suite.assert = assert.New(suite.T())
-	suite.adminClient = AdminClientMock{}
-	MinioServerInfoMock = func(_ context.Context) (madmin.InfoMessage, error) {
-		return madmin.InfoMessage{
-			Servers: []madmin.ServerProperties{{
-				Disks: []madmin.Disk{{}},
-			}},
-			Backend: madmin.ErasureBackend{Type: "mock"},
-		}, nil
-	}
-}
-
-func (suite *AdminInfoTestSuite) SetupTest() {
-	suite.server = httptest.NewServer(http.HandlerFunc(suite.serverHandler))
-	suite.currentServer, suite.isServerSet = os.LookupEnv(ConsoleMinIOServer)
-	os.Setenv(ConsoleMinIOServer, suite.server.URL)
-}
-
-func (suite *AdminInfoTestSuite) serverHandler(w http.ResponseWriter, _ *http.Request) {
-	if suite.isPrometheusRequest {
-		w.WriteHeader(200)
-	} else {
-		w.WriteHeader(400)
-	}
-}
-
-func (suite *AdminInfoTestSuite) TearDownSuite() {
-}
-
-func (suite *AdminInfoTestSuite) TearDownTest() {
-	if suite.isServerSet {
-		os.Setenv(ConsoleMinIOServer, suite.currentServer)
-	} else {
-		os.Unsetenv(ConsoleMinIOServer)
-	}
-}
-
-func (suite *AdminInfoTestSuite) TestRegisterAdminInfoHandlers() {
-	api := &operations.ConsoleAPI{}
-	suite.assertHandlersAreNil(api)
-	registerAdminInfoHandlers(api)
-	suite.assertHandlersAreNotNil(api)
-}
-
-func (suite *AdminInfoTestSuite) assertHandlersAreNil(api *operations.ConsoleAPI) {
-	suite.assert.Nil(api.SystemAdminInfoHandler)
-	suite.assert.Nil(api.SystemDashboardWidgetDetailsHandler)
-}
-
-func (suite *AdminInfoTestSuite) assertHandlersAreNotNil(api *operations.ConsoleAPI) {
-	suite.assert.NotNil(api.SystemAdminInfoHandler)
-	suite.assert.NotNil(api.SystemDashboardWidgetDetailsHandler)
-}
-
-func (suite *AdminInfoTestSuite) TestSystemAdminInfoHandlerWithError() {
-	params, api := suite.initSystemAdminInfoRequest()
-	response := api.SystemAdminInfoHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*systemApi.AdminInfoDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *AdminInfoTestSuite) initSystemAdminInfoRequest() (params systemApi.AdminInfoParams, api operations.ConsoleAPI) {
-	registerAdminInfoHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	defaultOnly := false
-	params.DefaultOnly = &defaultOnly
-	return params, api
-}
-
-func (suite *AdminInfoTestSuite) TestSystemDashboardWidgetDetailsHandlerWithError() {
-	params, api := suite.initSystemDashboardWidgetDetailsRequest()
-	response := api.SystemDashboardWidgetDetailsHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*systemApi.DashboardWidgetDetailsDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *AdminInfoTestSuite) initSystemDashboardWidgetDetailsRequest() (params systemApi.DashboardWidgetDetailsParams, api operations.ConsoleAPI) {
-	registerAdminInfoHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	return params, api
-}
-
-func (suite *AdminInfoTestSuite) TestGetUsageWidgetsForDeploymentWithoutError() {
-	ctx := context.WithValue(context.Background(), utils.ContextClientIP, "127.0.0.1")
-	suite.isPrometheusRequest = true
-	res, err := getUsageWidgetsForDeployment(ctx, suite.server.URL, suite.adminClient)
-	suite.assert.Nil(err)
-	suite.assert.NotNil(res)
-	suite.isPrometheusRequest = false
-}
-
-func (suite *AdminInfoTestSuite) TestGetWidgetDetailsWithoutError() {
-	ctx := context.WithValue(context.Background(), utils.ContextClientIP, "127.0.0.1")
-	suite.isPrometheusRequest = true
-	var step int32 = 1
-	var start int64
-	var end int64 = 1
-	res, err := getWidgetDetails(ctx, suite.server.URL, "mock", 1, &step, &start, &end)
-	suite.assert.Nil(err)
-	suite.assert.NotNil(res)
-	suite.isPrometheusRequest = false
-}
-
-func TestAdminInfo(t *testing.T) {
-	suite.Run(t, new(AdminInfoTestSuite))
-}

api/admin_inspect.go

@@ -1,117 +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 api
-
-import (
-	"encoding/base64"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-
-	"github.com/go-openapi/runtime"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/minio/console/api/operations"
-	inspectApi "github.com/minio/console/api/operations/inspect"
-	"github.com/minio/console/models"
-	"github.com/minio/madmin-go/v3"
-	"github.com/secure-io/sio-go"
-)
-
-func registerInspectHandler(api *operations.ConsoleAPI) {
-	api.InspectInspectHandler = inspectApi.InspectHandlerFunc(func(params inspectApi.InspectParams, principal *models.Principal) middleware.Responder {
-		k, r, err := getInspectResult(principal, &params)
-		if err != nil {
-			return inspectApi.NewInspectDefault(err.Code).WithPayload(err.APIError)
-		}
-
-		return middleware.ResponderFunc(processInspectResponse(&params, k, r))
-	})
-}
-
-func getInspectResult(session *models.Principal, params *inspectApi.InspectParams) ([]byte, io.ReadCloser, *CodedAPIError) {
-	ctx := params.HTTPRequest.Context()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, nil, ErrorWithContext(ctx, err)
-	}
-
-	cfg := madmin.InspectOptions{
-		File:   params.File,
-		Volume: params.Volume,
-	}
-
-	// TODO: Remove encryption option and always encrypt.
-	// Maybe also add public key field.
-	if params.Encrypt != nil && *params.Encrypt {
-		cfg.PublicKey, _ = base64.StdEncoding.DecodeString("MIIBCgKCAQEAs/128UFS9A8YSJY1XqYKt06dLVQQCGDee69T+0Tip/1jGAB4z0/3QMpH0MiS8Wjs4BRWV51qvkfAHzwwdU7y6jxU05ctb/H/WzRj3FYdhhHKdzear9TLJftlTs+xwj2XaADjbLXCV1jGLS889A7f7z5DgABlVZMQd9BjVAR8ED3xRJ2/ZCNuQVJ+A8r7TYPGMY3wWvhhPgPk3Lx4WDZxDiDNlFs4GQSaESSsiVTb9vyGe/94CsCTM6Cw9QG6ifHKCa/rFszPYdKCabAfHcS3eTr0GM+TThSsxO7KfuscbmLJkfQev1srfL2Ii2RbnysqIJVWKEwdW05ID8ryPkuTuwIDAQAB")
-	}
-
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	k, r, err := adminClient.inspect(ctx, cfg)
-	if err != nil {
-		return nil, nil, ErrorWithContext(ctx, err)
-	}
-	return k, r, nil
-}
-
-// borrowed from mc cli
-func decryptInspectV1(key [32]byte, r io.Reader) io.ReadCloser {
-	stream, err := sio.AES_256_GCM.Stream(key[:])
-	if err != nil {
-		return nil
-	}
-	nonce := make([]byte, stream.NonceSize())
-	return io.NopCloser(stream.DecryptReader(r, nonce, nil))
-}
-
-func processInspectResponse(params *inspectApi.InspectParams, k []byte, r io.ReadCloser) func(w http.ResponseWriter, _ runtime.Producer) {
-	isEnc := params.Encrypt != nil && *params.Encrypt
-	return func(w http.ResponseWriter, _ runtime.Producer) {
-		ext := "enc"
-		if len(k) == 32 && !isEnc {
-			ext = "zip"
-			r = decryptInspectV1(*(*[32]byte)(k), r)
-		}
-		fileName := fmt.Sprintf("inspect-%s-%s.%s", params.Volume, params.File, ext)
-		fileName = strings.Map(func(r rune) rune {
-			switch {
-			case r >= 'A' && r <= 'Z':
-				return r
-			case r >= 'a' && r <= 'z':
-				return r
-			case r >= '0' && r <= '9':
-				return r
-			default:
-				if strings.ContainsAny(string(r), "-+._") {
-					return r
-				}
-				return '_'
-			}
-		}, fileName)
-		w.Header().Set("Content-Type", "application/octet-stream")
-		w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", fileName))
-
-		_, err := io.Copy(w, r)
-		if err != nil {
-			LogError("unable to write all the data: %v", err)
-		}
-	}
-}

api/admin_kms.go

@@ -1,296 +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 api
-
-import (
-	"context"
-	"sort"
-
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/minio/console/api/operations"
-	kmsAPI "github.com/minio/console/api/operations/k_m_s"
-	"github.com/minio/console/models"
-	"github.com/minio/madmin-go/v3"
-)
-
-func registerKMSHandlers(api *operations.ConsoleAPI) {
-	registerKMSStatusHandlers(api)
-	registerKMSKeyHandlers(api)
-}
-
-func registerKMSStatusHandlers(api *operations.ConsoleAPI) {
-	api.KmsKMSStatusHandler = kmsAPI.KMSStatusHandlerFunc(func(params kmsAPI.KMSStatusParams, session *models.Principal) middleware.Responder {
-		resp, err := GetKMSStatusResponse(session, params)
-		if err != nil {
-			return kmsAPI.NewKMSStatusDefault(err.Code).WithPayload(err.APIError)
-		}
-		return kmsAPI.NewKMSStatusOK().WithPayload(resp)
-	})
-
-	api.KmsKMSMetricsHandler = kmsAPI.KMSMetricsHandlerFunc(func(params kmsAPI.KMSMetricsParams, session *models.Principal) middleware.Responder {
-		resp, err := GetKMSMetricsResponse(session, params)
-		if err != nil {
-			return kmsAPI.NewKMSMetricsDefault(err.Code).WithPayload(err.APIError)
-		}
-		return kmsAPI.NewKMSMetricsOK().WithPayload(resp)
-	})
-
-	api.KmsKMSAPIsHandler = kmsAPI.KMSAPIsHandlerFunc(func(params kmsAPI.KMSAPIsParams, session *models.Principal) middleware.Responder {
-		resp, err := GetKMSAPIsResponse(session, params)
-		if err != nil {
-			return kmsAPI.NewKMSAPIsDefault(err.Code).WithPayload(err.APIError)
-		}
-		return kmsAPI.NewKMSAPIsOK().WithPayload(resp)
-	})
-
-	api.KmsKMSVersionHandler = kmsAPI.KMSVersionHandlerFunc(func(params kmsAPI.KMSVersionParams, session *models.Principal) middleware.Responder {
-		resp, err := GetKMSVersionResponse(session, params)
-		if err != nil {
-			return kmsAPI.NewKMSVersionDefault(err.Code).WithPayload(err.APIError)
-		}
-		return kmsAPI.NewKMSVersionOK().WithPayload(resp)
-	})
-}
-
-func GetKMSStatusResponse(session *models.Principal, params kmsAPI.KMSStatusParams) (*models.KmsStatusResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return kmsStatus(ctx, AdminClient{Client: mAdmin})
-}
-
-func kmsStatus(ctx context.Context, minioClient MinioAdmin) (*models.KmsStatusResponse, *CodedAPIError) {
-	st, err := minioClient.kmsStatus(ctx)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return &models.KmsStatusResponse{
-		DefaultKeyID: st.DefaultKeyID,
-		Name:         st.Name,
-		Endpoints:    parseStatusEndpoints(st.Endpoints),
-	}, nil
-}
-
-func parseStatusEndpoints(endpoints map[string]madmin.ItemState) (kmsEndpoints []*models.KmsEndpoint) {
-	for key, value := range endpoints {
-		kmsEndpoints = append(kmsEndpoints, &models.KmsEndpoint{URL: key, Status: string(value)})
-	}
-	return kmsEndpoints
-}
-
-func GetKMSMetricsResponse(session *models.Principal, params kmsAPI.KMSMetricsParams) (*models.KmsMetricsResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return kmsMetrics(ctx, AdminClient{Client: mAdmin})
-}
-
-func kmsMetrics(ctx context.Context, minioClient MinioAdmin) (*models.KmsMetricsResponse, *CodedAPIError) {
-	metrics, err := minioClient.kmsMetrics(ctx)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return &models.KmsMetricsResponse{
-		RequestOK:        &metrics.RequestOK,
-		RequestErr:       &metrics.RequestErr,
-		RequestFail:      &metrics.RequestFail,
-		RequestActive:    &metrics.RequestActive,
-		AuditEvents:      &metrics.AuditEvents,
-		ErrorEvents:      &metrics.ErrorEvents,
-		LatencyHistogram: parseHistogram(metrics.LatencyHistogram),
-		Uptime:           &metrics.UpTime,
-		Cpus:             &metrics.CPUs,
-		UsableCPUs:       &metrics.UsableCPUs,
-		Threads:          &metrics.Threads,
-		HeapAlloc:        &metrics.HeapAlloc,
-		HeapObjects:      metrics.HeapObjects,
-		StackAlloc:       &metrics.StackAlloc,
-	}, nil
-}
-
-func parseHistogram(histogram map[int64]int64) (records []*models.KmsLatencyHistogram) {
-	for duration, total := range histogram {
-		records = append(records, &models.KmsLatencyHistogram{Duration: duration, Total: total})
-	}
-	cp := func(i, j int) bool {
-		return records[i].Duration < records[j].Duration
-	}
-	sort.Slice(records, cp)
-	return records
-}
-
-func GetKMSAPIsResponse(session *models.Principal, params kmsAPI.KMSAPIsParams) (*models.KmsAPIsResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return kmsAPIs(ctx, AdminClient{Client: mAdmin})
-}
-
-func kmsAPIs(ctx context.Context, minioClient MinioAdmin) (*models.KmsAPIsResponse, *CodedAPIError) {
-	apis, err := minioClient.kmsAPIs(ctx)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return &models.KmsAPIsResponse{
-		Results: parseApis(apis),
-	}, nil
-}
-
-func parseApis(apis []madmin.KMSAPI) (data []*models.KmsAPI) {
-	for _, api := range apis {
-		data = append(data, &models.KmsAPI{
-			Method:  api.Method,
-			Path:    api.Path,
-			MaxBody: api.MaxBody,
-			Timeout: api.Timeout,
-		})
-	}
-	return data
-}
-
-func GetKMSVersionResponse(session *models.Principal, params kmsAPI.KMSVersionParams) (*models.KmsVersionResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return kmsVersion(ctx, AdminClient{Client: mAdmin})
-}
-
-func kmsVersion(ctx context.Context, minioClient MinioAdmin) (*models.KmsVersionResponse, *CodedAPIError) {
-	version, err := minioClient.kmsVersion(ctx)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return &models.KmsVersionResponse{
-		Version: version.Version,
-	}, nil
-}
-
-func registerKMSKeyHandlers(api *operations.ConsoleAPI) {
-	api.KmsKMSCreateKeyHandler = kmsAPI.KMSCreateKeyHandlerFunc(func(params kmsAPI.KMSCreateKeyParams, session *models.Principal) middleware.Responder {
-		err := GetKMSCreateKeyResponse(session, params)
-		if err != nil {
-			return kmsAPI.NewKMSCreateKeyDefault(err.Code).WithPayload(err.APIError)
-		}
-		return kmsAPI.NewKMSCreateKeyCreated()
-	})
-
-	api.KmsKMSListKeysHandler = kmsAPI.KMSListKeysHandlerFunc(func(params kmsAPI.KMSListKeysParams, session *models.Principal) middleware.Responder {
-		resp, err := GetKMSListKeysResponse(session, params)
-		if err != nil {
-			return kmsAPI.NewKMSListKeysDefault(err.Code).WithPayload(err.APIError)
-		}
-		return kmsAPI.NewKMSListKeysOK().WithPayload(resp)
-	})
-
-	api.KmsKMSKeyStatusHandler = kmsAPI.KMSKeyStatusHandlerFunc(func(params kmsAPI.KMSKeyStatusParams, session *models.Principal) middleware.Responder {
-		resp, err := GetKMSKeyStatusResponse(session, params)
-		if err != nil {
-			return kmsAPI.NewKMSKeyStatusDefault(err.Code).WithPayload(err.APIError)
-		}
-		return kmsAPI.NewKMSKeyStatusOK().WithPayload(resp)
-	})
-}
-
-func GetKMSCreateKeyResponse(session *models.Principal, params kmsAPI.KMSCreateKeyParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	return createKey(ctx, *params.Body.Key, AdminClient{Client: mAdmin})
-}
-
-func createKey(ctx context.Context, key string, minioClient MinioAdmin) *CodedAPIError {
-	if err := minioClient.createKey(ctx, key); err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	return nil
-}
-
-func GetKMSListKeysResponse(session *models.Principal, params kmsAPI.KMSListKeysParams) (*models.KmsListKeysResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	pattern := ""
-	if params.Pattern != nil {
-		pattern = *params.Pattern
-	}
-	return listKeys(ctx, pattern, AdminClient{Client: mAdmin})
-}
-
-func listKeys(ctx context.Context, pattern string, minioClient MinioAdmin) (*models.KmsListKeysResponse, *CodedAPIError) {
-	results, err := minioClient.listKeys(ctx, pattern)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return &models.KmsListKeysResponse{Results: parseKeys(results)}, nil
-}
-
-// printDate - human friendly formatted date.
-const (
-	printDate = "2006-01-02 15:04:05 MST"
-)
-
-func parseKeys(results []madmin.KMSKeyInfo) (data []*models.KmsKeyInfo) {
-	for _, key := range results {
-		data = append(data, &models.KmsKeyInfo{
-			CreatedAt: key.CreatedAt.Format(printDate),
-			CreatedBy: key.CreatedBy,
-			Name:      key.Name,
-		})
-	}
-	return data
-}
-
-func GetKMSKeyStatusResponse(session *models.Principal, params kmsAPI.KMSKeyStatusParams) (*models.KmsKeyStatusResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return keyStatus(ctx, params.Name, AdminClient{Client: mAdmin})
-}
-
-func keyStatus(ctx context.Context, key string, minioClient MinioAdmin) (*models.KmsKeyStatusResponse, *CodedAPIError) {
-	ks, err := minioClient.keyStatus(ctx, key)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return &models.KmsKeyStatusResponse{
-		KeyID:         ks.KeyID,
-		EncryptionErr: ks.EncryptionErr,
-		DecryptionErr: ks.DecryptionErr,
-	}, nil
-}

api/admin_kms_test.go

@@ -1,238 +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 api
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-
-	"github.com/minio/console/api/operations"
-	kmsAPI "github.com/minio/console/api/operations/k_m_s"
-	"github.com/minio/console/models"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type KMSTestSuite struct {
-	suite.Suite
-	assert        *assert.Assertions
-	currentServer string
-	isServerSet   bool
-	server        *httptest.Server
-	adminClient   AdminClientMock
-}
-
-func (suite *KMSTestSuite) SetupSuite() {
-	suite.assert = assert.New(suite.T())
-	suite.adminClient = AdminClientMock{}
-}
-
-func (suite *KMSTestSuite) SetupTest() {
-	suite.server = httptest.NewServer(http.HandlerFunc(suite.serverHandler))
-	suite.currentServer, suite.isServerSet = os.LookupEnv(ConsoleMinIOServer)
-	os.Setenv(ConsoleMinIOServer, suite.server.URL)
-}
-
-func (suite *KMSTestSuite) serverHandler(w http.ResponseWriter, _ *http.Request) {
-	w.WriteHeader(400)
-}
-
-func (suite *KMSTestSuite) TearDownSuite() {
-}
-
-func (suite *KMSTestSuite) TearDownTest() {
-	if suite.isServerSet {
-		os.Setenv(ConsoleMinIOServer, suite.currentServer)
-	} else {
-		os.Unsetenv(ConsoleMinIOServer)
-	}
-}
-
-func (suite *KMSTestSuite) TestRegisterKMSHandlers() {
-	api := &operations.ConsoleAPI{}
-	suite.assertHandlersAreNil(api)
-	registerKMSHandlers(api)
-	suite.assertHandlersAreNotNil(api)
-}
-
-func (suite *KMSTestSuite) assertHandlersAreNil(api *operations.ConsoleAPI) {
-	suite.assert.Nil(api.KmsKMSStatusHandler)
-	suite.assert.Nil(api.KmsKMSMetricsHandler)
-	suite.assert.Nil(api.KmsKMSAPIsHandler)
-	suite.assert.Nil(api.KmsKMSVersionHandler)
-	suite.assert.Nil(api.KmsKMSCreateKeyHandler)
-	suite.assert.Nil(api.KmsKMSListKeysHandler)
-	suite.assert.Nil(api.KmsKMSKeyStatusHandler)
-}
-
-func (suite *KMSTestSuite) assertHandlersAreNotNil(api *operations.ConsoleAPI) {
-	suite.assert.NotNil(api.KmsKMSStatusHandler)
-	suite.assert.NotNil(api.KmsKMSMetricsHandler)
-	suite.assert.NotNil(api.KmsKMSAPIsHandler)
-	suite.assert.NotNil(api.KmsKMSVersionHandler)
-	suite.assert.NotNil(api.KmsKMSCreateKeyHandler)
-	suite.assert.NotNil(api.KmsKMSListKeysHandler)
-	suite.assert.NotNil(api.KmsKMSKeyStatusHandler)
-}
-
-func (suite *KMSTestSuite) TestKMSStatusHandlerWithError() {
-	params, api := suite.initKMSStatusRequest()
-	response := api.KmsKMSStatusHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*kmsAPI.KMSStatusDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *KMSTestSuite) initKMSStatusRequest() (params kmsAPI.KMSStatusParams, api operations.ConsoleAPI) {
-	registerKMSHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	return params, api
-}
-
-func (suite *KMSTestSuite) TestKMSStatusWithoutError() {
-	ctx := context.Background()
-	res, err := kmsStatus(ctx, suite.adminClient)
-	suite.assert.NotNil(res)
-	suite.assert.Nil(err)
-}
-
-func (suite *KMSTestSuite) TestKMSMetricsHandlerWithError() {
-	params, api := suite.initKMSMetricsRequest()
-	response := api.KmsKMSMetricsHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*kmsAPI.KMSMetricsDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *KMSTestSuite) initKMSMetricsRequest() (params kmsAPI.KMSMetricsParams, api operations.ConsoleAPI) {
-	registerKMSHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	return params, api
-}
-
-func (suite *KMSTestSuite) TestKMSMetricsWithoutError() {
-	ctx := context.Background()
-	res, err := kmsMetrics(ctx, suite.adminClient)
-	suite.assert.NotNil(res)
-	suite.assert.Nil(err)
-}
-
-func (suite *KMSTestSuite) TestKMSAPIsHandlerWithError() {
-	params, api := suite.initKMSAPIsRequest()
-	response := api.KmsKMSAPIsHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*kmsAPI.KMSAPIsDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *KMSTestSuite) initKMSAPIsRequest() (params kmsAPI.KMSAPIsParams, api operations.ConsoleAPI) {
-	registerKMSHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	return params, api
-}
-
-func (suite *KMSTestSuite) TestKMSAPIsWithoutError() {
-	ctx := context.Background()
-	res, err := kmsAPIs(ctx, suite.adminClient)
-	suite.assert.NotNil(res)
-	suite.assert.Nil(err)
-}
-
-func (suite *KMSTestSuite) TestKMSVersionHandlerWithError() {
-	params, api := suite.initKMSVersionRequest()
-	response := api.KmsKMSVersionHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*kmsAPI.KMSVersionDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *KMSTestSuite) initKMSVersionRequest() (params kmsAPI.KMSVersionParams, api operations.ConsoleAPI) {
-	registerKMSHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	return params, api
-}
-
-func (suite *KMSTestSuite) TestKMSVersionWithoutError() {
-	ctx := context.Background()
-	res, err := kmsVersion(ctx, suite.adminClient)
-	suite.assert.NotNil(res)
-	suite.assert.Nil(err)
-}
-
-func (suite *KMSTestSuite) TestKMSCreateKeyHandlerWithError() {
-	params, api := suite.initKMSCreateKeyRequest()
-	response := api.KmsKMSCreateKeyHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*kmsAPI.KMSCreateKeyDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *KMSTestSuite) initKMSCreateKeyRequest() (params kmsAPI.KMSCreateKeyParams, api operations.ConsoleAPI) {
-	registerKMSHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	key := "key"
-	params.Body = &models.KmsCreateKeyRequest{Key: &key}
-	return params, api
-}
-
-func (suite *KMSTestSuite) TestKMSCreateKeyWithoutError() {
-	ctx := context.Background()
-	err := createKey(ctx, "key", suite.adminClient)
-	suite.assert.Nil(err)
-}
-
-func (suite *KMSTestSuite) TestKMSListKeysHandlerWithError() {
-	params, api := suite.initKMSListKeysRequest()
-	response := api.KmsKMSListKeysHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*kmsAPI.KMSListKeysDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *KMSTestSuite) initKMSListKeysRequest() (params kmsAPI.KMSListKeysParams, api operations.ConsoleAPI) {
-	registerKMSHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	return params, api
-}
-
-func (suite *KMSTestSuite) TestKMSListKeysWithoutError() {
-	ctx := context.Background()
-	res, err := listKeys(ctx, "", suite.adminClient)
-	suite.assert.NotNil(res)
-	suite.assert.Nil(err)
-}
-
-func (suite *KMSTestSuite) TestKMSKeyStatusHandlerWithError() {
-	params, api := suite.initKMSKeyStatusRequest()
-	response := api.KmsKMSKeyStatusHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*kmsAPI.KMSKeyStatusDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *KMSTestSuite) initKMSKeyStatusRequest() (params kmsAPI.KMSKeyStatusParams, api operations.ConsoleAPI) {
-	registerKMSHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	return params, api
-}
-
-func (suite *KMSTestSuite) TestKMSKeyStatusWithoutError() {
-	ctx := context.Background()
-	res, err := keyStatus(ctx, "key", suite.adminClient)
-	suite.assert.NotNil(res)
-	suite.assert.Nil(err)
-}
-
-func TestKMS(t *testing.T) {
-	suite.Run(t, new(KMSTestSuite))
-}

api/admin_nodes.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 api
-
-import (
-	"context"
-
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/minio/console/api/operations"
-	systemApi "github.com/minio/console/api/operations/system"
-	"github.com/minio/console/models"
-)
-
-func registerNodesHandler(api *operations.ConsoleAPI) {
-	api.SystemListNodesHandler = systemApi.ListNodesHandlerFunc(func(params systemApi.ListNodesParams, session *models.Principal) middleware.Responder {
-		listNodesResponse, err := getListNodesResponse(session, params)
-		if err != nil {
-			return systemApi.NewListNodesDefault(err.Code).WithPayload(err.APIError)
-		}
-		return systemApi.NewListNodesOK().WithPayload(listNodesResponse)
-	})
-}
-
-// getListNodesResponse returns a list of available node endpoints .
-func getListNodesResponse(session *models.Principal, params systemApi.ListNodesParams) ([]string, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	var nodeList []string
-
-	adminResources, _ := mAdmin.ServerInfo(ctx)
-
-	for _, n := range adminResources.Servers {
-		nodeList = append(nodeList, n.Endpoint)
-	}
-
-	return nodeList, nil
-}

api/admin_notification_endpoints.go

@@ -1,162 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2021 MinIO, Inc.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package api
-
-import (
-	"context"
-	"errors"
-
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/minio/console/api/operations"
-	configurationApi "github.com/minio/console/api/operations/configuration"
-	"github.com/minio/console/models"
-)
-
-func registerAdminNotificationEndpointsHandlers(api *operations.ConsoleAPI) {
-	// return a list of notification endpoints
-	api.ConfigurationNotificationEndpointListHandler = configurationApi.NotificationEndpointListHandlerFunc(func(params configurationApi.NotificationEndpointListParams, session *models.Principal) middleware.Responder {
-		notifEndpoints, err := getNotificationEndpointsResponse(session, params)
-		if err != nil {
-			return configurationApi.NewNotificationEndpointListDefault(err.Code).WithPayload(err.APIError)
-		}
-		return configurationApi.NewNotificationEndpointListOK().WithPayload(notifEndpoints)
-	})
-	// add a new notification endpoints
-	api.ConfigurationAddNotificationEndpointHandler = configurationApi.AddNotificationEndpointHandlerFunc(func(params configurationApi.AddNotificationEndpointParams, session *models.Principal) middleware.Responder {
-		notifEndpoints, err := getAddNotificationEndpointResponse(session, params)
-		if err != nil {
-			return configurationApi.NewAddNotificationEndpointDefault(err.Code).WithPayload(err.APIError)
-		}
-		return configurationApi.NewAddNotificationEndpointCreated().WithPayload(notifEndpoints)
-	})
-}
-
-// getNotificationEndpoints invokes admin info and returns a list of notification endpoints
-func getNotificationEndpoints(ctx context.Context, client MinioAdmin) (*models.NotifEndpointResponse, error) {
-	serverInfo, err := client.serverInfo(ctx)
-	if err != nil {
-		return nil, err
-	}
-	var listEndpoints []*models.NotificationEndpointItem
-	for i := range serverInfo.Services.Notifications {
-		for service, endpointStatus := range serverInfo.Services.Notifications[i] {
-			for j := range endpointStatus {
-				for account, status := range endpointStatus[j] {
-					listEndpoints = append(listEndpoints, &models.NotificationEndpointItem{
-						Service:   models.NofiticationService(service),
-						AccountID: account,
-						Status:    status.Status,
-					})
-				}
-			}
-		}
-	}
-
-	// build response
-	return &models.NotifEndpointResponse{
-		NotificationEndpoints: listEndpoints,
-	}, nil
-}
-
-// getNotificationEndpointsResponse returns a list of notification endpoints in the instance
-func getNotificationEndpointsResponse(session *models.Principal, params configurationApi.NotificationEndpointListParams) (*models.NotifEndpointResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-	// serialize output
-	notfEndpointResp, err := getNotificationEndpoints(ctx, adminClient)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return notfEndpointResp, nil
-}
-
-func addNotificationEndpoint(ctx context.Context, client MinioAdmin, params *configurationApi.AddNotificationEndpointParams) (*models.SetNotificationEndpointResponse, error) {
-	configs := []*models.ConfigurationKV{}
-	var configName string
-
-	// we have different add validations for each service
-	switch *params.Body.Service {
-	case models.NofiticationServiceAmqp:
-		configName = "notify_amqp"
-	case models.NofiticationServiceMqtt:
-		configName = "notify_mqtt"
-	case models.NofiticationServiceElasticsearch:
-		configName = "notify_elasticsearch"
-	case models.NofiticationServiceRedis:
-		configName = "notify_redis"
-	case models.NofiticationServiceNats:
-		configName = "notify_nats"
-	case models.NofiticationServicePostgres:
-		configName = "notify_postgres"
-	case models.NofiticationServiceMysql:
-		configName = "notify_mysql"
-	case models.NofiticationServiceKafka:
-		configName = "notify_kafka"
-	case models.NofiticationServiceWebhook:
-		configName = "notify_webhook"
-	case models.NofiticationServiceNsq:
-		configName = "notify_nsq"
-	default:
-		return nil, errors.New("provided service is not supported")
-	}
-
-	// set all the config values if found on the param.Body.Properties
-	for k, val := range params.Body.Properties {
-		configs = append(configs, &models.ConfigurationKV{
-			Key:   k,
-			Value: val,
-		})
-	}
-
-	needsRestart, err := setConfigWithARNAccountID(ctx, client, &configName, configs, *params.Body.AccountID)
-	if err != nil {
-		return nil, err
-	}
-
-	return &models.SetNotificationEndpointResponse{
-		AccountID:  params.Body.AccountID,
-		Properties: params.Body.Properties,
-		Service:    params.Body.Service,
-		Restart:    needsRestart,
-	}, nil
-}
-
-// getNotificationEndpointsResponse returns a list of notification endpoints in the instance
-func getAddNotificationEndpointResponse(session *models.Principal, params configurationApi.AddNotificationEndpointParams) (*models.SetNotificationEndpointResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-	// serialize output
-	notfEndpointResp, err := addNotificationEndpoint(ctx, adminClient, &params)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return notfEndpointResp, nil
-}

api/admin_notification_endpoints_test.go

@@ -1,454 +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 api
-
-import (
-	"context"
-	"errors"
-	"reflect"
-	"testing"
-
-	"github.com/go-openapi/swag"
-
-	cfgApi "github.com/minio/console/api/operations/configuration"
-	"github.com/minio/console/models"
-)
-
-func Test_addNotificationEndpoint(t *testing.T) {
-	client := AdminClientMock{}
-
-	type args struct {
-		ctx    context.Context
-		client MinioAdmin
-		params *cfgApi.AddNotificationEndpointParams
-	}
-	tests := []struct {
-		name          string
-		args          args
-		mockSetConfig func(kv string) (restart bool, err error)
-		want          *models.SetNotificationEndpointResponse
-		wantErr       bool
-	}{
-		{
-			name: "valid postgres",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"host":     "localhost",
-							"user":     "user",
-							"password": "passwrd",
-						},
-						Service: models.NewNofiticationService("postgres"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, nil
-			},
-			want: &models.SetNotificationEndpointResponse{
-				AccountID: swag.String("1"),
-				Properties: map[string]string{
-					"host":     "localhost",
-					"user":     "user",
-					"password": "passwrd",
-				},
-				Service: models.NewNofiticationService("postgres"),
-				Restart: false,
-			},
-			wantErr: false,
-		},
-		{
-			name: "set config returns error",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"host":     "localhost",
-							"user":     "user",
-							"password": "passwrd",
-						},
-						Service: models.NewNofiticationService("postgres"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, errors.New("error")
-			},
-			want:    nil,
-			wantErr: true,
-		},
-		{
-			name: "valid mysql",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"host":     "localhost",
-							"user":     "user",
-							"password": "passwrd",
-						},
-						Service: models.NewNofiticationService("mysql"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, nil
-			},
-			want: &models.SetNotificationEndpointResponse{
-				AccountID: swag.String("1"),
-				Properties: map[string]string{
-					"host":     "localhost",
-					"user":     "user",
-					"password": "passwrd",
-				},
-				Service: models.NewNofiticationService("mysql"),
-				Restart: false,
-			},
-			wantErr: false,
-		},
-		{
-			name: "valid kafka",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"brokers": "http://localhost:8080/broker1",
-						},
-						Service: models.NewNofiticationService("kafka"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, nil
-			},
-			want: &models.SetNotificationEndpointResponse{
-				AccountID: swag.String("1"),
-				Properties: map[string]string{
-					"brokers": "http://localhost:8080/broker1",
-				},
-				Service: models.NewNofiticationService("kafka"),
-				Restart: false,
-			},
-			wantErr: false,
-		},
-		{
-			name: "valid amqp",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"url": "http://localhost:8080/broker1",
-						},
-						Service: models.NewNofiticationService("amqp"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, nil
-			},
-			want: &models.SetNotificationEndpointResponse{
-				AccountID: swag.String("1"),
-				Properties: map[string]string{
-					"url": "http://localhost:8080/broker1",
-				},
-				Service: models.NewNofiticationService("amqp"),
-				Restart: false,
-			},
-			wantErr: false,
-		},
-		{
-			name: "valid mqtt",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"broker": "http://localhost:8080/broker1",
-							"topic":  "minio",
-						},
-						Service: models.NewNofiticationService("mqtt"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, nil
-			},
-			want: &models.SetNotificationEndpointResponse{
-				AccountID: swag.String("1"),
-				Properties: map[string]string{
-					"broker": "http://localhost:8080/broker1",
-					"topic":  "minio",
-				},
-				Service: models.NewNofiticationService("mqtt"),
-				Restart: false,
-			},
-			wantErr: false,
-		},
-		{
-			name: "valid elasticsearch",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"url":    "http://localhost:8080/broker1",
-							"index":  "minio",
-							"format": "namespace",
-						},
-						Service: models.NewNofiticationService("elasticsearch"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, nil
-			},
-			want: &models.SetNotificationEndpointResponse{
-				AccountID: swag.String("1"),
-				Properties: map[string]string{
-					"url":    "http://localhost:8080/broker1",
-					"index":  "minio",
-					"format": "namespace",
-				},
-				Service: models.NewNofiticationService("elasticsearch"),
-				Restart: false,
-			},
-			wantErr: false,
-		},
-		{
-			name: "valid redis",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"address": "http://localhost:8080/broker1",
-							"key":     "minio",
-							"format":  "namespace",
-						},
-						Service: models.NewNofiticationService("redis"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, nil
-			},
-			want: &models.SetNotificationEndpointResponse{
-				AccountID: swag.String("1"),
-				Properties: map[string]string{
-					"address": "http://localhost:8080/broker1",
-					"key":     "minio",
-					"format":  "namespace",
-				},
-				Service: models.NewNofiticationService("redis"),
-				Restart: false,
-			},
-			wantErr: false,
-		},
-		{
-			name: "valid nats",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"address": "http://localhost:8080/broker1",
-							"subject": "minio",
-						},
-						Service: models.NewNofiticationService("nats"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, nil
-			},
-			want: &models.SetNotificationEndpointResponse{
-				AccountID: swag.String("1"),
-				Properties: map[string]string{
-					"address": "http://localhost:8080/broker1",
-					"subject": "minio",
-				},
-				Service: models.NewNofiticationService("nats"),
-				Restart: false,
-			},
-			wantErr: false,
-		},
-		{
-			name: "valid webhook",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"endpoint": "http://localhost:8080/broker1",
-						},
-						Service: models.NewNofiticationService("webhook"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, nil
-			},
-			want: &models.SetNotificationEndpointResponse{
-				AccountID: swag.String("1"),
-				Properties: map[string]string{
-					"endpoint": "http://localhost:8080/broker1",
-				},
-				Service: models.NewNofiticationService("webhook"),
-				Restart: false,
-			},
-			wantErr: false,
-		},
-		{
-			name: "valid nsq",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"nsqd_address": "http://localhost:8080/broker1",
-							"topic":        "minio",
-						},
-						Service: models.NewNofiticationService("nsq"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, nil
-			},
-			want: &models.SetNotificationEndpointResponse{
-				AccountID: swag.String("1"),
-				Properties: map[string]string{
-					"nsqd_address": "http://localhost:8080/broker1",
-					"topic":        "minio",
-				},
-				Service: models.NewNofiticationService("nsq"),
-				Restart: false,
-			},
-			wantErr: false,
-		},
-		{
-			name: "invalid service",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"host":     "localhost",
-							"user":     "user",
-							"password": "passwrd",
-						},
-						Service: models.NewNofiticationService("oorgle"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return false, errors.New("invalid config")
-			},
-			want:    nil,
-			wantErr: true,
-		},
-		{
-			name: "valid config, restart required",
-			args: args{
-				ctx:    context.Background(),
-				client: client,
-				params: &cfgApi.AddNotificationEndpointParams{
-					HTTPRequest: nil,
-					Body: &models.NotificationEndpoint{
-						AccountID: swag.String("1"),
-						Properties: map[string]string{
-							"host":     "localhost",
-							"user":     "user",
-							"password": "passwrd",
-						},
-						Service: models.NewNofiticationService("postgres"),
-					},
-				},
-			},
-			mockSetConfig: func(_ string) (restart bool, err error) {
-				return true, nil
-			},
-			want: &models.SetNotificationEndpointResponse{
-				AccountID: swag.String("1"),
-				Properties: map[string]string{
-					"host":     "localhost",
-					"user":     "user",
-					"password": "passwrd",
-				},
-				Service: models.NewNofiticationService("postgres"),
-				Restart: true,
-			},
-			wantErr: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(_ *testing.T) {
-			// mock function response from setConfig()
-			minioSetConfigKVMock = tt.mockSetConfig
-			got, err := addNotificationEndpoint(tt.args.ctx, tt.args.client, tt.args.params)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("addNotificationEndpoint() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("addNotificationEndpoint() got = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}

api/admin_policies.go

@@ -1,695 +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 api
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"sort"
-	"strings"
-
-	bucketApi "github.com/minio/console/api/operations/bucket"
-	policyApi "github.com/minio/console/api/operations/policy"
-	s3 "github.com/minio/minio-go/v7"
-
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/minio/console/api/operations"
-	"github.com/minio/console/models"
-	iampolicy "github.com/minio/pkg/v3/policy"
-
-	policies "github.com/minio/console/api/policy"
-)
-
-func registersPoliciesHandler(api *operations.ConsoleAPI) {
-	// List Policies
-	api.PolicyListPoliciesHandler = policyApi.ListPoliciesHandlerFunc(func(params policyApi.ListPoliciesParams, session *models.Principal) middleware.Responder {
-		listPoliciesResponse, err := getListPoliciesResponse(session, params)
-		if err != nil {
-			return policyApi.NewListPoliciesDefault(err.Code).WithPayload(err.APIError)
-		}
-		return policyApi.NewListPoliciesOK().WithPayload(listPoliciesResponse)
-	})
-	// Policy Info
-	api.PolicyPolicyInfoHandler = policyApi.PolicyInfoHandlerFunc(func(params policyApi.PolicyInfoParams, session *models.Principal) middleware.Responder {
-		policyInfo, err := getPolicyInfoResponse(session, params)
-		if err != nil {
-			return policyApi.NewPolicyInfoDefault(err.Code).WithPayload(err.APIError)
-		}
-		return policyApi.NewPolicyInfoOK().WithPayload(policyInfo)
-	})
-	// Add Policy
-	api.PolicyAddPolicyHandler = policyApi.AddPolicyHandlerFunc(func(params policyApi.AddPolicyParams, session *models.Principal) middleware.Responder {
-		policyResponse, err := getAddPolicyResponse(session, params)
-		if err != nil {
-			return policyApi.NewAddPolicyDefault(err.Code).WithPayload(err.APIError)
-		}
-		return policyApi.NewAddPolicyCreated().WithPayload(policyResponse)
-	})
-	// Remove Policy
-	api.PolicyRemovePolicyHandler = policyApi.RemovePolicyHandlerFunc(func(params policyApi.RemovePolicyParams, session *models.Principal) middleware.Responder {
-		if err := getRemovePolicyResponse(session, params); err != nil {
-			return policyApi.NewRemovePolicyDefault(err.Code).WithPayload(err.APIError)
-		}
-		return policyApi.NewRemovePolicyNoContent()
-	})
-	// Set Policy
-	api.PolicySetPolicyHandler = policyApi.SetPolicyHandlerFunc(func(params policyApi.SetPolicyParams, session *models.Principal) middleware.Responder {
-		if err := getSetPolicyResponse(session, params); err != nil {
-			return policyApi.NewSetPolicyDefault(err.Code).WithPayload(err.APIError)
-		}
-		return policyApi.NewSetPolicyNoContent()
-	})
-	// Set Policy Multiple User/Groups
-	api.PolicySetPolicyMultipleHandler = policyApi.SetPolicyMultipleHandlerFunc(func(params policyApi.SetPolicyMultipleParams, session *models.Principal) middleware.Responder {
-		if err := getSetPolicyMultipleResponse(session, params); err != nil {
-			return policyApi.NewSetPolicyMultipleDefault(err.Code).WithPayload(err.APIError)
-		}
-		return policyApi.NewSetPolicyMultipleNoContent()
-	})
-	api.BucketListPoliciesWithBucketHandler = bucketApi.ListPoliciesWithBucketHandlerFunc(func(params bucketApi.ListPoliciesWithBucketParams, session *models.Principal) middleware.Responder {
-		policyResponse, err := getListPoliciesWithBucketResponse(session, params)
-		if err != nil {
-			return bucketApi.NewListPoliciesWithBucketDefault(err.Code).WithPayload(err.APIError)
-		}
-		return bucketApi.NewListPoliciesWithBucketOK().WithPayload(policyResponse)
-	})
-	api.BucketListAccessRulesWithBucketHandler = bucketApi.ListAccessRulesWithBucketHandlerFunc(func(params bucketApi.ListAccessRulesWithBucketParams, session *models.Principal) middleware.Responder {
-		policyResponse, err := getListAccessRulesWithBucketResponse(session, params)
-		if err != nil {
-			return bucketApi.NewListAccessRulesWithBucketDefault(err.Code).WithPayload(err.APIError)
-		}
-		return bucketApi.NewListAccessRulesWithBucketOK().WithPayload(policyResponse)
-	})
-	api.BucketSetAccessRuleWithBucketHandler = bucketApi.SetAccessRuleWithBucketHandlerFunc(func(params bucketApi.SetAccessRuleWithBucketParams, session *models.Principal) middleware.Responder {
-		policyResponse, err := getSetAccessRuleWithBucketResponse(session, params)
-		if err != nil {
-			return bucketApi.NewSetAccessRuleWithBucketDefault(err.Code).WithPayload(err.APIError)
-		}
-		return bucketApi.NewSetAccessRuleWithBucketOK().WithPayload(policyResponse)
-	})
-	api.BucketDeleteAccessRuleWithBucketHandler = bucketApi.DeleteAccessRuleWithBucketHandlerFunc(func(params bucketApi.DeleteAccessRuleWithBucketParams, session *models.Principal) middleware.Responder {
-		policyResponse, err := getDeleteAccessRuleWithBucketResponse(session, params)
-		if err != nil {
-			return bucketApi.NewDeleteAccessRuleWithBucketDefault(err.Code).WithPayload(err.APIError)
-		}
-		return bucketApi.NewDeleteAccessRuleWithBucketOK().WithPayload(policyResponse)
-	})
-	api.PolicyListUsersForPolicyHandler = policyApi.ListUsersForPolicyHandlerFunc(func(params policyApi.ListUsersForPolicyParams, session *models.Principal) middleware.Responder {
-		policyUsersResponse, err := getListUsersForPolicyResponse(session, params)
-		if err != nil {
-			return policyApi.NewListUsersForPolicyDefault(err.Code).WithPayload(err.APIError)
-		}
-		return policyApi.NewListUsersForPolicyOK().WithPayload(policyUsersResponse)
-	})
-	api.PolicyListGroupsForPolicyHandler = policyApi.ListGroupsForPolicyHandlerFunc(func(params policyApi.ListGroupsForPolicyParams, session *models.Principal) middleware.Responder {
-		policyGroupsResponse, err := getListGroupsForPolicyResponse(session, params)
-		if err != nil {
-			return policyApi.NewListGroupsForPolicyDefault(err.Code).WithPayload(err.APIError)
-		}
-		return policyApi.NewListGroupsForPolicyOK().WithPayload(policyGroupsResponse)
-	})
-	// Gets policies for currently logged in user
-	api.PolicyGetUserPolicyHandler = policyApi.GetUserPolicyHandlerFunc(func(params policyApi.GetUserPolicyParams, session *models.Principal) middleware.Responder {
-		userPolicyResponse, err := getUserPolicyResponse(params.HTTPRequest.Context(), session)
-		if err != nil {
-			return policyApi.NewGetUserPolicyDefault(err.Code).WithPayload(err.APIError)
-		}
-		return policyApi.NewGetUserPolicyOK().WithPayload(userPolicyResponse)
-	})
-	// Gets policies for specified user
-	api.PolicyGetSAUserPolicyHandler = policyApi.GetSAUserPolicyHandlerFunc(func(params policyApi.GetSAUserPolicyParams, session *models.Principal) middleware.Responder {
-		userPolicyResponse, err := getSAUserPolicyResponse(session, params)
-		if err != nil {
-			return policyApi.NewGetSAUserPolicyDefault(err.Code).WithPayload(err.APIError)
-		}
-		return policyApi.NewGetSAUserPolicyOK().WithPayload(userPolicyResponse)
-	})
-}
-
-func getListAccessRulesWithBucketResponse(session *models.Principal, params bucketApi.ListAccessRulesWithBucketParams) (*models.ListAccessRulesResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	bucket := params.Bucket
-	client, err := newS3BucketClient(session, bucket, "", getClientIP(params.HTTPRequest))
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	accessRules, _ := client.GetAccessRules(ctx)
-	var accessRuleList []*models.AccessRule
-	for k, v := range accessRules {
-		accessRuleList = append(accessRuleList, &models.AccessRule{Prefix: k[len(bucket)+1 : len(k)-1], Access: v})
-	}
-	return &models.ListAccessRulesResponse{AccessRules: accessRuleList}, nil
-}
-
-func getSetAccessRuleWithBucketResponse(session *models.Principal, params bucketApi.SetAccessRuleWithBucketParams) (bool, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	prefixAccess := params.Prefixaccess
-	client, err := newS3BucketClient(session, params.Bucket, prefixAccess.Prefix, getClientIP(params.HTTPRequest))
-	if err != nil {
-		return false, ErrorWithContext(ctx, err)
-	}
-	errorVal := client.SetAccess(ctx, prefixAccess.Access, false)
-	if errorVal != nil {
-		returnError := ErrorWithContext(ctx, errorVal.Cause)
-		minioError := s3.ToErrorResponse(errorVal.Cause)
-		if minioError.Code == "NoSuchBucket" {
-			returnError.Code = 404
-		}
-		return false, returnError
-	}
-	return true, nil
-}
-
-func getDeleteAccessRuleWithBucketResponse(session *models.Principal, params bucketApi.DeleteAccessRuleWithBucketParams) (bool, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	bucket := params.Bucket
-	prefix := params.Prefix
-	client, err := newS3BucketClient(session, bucket, prefix.Prefix, getClientIP(params.HTTPRequest))
-	if err != nil {
-		return false, ErrorWithContext(ctx, err)
-	}
-	errorVal := client.SetAccess(ctx, "none", false)
-	if errorVal != nil {
-		return false, ErrorWithContext(ctx, errorVal.Cause)
-	}
-	return true, nil
-}
-
-func getListPoliciesWithBucketResponse(session *models.Principal, params bucketApi.ListPoliciesWithBucketParams) (*models.ListPoliciesResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	policies, err := listPoliciesWithBucket(ctx, params.Bucket, adminClient)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// serialize output
-	listPoliciesResponse := &models.ListPoliciesResponse{
-		Policies: policies,
-		Total:    int64(len(policies)),
-	}
-	return listPoliciesResponse, nil
-}
-
-// listPoliciesWithBucket calls MinIO server to list all policy names present on the server that apply to a particular bucket.
-// listPoliciesWithBucket() converts the map[string][]byte returned by client.listPolicies()
-// to []*models.Policy by iterating over each key in policyRawMap and
-// then using Unmarshal on the raw bytes to create a *models.Policy
-func listPoliciesWithBucket(ctx context.Context, bucket string, client MinioAdmin) ([]*models.Policy, error) {
-	policyMap, err := client.listPolicies(ctx)
-	var policies []*models.Policy
-	if err != nil {
-		return nil, err
-	}
-	for name, policy := range policyMap {
-		policy, err := parsePolicy(name, policy)
-		if err != nil {
-			return nil, err
-		}
-		if policyMatchesBucket(ctx, policy, bucket) {
-			policies = append(policies, policy)
-		}
-	}
-	return policies, nil
-}
-
-func policyMatchesBucket(ctx context.Context, policy *models.Policy, bucket string) bool {
-	policyData := &iampolicy.Policy{}
-	err := json.Unmarshal([]byte(policy.Policy), policyData)
-	if err != nil {
-		ErrorWithContext(ctx, fmt.Errorf("error parsing policy: %v", err))
-		return false
-	}
-	policyStatements := policyData.Statements
-	for i := 0; i < len(policyStatements); i++ {
-		resources := policyStatements[i].Resources
-		if resources.Match(bucket, map[string][]string{}) {
-			return true
-		}
-		if resources.Match(fmt.Sprintf("%s/*", bucket), map[string][]string{}) {
-			return true
-		}
-	}
-	return false
-}
-
-// listPolicies calls MinIO server to list all policy names present on the server.
-// listPolicies() converts the map[string][]byte returned by client.listPolicies()
-// to []*models.Policy by iterating over each key in policyRawMap and
-// then using Unmarshal on the raw bytes to create a *models.Policy
-func listPolicies(ctx context.Context, client MinioAdmin) ([]*models.Policy, error) {
-	policyMap, err := client.listPolicies(ctx)
-	var policies []*models.Policy
-	if err != nil {
-		return nil, err
-	}
-	for name, policy := range policyMap {
-		policy, err := parsePolicy(name, policy)
-		if err != nil {
-			return nil, err
-		}
-		policies = append(policies, policy)
-	}
-	return policies, nil
-}
-
-// getListPoliciesResponse performs listPolicies() and serializes it to the handler's output
-func getListPoliciesResponse(session *models.Principal, params policyApi.ListPoliciesParams) (*models.ListPoliciesResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	policies, err := listPolicies(ctx, adminClient)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// serialize output
-	listPoliciesResponse := &models.ListPoliciesResponse{
-		Policies: policies,
-		Total:    int64(len(policies)),
-	}
-	return listPoliciesResponse, nil
-}
-
-// getListUsersForPoliciesResponse performs lists users affected by a given policy.
-func getListUsersForPolicyResponse(session *models.Principal, params policyApi.ListUsersForPolicyParams) ([]string, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-	policies, err := listPolicies(ctx, adminClient)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	found := false
-	for i := range policies {
-		if policies[i].Name == params.Policy {
-			found = true
-		}
-	}
-	if !found {
-		return nil, ErrorWithContext(ctx, ErrPolicyNotFound, fmt.Errorf("the policy %s does not exist", params.Policy))
-	}
-	users, err := listUsers(ctx, adminClient)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	var filteredUsers []string
-	for _, user := range users {
-		for _, upolicy := range user.Policy {
-			if upolicy == params.Policy {
-				filteredUsers = append(filteredUsers, user.AccessKey)
-				break
-			}
-		}
-	}
-	sort.Strings(filteredUsers)
-	return filteredUsers, nil
-}
-
-func getUserPolicyResponse(ctx context.Context, session *models.Principal) (string, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
-	// serialize output
-	if session == nil {
-		return "nil", ErrorWithContext(ctx, ErrPolicyNotFound)
-	}
-	tokenClaims, _ := getClaimsFromToken(session.STSSessionToken)
-
-	// initialize admin client
-	mAdminClient, err := NewMinioAdminClient(ctx, &models.Principal{
-		STSAccessKeyID:     session.STSAccessKeyID,
-		STSSecretAccessKey: session.STSSecretAccessKey,
-		STSSessionToken:    session.STSSessionToken,
-	})
-	if err != nil {
-		return "nil", ErrorWithContext(ctx, err)
-	}
-	userAdminClient := AdminClient{Client: mAdminClient}
-	// Obtain the current policy assigned to this user
-	// necessary for generating the list of allowed endpoints
-	accountInfo, err := getAccountInfo(ctx, userAdminClient)
-	if err != nil {
-		return "nil", ErrorWithContext(ctx, err)
-	}
-	rawPolicy := policies.ReplacePolicyVariables(tokenClaims, accountInfo)
-	return string(rawPolicy), nil
-}
-
-func getSAUserPolicyResponse(session *models.Principal, params policyApi.GetSAUserPolicyParams) (*models.AUserPolicyResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	// serialize output
-	if session == nil {
-		return nil, ErrorWithContext(ctx, ErrPolicyNotFound)
-	}
-	// initialize admin client
-	mAdminClient, err := NewMinioAdminClient(params.HTTPRequest.Context(), &models.Principal{
-		STSAccessKeyID:     session.STSAccessKeyID,
-		STSSecretAccessKey: session.STSSecretAccessKey,
-		STSSessionToken:    session.STSSessionToken,
-	})
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	userAdminClient := AdminClient{Client: mAdminClient}
-
-	user, err := getUserInfo(ctx, userAdminClient, params.Name)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	var userPolicies []string
-	if len(user.PolicyName) > 0 {
-		userPolicies = strings.Split(user.PolicyName, ",")
-	}
-
-	for _, group := range user.MemberOf {
-		groupDesc, err := groupInfo(ctx, userAdminClient, group)
-		if err != nil {
-			return nil, ErrorWithContext(ctx, err)
-		}
-		if groupDesc.Policy != "" {
-			userPolicies = append(userPolicies, strings.Split(groupDesc.Policy, ",")...)
-		}
-	}
-
-	allKeys := make(map[string]bool)
-	var userPolicyList []string
-
-	for _, item := range userPolicies {
-		if _, value := allKeys[item]; !value {
-			allKeys[item] = true
-			userPolicyList = append(userPolicyList, item)
-		}
-	}
-	var userStatements []iampolicy.Statement
-
-	for _, pol := range userPolicyList {
-		policy, err := getPolicyStatements(ctx, userAdminClient, pol)
-		if err != nil {
-			return nil, ErrorWithContext(ctx, err)
-		}
-		userStatements = append(userStatements, policy...)
-	}
-
-	combinedPolicy := iampolicy.Policy{
-		Version:    "2012-10-17",
-		Statements: userStatements,
-	}
-
-	stringPolicy, err := json.Marshal(combinedPolicy)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	parsedPolicy := string(stringPolicy)
-
-	getUserPoliciesResponse := &models.AUserPolicyResponse{
-		Policy: parsedPolicy,
-	}
-
-	return getUserPoliciesResponse, nil
-}
-
-func getListGroupsForPolicyResponse(session *models.Principal, params policyApi.ListGroupsForPolicyParams) ([]string, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-	policies, err := listPolicies(ctx, adminClient)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	found := false
-	for i := range policies {
-		if policies[i].Name == params.Policy {
-			found = true
-		}
-	}
-	if !found {
-		return nil, ErrorWithContext(ctx, ErrPolicyNotFound, fmt.Errorf("the policy %s does not exist", params.Policy))
-	}
-
-	groups, err := adminClient.listGroups(ctx)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	var filteredGroups []string
-	for _, group := range groups {
-		info, err := groupInfo(ctx, adminClient, group)
-		if err != nil {
-			return nil, ErrorWithContext(ctx, err)
-		}
-		groupPolicies := strings.Split(info.Policy, ",")
-		for _, groupPolicy := range groupPolicies {
-			if groupPolicy == params.Policy {
-				filteredGroups = append(filteredGroups, group)
-			}
-		}
-	}
-	sort.Strings(filteredGroups)
-	return filteredGroups, nil
-}
-
-// removePolicy() calls MinIO server to remove a policy based on name.
-func removePolicy(ctx context.Context, client MinioAdmin, name string) error {
-	err := client.removePolicy(ctx, name)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// getRemovePolicyResponse() performs removePolicy() and serializes it to the handler's output
-func getRemovePolicyResponse(session *models.Principal, params policyApi.RemovePolicyParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	if params.Name == "" {
-		return ErrorWithContext(ctx, ErrPolicyNameNotInRequest)
-	}
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	if err := removePolicy(ctx, adminClient, params.Name); err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	return nil
-}
-
-// addPolicy calls MinIO server to add a canned policy.
-// addPolicy() takes name and policy in string format, policy
-// policy must be string in json format, in the future this will change
-// to a Policy struct{} - https://github.com/minio/minio/issues/9171
-func addPolicy(ctx context.Context, client MinioAdmin, name, policy string) (*models.Policy, error) {
-	iamp, err := iampolicy.ParseConfig(bytes.NewReader([]byte(policy)))
-	if err != nil {
-		return nil, err
-	}
-	if err := client.addPolicy(ctx, name, iamp); err != nil {
-		return nil, err
-	}
-	policyObject, err := policyInfo(ctx, client, name)
-	if err != nil {
-		return nil, err
-	}
-	return policyObject, nil
-}
-
-// getAddPolicyResponse performs addPolicy() and serializes it to the handler's output
-func getAddPolicyResponse(session *models.Principal, params policyApi.AddPolicyParams) (*models.Policy, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	if params.Body == nil {
-		return nil, ErrorWithContext(ctx, ErrPolicyBodyNotInRequest)
-	}
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-	policy, err := addPolicy(ctx, adminClient, *params.Body.Name, *params.Body.Policy)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return policy, nil
-}
-
-// policyInfo calls MinIO server to retrieve information of a canned policy.
-// policyInfo() takes a policy name, obtains the []byte (represents a string in JSON format)
-// and return it as *models.Policy , in the future this will change
-// to a Policy struct{} - https://github.com/minio/minio/issues/9171
-func policyInfo(ctx context.Context, client MinioAdmin, name string) (*models.Policy, error) {
-	policyRaw, err := client.getPolicy(ctx, name)
-	if err != nil {
-		return nil, err
-	}
-	policy, err := parsePolicy(name, policyRaw)
-	if err != nil {
-		return nil, err
-	}
-	return policy, nil
-}
-
-// getPolicy Statements calls MinIO server to retrieve information of a canned policy.
-// and returns the associated Statements
-func getPolicyStatements(ctx context.Context, client MinioAdmin, name string) ([]iampolicy.Statement, error) {
-	policyRaw, err := client.getPolicy(ctx, name)
-	if err != nil {
-		return nil, err
-	}
-
-	return policyRaw.Statements, nil
-}
-
-// getPolicyInfoResponse performs policyInfo() and serializes it to the handler's output
-func getPolicyInfoResponse(session *models.Principal, params policyApi.PolicyInfoParams) (*models.Policy, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-	policy, err := policyInfo(ctx, adminClient, params.Name)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return policy, nil
-}
-
-// SetPolicy calls MinIO server to assign policy to a group or user.
-func SetPolicy(ctx context.Context, client MinioAdmin, name, entityName string, entityType models.PolicyEntity) error {
-	isGroup := false
-	if entityType == models.PolicyEntityGroup {
-		isGroup = true
-	}
-	return client.setPolicy(ctx, name, entityName, isGroup)
-}
-
-// getSetPolicyResponse() performs SetPolicy() and serializes it to the handler's output
-func getSetPolicyResponse(session *models.Principal, params policyApi.SetPolicyParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	// Removing this section
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	if err := SetPolicy(ctx, adminClient, strings.Join(params.Body.Name, ","), *params.Body.EntityName, *params.Body.EntityType); err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	return nil
-}
-
-func getSetPolicyMultipleResponse(session *models.Principal, params policyApi.SetPolicyMultipleParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	if err := setPolicyMultipleEntities(ctx, adminClient, strings.Join(params.Body.Name, ","), params.Body.Users, params.Body.Groups); err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	return nil
-}
-
-// setPolicyMultipleEntities sets a policy to multiple users/groups
-func setPolicyMultipleEntities(ctx context.Context, client MinioAdmin, policyName string, users, groups []models.IamEntity) error {
-	for _, user := range users {
-		if err := client.setPolicy(ctx, policyName, string(user), false); err != nil {
-			return err
-		}
-	}
-	for _, group := range groups {
-		groupDesc, err := groupInfo(ctx, client, string(group))
-		if err != nil {
-			return err
-		}
-		allGroupPolicies := ""
-		if len(groups) > 1 {
-			allGroupPolicies = groupDesc.Policy + "," + policyName
-			s := strings.Split(allGroupPolicies, ",")
-			allGroupPolicies = strings.Join(UniqueKeys(s), ",")
-		} else {
-			allGroupPolicies = policyName
-		}
-		if err := client.setPolicy(ctx, allGroupPolicies, string(group), true); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// parsePolicy() converts from *rawPolicy to *models.Policy
-func parsePolicy(name string, rawPolicy *iampolicy.Policy) (*models.Policy, error) {
-	stringPolicy, err := json.Marshal(rawPolicy)
-	if err != nil {
-		return nil, err
-	}
-	policy := &models.Policy{
-		Name:   name,
-		Policy: string(stringPolicy),
-	}
-	return policy, nil
-}

api/admin_policies_test.go

@@ -1,382 +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 api
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"reflect"
-	"testing"
-
-	"github.com/minio/console/models"
-	iampolicy "github.com/minio/pkg/v3/policy"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestListPolicies(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	funcAssert := assert.New(t)
-	adminClient := AdminClientMock{}
-	// mock function response from listPolicies()
-	minioListPoliciesMock = func() (map[string]*iampolicy.Policy, error) {
-		var readonly iampolicy.Policy
-		var readwrite iampolicy.Policy
-		var diagnostis iampolicy.Policy
-
-		for _, p := range iampolicy.DefaultPolicies {
-			switch p.Name {
-			case "readonly":
-				readonly = p.Definition
-			case "readwrite":
-				readwrite = p.Definition
-			case "diagnostics":
-				diagnostis = p.Definition
-			}
-		}
-
-		return map[string]*iampolicy.Policy{
-			"readonly":    &readonly,
-			"readwrite":   &readwrite,
-			"diagnostics": &diagnostis,
-		}, nil
-	}
-	// Test-1 : listPolicies() Get response from minio client with three Canned Policies and return the same number on listPolicies()
-	function := "listPolicies()"
-	policiesList, err := listPolicies(ctx, adminClient)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// verify length of Policies is correct
-	funcAssert.Equal(3, len(policiesList), fmt.Sprintf("Failed on %s: length of Policies's lists is not the same", function))
-	// Test-2 : listPolicies() Return error and see that the error is handled correctly and returned
-	minioListPoliciesMock = func() (map[string]*iampolicy.Policy, error) {
-		return nil, errors.New("error")
-	}
-	_, err = listPolicies(ctx, adminClient)
-	if funcAssert.Error(err) {
-		funcAssert.Equal("error", err.Error())
-	}
-}
-
-func TestRemovePolicy(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	funcAssert := assert.New(t)
-	adminClient := AdminClientMock{}
-	// Test-1 : removePolicy() remove an existing policy
-	policyToRemove := "console-policy"
-	minioRemovePolicyMock = func(_ string) error {
-		return nil
-	}
-	function := "removePolicy()"
-	if err := removePolicy(ctx, adminClient, policyToRemove); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// Test-2 : removePolicy() Return error and see that the error is handled correctly and returned
-	minioRemovePolicyMock = func(_ string) error {
-		return errors.New("error")
-	}
-	if err := removePolicy(ctx, adminClient, policyToRemove); funcAssert.Error(err) {
-		funcAssert.Equal("error", err.Error())
-	}
-}
-
-func TestAddPolicy(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	funcAssert := assert.New(t)
-	adminClient := AdminClientMock{}
-	policyName := "new-policy"
-	policyDefinition := "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"s3:GetBucketLocation\",\"s3:GetObject\",\"s3:ListAllMyBuckets\"],\"Resource\":[\"arn:aws:s3:::*\"]}]}"
-	minioAddPolicyMock = func(_ string, _ *iampolicy.Policy) error {
-		return nil
-	}
-	minioGetPolicyMock = func(_ string) (*iampolicy.Policy, error) {
-		policy := "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"s3:GetBucketLocation\",\"s3:GetObject\",\"s3:ListAllMyBuckets\"],\"Resource\":[\"arn:aws:s3:::*\"]}]}"
-		iamp, err := iampolicy.ParseConfig(bytes.NewReader([]byte(policy)))
-		if err != nil {
-			return nil, err
-		}
-		return iamp, nil
-	}
-	assertPolicy := models.Policy{
-		Name:   "new-policy",
-		Policy: "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"s3:GetBucketLocation\",\"s3:GetObject\",\"s3:ListAllMyBuckets\"],\"Resource\":[\"arn:aws:s3:::*\"]}]}",
-	}
-	// Test-1 : addPolicy() adds a new policy
-	function := "addPolicy()"
-	policy, err := addPolicy(ctx, adminClient, policyName, policyDefinition)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	} else {
-		funcAssert.Equal(policy.Name, assertPolicy.Name)
-
-		var expectedPolicy iampolicy.Policy
-		var actualPolicy iampolicy.Policy
-		err1 := json.Unmarshal([]byte(policy.Policy), &expectedPolicy)
-		funcAssert.NoError(err1)
-		err2 := json.Unmarshal([]byte(assertPolicy.Policy), &actualPolicy)
-		funcAssert.NoError(err2)
-		funcAssert.Equal(expectedPolicy, actualPolicy)
-	}
-	// Test-2 : addPolicy() got an error while adding policy
-	minioAddPolicyMock = func(_ string, _ *iampolicy.Policy) error {
-		return errors.New("error")
-	}
-	if _, err := addPolicy(ctx, adminClient, policyName, policyDefinition); funcAssert.Error(err) {
-		funcAssert.Equal("error", err.Error())
-	}
-	// Test-3 : addPolicy() got an error while retrieving policy
-	minioAddPolicyMock = func(_ string, _ *iampolicy.Policy) error {
-		return nil
-	}
-	minioGetPolicyMock = func(_ string) (*iampolicy.Policy, error) {
-		return nil, errors.New("error")
-	}
-	if _, err := addPolicy(ctx, adminClient, policyName, policyDefinition); funcAssert.Error(err) {
-		funcAssert.Equal("error", err.Error())
-	}
-}
-
-func TestSetPolicy(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	funcAssert := assert.New(t)
-	adminClient := AdminClientMock{}
-	policyName := "readOnly"
-	entityName := "alevsk"
-	entityObject := models.PolicyEntityUser
-	minioSetPolicyMock = func(_, _ string, _ bool) error {
-		return nil
-	}
-	// Test-1 : SetPolicy() set policy to user
-	function := "SetPolicy()"
-	err := SetPolicy(ctx, adminClient, policyName, entityName, entityObject)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// Test-2 : SetPolicy() set policy to group
-	entityObject = models.PolicyEntityGroup
-	err = SetPolicy(ctx, adminClient, policyName, entityName, entityObject)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// Test-3 : SetPolicy() set policy to user and get error
-	entityObject = models.PolicyEntityUser
-	minioSetPolicyMock = func(_, _ string, _ bool) error {
-		return errors.New("error")
-	}
-	if err := SetPolicy(ctx, adminClient, policyName, entityName, entityObject); funcAssert.Error(err) {
-		funcAssert.Equal("error", err.Error())
-	}
-	// Test-4 : SetPolicy() set policy to group and get error
-	entityObject = models.PolicyEntityGroup
-	minioSetPolicyMock = func(_, _ string, _ bool) error {
-		return errors.New("error")
-	}
-	if err := SetPolicy(ctx, adminClient, policyName, entityName, entityObject); funcAssert.Error(err) {
-		funcAssert.Equal("error", err.Error())
-	}
-}
-
-func Test_SetPolicyMultiple(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	adminClient := AdminClientMock{}
-
-	type args struct {
-		policyName    string
-		users         []models.IamEntity
-		groups        []models.IamEntity
-		setPolicyFunc func(policyName, entityName string, isGroup bool) error
-	}
-	tests := []struct {
-		name          string
-		args          args
-		errorExpected error
-	}{
-		{
-			name: "Set policy to multiple users and groups",
-			args: args{
-				policyName: "readonly",
-				users:      []models.IamEntity{"user1", "user2"},
-				groups:     []models.IamEntity{"group1", "group2"},
-				setPolicyFunc: func(_, _ string, _ bool) error {
-					return nil
-				},
-			},
-			errorExpected: nil,
-		},
-		{
-			name: "Return error on set policy function",
-			args: args{
-				policyName: "readonly",
-				users:      []models.IamEntity{"user1", "user2"},
-				groups:     []models.IamEntity{"group1", "group2"},
-				setPolicyFunc: func(_, _ string, _ bool) error {
-					return errors.New("error set")
-				},
-			},
-			errorExpected: errors.New("error set"),
-		},
-		{
-			// Description: Empty lists of users and groups are acceptable
-			name: "Empty lists of users and groups",
-			args: args{
-				policyName: "readonly",
-				users:      []models.IamEntity{},
-				groups:     []models.IamEntity{},
-				setPolicyFunc: func(_, _ string, _ bool) error {
-					return nil
-				},
-			},
-			errorExpected: nil,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(_ *testing.T) {
-			minioSetPolicyMock = tt.args.setPolicyFunc
-			got := setPolicyMultipleEntities(ctx, adminClient, tt.args.policyName, tt.args.users, tt.args.groups)
-			if !reflect.DeepEqual(got, tt.errorExpected) {
-				ji, _ := json.Marshal(got)
-				vi, _ := json.Marshal(tt.errorExpected)
-				t.Errorf("got %s want %s", ji, vi)
-			}
-		})
-	}
-}
-
-func Test_policyMatchesBucket(t *testing.T) {
-	type args struct {
-		ctx    context.Context
-		policy *models.Policy
-		bucket string
-	}
-	tests := []struct {
-		name string
-		args args
-		want bool
-	}{
-		{
-			name: "Test1",
-			args: args{ctx: context.Background(), policy: &models.Policy{Name: "consoleAdmin", Policy: `{
-    "Version": "2012-10-17",
-    "Statement": [
-        {
-            "Effect": "Allow",
-            "Action": [
-                "admin:*"
-            ]
-        },
-        {
-            "Effect": "Allow",
-            "Action": [
-                "s3:*"
-            ],
-            "Resource": [
-                "arn:aws:s3:::*"
-            ]
-        }
-    ]
-}`}, bucket: "test1"},
-			want: true,
-		},
-		{
-			name: "Test2",
-			args: args{ctx: context.Background(), policy: &models.Policy{Name: "consoleAdmin", Policy: `{
-				"Version": "2012-10-17",
-				"Statement": [
-			{
-				"Effect": "Allow",
-				"Action": [
-				"s3:*"
-			],
-				"Resource": [
-				"arn:aws:s3:::bucket1"
-			]
-			}
-			]
-			}`}, bucket: "test1"},
-			want: false,
-		},
-		{
-			name: "Test3",
-			args: args{ctx: context.Background(), policy: &models.Policy{Name: "consoleAdmin", Policy: `{
-    "Version": "2012-10-17",
-    "Statement": [
-        {
-            "Sid": "VisualEditor0",
-            "Effect": "Allow",
-            "Action": [
-                "s3:ListStorageLensConfigurations",
-                "s3:GetAccessPoint",
-                "s3:PutAccountPublicAccessBlock",
-                "s3:GetAccountPublicAccessBlock",
-                "s3:ListAllMyBuckets",
-                "s3:ListAccessPoints",
-                "s3:ListJobs",
-                "s3:PutStorageLensConfiguration",
-                "s3:CreateJob"
-            ],
-            "Resource": "*"
-        },
-        {
-            "Sid": "VisualEditor1",
-            "Effect": "Allow",
-            "Action": "s3:*",
-            "Resource": [
-                "arn:aws:s3:::test",
-                "arn:aws:s3:::test/*",
-                "arn:aws:s3:::lkasdkljasd090901",
-                "arn:aws:s3:::lkasdkljasd090901/*"
-                ]
-        }
-    ]
-	}`}, bucket: "test1"},
-			want: false,
-		},
-		{
-			name: "Test4",
-			args: args{ctx: context.Background(), policy: &models.Policy{Name: "consoleAdmin", Policy: `{
-				"Version": "2012-10-17",
-				"Statement": [
-			{
-				"Effect": "Allow",
-				"Action": [
-				"s3:*"
-			],
-				"Resource": [
-				"arn:aws:s3:::bucket1"
-			]
-			}
-			]
-			}`}, bucket: "bucket1"},
-			want: true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(_ *testing.T) {
-			if got := policyMatchesBucket(tt.args.ctx, tt.args.policy, tt.args.bucket); got != tt.want {
-				t.Errorf("policyMatchesBucket() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}

api/admin_profiling.go

@@ -1,63 +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 api
-
-import (
-	"context"
-	"io"
-	"net/http"
-
-	"github.com/minio/console/models"
-	"github.com/minio/madmin-go/v3"
-	"github.com/minio/websocket"
-)
-
-var items []*models.StartProfilingItem
-
-type profileOptions struct {
-	Types string
-}
-
-func getProfileOptionsFromReq(req *http.Request) (*profileOptions, error) {
-	pOptions := profileOptions{}
-	pOptions.Types = req.FormValue("types")
-	return &pOptions, nil
-}
-
-func startProfiling(ctx context.Context, conn WSConn, client MinioAdmin, pOpts *profileOptions) error {
-	profilingResults, err := client.startProfiling(ctx, madmin.ProfilerType(pOpts.Types))
-	if err != nil {
-		return err
-	}
-	items = []*models.StartProfilingItem{}
-	for _, result := range profilingResults {
-		items = append(items, &models.StartProfilingItem{
-			Success:  result.Success,
-			Error:    result.Error,
-			NodeName: result.NodeName,
-		})
-	}
-	zippedData, err := client.stopProfiling(ctx)
-	if err != nil {
-		return err
-	}
-	message, err := io.ReadAll(zippedData)
-	if err != nil {
-		return err
-	}
-	return conn.writeMessage(websocket.BinaryMessage, message)
-}

api/admin_profiling_test.go

@@ -1,105 +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 api
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"io"
-	"net/http"
-	"net/url"
-	"testing"
-
-	"github.com/minio/madmin-go/v3"
-	"github.com/stretchr/testify/assert"
-)
-
-// Implementing fake closingBuffer to mock stopProfiling() (io.ReadCloser, error)
-type ClosingBuffer struct {
-	*bytes.Buffer
-}
-
-// Implementing a fake Close function for io.ReadCloser
-func (cb *ClosingBuffer) Close() error {
-	return nil
-}
-
-func TestStartProfiling(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	mockWSConn := mockConn{}
-	function := "startProfiling()"
-	testOptions := &profileOptions{
-		Types: "cpu",
-	}
-
-	// Test-1 : startProfiling() Get response from MinIO server with one profiling object without errors
-	// mock function response from startProfiling()
-	minioStartProfiling = func(_ madmin.ProfilerType) ([]madmin.StartProfilingResult, error) {
-		return []madmin.StartProfilingResult{
-			{
-				NodeName: "http://127.0.0.1:9000/",
-				Success:  true,
-				Error:    "",
-			},
-			{
-				NodeName: "http://127.0.0.1:9001/",
-				Success:  true,
-				Error:    "",
-			},
-		}, nil
-	}
-	// mock function response from stopProfiling()
-	minioStopProfiling = func() (io.ReadCloser, error) {
-		return &ClosingBuffer{bytes.NewBufferString("In memory string eaeae")}, nil
-	}
-	// mock function response from mockConn.writeMessage()
-	connWriteMessageMock = func(_ int, _ []byte) error {
-		return nil
-	}
-	err := startProfiling(ctx, mockWSConn, adminClient, testOptions)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	assert.Equal(err, nil)
-
-	// Test-2 : startProfiling() Correctly handles errors returned by MinIO
-	// mock function response from startProfiling()
-	minioStartProfiling = func(_ madmin.ProfilerType) ([]madmin.StartProfilingResult, error) {
-		return nil, errors.New("error")
-	}
-	err = startProfiling(ctx, mockWSConn, adminClient, testOptions)
-	if assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-
-	// Test-3: getProfileOptionsFromReq() correctly returns profile options from request
-	u, _ := url.Parse("ws://localhost/ws/profile?types=cpu,mem,block,mutex,trace,threads,goroutines")
-	req := &http.Request{
-		URL: u,
-	}
-	opts, err := getProfileOptionsFromReq(req)
-	if assert.NoError(err) {
-		expectedOptions := profileOptions{
-			Types: "cpu,mem,block,mutex,trace,threads,goroutines",
-		}
-		assert.Equal(expectedOptions.Types, opts.Types)
-	}
-}

api/admin_releases.go

@@ -1,116 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 api
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-	"time"
-
-	"github.com/minio/console/pkg/utils"
-
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/minio/console/api/operations"
-	release "github.com/minio/console/api/operations/release"
-	"github.com/minio/console/models"
-	"github.com/minio/pkg/v3/env"
-)
-
-var (
-	releaseServiceHostEnvVar  = "RELEASE_SERVICE_HOST"
-	defaultReleaseServiceHost = "https://enterprise-updates.ic.min.dev"
-)
-
-func registerReleasesHandlers(api *operations.ConsoleAPI) {
-	api.ReleaseListReleasesHandler = release.ListReleasesHandlerFunc(func(params release.ListReleasesParams, session *models.Principal) middleware.Responder {
-		resp, err := GetReleaseListResponse(session, params)
-		if err != nil {
-			return release.NewListReleasesDefault(err.Code).WithPayload(err.APIError)
-		}
-		return release.NewListReleasesOK().WithPayload(resp)
-	})
-}
-
-func GetReleaseListResponse(_ *models.Principal, params release.ListReleasesParams) (*models.ReleaseListResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	repo := params.Repo
-	currentRelease := ""
-	if params.Current != nil {
-		currentRelease = *params.Current
-	}
-	search := ""
-	if params.Search != nil {
-		search = *params.Search
-	}
-	filter := ""
-	if params.Filter != nil {
-		filter = *params.Filter
-	}
-	ctx = context.WithValue(ctx, utils.ContextClientIP, getClientIP(params.HTTPRequest))
-	return releaseList(ctx, repo, currentRelease, search, filter)
-}
-
-func releaseList(ctx context.Context, repo, currentRelease, search, filter string) (*models.ReleaseListResponse, *CodedAPIError) {
-	serviceURL := getReleaseServiceURL()
-	clientIP := utils.ClientIPFromContext(ctx)
-	releases, err := getReleases(serviceURL, repo, currentRelease, search, filter, clientIP)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return releases, nil
-}
-
-func getReleaseServiceURL() string {
-	host := env.Get(releaseServiceHostEnvVar, defaultReleaseServiceHost)
-	return fmt.Sprintf("%s/releases", host)
-}
-
-func getReleases(endpoint, repo, currentRelease, search, filter, clientIP string) (*models.ReleaseListResponse, error) {
-	rl := &models.ReleaseListResponse{}
-	req, err := http.NewRequest(http.MethodGet, endpoint, nil)
-	if err != nil {
-		return nil, err
-	}
-	q := &url.Values{}
-	q.Add("repo", repo)
-	q.Add("search", search)
-	q.Add("filter", filter)
-	q.Add("current", currentRelease)
-	req.URL.RawQuery = q.Encode()
-	req.Header.Set("Content-Type", "application/json")
-
-	client := GetConsoleHTTPClient(clientIP)
-	client.Timeout = time.Second * 5
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("error getting releases: %s", resp.Status)
-	}
-	err = json.NewDecoder(resp.Body).Decode(&rl)
-	if err != nil {
-		return nil, err
-	}
-	return rl, nil
-}

api/admin_releases_test.go

@@ -1,104 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 api
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-
-	"github.com/minio/console/api/operations"
-	release "github.com/minio/console/api/operations/release"
-	"github.com/minio/console/models"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type ReleasesTestSuite struct {
-	suite.Suite
-	assert        *assert.Assertions
-	currentServer string
-	isServerSet   bool
-	getServer     *httptest.Server
-	withError     bool
-}
-
-func (suite *ReleasesTestSuite) SetupSuite() {
-	suite.assert = assert.New(suite.T())
-	suite.getServer = httptest.NewServer(http.HandlerFunc(suite.getHandler))
-	suite.currentServer, suite.isServerSet = os.LookupEnv(releaseServiceHostEnvVar)
-	os.Setenv(releaseServiceHostEnvVar, suite.getServer.URL)
-}
-
-func (suite *ReleasesTestSuite) TearDownSuite() {
-	if suite.isServerSet {
-		os.Setenv(releaseServiceHostEnvVar, suite.currentServer)
-	} else {
-		os.Unsetenv(releaseServiceHostEnvVar)
-	}
-}
-
-func (suite *ReleasesTestSuite) getHandler(
-	w http.ResponseWriter, _ *http.Request,
-) {
-	if suite.withError {
-		w.WriteHeader(400)
-	} else {
-		w.WriteHeader(200)
-		response := &models.ReleaseListResponse{}
-		bytes, _ := json.Marshal(response)
-		fmt.Fprint(w, string(bytes))
-	}
-}
-
-func (suite *ReleasesTestSuite) TestRegisterReleasesHandlers() {
-	api := &operations.ConsoleAPI{}
-	suite.assert.Nil(api.ReleaseListReleasesHandler)
-	registerReleasesHandlers(api)
-	suite.assert.NotNil(api.ReleaseListReleasesHandler)
-}
-
-func (suite *ReleasesTestSuite) TestGetReleasesWithError() {
-	api := &operations.ConsoleAPI{}
-	current := "mock"
-	registerReleasesHandlers(api)
-	params := release.NewListReleasesParams()
-	params.Current = &current
-	params.HTTPRequest = &http.Request{}
-	suite.withError = true
-	response := api.ReleaseListReleasesHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*release.ListReleasesDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *ReleasesTestSuite) TestGetReleasesWithoutError() {
-	api := &operations.ConsoleAPI{}
-	registerReleasesHandlers(api)
-	params := release.NewListReleasesParams()
-	params.HTTPRequest = &http.Request{}
-	suite.withError = false
-	response := api.ReleaseListReleasesHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*release.ListReleasesOK)
-	suite.assert.True(ok)
-}
-
-func TestReleases(t *testing.T) {
-	suite.Run(t, new(ReleasesTestSuite))
-}

api/admin_remote_buckets.go

@@ -1,810 +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 api
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/url"
-	"strconv"
-	"time"
-
-	"github.com/minio/console/pkg/utils"
-
-	"github.com/minio/madmin-go/v3"
-
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/swag"
-	"github.com/minio/console/api/operations"
-	bucketApi "github.com/minio/console/api/operations/bucket"
-	"github.com/minio/console/models"
-	"github.com/minio/minio-go/v7/pkg/replication"
-)
-
-type RemoteBucketResult struct {
-	OriginBucket string
-	TargetBucket string
-	Error        string
-}
-
-func registerAdminBucketRemoteHandlers(api *operations.ConsoleAPI) {
-	// return list of remote buckets
-	api.BucketListRemoteBucketsHandler = bucketApi.ListRemoteBucketsHandlerFunc(func(params bucketApi.ListRemoteBucketsParams, session *models.Principal) middleware.Responder {
-		listResp, err := getListRemoteBucketsResponse(session, params)
-		if err != nil {
-			return bucketApi.NewListRemoteBucketsDefault(err.Code).WithPayload(err.APIError)
-		}
-		return bucketApi.NewListRemoteBucketsOK().WithPayload(listResp)
-	})
-
-	// return information about a specific bucket
-	api.BucketRemoteBucketDetailsHandler = bucketApi.RemoteBucketDetailsHandlerFunc(func(params bucketApi.RemoteBucketDetailsParams, session *models.Principal) middleware.Responder {
-		response, err := getRemoteBucketDetailsResponse(session, params)
-		if err != nil {
-			return bucketApi.NewRemoteBucketDetailsDefault(err.Code).WithPayload(err.APIError)
-		}
-		return bucketApi.NewRemoteBucketDetailsOK().WithPayload(response)
-	})
-
-	// delete remote bucket
-	api.BucketDeleteRemoteBucketHandler = bucketApi.DeleteRemoteBucketHandlerFunc(func(params bucketApi.DeleteRemoteBucketParams, session *models.Principal) middleware.Responder {
-		err := getDeleteRemoteBucketResponse(session, params)
-		if err != nil {
-			return bucketApi.NewDeleteRemoteBucketDefault(err.Code).WithPayload(err.APIError)
-		}
-		return bucketApi.NewDeleteRemoteBucketNoContent()
-	})
-
-	// set remote bucket
-	api.BucketAddRemoteBucketHandler = bucketApi.AddRemoteBucketHandlerFunc(func(params bucketApi.AddRemoteBucketParams, session *models.Principal) middleware.Responder {
-		err := getAddRemoteBucketResponse(session, params)
-		if err != nil {
-			return bucketApi.NewAddRemoteBucketDefault(err.Code).WithPayload(err.APIError)
-		}
-		return bucketApi.NewAddRemoteBucketCreated()
-	})
-
-	// set multi-bucket replication
-	api.BucketSetMultiBucketReplicationHandler = bucketApi.SetMultiBucketReplicationHandlerFunc(func(params bucketApi.SetMultiBucketReplicationParams, session *models.Principal) middleware.Responder {
-		response, err := setMultiBucketReplicationResponse(session, params)
-		if err != nil {
-			return bucketApi.NewSetMultiBucketReplicationDefault(err.Code).WithPayload(err.APIError)
-		}
-
-		return bucketApi.NewSetMultiBucketReplicationOK().WithPayload(response)
-	})
-
-	// list external buckets
-	api.BucketListExternalBucketsHandler = bucketApi.ListExternalBucketsHandlerFunc(func(params bucketApi.ListExternalBucketsParams, _ *models.Principal) middleware.Responder {
-		response, err := listExternalBucketsResponse(params)
-		if err != nil {
-			return bucketApi.NewListExternalBucketsDefault(err.Code).WithPayload(err.APIError)
-		}
-
-		return bucketApi.NewListExternalBucketsOK().WithPayload(response)
-	})
-
-	// delete replication rule
-	api.BucketDeleteBucketReplicationRuleHandler = bucketApi.DeleteBucketReplicationRuleHandlerFunc(func(params bucketApi.DeleteBucketReplicationRuleParams, session *models.Principal) middleware.Responder {
-		err := deleteReplicationRuleResponse(session, params)
-		if err != nil {
-			return bucketApi.NewDeleteBucketReplicationRuleDefault(err.Code).WithPayload(err.APIError)
-		}
-
-		return bucketApi.NewDeleteBucketReplicationRuleNoContent()
-	})
-
-	// delete all replication rules for a bucket
-	api.BucketDeleteAllReplicationRulesHandler = bucketApi.DeleteAllReplicationRulesHandlerFunc(func(params bucketApi.DeleteAllReplicationRulesParams, session *models.Principal) middleware.Responder {
-		err := deleteBucketReplicationRulesResponse(session, params)
-		if err != nil {
-			if err.Code == 500 && err.APIError.DetailedMessage == "The remote target does not exist" {
-				// We should ignore this MinIO error when deleting all replication rules
-				return bucketApi.NewDeleteAllReplicationRulesNoContent() // This will return 204 as per swagger spec
-			}
-			// If there is a different error, then we should handle it
-			// This will return a generic error with err.Code (likely a 500 or 404) and its *err.DetailedMessage
-			return bucketApi.NewDeleteAllReplicationRulesDefault(err.Code).WithPayload(err.APIError)
-		}
-		return bucketApi.NewDeleteAllReplicationRulesNoContent()
-	})
-
-	// delete selected replication rules for a bucket
-	api.BucketDeleteSelectedReplicationRulesHandler = bucketApi.DeleteSelectedReplicationRulesHandlerFunc(func(params bucketApi.DeleteSelectedReplicationRulesParams, session *models.Principal) middleware.Responder {
-		err := deleteSelectedReplicationRulesResponse(session, params)
-		if err != nil {
-			return bucketApi.NewDeleteSelectedReplicationRulesDefault(err.Code).WithPayload(err.APIError)
-		}
-
-		return bucketApi.NewDeleteSelectedReplicationRulesNoContent()
-	})
-
-	// update local bucket replication config item
-	api.BucketUpdateMultiBucketReplicationHandler = bucketApi.UpdateMultiBucketReplicationHandlerFunc(func(params bucketApi.UpdateMultiBucketReplicationParams, session *models.Principal) middleware.Responder {
-		err := updateBucketReplicationResponse(session, params)
-		if err != nil {
-			return bucketApi.NewUpdateMultiBucketReplicationDefault(err.Code).WithPayload(err.APIError)
-		}
-		return bucketApi.NewUpdateMultiBucketReplicationCreated()
-	})
-}
-
-func getListRemoteBucketsResponse(session *models.Principal, params bucketApi.ListRemoteBucketsParams) (*models.ListRemoteBucketsResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, fmt.Errorf("error creating Madmin Client: %v", err))
-	}
-	adminClient := AdminClient{Client: mAdmin}
-	return listRemoteBuckets(ctx, adminClient)
-}
-
-func getRemoteBucketDetailsResponse(session *models.Principal, params bucketApi.RemoteBucketDetailsParams) (*models.RemoteBucket, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, fmt.Errorf("error creating Madmin Client: %v", err))
-	}
-	adminClient := AdminClient{Client: mAdmin}
-	return getRemoteBucket(ctx, adminClient, params.Name)
-}
-
-func getDeleteRemoteBucketResponse(session *models.Principal, params bucketApi.DeleteRemoteBucketParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return ErrorWithContext(ctx, fmt.Errorf("error creating Madmin Client: %v", err))
-	}
-	adminClient := AdminClient{Client: mAdmin}
-	err = deleteRemoteBucket(ctx, adminClient, params.SourceBucketName, params.Arn)
-	if err != nil {
-		return ErrorWithContext(ctx, fmt.Errorf("error deleting remote bucket: %v", err))
-	}
-	return nil
-}
-
-func getAddRemoteBucketResponse(session *models.Principal, params bucketApi.AddRemoteBucketParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return ErrorWithContext(ctx, fmt.Errorf("error creating Madmin Client: %v", err))
-	}
-	adminClient := AdminClient{Client: mAdmin}
-	_, err = addRemoteBucket(ctx, adminClient, *params.Body)
-	if err != nil {
-		return ErrorWithContext(ctx, fmt.Errorf("error adding remote bucket: %v", err))
-	}
-	return nil
-}
-
-func listRemoteBuckets(ctx context.Context, client MinioAdmin) (*models.ListRemoteBucketsResponse, *CodedAPIError) {
-	var remoteBuckets []*models.RemoteBucket
-	buckets, err := client.listRemoteBuckets(ctx, "", "")
-	if err != nil {
-		return nil, ErrorWithContext(ctx, fmt.Errorf("error listing remote buckets: %v", err))
-	}
-	for _, bucket := range buckets {
-		remoteBucket := &models.RemoteBucket{
-			AccessKey:         swag.String(bucket.Credentials.AccessKey),
-			RemoteARN:         swag.String(bucket.Arn),
-			SecretKey:         bucket.Credentials.SecretKey,
-			Service:           "replication",
-			SourceBucket:      swag.String(bucket.SourceBucket),
-			Status:            "",
-			TargetBucket:      bucket.TargetBucket,
-			TargetURL:         bucket.Endpoint,
-			SyncMode:          "async",
-			Bandwidth:         bucket.BandwidthLimit,
-			HealthCheckPeriod: int64(bucket.HealthCheckDuration.Seconds()),
-		}
-		if bucket.ReplicationSync {
-			remoteBucket.SyncMode = "sync"
-		}
-		remoteBuckets = append(remoteBuckets, remoteBucket)
-	}
-
-	return &models.ListRemoteBucketsResponse{
-		Buckets: remoteBuckets,
-		Total:   int64(len(remoteBuckets)),
-	}, nil
-}
-
-func getRemoteBucket(ctx context.Context, client MinioAdmin, name string) (*models.RemoteBucket, *CodedAPIError) {
-	remoteBucket, err := client.getRemoteBucket(ctx, name, "")
-	if err != nil {
-		return nil, ErrorWithContext(ctx, fmt.Errorf("error getting remote bucket details: %v", err))
-	}
-	if remoteBucket == nil {
-		return nil, ErrorWithContext(ctx, "error getting remote bucket details: bucket not found")
-	}
-	return &models.RemoteBucket{
-		AccessKey:    &remoteBucket.Credentials.AccessKey,
-		RemoteARN:    &remoteBucket.Arn,
-		SecretKey:    remoteBucket.Credentials.SecretKey,
-		Service:      "replication",
-		SourceBucket: &remoteBucket.SourceBucket,
-		Status:       "",
-		TargetBucket: remoteBucket.TargetBucket,
-		TargetURL:    remoteBucket.Endpoint,
-	}, nil
-}
-
-func deleteRemoteBucket(ctx context.Context, client MinioAdmin, sourceBucketName, arn string) error {
-	return client.removeRemoteBucket(ctx, sourceBucketName, arn)
-}
-
-func addRemoteBucket(ctx context.Context, client MinioAdmin, params models.CreateRemoteBucket) (string, error) {
-	TargetURL := *params.TargetURL
-	accessKey := *params.AccessKey
-	secretKey := *params.SecretKey
-	u, err := url.Parse(TargetURL)
-	if err != nil {
-		return "", errors.New("malformed Remote target URL")
-	}
-	secure := u.Scheme == "https"
-	host := u.Host
-	if u.Port() == "" {
-		port := 80
-		if secure {
-			port = 443
-		}
-		host = host + ":" + strconv.Itoa(port)
-	}
-	creds := &madmin.Credentials{AccessKey: accessKey, SecretKey: secretKey}
-	remoteBucket := &madmin.BucketTarget{
-		TargetBucket:    *params.TargetBucket,
-		Secure:          secure,
-		Credentials:     creds,
-		Endpoint:        host,
-		Path:            "",
-		API:             "s3v4",
-		Type:            "replication",
-		Region:          params.Region,
-		ReplicationSync: *params.SyncMode == "sync",
-	}
-	if *params.SyncMode == "async" {
-		remoteBucket.BandwidthLimit = params.Bandwidth
-	}
-	if params.HealthCheckPeriod > 0 {
-		remoteBucket.HealthCheckDuration = time.Duration(params.HealthCheckPeriod) * time.Second
-	}
-	bucketARN, err := client.addRemoteBucket(ctx, *params.SourceBucket, remoteBucket)
-
-	return bucketARN, err
-}
-
-func addBucketReplicationItem(ctx context.Context, session *models.Principal, minClient minioClient, bucketName, prefix, destinationARN string, repExistingObj, repDelMark, repDels, repMeta bool, tags string, priority int32, storageClass string) error {
-	// we will tolerate this call failing
-	cfg, err := minClient.getBucketReplication(ctx, bucketName)
-	if err != nil {
-		ErrorWithContext(ctx, fmt.Errorf("error fetching replication configuration for bucket %s: %v", bucketName, err))
-	}
-
-	// add rule
-	maxPrio := 0
-
-	if priority <= 0 { // We pick next priority by default
-		for _, r := range cfg.Rules {
-			if r.Priority > maxPrio {
-				maxPrio = r.Priority
-			}
-		}
-		maxPrio++
-	} else { // User picked priority, we try to set this manually
-		maxPrio = int(priority)
-	}
-	clientIP := utils.ClientIPFromContext(ctx)
-	s3Client, err := newS3BucketClient(session, bucketName, prefix, clientIP)
-	if err != nil {
-		ErrorWithContext(ctx, fmt.Errorf("error creating S3Client: %v", err))
-		return err
-	}
-	// create a mc S3Client interface implementation
-	// defining the client to be used
-	mcClient := mcClient{client: s3Client}
-
-	repDelMarkStatus := "disable"
-	if repDelMark {
-		repDelMarkStatus = "enable"
-	}
-
-	repDelsStatus := "disable"
-	if repDels {
-		repDelsStatus = "enable"
-	}
-
-	repMetaStatus := "disable"
-	if repMeta {
-		repMetaStatus = "enable"
-	}
-
-	existingRepStatus := "disable"
-	if repExistingObj {
-		existingRepStatus = "enable"
-	}
-
-	opts := replication.Options{
-		Priority:                fmt.Sprintf("%d", maxPrio),
-		RuleStatus:              "enable",
-		DestBucket:              destinationARN,
-		Op:                      replication.AddOption,
-		TagString:               tags,
-		ExistingObjectReplicate: existingRepStatus,
-		ReplicateDeleteMarkers:  repDelMarkStatus,
-		ReplicateDeletes:        repDelsStatus,
-		ReplicaSync:             repMetaStatus,
-		StorageClass:            storageClass,
-	}
-
-	err2 := mcClient.setReplication(ctx, &cfg, opts)
-	if err2 != nil {
-		ErrorWithContext(ctx, fmt.Errorf("error creating replication for bucket: %v", err2.Cause))
-		return err2.Cause
-	}
-	return nil
-}
-
-func editBucketReplicationItem(ctx context.Context, session *models.Principal, minClient minioClient, ruleID, bucketName, prefix, destinationARN string, ruleStatus, repDelMark, repDels, repMeta, existingObjectRep bool, tags string, priority int32, storageClass string) error {
-	// we will tolerate this call failing
-	cfg, err := minClient.getBucketReplication(ctx, bucketName)
-	if err != nil {
-		ErrorWithContext(ctx, fmt.Errorf("error fetching replication configuration for bucket %s: %v", bucketName, err))
-	}
-
-	maxPrio := int(priority)
-
-	clientIP := utils.ClientIPFromContext(ctx)
-	s3Client, err := newS3BucketClient(session, bucketName, prefix, clientIP)
-	if err != nil {
-		return fmt.Errorf("error creating S3Client: %v", err)
-	}
-	// create a mc S3Client interface implementation
-	// defining the client to be used
-	mcClient := mcClient{client: s3Client}
-
-	ruleState := "disable"
-	if ruleStatus {
-		ruleState = "enable"
-	}
-
-	repDelMarkStatus := "disable"
-	if repDelMark {
-		repDelMarkStatus = "enable"
-	}
-
-	repDelsStatus := "disable"
-	if repDels {
-		repDelsStatus = "enable"
-	}
-
-	repMetaStatus := "disable"
-	if repMeta {
-		repMetaStatus = "enable"
-	}
-
-	existingRepStatus := "disable"
-	if existingObjectRep {
-		existingRepStatus = "enable"
-	}
-
-	opts := replication.Options{
-		ID:                      ruleID,
-		Priority:                fmt.Sprintf("%d", maxPrio),
-		RuleStatus:              ruleState,
-		DestBucket:              destinationARN,
-		Op:                      replication.SetOption,
-		TagString:               tags,
-		IsTagSet:                true,
-		ExistingObjectReplicate: existingRepStatus,
-		ReplicateDeleteMarkers:  repDelMarkStatus,
-		ReplicateDeletes:        repDelsStatus,
-		ReplicaSync:             repMetaStatus,
-		StorageClass:            storageClass,
-		IsSCSet:                 true,
-	}
-
-	err2 := mcClient.setReplication(ctx, &cfg, opts)
-	if err2 != nil {
-		return fmt.Errorf("error modifying replication for bucket: %v", err2.Cause)
-	}
-	return nil
-}
-
-func setMultiBucketReplication(ctx context.Context, session *models.Principal, client MinioAdmin, minClient minioClient, params bucketApi.SetMultiBucketReplicationParams) []RemoteBucketResult {
-	bucketsRelation := params.Body.BucketsRelation
-
-	// Parallel remote bucket adding
-	parallelRemoteBucket := func(bucketRelationData *models.MultiBucketsRelation) chan RemoteBucketResult {
-		remoteProc := make(chan RemoteBucketResult)
-		sourceBucket := bucketRelationData.OriginBucket
-		targetBucket := bucketRelationData.DestinationBucket
-
-		go func() {
-			defer close(remoteProc)
-
-			createRemoteBucketParams := models.CreateRemoteBucket{
-				AccessKey:         params.Body.AccessKey,
-				SecretKey:         params.Body.SecretKey,
-				SourceBucket:      &sourceBucket,
-				TargetBucket:      &targetBucket,
-				Region:            params.Body.Region,
-				TargetURL:         params.Body.TargetURL,
-				SyncMode:          params.Body.SyncMode,
-				Bandwidth:         params.Body.Bandwidth,
-				HealthCheckPeriod: params.Body.HealthCheckPeriod,
-			}
-
-			// We add the remote bucket reference & store the arn or errors returned
-			arn, err := addRemoteBucket(ctx, client, createRemoteBucketParams)
-
-			if err == nil {
-				err = addBucketReplicationItem(
-					ctx,
-					session,
-					minClient,
-					sourceBucket,
-					params.Body.Prefix,
-					arn,
-					params.Body.ReplicateExistingObjects,
-					params.Body.ReplicateDeleteMarkers,
-					params.Body.ReplicateDeletes,
-					params.Body.ReplicateMetadata,
-					params.Body.Tags,
-					params.Body.Priority,
-					params.Body.StorageClass)
-			}
-
-			errorReturn := ""
-
-			if err != nil {
-				deleteRemoteBucket(ctx, client, sourceBucket, arn)
-				errorReturn = err.Error()
-			}
-
-			retParams := RemoteBucketResult{
-				OriginBucket: sourceBucket,
-				TargetBucket: targetBucket,
-				Error:        errorReturn,
-			}
-
-			remoteProc <- retParams
-		}()
-		return remoteProc
-	}
-
-	var bucketsManagement []chan RemoteBucketResult
-
-	for _, bucketName := range bucketsRelation {
-		// We generate the ARNs for each bucket
-		rBucket := parallelRemoteBucket(bucketName)
-		bucketsManagement = append(bucketsManagement, rBucket)
-	}
-
-	resultsList := []RemoteBucketResult{}
-	for _, result := range bucketsManagement {
-		res := <-result
-		resultsList = append(resultsList, res)
-	}
-
-	return resultsList
-}
-
-func setMultiBucketReplicationResponse(session *models.Principal, params bucketApi.SetMultiBucketReplicationParams) (*models.MultiBucketResponseState, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, fmt.Errorf("error creating Madmin Client: %v", err))
-	}
-	adminClient := AdminClient{Client: mAdmin}
-
-	mClient, err := newMinioClient(session, getClientIP(params.HTTPRequest))
-	if err != nil {
-		return nil, ErrorWithContext(ctx, fmt.Errorf("error creating MinIO Client: %v", err))
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	mnClient := minioClient{client: mClient}
-
-	replicationResults := setMultiBucketReplication(ctx, session, adminClient, mnClient, params)
-
-	if replicationResults == nil {
-		return nil, ErrorWithContext(ctx, errors.New("error setting buckets replication"))
-	}
-
-	resParsed := []*models.MultiBucketResponseItem{}
-
-	for _, repResult := range replicationResults {
-		responseItem := models.MultiBucketResponseItem{
-			ErrorString:  repResult.Error,
-			OriginBucket: repResult.OriginBucket,
-			TargetBucket: repResult.TargetBucket,
-		}
-
-		resParsed = append(resParsed, &responseItem)
-	}
-
-	resultsParsed := models.MultiBucketResponseState{
-		ReplicationState: resParsed,
-	}
-
-	return &resultsParsed, nil
-}
-
-func listExternalBucketsResponse(params bucketApi.ListExternalBucketsParams) (*models.ListBucketsResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	remoteAdmin, err := newAdminFromCreds(*params.Body.AccessKey, *params.Body.SecretKey, *params.Body.TargetURL, *params.Body.UseTLS)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return listExternalBuckets(ctx, AdminClient{Client: remoteAdmin})
-}
-
-func listExternalBuckets(ctx context.Context, client MinioAdmin) (*models.ListBucketsResponse, *CodedAPIError) {
-	buckets, err := getAccountBuckets(ctx, client)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	return &models.ListBucketsResponse{
-		Buckets: buckets,
-		Total:   int64(len(buckets)),
-	}, nil
-}
-
-func getARNFromID(conf *replication.Config, rule string) string {
-	for i := range conf.Rules {
-		if conf.Rules[i].ID == rule {
-			return conf.Rules[i].Destination.Bucket
-		}
-	}
-	return ""
-}
-
-func getARNsFromIDs(conf *replication.Config, rules []string) []string {
-	temp := make(map[string]string)
-	for i := range conf.Rules {
-		temp[conf.Rules[i].ID] = conf.Rules[i].Destination.Bucket
-	}
-	var retval []string
-	for i := range rules {
-		if val, ok := temp[rules[i]]; ok {
-			retval = append(retval, val)
-		}
-	}
-	return retval
-}
-
-func deleteReplicationRule(ctx context.Context, session *models.Principal, bucketName, ruleID string) error {
-	clientIP := utils.ClientIPFromContext(ctx)
-	mClient, err := newMinioClient(session, clientIP)
-	if err != nil {
-		return fmt.Errorf("error creating MinIO Client: %v", err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	minClient := minioClient{client: mClient}
-
-	cfg, err := minClient.getBucketReplication(ctx, bucketName)
-	if err != nil {
-		ErrorWithContext(ctx, fmt.Errorf("error versioning bucket: %v", err))
-	}
-
-	s3Client, err := newS3BucketClient(session, bucketName, "", clientIP)
-	if err != nil {
-		return fmt.Errorf("error creating S3Client: %v", err)
-	}
-	mAdmin, err := NewMinioAdminClient(ctx, session)
-	if err != nil {
-		return fmt.Errorf("error creating Admin Client: %v", err)
-	}
-	admClient := AdminClient{Client: mAdmin}
-
-	// create a mc S3Client interface implementation
-	// defining the client to be used
-	mcClient := mcClient{client: s3Client}
-
-	opts := replication.Options{
-		ID: ruleID,
-		Op: replication.RemoveOption,
-	}
-
-	err2 := mcClient.setReplication(ctx, &cfg, opts)
-	if err2 != nil {
-		return err2.Cause
-	}
-
-	// Replication rule was successfully deleted. We remove remote bucket
-	err3 := deleteRemoteBucket(ctx, admClient, bucketName, getARNFromID(&cfg, ruleID))
-	if err3 != nil {
-		return err3
-	}
-
-	return nil
-}
-
-func deleteAllReplicationRules(ctx context.Context, session *models.Principal, bucketName string) error {
-	clientIP := utils.ClientIPFromContext(ctx)
-
-	s3Client, err := newS3BucketClient(session, bucketName, "", clientIP)
-	if err != nil {
-		return fmt.Errorf("error creating S3Client: %v", err)
-	}
-	// create a mc S3Client interface implementation
-	// defining the client to be used
-	mcClient := mcClient{client: s3Client}
-	mClient, err := newMinioClient(session, clientIP)
-	if err != nil {
-		return fmt.Errorf("error creating MinIO Client: %v", err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	minClient := minioClient{client: mClient}
-
-	cfg, err := minClient.getBucketReplication(ctx, bucketName)
-	if err != nil {
-		ErrorWithContext(ctx, fmt.Errorf("error versioning bucket: %v", err))
-	}
-
-	mAdmin, err := NewMinioAdminClient(ctx, session)
-	if err != nil {
-		return fmt.Errorf("error creating Admin Client: %v", err)
-	}
-	admClient := AdminClient{Client: mAdmin}
-
-	err2 := mcClient.deleteAllReplicationRules(ctx)
-
-	if err2 != nil {
-		return err2.ToGoError()
-	}
-
-	for i := range cfg.Rules {
-		err3 := deleteRemoteBucket(ctx, admClient, bucketName, cfg.Rules[i].Destination.Bucket)
-		if err3 != nil {
-			return err3
-		}
-	}
-
-	return nil
-}
-
-func deleteSelectedReplicationRules(ctx context.Context, session *models.Principal, bucketName string, rules []string) error {
-	clientIP := utils.ClientIPFromContext(ctx)
-	mClient, err := newMinioClient(session, clientIP)
-	if err != nil {
-		return fmt.Errorf("error creating MinIO Client: %v", err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	minClient := minioClient{client: mClient}
-
-	cfg, err := minClient.getBucketReplication(ctx, bucketName)
-	if err != nil {
-		ErrorWithContext(ctx, fmt.Errorf("error versioning bucket: %v", err))
-	}
-
-	s3Client, err := newS3BucketClient(session, bucketName, "", clientIP)
-	if err != nil {
-		return fmt.Errorf("error creating S3Client: %v", err)
-	}
-	// create a mc S3Client interface implementation
-	// defining the client to be used
-	mcClient := mcClient{client: s3Client}
-
-	mAdmin, err := NewMinioAdminClient(ctx, session)
-	if err != nil {
-		return fmt.Errorf("error creating Admin Client: %v", err)
-	}
-	admClient := AdminClient{Client: mAdmin}
-
-	ARNs := getARNsFromIDs(&cfg, rules)
-
-	for i := range rules {
-		opts := replication.Options{
-			ID: rules[i],
-			Op: replication.RemoveOption,
-		}
-		err2 := mcClient.setReplication(ctx, &cfg, opts)
-		if err2 != nil {
-			return err2.Cause
-		}
-
-		// In case replication rule was deleted successfully, we remove the remote bucket ARN
-		err3 := deleteRemoteBucket(ctx, admClient, bucketName, ARNs[i])
-		if err3 != nil {
-			return err3
-		}
-	}
-	return nil
-}
-
-func deleteReplicationRuleResponse(session *models.Principal, params bucketApi.DeleteBucketReplicationRuleParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	ctx = context.WithValue(ctx, utils.ContextClientIP, getClientIP(params.HTTPRequest))
-	err := deleteReplicationRule(ctx, session, params.BucketName, params.RuleID)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	return nil
-}
-
-func deleteBucketReplicationRulesResponse(session *models.Principal, params bucketApi.DeleteAllReplicationRulesParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	ctx = context.WithValue(ctx, utils.ContextClientIP, getClientIP(params.HTTPRequest))
-	err := deleteAllReplicationRules(ctx, session, params.BucketName)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	return nil
-}
-
-func deleteSelectedReplicationRulesResponse(session *models.Principal, params bucketApi.DeleteSelectedReplicationRulesParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-
-	ctx = context.WithValue(ctx, utils.ContextClientIP, getClientIP(params.HTTPRequest))
-
-	err := deleteSelectedReplicationRules(ctx, session, params.BucketName, params.Rules.Rules)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	return nil
-}
-
-func updateBucketReplicationResponse(session *models.Principal, params bucketApi.UpdateMultiBucketReplicationParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-
-	mClient, err := newMinioClient(session, getClientIP(params.HTTPRequest))
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	minClient := minioClient{client: mClient}
-
-	err = editBucketReplicationItem(
-		ctx,
-		session,
-		minClient,
-		params.RuleID,
-		params.BucketName,
-		params.Body.Prefix,
-		params.Body.Arn,
-		params.Body.RuleState,
-		params.Body.ReplicateDeleteMarkers,
-		params.Body.ReplicateDeletes,
-		params.Body.ReplicateMetadata,
-		params.Body.ReplicateExistingObjects,
-		params.Body.Tags,
-		params.Body.Priority,
-		params.Body.StorageClass)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-
-	return nil
-}

api/admin_remote_buckets_test.go

@@ -1,386 +0,0 @@
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 api
-
-import (
-	"context"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-
-	"github.com/minio/console/pkg/utils"
-
-	"github.com/go-openapi/swag"
-	"github.com/minio/console/api/operations"
-	bucketApi "github.com/minio/console/api/operations/bucket"
-	"github.com/minio/console/models"
-	"github.com/minio/madmin-go/v3"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type RemoteBucketsTestSuite struct {
-	suite.Suite
-	assert           *assert.Assertions
-	currentServer    string
-	isServerSet      bool
-	server           *httptest.Server
-	adminClient      AdminClientMock
-	minioClient      minioClientMock
-	mockRemoteBucket *models.RemoteBucket
-	mockBucketTarget *madmin.BucketTarget
-	mockListBuckets  *models.ListBucketsResponse
-}
-
-func (suite *RemoteBucketsTestSuite) SetupSuite() {
-	suite.assert = assert.New(suite.T())
-	suite.adminClient = AdminClientMock{}
-	suite.minioClient = minioClientMock{}
-	suite.mockObjects()
-}
-
-func (suite *RemoteBucketsTestSuite) mockObjects() {
-	suite.mockListBuckets = &models.ListBucketsResponse{
-		Buckets: []*models.Bucket{},
-		Total:   0,
-	}
-	suite.mockRemoteBucket = &models.RemoteBucket{
-		AccessKey:    swag.String("accessKey"),
-		SecretKey:    "secretKey",
-		RemoteARN:    swag.String("remoteARN"),
-		Service:      "replication",
-		SourceBucket: swag.String("sourceBucket"),
-		TargetBucket: "targetBucket",
-		TargetURL:    "targetURL",
-		Status:       "",
-	}
-	suite.mockBucketTarget = &madmin.BucketTarget{
-		Credentials: &madmin.Credentials{
-			AccessKey: *suite.mockRemoteBucket.AccessKey,
-			SecretKey: suite.mockRemoteBucket.SecretKey,
-		},
-		Arn:          *suite.mockRemoteBucket.RemoteARN,
-		SourceBucket: *suite.mockRemoteBucket.SourceBucket,
-		TargetBucket: suite.mockRemoteBucket.TargetBucket,
-		Endpoint:     suite.mockRemoteBucket.TargetURL,
-	}
-}
-
-func (suite *RemoteBucketsTestSuite) SetupTest() {
-	suite.server = httptest.NewServer(http.HandlerFunc(suite.serverHandler))
-	suite.currentServer, suite.isServerSet = os.LookupEnv(ConsoleMinIOServer)
-	os.Setenv(ConsoleMinIOServer, suite.server.URL)
-}
-
-func (suite *RemoteBucketsTestSuite) serverHandler(w http.ResponseWriter, _ *http.Request) {
-	w.WriteHeader(400)
-}
-
-func (suite *RemoteBucketsTestSuite) TearDownSuite() {
-}
-
-func (suite *RemoteBucketsTestSuite) TearDownTest() {
-	if suite.isServerSet {
-		os.Setenv(ConsoleMinIOServer, suite.currentServer)
-	} else {
-		os.Unsetenv(ConsoleMinIOServer)
-	}
-}
-
-func (suite *RemoteBucketsTestSuite) TestRegisterRemoteBucketsHandlers() {
-	api := &operations.ConsoleAPI{}
-	suite.assertHandlersAreNil(api)
-	registerAdminBucketRemoteHandlers(api)
-	suite.assertHandlersAreNotNil(api)
-}
-
-func (suite *RemoteBucketsTestSuite) assertHandlersAreNil(api *operations.ConsoleAPI) {
-	suite.assert.Nil(api.BucketListRemoteBucketsHandler)
-	suite.assert.Nil(api.BucketRemoteBucketDetailsHandler)
-	suite.assert.Nil(api.BucketDeleteRemoteBucketHandler)
-	suite.assert.Nil(api.BucketAddRemoteBucketHandler)
-	suite.assert.Nil(api.BucketSetMultiBucketReplicationHandler)
-	suite.assert.Nil(api.BucketListExternalBucketsHandler)
-	suite.assert.Nil(api.BucketDeleteBucketReplicationRuleHandler)
-	suite.assert.Nil(api.BucketDeleteAllReplicationRulesHandler)
-	suite.assert.Nil(api.BucketDeleteSelectedReplicationRulesHandler)
-	suite.assert.Nil(api.BucketUpdateMultiBucketReplicationHandler)
-}
-
-func (suite *RemoteBucketsTestSuite) assertHandlersAreNotNil(api *operations.ConsoleAPI) {
-	suite.assert.NotNil(api.BucketListRemoteBucketsHandler)
-	suite.assert.NotNil(api.BucketRemoteBucketDetailsHandler)
-	suite.assert.NotNil(api.BucketDeleteRemoteBucketHandler)
-	suite.assert.NotNil(api.BucketAddRemoteBucketHandler)
-	suite.assert.NotNil(api.BucketSetMultiBucketReplicationHandler)
-	suite.assert.NotNil(api.BucketListExternalBucketsHandler)
-	suite.assert.NotNil(api.BucketDeleteBucketReplicationRuleHandler)
-	suite.assert.NotNil(api.BucketDeleteAllReplicationRulesHandler)
-	suite.assert.NotNil(api.BucketDeleteSelectedReplicationRulesHandler)
-	suite.assert.NotNil(api.BucketUpdateMultiBucketReplicationHandler)
-}
-
-func (suite *RemoteBucketsTestSuite) TestListRemoteBucketsHandlerWithError() {
-	params, api := suite.initListRemoteBucketsRequest()
-	response := api.BucketListRemoteBucketsHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*bucketApi.ListRemoteBucketsDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *RemoteBucketsTestSuite) initListRemoteBucketsRequest() (params bucketApi.ListRemoteBucketsParams, api operations.ConsoleAPI) {
-	registerAdminBucketRemoteHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	return params, api
-}
-
-func (suite *RemoteBucketsTestSuite) TestListRemoteBucketsWithoutError() {
-	ctx := context.Background()
-	minioListRemoteBucketsMock = func(_ context.Context, _, _ string) (targets []madmin.BucketTarget, err error) {
-		return []madmin.BucketTarget{{
-			Credentials: &madmin.Credentials{
-				AccessKey: "accessKey",
-				SecretKey: "secretKey",
-			},
-		}}, nil
-	}
-	res, err := listRemoteBuckets(ctx, &suite.adminClient)
-	suite.assert.NotNil(res)
-	suite.assert.Nil(err)
-}
-
-func (suite *RemoteBucketsTestSuite) TestRemoteBucketDetailsHandlerWithError() {
-	params, api := suite.initRemoteBucketDetailsRequest()
-	response := api.BucketRemoteBucketDetailsHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*bucketApi.RemoteBucketDetailsDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *RemoteBucketsTestSuite) initRemoteBucketDetailsRequest() (params bucketApi.RemoteBucketDetailsParams, api operations.ConsoleAPI) {
-	registerAdminBucketRemoteHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	return params, api
-}
-
-func (suite *RemoteBucketsTestSuite) TestGetRemoteBucketWithoutError() {
-	ctx := context.Background()
-	minioGetRemoteBucketMock = func(_ context.Context, _, _ string) (targets *madmin.BucketTarget, err error) {
-		return suite.mockBucketTarget, nil
-	}
-	res, err := getRemoteBucket(ctx, &suite.adminClient, "bucketName")
-	suite.assert.Nil(err)
-	suite.assert.NotNil(res)
-	suite.assert.Equal(suite.mockRemoteBucket, res)
-}
-
-func (suite *RemoteBucketsTestSuite) TestDeleteRemoteBucketHandlerWithError() {
-	params, api := suite.initDeleteRemoteBucketRequest()
-	response := api.BucketDeleteRemoteBucketHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*bucketApi.DeleteRemoteBucketDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *RemoteBucketsTestSuite) initDeleteRemoteBucketRequest() (params bucketApi.DeleteRemoteBucketParams, api operations.ConsoleAPI) {
-	registerAdminBucketRemoteHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	return params, api
-}
-
-func (suite *RemoteBucketsTestSuite) TestAddRemoteBucketHandlerWithError() {
-	params, api := suite.initAddRemoteBucketRequest()
-	response := api.BucketAddRemoteBucketHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*bucketApi.AddRemoteBucketDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *RemoteBucketsTestSuite) initAddRemoteBucketRequest() (params bucketApi.AddRemoteBucketParams, api operations.ConsoleAPI) {
-	registerAdminBucketRemoteHandlers(&api)
-	url := "^&*&^%^"
-	accessKey := "accessKey"
-	secretKey := "secretKey"
-	params.HTTPRequest = &http.Request{}
-	params.Body = &models.CreateRemoteBucket{
-		TargetURL: &url,
-		AccessKey: &accessKey,
-		SecretKey: &secretKey,
-	}
-	return params, api
-}
-
-func (suite *RemoteBucketsTestSuite) TestAddRemoteBucketWithoutError() {
-	ctx := context.Background()
-	minioAddRemoteBucketMock = func(_ context.Context, _ string, _ *madmin.BucketTarget) (string, error) {
-		return "bucketName", nil
-	}
-	url := "https://localhost"
-	accessKey := "accessKey"
-	secretKey := "secretKey"
-	targetBucket := "targetBucket"
-	syncMode := "async"
-	sourceBucket := "sourceBucket"
-	data := models.CreateRemoteBucket{
-		TargetURL:         &url,
-		TargetBucket:      &targetBucket,
-		AccessKey:         &accessKey,
-		SecretKey:         &secretKey,
-		SyncMode:          &syncMode,
-		HealthCheckPeriod: 10,
-		SourceBucket:      &sourceBucket,
-	}
-	res, err := addRemoteBucket(ctx, &suite.adminClient, data)
-	suite.assert.NotNil(res)
-	suite.assert.Nil(err)
-}
-
-func (suite *RemoteBucketsTestSuite) TestSetMultiBucketReplicationHandlerWithError() {
-	params, api := suite.initSetMultiBucketReplicationRequest()
-	response := api.BucketSetMultiBucketReplicationHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*bucketApi.SetMultiBucketReplicationOK)
-	suite.assert.True(ok)
-}
-
-func (suite *RemoteBucketsTestSuite) initSetMultiBucketReplicationRequest() (params bucketApi.SetMultiBucketReplicationParams, api operations.ConsoleAPI) {
-	registerAdminBucketRemoteHandlers(&api)
-	accessKey := "accessKey"
-	secretKey := "secretKey"
-	targetURL := "https://localhost"
-	syncMode := "async"
-	params.HTTPRequest = &http.Request{}
-	params.Body = &models.MultiBucketReplication{
-		BucketsRelation:   []*models.MultiBucketsRelation{{}},
-		AccessKey:         &accessKey,
-		SecretKey:         &secretKey,
-		Region:            "region",
-		TargetURL:         &targetURL,
-		SyncMode:          &syncMode,
-		Bandwidth:         10,
-		HealthCheckPeriod: 10,
-	}
-	return params, api
-}
-
-func (suite *RemoteBucketsTestSuite) TestListExternalBucketsHandlerWithError() {
-	params, api := suite.initListExternalBucketsRequest()
-	response := api.BucketListExternalBucketsHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*bucketApi.ListExternalBucketsDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *RemoteBucketsTestSuite) initListExternalBucketsRequest() (params bucketApi.ListExternalBucketsParams, api operations.ConsoleAPI) {
-	registerAdminBucketRemoteHandlers(&api)
-	url := "http://localhost:9000"
-	accessKey := "accessKey"
-	secretKey := "secretKey"
-	tls := false
-	params.HTTPRequest = &http.Request{}
-	params.Body = &models.ListExternalBucketsParams{
-		TargetURL: &url,
-		AccessKey: &accessKey,
-		SecretKey: &secretKey,
-		UseTLS:    &tls,
-	}
-	return params, api
-}
-
-func (suite *RemoteBucketsTestSuite) TestListExternalBucketsWithError() {
-	ctx := context.Background()
-	minioAccountInfoMock = func(_ context.Context) (madmin.AccountInfo, error) {
-		return madmin.AccountInfo{}, errors.New("error")
-	}
-	res, err := listExternalBuckets(ctx, &suite.adminClient)
-	suite.assert.NotNil(err)
-	suite.assert.Nil(res)
-}
-
-func (suite *RemoteBucketsTestSuite) TestListExternalBucketsWithoutError() {
-	ctx := context.Background()
-	minioAccountInfoMock = func(_ context.Context) (madmin.AccountInfo, error) {
-		return madmin.AccountInfo{
-			Buckets: []madmin.BucketAccessInfo{},
-		}, nil
-	}
-	res, err := listExternalBuckets(ctx, &suite.adminClient)
-	suite.assert.Nil(err)
-	suite.assert.NotNil(res)
-	suite.assert.Equal(suite.mockListBuckets, res)
-}
-
-func (suite *RemoteBucketsTestSuite) TestDeleteBucketReplicationRuleHandlerWithError() {
-	params, api := suite.initDeleteBucketReplicationRuleRequest()
-	response := api.BucketDeleteBucketReplicationRuleHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*bucketApi.DeleteBucketReplicationRuleDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *RemoteBucketsTestSuite) initDeleteBucketReplicationRuleRequest() (params bucketApi.DeleteBucketReplicationRuleParams, api operations.ConsoleAPI) {
-	registerAdminBucketRemoteHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	return params, api
-}
-
-func (suite *RemoteBucketsTestSuite) TestDeleteAllReplicationRulesHandlerWithError() {
-	params, api := suite.initDeleteAllReplicationRulesRequest()
-	response := api.BucketDeleteAllReplicationRulesHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*bucketApi.DeleteAllReplicationRulesDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *RemoteBucketsTestSuite) initDeleteAllReplicationRulesRequest() (params bucketApi.DeleteAllReplicationRulesParams, api operations.ConsoleAPI) {
-	registerAdminBucketRemoteHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	return params, api
-}
-
-func (suite *RemoteBucketsTestSuite) TestDeleteSelectedReplicationRulesHandlerWithError() {
-	params, api := suite.initDeleteSelectedReplicationRulesRequest()
-	response := api.BucketDeleteSelectedReplicationRulesHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*bucketApi.DeleteSelectedReplicationRulesDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *RemoteBucketsTestSuite) initDeleteSelectedReplicationRulesRequest() (params bucketApi.DeleteSelectedReplicationRulesParams, api operations.ConsoleAPI) {
-	registerAdminBucketRemoteHandlers(&api)
-	params.HTTPRequest = &http.Request{}
-	params.BucketName = "bucketName"
-	params.Rules = &models.BucketReplicationRuleList{
-		Rules: []string{"rule1", "rule2"},
-	}
-
-	return params, api
-}
-
-func (suite *RemoteBucketsTestSuite) TestUpdateMultiBucketReplicationHandlerWithError() {
-	params, api := suite.initUpdateMultiBucketReplicationRequest()
-	response := api.BucketUpdateMultiBucketReplicationHandler.Handle(params, &models.Principal{})
-	_, ok := response.(*bucketApi.UpdateMultiBucketReplicationDefault)
-	suite.assert.True(ok)
-}
-
-func (suite *RemoteBucketsTestSuite) initUpdateMultiBucketReplicationRequest() (params bucketApi.UpdateMultiBucketReplicationParams, api operations.ConsoleAPI) {
-	registerAdminBucketRemoteHandlers(&api)
-	r := &http.Request{}
-	ctx := context.WithValue(context.Background(), utils.ContextClientIP, "127.0.0.1")
-	rc := r.WithContext(ctx)
-	params.HTTPRequest = rc
-	params.Body = &models.MultiBucketReplicationEdit{}
-	return params, api
-}
-
-func TestRemoteBuckets(t *testing.T) {
-	suite.Run(t, new(RemoteBucketsTestSuite))
-}

api/admin_service.go

@@ -1,77 +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 api
-
-import (
-	"context"
-	"time"
-
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/minio/console/api/operations"
-	"github.com/minio/console/models"
-
-	svcApi "github.com/minio/console/api/operations/service"
-)
-
-func registerServiceHandlers(api *operations.ConsoleAPI) {
-	// Restart Service
-	api.ServiceRestartServiceHandler = svcApi.RestartServiceHandlerFunc(func(params svcApi.RestartServiceParams, session *models.Principal) middleware.Responder {
-		if err := getRestartServiceResponse(session, params); err != nil {
-			return svcApi.NewRestartServiceDefault(err.Code).WithPayload(err.APIError)
-		}
-		return svcApi.NewRestartServiceNoContent()
-	})
-}
-
-// serviceRestart - restarts the MinIO cluster
-func serviceRestart(ctx context.Context, client MinioAdmin) error {
-	if err := client.serviceRestart(ctx); err != nil {
-		return err
-	}
-	// copy behavior from minio/mc mainAdminServiceRestart()
-	//
-	// Max. time taken by the server to shutdown is 5 seconds.
-	// This can happen when there are lot of s3 requests pending when the server
-	// receives a restart command.
-	// Sleep for 6 seconds and then check if the server is online.
-	time.Sleep(6 * time.Second)
-
-	// Fetch the service status of the specified MinIO server
-	_, err := client.serverInfo(ctx)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// getRestartServiceResponse performs serviceRestart()
-func getRestartServiceResponse(session *models.Principal, params svcApi.RestartServiceParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	// create a MinIO Admin Client interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	if err := serviceRestart(ctx, adminClient); err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	return nil
-}

api/admin_service_test.go

@@ -1,68 +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 api
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"github.com/minio/madmin-go/v3"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestServiceRestart(t *testing.T) {
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	ctx := context.Background()
-	function := "serviceRestart()"
-	// Test-1 : serviceRestart() restart services no errors
-	// mock function response from listGroups()
-	minioServiceRestartMock = func(_ context.Context) error {
-		return nil
-	}
-	MinioServerInfoMock = func(_ context.Context) (madmin.InfoMessage, error) {
-		return madmin.InfoMessage{}, nil
-	}
-	if err := serviceRestart(ctx, adminClient); err != nil {
-		t.Errorf("Failed on %s:, errors occurred: %s", function, err.Error())
-	}
-
-	// Test-2 : serviceRestart() returns errors on client.serviceRestart call
-	// and see that the errors is handled correctly and returned
-	minioServiceRestartMock = func(_ context.Context) error {
-		return errors.New("error")
-	}
-	MinioServerInfoMock = func(_ context.Context) (madmin.InfoMessage, error) {
-		return madmin.InfoMessage{}, nil
-	}
-	if err := serviceRestart(ctx, adminClient); assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-
-	// Test-3 : serviceRestart() returns errors on client.serverInfo() call
-	// and see that the errors is handled correctly and returned
-	minioServiceRestartMock = func(_ context.Context) error {
-		return nil
-	}
-	MinioServerInfoMock = func(_ context.Context) (madmin.InfoMessage, error) {
-		return madmin.InfoMessage{}, errors.New("error on server info")
-	}
-	if err := serviceRestart(ctx, adminClient); assert.Error(err) {
-		assert.Equal("error on server info", err.Error())
-	}
-}

api/admin_trace.go

@@ -1,153 +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 api
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/minio/madmin-go/v3"
-	"github.com/minio/websocket"
-)
-
-// shortTraceMsg Short trace record
-type shortTraceMsg struct {
-	Host       string    `json:"host"`
-	Time       string    `json:"time"`
-	Client     string    `json:"client"`
-	CallStats  callStats `json:"callStats"`
-	FuncName   string    `json:"api"`
-	Path       string    `json:"path"`
-	Query      string    `json:"query"`
-	StatusCode int       `json:"statusCode"`
-	StatusMsg  string    `json:"statusMsg"`
-}
-
-type callStats struct {
-	Rx       int    `json:"rx"`
-	Tx       int    `json:"tx"`
-	Duration string `json:"duration"`
-	Ttfb     string `json:"timeToFirstByte"`
-}
-
-// trace filters
-func matchTrace(opts TraceRequest, traceInfo madmin.ServiceTraceInfo) bool {
-	statusCode := int(opts.statusCode)
-	method := opts.method
-	funcName := opts.funcName
-	apiPath := opts.path
-
-	if statusCode == 0 && method == "" && funcName == "" && apiPath == "" {
-		// no specific filtering found trace all the requests
-		return true
-	}
-
-	// Filter request path if passed by the user
-	if apiPath != "" {
-		pathToLookup := strings.ToLower(apiPath)
-		pathFromTrace := strings.ToLower(traceInfo.Trace.Path)
-
-		return strings.Contains(pathFromTrace, pathToLookup)
-	}
-
-	// Filter response status codes if passed by the user
-	if statusCode > 0 && traceInfo.Trace.HTTP != nil {
-		statusCodeFromTrace := traceInfo.Trace.HTTP.RespInfo.StatusCode
-
-		return statusCodeFromTrace == statusCode
-	}
-
-	// Filter request method if passed by the user
-	if method != "" && traceInfo.Trace.HTTP != nil {
-		methodFromTrace := traceInfo.Trace.HTTP.ReqInfo.Method
-
-		return methodFromTrace == method
-	}
-
-	if funcName != "" {
-		funcToLookup := strings.ToLower(funcName)
-		funcFromTrace := strings.ToLower(traceInfo.Trace.FuncName)
-
-		return strings.Contains(funcFromTrace, funcToLookup)
-	}
-
-	return true
-}
-
-// startTraceInfo starts trace of the servers
-func startTraceInfo(ctx context.Context, conn WSConn, client MinioAdmin, opts TraceRequest) error {
-	// Start listening on all trace activity.
-	traceCh := client.serviceTrace(ctx, opts.threshold, opts.s3, opts.internal, opts.storage, opts.os, opts.onlyErrors)
-	for {
-		select {
-		case <-ctx.Done():
-			return nil
-		case traceInfo, ok := <-traceCh:
-			// zero value returned because the channel is closed and empty
-			if !ok {
-				return nil
-			}
-			if traceInfo.Err != nil {
-				LogError("error on serviceTrace: %v", traceInfo.Err)
-				return traceInfo.Err
-			}
-			if matchTrace(opts, traceInfo) {
-				// Serialize message to be sent
-				traceInfoBytes, err := json.Marshal(shortTrace(&traceInfo))
-				if err != nil {
-					LogError("error on json.Marshal: %v", err)
-					return err
-				}
-				// Send Message through websocket connection
-				err = conn.writeMessage(websocket.TextMessage, traceInfoBytes)
-				if err != nil {
-					LogError("error writeMessage: %v", err)
-					return err
-				}
-			}
-		}
-	}
-}
-
-// shortTrace creates a shorter Trace Info message.
-// Same implementation as github/minio/mc/cmd/admin-trace.go
-func shortTrace(info *madmin.ServiceTraceInfo) shortTraceMsg {
-	t := info.Trace
-	s := shortTraceMsg{}
-
-	s.Time = t.Time.Format(time.RFC3339)
-	s.Path = t.Path
-	s.FuncName = t.FuncName
-	s.CallStats.Duration = t.Duration.String()
-	if info.Trace.HTTP != nil {
-		s.Query = t.HTTP.ReqInfo.RawQuery
-		s.StatusCode = t.HTTP.RespInfo.StatusCode
-		s.StatusMsg = http.StatusText(t.HTTP.RespInfo.StatusCode)
-		s.CallStats.Rx = t.HTTP.CallStats.InputBytes
-		s.CallStats.Tx = t.HTTP.CallStats.OutputBytes
-		s.CallStats.Ttfb = t.HTTP.CallStats.TimeToFirstByte.String()
-		if host, ok := t.HTTP.ReqInfo.Headers["Host"]; ok {
-			s.Host = strings.Join(host, "")
-		}
-		s.Client = t.HTTP.ReqInfo.Client
-	}
-
-	return s
-}

api/admin_trace_test.go

@@ -1,119 +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 api
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"testing"
-
-	"github.com/minio/madmin-go/v3"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestAdminTrace(t *testing.T) {
-	assert := assert.New(t)
-	adminClient := AdminClientMock{}
-	mockWSConn := mockConn{}
-	function := "startTraceInfo(ctx, )"
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	testReceiver := make(chan shortTraceMsg, 5)
-	textToReceive := "test"
-	testStreamSize := 5
-	isClosed := false // testReceiver is closed?
-
-	// Test-1: Serve Trace with no errors until trace finishes sending
-	// define mock function behavior for minio server Trace
-	minioServiceTraceMock = func(_ context.Context, _ int64, _, _, _, _, _ bool) <-chan madmin.ServiceTraceInfo {
-		ch := make(chan madmin.ServiceTraceInfo)
-		// Only success, start a routine to start reading line by line.
-		go func(ch chan<- madmin.ServiceTraceInfo) {
-			defer close(ch)
-			lines := make([]int, testStreamSize)
-			// mocking sending 5 lines of info
-			for range lines {
-				info := madmin.TraceInfo{
-					FuncName: textToReceive,
-				}
-				ch <- madmin.ServiceTraceInfo{Trace: info}
-			}
-		}(ch)
-		return ch
-	}
-	writesCount := 1
-	// mock connection WriteMessage() no error
-	connWriteMessageMock = func(_ int, data []byte) error {
-		// emulate that receiver gets the message written
-		var t shortTraceMsg
-		_ = json.Unmarshal(data, &t)
-		if writesCount == testStreamSize {
-			// for testing we need to close the receiver channel
-			if !isClosed {
-				close(testReceiver)
-				isClosed = true
-			}
-			return nil
-		}
-		testReceiver <- t
-		writesCount++
-		return nil
-	}
-	if err := startTraceInfo(ctx, mockWSConn, adminClient, TraceRequest{s3: true, internal: true, storage: true, os: true, onlyErrors: false}); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// check that the TestReceiver got the same number of data from trace.
-	for i := range testReceiver {
-		assert.Equal(textToReceive, i.FuncName)
-	}
-
-	// Test-2: if error happens while writing, return error
-	connWriteMessageMock = func(_ int, _ []byte) error {
-		return fmt.Errorf("error on write")
-	}
-	if err := startTraceInfo(ctx, mockWSConn, adminClient, TraceRequest{}); assert.Error(err) {
-		assert.Equal("error on write", err.Error())
-	}
-
-	// Test-3: error happens on serviceTrace Minio, trace should stop
-	// and error shall be returned.
-	minioServiceTraceMock = func(_ context.Context, _ int64, _, _, _, _, _ bool) <-chan madmin.ServiceTraceInfo {
-		ch := make(chan madmin.ServiceTraceInfo)
-		// Only success, start a routine to start reading line by line.
-		go func(ch chan<- madmin.ServiceTraceInfo) {
-			defer close(ch)
-			lines := make([]int, 2)
-			// mocking sending 5 lines of info
-			for range lines {
-				info := madmin.TraceInfo{
-					NodeName: "test",
-				}
-				ch <- madmin.ServiceTraceInfo{Trace: info}
-			}
-			ch <- madmin.ServiceTraceInfo{Err: fmt.Errorf("error on trace")}
-		}(ch)
-		return ch
-	}
-	connWriteMessageMock = func(_ int, _ []byte) error {
-		return nil
-	}
-	if err := startTraceInfo(ctx, mockWSConn, adminClient, TraceRequest{}); assert.Error(err) {
-		assert.Equal("error on trace", err.Error())
-	}
-}

api/admin_users.go

@@ -1,722 +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 api
-
-import (
-	"context"
-	"fmt"
-	"sort"
-	"strings"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/minio/console/api/operations"
-	accountApi "github.com/minio/console/api/operations/account"
-	bucketApi "github.com/minio/console/api/operations/bucket"
-	userApi "github.com/minio/console/api/operations/user"
-	"github.com/minio/console/models"
-	"github.com/minio/madmin-go/v3"
-	iampolicy "github.com/minio/pkg/v3/policy"
-)
-
-// Policy evaluated constants
-const (
-	Unknown = 0
-	Allow   = 1
-	Deny    = -1
-)
-
-func registerUsersHandlers(api *operations.ConsoleAPI) {
-	// List Users
-	api.UserListUsersHandler = userApi.ListUsersHandlerFunc(func(params userApi.ListUsersParams, session *models.Principal) middleware.Responder {
-		listUsersResponse, err := getListUsersResponse(session, params)
-		if err != nil {
-			return userApi.NewListUsersDefault(err.Code).WithPayload(err.APIError)
-		}
-		return userApi.NewListUsersOK().WithPayload(listUsersResponse)
-	})
-	// Add User
-	api.UserAddUserHandler = userApi.AddUserHandlerFunc(func(params userApi.AddUserParams, session *models.Principal) middleware.Responder {
-		userResponse, err := getUserAddResponse(session, params)
-		if err != nil {
-			return userApi.NewAddUserDefault(err.Code).WithPayload(err.APIError)
-		}
-		return userApi.NewAddUserCreated().WithPayload(userResponse)
-	})
-	// Remove User
-	api.UserRemoveUserHandler = userApi.RemoveUserHandlerFunc(func(params userApi.RemoveUserParams, session *models.Principal) middleware.Responder {
-		err := getRemoveUserResponse(session, params)
-		if err != nil {
-			return userApi.NewRemoveUserDefault(err.Code).WithPayload(err.APIError)
-		}
-		return userApi.NewRemoveUserNoContent()
-	})
-	// Update User-Groups
-	api.UserUpdateUserGroupsHandler = userApi.UpdateUserGroupsHandlerFunc(func(params userApi.UpdateUserGroupsParams, session *models.Principal) middleware.Responder {
-		userUpdateResponse, err := getUpdateUserGroupsResponse(session, params)
-		if err != nil {
-			return userApi.NewUpdateUserGroupsDefault(err.Code).WithPayload(err.APIError)
-		}
-
-		return userApi.NewUpdateUserGroupsOK().WithPayload(userUpdateResponse)
-	})
-	// Get User
-	api.UserGetUserInfoHandler = userApi.GetUserInfoHandlerFunc(func(params userApi.GetUserInfoParams, session *models.Principal) middleware.Responder {
-		userInfoResponse, err := getUserInfoResponse(session, params)
-		if err != nil {
-			return userApi.NewGetUserInfoDefault(err.Code).WithPayload(err.APIError)
-		}
-
-		return userApi.NewGetUserInfoOK().WithPayload(userInfoResponse)
-	})
-	// Update User
-	api.UserUpdateUserInfoHandler = userApi.UpdateUserInfoHandlerFunc(func(params userApi.UpdateUserInfoParams, session *models.Principal) middleware.Responder {
-		userUpdateResponse, err := getUpdateUserResponse(session, params)
-		if err != nil {
-			return userApi.NewUpdateUserInfoDefault(err.Code).WithPayload(err.APIError)
-		}
-
-		return userApi.NewUpdateUserInfoOK().WithPayload(userUpdateResponse)
-	})
-	// Update User-Groups Bulk
-	api.UserBulkUpdateUsersGroupsHandler = userApi.BulkUpdateUsersGroupsHandlerFunc(func(params userApi.BulkUpdateUsersGroupsParams, session *models.Principal) middleware.Responder {
-		err := getAddUsersListToGroupsResponse(session, params)
-		if err != nil {
-			return userApi.NewBulkUpdateUsersGroupsDefault(err.Code).WithPayload(err.APIError)
-		}
-
-		return userApi.NewBulkUpdateUsersGroupsOK()
-	})
-	api.BucketListUsersWithAccessToBucketHandler = bucketApi.ListUsersWithAccessToBucketHandlerFunc(func(params bucketApi.ListUsersWithAccessToBucketParams, session *models.Principal) middleware.Responder {
-		response, err := getListUsersWithAccessToBucketResponse(session, params)
-		if err != nil {
-			return bucketApi.NewListUsersWithAccessToBucketDefault(err.Code).WithPayload(err.APIError)
-		}
-		return bucketApi.NewListUsersWithAccessToBucketOK().WithPayload(response)
-	})
-	// Change User Password
-	api.AccountChangeUserPasswordHandler = accountApi.ChangeUserPasswordHandlerFunc(func(params accountApi.ChangeUserPasswordParams, session *models.Principal) middleware.Responder {
-		err := getChangeUserPasswordResponse(session, params)
-		if err != nil {
-			return accountApi.NewChangeUserPasswordDefault(err.Code).WithPayload(err.APIError)
-		}
-		return accountApi.NewChangeUserPasswordCreated()
-	})
-	// Check number of Service Accounts for listed users
-	api.UserCheckUserServiceAccountsHandler = userApi.CheckUserServiceAccountsHandlerFunc(func(params userApi.CheckUserServiceAccountsParams, session *models.Principal) middleware.Responder {
-		userSAList, err := getCheckUserSAResponse(session, params)
-		if err != nil {
-			return userApi.NewCheckUserServiceAccountsDefault(err.Code).WithPayload(err.APIError)
-		}
-		return userApi.NewCheckUserServiceAccountsOK().WithPayload(userSAList)
-	})
-}
-
-func listUsers(ctx context.Context, client MinioAdmin) ([]*models.User, error) {
-	// Get list of all users in the MinIO
-	// This call requires explicit authentication, no anonymous requests are
-	// allowed for listing users.
-	userMap, err := client.listUsers(ctx)
-	if err != nil {
-		return []*models.User{}, err
-	}
-
-	var users []*models.User
-	for accessKey, user := range userMap {
-		userElem := &models.User{
-			AccessKey: accessKey,
-			Status:    string(user.Status),
-			Policy:    strings.Split(user.PolicyName, ","),
-			MemberOf:  user.MemberOf,
-		}
-		users = append(users, userElem)
-	}
-
-	return users, nil
-}
-
-// getListUsersResponse performs listUsers() and serializes it to the handler's output
-func getListUsersResponse(session *models.Principal, params userApi.ListUsersParams) (*models.ListUsersResponse, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-	users, err := listUsers(ctx, adminClient)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// serialize output
-	listUsersResponse := &models.ListUsersResponse{
-		Users: users,
-	}
-	return listUsersResponse, nil
-}
-
-// addUser invokes adding a users on `MinioAdmin` and builds the response `models.User`
-func addUser(ctx context.Context, client MinioAdmin, accessKey, secretKey *string, groups []string, policies []string) (*models.User, error) {
-	// Calls into MinIO to add a new user if there's an errors return it
-	if err := client.addUser(ctx, *accessKey, *secretKey); err != nil {
-		return nil, err
-	}
-	// set groups for the newly created user
-	var userWithGroups *models.User
-	if len(groups) > 0 {
-		var errUG error
-		userWithGroups, errUG = updateUserGroups(ctx, client, *accessKey, groups)
-
-		if errUG != nil {
-			return nil, errUG
-		}
-	}
-	// set policies for the newly created user
-	if len(policies) > 0 {
-		policyString := strings.Join(policies, ",")
-		if err := SetPolicy(ctx, client, policyString, *accessKey, "user"); err != nil {
-			return nil, err
-		}
-	}
-
-	memberOf := []string{}
-	status := "enabled"
-	if userWithGroups != nil {
-		memberOf = userWithGroups.MemberOf
-		status = userWithGroups.Status
-	}
-
-	userRet := &models.User{
-		AccessKey: *accessKey,
-		MemberOf:  memberOf,
-		Policy:    policies,
-		Status:    status,
-	}
-	return userRet, nil
-}
-
-func getUserAddResponse(session *models.Principal, params userApi.AddUserParams) (*models.User, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-	var userExists bool
-
-	_, err = adminClient.getUserInfo(ctx, *params.Body.AccessKey)
-	userExists = err == nil
-
-	if userExists {
-		return nil, ErrorWithContext(ctx, ErrNonUniqueAccessKey)
-	}
-	user, err := addUser(
-		ctx,
-		adminClient,
-		params.Body.AccessKey,
-		params.Body.SecretKey,
-		params.Body.Groups,
-		params.Body.Policies,
-	)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return user, nil
-}
-
-// removeUser invokes removing an user on `MinioAdmin`, then we return the response from API
-func removeUser(ctx context.Context, client MinioAdmin, accessKey string) error {
-	return client.removeUser(ctx, accessKey)
-}
-
-func getRemoveUserResponse(session *models.Principal, params userApi.RemoveUserParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	if session.AccountAccessKey == params.Name {
-		return ErrorWithContext(ctx, ErrAvoidSelfAccountDelete)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-	if err := removeUser(ctx, adminClient, params.Name); err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	return nil
-}
-
-// getUserInfo calls MinIO server get the User Information
-func getUserInfo(ctx context.Context, client MinioAdmin, accessKey string) (*madmin.UserInfo, error) {
-	userInfo, err := client.getUserInfo(ctx, accessKey)
-	if err != nil {
-		return nil, err
-	}
-	return &userInfo, nil
-}
-
-func getUserInfoResponse(session *models.Principal, params userApi.GetUserInfoParams) (*models.User, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	user, err := getUserInfo(ctx, adminClient, params.Name)
-	if err != nil {
-		// User doesn't exist, return 404
-		if madmin.ToErrorResponse(err).Code == "XMinioAdminNoSuchUser" {
-			errorCode := 404
-			errorMessage := "User doesn't exist"
-			return nil, &CodedAPIError{Code: errorCode, APIError: &models.APIError{Message: errorMessage, DetailedMessage: err.Error()}}
-		}
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	var policies []string
-	if user.PolicyName == "" {
-		policies = []string{}
-	} else {
-		policies = strings.Split(user.PolicyName, ",")
-	}
-
-	hasPolicy := true
-
-	if len(policies) == 0 {
-		hasPolicy = false
-		for i := 0; i < len(user.MemberOf); i++ {
-			group, err := adminClient.getGroupDescription(ctx, user.MemberOf[i])
-			if err != nil {
-				continue
-			}
-			if group.Policy != "" {
-				hasPolicy = true
-				break
-			}
-		}
-	}
-
-	userInformation := &models.User{
-		AccessKey: params.Name,
-		MemberOf:  user.MemberOf,
-		Policy:    policies,
-		Status:    string(user.Status),
-		HasPolicy: hasPolicy,
-	}
-
-	return userInformation, nil
-}
-
-// updateUserGroups invokes getUserInfo() to get the old groups from the user,
-// then we merge the list with the new groups list to have a shorter iteration between groups and we do a comparison between the current and old groups.
-// We delete or update the groups according the location in each list and send the user with the new groups from `MinioAdmin` to the client
-func updateUserGroups(ctx context.Context, client MinioAdmin, user string, groupsToAssign []string) (*models.User, error) {
-	parallelUserUpdate := func(groupName string, originGroups []string) chan error {
-		chProcess := make(chan error)
-
-		go func() error {
-			defer close(chProcess)
-
-			// Compare if groupName is in the arrays
-			isGroupPersistent := IsElementInArray(groupsToAssign, groupName)
-			isInOriginGroups := IsElementInArray(originGroups, groupName)
-
-			if isGroupPersistent && isInOriginGroups { // Group is already assigned and doesn't need to be updated
-				chProcess <- nil
-
-				return nil
-			}
-
-			isRemove := false // User is added by default
-
-			// User is deleted from the group
-			if !isGroupPersistent {
-				isRemove = true
-			}
-
-			userToAddRemove := []string{user}
-
-			updateReturn := updateGroupMembers(ctx, client, groupName, userToAddRemove, isRemove)
-
-			chProcess <- updateReturn
-
-			return updateReturn
-		}()
-
-		return chProcess
-	}
-
-	userInfoOr, err := getUserInfo(ctx, client, user)
-	if err != nil {
-		return nil, err
-	}
-
-	memberOf := userInfoOr.MemberOf
-	mergedGroupArray := UniqueKeys(append(memberOf, groupsToAssign...))
-
-	var listOfUpdates []chan error
-
-	// Each group must be updated individually because there is no way to update all the groups at once for a user,
-	// we are using the same logic as 'mc admin group add' command
-	for _, groupN := range mergedGroupArray {
-		proc := parallelUserUpdate(groupN, memberOf)
-		listOfUpdates = append(listOfUpdates, proc)
-	}
-
-	channelHasError := false
-
-	for _, chanRet := range listOfUpdates {
-		locError := <-chanRet
-
-		if locError != nil {
-			channelHasError = true
-		}
-	}
-
-	if channelHasError {
-		errRt := errors.New(500, "there was an error updating the groups")
-		return nil, errRt
-	}
-
-	userInfo, err := getUserInfo(ctx, client, user)
-	if err != nil {
-		return nil, err
-	}
-
-	policies := strings.Split(userInfo.PolicyName, ",")
-
-	userReturn := &models.User{
-		AccessKey: user,
-		MemberOf:  userInfo.MemberOf,
-		Policy:    policies,
-		Status:    string(userInfo.Status),
-	}
-
-	return userReturn, nil
-}
-
-func getUpdateUserGroupsResponse(session *models.Principal, params userApi.UpdateUserGroupsParams) (*models.User, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	user, err := updateUserGroups(ctx, adminClient, params.Name, params.Body.Groups)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	return user, nil
-}
-
-// setUserStatus invokes setUserStatus from madmin to update user status
-func setUserStatus(ctx context.Context, client MinioAdmin, user string, status string) error {
-	var setStatus madmin.AccountStatus
-	switch status {
-	case "enabled":
-		setStatus = madmin.AccountEnabled
-	case "disabled":
-		setStatus = madmin.AccountDisabled
-	default:
-		return errors.New(500, "status not valid")
-	}
-
-	return client.setUserStatus(ctx, user, setStatus)
-}
-
-func getUpdateUserResponse(session *models.Principal, params userApi.UpdateUserInfoParams) (*models.User, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-	status := *params.Body.Status
-	groups := params.Body.Groups
-
-	if err := setUserStatus(ctx, adminClient, params.Name, status); err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-
-	userElem, errUG := updateUserGroups(ctx, adminClient, params.Name, groups)
-
-	if errUG != nil {
-		return nil, ErrorWithContext(ctx, errUG)
-	}
-	return userElem, nil
-}
-
-// addUsersListToGroups iterates over the user list & assigns the requested groups to each user.
-func addUsersListToGroups(ctx context.Context, client MinioAdmin, usersToUpdate []string, groupsToAssign []string) error {
-	// We update each group with the complete usersList
-	parallelGroupsUpdate := func(groupToAssign string) chan error {
-		groupProcess := make(chan error)
-
-		go func() {
-			defer close(groupProcess)
-			// We add the users array to the group.
-			err := updateGroupMembers(ctx, client, groupToAssign, usersToUpdate, false)
-
-			groupProcess <- err
-		}()
-		return groupProcess
-	}
-
-	var groupsUpdateList []chan error
-
-	// We get each group name & add users accordingly
-	for _, groupName := range groupsToAssign {
-		// We update the group
-		proc := parallelGroupsUpdate(groupName)
-		groupsUpdateList = append(groupsUpdateList, proc)
-	}
-
-	errorsList := []string{} // We get the errors list because we want to have all errors at once.
-	for _, err := range groupsUpdateList {
-		errorFromUpdate := <-err // We store the errors to avoid Data Race
-		if errorFromUpdate != nil {
-			// If there is an errors, we store the errors strings so we can join them after we receive all errors
-			errorsList = append(errorsList, errorFromUpdate.Error()) // We wait until all the channels have been closed.
-		}
-	}
-
-	// If there are errors, we throw the final errors with the errors inside
-	if len(errorsList) > 0 {
-		errGen := fmt.Errorf("error in users-groups assignation: %q", strings.Join(errorsList, ","))
-		return errGen
-	}
-
-	return nil
-}
-
-func getAddUsersListToGroupsResponse(session *models.Principal, params userApi.BulkUpdateUsersGroupsParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	usersList := params.Body.Users
-	groupsList := params.Body.Groups
-
-	if err := addUsersListToGroups(ctx, adminClient, usersList, groupsList); err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-
-	return nil
-}
-
-func getListUsersWithAccessToBucketResponse(session *models.Principal, params bucketApi.ListUsersWithAccessToBucketParams) ([]string, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-	list, err := listUsersWithAccessToBucket(ctx, adminClient, params.Bucket)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	return list, nil
-}
-
-func policyAllowsAndMatchesBucket(policy *iampolicy.Policy, bucket string) int {
-	policyStatements := policy.Statements
-	for i := 0; i < len(policyStatements); i++ {
-		resources := policyStatements[i].Resources
-		effect := policyStatements[i].Effect
-		if resources.Match(bucket, map[string][]string{}) {
-			if effect.IsValid() {
-				if effect.IsAllowed(true) {
-					return Allow
-				}
-				return Deny
-			}
-		}
-	}
-	return Unknown
-}
-
-func listUsersWithAccessToBucket(ctx context.Context, adminClient MinioAdmin, bucket string) ([]string, error) {
-	users, err := adminClient.listUsers(ctx)
-	if err != nil {
-		return nil, err
-	}
-	var retval []string
-	akHasAccess := make(map[string]struct{})
-	akIsDenied := make(map[string]struct{})
-	for k, v := range users {
-		for _, policyName := range strings.Split(v.PolicyName, ",") {
-			policyName = strings.TrimSpace(policyName)
-			if policyName == "" {
-				continue
-			}
-			policy, err := adminClient.getPolicy(ctx, policyName)
-			if err != nil {
-				ErrorWithContext(ctx, fmt.Errorf("unable to fetch policy %s: %v", policyName, err))
-				continue
-			}
-			if _, ok := akIsDenied[k]; !ok {
-				switch policyAllowsAndMatchesBucket(policy, bucket) {
-				case Allow:
-					if _, ok := akHasAccess[k]; !ok {
-						akHasAccess[k] = struct{}{}
-					}
-				case Deny:
-					akIsDenied[k] = struct{}{}
-					delete(akHasAccess, k)
-				}
-			}
-		}
-	}
-
-	groups, err := adminClient.listGroups(ctx)
-	if err != nil {
-		ErrorWithContext(ctx, fmt.Errorf("unable to list groups: %v", err))
-		return retval, nil
-	}
-
-	for _, groupName := range groups {
-		info, err := groupInfo(ctx, adminClient, groupName)
-		if err != nil {
-			ErrorWithContext(ctx, fmt.Errorf("unable to fetch group info %s: %v", groupName, err))
-			continue
-		}
-		policy, err := adminClient.getPolicy(ctx, info.Policy)
-		if err != nil {
-			ErrorWithContext(ctx, fmt.Errorf("unable to fetch group policy %s: %v", info.Policy, err))
-			continue
-		}
-		for _, member := range info.Members {
-			if _, ok := akIsDenied[member]; !ok {
-				switch policyAllowsAndMatchesBucket(policy, bucket) {
-				case Allow:
-					if _, ok := akHasAccess[member]; !ok {
-						akHasAccess[member] = struct{}{}
-					}
-				case Deny:
-					akIsDenied[member] = struct{}{}
-					delete(akHasAccess, member)
-				}
-			}
-		}
-	}
-	for k := range akHasAccess {
-		retval = append(retval, k)
-	}
-	sort.Strings(retval)
-	return retval, nil
-}
-
-// changeUserPassword changes password of selectedUser to newSecretKey
-func changeUserPassword(ctx context.Context, client MinioAdmin, selectedUser string, newSecretKey string) error {
-	return client.changePassword(ctx, selectedUser, newSecretKey)
-}
-
-// getChangeUserPasswordResponse will change the password of selctedUser to newSecretKey
-func getChangeUserPasswordResponse(session *models.Principal, params accountApi.ChangeUserPasswordParams) *CodedAPIError {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	// params will contain selectedUser and newSecretKey credentials for the user
-	user := *params.Body.SelectedUser
-	newSecretKey := *params.Body.NewSecretKey
-
-	// changes password of user to newSecretKey
-	if err := changeUserPassword(ctx, adminClient, user, newSecretKey); err != nil {
-		return ErrorWithContext(ctx, err)
-	}
-	return nil
-}
-
-func getCheckUserSAResponse(session *models.Principal, params userApi.CheckUserServiceAccountsParams) (*models.UserServiceAccountSummary, *CodedAPIError) {
-	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
-	defer cancel()
-	mAdmin, err := NewMinioAdminClient(params.HTTPRequest.Context(), session)
-	if err != nil {
-		return nil, ErrorWithContext(ctx, err)
-	}
-	// create a minioClient interface implementation
-	// defining the client to be used
-	adminClient := AdminClient{Client: mAdmin}
-
-	var userServiceAccountList []*models.UserServiceAccountItem
-	hasSA := false
-	for _, user := range params.SelectedUsers {
-		listServAccs, err := adminClient.listServiceAccounts(ctx, user)
-		if err != nil {
-			return nil, ErrorWithContext(ctx, err)
-		}
-		numSAs := int64(len(listServAccs.Accounts))
-		if numSAs > 0 {
-			hasSA = true
-		}
-		userAccountItem := &models.UserServiceAccountItem{
-			UserName: user,
-			NumSAs:   numSAs,
-		}
-		userServiceAccountList = append(userServiceAccountList, userAccountItem)
-	}
-
-	userAccountList := &models.UserServiceAccountSummary{
-		UserServiceAccountList: userServiceAccountList,
-		HasSA:                  hasSA,
-	}
-
-	return userAccountList, nil
-}

api/admin_users_test.go

@@ -1,535 +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 api
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/minio/madmin-go/v3"
-	iampolicy "github.com/minio/pkg/v3/policy"
-	asrt "github.com/stretchr/testify/assert"
-)
-
-func TestListUsers(t *testing.T) {
-	assert := asrt.New(t)
-	adminClient := AdminClientMock{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	// Test-1 : listUsers() Get response from minio client with two users and return the same number on listUsers()
-	// mock minIO client
-	mockUserMap := map[string]madmin.UserInfo{
-		"ABCDEFGHI": {
-			SecretKey:  "",
-			PolicyName: "ABCDEFGHI-policy",
-			Status:     "enabled",
-			MemberOf:   []string{"group1", "group2"},
-		},
-		"ZBCDEFGHI": {
-			SecretKey:  "",
-			PolicyName: "ZBCDEFGHI-policy",
-			Status:     "enabled",
-			MemberOf:   []string{"group1", "group2"},
-		},
-	}
-
-	// mock function response from listUsersWithContext(ctx)
-	minioListUsersMock = func() (map[string]madmin.UserInfo, error) {
-		return mockUserMap, nil
-	}
-
-	// get list users response this response should have Name, CreationDate, Size and Access
-	// as part of of each user
-	function := "listUsers()"
-	userMap, err := listUsers(ctx, adminClient)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// verify length of users is correct
-	assert.Equal(len(mockUserMap), len(userMap), fmt.Sprintf("Failed on %s: length of user's lists is not the same", function))
-
-	for _, b := range userMap {
-		assert.Contains(mockUserMap, b.AccessKey)
-		assert.Equal(string(mockUserMap[b.AccessKey].Status), b.Status)
-		assert.Equal(mockUserMap[b.AccessKey].PolicyName, strings.Join(b.Policy, ","))
-		assert.ElementsMatch(mockUserMap[b.AccessKey].MemberOf, []string{"group1", "group2"})
-	}
-
-	// Test-2 : listUsers() Return and see that the error is handled correctly and returned
-	minioListUsersMock = func() (map[string]madmin.UserInfo, error) {
-		return nil, errors.New("error")
-	}
-	_, err = listUsers(ctx, adminClient)
-	if assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}
-
-func TestAddUser(t *testing.T) {
-	assert := asrt.New(t)
-	adminClient := AdminClientMock{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	// Test-1: valid case of adding a user with a proper access key
-	accessKey := "ABCDEFGHI"
-	secretKey := "ABCDEFGHIABCDEFGHI"
-	groups := []string{"group1", "group2", "group3"}
-	policies := []string{}
-	emptyGroupTest := []string{}
-	mockResponse := &madmin.UserInfo{
-		MemberOf:   []string{"group1", "group2", "gropup3"},
-		PolicyName: "",
-		Status:     "enabled",
-		SecretKey:  "",
-	}
-
-	// mock function response from addUser() return no error
-	minioAddUserMock = func(_, _ string) error {
-		return nil
-	}
-
-	minioGetUserInfoMock = func(_ string) (madmin.UserInfo, error) {
-		return *mockResponse, nil
-	}
-
-	minioUpdateGroupMembersMock = func(_ madmin.GroupAddRemove) error {
-		return nil
-	}
-	// Test-1: Add a user
-	function := "addUser()"
-	user, err := addUser(ctx, adminClient, &accessKey, &secretKey, groups, policies)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// no error should have been returned
-	assert.Nil(err, "Error is not null")
-	// the same access key should be in the model users
-	assert.Equal(user.AccessKey, accessKey)
-
-	// Test-2 Add a user with empty groups list
-	user, err = addUser(ctx, adminClient, &accessKey, &secretKey, emptyGroupTest, policies)
-	// no error should have been returned
-	assert.Nil(err, "Error is not null")
-	// the same access key should be in the model users
-	assert.Equal(user.AccessKey, accessKey)
-
-	// Test-3: valid case
-	accessKey = "AB"
-	secretKey = "ABCDEFGHIABCDEFGHI"
-	// mock function response from addUser() return no error
-	minioAddUserMock = func(_, _ string) error {
-		return errors.New("error")
-	}
-
-	user, err = addUser(ctx, adminClient, &accessKey, &secretKey, groups, policies)
-
-	// no error should have been returned
-	assert.Nil(user, "User is not null")
-	assert.NotNil(err, "An error should have been returned")
-
-	if assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-
-	// Test-4: add groups function returns an error
-	minioUpdateGroupMembersMock = func(_ madmin.GroupAddRemove) error {
-		return errors.New("error")
-	}
-
-	user, err = addUser(ctx, adminClient, &accessKey, &secretKey, groups, policies)
-
-	// no error should have been returned
-	assert.Nil(user, "User is not null")
-	assert.NotNil(err, "An error should have been returned")
-
-	if assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}
-
-func TestRemoveUser(t *testing.T) {
-	assert := asrt.New(t)
-	// mock minIO client
-	adminClient := AdminClientMock{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	function := "removeUser()"
-
-	// Test-1: removeUser() delete a user
-	// mock function response from removeUser(accessKey)
-	minioRemoveUserMock = func(_ string) error {
-		return nil
-	}
-
-	if err := removeUser(ctx, adminClient, "ABCDEFGHI"); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-
-	// Test-2: removeUser() make sure errors are handled correctly when error on DeleteUser()
-	// mock function response from removeUser(accessKey)
-	minioRemoveUserMock = func(_ string) error {
-		return errors.New("error")
-	}
-
-	if err := removeUser(ctx, adminClient, "notexistentuser"); assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}
-
-func TestUserGroups(t *testing.T) {
-	assert := asrt.New(t)
-	// mock minIO client
-	adminClient := AdminClientMock{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	function := "updateUserGroups()"
-	mockUserGroups := []string{"group1", "group2", "group3"}
-	mockUserName := "testUser"
-	mockResponse := &madmin.UserInfo{
-		MemberOf:   []string{"group1", "group2", "gropup3"},
-		PolicyName: "",
-		Status:     "enabled",
-		SecretKey:  mockUserName,
-	}
-	mockEmptyResponse := &madmin.UserInfo{
-		MemberOf:   nil,
-		PolicyName: "",
-		Status:     "",
-		SecretKey:  "",
-	}
-
-	// Test-1: updateUserGroups() updates the groups for a user
-	// mock function response from updateUserGroups(accessKey, groupsToAssign)
-
-	minioGetUserInfoMock = func(_ string) (madmin.UserInfo, error) {
-		return *mockResponse, nil
-	}
-
-	minioUpdateGroupMembersMock = func(_ madmin.GroupAddRemove) error {
-		return nil
-	}
-
-	if _, err := updateUserGroups(ctx, adminClient, mockUserName, mockUserGroups); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-
-	// Test-2: updateUserGroups() make sure errors are handled correctly when error on UpdateGroupMembersMock()
-	// mock function response from removeUser(accessKey)
-
-	minioUpdateGroupMembersMock = func(_ madmin.GroupAddRemove) error {
-		return errors.New("error")
-	}
-
-	if _, err := updateUserGroups(ctx, adminClient, mockUserName, mockUserGroups); assert.Error(err) {
-		assert.Equal("there was an error updating the groups", err.Error())
-	}
-
-	// Test-3: updateUserGroups() make sure we return the correct error when getUserInfo returns error
-	minioGetUserInfoMock = func(_ string) (madmin.UserInfo, error) {
-		return *mockEmptyResponse, errors.New("error getting user ")
-	}
-
-	minioUpdateGroupMembersMock = func(_ madmin.GroupAddRemove) error {
-		return nil
-	}
-
-	if _, err := updateUserGroups(ctx, adminClient, mockUserName, mockUserGroups); assert.Error(err) {
-		assert.Equal("error getting user ", err.Error())
-	}
-}
-
-func TestGetUserInfo(t *testing.T) {
-	assert := asrt.New(t)
-	adminClient := AdminClientMock{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// Test-1 : getUserInfo() get user info
-	userName := "userNameTest"
-	mockResponse := &madmin.UserInfo{
-		SecretKey:  userName,
-		PolicyName: "",
-		MemberOf:   []string{"group1", "group2", "group3"},
-		Status:     "enabled",
-	}
-	emptyMockResponse := &madmin.UserInfo{
-		SecretKey:  "",
-		PolicyName: "",
-		Status:     "",
-		MemberOf:   nil,
-	}
-
-	// mock function response from getUserInfo()
-	minioGetUserInfoMock = func(_ string) (madmin.UserInfo, error) {
-		return *mockResponse, nil
-	}
-	function := "getUserInfo()"
-	info, err := getUserInfo(ctx, adminClient, userName)
-	if err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-
-	assert.Equal(userName, info.SecretKey)
-	assert.Equal("", info.PolicyName)
-	assert.ElementsMatch([]string{"group1", "group2", "group3"}, info.MemberOf)
-	assert.Equal(mockResponse.Status, info.Status)
-
-	// Test-2 : getUserInfo() Return error and see that the error is handled correctly and returned
-	minioGetUserInfoMock = func(_ string) (madmin.UserInfo, error) {
-		return *emptyMockResponse, errors.New("error")
-	}
-	_, err = getUserInfo(ctx, adminClient, userName)
-	if assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}
-
-func TestSetUserStatus(t *testing.T) {
-	assert := asrt.New(t)
-	adminClient := AdminClientMock{}
-	function := "setUserStatus()"
-	userName := "userName123"
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// Test-1: setUserStatus() update valid disabled status
-	expectedStatus := "disabled"
-	minioSetUserStatusMock = func(_ string, _ madmin.AccountStatus) error {
-		return nil
-	}
-	if err := setUserStatus(ctx, adminClient, userName, expectedStatus); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// Test-2: setUserStatus() update valid enabled status
-	expectedStatus = "enabled"
-	minioSetUserStatusMock = func(_ string, _ madmin.AccountStatus) error {
-		return nil
-	}
-	if err := setUserStatus(ctx, adminClient, userName, expectedStatus); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-	// Test-3: setUserStatus() update invalid status, should send error
-	expectedStatus = "invalid"
-	minioSetUserStatusMock = func(_ string, _ madmin.AccountStatus) error {
-		return nil
-	}
-	if err := setUserStatus(ctx, adminClient, userName, expectedStatus); assert.Error(err) {
-		assert.Equal("status not valid", err.Error())
-	}
-	// Test-4: setUserStatus() handler error correctly
-	expectedStatus = "enabled"
-	minioSetUserStatusMock = func(_ string, _ madmin.AccountStatus) error {
-		return errors.New("error")
-	}
-	if err := setUserStatus(ctx, adminClient, userName, expectedStatus); assert.Error(err) {
-		assert.Equal("error", err.Error())
-	}
-}
-
-func TestUserGroupsBulk(t *testing.T) {
-	assert := asrt.New(t)
-	// mock minIO client
-	adminClient := AdminClientMock{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	function := "updateUserGroups()"
-	mockUserGroups := []string{"group1", "group2", "group3"}
-	mockUsers := []string{"testUser", "testUser2"}
-
-	// Test-1: addUsersListToGroups() updates the groups for a users list
-	// mock function response from updateUserGroups(accessKey, groupsToAssign)
-	minioUpdateGroupMembersMock = func(_ madmin.GroupAddRemove) error {
-		return nil
-	}
-
-	if err := addUsersListToGroups(ctx, adminClient, mockUsers, mockUserGroups); err != nil {
-		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
-	}
-
-	// Test-2: addUsersListToGroups() make sure errors are handled correctly when error on updateGroupMembers()
-	// mock function response from removeUser(accessKey)
-	minioUpdateGroupMembersMock = func(_ madmin.GroupAddRemove) error {
-		return errors.New("error")
-	}
-
-	if err := addUsersListToGroups(ctx, adminClient, mockUsers, mockUserGroups); assert.Error(err) {
-		assert.Equal("error in users-groups assignation: \"error,error,error\"", err.Error())
-	}
-}
-
-func TestListUsersWithAccessToBucket(t *testing.T) {
-	assert := asrt.New(t)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	adminClient := AdminClientMock{}
-	user1 := madmin.UserInfo{
-		SecretKey:  "testtest",
-		PolicyName: "consoleAdmin,testPolicy,redundantPolicy",
-		Status:     "enabled",
-		MemberOf:   []string{"group1"},
-	}
-	user2 := madmin.UserInfo{
-		SecretKey:  "testtest",
-		PolicyName: "testPolicy, otherPolicy",
-		Status:     "enabled",
-		MemberOf:   []string{"group1"},
-	}
-	mockUsers := map[string]madmin.UserInfo{"testuser1": user1, "testuser2": user2}
-	minioListUsersMock = func() (map[string]madmin.UserInfo, error) {
-		return mockUsers, nil
-	}
-	policyMap := map[string]string{
-		"consoleAdmin": `{
-    "Version": "2012-10-17",
-    "Statement": [
-        {
-            "Effect": "Allow",
-            "Action": [
-                "admin:*"
-            ]
-        },
-        {
-            "Effect": "Allow",
-            "Action": [
-                "s3:*"
-            ],
-            "Resource": [
-                "arn:aws:s3:::*"
-            ]
-        }
-    ]
-}`,
-		"testPolicy": `{
-				"Version": "2012-10-17",
-				"Statement": [
-			{
-				"Effect": "Deny",
-				"Action": [
-				"s3:*"
-			],
-				"Resource": [
-				"arn:aws:s3:::bucket1"
-			]
-			}
-			]
-			}`,
-		"otherPolicy": `{
-				"Version": "2012-10-17",
-				"Statement": [
-			{
-				"Effect": "Allow",
-				"Action": [
-				"s3:*"
-			],
-				"Resource": [
-				"arn:aws:s3:::bucket2"
-			]
-			}
-			]
-			}`,
-		"thirdPolicy": `{
-				"Version": "2012-10-17",
-				"Statement": [
-			{
-				"Effect": "Allow",
-				"Action": [
-				"s3:*"
-			],
-				"Resource": [
-				"arn:aws:s3:::bucket3"
-			]
-			}
-			]
-			}`, "RedundantPolicy": `{
-				"Version": "2012-10-17",
-				"Statement": [
-			{
-				"Effect": "Allow",
-				"Action": [
-				"s3:*"
-			],
-				"Resource": [
-				"arn:aws:s3:::bucket1"
-			]
-			}
-			]
-			}`,
-	}
-	minioGetPolicyMock = func(name string) (*iampolicy.Policy, error) {
-		iamp, err := iampolicy.ParseConfig(bytes.NewReader([]byte(policyMap[name])))
-		if err != nil {
-			return nil, err
-		}
-		return iamp, nil
-	}
-	minioListGroupsMock = func() ([]string, error) {
-		return []string{"group1"}, nil
-	}
-	minioGetGroupDescriptionMock = func(name string) (*madmin.GroupDesc, error) {
-		if name == "group1" {
-			mockResponse := &madmin.GroupDesc{
-				Name:    "group1",
-				Policy:  "thirdPolicy",
-				Members: []string{"testuser1", "testuser2"},
-				Status:  "enabled",
-			}
-			return mockResponse, nil
-		}
-		return nil, ErrDefault
-	}
-	type args struct {
-		bucket string
-	}
-	tests := []struct {
-		name string
-		args args
-		want []string
-	}{
-		{
-			name: "Test1",
-			args: args{bucket: "bucket0"},
-			want: []string{"testuser1"},
-		},
-		{
-			name: "Test2",
-			args: args{bucket: "bucket1"},
-			want: []string(nil),
-		},
-		{
-			name: "Test3",
-			args: args{bucket: "bucket2"},
-			want: []string{"testuser1", "testuser2"},
-		},
-		{
-			name: "Test4",
-			args: args{bucket: "bucket3"},
-			want: []string{"testuser1", "testuser2"},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(_ *testing.T) {
-			got, _ := listUsersWithAccessToBucket(ctx, adminClient, tt.args.bucket)
-			assert.Equal(got, tt.want)
-		})
-	}
-}

api/client-admin.go

@@ -17,16 +17,12 @@
 package api
 
 import (
-	"bytes"
 	"context"
-	"encoding/json"
-	"io"
 	"net"
 	"net/http"
 	"net/url"
 	"regexp"
 	"strings"
-	"time"
 
 	"github.com/minio/console/pkg"
 
@@ -35,7 +31,6 @@ import (
 	"github.com/minio/console/models"
 	"github.com/minio/madmin-go/v3"
 	"github.com/minio/minio-go/v7/pkg/credentials"
-	iampolicy "github.com/minio/pkg/v3/policy"
 )
 
 const globalAppName = "MinIO Console"
@@ -44,88 +39,9 @@ const globalAppName = "MinIO Console"
 // by mock when testing, it should include all MinioAdmin respective api calls
 // that are used within this project.
 type MinioAdmin interface {
-	listUsers(ctx context.Context) (map[string]madmin.UserInfo, error)
-	addUser(ctx context.Context, acessKey, SecretKey string) error
-	removeUser(ctx context.Context, accessKey string) error
-	getUserInfo(ctx context.Context, accessKey string) (madmin.UserInfo, error)
-	setUserStatus(ctx context.Context, accessKey string, status madmin.AccountStatus) error
-	listGroups(ctx context.Context) ([]string, error)
-	updateGroupMembers(ctx context.Context, greq madmin.GroupAddRemove) error
-	getGroupDescription(ctx context.Context, group string) (*madmin.GroupDesc, error)
-	setGroupStatus(ctx context.Context, group string, status madmin.GroupStatus) error
-	listPolicies(ctx context.Context) (map[string]*iampolicy.Policy, error)
-	getPolicy(ctx context.Context, name string) (*iampolicy.Policy, error)
-	removePolicy(ctx context.Context, name string) error
-	addPolicy(ctx context.Context, name string, policy *iampolicy.Policy) error
-	setPolicy(ctx context.Context, policyName, entityName string, isGroup bool) error
-	getConfigKV(ctx context.Context, key string) ([]byte, error)
-	helpConfigKV(ctx context.Context, subSys, key string, envOnly bool) (madmin.Help, error)
-	helpConfigKVGlobal(ctx context.Context, envOnly bool) (madmin.Help, error)
-	setConfigKV(ctx context.Context, kv string) (restart bool, err error)
-	delConfigKV(ctx context.Context, kv string) (err error)
-	serviceRestart(ctx context.Context) error
-	serverInfo(ctx context.Context) (madmin.InfoMessage, error)
-	startProfiling(ctx context.Context, profiler madmin.ProfilerType) ([]madmin.StartProfilingResult, error)
-	stopProfiling(ctx context.Context) (io.ReadCloser, error)
-	serviceTrace(ctx context.Context, threshold int64, s3, internal, storage, os, errTrace bool) <-chan madmin.ServiceTraceInfo
-	getLogs(ctx context.Context, node string, lineCnt int, logKind string) <-chan madmin.LogInfo
 	AccountInfo(ctx context.Context) (madmin.AccountInfo, error)
-	heal(ctx context.Context, bucket, prefix string, healOpts madmin.HealOpts, clientToken string,
-		forceStart, forceStop bool) (healStart madmin.HealStartSuccess, healTaskStatus madmin.HealTaskStatus, err error)
-	// Service Accounts
-	addServiceAccount(ctx context.Context, policy string, user string, accessKey string, secretKey string, name string, description string, expiry *time.Time, comment string) (madmin.Credentials, error)
-	listServiceAccounts(ctx context.Context, user string) (madmin.ListServiceAccountsResp, error)
-	deleteServiceAccount(ctx context.Context, serviceAccount string) error
-	infoServiceAccount(ctx context.Context, serviceAccount string) (madmin.InfoServiceAccountResp, error)
-	updateServiceAccount(ctx context.Context, serviceAccount string, opts madmin.UpdateServiceAccountReq) error
-	// Remote Buckets
-	listRemoteBuckets(ctx context.Context, bucket, arnType string) (targets []madmin.BucketTarget, err error)
-	getRemoteBucket(ctx context.Context, bucket, arnType string) (targets *madmin.BucketTarget, err error)
-	removeRemoteBucket(ctx context.Context, bucket, arn string) error
-	addRemoteBucket(ctx context.Context, bucket string, target *madmin.BucketTarget) (string, error)
-	// Account password management
-	changePassword(ctx context.Context, accessKey, secretKey string) error
-	serverHealthInfo(ctx context.Context, deadline time.Duration) (interface{}, string, error)
-	// List Tiers
-	listTiers(ctx context.Context) ([]*madmin.TierConfig, error)
-	// Tier Info
-	tierStats(ctx context.Context) ([]madmin.TierInfo, error)
-	// Add Tier
-	addTier(ctx context.Context, tier *madmin.TierConfig) error
-	// Edit Tier Credentials
-	editTierCreds(ctx context.Context, tierName string, creds madmin.TierCreds) error
-	// verify Tier status
-	verifyTierStatus(ctx context.Context, tierName string) error
-	// remove empty Tier
-	removeTier(ctx context.Context, tierName string) error
-	// Speedtest
-	speedtest(ctx context.Context, opts madmin.SpeedtestOpts) (chan madmin.SpeedTestResult, error)
-	// Site Relication
-	getSiteReplicationInfo(ctx context.Context) (*madmin.SiteReplicationInfo, error)
-	addSiteReplicationInfo(ctx context.Context, sites []madmin.PeerSite, opts madmin.SRAddOptions) (*madmin.ReplicateAddStatus, error)
-	editSiteReplicationInfo(ctx context.Context, site madmin.PeerInfo, opts madmin.SREditOptions) (*madmin.ReplicateEditStatus, error)
-	deleteSiteReplicationInfo(ctx context.Context, removeReq madmin.SRRemoveReq) (*madmin.ReplicateRemoveStatus, error)
-
-	// Replication status
-	getSiteReplicationStatus(ctx context.Context, params madmin.SRStatusOptions) (*madmin.SRStatusInfo, error)
-
 	// KMS
 	kmsStatus(ctx context.Context) (madmin.KMSStatus, error)
-	kmsMetrics(ctx context.Context) (*madmin.KMSMetrics, error)
-	kmsAPIs(ctx context.Context) ([]madmin.KMSAPI, error)
-	kmsVersion(ctx context.Context) (*madmin.KMSVersion, error)
-	createKey(ctx context.Context, key string) error
-	listKeys(ctx context.Context, pattern string) ([]madmin.KMSKeyInfo, error)
-	keyStatus(ctx context.Context, key string) (*madmin.KMSKeyStatus, error)
-
-	// IDP
-	addOrUpdateIDPConfig(ctx context.Context, idpType, cfgName, cfgData string, update bool) (restart bool, err error)
-	listIDPConfig(ctx context.Context, idpType string) ([]madmin.IDPListItem, error)
-	deleteIDPConfig(ctx context.Context, idpType, cfgName string) (restart bool, err error)
-	getIDPConfig(ctx context.Context, cfgType, cfgName string) (c madmin.IDPConfig, err error)
-
-	// LDAP
-	getLDAPPolicyEntities(ctx context.Context, query madmin.PolicyEntitiesQuery) (madmin.PolicyEntitiesResult, error)
 }
 
 // Interface implementation
@@ -136,306 +52,17 @@ type AdminClient struct {
 	Client *madmin.AdminClient
 }
 
-func (ac AdminClient) changePassword(ctx context.Context, accessKey, secretKey string) error {
-	return ac.Client.SetUser(ctx, accessKey, secretKey, madmin.AccountEnabled)
-}
-
-// implements madmin.ListUsers()
-func (ac AdminClient) listUsers(ctx context.Context) (map[string]madmin.UserInfo, error) {
-	return ac.Client.ListUsers(ctx)
-}
-
-// implements madmin.AddUser()
-func (ac AdminClient) addUser(ctx context.Context, accessKey, secretKey string) error {
-	return ac.Client.AddUser(ctx, accessKey, secretKey)
-}
-
-// implements madmin.RemoveUser()
-func (ac AdminClient) removeUser(ctx context.Context, accessKey string) error {
-	return ac.Client.RemoveUser(ctx, accessKey)
-}
-
-// implements madmin.GetUserInfo()
-func (ac AdminClient) getUserInfo(ctx context.Context, accessKey string) (madmin.UserInfo, error) {
-	return ac.Client.GetUserInfo(ctx, accessKey)
-}
-
-// implements madmin.SetUserStatus()
-func (ac AdminClient) setUserStatus(ctx context.Context, accessKey string, status madmin.AccountStatus) error {
-	return ac.Client.SetUserStatus(ctx, accessKey, status)
-}
-
-// implements madmin.ListGroups()
-func (ac AdminClient) listGroups(ctx context.Context) ([]string, error) {
-	return ac.Client.ListGroups(ctx)
-}
-
-// implements madmin.UpdateGroupMembers()
-func (ac AdminClient) updateGroupMembers(ctx context.Context, greq madmin.GroupAddRemove) error {
-	return ac.Client.UpdateGroupMembers(ctx, greq)
-}
-
-// implements madmin.GetGroupDescription(group)
-func (ac AdminClient) getGroupDescription(ctx context.Context, group string) (*madmin.GroupDesc, error) {
-	return ac.Client.GetGroupDescription(ctx, group)
-}
-
-// implements madmin.SetGroupStatus(group, status)
-func (ac AdminClient) setGroupStatus(ctx context.Context, group string, status madmin.GroupStatus) error {
-	return ac.Client.SetGroupStatus(ctx, group, status)
-}
-
-// implements madmin.ListCannedPolicies()
-func (ac AdminClient) listPolicies(ctx context.Context) (map[string]*iampolicy.Policy, error) {
-	policyMap, err := ac.Client.ListCannedPolicies(ctx)
-	if err != nil {
-		return nil, err
-	}
-	policies := make(map[string]*iampolicy.Policy, len(policyMap))
-	for k, v := range policyMap {
-		p, err := iampolicy.ParseConfig(bytes.NewReader(v))
-		if err != nil {
-			return nil, err
-		}
-		policies[k] = p
-	}
-	return policies, nil
-}
-
-// implements madmin.ListCannedPolicies()
-func (ac AdminClient) getPolicy(ctx context.Context, name string) (*iampolicy.Policy, error) {
-	info, err := ac.Client.InfoCannedPolicyV2(ctx, name)
-	if err != nil {
-		return nil, err
-	}
-	return iampolicy.ParseConfig(bytes.NewReader(info.Policy))
-}
-
-// implements madmin.RemoveCannedPolicy()
-func (ac AdminClient) removePolicy(ctx context.Context, name string) error {
-	return ac.Client.RemoveCannedPolicy(ctx, name)
-}
-
-// implements madmin.AddCannedPolicy()
-func (ac AdminClient) addPolicy(ctx context.Context, name string, policy *iampolicy.Policy) error {
-	buf, err := json.Marshal(policy)
-	if err != nil {
-		return err
-	}
-	return ac.Client.AddCannedPolicy(ctx, name, buf)
-}
-
-// implements madmin.SetPolicy()
-func (ac AdminClient) setPolicy(ctx context.Context, policyName, entityName string, isGroup bool) error {
-	// nolint:staticcheck // ignore SA1019
-	return ac.Client.SetPolicy(ctx, policyName, entityName, isGroup)
-}
-
-// implements madmin.GetConfigKV()
-func (ac AdminClient) getConfigKV(ctx context.Context, key string) ([]byte, error) {
-	return ac.Client.GetConfigKV(ctx, key)
-}
-
-// implements madmin.HelpConfigKV()
-func (ac AdminClient) helpConfigKV(ctx context.Context, subSys, key string, envOnly bool) (madmin.Help, error) {
-	return ac.Client.HelpConfigKV(ctx, subSys, key, envOnly)
-}
-
-// implements madmin.helpConfigKVGlobal()
-func (ac AdminClient) helpConfigKVGlobal(ctx context.Context, envOnly bool) (madmin.Help, error) {
-	return ac.Client.HelpConfigKV(ctx, "", "", envOnly)
-}
-
-// implements madmin.SetConfigKV()
-func (ac AdminClient) setConfigKV(ctx context.Context, kv string) (restart bool, err error) {
-	return ac.Client.SetConfigKV(ctx, kv)
-}
-
-// implements madmin.DelConfigKV()
-func (ac AdminClient) delConfigKV(ctx context.Context, kv string) (err error) {
-	_, err = ac.Client.DelConfigKV(ctx, kv)
-	return err
-}
-
-// implements madmin.ServiceRestart()
-func (ac AdminClient) serviceRestart(ctx context.Context) (err error) {
-	return ac.Client.ServiceRestart(ctx)
-}
-
-// implements madmin.ServerInfo()
-func (ac AdminClient) serverInfo(ctx context.Context) (madmin.InfoMessage, error) {
-	return ac.Client.ServerInfo(ctx)
-}
-
-// implements madmin.StartProfiling()
-func (ac AdminClient) startProfiling(ctx context.Context, profiler madmin.ProfilerType) ([]madmin.StartProfilingResult, error) {
-	return ac.Client.StartProfiling(ctx, profiler)
-}
-
-// implements madmin.DownloadProfilingData()
-func (ac AdminClient) stopProfiling(ctx context.Context) (io.ReadCloser, error) {
-	return ac.Client.DownloadProfilingData(ctx)
-}
-
-// implements madmin.ServiceTrace()
-func (ac AdminClient) serviceTrace(ctx context.Context, threshold int64, _, internal, storage, os, errTrace bool) <-chan madmin.ServiceTraceInfo {
-	thresholdT := time.Duration(threshold)
-
-	tracingOptions := madmin.ServiceTraceOpts{
-		S3:         true,
-		OnlyErrors: errTrace,
-		Internal:   internal,
-		Storage:    storage,
-		OS:         os,
-		Threshold:  thresholdT,
-	}
-
-	return ac.Client.ServiceTrace(ctx, tracingOptions)
-}
-
-// implements madmin.GetLogs()
-func (ac AdminClient) getLogs(ctx context.Context, node string, lineCnt int, logKind string) <-chan madmin.LogInfo {
-	return ac.Client.GetLogs(ctx, node, lineCnt, logKind)
-}
-
-// implements madmin.AddServiceAccount()
-func (ac AdminClient) addServiceAccount(ctx context.Context, policy string, user string, accessKey string, secretKey string, name string, description string, expiry *time.Time, comment string) (madmin.Credentials, error) {
-	return ac.Client.AddServiceAccount(ctx, madmin.AddServiceAccountReq{
-		Policy:      []byte(policy),
-		TargetUser:  user,
-		AccessKey:   accessKey,
-		SecretKey:   secretKey,
-		Name:        name,
-		Description: description,
-		Expiration:  expiry,
-		Comment:     comment,
-	})
-}
-
-// implements madmin.ListServiceAccounts()
-func (ac AdminClient) listServiceAccounts(ctx context.Context, user string) (madmin.ListServiceAccountsResp, error) {
-	return ac.Client.ListServiceAccounts(ctx, user)
-}
-
-// implements madmin.DeleteServiceAccount()
-func (ac AdminClient) deleteServiceAccount(ctx context.Context, serviceAccount string) error {
-	return ac.Client.DeleteServiceAccount(ctx, serviceAccount)
-}
-
-// implements madmin.InfoServiceAccount()
-func (ac AdminClient) infoServiceAccount(ctx context.Context, serviceAccount string) (madmin.InfoServiceAccountResp, error) {
-	return ac.Client.InfoServiceAccount(ctx, serviceAccount)
-}
-
-// implements madmin.UpdateServiceAccount()
-func (ac AdminClient) updateServiceAccount(ctx context.Context, serviceAccount string, opts madmin.UpdateServiceAccountReq) error {
-	return ac.Client.UpdateServiceAccount(ctx, serviceAccount, opts)
-}
-
 // AccountInfo implements madmin.AccountInfo()
 func (ac AdminClient) AccountInfo(ctx context.Context) (madmin.AccountInfo, error) {
 	return ac.Client.AccountInfo(ctx, madmin.AccountOpts{})
 }
 
-func (ac AdminClient) heal(ctx context.Context, bucket, prefix string, healOpts madmin.HealOpts, clientToken string,
-	forceStart, forceStop bool,
-) (healStart madmin.HealStartSuccess, healTaskStatus madmin.HealTaskStatus, err error) {
-	return ac.Client.Heal(ctx, bucket, prefix, healOpts, clientToken, forceStart, forceStop)
-}
-
-// listRemoteBuckets - return a list of remote buckets
-func (ac AdminClient) listRemoteBuckets(ctx context.Context, bucket, arnType string) (targets []madmin.BucketTarget, err error) {
-	return ac.Client.ListRemoteTargets(ctx, bucket, arnType)
-}
-
-// getRemoteBucket - gets remote bucked based on a given bucket name
-func (ac AdminClient) getRemoteBucket(ctx context.Context, bucket, arnType string) (*madmin.BucketTarget, error) {
-	targets, err := ac.Client.ListRemoteTargets(ctx, bucket, arnType)
-	if err != nil {
-		return nil, err
-	}
-	if len(targets) > 0 {
-		return &targets[0], nil
-	}
-	return nil, err
-}
-
-// removeRemoteBucket removes a remote target associated with particular ARN for this bucket
-func (ac AdminClient) removeRemoteBucket(ctx context.Context, bucket, arn string) error {
-	return ac.Client.RemoveRemoteTarget(ctx, bucket, arn)
-}
-
-// addRemoteBucket sets up a remote target for this bucket
-func (ac AdminClient) addRemoteBucket(ctx context.Context, bucket string, target *madmin.BucketTarget) (string, error) {
-	return ac.Client.SetRemoteTarget(ctx, bucket, target)
-}
-
-func (ac AdminClient) setBucketQuota(ctx context.Context, bucket string, quota *madmin.BucketQuota) error {
-	return ac.Client.SetBucketQuota(ctx, bucket, quota)
-}
-
 func (ac AdminClient) getBucketQuota(ctx context.Context, bucket string) (madmin.BucketQuota, error) {
 	return ac.Client.GetBucketQuota(ctx, bucket)
 }
 
-// serverHealthInfo implements mc.ServerHealthInfo - Connect to a minio server and call Health Info Management API
+func (ac AdminClient) kmsStatus(ctx context.Context) (madmin.KMSStatus, error) {
-func (ac AdminClient) serverHealthInfo(ctx context.Context, deadline time.Duration) (interface{}, string, error) {
+	return ac.Client.KMSStatus(ctx)
-	info := madmin.HealthInfo{}
-	var healthInfo interface{}
-	var version string
-	var resp *http.Response
-	var err error
-	resp, version, err = ac.Client.ServerHealthInfo(ctx, madmin.HealthDataTypesList, deadline, "")
-	if err != nil {
-		return nil, version, err
-	}
-	decoder := json.NewDecoder(resp.Body)
-	for {
-		if err = decoder.Decode(&info); err != nil {
-			break
-		}
-	}
-	if info.Version == "" {
-		return nil, "", ErrHealthReportFail
-	}
-	healthInfo = info
-
-	return healthInfo, version, nil
-}
-
-// implements madmin.listTiers()
-func (ac AdminClient) listTiers(ctx context.Context) ([]*madmin.TierConfig, error) {
-	return ac.Client.ListTiers(ctx)
-}
-
-// implements madmin.tierStats()
-func (ac AdminClient) tierStats(ctx context.Context) ([]madmin.TierInfo, error) {
-	return ac.Client.TierStats(ctx)
-}
-
-// implements madmin.AddTier()
-func (ac AdminClient) addTier(ctx context.Context, cfg *madmin.TierConfig) error {
-	return ac.Client.AddTier(ctx, cfg)
-}
-
-// implements madmin.Inspect()
-func (ac AdminClient) inspect(ctx context.Context, insOpts madmin.InspectOptions) ([]byte, io.ReadCloser, error) {
-	return ac.Client.Inspect(ctx, insOpts)
-}
-
-// implements madmin.EditTier()
-func (ac AdminClient) editTierCreds(ctx context.Context, tierName string, creds madmin.TierCreds) error {
-	return ac.Client.EditTier(ctx, tierName, creds)
-}
-
-// implements madmin.VerifyTier()
-func (ac AdminClient) verifyTierStatus(ctx context.Context, tierName string) error {
-	return ac.Client.VerifyTier(ctx, tierName)
-}
-
-// implements madmin.RemoveTier()
-func (ac AdminClient) removeTier(ctx context.Context, tierName string) error {
-	return ac.Client.RemoveTier(ctx, tierName)
 }
 
 func NewMinioAdminClient(ctx context.Context, sessionClaims *models.Principal) (*madmin.AdminClient, error) {
@@ -465,19 +92,6 @@ func newAdminFromClaims(claims *models.Principal, clientIP string) (*madmin.Admi
 	return adminClient, nil
 }
 
-// newAdminFromCreds Creates a minio client using custom credentials for connecting to a remote host
-func newAdminFromCreds(accessKey, secretKey, endpoint string, tlsEnabled bool) (*madmin.AdminClient, error) {
-	minioClient, err := madmin.NewWithOptions(endpoint, &madmin.Options{
-		Creds:  credentials.NewStaticV4(accessKey, secretKey, ""),
-		Secure: tlsEnabled,
-	})
-	if err != nil {
-		return nil, err
-	}
-	minioClient.SetAppInfo(globalAppName, pkg.Version)
-	return minioClient, nil
-}
-
 // isLocalAddress returns true if the url contains an IPv4/IPv6 hostname
 // that points to the local machine - FQDN are not supported
 func isLocalIPEndpoint(endpoint string) bool {
@@ -574,114 +188,3 @@ func getClientIP(r *http.Request) string {
 	}
 	return raddr
 }
-
-func (ac AdminClient) speedtest(ctx context.Context, opts madmin.SpeedtestOpts) (chan madmin.SpeedTestResult, error) {
-	return ac.Client.Speedtest(ctx, opts)
-}
-
-// Site Replication
-func (ac AdminClient) getSiteReplicationInfo(ctx context.Context) (*madmin.SiteReplicationInfo, error) {
-	res, err := ac.Client.SiteReplicationInfo(ctx)
-	if err != nil {
-		return nil, err
-	}
-	return &madmin.SiteReplicationInfo{
-		Enabled:                 res.Enabled,
-		Name:                    res.Name,
-		Sites:                   res.Sites,
-		ServiceAccountAccessKey: res.ServiceAccountAccessKey,
-	}, nil
-}
-
-func (ac AdminClient) addSiteReplicationInfo(ctx context.Context, sites []madmin.PeerSite, opts madmin.SRAddOptions) (*madmin.ReplicateAddStatus, error) {
-	res, err := ac.Client.SiteReplicationAdd(ctx, sites, opts)
-	if err != nil {
-		return nil, err
-	}
-
-	return &madmin.ReplicateAddStatus{
-		Success:                 res.Success,
-		Status:                  res.Status,
-		ErrDetail:               res.ErrDetail,
-		InitialSyncErrorMessage: res.InitialSyncErrorMessage,
-	}, nil
-}
-
-func (ac AdminClient) editSiteReplicationInfo(ctx context.Context, site madmin.PeerInfo, opts madmin.SREditOptions) (*madmin.ReplicateEditStatus, error) {
-	res, err := ac.Client.SiteReplicationEdit(ctx, site, opts)
-	if err != nil {
-		return nil, err
-	}
-	return &madmin.ReplicateEditStatus{
-		Success:   res.Success,
-		Status:    res.Status,
-		ErrDetail: res.ErrDetail,
-	}, nil
-}
-
-func (ac AdminClient) deleteSiteReplicationInfo(ctx context.Context, removeReq madmin.SRRemoveReq) (*madmin.ReplicateRemoveStatus, error) {
-	res, err := ac.Client.SiteReplicationRemove(ctx, removeReq)
-	if err != nil {
-		return nil, err
-	}
-	return &madmin.ReplicateRemoveStatus{
-		Status:    res.Status,
-		ErrDetail: res.ErrDetail,
-	}, nil
-}
-
-func (ac AdminClient) getSiteReplicationStatus(ctx context.Context, params madmin.SRStatusOptions) (*madmin.SRStatusInfo, error) {
-	res, err := ac.Client.SRStatusInfo(ctx, params)
-	if err != nil {
-		return nil, err
-	}
-	return &res, nil
-}
-
-func (ac AdminClient) kmsStatus(ctx context.Context) (madmin.KMSStatus, error) {
-	return ac.Client.KMSStatus(ctx)
-}
-
-func (ac AdminClient) kmsMetrics(ctx context.Context) (*madmin.KMSMetrics, error) {
-	return ac.Client.KMSMetrics(ctx)
-}
-
-func (ac AdminClient) kmsAPIs(ctx context.Context) ([]madmin.KMSAPI, error) {
-	return ac.Client.KMSAPIs(ctx)
-}
-
-func (ac AdminClient) kmsVersion(ctx context.Context) (*madmin.KMSVersion, error) {
-	return ac.Client.KMSVersion(ctx)
-}
-
-func (ac AdminClient) createKey(ctx context.Context, key string) error {
-	return ac.Client.CreateKey(ctx, key)
-}
-
-func (ac AdminClient) listKeys(ctx context.Context, pattern string) ([]madmin.KMSKeyInfo, error) {
-	return ac.Client.ListKeys(ctx, pattern)
-}
-
-func (ac AdminClient) keyStatus(ctx context.Context, key string) (*madmin.KMSKeyStatus, error) {
-	return ac.Client.GetKeyStatus(ctx, key)
-}
-
-func (ac AdminClient) addOrUpdateIDPConfig(ctx context.Context, idpType, cfgName, cfgData string, update bool) (restart bool, err error) {
-	return ac.Client.AddOrUpdateIDPConfig(ctx, idpType, cfgName, cfgData, update)
-}
-
-func (ac AdminClient) listIDPConfig(ctx context.Context, idpType string) ([]madmin.IDPListItem, error) {
-	return ac.Client.ListIDPConfig(ctx, idpType)
-}
-
-func (ac AdminClient) deleteIDPConfig(ctx context.Context, idpType, cfgName string) (restart bool, err error) {
-	return ac.Client.DeleteIDPConfig(ctx, idpType, cfgName)
-}
-
-func (ac AdminClient) getIDPConfig(ctx context.Context, idpType, cfgName string) (c madmin.IDPConfig, err error) {
-	return ac.Client.GetIDPConfig(ctx, idpType, cfgName)
-}
-
-func (ac AdminClient) getLDAPPolicyEntities(ctx context.Context, query madmin.PolicyEntitiesQuery) (madmin.PolicyEntitiesResult, error) {
-	return ac.Client.GetLDAPPolicyEntities(ctx, query)
-}

api/client.go

@@ -21,11 +21,11 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"net/http"
 	"path"
 	"strings"
 	"time"
 
-	"github.com/minio/minio-go/v7/pkg/replication"
 	"github.com/minio/minio-go/v7/pkg/sse"
 	xnet "github.com/minio/pkg/v3/net"
 
@@ -137,11 +137,6 @@ func (c minioClient) getBucketVersioning(ctx context.Context, bucketName string)
 	return c.client.GetBucketVersioning(ctx, bucketName)
 }
 
-// implements minio.getBucketVersioning(ctx, bucketName)
-func (c minioClient) getBucketReplication(ctx context.Context, bucketName string) (replication.Config, error) {
-	return c.client.GetBucketReplication(ctx, bucketName)
-}
-
 // implements minio.listObjects(ctx)
 func (c minioClient) listObjects(ctx context.Context, bucket string, opts minio.ListObjectsOptions) <-chan minio.ObjectInfo {
 	return c.client.ListObjects(ctx, bucket, opts)
@@ -246,14 +241,6 @@ func (c mcClient) watch(ctx context.Context, options mc.WatchOptions) (*mc.Watch
 	return c.client.Watch(ctx, options)
 }
 
-func (c mcClient) setReplication(ctx context.Context, cfg *replication.Config, opts replication.Options) *probe.Error {
-	return c.client.SetReplication(ctx, cfg, opts)
-}
-
-func (c mcClient) deleteAllReplicationRules(ctx context.Context) *probe.Error {
-	return c.client.RemoveReplication(ctx)
-}
-
 func (c mcClient) setVersioning(ctx context.Context, status string, excludePrefix []string, excludeFolders bool) *probe.Error {
 	return c.client.SetVersion(ctx, status, excludePrefix, excludeFolders)
 }
@@ -288,6 +275,7 @@ type ConsoleCredentialsI interface {
 type ConsoleCredentials struct {
 	ConsoleCredentials *credentials.Credentials
 	AccountAccessKey   string
+	CredContext        *credentials.CredContext
 }
 
 func (c ConsoleCredentials) GetAccountAccessKey() string {
@@ -296,7 +284,7 @@ func (c ConsoleCredentials) GetAccountAccessKey() string {
 
 // Get implements *Login.Get()
 func (c ConsoleCredentials) Get() (credentials.Value, error) {
-	return c.ConsoleCredentials.Get()
+	return c.ConsoleCredentials.GetWithContext(c.CredContext)
 }
 
 // Expire implements *Login.Expire()
@@ -311,6 +299,10 @@ type consoleSTSAssumeRole struct {
 	stsAssumeRole *credentials.STSAssumeRole
 }
 
+func (s consoleSTSAssumeRole) RetrieveWithCredContext(cc *credentials.CredContext) (credentials.Value, error) {
+	return s.stsAssumeRole.RetrieveWithCredContext(cc)
+}
+
 func (s consoleSTSAssumeRole) Retrieve() (credentials.Value, error) {
 	return s.stsAssumeRole.Retrieve()
 }
@@ -319,7 +311,7 @@ func (s consoleSTSAssumeRole) IsExpired() bool {
 	return s.stsAssumeRole.IsExpired()
 }
 
-func stsCredentials(minioURL, accessKey, secretKey, location, clientIP string) (*credentials.Credentials, error) {
+func stsCredentials(minioURL, accessKey, secretKey, location string, client *http.Client) (*credentials.Credentials, error) {
 	if accessKey == "" || secretKey == "" {
 		return nil, errors.New("credentials endpoint, access and secret key are mandatory for AssumeRoleSTS")
 	}
@@ -330,7 +322,7 @@ func stsCredentials(minioURL, accessKey, secretKey, location, clientIP string) (
 		DurationSeconds: int(xjwt.GetConsoleSTSDuration().Seconds()),
 	}
 	stsAssumeRole := &credentials.STSAssumeRole{
-		Client:      GetConsoleHTTPClient(clientIP),
+		Client:      client,
 		STSEndpoint: minioURL,
 		Options:     opts,
 	}
@@ -338,51 +330,48 @@ func stsCredentials(minioURL, accessKey, secretKey, location, clientIP string) (
 	return credentials.New(consoleSTSWrapper), nil
 }
 
-func NewConsoleCredentials(accessKey, secretKey, location, clientIP string) (*credentials.Credentials, error) {
+func NewConsoleCredentials(accessKey, secretKey, location string, client *http.Client) (*credentials.Credentials, error) {
 	minioURL := getMinIOServer()
 
-	// Future authentication methods can be added under this switch statement
-	switch {
 	// LDAP authentication for Console
-	case ldap.GetLDAPEnabled():
+	if ldap.GetLDAPEnabled() {
-		{
+		creds, err := auth.GetCredentialsFromLDAP(client, minioURL, accessKey, secretKey)
-			creds, err := auth.GetCredentialsFromLDAP(GetConsoleHTTPClient(clientIP), minioURL, accessKey, secretKey)
+		if err != nil {
+			return nil, err
+		}
+
+		credContext := &credentials.CredContext{
+			Client: client,
+		}
+
+		// We verify if LDAP credentials are correct and no error is returned
+		_, err = creds.GetWithContext(credContext)
+
+		if err != nil && strings.Contains(strings.ToLower(err.Error()), "not found") {
+			// We try to use STS Credentials in case LDAP credentials are incorrect.
+			stsCreds, errSTS := stsCredentials(minioURL, accessKey, secretKey, location, client)
+
+			// If there is an error with STS too, then we return the original LDAP error
+			if errSTS != nil {
+				LogError("error in STS credentials for LDAP case: %v ", errSTS)
+
+				// We return LDAP result
+				return creds, nil
+			}
+
+			_, err := stsCreds.GetWithContext(credContext)
+			// There is an error with STS credentials, We return the result of LDAP as STS is not a priority in this case.
 			if err != nil {
-				return nil, err
+				return creds, nil
 			}
 
-			// We verify if LDAP credentials are correct and no error is returned
+			return stsCreds, nil
-			_, err = creds.Get()
-
-			if err != nil && strings.Contains(strings.ToLower(err.Error()), "not found") {
-				// We try to use STS Credentials in case LDAP credentials are incorrect.
-				stsCreds, errSTS := stsCredentials(minioURL, accessKey, secretKey, location, clientIP)
-
-				// If there is an error with STS too, then we return the original LDAP error
-				if errSTS != nil {
-					LogError("error in STS credentials for LDAP case: %v ", errSTS)
-
-					// We return LDAP result
-					return creds, nil
-				}
-
-				_, err := stsCreds.Get()
-				// There is an error with STS credentials, We return the result of LDAP as STS is not a priority in this case.
-				if err != nil {
-					return creds, nil
-				}
-
-				return stsCreds, nil
-			}
-
-			return creds, nil
-		}
-	// default authentication for Console is via STS (Security Token Service) against MinIO
-	default:
-		{
-			return stsCredentials(minioURL, accessKey, secretKey, location, clientIP)
 		}
+
+		return creds, nil
 	}
+
+	return stsCredentials(minioURL, accessKey, secretKey, location, client)
 }
 
 // getConsoleCredentialsFromSession returns the *consoleCredentials.Login associated to the

api/config.go

@@ -262,18 +262,10 @@ func getPrometheusURL() string {
 	return env.Get(PrometheusURL, "")
 }
 
-func getPrometheusAuthToken() string {
-	return env.Get(PrometheusAuthToken, "")
-}
-
 func getPrometheusJobID() string {
 	return env.Get(PrometheusJobID, "minio-job")
 }
 
-func getPrometheusExtraLabels() string {
-	return env.Get(PrometheusExtraLabels, "")
-}
-
 func getMaxConcurrentUploadsLimit() int64 {
 	cu, err := strconv.ParseInt(env.Get(ConsoleMaxConcurrentUploads, "10"), 10, 64)
 	if err != nil {

api/configure_console.go

@@ -115,52 +115,13 @@ func configureAPI(api *operations.ConsoleAPI) http.Handler {
 	registerLogoutHandlers(api)
 	// Register bucket handlers
 	registerBucketsHandlers(api)
-	// Register all users handlers
-	registerUsersHandlers(api)
-	// Register groups handlers
-	registerGroupsHandlers(api)
-	// Register policies handlers
-	registersPoliciesHandler(api)
-	// Register configurations handlers
-	registerConfigHandlers(api)
-	// Register bucket events handlers
-	registerBucketEventsHandlers(api)
-	// Register service handlers
-	registerServiceHandlers(api)
 	// Register session handlers
 	registerSessionHandlers(api)
-	// Register admin info handlers
-	registerAdminInfoHandlers(api)
-	// Register admin arns handlers
-	registerAdminArnsHandlers(api)
-	// Register admin notification endpoints handlers
-	registerAdminNotificationEndpointsHandlers(api)
-	// Register admin Service Account Handlers
-	registerServiceAccountsHandlers(api)
-	// Register admin remote buckets
-	registerAdminBucketRemoteHandlers(api)
-	// Register admin log search
-	registerLogSearchHandlers(api)
-	// Register admin KMS handlers
-	registerKMSHandlers(api)
-	// Register admin IDP handlers
-	registerIDPHandlers(api)
-	// Register Inspect Handler
-	registerInspectHandler(api)
-	// Register nodes handlers
-	registerNodesHandler(api)
-
-	// Operator Console
-
 	// Register Object's Handlers
 	registerObjectsHandlers(api)
 	// Register Bucket Quota's Handlers
 	registerBucketQuotaHandlers(api)
-	// Register Account handlers
+	// Register Bucket Policy's Handlers
-	registerAccountHandlers(api)
-
-	registerReleasesHandlers(api)
-
 	registerPublicObjectsHandlers(api)
 
 	api.PreServerShutdown = func() {}

api/operations/account/account_change_password.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 account
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// AccountChangePasswordHandlerFunc turns a function with the right signature into a account change password handler
-type AccountChangePasswordHandlerFunc func(AccountChangePasswordParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn AccountChangePasswordHandlerFunc) Handle(params AccountChangePasswordParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// AccountChangePasswordHandler interface for that can handle valid account change password params
-type AccountChangePasswordHandler interface {
-	Handle(AccountChangePasswordParams, *models.Principal) middleware.Responder
-}
-
-// NewAccountChangePassword creates a new http.Handler for the account change password operation
-func NewAccountChangePassword(ctx *middleware.Context, handler AccountChangePasswordHandler) *AccountChangePassword {
-	return &AccountChangePassword{Context: ctx, Handler: handler}
-}
-
-/*
-	AccountChangePassword swagger:route POST /account/change-password Account accountChangePassword
-
-Change password of currently logged in user.
-*/
-type AccountChangePassword struct {
-	Context *middleware.Context
-	Handler AccountChangePasswordHandler
-}
-
-func (o *AccountChangePassword) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewAccountChangePasswordParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/account/account_change_password_parameters.go

@@ -1,101 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 account
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"io"
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/validate"
-
-	"github.com/minio/console/models"
-)
-
-// NewAccountChangePasswordParams creates a new AccountChangePasswordParams object
-//
-// There are no default values defined in the spec.
-func NewAccountChangePasswordParams() AccountChangePasswordParams {
-
-	return AccountChangePasswordParams{}
-}
-
-// AccountChangePasswordParams contains all the bound params for the account change password operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters AccountChangePassword
-type AccountChangePasswordParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: body
-	*/
-	Body *models.AccountChangePasswordRequest
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewAccountChangePasswordParams() beforehand.
-func (o *AccountChangePasswordParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	if runtime.HasBody(r) {
-		defer r.Body.Close()
-		var body models.AccountChangePasswordRequest
-		if err := route.Consumer.Consume(r.Body, &body); err != nil {
-			if err == io.EOF {
-				res = append(res, errors.Required("body", "body", ""))
-			} else {
-				res = append(res, errors.NewParseError("body", "body", "", err))
-			}
-		} else {
-			// validate body object
-			if err := body.Validate(route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			ctx := validate.WithOperationRequest(r.Context())
-			if err := body.ContextValidate(ctx, route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			if len(res) == 0 {
-				o.Body = &body
-			}
-		}
-	} else {
-		res = append(res, errors.Required("body", "body", ""))
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}

api/operations/account/account_change_password_responses.go

@@ -1,115 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 account
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// AccountChangePasswordNoContentCode is the HTTP code returned for type AccountChangePasswordNoContent
-const AccountChangePasswordNoContentCode int = 204
-
-/*
-AccountChangePasswordNoContent A successful login.
-
-swagger:response accountChangePasswordNoContent
-*/
-type AccountChangePasswordNoContent struct {
-}
-
-// NewAccountChangePasswordNoContent creates AccountChangePasswordNoContent with default headers values
-func NewAccountChangePasswordNoContent() *AccountChangePasswordNoContent {
-
-	return &AccountChangePasswordNoContent{}
-}
-
-// WriteResponse to the client
-func (o *AccountChangePasswordNoContent) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
-
-	rw.WriteHeader(204)
-}
-
-/*
-AccountChangePasswordDefault Generic error response.
-
-swagger:response accountChangePasswordDefault
-*/
-type AccountChangePasswordDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewAccountChangePasswordDefault creates AccountChangePasswordDefault with default headers values
-func NewAccountChangePasswordDefault(code int) *AccountChangePasswordDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &AccountChangePasswordDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the account change password default response
-func (o *AccountChangePasswordDefault) WithStatusCode(code int) *AccountChangePasswordDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the account change password default response
-func (o *AccountChangePasswordDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the account change password default response
-func (o *AccountChangePasswordDefault) WithPayload(payload *models.APIError) *AccountChangePasswordDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the account change password default response
-func (o *AccountChangePasswordDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *AccountChangePasswordDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/account/account_change_password_urlbuilder.go

@@ -1,104 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 account
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-)
-
-// AccountChangePasswordURL generates an URL for the account change password operation
-type AccountChangePasswordURL struct {
-	_basePath string
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *AccountChangePasswordURL) WithBasePath(bp string) *AccountChangePasswordURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *AccountChangePasswordURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *AccountChangePasswordURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/account/change-password"
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *AccountChangePasswordURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *AccountChangePasswordURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *AccountChangePasswordURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on AccountChangePasswordURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on AccountChangePasswordURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *AccountChangePasswordURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/account/change_user_password.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 account
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// ChangeUserPasswordHandlerFunc turns a function with the right signature into a change user password handler
-type ChangeUserPasswordHandlerFunc func(ChangeUserPasswordParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn ChangeUserPasswordHandlerFunc) Handle(params ChangeUserPasswordParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// ChangeUserPasswordHandler interface for that can handle valid change user password params
-type ChangeUserPasswordHandler interface {
-	Handle(ChangeUserPasswordParams, *models.Principal) middleware.Responder
-}
-
-// NewChangeUserPassword creates a new http.Handler for the change user password operation
-func NewChangeUserPassword(ctx *middleware.Context, handler ChangeUserPasswordHandler) *ChangeUserPassword {
-	return &ChangeUserPassword{Context: ctx, Handler: handler}
-}
-
-/*
-	ChangeUserPassword swagger:route POST /account/change-user-password Account changeUserPassword
-
-Change password of currently logged in user.
-*/
-type ChangeUserPassword struct {
-	Context *middleware.Context
-	Handler ChangeUserPasswordHandler
-}
-
-func (o *ChangeUserPassword) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewChangeUserPasswordParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/account/change_user_password_parameters.go

@@ -1,101 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 account
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"io"
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/validate"
-
-	"github.com/minio/console/models"
-)
-
-// NewChangeUserPasswordParams creates a new ChangeUserPasswordParams object
-//
-// There are no default values defined in the spec.
-func NewChangeUserPasswordParams() ChangeUserPasswordParams {
-
-	return ChangeUserPasswordParams{}
-}
-
-// ChangeUserPasswordParams contains all the bound params for the change user password operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters ChangeUserPassword
-type ChangeUserPasswordParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: body
-	*/
-	Body *models.ChangeUserPasswordRequest
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewChangeUserPasswordParams() beforehand.
-func (o *ChangeUserPasswordParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	if runtime.HasBody(r) {
-		defer r.Body.Close()
-		var body models.ChangeUserPasswordRequest
-		if err := route.Consumer.Consume(r.Body, &body); err != nil {
-			if err == io.EOF {
-				res = append(res, errors.Required("body", "body", ""))
-			} else {
-				res = append(res, errors.NewParseError("body", "body", "", err))
-			}
-		} else {
-			// validate body object
-			if err := body.Validate(route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			ctx := validate.WithOperationRequest(r.Context())
-			if err := body.ContextValidate(ctx, route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			if len(res) == 0 {
-				o.Body = &body
-			}
-		}
-	} else {
-		res = append(res, errors.Required("body", "body", ""))
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}

api/operations/account/change_user_password_responses.go

@@ -1,115 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 account
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// ChangeUserPasswordCreatedCode is the HTTP code returned for type ChangeUserPasswordCreated
-const ChangeUserPasswordCreatedCode int = 201
-
-/*
-ChangeUserPasswordCreated Password successfully changed.
-
-swagger:response changeUserPasswordCreated
-*/
-type ChangeUserPasswordCreated struct {
-}
-
-// NewChangeUserPasswordCreated creates ChangeUserPasswordCreated with default headers values
-func NewChangeUserPasswordCreated() *ChangeUserPasswordCreated {
-
-	return &ChangeUserPasswordCreated{}
-}
-
-// WriteResponse to the client
-func (o *ChangeUserPasswordCreated) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
-
-	rw.WriteHeader(201)
-}
-
-/*
-ChangeUserPasswordDefault Generic error response.
-
-swagger:response changeUserPasswordDefault
-*/
-type ChangeUserPasswordDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewChangeUserPasswordDefault creates ChangeUserPasswordDefault with default headers values
-func NewChangeUserPasswordDefault(code int) *ChangeUserPasswordDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &ChangeUserPasswordDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the change user password default response
-func (o *ChangeUserPasswordDefault) WithStatusCode(code int) *ChangeUserPasswordDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the change user password default response
-func (o *ChangeUserPasswordDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the change user password default response
-func (o *ChangeUserPasswordDefault) WithPayload(payload *models.APIError) *ChangeUserPasswordDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the change user password default response
-func (o *ChangeUserPasswordDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *ChangeUserPasswordDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/account/change_user_password_urlbuilder.go

@@ -1,104 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 account
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-)
-
-// ChangeUserPasswordURL generates an URL for the change user password operation
-type ChangeUserPasswordURL struct {
-	_basePath string
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *ChangeUserPasswordURL) WithBasePath(bp string) *ChangeUserPasswordURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *ChangeUserPasswordURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *ChangeUserPasswordURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/account/change-user-password"
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *ChangeUserPasswordURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *ChangeUserPasswordURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *ChangeUserPasswordURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on ChangeUserPasswordURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on ChangeUserPasswordURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *ChangeUserPasswordURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/bucket/add_remote_bucket.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// AddRemoteBucketHandlerFunc turns a function with the right signature into a add remote bucket handler
-type AddRemoteBucketHandlerFunc func(AddRemoteBucketParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn AddRemoteBucketHandlerFunc) Handle(params AddRemoteBucketParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// AddRemoteBucketHandler interface for that can handle valid add remote bucket params
-type AddRemoteBucketHandler interface {
-	Handle(AddRemoteBucketParams, *models.Principal) middleware.Responder
-}
-
-// NewAddRemoteBucket creates a new http.Handler for the add remote bucket operation
-func NewAddRemoteBucket(ctx *middleware.Context, handler AddRemoteBucketHandler) *AddRemoteBucket {
-	return &AddRemoteBucket{Context: ctx, Handler: handler}
-}
-
-/*
-	AddRemoteBucket swagger:route POST /remote-buckets Bucket addRemoteBucket
-
-Add Remote Bucket
-*/
-type AddRemoteBucket struct {
-	Context *middleware.Context
-	Handler AddRemoteBucketHandler
-}
-
-func (o *AddRemoteBucket) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewAddRemoteBucketParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/bucket/add_remote_bucket_parameters.go

@@ -1,101 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"io"
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/validate"
-
-	"github.com/minio/console/models"
-)
-
-// NewAddRemoteBucketParams creates a new AddRemoteBucketParams object
-//
-// There are no default values defined in the spec.
-func NewAddRemoteBucketParams() AddRemoteBucketParams {
-
-	return AddRemoteBucketParams{}
-}
-
-// AddRemoteBucketParams contains all the bound params for the add remote bucket operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters AddRemoteBucket
-type AddRemoteBucketParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: body
-	*/
-	Body *models.CreateRemoteBucket
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewAddRemoteBucketParams() beforehand.
-func (o *AddRemoteBucketParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	if runtime.HasBody(r) {
-		defer r.Body.Close()
-		var body models.CreateRemoteBucket
-		if err := route.Consumer.Consume(r.Body, &body); err != nil {
-			if err == io.EOF {
-				res = append(res, errors.Required("body", "body", ""))
-			} else {
-				res = append(res, errors.NewParseError("body", "body", "", err))
-			}
-		} else {
-			// validate body object
-			if err := body.Validate(route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			ctx := validate.WithOperationRequest(r.Context())
-			if err := body.ContextValidate(ctx, route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			if len(res) == 0 {
-				o.Body = &body
-			}
-		}
-	} else {
-		res = append(res, errors.Required("body", "body", ""))
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}

api/operations/bucket/add_remote_bucket_responses.go

@@ -1,115 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// AddRemoteBucketCreatedCode is the HTTP code returned for type AddRemoteBucketCreated
-const AddRemoteBucketCreatedCode int = 201
-
-/*
-AddRemoteBucketCreated A successful response.
-
-swagger:response addRemoteBucketCreated
-*/
-type AddRemoteBucketCreated struct {
-}
-
-// NewAddRemoteBucketCreated creates AddRemoteBucketCreated with default headers values
-func NewAddRemoteBucketCreated() *AddRemoteBucketCreated {
-
-	return &AddRemoteBucketCreated{}
-}
-
-// WriteResponse to the client
-func (o *AddRemoteBucketCreated) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
-
-	rw.WriteHeader(201)
-}
-
-/*
-AddRemoteBucketDefault Generic error response.
-
-swagger:response addRemoteBucketDefault
-*/
-type AddRemoteBucketDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewAddRemoteBucketDefault creates AddRemoteBucketDefault with default headers values
-func NewAddRemoteBucketDefault(code int) *AddRemoteBucketDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &AddRemoteBucketDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the add remote bucket default response
-func (o *AddRemoteBucketDefault) WithStatusCode(code int) *AddRemoteBucketDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the add remote bucket default response
-func (o *AddRemoteBucketDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the add remote bucket default response
-func (o *AddRemoteBucketDefault) WithPayload(payload *models.APIError) *AddRemoteBucketDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the add remote bucket default response
-func (o *AddRemoteBucketDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *AddRemoteBucketDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/bucket/add_remote_bucket_urlbuilder.go

@@ -1,104 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-)
-
-// AddRemoteBucketURL generates an URL for the add remote bucket operation
-type AddRemoteBucketURL struct {
-	_basePath string
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *AddRemoteBucketURL) WithBasePath(bp string) *AddRemoteBucketURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *AddRemoteBucketURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *AddRemoteBucketURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/remote-buckets"
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *AddRemoteBucketURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *AddRemoteBucketURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *AddRemoteBucketURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on AddRemoteBucketURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on AddRemoteBucketURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *AddRemoteBucketURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/bucket/bucket_set_policy.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// BucketSetPolicyHandlerFunc turns a function with the right signature into a bucket set policy handler
-type BucketSetPolicyHandlerFunc func(BucketSetPolicyParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn BucketSetPolicyHandlerFunc) Handle(params BucketSetPolicyParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// BucketSetPolicyHandler interface for that can handle valid bucket set policy params
-type BucketSetPolicyHandler interface {
-	Handle(BucketSetPolicyParams, *models.Principal) middleware.Responder
-}
-
-// NewBucketSetPolicy creates a new http.Handler for the bucket set policy operation
-func NewBucketSetPolicy(ctx *middleware.Context, handler BucketSetPolicyHandler) *BucketSetPolicy {
-	return &BucketSetPolicy{Context: ctx, Handler: handler}
-}
-
-/*
-	BucketSetPolicy swagger:route PUT /buckets/{name}/set-policy Bucket bucketSetPolicy
-
-Bucket Set Policy
-*/
-type BucketSetPolicy struct {
-	Context *middleware.Context
-	Handler BucketSetPolicyHandler
-}
-
-func (o *BucketSetPolicy) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewBucketSetPolicyParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/bucket/bucket_set_policy_parameters.go

@@ -1,126 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"io"
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/validate"
-
-	"github.com/minio/console/models"
-)
-
-// NewBucketSetPolicyParams creates a new BucketSetPolicyParams object
-//
-// There are no default values defined in the spec.
-func NewBucketSetPolicyParams() BucketSetPolicyParams {
-
-	return BucketSetPolicyParams{}
-}
-
-// BucketSetPolicyParams contains all the bound params for the bucket set policy operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters BucketSetPolicy
-type BucketSetPolicyParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: body
-	*/
-	Body *models.SetBucketPolicyRequest
-	/*
-	  Required: true
-	  In: path
-	*/
-	Name string
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewBucketSetPolicyParams() beforehand.
-func (o *BucketSetPolicyParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	if runtime.HasBody(r) {
-		defer r.Body.Close()
-		var body models.SetBucketPolicyRequest
-		if err := route.Consumer.Consume(r.Body, &body); err != nil {
-			if err == io.EOF {
-				res = append(res, errors.Required("body", "body", ""))
-			} else {
-				res = append(res, errors.NewParseError("body", "body", "", err))
-			}
-		} else {
-			// validate body object
-			if err := body.Validate(route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			ctx := validate.WithOperationRequest(r.Context())
-			if err := body.ContextValidate(ctx, route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			if len(res) == 0 {
-				o.Body = &body
-			}
-		}
-	} else {
-		res = append(res, errors.Required("body", "body", ""))
-	}
-
-	rName, rhkName, _ := route.Params.GetOK("name")
-	if err := o.bindName(rName, rhkName, route.Formats); err != nil {
-		res = append(res, err)
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-// bindName binds and validates parameter Name from path.
-func (o *BucketSetPolicyParams) bindName(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.Name = raw
-
-	return nil
-}

api/operations/bucket/bucket_set_policy_responses.go

@@ -1,135 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// BucketSetPolicyOKCode is the HTTP code returned for type BucketSetPolicyOK
-const BucketSetPolicyOKCode int = 200
-
-/*
-BucketSetPolicyOK A successful response.
-
-swagger:response bucketSetPolicyOK
-*/
-type BucketSetPolicyOK struct {
-
-	/*
-	  In: Body
-	*/
-	Payload *models.Bucket `json:"body,omitempty"`
-}
-
-// NewBucketSetPolicyOK creates BucketSetPolicyOK with default headers values
-func NewBucketSetPolicyOK() *BucketSetPolicyOK {
-
-	return &BucketSetPolicyOK{}
-}
-
-// WithPayload adds the payload to the bucket set policy o k response
-func (o *BucketSetPolicyOK) WithPayload(payload *models.Bucket) *BucketSetPolicyOK {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the bucket set policy o k response
-func (o *BucketSetPolicyOK) SetPayload(payload *models.Bucket) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *BucketSetPolicyOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(200)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}
-
-/*
-BucketSetPolicyDefault Generic error response.
-
-swagger:response bucketSetPolicyDefault
-*/
-type BucketSetPolicyDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewBucketSetPolicyDefault creates BucketSetPolicyDefault with default headers values
-func NewBucketSetPolicyDefault(code int) *BucketSetPolicyDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &BucketSetPolicyDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the bucket set policy default response
-func (o *BucketSetPolicyDefault) WithStatusCode(code int) *BucketSetPolicyDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the bucket set policy default response
-func (o *BucketSetPolicyDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the bucket set policy default response
-func (o *BucketSetPolicyDefault) WithPayload(payload *models.APIError) *BucketSetPolicyDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the bucket set policy default response
-func (o *BucketSetPolicyDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *BucketSetPolicyDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/bucket/bucket_set_policy_urlbuilder.go

@@ -1,116 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-	"strings"
-)
-
-// BucketSetPolicyURL generates an URL for the bucket set policy operation
-type BucketSetPolicyURL struct {
-	Name string
-
-	_basePath string
-	// avoid unkeyed usage
-	_ struct{}
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *BucketSetPolicyURL) WithBasePath(bp string) *BucketSetPolicyURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *BucketSetPolicyURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *BucketSetPolicyURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/buckets/{name}/set-policy"
-
-	name := o.Name
-	if name != "" {
-		_path = strings.Replace(_path, "{name}", name, -1)
-	} else {
-		return nil, errors.New("name is required on BucketSetPolicyURL")
-	}
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *BucketSetPolicyURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *BucketSetPolicyURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *BucketSetPolicyURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on BucketSetPolicyURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on BucketSetPolicyURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *BucketSetPolicyURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/bucket/create_bucket_event.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// CreateBucketEventHandlerFunc turns a function with the right signature into a create bucket event handler
-type CreateBucketEventHandlerFunc func(CreateBucketEventParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn CreateBucketEventHandlerFunc) Handle(params CreateBucketEventParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// CreateBucketEventHandler interface for that can handle valid create bucket event params
-type CreateBucketEventHandler interface {
-	Handle(CreateBucketEventParams, *models.Principal) middleware.Responder
-}
-
-// NewCreateBucketEvent creates a new http.Handler for the create bucket event operation
-func NewCreateBucketEvent(ctx *middleware.Context, handler CreateBucketEventHandler) *CreateBucketEvent {
-	return &CreateBucketEvent{Context: ctx, Handler: handler}
-}
-
-/*
-	CreateBucketEvent swagger:route POST /buckets/{bucket_name}/events Bucket createBucketEvent
-
-Create Bucket Event
-*/
-type CreateBucketEvent struct {
-	Context *middleware.Context
-	Handler CreateBucketEventHandler
-}
-
-func (o *CreateBucketEvent) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewCreateBucketEventParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/bucket/create_bucket_event_parameters.go

@@ -1,126 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"io"
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/validate"
-
-	"github.com/minio/console/models"
-)
-
-// NewCreateBucketEventParams creates a new CreateBucketEventParams object
-//
-// There are no default values defined in the spec.
-func NewCreateBucketEventParams() CreateBucketEventParams {
-
-	return CreateBucketEventParams{}
-}
-
-// CreateBucketEventParams contains all the bound params for the create bucket event operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters CreateBucketEvent
-type CreateBucketEventParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: body
-	*/
-	Body *models.BucketEventRequest
-	/*
-	  Required: true
-	  In: path
-	*/
-	BucketName string
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewCreateBucketEventParams() beforehand.
-func (o *CreateBucketEventParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	if runtime.HasBody(r) {
-		defer r.Body.Close()
-		var body models.BucketEventRequest
-		if err := route.Consumer.Consume(r.Body, &body); err != nil {
-			if err == io.EOF {
-				res = append(res, errors.Required("body", "body", ""))
-			} else {
-				res = append(res, errors.NewParseError("body", "body", "", err))
-			}
-		} else {
-			// validate body object
-			if err := body.Validate(route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			ctx := validate.WithOperationRequest(r.Context())
-			if err := body.ContextValidate(ctx, route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			if len(res) == 0 {
-				o.Body = &body
-			}
-		}
-	} else {
-		res = append(res, errors.Required("body", "body", ""))
-	}
-
-	rBucketName, rhkBucketName, _ := route.Params.GetOK("bucket_name")
-	if err := o.bindBucketName(rBucketName, rhkBucketName, route.Formats); err != nil {
-		res = append(res, err)
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-// bindBucketName binds and validates parameter BucketName from path.
-func (o *CreateBucketEventParams) bindBucketName(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.BucketName = raw
-
-	return nil
-}

api/operations/bucket/create_bucket_event_responses.go

@@ -1,115 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// CreateBucketEventCreatedCode is the HTTP code returned for type CreateBucketEventCreated
-const CreateBucketEventCreatedCode int = 201
-
-/*
-CreateBucketEventCreated A successful response.
-
-swagger:response createBucketEventCreated
-*/
-type CreateBucketEventCreated struct {
-}
-
-// NewCreateBucketEventCreated creates CreateBucketEventCreated with default headers values
-func NewCreateBucketEventCreated() *CreateBucketEventCreated {
-
-	return &CreateBucketEventCreated{}
-}
-
-// WriteResponse to the client
-func (o *CreateBucketEventCreated) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
-
-	rw.WriteHeader(201)
-}
-
-/*
-CreateBucketEventDefault Generic error response.
-
-swagger:response createBucketEventDefault
-*/
-type CreateBucketEventDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewCreateBucketEventDefault creates CreateBucketEventDefault with default headers values
-func NewCreateBucketEventDefault(code int) *CreateBucketEventDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &CreateBucketEventDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the create bucket event default response
-func (o *CreateBucketEventDefault) WithStatusCode(code int) *CreateBucketEventDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the create bucket event default response
-func (o *CreateBucketEventDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the create bucket event default response
-func (o *CreateBucketEventDefault) WithPayload(payload *models.APIError) *CreateBucketEventDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the create bucket event default response
-func (o *CreateBucketEventDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *CreateBucketEventDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/bucket/create_bucket_event_urlbuilder.go

@@ -1,116 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-	"strings"
-)
-
-// CreateBucketEventURL generates an URL for the create bucket event operation
-type CreateBucketEventURL struct {
-	BucketName string
-
-	_basePath string
-	// avoid unkeyed usage
-	_ struct{}
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *CreateBucketEventURL) WithBasePath(bp string) *CreateBucketEventURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *CreateBucketEventURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *CreateBucketEventURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/buckets/{bucket_name}/events"
-
-	bucketName := o.BucketName
-	if bucketName != "" {
-		_path = strings.Replace(_path, "{bucket_name}", bucketName, -1)
-	} else {
-		return nil, errors.New("bucketName is required on CreateBucketEventURL")
-	}
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *CreateBucketEventURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *CreateBucketEventURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *CreateBucketEventURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on CreateBucketEventURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on CreateBucketEventURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *CreateBucketEventURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/bucket/delete_access_rule_with_bucket.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteAccessRuleWithBucketHandlerFunc turns a function with the right signature into a delete access rule with bucket handler
-type DeleteAccessRuleWithBucketHandlerFunc func(DeleteAccessRuleWithBucketParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn DeleteAccessRuleWithBucketHandlerFunc) Handle(params DeleteAccessRuleWithBucketParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// DeleteAccessRuleWithBucketHandler interface for that can handle valid delete access rule with bucket params
-type DeleteAccessRuleWithBucketHandler interface {
-	Handle(DeleteAccessRuleWithBucketParams, *models.Principal) middleware.Responder
-}
-
-// NewDeleteAccessRuleWithBucket creates a new http.Handler for the delete access rule with bucket operation
-func NewDeleteAccessRuleWithBucket(ctx *middleware.Context, handler DeleteAccessRuleWithBucketHandler) *DeleteAccessRuleWithBucket {
-	return &DeleteAccessRuleWithBucket{Context: ctx, Handler: handler}
-}
-
-/*
-	DeleteAccessRuleWithBucket swagger:route DELETE /bucket/{bucket}/access-rules Bucket deleteAccessRuleWithBucket
-
-Delete Access Rule From Given Bucket
-*/
-type DeleteAccessRuleWithBucket struct {
-	Context *middleware.Context
-	Handler DeleteAccessRuleWithBucketHandler
-}
-
-func (o *DeleteAccessRuleWithBucket) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewDeleteAccessRuleWithBucketParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/bucket/delete_access_rule_with_bucket_parameters.go

@@ -1,126 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"io"
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/validate"
-
-	"github.com/minio/console/models"
-)
-
-// NewDeleteAccessRuleWithBucketParams creates a new DeleteAccessRuleWithBucketParams object
-//
-// There are no default values defined in the spec.
-func NewDeleteAccessRuleWithBucketParams() DeleteAccessRuleWithBucketParams {
-
-	return DeleteAccessRuleWithBucketParams{}
-}
-
-// DeleteAccessRuleWithBucketParams contains all the bound params for the delete access rule with bucket operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters DeleteAccessRuleWithBucket
-type DeleteAccessRuleWithBucketParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: path
-	*/
-	Bucket string
-	/*
-	  Required: true
-	  In: body
-	*/
-	Prefix *models.PrefixWrapper
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewDeleteAccessRuleWithBucketParams() beforehand.
-func (o *DeleteAccessRuleWithBucketParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	rBucket, rhkBucket, _ := route.Params.GetOK("bucket")
-	if err := o.bindBucket(rBucket, rhkBucket, route.Formats); err != nil {
-		res = append(res, err)
-	}
-
-	if runtime.HasBody(r) {
-		defer r.Body.Close()
-		var body models.PrefixWrapper
-		if err := route.Consumer.Consume(r.Body, &body); err != nil {
-			if err == io.EOF {
-				res = append(res, errors.Required("prefix", "body", ""))
-			} else {
-				res = append(res, errors.NewParseError("prefix", "body", "", err))
-			}
-		} else {
-			// validate body object
-			if err := body.Validate(route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			ctx := validate.WithOperationRequest(r.Context())
-			if err := body.ContextValidate(ctx, route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			if len(res) == 0 {
-				o.Prefix = &body
-			}
-		}
-	} else {
-		res = append(res, errors.Required("prefix", "body", ""))
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-// bindBucket binds and validates parameter Bucket from path.
-func (o *DeleteAccessRuleWithBucketParams) bindBucket(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.Bucket = raw
-
-	return nil
-}

api/operations/bucket/delete_access_rule_with_bucket_responses.go

@@ -1,133 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteAccessRuleWithBucketOKCode is the HTTP code returned for type DeleteAccessRuleWithBucketOK
-const DeleteAccessRuleWithBucketOKCode int = 200
-
-/*
-DeleteAccessRuleWithBucketOK A successful response.
-
-swagger:response deleteAccessRuleWithBucketOK
-*/
-type DeleteAccessRuleWithBucketOK struct {
-
-	/*
-	  In: Body
-	*/
-	Payload bool `json:"body,omitempty"`
-}
-
-// NewDeleteAccessRuleWithBucketOK creates DeleteAccessRuleWithBucketOK with default headers values
-func NewDeleteAccessRuleWithBucketOK() *DeleteAccessRuleWithBucketOK {
-
-	return &DeleteAccessRuleWithBucketOK{}
-}
-
-// WithPayload adds the payload to the delete access rule with bucket o k response
-func (o *DeleteAccessRuleWithBucketOK) WithPayload(payload bool) *DeleteAccessRuleWithBucketOK {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the delete access rule with bucket o k response
-func (o *DeleteAccessRuleWithBucketOK) SetPayload(payload bool) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *DeleteAccessRuleWithBucketOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(200)
-	payload := o.Payload
-	if err := producer.Produce(rw, payload); err != nil {
-		panic(err) // let the recovery middleware deal with this
-	}
-}
-
-/*
-DeleteAccessRuleWithBucketDefault Generic error response.
-
-swagger:response deleteAccessRuleWithBucketDefault
-*/
-type DeleteAccessRuleWithBucketDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewDeleteAccessRuleWithBucketDefault creates DeleteAccessRuleWithBucketDefault with default headers values
-func NewDeleteAccessRuleWithBucketDefault(code int) *DeleteAccessRuleWithBucketDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &DeleteAccessRuleWithBucketDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the delete access rule with bucket default response
-func (o *DeleteAccessRuleWithBucketDefault) WithStatusCode(code int) *DeleteAccessRuleWithBucketDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the delete access rule with bucket default response
-func (o *DeleteAccessRuleWithBucketDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the delete access rule with bucket default response
-func (o *DeleteAccessRuleWithBucketDefault) WithPayload(payload *models.APIError) *DeleteAccessRuleWithBucketDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the delete access rule with bucket default response
-func (o *DeleteAccessRuleWithBucketDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *DeleteAccessRuleWithBucketDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/bucket/delete_access_rule_with_bucket_urlbuilder.go

@@ -1,116 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-	"strings"
-)
-
-// DeleteAccessRuleWithBucketURL generates an URL for the delete access rule with bucket operation
-type DeleteAccessRuleWithBucketURL struct {
-	Bucket string
-
-	_basePath string
-	// avoid unkeyed usage
-	_ struct{}
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteAccessRuleWithBucketURL) WithBasePath(bp string) *DeleteAccessRuleWithBucketURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteAccessRuleWithBucketURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *DeleteAccessRuleWithBucketURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/bucket/{bucket}/access-rules"
-
-	bucket := o.Bucket
-	if bucket != "" {
-		_path = strings.Replace(_path, "{bucket}", bucket, -1)
-	} else {
-		return nil, errors.New("bucket is required on DeleteAccessRuleWithBucketURL")
-	}
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *DeleteAccessRuleWithBucketURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *DeleteAccessRuleWithBucketURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *DeleteAccessRuleWithBucketURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on DeleteAccessRuleWithBucketURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on DeleteAccessRuleWithBucketURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *DeleteAccessRuleWithBucketURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/bucket/delete_all_replication_rules.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteAllReplicationRulesHandlerFunc turns a function with the right signature into a delete all replication rules handler
-type DeleteAllReplicationRulesHandlerFunc func(DeleteAllReplicationRulesParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn DeleteAllReplicationRulesHandlerFunc) Handle(params DeleteAllReplicationRulesParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// DeleteAllReplicationRulesHandler interface for that can handle valid delete all replication rules params
-type DeleteAllReplicationRulesHandler interface {
-	Handle(DeleteAllReplicationRulesParams, *models.Principal) middleware.Responder
-}
-
-// NewDeleteAllReplicationRules creates a new http.Handler for the delete all replication rules operation
-func NewDeleteAllReplicationRules(ctx *middleware.Context, handler DeleteAllReplicationRulesHandler) *DeleteAllReplicationRules {
-	return &DeleteAllReplicationRules{Context: ctx, Handler: handler}
-}
-
-/*
-	DeleteAllReplicationRules swagger:route DELETE /buckets/{bucket_name}/delete-all-replication-rules Bucket deleteAllReplicationRules
-
-Deletes all replication rules from a bucket
-*/
-type DeleteAllReplicationRules struct {
-	Context *middleware.Context
-	Handler DeleteAllReplicationRulesHandler
-}
-
-func (o *DeleteAllReplicationRules) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewDeleteAllReplicationRulesParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/bucket/delete_all_replication_rules_parameters.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/strfmt"
-)
-
-// NewDeleteAllReplicationRulesParams creates a new DeleteAllReplicationRulesParams object
-//
-// There are no default values defined in the spec.
-func NewDeleteAllReplicationRulesParams() DeleteAllReplicationRulesParams {
-
-	return DeleteAllReplicationRulesParams{}
-}
-
-// DeleteAllReplicationRulesParams contains all the bound params for the delete all replication rules operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters DeleteAllReplicationRules
-type DeleteAllReplicationRulesParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: path
-	*/
-	BucketName string
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewDeleteAllReplicationRulesParams() beforehand.
-func (o *DeleteAllReplicationRulesParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	rBucketName, rhkBucketName, _ := route.Params.GetOK("bucket_name")
-	if err := o.bindBucketName(rBucketName, rhkBucketName, route.Formats); err != nil {
-		res = append(res, err)
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-// bindBucketName binds and validates parameter BucketName from path.
-func (o *DeleteAllReplicationRulesParams) bindBucketName(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.BucketName = raw
-
-	return nil
-}

api/operations/bucket/delete_all_replication_rules_responses.go

@@ -1,115 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteAllReplicationRulesNoContentCode is the HTTP code returned for type DeleteAllReplicationRulesNoContent
-const DeleteAllReplicationRulesNoContentCode int = 204
-
-/*
-DeleteAllReplicationRulesNoContent A successful response.
-
-swagger:response deleteAllReplicationRulesNoContent
-*/
-type DeleteAllReplicationRulesNoContent struct {
-}
-
-// NewDeleteAllReplicationRulesNoContent creates DeleteAllReplicationRulesNoContent with default headers values
-func NewDeleteAllReplicationRulesNoContent() *DeleteAllReplicationRulesNoContent {
-
-	return &DeleteAllReplicationRulesNoContent{}
-}
-
-// WriteResponse to the client
-func (o *DeleteAllReplicationRulesNoContent) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
-
-	rw.WriteHeader(204)
-}
-
-/*
-DeleteAllReplicationRulesDefault Generic error response.
-
-swagger:response deleteAllReplicationRulesDefault
-*/
-type DeleteAllReplicationRulesDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewDeleteAllReplicationRulesDefault creates DeleteAllReplicationRulesDefault with default headers values
-func NewDeleteAllReplicationRulesDefault(code int) *DeleteAllReplicationRulesDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &DeleteAllReplicationRulesDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the delete all replication rules default response
-func (o *DeleteAllReplicationRulesDefault) WithStatusCode(code int) *DeleteAllReplicationRulesDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the delete all replication rules default response
-func (o *DeleteAllReplicationRulesDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the delete all replication rules default response
-func (o *DeleteAllReplicationRulesDefault) WithPayload(payload *models.APIError) *DeleteAllReplicationRulesDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the delete all replication rules default response
-func (o *DeleteAllReplicationRulesDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *DeleteAllReplicationRulesDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/bucket/delete_all_replication_rules_urlbuilder.go

@@ -1,116 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-	"strings"
-)
-
-// DeleteAllReplicationRulesURL generates an URL for the delete all replication rules operation
-type DeleteAllReplicationRulesURL struct {
-	BucketName string
-
-	_basePath string
-	// avoid unkeyed usage
-	_ struct{}
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteAllReplicationRulesURL) WithBasePath(bp string) *DeleteAllReplicationRulesURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteAllReplicationRulesURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *DeleteAllReplicationRulesURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/buckets/{bucket_name}/delete-all-replication-rules"
-
-	bucketName := o.BucketName
-	if bucketName != "" {
-		_path = strings.Replace(_path, "{bucket_name}", bucketName, -1)
-	} else {
-		return nil, errors.New("bucketName is required on DeleteAllReplicationRulesURL")
-	}
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *DeleteAllReplicationRulesURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *DeleteAllReplicationRulesURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *DeleteAllReplicationRulesURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on DeleteAllReplicationRulesURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on DeleteAllReplicationRulesURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *DeleteAllReplicationRulesURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/bucket/delete_bucket.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteBucketHandlerFunc turns a function with the right signature into a delete bucket handler
-type DeleteBucketHandlerFunc func(DeleteBucketParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn DeleteBucketHandlerFunc) Handle(params DeleteBucketParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// DeleteBucketHandler interface for that can handle valid delete bucket params
-type DeleteBucketHandler interface {
-	Handle(DeleteBucketParams, *models.Principal) middleware.Responder
-}
-
-// NewDeleteBucket creates a new http.Handler for the delete bucket operation
-func NewDeleteBucket(ctx *middleware.Context, handler DeleteBucketHandler) *DeleteBucket {
-	return &DeleteBucket{Context: ctx, Handler: handler}
-}
-
-/*
-	DeleteBucket swagger:route DELETE /buckets/{name} Bucket deleteBucket
-
-Delete Bucket
-*/
-type DeleteBucket struct {
-	Context *middleware.Context
-	Handler DeleteBucketHandler
-}
-
-func (o *DeleteBucket) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewDeleteBucketParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/bucket/delete_bucket_event.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteBucketEventHandlerFunc turns a function with the right signature into a delete bucket event handler
-type DeleteBucketEventHandlerFunc func(DeleteBucketEventParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn DeleteBucketEventHandlerFunc) Handle(params DeleteBucketEventParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// DeleteBucketEventHandler interface for that can handle valid delete bucket event params
-type DeleteBucketEventHandler interface {
-	Handle(DeleteBucketEventParams, *models.Principal) middleware.Responder
-}
-
-// NewDeleteBucketEvent creates a new http.Handler for the delete bucket event operation
-func NewDeleteBucketEvent(ctx *middleware.Context, handler DeleteBucketEventHandler) *DeleteBucketEvent {
-	return &DeleteBucketEvent{Context: ctx, Handler: handler}
-}
-
-/*
-	DeleteBucketEvent swagger:route DELETE /buckets/{bucket_name}/events/{arn} Bucket deleteBucketEvent
-
-Delete Bucket Event
-*/
-type DeleteBucketEvent struct {
-	Context *middleware.Context
-	Handler DeleteBucketEventHandler
-}
-
-func (o *DeleteBucketEvent) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewDeleteBucketEventParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/bucket/delete_bucket_event_parameters.go

@@ -1,150 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"io"
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/validate"
-
-	"github.com/minio/console/models"
-)
-
-// NewDeleteBucketEventParams creates a new DeleteBucketEventParams object
-//
-// There are no default values defined in the spec.
-func NewDeleteBucketEventParams() DeleteBucketEventParams {
-
-	return DeleteBucketEventParams{}
-}
-
-// DeleteBucketEventParams contains all the bound params for the delete bucket event operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters DeleteBucketEvent
-type DeleteBucketEventParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: path
-	*/
-	Arn string
-	/*
-	  Required: true
-	  In: body
-	*/
-	Body *models.NotificationDeleteRequest
-	/*
-	  Required: true
-	  In: path
-	*/
-	BucketName string
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewDeleteBucketEventParams() beforehand.
-func (o *DeleteBucketEventParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	rArn, rhkArn, _ := route.Params.GetOK("arn")
-	if err := o.bindArn(rArn, rhkArn, route.Formats); err != nil {
-		res = append(res, err)
-	}
-
-	if runtime.HasBody(r) {
-		defer r.Body.Close()
-		var body models.NotificationDeleteRequest
-		if err := route.Consumer.Consume(r.Body, &body); err != nil {
-			if err == io.EOF {
-				res = append(res, errors.Required("body", "body", ""))
-			} else {
-				res = append(res, errors.NewParseError("body", "body", "", err))
-			}
-		} else {
-			// validate body object
-			if err := body.Validate(route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			ctx := validate.WithOperationRequest(r.Context())
-			if err := body.ContextValidate(ctx, route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			if len(res) == 0 {
-				o.Body = &body
-			}
-		}
-	} else {
-		res = append(res, errors.Required("body", "body", ""))
-	}
-
-	rBucketName, rhkBucketName, _ := route.Params.GetOK("bucket_name")
-	if err := o.bindBucketName(rBucketName, rhkBucketName, route.Formats); err != nil {
-		res = append(res, err)
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-// bindArn binds and validates parameter Arn from path.
-func (o *DeleteBucketEventParams) bindArn(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.Arn = raw
-
-	return nil
-}
-
-// bindBucketName binds and validates parameter BucketName from path.
-func (o *DeleteBucketEventParams) bindBucketName(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.BucketName = raw
-
-	return nil
-}

api/operations/bucket/delete_bucket_event_responses.go

@@ -1,115 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteBucketEventNoContentCode is the HTTP code returned for type DeleteBucketEventNoContent
-const DeleteBucketEventNoContentCode int = 204
-
-/*
-DeleteBucketEventNoContent A successful response.
-
-swagger:response deleteBucketEventNoContent
-*/
-type DeleteBucketEventNoContent struct {
-}
-
-// NewDeleteBucketEventNoContent creates DeleteBucketEventNoContent with default headers values
-func NewDeleteBucketEventNoContent() *DeleteBucketEventNoContent {
-
-	return &DeleteBucketEventNoContent{}
-}
-
-// WriteResponse to the client
-func (o *DeleteBucketEventNoContent) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
-
-	rw.WriteHeader(204)
-}
-
-/*
-DeleteBucketEventDefault Generic error response.
-
-swagger:response deleteBucketEventDefault
-*/
-type DeleteBucketEventDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewDeleteBucketEventDefault creates DeleteBucketEventDefault with default headers values
-func NewDeleteBucketEventDefault(code int) *DeleteBucketEventDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &DeleteBucketEventDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the delete bucket event default response
-func (o *DeleteBucketEventDefault) WithStatusCode(code int) *DeleteBucketEventDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the delete bucket event default response
-func (o *DeleteBucketEventDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the delete bucket event default response
-func (o *DeleteBucketEventDefault) WithPayload(payload *models.APIError) *DeleteBucketEventDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the delete bucket event default response
-func (o *DeleteBucketEventDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *DeleteBucketEventDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/bucket/delete_bucket_event_urlbuilder.go

@@ -1,124 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-	"strings"
-)
-
-// DeleteBucketEventURL generates an URL for the delete bucket event operation
-type DeleteBucketEventURL struct {
-	Arn        string
-	BucketName string
-
-	_basePath string
-	// avoid unkeyed usage
-	_ struct{}
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteBucketEventURL) WithBasePath(bp string) *DeleteBucketEventURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteBucketEventURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *DeleteBucketEventURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/buckets/{bucket_name}/events/{arn}"
-
-	arn := o.Arn
-	if arn != "" {
-		_path = strings.Replace(_path, "{arn}", arn, -1)
-	} else {
-		return nil, errors.New("arn is required on DeleteBucketEventURL")
-	}
-
-	bucketName := o.BucketName
-	if bucketName != "" {
-		_path = strings.Replace(_path, "{bucket_name}", bucketName, -1)
-	} else {
-		return nil, errors.New("bucketName is required on DeleteBucketEventURL")
-	}
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *DeleteBucketEventURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *DeleteBucketEventURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *DeleteBucketEventURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on DeleteBucketEventURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on DeleteBucketEventURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *DeleteBucketEventURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/bucket/delete_bucket_parameters.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/strfmt"
-)
-
-// NewDeleteBucketParams creates a new DeleteBucketParams object
-//
-// There are no default values defined in the spec.
-func NewDeleteBucketParams() DeleteBucketParams {
-
-	return DeleteBucketParams{}
-}
-
-// DeleteBucketParams contains all the bound params for the delete bucket operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters DeleteBucket
-type DeleteBucketParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: path
-	*/
-	Name string
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewDeleteBucketParams() beforehand.
-func (o *DeleteBucketParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	rName, rhkName, _ := route.Params.GetOK("name")
-	if err := o.bindName(rName, rhkName, route.Formats); err != nil {
-		res = append(res, err)
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-// bindName binds and validates parameter Name from path.
-func (o *DeleteBucketParams) bindName(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.Name = raw
-
-	return nil
-}

api/operations/bucket/delete_bucket_replication_rule.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteBucketReplicationRuleHandlerFunc turns a function with the right signature into a delete bucket replication rule handler
-type DeleteBucketReplicationRuleHandlerFunc func(DeleteBucketReplicationRuleParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn DeleteBucketReplicationRuleHandlerFunc) Handle(params DeleteBucketReplicationRuleParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// DeleteBucketReplicationRuleHandler interface for that can handle valid delete bucket replication rule params
-type DeleteBucketReplicationRuleHandler interface {
-	Handle(DeleteBucketReplicationRuleParams, *models.Principal) middleware.Responder
-}
-
-// NewDeleteBucketReplicationRule creates a new http.Handler for the delete bucket replication rule operation
-func NewDeleteBucketReplicationRule(ctx *middleware.Context, handler DeleteBucketReplicationRuleHandler) *DeleteBucketReplicationRule {
-	return &DeleteBucketReplicationRule{Context: ctx, Handler: handler}
-}
-
-/*
-	DeleteBucketReplicationRule swagger:route DELETE /buckets/{bucket_name}/replication/{rule_id} Bucket deleteBucketReplicationRule
-
-Bucket Replication Rule Delete
-*/
-type DeleteBucketReplicationRule struct {
-	Context *middleware.Context
-	Handler DeleteBucketReplicationRuleHandler
-}
-
-func (o *DeleteBucketReplicationRule) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewDeleteBucketReplicationRuleParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/bucket/delete_bucket_replication_rule_parameters.go

@@ -1,112 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/strfmt"
-)
-
-// NewDeleteBucketReplicationRuleParams creates a new DeleteBucketReplicationRuleParams object
-//
-// There are no default values defined in the spec.
-func NewDeleteBucketReplicationRuleParams() DeleteBucketReplicationRuleParams {
-
-	return DeleteBucketReplicationRuleParams{}
-}
-
-// DeleteBucketReplicationRuleParams contains all the bound params for the delete bucket replication rule operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters DeleteBucketReplicationRule
-type DeleteBucketReplicationRuleParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: path
-	*/
-	BucketName string
-	/*
-	  Required: true
-	  In: path
-	*/
-	RuleID string
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewDeleteBucketReplicationRuleParams() beforehand.
-func (o *DeleteBucketReplicationRuleParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	rBucketName, rhkBucketName, _ := route.Params.GetOK("bucket_name")
-	if err := o.bindBucketName(rBucketName, rhkBucketName, route.Formats); err != nil {
-		res = append(res, err)
-	}
-
-	rRuleID, rhkRuleID, _ := route.Params.GetOK("rule_id")
-	if err := o.bindRuleID(rRuleID, rhkRuleID, route.Formats); err != nil {
-		res = append(res, err)
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-// bindBucketName binds and validates parameter BucketName from path.
-func (o *DeleteBucketReplicationRuleParams) bindBucketName(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.BucketName = raw
-
-	return nil
-}
-
-// bindRuleID binds and validates parameter RuleID from path.
-func (o *DeleteBucketReplicationRuleParams) bindRuleID(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.RuleID = raw
-
-	return nil
-}

api/operations/bucket/delete_bucket_replication_rule_responses.go

@@ -1,115 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteBucketReplicationRuleNoContentCode is the HTTP code returned for type DeleteBucketReplicationRuleNoContent
-const DeleteBucketReplicationRuleNoContentCode int = 204
-
-/*
-DeleteBucketReplicationRuleNoContent A successful response.
-
-swagger:response deleteBucketReplicationRuleNoContent
-*/
-type DeleteBucketReplicationRuleNoContent struct {
-}
-
-// NewDeleteBucketReplicationRuleNoContent creates DeleteBucketReplicationRuleNoContent with default headers values
-func NewDeleteBucketReplicationRuleNoContent() *DeleteBucketReplicationRuleNoContent {
-
-	return &DeleteBucketReplicationRuleNoContent{}
-}
-
-// WriteResponse to the client
-func (o *DeleteBucketReplicationRuleNoContent) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
-
-	rw.WriteHeader(204)
-}
-
-/*
-DeleteBucketReplicationRuleDefault Generic error response.
-
-swagger:response deleteBucketReplicationRuleDefault
-*/
-type DeleteBucketReplicationRuleDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewDeleteBucketReplicationRuleDefault creates DeleteBucketReplicationRuleDefault with default headers values
-func NewDeleteBucketReplicationRuleDefault(code int) *DeleteBucketReplicationRuleDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &DeleteBucketReplicationRuleDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the delete bucket replication rule default response
-func (o *DeleteBucketReplicationRuleDefault) WithStatusCode(code int) *DeleteBucketReplicationRuleDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the delete bucket replication rule default response
-func (o *DeleteBucketReplicationRuleDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the delete bucket replication rule default response
-func (o *DeleteBucketReplicationRuleDefault) WithPayload(payload *models.APIError) *DeleteBucketReplicationRuleDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the delete bucket replication rule default response
-func (o *DeleteBucketReplicationRuleDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *DeleteBucketReplicationRuleDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/bucket/delete_bucket_replication_rule_urlbuilder.go

@@ -1,124 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-	"strings"
-)
-
-// DeleteBucketReplicationRuleURL generates an URL for the delete bucket replication rule operation
-type DeleteBucketReplicationRuleURL struct {
-	BucketName string
-	RuleID     string
-
-	_basePath string
-	// avoid unkeyed usage
-	_ struct{}
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteBucketReplicationRuleURL) WithBasePath(bp string) *DeleteBucketReplicationRuleURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteBucketReplicationRuleURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *DeleteBucketReplicationRuleURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/buckets/{bucket_name}/replication/{rule_id}"
-
-	bucketName := o.BucketName
-	if bucketName != "" {
-		_path = strings.Replace(_path, "{bucket_name}", bucketName, -1)
-	} else {
-		return nil, errors.New("bucketName is required on DeleteBucketReplicationRuleURL")
-	}
-
-	ruleID := o.RuleID
-	if ruleID != "" {
-		_path = strings.Replace(_path, "{rule_id}", ruleID, -1)
-	} else {
-		return nil, errors.New("ruleId is required on DeleteBucketReplicationRuleURL")
-	}
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *DeleteBucketReplicationRuleURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *DeleteBucketReplicationRuleURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *DeleteBucketReplicationRuleURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on DeleteBucketReplicationRuleURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on DeleteBucketReplicationRuleURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *DeleteBucketReplicationRuleURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/bucket/delete_bucket_responses.go

@@ -1,115 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteBucketNoContentCode is the HTTP code returned for type DeleteBucketNoContent
-const DeleteBucketNoContentCode int = 204
-
-/*
-DeleteBucketNoContent A successful response.
-
-swagger:response deleteBucketNoContent
-*/
-type DeleteBucketNoContent struct {
-}
-
-// NewDeleteBucketNoContent creates DeleteBucketNoContent with default headers values
-func NewDeleteBucketNoContent() *DeleteBucketNoContent {
-
-	return &DeleteBucketNoContent{}
-}
-
-// WriteResponse to the client
-func (o *DeleteBucketNoContent) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
-
-	rw.WriteHeader(204)
-}
-
-/*
-DeleteBucketDefault Generic error response.
-
-swagger:response deleteBucketDefault
-*/
-type DeleteBucketDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewDeleteBucketDefault creates DeleteBucketDefault with default headers values
-func NewDeleteBucketDefault(code int) *DeleteBucketDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &DeleteBucketDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the delete bucket default response
-func (o *DeleteBucketDefault) WithStatusCode(code int) *DeleteBucketDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the delete bucket default response
-func (o *DeleteBucketDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the delete bucket default response
-func (o *DeleteBucketDefault) WithPayload(payload *models.APIError) *DeleteBucketDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the delete bucket default response
-func (o *DeleteBucketDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *DeleteBucketDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/bucket/delete_bucket_urlbuilder.go

@@ -1,116 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-	"strings"
-)
-
-// DeleteBucketURL generates an URL for the delete bucket operation
-type DeleteBucketURL struct {
-	Name string
-
-	_basePath string
-	// avoid unkeyed usage
-	_ struct{}
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteBucketURL) WithBasePath(bp string) *DeleteBucketURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteBucketURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *DeleteBucketURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/buckets/{name}"
-
-	name := o.Name
-	if name != "" {
-		_path = strings.Replace(_path, "{name}", name, -1)
-	} else {
-		return nil, errors.New("name is required on DeleteBucketURL")
-	}
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *DeleteBucketURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *DeleteBucketURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *DeleteBucketURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on DeleteBucketURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on DeleteBucketURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *DeleteBucketURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/bucket/delete_remote_bucket.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteRemoteBucketHandlerFunc turns a function with the right signature into a delete remote bucket handler
-type DeleteRemoteBucketHandlerFunc func(DeleteRemoteBucketParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn DeleteRemoteBucketHandlerFunc) Handle(params DeleteRemoteBucketParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// DeleteRemoteBucketHandler interface for that can handle valid delete remote bucket params
-type DeleteRemoteBucketHandler interface {
-	Handle(DeleteRemoteBucketParams, *models.Principal) middleware.Responder
-}
-
-// NewDeleteRemoteBucket creates a new http.Handler for the delete remote bucket operation
-func NewDeleteRemoteBucket(ctx *middleware.Context, handler DeleteRemoteBucketHandler) *DeleteRemoteBucket {
-	return &DeleteRemoteBucket{Context: ctx, Handler: handler}
-}
-
-/*
-	DeleteRemoteBucket swagger:route DELETE /remote-buckets/{source-bucket-name}/{arn} Bucket deleteRemoteBucket
-
-Delete Remote Bucket
-*/
-type DeleteRemoteBucket struct {
-	Context *middleware.Context
-	Handler DeleteRemoteBucketHandler
-}
-
-func (o *DeleteRemoteBucket) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewDeleteRemoteBucketParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/bucket/delete_remote_bucket_parameters.go

@@ -1,112 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/strfmt"
-)
-
-// NewDeleteRemoteBucketParams creates a new DeleteRemoteBucketParams object
-//
-// There are no default values defined in the spec.
-func NewDeleteRemoteBucketParams() DeleteRemoteBucketParams {
-
-	return DeleteRemoteBucketParams{}
-}
-
-// DeleteRemoteBucketParams contains all the bound params for the delete remote bucket operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters DeleteRemoteBucket
-type DeleteRemoteBucketParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: path
-	*/
-	Arn string
-	/*
-	  Required: true
-	  In: path
-	*/
-	SourceBucketName string
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewDeleteRemoteBucketParams() beforehand.
-func (o *DeleteRemoteBucketParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	rArn, rhkArn, _ := route.Params.GetOK("arn")
-	if err := o.bindArn(rArn, rhkArn, route.Formats); err != nil {
-		res = append(res, err)
-	}
-
-	rSourceBucketName, rhkSourceBucketName, _ := route.Params.GetOK("source-bucket-name")
-	if err := o.bindSourceBucketName(rSourceBucketName, rhkSourceBucketName, route.Formats); err != nil {
-		res = append(res, err)
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-// bindArn binds and validates parameter Arn from path.
-func (o *DeleteRemoteBucketParams) bindArn(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.Arn = raw
-
-	return nil
-}
-
-// bindSourceBucketName binds and validates parameter SourceBucketName from path.
-func (o *DeleteRemoteBucketParams) bindSourceBucketName(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.SourceBucketName = raw
-
-	return nil
-}

api/operations/bucket/delete_remote_bucket_responses.go

@@ -1,115 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteRemoteBucketNoContentCode is the HTTP code returned for type DeleteRemoteBucketNoContent
-const DeleteRemoteBucketNoContentCode int = 204
-
-/*
-DeleteRemoteBucketNoContent A successful response.
-
-swagger:response deleteRemoteBucketNoContent
-*/
-type DeleteRemoteBucketNoContent struct {
-}
-
-// NewDeleteRemoteBucketNoContent creates DeleteRemoteBucketNoContent with default headers values
-func NewDeleteRemoteBucketNoContent() *DeleteRemoteBucketNoContent {
-
-	return &DeleteRemoteBucketNoContent{}
-}
-
-// WriteResponse to the client
-func (o *DeleteRemoteBucketNoContent) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
-
-	rw.WriteHeader(204)
-}
-
-/*
-DeleteRemoteBucketDefault Generic error response.
-
-swagger:response deleteRemoteBucketDefault
-*/
-type DeleteRemoteBucketDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewDeleteRemoteBucketDefault creates DeleteRemoteBucketDefault with default headers values
-func NewDeleteRemoteBucketDefault(code int) *DeleteRemoteBucketDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &DeleteRemoteBucketDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the delete remote bucket default response
-func (o *DeleteRemoteBucketDefault) WithStatusCode(code int) *DeleteRemoteBucketDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the delete remote bucket default response
-func (o *DeleteRemoteBucketDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the delete remote bucket default response
-func (o *DeleteRemoteBucketDefault) WithPayload(payload *models.APIError) *DeleteRemoteBucketDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the delete remote bucket default response
-func (o *DeleteRemoteBucketDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *DeleteRemoteBucketDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/bucket/delete_remote_bucket_urlbuilder.go

@@ -1,124 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-	"strings"
-)
-
-// DeleteRemoteBucketURL generates an URL for the delete remote bucket operation
-type DeleteRemoteBucketURL struct {
-	Arn              string
-	SourceBucketName string
-
-	_basePath string
-	// avoid unkeyed usage
-	_ struct{}
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteRemoteBucketURL) WithBasePath(bp string) *DeleteRemoteBucketURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteRemoteBucketURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *DeleteRemoteBucketURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/remote-buckets/{source-bucket-name}/{arn}"
-
-	arn := o.Arn
-	if arn != "" {
-		_path = strings.Replace(_path, "{arn}", arn, -1)
-	} else {
-		return nil, errors.New("arn is required on DeleteRemoteBucketURL")
-	}
-
-	sourceBucketName := o.SourceBucketName
-	if sourceBucketName != "" {
-		_path = strings.Replace(_path, "{source-bucket-name}", sourceBucketName, -1)
-	} else {
-		return nil, errors.New("sourceBucketName is required on DeleteRemoteBucketURL")
-	}
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *DeleteRemoteBucketURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *DeleteRemoteBucketURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *DeleteRemoteBucketURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on DeleteRemoteBucketURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on DeleteRemoteBucketURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *DeleteRemoteBucketURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/bucket/delete_selected_replication_rules.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteSelectedReplicationRulesHandlerFunc turns a function with the right signature into a delete selected replication rules handler
-type DeleteSelectedReplicationRulesHandlerFunc func(DeleteSelectedReplicationRulesParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn DeleteSelectedReplicationRulesHandlerFunc) Handle(params DeleteSelectedReplicationRulesParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// DeleteSelectedReplicationRulesHandler interface for that can handle valid delete selected replication rules params
-type DeleteSelectedReplicationRulesHandler interface {
-	Handle(DeleteSelectedReplicationRulesParams, *models.Principal) middleware.Responder
-}
-
-// NewDeleteSelectedReplicationRules creates a new http.Handler for the delete selected replication rules operation
-func NewDeleteSelectedReplicationRules(ctx *middleware.Context, handler DeleteSelectedReplicationRulesHandler) *DeleteSelectedReplicationRules {
-	return &DeleteSelectedReplicationRules{Context: ctx, Handler: handler}
-}
-
-/*
-	DeleteSelectedReplicationRules swagger:route DELETE /buckets/{bucket_name}/delete-selected-replication-rules Bucket deleteSelectedReplicationRules
-
-Deletes selected replication rules from a bucket
-*/
-type DeleteSelectedReplicationRules struct {
-	Context *middleware.Context
-	Handler DeleteSelectedReplicationRulesHandler
-}
-
-func (o *DeleteSelectedReplicationRules) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewDeleteSelectedReplicationRulesParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/bucket/delete_selected_replication_rules_parameters.go

@@ -1,126 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"io"
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/strfmt"
-	"github.com/go-openapi/validate"
-
-	"github.com/minio/console/models"
-)
-
-// NewDeleteSelectedReplicationRulesParams creates a new DeleteSelectedReplicationRulesParams object
-//
-// There are no default values defined in the spec.
-func NewDeleteSelectedReplicationRulesParams() DeleteSelectedReplicationRulesParams {
-
-	return DeleteSelectedReplicationRulesParams{}
-}
-
-// DeleteSelectedReplicationRulesParams contains all the bound params for the delete selected replication rules operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters DeleteSelectedReplicationRules
-type DeleteSelectedReplicationRulesParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: path
-	*/
-	BucketName string
-	/*
-	  Required: true
-	  In: body
-	*/
-	Rules *models.BucketReplicationRuleList
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewDeleteSelectedReplicationRulesParams() beforehand.
-func (o *DeleteSelectedReplicationRulesParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	rBucketName, rhkBucketName, _ := route.Params.GetOK("bucket_name")
-	if err := o.bindBucketName(rBucketName, rhkBucketName, route.Formats); err != nil {
-		res = append(res, err)
-	}
-
-	if runtime.HasBody(r) {
-		defer r.Body.Close()
-		var body models.BucketReplicationRuleList
-		if err := route.Consumer.Consume(r.Body, &body); err != nil {
-			if err == io.EOF {
-				res = append(res, errors.Required("rules", "body", ""))
-			} else {
-				res = append(res, errors.NewParseError("rules", "body", "", err))
-			}
-		} else {
-			// validate body object
-			if err := body.Validate(route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			ctx := validate.WithOperationRequest(r.Context())
-			if err := body.ContextValidate(ctx, route.Formats); err != nil {
-				res = append(res, err)
-			}
-
-			if len(res) == 0 {
-				o.Rules = &body
-			}
-		}
-	} else {
-		res = append(res, errors.Required("rules", "body", ""))
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-// bindBucketName binds and validates parameter BucketName from path.
-func (o *DeleteSelectedReplicationRulesParams) bindBucketName(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.BucketName = raw
-
-	return nil
-}

api/operations/bucket/delete_selected_replication_rules_responses.go

@@ -1,115 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// DeleteSelectedReplicationRulesNoContentCode is the HTTP code returned for type DeleteSelectedReplicationRulesNoContent
-const DeleteSelectedReplicationRulesNoContentCode int = 204
-
-/*
-DeleteSelectedReplicationRulesNoContent A successful response.
-
-swagger:response deleteSelectedReplicationRulesNoContent
-*/
-type DeleteSelectedReplicationRulesNoContent struct {
-}
-
-// NewDeleteSelectedReplicationRulesNoContent creates DeleteSelectedReplicationRulesNoContent with default headers values
-func NewDeleteSelectedReplicationRulesNoContent() *DeleteSelectedReplicationRulesNoContent {
-
-	return &DeleteSelectedReplicationRulesNoContent{}
-}
-
-// WriteResponse to the client
-func (o *DeleteSelectedReplicationRulesNoContent) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
-
-	rw.WriteHeader(204)
-}
-
-/*
-DeleteSelectedReplicationRulesDefault Generic error response.
-
-swagger:response deleteSelectedReplicationRulesDefault
-*/
-type DeleteSelectedReplicationRulesDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewDeleteSelectedReplicationRulesDefault creates DeleteSelectedReplicationRulesDefault with default headers values
-func NewDeleteSelectedReplicationRulesDefault(code int) *DeleteSelectedReplicationRulesDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &DeleteSelectedReplicationRulesDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the delete selected replication rules default response
-func (o *DeleteSelectedReplicationRulesDefault) WithStatusCode(code int) *DeleteSelectedReplicationRulesDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the delete selected replication rules default response
-func (o *DeleteSelectedReplicationRulesDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the delete selected replication rules default response
-func (o *DeleteSelectedReplicationRulesDefault) WithPayload(payload *models.APIError) *DeleteSelectedReplicationRulesDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the delete selected replication rules default response
-func (o *DeleteSelectedReplicationRulesDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *DeleteSelectedReplicationRulesDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/bucket/delete_selected_replication_rules_urlbuilder.go

@@ -1,116 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-	"strings"
-)
-
-// DeleteSelectedReplicationRulesURL generates an URL for the delete selected replication rules operation
-type DeleteSelectedReplicationRulesURL struct {
-	BucketName string
-
-	_basePath string
-	// avoid unkeyed usage
-	_ struct{}
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteSelectedReplicationRulesURL) WithBasePath(bp string) *DeleteSelectedReplicationRulesURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DeleteSelectedReplicationRulesURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *DeleteSelectedReplicationRulesURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/buckets/{bucket_name}/delete-selected-replication-rules"
-
-	bucketName := o.BucketName
-	if bucketName != "" {
-		_path = strings.Replace(_path, "{bucket_name}", bucketName, -1)
-	} else {
-		return nil, errors.New("bucketName is required on DeleteSelectedReplicationRulesURL")
-	}
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *DeleteSelectedReplicationRulesURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *DeleteSelectedReplicationRulesURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *DeleteSelectedReplicationRulesURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on DeleteSelectedReplicationRulesURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on DeleteSelectedReplicationRulesURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *DeleteSelectedReplicationRulesURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/bucket/disable_bucket_encryption.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// DisableBucketEncryptionHandlerFunc turns a function with the right signature into a disable bucket encryption handler
-type DisableBucketEncryptionHandlerFunc func(DisableBucketEncryptionParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn DisableBucketEncryptionHandlerFunc) Handle(params DisableBucketEncryptionParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// DisableBucketEncryptionHandler interface for that can handle valid disable bucket encryption params
-type DisableBucketEncryptionHandler interface {
-	Handle(DisableBucketEncryptionParams, *models.Principal) middleware.Responder
-}
-
-// NewDisableBucketEncryption creates a new http.Handler for the disable bucket encryption operation
-func NewDisableBucketEncryption(ctx *middleware.Context, handler DisableBucketEncryptionHandler) *DisableBucketEncryption {
-	return &DisableBucketEncryption{Context: ctx, Handler: handler}
-}
-
-/*
-	DisableBucketEncryption swagger:route POST /buckets/{bucket_name}/encryption/disable Bucket disableBucketEncryption
-
-Disable bucket encryption.
-*/
-type DisableBucketEncryption struct {
-	Context *middleware.Context
-	Handler DisableBucketEncryptionHandler
-}
-
-func (o *DisableBucketEncryption) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewDisableBucketEncryptionParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}

api/operations/bucket/disable_bucket_encryption_parameters.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/strfmt"
-)
-
-// NewDisableBucketEncryptionParams creates a new DisableBucketEncryptionParams object
-//
-// There are no default values defined in the spec.
-func NewDisableBucketEncryptionParams() DisableBucketEncryptionParams {
-
-	return DisableBucketEncryptionParams{}
-}
-
-// DisableBucketEncryptionParams contains all the bound params for the disable bucket encryption operation
-// typically these are obtained from a http.Request
-//
-// swagger:parameters DisableBucketEncryption
-type DisableBucketEncryptionParams struct {
-
-	// HTTP Request Object
-	HTTPRequest *http.Request `json:"-"`
-
-	/*
-	  Required: true
-	  In: path
-	*/
-	BucketName string
-}
-
-// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
-// for simple values it will use straight method calls.
-//
-// To ensure default values, the struct must have been initialized with NewDisableBucketEncryptionParams() beforehand.
-func (o *DisableBucketEncryptionParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
-	var res []error
-
-	o.HTTPRequest = r
-
-	rBucketName, rhkBucketName, _ := route.Params.GetOK("bucket_name")
-	if err := o.bindBucketName(rBucketName, rhkBucketName, route.Formats); err != nil {
-		res = append(res, err)
-	}
-	if len(res) > 0 {
-		return errors.CompositeValidationError(res...)
-	}
-	return nil
-}
-
-// bindBucketName binds and validates parameter BucketName from path.
-func (o *DisableBucketEncryptionParams) bindBucketName(rawData []string, hasKey bool, formats strfmt.Registry) error {
-	var raw string
-	if len(rawData) > 0 {
-		raw = rawData[len(rawData)-1]
-	}
-
-	// Required: true
-	// Parameter is provided by construction from the route
-	o.BucketName = raw
-
-	return nil
-}

api/operations/bucket/disable_bucket_encryption_responses.go

@@ -1,115 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime"
-
-	"github.com/minio/console/models"
-)
-
-// DisableBucketEncryptionOKCode is the HTTP code returned for type DisableBucketEncryptionOK
-const DisableBucketEncryptionOKCode int = 200
-
-/*
-DisableBucketEncryptionOK A successful response.
-
-swagger:response disableBucketEncryptionOK
-*/
-type DisableBucketEncryptionOK struct {
-}
-
-// NewDisableBucketEncryptionOK creates DisableBucketEncryptionOK with default headers values
-func NewDisableBucketEncryptionOK() *DisableBucketEncryptionOK {
-
-	return &DisableBucketEncryptionOK{}
-}
-
-// WriteResponse to the client
-func (o *DisableBucketEncryptionOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
-
-	rw.WriteHeader(200)
-}
-
-/*
-DisableBucketEncryptionDefault Generic error response.
-
-swagger:response disableBucketEncryptionDefault
-*/
-type DisableBucketEncryptionDefault struct {
-	_statusCode int
-
-	/*
-	  In: Body
-	*/
-	Payload *models.APIError `json:"body,omitempty"`
-}
-
-// NewDisableBucketEncryptionDefault creates DisableBucketEncryptionDefault with default headers values
-func NewDisableBucketEncryptionDefault(code int) *DisableBucketEncryptionDefault {
-	if code <= 0 {
-		code = 500
-	}
-
-	return &DisableBucketEncryptionDefault{
-		_statusCode: code,
-	}
-}
-
-// WithStatusCode adds the status to the disable bucket encryption default response
-func (o *DisableBucketEncryptionDefault) WithStatusCode(code int) *DisableBucketEncryptionDefault {
-	o._statusCode = code
-	return o
-}
-
-// SetStatusCode sets the status to the disable bucket encryption default response
-func (o *DisableBucketEncryptionDefault) SetStatusCode(code int) {
-	o._statusCode = code
-}
-
-// WithPayload adds the payload to the disable bucket encryption default response
-func (o *DisableBucketEncryptionDefault) WithPayload(payload *models.APIError) *DisableBucketEncryptionDefault {
-	o.Payload = payload
-	return o
-}
-
-// SetPayload sets the payload to the disable bucket encryption default response
-func (o *DisableBucketEncryptionDefault) SetPayload(payload *models.APIError) {
-	o.Payload = payload
-}
-
-// WriteResponse to the client
-func (o *DisableBucketEncryptionDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
-
-	rw.WriteHeader(o._statusCode)
-	if o.Payload != nil {
-		payload := o.Payload
-		if err := producer.Produce(rw, payload); err != nil {
-			panic(err) // let the recovery middleware deal with this
-		}
-	}
-}

api/operations/bucket/disable_bucket_encryption_urlbuilder.go

@@ -1,116 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"errors"
-	"net/url"
-	golangswaggerpaths "path"
-	"strings"
-)
-
-// DisableBucketEncryptionURL generates an URL for the disable bucket encryption operation
-type DisableBucketEncryptionURL struct {
-	BucketName string
-
-	_basePath string
-	// avoid unkeyed usage
-	_ struct{}
-}
-
-// WithBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DisableBucketEncryptionURL) WithBasePath(bp string) *DisableBucketEncryptionURL {
-	o.SetBasePath(bp)
-	return o
-}
-
-// SetBasePath sets the base path for this url builder, only required when it's different from the
-// base path specified in the swagger spec.
-// When the value of the base path is an empty string
-func (o *DisableBucketEncryptionURL) SetBasePath(bp string) {
-	o._basePath = bp
-}
-
-// Build a url path and query string
-func (o *DisableBucketEncryptionURL) Build() (*url.URL, error) {
-	var _result url.URL
-
-	var _path = "/buckets/{bucket_name}/encryption/disable"
-
-	bucketName := o.BucketName
-	if bucketName != "" {
-		_path = strings.Replace(_path, "{bucket_name}", bucketName, -1)
-	} else {
-		return nil, errors.New("bucketName is required on DisableBucketEncryptionURL")
-	}
-
-	_basePath := o._basePath
-	if _basePath == "" {
-		_basePath = "/api/v1"
-	}
-	_result.Path = golangswaggerpaths.Join(_basePath, _path)
-
-	return &_result, nil
-}
-
-// Must is a helper function to panic when the url builder returns an error
-func (o *DisableBucketEncryptionURL) Must(u *url.URL, err error) *url.URL {
-	if err != nil {
-		panic(err)
-	}
-	if u == nil {
-		panic("url can't be nil")
-	}
-	return u
-}
-
-// String returns the string representation of the path with query string
-func (o *DisableBucketEncryptionURL) String() string {
-	return o.Must(o.Build()).String()
-}
-
-// BuildFull builds a full url with scheme, host, path and query string
-func (o *DisableBucketEncryptionURL) BuildFull(scheme, host string) (*url.URL, error) {
-	if scheme == "" {
-		return nil, errors.New("scheme is required for a full url on DisableBucketEncryptionURL")
-	}
-	if host == "" {
-		return nil, errors.New("host is required for a full url on DisableBucketEncryptionURL")
-	}
-
-	base, err := o.Build()
-	if err != nil {
-		return nil, err
-	}
-
-	base.Scheme = scheme
-	base.Host = host
-	return base, nil
-}
-
-// StringFull returns the string representation of a complete url
-func (o *DisableBucketEncryptionURL) StringFull(scheme, host string) string {
-	return o.Must(o.BuildFull(scheme, host)).String()
-}

api/operations/bucket/enable_bucket_encryption.go

@@ -1,88 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// This file is part of MinIO Console Server
-// Copyright (c) 2023 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 bucket
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the generate command
-
-import (
-	"net/http"
-
-	"github.com/go-openapi/runtime/middleware"
-
-	"github.com/minio/console/models"
-)
-
-// EnableBucketEncryptionHandlerFunc turns a function with the right signature into a enable bucket encryption handler
-type EnableBucketEncryptionHandlerFunc func(EnableBucketEncryptionParams, *models.Principal) middleware.Responder
-
-// Handle executing the request and returning a response
-func (fn EnableBucketEncryptionHandlerFunc) Handle(params EnableBucketEncryptionParams, principal *models.Principal) middleware.Responder {
-	return fn(params, principal)
-}
-
-// EnableBucketEncryptionHandler interface for that can handle valid enable bucket encryption params
-type EnableBucketEncryptionHandler interface {
-	Handle(EnableBucketEncryptionParams, *models.Principal) middleware.Responder
-}
-
-// NewEnableBucketEncryption creates a new http.Handler for the enable bucket encryption operation
-func NewEnableBucketEncryption(ctx *middleware.Context, handler EnableBucketEncryptionHandler) *EnableBucketEncryption {
-	return &EnableBucketEncryption{Context: ctx, Handler: handler}
-}
-
-/*
-	EnableBucketEncryption swagger:route POST /buckets/{bucket_name}/encryption/enable Bucket enableBucketEncryption
-
-Enable bucket encryption.
-*/
-type EnableBucketEncryption struct {
-	Context *middleware.Context
-	Handler EnableBucketEncryptionHandler
-}
-
-func (o *EnableBucketEncryption) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	route, rCtx, _ := o.Context.RouteInfo(r)
-	if rCtx != nil {
-		*r = *rCtx
-	}
-	var Params = NewEnableBucketEncryptionParams()
-	uprinc, aCtx, err := o.Context.Authorize(r, route)
-	if err != nil {
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-	if aCtx != nil {
-		*r = *aCtx
-	}
-	var principal *models.Principal
-	if uprinc != nil {
-		principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
-	}
-
-	if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
-		o.Context.Respond(rw, r, route.Produces, route, err)
-		return
-	}
-
-	res := o.Handler.Handle(Params, principal) // actually handle the request
-	o.Context.Respond(rw, r, route.Produces, route, res)
-
-}