Intial Commit Migrating from github.com/minio/m3

restapi/admin_config.go

@@ -0,0 +1,186 @@
+// This file is part of MinIO Kubernetes Cloud
+// Copyright (c) 2020 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 restapi
+
+import (
+	"context"
+	"log"
+	"strings"
+
+	"github.com/go-openapi/errors"
+	"github.com/go-openapi/runtime/middleware"
+	"github.com/go-openapi/swag"
+	"github.com/minio/m3/mcs/models"
+	"github.com/minio/m3/mcs/restapi/operations"
+
+	"github.com/minio/m3/mcs/restapi/operations/admin_api"
+)
+
+func registerConfigHandlers(api *operations.McsAPI) {
+	// List Configurations
+	api.AdminAPIListConfigHandler = admin_api.ListConfigHandlerFunc(func(params admin_api.ListConfigParams, principal interface{}) middleware.Responder {
+		configListResp, err := getListConfigResponse()
+		if err != nil {
+			return admin_api.NewListConfigDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewListConfigOK().WithPayload(configListResp)
+	})
+	// Configuration Info
+	api.AdminAPIConfigInfoHandler = admin_api.ConfigInfoHandlerFunc(func(params admin_api.ConfigInfoParams, principal interface{}) middleware.Responder {
+		config, err := getConfigResponse(params)
+		if err != nil {
+			return admin_api.NewConfigInfoDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewConfigInfoOK().WithPayload(config)
+	})
+	// Set Configuration
+	api.AdminAPISetConfigHandler = admin_api.SetConfigHandlerFunc(func(params admin_api.SetConfigParams, principal interface{}) middleware.Responder {
+		if err := setConfigResponse(params.Name, params.Body); err != nil {
+			return admin_api.NewSetConfigDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewSetConfigNoContent()
+	})
+}
+
+// listConfig gets all configurations' names and their descriptions
+func listConfig(client MinioAdmin) ([]*models.ConfigDescription, error) {
+	ctx := context.Background()
+	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() (*models.ListConfigResponse, error) {
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return nil, 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 {
+		log.Println("error listing configurations:", err)
+		return nil, err
+	}
+	listGroupsResponse := &models.ListConfigResponse{
+		Configurations: configDescs,
+		Total:          int64(len(configDescs)),
+	}
+	return listGroupsResponse, nil
+}
+
+// getConfig gets the key values for a defined configuration
+func getConfig(client MinioAdmin, name string) ([]*models.ConfigurationKV, error) {
+	ctx := context.Background()
+	configTarget, err := client.getConfigKV(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+	// configTarget comes as an array []madmin.Target
+	if len(configTarget) > 0 {
+		// return Key Values, first element contains info
+		var confkv []*models.ConfigurationKV
+		for _, kv := range configTarget[0].KVS {
+			confkv = append(confkv, &models.ConfigurationKV{Key: kv.Key, Value: kv.Value})
+		}
+		return confkv, nil
+	}
+
+	return nil, errors.New(500, "error getting config: empty info")
+}
+
+// getConfigResponse performs getConfig() and serializes it to the handler's output
+func getConfigResponse(params admin_api.ConfigInfoParams) (*models.Configuration, error) {
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return nil, err
+	}
+	// create a MinIO Admin Client interface implementation
+	// defining the client to be used
+	adminClient := adminClient{client: mAdmin}
+
+	configkv, err := getConfig(adminClient, params.Name)
+	if err != nil {
+		log.Println("error listing configurations:", err)
+		return nil, err
+	}
+	configurationObj := &models.Configuration{
+		Name:      params.Name,
+		KeyValues: configkv,
+	}
+	return configurationObj, nil
+}
+
+// setConfig sets a configuration with the defined key values
+func setConfig(client MinioAdmin, name *string, kvs []*models.ConfigurationKV, arnResourceID string) error {
+	config := buildConfig(name, kvs, arnResourceID)
+	ctx := context.Background()
+	if err := client.setConfigKV(ctx, *config); err != nil {
+		return err
+	}
+	return nil
+}
+
+// buildConfig builds a concatenated string including name and keyvalues
+// e.g. `region name=us-west-1`
+func buildConfig(name *string, kvs []*models.ConfigurationKV, arnResourceID string) *string {
+	// if arnResourceID is not empty the configuration will be treated as a notification target
+	// arnResourceID will be used as an identifier for that specific target
+	// docs: https://docs.min.io/docs/minio-bucket-notification-guide.html
+	configName := *name
+	if arnResourceID != "" {
+		configName += ":" + arnResourceID
+	}
+	configElements := []string{configName}
+	for _, kv := range kvs {
+		configElements = append(configElements, kv.Key+"="+kv.Value)
+	}
+	config := strings.Join(configElements, " ")
+	return &config
+}
+
+// setConfigResponse implements setConfig() to be used by handler
+func setConfigResponse(name string, configRequest *models.SetConfigRequest) error {
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return err
+	}
+	// create a MinIO Admin Client interface implementation
+	// defining the client to be used
+	adminClient := adminClient{client: mAdmin}
+	if err := setConfig(adminClient, swag.String(name), configRequest.KeyValues, configRequest.ArnResourceID); err != nil {
+		log.Println("error listing configurations:", err)
+		return err
+	}
+	return nil
+}

restapi/admin_config_test.go

@@ -0,0 +1,209 @@
+// This file is part of MinIO Kubernetes Cloud
+// Copyright (c) 2020 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 restapi
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/go-openapi/swag"
+	"github.com/minio/m3/mcs/models"
+	"github.com/minio/minio/pkg/madmin"
+
+	"errors"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// assigning mock at runtime instead of compile time
+var minioHelpConfigKVMock func(subSys, key string, envOnly bool) (madmin.Help, error)
+var minioGetConfigKVMock func(key string) (madmin.Targets, error)
+var minioSetConfigKVMock func(kv string) error
+
+// mock function helpConfigKV()
+func (ac adminClientMock) helpConfigKV(ctx context.Context, subSys, key string, envOnly bool) (madmin.Help, error) {
+	return minioHelpConfigKVMock(subSys, key, envOnly)
+}
+
+// mock function getConfigKV()
+func (ac adminClientMock) getConfigKV(ctx context.Context, name string) (madmin.Targets, error) {
+	return minioGetConfigKVMock(name)
+}
+
+// mock function setConfigKV()
+func (ac adminClientMock) setConfigKV(ctx context.Context, kv string) error {
+	return minioSetConfigKVMock(kv)
+}
+
+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{
+		madmin.HelpKV{
+			Key:         "region",
+			Description: "label the location of the server",
+		},
+		madmin.HelpKV{
+			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(subSys, key string, envOnly 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(subSys, key string, envOnly bool) (madmin.Help, error) {
+		return madmin.Help{}, errors.New("error")
+	}
+	_, err = listConfig(adminClient)
+	if assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+}
+
+func TestGetConfigInfo(t *testing.T) {
+	assert := assert.New(t)
+	adminClient := adminClientMock{}
+	function := "getConfig()"
+	// Test-1 : getConfig() get info of postgres configuration, has 3 key-value pairs
+	configMock := []madmin.Target{
+		madmin.Target{
+			SubSystem: "notify_postgres",
+			KVS: []madmin.KV{
+				madmin.KV{
+					Key:   "enable",
+					Value: "off",
+				},
+				madmin.KV{
+					Key:   "format",
+					Value: "namespace",
+				},
+				madmin.KV{
+					Key:   "connection",
+					Value: "",
+				},
+			},
+		},
+	}
+	expectedKV := configMock[0].KVS
+	// mock function response from getConfig()
+	minioGetConfigKVMock = func(key string) (madmin.Targets, error) {
+		return configMock, nil
+	}
+	configNameToGet := "notify_postgres"
+	configInfo, err := getConfig(adminClient, configNameToGet)
+	if err != nil {
+		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
+	}
+	// verify length of keys is correct
+	assert.Equal(len(expectedKV), len(configInfo), fmt.Sprintf("Failed on %s: length of Configs's lists is not the same", function))
+	// verify KeysHelp content
+	for i, kv := range configInfo {
+		assert.Equal(expectedKV[i].Key, kv.Key)
+		assert.Equal(expectedKV[i].Value, kv.Value)
+	}
+
+	// Test-2 : getConfig() Return error and see that the error is handled correctly and returned
+	minioGetConfigKVMock = func(key string) (madmin.Targets, error) {
+		return madmin.Targets{}, errors.New("error")
+	}
+	_, err = getConfig(adminClient, configNameToGet)
+	if assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+
+	// Test-3 : getConfig() get info but Response has empty results (possible)
+	configMock = []madmin.Target{}
+	// mock function response from getConfig()
+	minioGetConfigKVMock = func(key string) (madmin.Targets, error) {
+		return configMock, nil
+	}
+	configNameToGet = "notify_postgres"
+	_, err = getConfig(adminClient, configNameToGet)
+	if assert.Error(err) {
+		assert.Equal("error getting config: empty info", err.Error())
+	}
+}
+
+func TestSetConfig(t *testing.T) {
+	assert := assert.New(t)
+	adminClient := adminClientMock{}
+	function := "setConfig()"
+	// mock function response from setConfig()
+	minioSetConfigKVMock = func(kv string) error {
+		return nil
+	}
+	configName := "notify_postgres"
+	kvs := []*models.ConfigurationKV{
+		&models.ConfigurationKV{
+			Key:   "enable",
+			Value: "off",
+		},
+		&models.ConfigurationKV{
+			Key:   "connection_string",
+			Value: "",
+		},
+	}
+	arnResourceID := ""
+
+	// Test-1 : setConfig() sets a config with two key value pairs
+	err := setConfig(adminClient, swag.String(configName), kvs, arnResourceID)
+	if err != nil {
+		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
+	}
+
+	// Test-2 : setConfig() returns error, handle properly
+	minioSetConfigKVMock = func(kv string) error {
+		return errors.New("error")
+	}
+	if err := setConfig(adminClient, swag.String(configName), kvs, arnResourceID); assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+
+	// Test-3: buildConfig() format correctly configuration as "config_name k=v k2=v2"
+	config := buildConfig(swag.String(configName), kvs, arnResourceID)
+	assert.Equal(fmt.Sprintf("%s enable=off connection_string=", configName), *config)
+
+	// Test-4: buildConfig() format correctly configuration if it has a non empty arnResourceID as "config_name:resourceid k=v k2=v2"
+	arnResourceID = "postgres"
+	config = buildConfig(swag.String(configName), kvs, arnResourceID)
+	assert.Equal(fmt.Sprintf("%s:%s enable=off connection_string=", configName, arnResourceID), *config)
+}

restapi/admin_groups.go

@@ -0,0 +1,348 @@
+// This file is part of MinIO Kubernetes Cloud
+// Copyright (c) 2020 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 restapi
+
+import (
+	"context"
+	"log"
+
+	"github.com/go-openapi/errors"
+	"github.com/go-openapi/runtime/middleware"
+	"github.com/go-openapi/swag"
+	"github.com/minio/m3/mcs/restapi/operations"
+	"github.com/minio/minio/pkg/madmin"
+
+	"github.com/minio/m3/mcs/restapi/operations/admin_api"
+
+	"github.com/minio/m3/mcs/models"
+)
+
+func registerGroupsHandlers(api *operations.McsAPI) {
+	// List Groups
+	api.AdminAPIListGroupsHandler = admin_api.ListGroupsHandlerFunc(func(params admin_api.ListGroupsParams, principal interface{}) middleware.Responder {
+		listGroupsResponse, err := getListGroupsResponse()
+		if err != nil {
+			return admin_api.NewListGroupsDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewListGroupsOK().WithPayload(listGroupsResponse)
+	})
+	// Group Info
+	api.AdminAPIGroupInfoHandler = admin_api.GroupInfoHandlerFunc(func(params admin_api.GroupInfoParams, principal interface{}) middleware.Responder {
+		groupInfo, err := getGroupInfoResponse(params)
+		if err != nil {
+			return admin_api.NewGroupInfoDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewGroupInfoOK().WithPayload(groupInfo)
+	})
+	// Add Group
+	api.AdminAPIAddGroupHandler = admin_api.AddGroupHandlerFunc(func(params admin_api.AddGroupParams, principal interface{}) middleware.Responder {
+		if err := getAddGroupResponse(params.Body); err != nil {
+			return admin_api.NewAddGroupDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewAddGroupCreated()
+	})
+	// Remove Group
+	api.AdminAPIRemoveGroupHandler = admin_api.RemoveGroupHandlerFunc(func(params admin_api.RemoveGroupParams, principal interface{}) middleware.Responder {
+		if err := getRemoveGroupResponse(params); err != nil {
+			return admin_api.NewRemoveGroupDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewRemoveGroupNoContent()
+	})
+	// Update Group
+	api.AdminAPIUpdateGroupHandler = admin_api.UpdateGroupHandlerFunc(func(params admin_api.UpdateGroupParams, principal interface{}) middleware.Responder {
+		groupUpdateResp, err := getUpdateGroupResponse(params)
+		if err != nil {
+			return admin_api.NewUpdateGroupDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewUpdateGroupOK().WithPayload(groupUpdateResp)
+	})
+}
+
+// listGroups calls MinIO server to list all groups names present on the server.
+func listGroups(ctx context.Context, client MinioAdmin) (*[]string, error) {
+	groupList, err := client.listGroups(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return &groupList, nil
+}
+
+// getListGroupsResponse performs listGroups() and serializes it to the handler's output
+func getListGroupsResponse() (*models.ListGroupsResponse, error) {
+	ctx := context.Background()
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return nil, err
+	}
+	// create a MinIO Admin Client interface implementation
+	// defining the client to be used
+	adminClient := adminClient{client: mAdmin}
+
+	groups, err := listGroups(ctx, adminClient)
+	if err != nil {
+		log.Println("error listing groups:", err)
+		return nil, 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(params admin_api.GroupInfoParams) (*models.Group, error) {
+	ctx := context.Background()
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return nil, 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 {
+		log.Println("error getting  group info:", err)
+		return nil, 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(params *models.AddGroupRequest) error {
+	ctx := context.Background()
+	// AddGroup request needed to proceed
+	if params == nil {
+		log.Println("error AddGroup body not in request")
+		return errors.New(500, "error AddGroup body not in request")
+	}
+
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return err
+	}
+	// create a MinIO Admin Client interface implementation
+	// defining the client to be used
+	adminClient := adminClient{client: mAdmin}
+
+	if err := addGroup(ctx, adminClient, *params.Group, params.Members); err != nil {
+		log.Println("error adding group:", err)
+		return 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(params admin_api.RemoveGroupParams) error {
+	ctx := context.Background()
+
+	if params.Name == "" {
+		log.Println("error group name not in request")
+		return errors.New(500, "error group name not in request")
+	}
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return 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 {
+		log.Println("error removing group:", err)
+		return err
+	}
+	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")
+	}
+	if err := client.setGroupStatus(ctx, group, setStatus); err != nil {
+		return err
+	}
+	return nil
+}
+
+// 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(params admin_api.UpdateGroupParams) (*models.Group, error) {
+	ctx := context.Background()
+	if params.Name == "" {
+		log.Println("error group name not in request")
+		return nil, errors.New(500, "error group name not in request")
+	}
+	if params.Body == nil {
+		log.Println("error body not in request")
+		return nil, errors.New(500, "error body not in request")
+	}
+	expectedGroupUpdate := params.Body
+	groupName := params.Name
+
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return nil, err
+	}
+	// create a MinIO Admin Client interface implementation
+	// defining the client to be used
+	adminClient := adminClient{client: mAdmin}
+
+	groupUpdated, err := groupUpdate(ctx, adminClient, groupName, expectedGroupUpdate)
+	if err != nil {
+		log.Println("error updating group:", err)
+		return nil, 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 {
+		log.Println("error getting  group info:", err)
+		return nil, err
+	}
+	// update group members
+	err = addOrDeleteMembers(ctx, client, groupDescription, expectedMembers)
+	if err != nil {
+		log.Println("error updating group:", 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 {
+			log.Println("error updating group's status:", err)
+			return nil, err
+		}
+	}
+	// return latest group info to verify that changes were applied correctly
+	groupDescription, err = groupInfo(ctx, client, groupName)
+	if err != nil {
+		log.Println("error getting  group info:", err)
+		return nil, err
+	}
+	return groupDescription, nil
+}

restapi/admin_policies.go

@@ -0,0 +1,298 @@
+// This file is part of MinIO Kubernetes Cloud
+// Copyright (c) 2020 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 restapi
+
+import (
+	"context"
+	"encoding/json"
+	"log"
+
+	"github.com/go-openapi/errors"
+
+	"github.com/go-openapi/runtime/middleware"
+	"github.com/go-openapi/swag"
+	"github.com/minio/m3/mcs/models"
+	"github.com/minio/m3/mcs/restapi/operations"
+	"github.com/minio/m3/mcs/restapi/operations/admin_api"
+)
+
+func registersPoliciesHandler(api *operations.McsAPI) {
+	// List Policies
+	api.AdminAPIListPoliciesHandler = admin_api.ListPoliciesHandlerFunc(func(params admin_api.ListPoliciesParams, principal interface{}) middleware.Responder {
+		listPoliciesResponse, err := getListPoliciesResponse()
+		if err != nil {
+			return admin_api.NewListPoliciesDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewListPoliciesOK().WithPayload(listPoliciesResponse)
+	})
+	// Policy Info
+	api.AdminAPIPolicyInfoHandler = admin_api.PolicyInfoHandlerFunc(func(params admin_api.PolicyInfoParams, principal interface{}) middleware.Responder {
+		policyInfo, err := getPolicyInfoResponse(params)
+		if err != nil {
+			return admin_api.NewPolicyInfoDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewPolicyInfoOK().WithPayload(policyInfo)
+	})
+	// Add Policy
+	api.AdminAPIAddPolicyHandler = admin_api.AddPolicyHandlerFunc(func(params admin_api.AddPolicyParams, principal interface{}) middleware.Responder {
+		policyResponse, err := getAddPolicyResponse(params.Body)
+		if err != nil {
+			return admin_api.NewAddPolicyDefault(500).WithPayload(&models.Error{
+				Code:    500,
+				Message: swag.String(err.Error()),
+			})
+		}
+		return admin_api.NewAddPolicyCreated().WithPayload(policyResponse)
+	})
+	// Remove Policy
+	api.AdminAPIRemovePolicyHandler = admin_api.RemovePolicyHandlerFunc(func(params admin_api.RemovePolicyParams, principal interface{}) middleware.Responder {
+		if err := getRemovePolicyResponse(params); err != nil {
+			return admin_api.NewRemovePolicyDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewRemovePolicyNoContent()
+	})
+	// Set Policy
+	api.AdminAPISetPolicyHandler = admin_api.SetPolicyHandlerFunc(func(params admin_api.SetPolicyParams, principal interface{}) middleware.Responder {
+		if err := getSetPolicyResponse(params.Name, params.Body); err != nil {
+			return admin_api.NewSetPolicyDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewSetPolicyNoContent()
+	})
+}
+
+type rawStatement struct {
+	Action   []string `json:"Action"`
+	Effect   string   `json:"Effect"`
+	Resource []string `json:"Resource"`
+}
+
+type rawPolicy struct {
+	Name      string          `json:"Name"`
+	Statement []*rawStatement `json:"Statement"`
+	Version   string          `json:"Version"`
+}
+
+// parseRawPolicy() converts from *rawPolicy to *models.Policy
+// Iterates over the raw statements and copied them to models.policy
+// this is need it until fixed from minio/minio side: https://github.com/minio/minio/issues/9171
+func parseRawPolicy(rawPolicy *rawPolicy) *models.Policy {
+	var statements []*models.Statement
+	for _, rawStatement := range rawPolicy.Statement {
+		statement := &models.Statement{
+			Actions:   rawStatement.Action,
+			Effect:    rawStatement.Effect,
+			Resources: rawStatement.Resource,
+		}
+		statements = append(statements, statement)
+	}
+	policy := &models.Policy{
+		Name:       rawPolicy.Name,
+		Version:    rawPolicy.Version,
+		Statements: statements,
+	}
+	return policy
+}
+
+// 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(client MinioAdmin) ([]*models.Policy, error) {
+	ctx := context.Background()
+	policyRawMap, err := client.listPolicies(ctx)
+	var policies []*models.Policy
+	if err != nil {
+		return nil, err
+	}
+	for name, policyRaw := range policyRawMap {
+		var rawPolicy *rawPolicy
+		if err := json.Unmarshal(policyRaw, &rawPolicy); err != nil {
+			return nil, err
+		}
+		policy := parseRawPolicy(rawPolicy)
+		policy.Name = name
+		policies = append(policies, policy)
+	}
+	return policies, nil
+}
+
+// getListPoliciesResponse performs listPolicies() and serializes it to the handler's output
+func getListPoliciesResponse() (*models.ListPoliciesResponse, error) {
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return nil, err
+	}
+	// create a MinIO Admin Client interface implementation
+	// defining the client to be used
+	adminClient := adminClient{client: mAdmin}
+
+	policies, err := listPolicies(adminClient)
+	if err != nil {
+		log.Println("error listing policies:", err)
+		return nil, err
+	}
+	// serialize output
+	listPoliciesResponse := &models.ListPoliciesResponse{
+		Policies: policies,
+		Total:    int64(len(policies)),
+	}
+	return listPoliciesResponse, nil
+}
+
+// removePolicy() calls MinIO server to remove a policy based on name.
+func removePolicy(client MinioAdmin, name string) error {
+	ctx := context.Background()
+	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(params admin_api.RemovePolicyParams) error {
+	if params.Name == "" {
+		log.Println("error policy name not in request")
+		return errors.New(500, "error policy name not in request")
+	}
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return err
+	}
+	// create a MinIO Admin Client interface implementation
+	// defining the client to be used
+	adminClient := adminClient{client: mAdmin}
+
+	if err := removePolicy(adminClient, params.Name); err != nil {
+		log.Println("error removing policy:", err)
+		return 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(client MinioAdmin, name, policy string) (*models.Policy, error) {
+	ctx := context.Background()
+	if err := client.addPolicy(ctx, name, policy); err != nil {
+		return nil, err
+	}
+	policyObject, err := policyInfo(client, name)
+	if err != nil {
+		return nil, err
+	}
+	return policyObject, nil
+}
+
+// getAddPolicyResponse performs addPolicy() and serializes it to the handler's output
+func getAddPolicyResponse(params *models.AddPolicyRequest) (*models.Policy, error) {
+	if params == nil {
+		log.Println("error AddPolicy body not in request")
+		return nil, errors.New(500, "error AddPolicy body not in request")
+	}
+
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return nil, err
+	}
+	// create a MinIO Admin Client interface implementation
+	// defining the client to be used
+	adminClient := adminClient{client: mAdmin}
+	policy, err := addPolicy(adminClient, *params.Name, params.Definition)
+	if err != nil {
+		log.Println("error adding policy")
+		return nil, err
+	}
+	return policy, nil
+}
+
+// policyInfo calls MinIO server to retrieve information of a canned policy.
+// policyInfo() takes a policy name, obtains an []byte (represents a string in JSON format)
+// from the MinIO server and then convert it to *models.Policy , in the future this will change
+// to a Policy struct{} - https://github.com/minio/minio/issues/9171
+func policyInfo(client MinioAdmin, name string) (*models.Policy, error) {
+	ctx := context.Background()
+	policyRaw, err := client.getPolicy(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+	var rawPolicy *rawPolicy
+	if err := json.Unmarshal(policyRaw, &rawPolicy); err != nil {
+		return nil, err
+	}
+	policyObject := parseRawPolicy(rawPolicy)
+	policyObject.Name = name
+	return policyObject, nil
+}
+
+// getPolicyInfoResponse performs policyInfo() and serializes it to the handler's output
+func getPolicyInfoResponse(params admin_api.PolicyInfoParams) (*models.Policy, error) {
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return nil, err
+	}
+	// create a MinIO Admin Client interface implementation
+	// defining the client to be used
+	adminClient := adminClient{client: mAdmin}
+	policy, err := policyInfo(adminClient, params.Name)
+	if err != nil {
+		log.Println("error getting  group info:", err)
+		return nil, err
+	}
+	return policy, nil
+}
+
+// setPolicy() calls MinIO server to assign policy to a group or user.
+func setPolicy(client MinioAdmin, name, entityName string, entityType models.PolicyEntity) error {
+	isGroup := false
+	if entityType == "group" {
+		isGroup = true
+	}
+	ctx := context.Background()
+	if err := client.setPolicy(ctx, name, entityName, isGroup); err != nil {
+		return err
+	}
+	return nil
+}
+
+// getSetPolicyResponse() performs setPolicy() and serializes it to the handler's output
+func getSetPolicyResponse(name string, params *models.SetPolicyRequest) error {
+	if name == "" {
+		log.Println("error policy name not in request")
+		return errors.New(500, "error policy name not in request")
+	}
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return err
+	}
+	// create a MinIO Admin Client interface implementation
+	// defining the client to be used
+	adminClient := adminClient{client: mAdmin}
+
+	if err := setPolicy(adminClient, name, *params.EntityName, params.EntityType); err != nil {
+		log.Println("error setting policy:", err)
+		return err
+	}
+	return nil
+}

restapi/admin_policies_test.go

@@ -0,0 +1,282 @@
+// This file is part of MinIO Kubernetes Cloud
+// Copyright (c) 2020 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 restapi
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"errors"
+
+	"github.com/minio/m3/mcs/models"
+	"github.com/stretchr/testify/assert"
+)
+
+// assigning mock at runtime instead of compile time
+var minioListPoliciesMock func() (map[string][]byte, error)
+var minioGetPolicyMock func(name string) ([]byte, error)
+var minioRemovePolicyMock func(name string) error
+var minioAddPolicyMock func(name, policy string) error
+var minioSetPolicyMock func(policyName, entityName string, isGroup bool) error
+
+// mock function of listPolicies()
+func (ac adminClientMock) listPolicies(ctx context.Context) (map[string][]byte, error) {
+	return minioListPoliciesMock()
+}
+
+// mock function of getPolicy()
+func (ac adminClientMock) getPolicy(ctx context.Context, name string) ([]byte, error) {
+	return minioGetPolicyMock(name)
+}
+
+// mock function of removePolicy()
+func (ac adminClientMock) removePolicy(ctx context.Context, name string) error {
+	return minioRemovePolicyMock(name)
+}
+
+// mock function of addPolicy()
+func (ac adminClientMock) addPolicy(ctx context.Context, name, policy string) error {
+	return minioAddPolicyMock(name, policy)
+}
+
+// mock function setPolicy()
+func (ac adminClientMock) setPolicy(ctx context.Context, policyName, entityName string, isGroup bool) error {
+	return minioSetPolicyMock(policyName, entityName, isGroup)
+}
+
+func TestListPolicies(t *testing.T) {
+	assert := assert.New(t)
+	adminClient := adminClientMock{}
+	mockPoliciesList := map[string][]byte{
+		"readonly":    []byte("{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"s3:GetBucketLocation\",\"s3:GetObject\"],\"Resource\":[\"arn:aws:s3:::*\"]}]}"),
+		"readwrite":   []byte("{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"s3:*\"],\"Resource\":[\"arn:aws:s3:::*\"]}]}"),
+		"diagnostics": []byte("{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":[\"admin:ServerInfo\",\"admin:HardwareInfo\",\"admin:TopLocksInfo\",\"admin:PerfInfo\",\"admin:Profiling\",\"admin:ServerTrace\",\"admin:ConsoleLog\"],\"Resource\":[\"arn:aws:s3:::*\"]}]}"),
+	}
+	assertPoliciesMap := map[string]models.Policy{
+		"readonly": {
+			Name: "readonly",
+			Statements: []*models.Statement{
+				{
+					Actions:   []string{"s3:GetBucketLocation", "s3:GetObject"},
+					Effect:    "Allow",
+					Resources: []string{"arn:aws:s3:::*"},
+				},
+			},
+			Version: "2012-10-17",
+		},
+		"readwrite": {
+			Name: "readwrite",
+			Statements: []*models.Statement{
+				{
+					Actions:   []string{"s3:*"},
+					Effect:    "Allow",
+					Resources: []string{"arn:aws:s3:::*"},
+				},
+			},
+			Version: "2012-10-17",
+		},
+		"diagnostics": {
+			Name: "diagnostics",
+			Statements: []*models.Statement{
+				{
+					Actions: []string{
+						"admin:ServerInfo",
+						"admin:HardwareInfo",
+						"admin:TopLocksInfo",
+						"admin:PerfInfo",
+						"admin:Profiling",
+						"admin:ServerTrace",
+						"admin:ConsoleLog",
+					},
+					Effect:    "Allow",
+					Resources: []string{"arn:aws:s3:::*"},
+				},
+			},
+			Version: "2012-10-17",
+		},
+	}
+	// mock function response from listPolicies()
+	minioListPoliciesMock = func() (map[string][]byte, error) {
+		return mockPoliciesList, 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(adminClient)
+	if err != nil {
+		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
+	}
+	// verify length of Policies is correct
+	assert.Equal(len(mockPoliciesList), len(policiesList), fmt.Sprintf("Failed on %s: length of Policies's lists is not the same", function))
+	// Test-2 :
+	// get list policies response, this response should have Name, Version and Statement
+	// as part of each Policy
+	for _, policy := range policiesList {
+		assertPolicy := assertPoliciesMap[policy.Name]
+		// Check if policy statement has the same length as in the assertPoliciesMap
+		assert.Equal(len(policy.Statements), len(assertPolicy.Statements))
+		// Check if policy name is the same as in the assertPoliciesMap
+		assert.Equal(policy.Name, assertPolicy.Name)
+		// Check if policy version is the same as in the assertPoliciesMap
+		assert.Equal(policy.Version, assertPolicy.Version)
+		// Iterate over each policy statement
+		for i, statement := range policy.Statements {
+			// Check if each statement effect is the same as in the assertPoliciesMap statement
+			assert.Equal(statement.Effect, assertPolicy.Statements[i].Effect)
+			// Check if each statement action is the same as in the assertPoliciesMap statement
+			assert.Equal(statement.Actions, assertPolicy.Statements[i].Actions)
+			// Check if each statement resource is the same as in the assertPoliciesMap resource
+			assert.Equal(statement.Resources, assertPolicy.Statements[i].Resources)
+		}
+	}
+	// Test-3 : listPolicies() Return error and see that the error is handled correctly and returned
+	minioListPoliciesMock = func() (map[string][]byte, error) {
+		return nil, errors.New("error")
+	}
+	_, err = listPolicies(adminClient)
+	if assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+	//Test-4 : listPolicies() handles malformed json
+	minioListPoliciesMock = func() (map[string][]byte, error) {
+		malformedData := map[string][]byte{
+			"malformed-policy": []byte("asdasdasdasdasd"),
+		}
+		return malformedData, nil
+	}
+	_, err = listPolicies(adminClient)
+	if assert.Error(err) {
+		assert.NotEmpty(err.Error())
+	}
+}
+
+func TestRemovePolicy(t *testing.T) {
+	assert := assert.New(t)
+	adminClient := adminClientMock{}
+	// Test-1 : removePolicy() remove an existing policy
+	policyToRemove := "mcs-policy"
+	minioRemovePolicyMock = func(name string) error {
+		return nil
+	}
+	function := "removePolicy()"
+	if err := removePolicy(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(name string) error {
+		return errors.New("error")
+	}
+	if err := removePolicy(adminClient, policyToRemove); assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+}
+
+func TestAddPolicy(t *testing.T) {
+	assert := 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(name, policy string) error {
+		return nil
+	}
+	minioGetPolicyMock = func(name string) (bytes []byte, err error) {
+		return []byte(policyDefinition), nil
+	}
+	assertPolicy := models.Policy{
+		Name: "new-policy",
+		Statements: []*models.Statement{
+			{
+				Actions:   []string{"s3:GetBucketLocation", "s3:GetObject", "s3:ListAllMyBuckets"},
+				Effect:    "Allow",
+				Resources: []string{"arn:aws:s3:::*"},
+			},
+		},
+		Version: "2012-10-17",
+	}
+	// Test-1 : addPolicy() adds a new policy
+	function := "addPolicy()"
+	policy, err := addPolicy(adminClient, policyName, policyDefinition)
+	if err != nil {
+		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
+	}
+	assert.Equal(policy.Name, assertPolicy.Name)
+	assert.Equal(policy.Version, assertPolicy.Version)
+	assert.Equal(len(policy.Statements), len(assertPolicy.Statements))
+	// Test-2 : addPolicy() got an error while adding policy
+	minioAddPolicyMock = func(name, policy string) error {
+		return errors.New("error")
+	}
+	if _, err := addPolicy(adminClient, policyName, policyDefinition); assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+	// Test-3 : addPolicy() got an error while retrieving policy
+	minioAddPolicyMock = func(name, policy string) error {
+		return nil
+	}
+	minioGetPolicyMock = func(name string) (bytes []byte, err error) {
+		return nil, errors.New("error")
+	}
+	if _, err := addPolicy(adminClient, policyName, policyDefinition); assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+	// Test-4 : addPolicy() got an error while parsing policy
+	minioGetPolicyMock = func(name string) (bytes []byte, err error) {
+		return []byte("eaeaeaeae"), nil
+	}
+	if _, err := addPolicy(adminClient, policyName, policyDefinition); assert.Error(err) {
+		assert.NotEmpty(err.Error())
+	}
+}
+
+func TestSetPolicy(t *testing.T) {
+	assert := assert.New(t)
+	adminClient := adminClientMock{}
+	policyName := "readOnly"
+	entityName := "alevsk"
+	entityObject := models.PolicyEntityUser
+	minioSetPolicyMock = func(policyName, entityName string, isGroup bool) error {
+		return nil
+	}
+	// Test-1 : setPolicy() set policy to user
+	function := "setPolicy()"
+	err := setPolicy(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(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(policyName, entityName string, isGroup bool) error {
+		return errors.New("error")
+	}
+	if err := setPolicy(adminClient, policyName, entityName, entityObject); assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+	// Test-4 : setPolicy() set policy to group and get error
+	entityObject = models.PolicyEntityGroup
+	minioSetPolicyMock = func(policyName, entityName string, isGroup bool) error {
+		return errors.New("error")
+	}
+	if err := setPolicy(adminClient, policyName, entityName, entityObject); assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+}

restapi/admin_service.go

@@ -0,0 +1,80 @@
+// This file is part of MinIO Kubernetes Cloud
+// Copyright (c) 2020 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 restapi
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"github.com/go-openapi/runtime/middleware"
+	"github.com/go-openapi/swag"
+	"github.com/minio/m3/mcs/models"
+	"github.com/minio/m3/mcs/restapi/operations"
+
+	"github.com/minio/m3/mcs/restapi/operations/admin_api"
+)
+
+func registerServiceHandlers(api *operations.McsAPI) {
+	// Restart Service
+	api.AdminAPIRestartServiceHandler = admin_api.RestartServiceHandlerFunc(func(params admin_api.RestartServiceParams, principal interface{}) middleware.Responder {
+		if err := getRestartServiceResponse(); err != nil {
+			return admin_api.NewRestartServiceDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.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() error {
+	ctx := context.Background()
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return 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 {
+		log.Println("error restarting service:", err)
+		return err
+	}
+	return nil
+}

restapi/admin_service_test.go

@@ -0,0 +1,83 @@
+// This file is part of MinIO Kubernetes Cloud
+// Copyright (c) 2020 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 restapi
+
+import (
+	"context"
+	"testing"
+
+	"errors"
+
+	"github.com/minio/minio/pkg/madmin"
+	"github.com/stretchr/testify/assert"
+)
+
+// assigning mock at runtime instead of compile time
+var minioServiceRestartMock func(ctx context.Context) error
+var minioServerInfoMock func(ctx context.Context) (madmin.InfoMessage, error)
+
+// mock function of serviceRestart()
+func (ac adminClientMock) serviceRestart(ctx context.Context) error {
+	return minioServiceRestartMock(ctx)
+}
+
+// mock function of serverInfo()
+func (ac adminClientMock) serverInfo(ctx context.Context) (madmin.InfoMessage, error) {
+	return minioServerInfoMock(ctx)
+}
+
+func TestServiceRestart(t *testing.T) {
+	assert := assert.New(t)
+	adminClient := adminClientMock{}
+	ctx := context.Background()
+	function := "serviceRestart()"
+	// Test-1 : serviceRestart() restart services no error
+	// mock function response from listGroups()
+	minioServiceRestartMock = func(ctx context.Context) error {
+		return nil
+	}
+	minioServerInfoMock = func(ctx context.Context) (madmin.InfoMessage, error) {
+		return madmin.InfoMessage{}, nil
+	}
+	if err := serviceRestart(ctx, adminClient); err != nil {
+		t.Errorf("Failed on %s:, error occurred: %s", function, err.Error())
+	}
+
+	// Test-2 : serviceRestart() returns error on client.serviceRestart call
+	// and see that the error is handled correctly and returned
+	minioServiceRestartMock = func(ctx context.Context) error {
+		return errors.New("error")
+	}
+	minioServerInfoMock = func(ctx 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 error on client.serverInfo() call
+	// and see that the error is handled correctly and returned
+	minioServiceRestartMock = func(ctx context.Context) error {
+		return nil
+	}
+	minioServerInfoMock = func(ctx 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())
+	}
+}

restapi/admin_test.go

@@ -0,0 +1,379 @@
+// This file is part of MinIO Kubernetes Cloud
+// Copyright (c) 2020 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 restapi
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/minio/minio/pkg/madmin"
+
+	"errors"
+
+	"github.com/stretchr/testify/assert"
+	asrt "github.com/stretchr/testify/assert"
+)
+
+// assigning mock at runtime instead of compile time
+var minioListUsersMock func() (map[string]madmin.UserInfo, error)
+var minioAddUserMock func(accessKey, secreyKey string) error
+var minioListGroupsMock func() ([]string, error)
+var minioUpdateGroupMembersMock func(madmin.GroupAddRemove) error
+var minioGetGroupDescriptionMock func(group string) (*madmin.GroupDesc, error)
+var minioSetGroupStatusMock func(group string, status madmin.GroupStatus) error
+
+// Define a mock struct of Admin Client interface implementation
+type adminClientMock struct{}
+
+// mock function of listUsers()
+func (ac adminClientMock) listUsers(ctx context.Context) (map[string]madmin.UserInfo, error) {
+	return minioListUsersMock()
+}
+
+// mock function of addUser()
+func (ac adminClientMock) addUser(ctx context.Context, accessKey, secretKey string) error {
+	return minioAddUserMock(accessKey, secretKey)
+}
+
+// mock function of listGroups()
+func (ac adminClientMock) listGroups(ctx context.Context) ([]string, error) {
+	return minioListGroupsMock()
+}
+
+// mock function of updateGroupMembers()
+func (ac adminClientMock) updateGroupMembers(ctx context.Context, req madmin.GroupAddRemove) error {
+	return minioUpdateGroupMembersMock(req)
+}
+
+// mock function of getGroupDescription()
+func (ac adminClientMock) getGroupDescription(ctx context.Context, group string) (*madmin.GroupDesc, error) {
+	return minioGetGroupDescriptionMock(group)
+}
+
+// mock function setGroupStatus()
+func (ac adminClientMock) setGroupStatus(ctx context.Context, group string, status madmin.GroupStatus) error {
+	return minioSetGroupStatusMock(group, status)
+}
+
+func TestListUsers(t *testing.T) {
+	assert := asrt.New(t)
+	adminClient := adminClientMock{}
+	// 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": madmin.UserInfo{
+			SecretKey:  "",
+			PolicyName: "ABCDEFGHI-policy",
+			Status:     "enabled",
+			MemberOf:   []string{"group1", "group2"},
+		},
+		"ZBCDEFGHI": madmin.UserInfo{
+			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(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, 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(adminClient)
+	if assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+}
+
+func TestAddUser(t *testing.T) {
+	assert := asrt.New(t)
+	adminClient := adminClientMock{}
+
+	// Test-1: valid case of adding a user with a proper access key
+	accessKey := "ABCDEFGHI"
+	secretKey := "ABCDEFGHIABCDEFGHI"
+
+	// mock function response from addUser() return no error
+	minioAddUserMock = func(accessKey, secretKey string) error {
+		return nil
+	}
+	// adds a valid user to MinIO
+	function := "addUser()"
+	user, err := addUser(adminClient, &accessKey, &secretKey)
+	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-1: valid case
+	accessKey = "AB"
+	secretKey = "ABCDEFGHIABCDEFGHI"
+
+	// mock function response from addUser() return no error
+	minioAddUserMock = func(accessKey, secretKey string) error {
+		return errors.New("error")
+	}
+
+	user, err = addUser(adminClient, &accessKey, &secretKey)
+
+	// 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 TestListGroups(t *testing.T) {
+	assert := assert.New(t)
+	adminClient := adminClientMock{}
+	ctx := context.Background()
+
+	// 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 := listGroups(ctx, adminClient)
+	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 = listGroups(ctx, adminClient)
+	if assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+}
+
+func TestAddGroup(t *testing.T) {
+	assert := assert.New(t)
+	adminClient := adminClientMock{}
+	ctx := context.Background()
+
+	// 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 := context.Background()
+
+	// 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 := context.Background()
+
+	// 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(group 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(group string) (*madmin.GroupDesc, error) {
+		return nil, errors.New("error")
+	}
+	_, err = groupInfo(ctx, adminClient, groupName)
+	if assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+}
+
+func TestUpdateGroupInfo(t *testing.T) {
+	assert := assert.New(t)
+	adminClient := adminClientMock{}
+	ctx := context.Background()
+
+	// 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())
+	}
+}
+
+func TestSetGroupStatus(t *testing.T) {
+	assert := assert.New(t)
+	adminClient := adminClientMock{}
+	function := "setGroupStatus()"
+	groupName := "acmeGroup"
+	ctx := context.Background()
+
+	// Test-1: setGroupStatus() update valid disabled status
+	expectedStatus := "disabled"
+	minioSetGroupStatusMock = func(group string, status 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(group string, status 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(group string, status 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(group string, status madmin.GroupStatus) error {
+		return errors.New("error")
+	}
+	if err := setGroupStatus(ctx, adminClient, groupName, expectedStatus); assert.Error(err) {
+		assert.Equal("error", err.Error())
+	}
+}

restapi/admin_users.go

@@ -0,0 +1,131 @@
+// This file is part of MinIO Kubernetes Cloud
+// Copyright (c) 2020 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 restapi
+
+import (
+	"context"
+	"log"
+
+	"github.com/go-openapi/runtime/middleware"
+	"github.com/go-openapi/swag"
+	"github.com/minio/m3/mcs/restapi/operations"
+
+	"github.com/minio/m3/mcs/restapi/operations/admin_api"
+
+	"github.com/minio/m3/mcs/models"
+)
+
+func registerUsersHandlers(api *operations.McsAPI) {
+	// List Users
+	api.AdminAPIListUsersHandler = admin_api.ListUsersHandlerFunc(func(params admin_api.ListUsersParams, principal interface{}) middleware.Responder {
+		listUsersResponse, err := getListUsersResponse()
+		if err != nil {
+			return admin_api.NewListUsersDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewListUsersOK().WithPayload(listUsersResponse)
+	})
+	// Add User
+	api.AdminAPIAddUserHandler = admin_api.AddUserHandlerFunc(func(params admin_api.AddUserParams, principal interface{}) middleware.Responder {
+		userResponse, err := getUserAddResponse(params)
+		if err != nil {
+			return admin_api.NewAddUserDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
+		}
+		return admin_api.NewAddUserCreated().WithPayload(userResponse)
+	})
+}
+
+func listUsers(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.
+	ctx := context.Background()
+	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:    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() (*models.ListUsersResponse, error) {
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return nil, err
+	}
+	// create a minioClient interface implementation
+	// defining the client to be used
+	adminClient := adminClient{client: mAdmin}
+
+	users, err := listUsers(adminClient)
+	if err != nil {
+		log.Println("error listing users:", err)
+		return nil, 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(client MinioAdmin, accessKey, secretKey *string) (*models.User, error) {
+	// Calls into MinIO to add a new user if there's an error return it
+	ctx := context.Background()
+	err := client.addUser(ctx, *accessKey, *secretKey)
+	if err != nil {
+		return nil, err
+	}
+
+	userElem := &models.User{
+		AccessKey: *accessKey,
+	}
+
+	return userElem, nil
+}
+
+func getUserAddResponse(params admin_api.AddUserParams) (*models.User, error) {
+	mAdmin, err := newMAdminClient()
+	if err != nil {
+		log.Println("error creating Madmin Client:", err)
+		return nil, err
+	}
+	// create a minioClient interface implementation
+	// defining the client to be used
+	adminClient := adminClient{client: mAdmin}
+
+	user, err := addUser(adminClient, params.Body.AccessKey, params.Body.SecretKey)
+	if err != nil {
+		log.Println("error adding user:", err)
+		return nil, err
+	}
+	return user, nil
+}

restapi/client-admin.go

@@ -0,0 +1,256 @@
+// This file is part of MinIO Orchestrator
+// Copyright (c) 2020 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 restapi
+
+import (
+	"context"
+	"crypto/tls"
+	"hash/fnv"
+	"net"
+	"net/http"
+	"net/url"
+	"path/filepath"
+	"runtime"
+	"sync"
+	"time"
+
+	"github.com/minio/mc/pkg/httptracer"
+	"github.com/minio/mc/pkg/probe"
+	"github.com/minio/minio/pkg/madmin"
+)
+
+const globalAppName = "orchestrator portal"
+
+// newAdminFactory encloses New function with client cache.
+func newAdminFactory() func(config *Config) (*madmin.AdminClient, *probe.Error) {
+	clientCache := make(map[uint32]*madmin.AdminClient)
+	mutex := &sync.Mutex{}
+
+	// Return New function.
+	return func(config *Config) (*madmin.AdminClient, *probe.Error) {
+		// Creates a parsed URL.
+		targetURL, e := url.Parse(config.HostURL)
+		if e != nil {
+			return nil, probe.NewError(e)
+		}
+		// By default enable HTTPs.
+		useTLS := true
+		if targetURL.Scheme == "http" {
+			useTLS = false
+		}
+
+		// Save if target supports virtual host style.
+		hostName := targetURL.Host
+
+		// Generate a hash out of s3Conf.
+		confHash := fnv.New32a()
+		confHash.Write([]byte(hostName + config.AccessKey + config.SecretKey))
+		confSum := confHash.Sum32()
+
+		// Lookup previous cache by hash.
+		mutex.Lock()
+		defer mutex.Unlock()
+		var api *madmin.AdminClient
+		var found bool
+		if api, found = clientCache[confSum]; !found {
+			// Not found. Instantiate a new MinIO
+			var e error
+			api, e = madmin.New(hostName, config.AccessKey, config.SecretKey, useTLS)
+			if e != nil {
+				return nil, probe.NewError(e)
+			}
+
+			// Keep TLS config.
+			tlsConfig := &tls.Config{}
+			if config.Insecure {
+				tlsConfig.InsecureSkipVerify = true
+			}
+
+			var transport http.RoundTripper = &http.Transport{
+				Proxy: http.ProxyFromEnvironment,
+				DialContext: (&net.Dialer{
+					Timeout:   30 * time.Second,
+					KeepAlive: 30 * time.Second,
+				}).DialContext,
+				MaxIdleConns:          100,
+				IdleConnTimeout:       90 * time.Second,
+				TLSHandshakeTimeout:   10 * time.Second,
+				ExpectContinueTimeout: 1 * time.Second,
+				TLSClientConfig:       tlsConfig,
+			}
+
+			if config.Debug {
+				transport = httptracer.GetNewTraceTransport(newTraceV4(), transport)
+			}
+
+			// Set custom transport.
+			api.SetCustomTransport(transport)
+
+			// Set app info.
+			api.SetAppInfo(config.AppName, config.AppVersion)
+
+			// Cache the new MinIO Client with hash of config as key.
+			clientCache[confSum] = api
+		}
+
+		// Store the new api object.
+		return api, nil
+	}
+}
+
+// NewAdminClient gives a new client interface
+func NewAdminClient(url string, accessKey string, secretKey string) (*madmin.AdminClient, *probe.Error) {
+	appName := filepath.Base(globalAppName)
+	s3Client, err := s3AdminNew(&Config{
+		HostURL:     url,
+		AccessKey:   accessKey,
+		SecretKey:   secretKey,
+		AppName:     appName,
+		AppVersion:  Version,
+		AppComments: []string{appName, runtime.GOOS, runtime.GOARCH},
+	})
+	if err != nil {
+		return nil, err.Trace(url)
+	}
+	return s3Client, nil
+}
+
+// s3AdminNew returns an initialized minioAdmin structure. If debug is enabled,
+// it also enables an internal trace transport.
+var s3AdminNew = newAdminFactory()
+
+// Define MinioAdmin interface with all functions to be implemented
+// 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
+	listGroups(ctx context.Context) ([]string, error)
+	updateGroupMembers(ctx context.Context, greq madmin.GroupAddRemove) error
+	getGroupDescription(ctx context.Context, grouo string) (*madmin.GroupDesc, error)
+	setGroupStatus(ctx context.Context, group string, status madmin.GroupStatus) error
+	listPolicies(ctx context.Context) (map[string][]byte, error)
+	getPolicy(ctx context.Context, name string) ([]byte, error)
+	removePolicy(ctx context.Context, name string) error
+	addPolicy(ctx context.Context, name, policy string) error
+	setPolicy(ctx context.Context, policyName, entityName string, isGroup bool) error
+	getConfigKV(ctx context.Context, key string) (madmin.Targets, error)
+	helpConfigKV(ctx context.Context, subSys, key string, envOnly bool) (madmin.Help, error)
+	setConfigKV(ctx context.Context, kv string) (err error)
+	serviceRestart(ctx context.Context) error
+	serverInfo(ctx context.Context) (madmin.InfoMessage, error)
+}
+
+// Interface implementation
+//
+// Define the structure of a minIO Client and define the functions that are actually used
+// from minIO api.
+type adminClient struct {
+	client *madmin.AdminClient
+}
+
+// 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, acessKey, secretKey string) error {
+	return ac.client.AddUser(ctx, acessKey, secretKey)
+}
+
+// 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][]byte, error) {
+	return ac.client.ListCannedPolicies(ctx)
+}
+
+// implements madmin.ListCannedPolicies()
+func (ac adminClient) getPolicy(ctx context.Context, name string) ([]byte, error) {
+	return ac.client.InfoCannedPolicy(ctx, name)
+}
+
+// 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, policy string) error {
+	return ac.client.AddCannedPolicy(ctx, name, policy)
+}
+
+// implements madmin.SetPolicy()
+func (ac adminClient) setPolicy(ctx context.Context, policyName, entityName string, isGroup bool) error {
+	return ac.client.SetPolicy(ctx, policyName, entityName, isGroup)
+}
+
+// implements madmin.GetConfigKV()
+func (ac adminClient) getConfigKV(ctx context.Context, key string) (madmin.Targets, 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.SetConfigKV()
+func (ac adminClient) setConfigKV(ctx context.Context, kv string) (err error) {
+	return ac.client.SetConfigKV(ctx, kv)
+}
+
+// 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)
+}
+
+func newMAdminClient() (*madmin.AdminClient, error) {
+	endpoint := getMinIOServer()
+	accessKeyID := getAccessKey()
+	secretAccessKey := getSecretKey()
+
+	adminClient, pErr := NewAdminClient(endpoint, accessKeyID, secretAccessKey)
+	if pErr != nil {
+		return nil, pErr.Cause
+	}
+	return adminClient, nil
+}

restapi/client-s3-trace_v4.go

@@ -0,0 +1,89 @@
+// This file is part of MinIO Orchestrator
+// Copyright (c) 2020 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 restapi
+
+import (
+	"net/http"
+	"net/http/httputil"
+	"regexp"
+	"strings"
+
+	"github.com/minio/mc/pkg/httptracer"
+	"github.com/minio/minio/pkg/console"
+)
+
+// traceV4 - tracing structure for signature version '4'.
+type traceV4 struct{}
+
+// newTraceV4 - initialize Trace structure
+func newTraceV4() httptracer.HTTPTracer {
+	return traceV4{}
+}
+
+// Request - Trace HTTP Request
+func (t traceV4) Request(req *http.Request) (err error) {
+	origAuth := req.Header.Get("Authorization")
+
+	printTrace := func() error {
+		reqTrace, rerr := httputil.DumpRequestOut(req, false) // Only display header
+		if rerr == nil {
+			console.Debug(string(reqTrace))
+		}
+		return rerr
+	}
+
+	if strings.TrimSpace(origAuth) != "" {
+		// Authorization (S3 v4 signature) Format:
+		// Authorization: AWS4-HMAC-SHA256 Credential=AKIAJNACEGBGMXBHLEZA/20150524/us-east-1/s3/aws4_request, SignedHeaders=host;x-amz-content-sha256;x-amz-date, Signature=bbfaa693c626021bcb5f911cd898a1a30206c1fad6bad1e0eb89e282173bd24c
+
+		// Strip out accessKeyID from: Credential=<access-key-id>/<date>/<aws-region>/<aws-service>/aws4_request
+		regCred := regexp.MustCompile("Credential=([A-Z0-9]+)/")
+		newAuth := regCred.ReplaceAllString(origAuth, "Credential=**REDACTED**/")
+
+		// Strip out 256-bit signature from: Signature=<256-bit signature>
+		regSign := regexp.MustCompile("Signature=([[0-9a-f]+)")
+		newAuth = regSign.ReplaceAllString(newAuth, "Signature=**REDACTED**")
+
+		// Set a temporary redacted auth
+		req.Header.Set("Authorization", newAuth)
+
+		err = printTrace()
+
+		// Undo
+		req.Header.Set("Authorization", origAuth)
+	} else {
+		err = printTrace()
+	}
+	return err
+}
+
+// Response - Trace HTTP Response
+func (t traceV4) Response(resp *http.Response) (err error) {
+	var respTrace []byte
+	// For errors we make sure to dump response body as well.
+	if resp.StatusCode != http.StatusOK &&
+		resp.StatusCode != http.StatusPartialContent &&
+		resp.StatusCode != http.StatusNoContent {
+		respTrace, err = httputil.DumpResponse(resp, true)
+	} else {
+		respTrace, err = httputil.DumpResponse(resp, false)
+	}
+	if err == nil {
+		console.Debug(string(respTrace))
+	}
+	return err
+}

restapi/client.go

@@ -0,0 +1,109 @@
+// This file is part of MinIO Orchestrator
+// Copyright (c) 2020 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 restapi
+
+import (
+	"context"
+
+	"github.com/minio/minio-go/v6"
+)
+
+func init() {
+	// All minio-go API operations shall be performed only once,
+	// another way to look at this is we are turning off retries.
+	minio.MaxRetry = 1
+}
+
+// Config - see http://docs.amazonwebservices.com/AmazonS3/latest/dev/index.html?RESTAuthentication.html
+type Config struct {
+	AccessKey   string
+	SecretKey   string
+	Signature   string
+	HostURL     string
+	AppName     string
+	AppVersion  string
+	AppComments []string
+	Debug       bool
+	Insecure    bool
+	Lookup      minio.BucketLookupType
+}
+
+// Define MinioClient interface with all functions to be implemented
+// by mock when testing, it should include all MinioClient respective api calls
+// that are used within this project.
+type MinioClient interface {
+	listBucketsWithContext(ctx context.Context) ([]minio.BucketInfo, error)
+	makeBucketWithContext(ctx context.Context, bucketName, location string) error
+	setBucketPolicyWithContext(ctx context.Context, bucketName, policy string) error
+	removeBucket(bucketName string) error
+	getBucketNotification(bucketName string) (bucketNotification minio.BucketNotification, err error)
+	getBucketPolicy(bucketName string) (string, error)
+}
+
+// Interface implementation
+//
+// Define the structure of a minIO Client and define the functions that are actually used
+// from minIO api.
+type minioClient struct {
+	client *minio.Client
+}
+
+// implements minio.ListBucketsWithContext(ctx)
+func (mc minioClient) listBucketsWithContext(ctx context.Context) ([]minio.BucketInfo, error) {
+	return mc.client.ListBucketsWithContext(ctx)
+}
+
+// implements minio.MakeBucketWithContext(ctx, bucketName, location)
+func (mc minioClient) makeBucketWithContext(ctx context.Context, bucketName, location string) error {
+	return mc.client.MakeBucketWithContext(ctx, bucketName, location)
+}
+
+// implements minio.SetBucketPolicyWithContext(ctx, bucketName, policy)
+func (mc minioClient) setBucketPolicyWithContext(ctx context.Context, bucketName, policy string) error {
+	return mc.client.SetBucketPolicyWithContext(ctx, bucketName, policy)
+}
+
+// implements minio.RemoveBucket(bucketName)
+func (mc minioClient) removeBucket(bucketName string) error {
+	return mc.client.RemoveBucket(bucketName)
+}
+
+// implements minio.GetBucketNotification(bucketName)
+func (mc minioClient) getBucketNotification(bucketName string) (bucketNotification minio.BucketNotification, err error) {
+	return mc.client.GetBucketNotification(bucketName)
+}
+
+// implements minio.GetBucketPolicy(bucketName)
+func (mc minioClient) getBucketPolicy(bucketName string) (string, error) {
+	return mc.client.GetBucketPolicy(bucketName)
+}
+
+// newMinioClient creates a new MinIO client to talk to the server
+func newMinioClient() (*minio.Client, error) {
+	endpoint := getMinIOEndpoint()
+	accessKeyID := getAccessKey()
+	secretAccessKey := getSecretKey()
+	useSSL := getMinIOEndpointSSL()
+
+	// Initialize minio client object.
+	minioClient, err := minio.NewV4(endpoint, accessKeyID, secretAccessKey, useSSL)
+	if err != nil {
+		return nil, err
+	}
+
+	return minioClient, nil
+}

restapi/config.go

@@ -0,0 +1,59 @@
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 restapi
+
+import (
+	"strings"
+
+	"github.com/minio/minio/pkg/env"
+)
+
+func getAccessKey() string {
+	return env.Get(McsAccessKey, "minioadmin")
+}
+
+func getSecretKey() string {
+	return env.Get(McsSecretKey, "minioadmin")
+}
+
+func getMinIOServer() string {
+	return env.Get(McsMinIOServer, "http://localhost:9000")
+}
+
+func getMinIOEndpoint() string {
+	server := getMinIOServer()
+	if strings.Contains(server, "://") {
+		parts := strings.Split(server, "://")
+		if len(parts) > 1 {
+			server = parts[1]
+		}
+	}
+	return server
+}
+
+func getMinIOEndpointSSL() bool {
+	server := getMinIOServer()
+	if strings.Contains(server, "://") {
+		parts := strings.Split(server, "://")
+		if len(parts) > 1 {
+			if parts[1] == "https" {
+				return true
+			}
+		}
+	}
+	return false
+}

restapi/configure_mcs.go

@@ -0,0 +1,133 @@
+// This file is part of MinIO Kubernetes Cloud
+// Copyright (c) 2020 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/>.
+
+// This file is safe to edit. Once it exists it will not be overwritten
+
+package restapi
+
+import (
+	"crypto/tls"
+	"log"
+	"net/http"
+	"strings"
+
+	"github.com/minio/m3/mcs/restapi/sessions"
+
+	"github.com/minio/m3/mcs/models"
+
+	assetfs "github.com/elazarl/go-bindata-assetfs"
+
+	portalUI "github.com/minio/m3/mcs/portal-ui"
+
+	"github.com/go-openapi/errors"
+	"github.com/go-openapi/runtime"
+	"github.com/minio/m3/mcs/restapi/operations"
+)
+
+//go:generate swagger generate server --target ../../mcs --name Mcs --spec ../swagger.yml
+
+func configureFlags(api *operations.McsAPI) {
+	// api.CommandLineOptionsGroups = []swag.CommandLineOptionsGroup{ ... }
+}
+
+func configureAPI(api *operations.McsAPI) http.Handler {
+	// configure the api here
+	api.ServeError = errors.ServeError
+
+	// Set your custom logger if needed. Default one is log.Printf
+	// Expected interface func(string, ...interface{})
+	//
+	// Example:
+	// api.Logger = log.Printf
+
+	api.JSONConsumer = runtime.JSONConsumer()
+
+	api.JSONProducer = runtime.JSONProducer()
+	// Applies when the "x-token" header is set
+
+	api.KeyAuth = func(token string, scopes []string) (interface{}, error) {
+		if sessions.GetInstance().ValidSession(token) {
+			prin := models.Principal(token)
+			return &prin, nil
+		}
+		log.Printf("Access attempt with incorrect api key auth: %s", token)
+		return nil, errors.New(401, "incorrect api key auth")
+	}
+
+	// Register login handlers
+	registerLoginHandlers(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)
+
+	api.PreServerShutdown = func() {}
+
+	api.ServerShutdown = func() {}
+
+	return setupGlobalMiddleware(api.Serve(setupMiddlewares))
+}
+
+// The TLS configuration before HTTPS server starts.
+func configureTLS(tlsConfig *tls.Config) {
+	// Make all necessary changes to the TLS configuration here.
+}
+
+// As soon as server is initialized but not run yet, this function will be called.
+// If you need to modify a config, store server instance to stop it individually later, this is the place.
+// This function can be called multiple times, depending on the number of serving schemes.
+// scheme value will be set accordingly: "http", "https" or "unix"
+func configureServer(s *http.Server, scheme, addr string) {
+}
+
+// The middleware configuration is for the handler executors. These do not apply to the swagger.json document.
+// The middleware executes after routing but before authentication, binding and validation
+func setupMiddlewares(handler http.Handler) http.Handler {
+	return handler
+}
+
+// The middleware configuration happens before anything, this middleware also applies to serving the swagger.json document.
+// So this is a good place to plug in a panic handling middleware, logging and metrics
+func setupGlobalMiddleware(handler http.Handler) http.Handler {
+	// serve static files
+	next := FileServerMiddleware(handler)
+	return next
+}
+
+// FileServerMiddleware serves files from the static folder
+func FileServerMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if strings.HasPrefix(r.URL.Path, "/api") {
+			next.ServeHTTP(w, r)
+		} else {
+			http.FileServer(&assetfs.AssetFS{
+				Asset:     portalUI.Asset,
+				AssetDir:  portalUI.AssetDir,
+				AssetInfo: portalUI.AssetInfo,
+				Prefix:    "build"}).ServeHTTP(w, r)
+		}
+	})
+}

restapi/consts.go

@@ -0,0 +1,24 @@
+// This file is part of MinIO Kubernetes Cloud
+// Copyright (c) 2020 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 restapi
+
+const (
+	Version        = `0.1.0`
+	McsAccessKey   = "MCS_ACCESS_KEY"
+	McsSecretKey   = "MCS_SECRET_KEY"
+	McsMinIOServer = "MCS_MINIO_SERVER"
+)

restapi/doc.go

@@ -0,0 +1,34 @@
+// Code generated by go-swagger; DO NOT EDIT.
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 restapi MinIO Console Server
+//
+//  Schemes:
+//    http
+//  Host: localhost
+//  BasePath: /
+//  Version: 0.1.0
+//
+//  Consumes:
+//    - application/json
+//
+//  Produces:
+//    - application/json
+//
+// swagger:meta
+package restapi

restapi/operations/admin_api/add_group.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// AddGroupHandlerFunc turns a function with the right signature into a add group handler
+type AddGroupHandlerFunc func(AddGroupParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn AddGroupHandlerFunc) Handle(params AddGroupParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// AddGroupHandler interface for that can handle valid add group params
+type AddGroupHandler interface {
+	Handle(AddGroupParams, interface{}) middleware.Responder
+}
+
+// NewAddGroup creates a new http.Handler for the add group operation
+func NewAddGroup(ctx *middleware.Context, handler AddGroupHandler) *AddGroup {
+	return &AddGroup{Context: ctx, Handler: handler}
+}
+
+/*AddGroup swagger:route POST /api/v1/groups AdminAPI addGroup
+
+Add Group
+
+*/
+type AddGroup struct {
+	Context *middleware.Context
+	Handler AddGroupHandler
+}
+
+func (o *AddGroup) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewAddGroupParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/add_group_parameters.go

@@ -0,0 +1,94 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/minio/m3/mcs/models"
+)
+
+// NewAddGroupParams creates a new AddGroupParams object
+// no default values defined in spec.
+func NewAddGroupParams() AddGroupParams {
+
+	return AddGroupParams{}
+}
+
+// AddGroupParams contains all the bound params for the add group operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters AddGroup
+type AddGroupParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+
+	/*
+	  Required: true
+	  In: body
+	*/
+	Body *models.AddGroupRequest
+}
+
+// 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 NewAddGroupParams() beforehand.
+func (o *AddGroupParams) 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.AddGroupRequest
+		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)
+			}
+
+			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
+}

restapi/operations/admin_api/add_group_responses.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// AddGroupCreatedCode is the HTTP code returned for type AddGroupCreated
+const AddGroupCreatedCode int = 201
+
+/*AddGroupCreated A successful response.
+
+swagger:response addGroupCreated
+*/
+type AddGroupCreated struct {
+}
+
+// NewAddGroupCreated creates AddGroupCreated with default headers values
+func NewAddGroupCreated() *AddGroupCreated {
+
+	return &AddGroupCreated{}
+}
+
+// WriteResponse to the client
+func (o *AddGroupCreated) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+	rw.WriteHeader(201)
+}
+
+/*AddGroupDefault Generic error response.
+
+swagger:response addGroupDefault
+*/
+type AddGroupDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewAddGroupDefault creates AddGroupDefault with default headers values
+func NewAddGroupDefault(code int) *AddGroupDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &AddGroupDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the add group default response
+func (o *AddGroupDefault) WithStatusCode(code int) *AddGroupDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the add group default response
+func (o *AddGroupDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the add group default response
+func (o *AddGroupDefault) WithPayload(payload *models.Error) *AddGroupDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the add group default response
+func (o *AddGroupDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *AddGroupDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/add_group_urlbuilder.go

@@ -0,0 +1,101 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// AddGroupURL generates an URL for the add group operation
+type AddGroupURL 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 *AddGroupURL) WithBasePath(bp string) *AddGroupURL {
+	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 *AddGroupURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *AddGroupURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/groups"
+
+	_basePath := o._basePath
+	_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 *AddGroupURL) 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 *AddGroupURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *AddGroupURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on AddGroupURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on AddGroupURL")
+	}
+
+	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 *AddGroupURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/add_policy.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// AddPolicyHandlerFunc turns a function with the right signature into a add policy handler
+type AddPolicyHandlerFunc func(AddPolicyParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn AddPolicyHandlerFunc) Handle(params AddPolicyParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// AddPolicyHandler interface for that can handle valid add policy params
+type AddPolicyHandler interface {
+	Handle(AddPolicyParams, interface{}) middleware.Responder
+}
+
+// NewAddPolicy creates a new http.Handler for the add policy operation
+func NewAddPolicy(ctx *middleware.Context, handler AddPolicyHandler) *AddPolicy {
+	return &AddPolicy{Context: ctx, Handler: handler}
+}
+
+/*AddPolicy swagger:route POST /api/v1/policies AdminAPI addPolicy
+
+Add Policy
+
+*/
+type AddPolicy struct {
+	Context *middleware.Context
+	Handler AddPolicyHandler
+}
+
+func (o *AddPolicy) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewAddPolicyParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/add_policy_parameters.go

@@ -0,0 +1,94 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/minio/m3/mcs/models"
+)
+
+// NewAddPolicyParams creates a new AddPolicyParams object
+// no default values defined in spec.
+func NewAddPolicyParams() AddPolicyParams {
+
+	return AddPolicyParams{}
+}
+
+// AddPolicyParams contains all the bound params for the add policy operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters AddPolicy
+type AddPolicyParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+
+	/*
+	  Required: true
+	  In: body
+	*/
+	Body *models.AddPolicyRequest
+}
+
+// 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 NewAddPolicyParams() beforehand.
+func (o *AddPolicyParams) 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.AddPolicyRequest
+		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)
+			}
+
+			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
+}

restapi/operations/admin_api/add_policy_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// AddPolicyCreatedCode is the HTTP code returned for type AddPolicyCreated
+const AddPolicyCreatedCode int = 201
+
+/*AddPolicyCreated A successful response.
+
+swagger:response addPolicyCreated
+*/
+type AddPolicyCreated struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Policy `json:"body,omitempty"`
+}
+
+// NewAddPolicyCreated creates AddPolicyCreated with default headers values
+func NewAddPolicyCreated() *AddPolicyCreated {
+
+	return &AddPolicyCreated{}
+}
+
+// WithPayload adds the payload to the add policy created response
+func (o *AddPolicyCreated) WithPayload(payload *models.Policy) *AddPolicyCreated {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the add policy created response
+func (o *AddPolicyCreated) SetPayload(payload *models.Policy) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *AddPolicyCreated) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+	rw.WriteHeader(201)
+	if o.Payload != nil {
+		payload := o.Payload
+		if err := producer.Produce(rw, payload); err != nil {
+			panic(err) // let the recovery middleware deal with this
+		}
+	}
+}
+
+/*AddPolicyDefault Generic error response.
+
+swagger:response addPolicyDefault
+*/
+type AddPolicyDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewAddPolicyDefault creates AddPolicyDefault with default headers values
+func NewAddPolicyDefault(code int) *AddPolicyDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &AddPolicyDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the add policy default response
+func (o *AddPolicyDefault) WithStatusCode(code int) *AddPolicyDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the add policy default response
+func (o *AddPolicyDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the add policy default response
+func (o *AddPolicyDefault) WithPayload(payload *models.Error) *AddPolicyDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the add policy default response
+func (o *AddPolicyDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *AddPolicyDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/add_policy_urlbuilder.go

@@ -0,0 +1,101 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// AddPolicyURL generates an URL for the add policy operation
+type AddPolicyURL 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 *AddPolicyURL) WithBasePath(bp string) *AddPolicyURL {
+	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 *AddPolicyURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *AddPolicyURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/policies"
+
+	_basePath := o._basePath
+	_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 *AddPolicyURL) 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 *AddPolicyURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *AddPolicyURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on AddPolicyURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on AddPolicyURL")
+	}
+
+	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 *AddPolicyURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/add_user.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// AddUserHandlerFunc turns a function with the right signature into a add user handler
+type AddUserHandlerFunc func(AddUserParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn AddUserHandlerFunc) Handle(params AddUserParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// AddUserHandler interface for that can handle valid add user params
+type AddUserHandler interface {
+	Handle(AddUserParams, interface{}) middleware.Responder
+}
+
+// NewAddUser creates a new http.Handler for the add user operation
+func NewAddUser(ctx *middleware.Context, handler AddUserHandler) *AddUser {
+	return &AddUser{Context: ctx, Handler: handler}
+}
+
+/*AddUser swagger:route POST /api/v1/users AdminAPI addUser
+
+Add User
+
+*/
+type AddUser struct {
+	Context *middleware.Context
+	Handler AddUserHandler
+}
+
+func (o *AddUser) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewAddUserParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/add_user_parameters.go

@@ -0,0 +1,94 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/minio/m3/mcs/models"
+)
+
+// NewAddUserParams creates a new AddUserParams object
+// no default values defined in spec.
+func NewAddUserParams() AddUserParams {
+
+	return AddUserParams{}
+}
+
+// AddUserParams contains all the bound params for the add user operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters AddUser
+type AddUserParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+
+	/*
+	  Required: true
+	  In: body
+	*/
+	Body *models.AddUserRequest
+}
+
+// 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 NewAddUserParams() beforehand.
+func (o *AddUserParams) 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.AddUserRequest
+		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)
+			}
+
+			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
+}

restapi/operations/admin_api/add_user_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// AddUserCreatedCode is the HTTP code returned for type AddUserCreated
+const AddUserCreatedCode int = 201
+
+/*AddUserCreated A successful response.
+
+swagger:response addUserCreated
+*/
+type AddUserCreated struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.User `json:"body,omitempty"`
+}
+
+// NewAddUserCreated creates AddUserCreated with default headers values
+func NewAddUserCreated() *AddUserCreated {
+
+	return &AddUserCreated{}
+}
+
+// WithPayload adds the payload to the add user created response
+func (o *AddUserCreated) WithPayload(payload *models.User) *AddUserCreated {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the add user created response
+func (o *AddUserCreated) SetPayload(payload *models.User) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *AddUserCreated) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+	rw.WriteHeader(201)
+	if o.Payload != nil {
+		payload := o.Payload
+		if err := producer.Produce(rw, payload); err != nil {
+			panic(err) // let the recovery middleware deal with this
+		}
+	}
+}
+
+/*AddUserDefault Generic error response.
+
+swagger:response addUserDefault
+*/
+type AddUserDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewAddUserDefault creates AddUserDefault with default headers values
+func NewAddUserDefault(code int) *AddUserDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &AddUserDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the add user default response
+func (o *AddUserDefault) WithStatusCode(code int) *AddUserDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the add user default response
+func (o *AddUserDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the add user default response
+func (o *AddUserDefault) WithPayload(payload *models.Error) *AddUserDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the add user default response
+func (o *AddUserDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *AddUserDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/add_user_urlbuilder.go

@@ -0,0 +1,101 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// AddUserURL generates an URL for the add user operation
+type AddUserURL 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 *AddUserURL) WithBasePath(bp string) *AddUserURL {
+	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 *AddUserURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *AddUserURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/users"
+
+	_basePath := o._basePath
+	_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 *AddUserURL) 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 *AddUserURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *AddUserURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on AddUserURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on AddUserURL")
+	}
+
+	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 *AddUserURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/config_info.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// ConfigInfoHandlerFunc turns a function with the right signature into a config info handler
+type ConfigInfoHandlerFunc func(ConfigInfoParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn ConfigInfoHandlerFunc) Handle(params ConfigInfoParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// ConfigInfoHandler interface for that can handle valid config info params
+type ConfigInfoHandler interface {
+	Handle(ConfigInfoParams, interface{}) middleware.Responder
+}
+
+// NewConfigInfo creates a new http.Handler for the config info operation
+func NewConfigInfo(ctx *middleware.Context, handler ConfigInfoHandler) *ConfigInfo {
+	return &ConfigInfo{Context: ctx, Handler: handler}
+}
+
+/*ConfigInfo swagger:route GET /api/v1/configs/{name} AdminAPI configInfo
+
+Configuration info
+
+*/
+type ConfigInfo struct {
+	Context *middleware.Context
+	Handler ConfigInfoHandler
+}
+
+func (o *ConfigInfo) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewConfigInfoParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/config_info_parameters.go

@@ -0,0 +1,89 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// NewConfigInfoParams creates a new ConfigInfoParams object
+// no default values defined in spec.
+func NewConfigInfoParams() ConfigInfoParams {
+
+	return ConfigInfoParams{}
+}
+
+// ConfigInfoParams contains all the bound params for the config info operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters ConfigInfo
+type ConfigInfoParams 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 NewConfigInfoParams() beforehand.
+func (o *ConfigInfoParams) 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 *ConfigInfoParams) 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
+}

restapi/operations/admin_api/config_info_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// ConfigInfoOKCode is the HTTP code returned for type ConfigInfoOK
+const ConfigInfoOKCode int = 200
+
+/*ConfigInfoOK A successful response.
+
+swagger:response configInfoOK
+*/
+type ConfigInfoOK struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Configuration `json:"body,omitempty"`
+}
+
+// NewConfigInfoOK creates ConfigInfoOK with default headers values
+func NewConfigInfoOK() *ConfigInfoOK {
+
+	return &ConfigInfoOK{}
+}
+
+// WithPayload adds the payload to the config info o k response
+func (o *ConfigInfoOK) WithPayload(payload *models.Configuration) *ConfigInfoOK {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the config info o k response
+func (o *ConfigInfoOK) SetPayload(payload *models.Configuration) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ConfigInfoOK) 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
+		}
+	}
+}
+
+/*ConfigInfoDefault Generic error response.
+
+swagger:response configInfoDefault
+*/
+type ConfigInfoDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewConfigInfoDefault creates ConfigInfoDefault with default headers values
+func NewConfigInfoDefault(code int) *ConfigInfoDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &ConfigInfoDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the config info default response
+func (o *ConfigInfoDefault) WithStatusCode(code int) *ConfigInfoDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the config info default response
+func (o *ConfigInfoDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the config info default response
+func (o *ConfigInfoDefault) WithPayload(payload *models.Error) *ConfigInfoDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the config info default response
+func (o *ConfigInfoDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ConfigInfoDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/config_info_urlbuilder.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// ConfigInfoURL generates an URL for the config info operation
+type ConfigInfoURL 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 *ConfigInfoURL) WithBasePath(bp string) *ConfigInfoURL {
+	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 *ConfigInfoURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *ConfigInfoURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/configs/{name}"
+
+	name := o.Name
+	if name != "" {
+		_path = strings.Replace(_path, "{name}", name, -1)
+	} else {
+		return nil, errors.New("name is required on ConfigInfoURL")
+	}
+
+	_basePath := o._basePath
+	_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 *ConfigInfoURL) 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 *ConfigInfoURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *ConfigInfoURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on ConfigInfoURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on ConfigInfoURL")
+	}
+
+	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 *ConfigInfoURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/group_info.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// GroupInfoHandlerFunc turns a function with the right signature into a group info handler
+type GroupInfoHandlerFunc func(GroupInfoParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn GroupInfoHandlerFunc) Handle(params GroupInfoParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// GroupInfoHandler interface for that can handle valid group info params
+type GroupInfoHandler interface {
+	Handle(GroupInfoParams, interface{}) middleware.Responder
+}
+
+// NewGroupInfo creates a new http.Handler for the group info operation
+func NewGroupInfo(ctx *middleware.Context, handler GroupInfoHandler) *GroupInfo {
+	return &GroupInfo{Context: ctx, Handler: handler}
+}
+
+/*GroupInfo swagger:route GET /api/v1/groups/{name} AdminAPI groupInfo
+
+Group info
+
+*/
+type GroupInfo struct {
+	Context *middleware.Context
+	Handler GroupInfoHandler
+}
+
+func (o *GroupInfo) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewGroupInfoParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/group_info_parameters.go

@@ -0,0 +1,89 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// NewGroupInfoParams creates a new GroupInfoParams object
+// no default values defined in spec.
+func NewGroupInfoParams() GroupInfoParams {
+
+	return GroupInfoParams{}
+}
+
+// GroupInfoParams contains all the bound params for the group info operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters GroupInfo
+type GroupInfoParams 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 NewGroupInfoParams() beforehand.
+func (o *GroupInfoParams) 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 *GroupInfoParams) 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
+}

restapi/operations/admin_api/group_info_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// GroupInfoOKCode is the HTTP code returned for type GroupInfoOK
+const GroupInfoOKCode int = 200
+
+/*GroupInfoOK A successful response.
+
+swagger:response groupInfoOK
+*/
+type GroupInfoOK struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Group `json:"body,omitempty"`
+}
+
+// NewGroupInfoOK creates GroupInfoOK with default headers values
+func NewGroupInfoOK() *GroupInfoOK {
+
+	return &GroupInfoOK{}
+}
+
+// WithPayload adds the payload to the group info o k response
+func (o *GroupInfoOK) WithPayload(payload *models.Group) *GroupInfoOK {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the group info o k response
+func (o *GroupInfoOK) SetPayload(payload *models.Group) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *GroupInfoOK) 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
+		}
+	}
+}
+
+/*GroupInfoDefault Generic error response.
+
+swagger:response groupInfoDefault
+*/
+type GroupInfoDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewGroupInfoDefault creates GroupInfoDefault with default headers values
+func NewGroupInfoDefault(code int) *GroupInfoDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &GroupInfoDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the group info default response
+func (o *GroupInfoDefault) WithStatusCode(code int) *GroupInfoDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the group info default response
+func (o *GroupInfoDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the group info default response
+func (o *GroupInfoDefault) WithPayload(payload *models.Error) *GroupInfoDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the group info default response
+func (o *GroupInfoDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *GroupInfoDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/group_info_urlbuilder.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// GroupInfoURL generates an URL for the group info operation
+type GroupInfoURL 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 *GroupInfoURL) WithBasePath(bp string) *GroupInfoURL {
+	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 *GroupInfoURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *GroupInfoURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/groups/{name}"
+
+	name := o.Name
+	if name != "" {
+		_path = strings.Replace(_path, "{name}", name, -1)
+	} else {
+		return nil, errors.New("name is required on GroupInfoURL")
+	}
+
+	_basePath := o._basePath
+	_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 *GroupInfoURL) 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 *GroupInfoURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *GroupInfoURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on GroupInfoURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on GroupInfoURL")
+	}
+
+	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 *GroupInfoURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/list_config.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// ListConfigHandlerFunc turns a function with the right signature into a list config handler
+type ListConfigHandlerFunc func(ListConfigParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn ListConfigHandlerFunc) Handle(params ListConfigParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// ListConfigHandler interface for that can handle valid list config params
+type ListConfigHandler interface {
+	Handle(ListConfigParams, interface{}) middleware.Responder
+}
+
+// NewListConfig creates a new http.Handler for the list config operation
+func NewListConfig(ctx *middleware.Context, handler ListConfigHandler) *ListConfig {
+	return &ListConfig{Context: ctx, Handler: handler}
+}
+
+/*ListConfig swagger:route GET /api/v1/configs AdminAPI listConfig
+
+List Configurations
+
+*/
+type ListConfig struct {
+	Context *middleware.Context
+	Handler ListConfigHandler
+}
+
+func (o *ListConfig) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewListConfigParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/list_config_parameters.go

@@ -0,0 +1,130 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+	"github.com/go-openapi/runtime/middleware"
+	"github.com/go-openapi/strfmt"
+	"github.com/go-openapi/swag"
+)
+
+// NewListConfigParams creates a new ListConfigParams object
+// no default values defined in spec.
+func NewListConfigParams() ListConfigParams {
+
+	return ListConfigParams{}
+}
+
+// ListConfigParams contains all the bound params for the list config operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters ListConfig
+type ListConfigParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+
+	/*
+	  In: query
+	*/
+	Limit *int32
+	/*
+	  In: query
+	*/
+	Offset *int32
+}
+
+// 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 NewListConfigParams() beforehand.
+func (o *ListConfigParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
+	var res []error
+
+	o.HTTPRequest = r
+
+	qs := runtime.Values(r.URL.Query())
+
+	qLimit, qhkLimit, _ := qs.GetOK("limit")
+	if err := o.bindLimit(qLimit, qhkLimit, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	qOffset, qhkOffset, _ := qs.GetOK("offset")
+	if err := o.bindOffset(qOffset, qhkOffset, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}
+
+// bindLimit binds and validates parameter Limit from query.
+func (o *ListConfigParams) bindLimit(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	value, err := swag.ConvertInt32(raw)
+	if err != nil {
+		return errors.InvalidType("limit", "query", "int32", raw)
+	}
+	o.Limit = &value
+
+	return nil
+}
+
+// bindOffset binds and validates parameter Offset from query.
+func (o *ListConfigParams) bindOffset(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	value, err := swag.ConvertInt32(raw)
+	if err != nil {
+		return errors.InvalidType("offset", "query", "int32", raw)
+	}
+	o.Offset = &value
+
+	return nil
+}

restapi/operations/admin_api/list_config_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// ListConfigOKCode is the HTTP code returned for type ListConfigOK
+const ListConfigOKCode int = 200
+
+/*ListConfigOK A successful response.
+
+swagger:response listConfigOK
+*/
+type ListConfigOK struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.ListConfigResponse `json:"body,omitempty"`
+}
+
+// NewListConfigOK creates ListConfigOK with default headers values
+func NewListConfigOK() *ListConfigOK {
+
+	return &ListConfigOK{}
+}
+
+// WithPayload adds the payload to the list config o k response
+func (o *ListConfigOK) WithPayload(payload *models.ListConfigResponse) *ListConfigOK {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the list config o k response
+func (o *ListConfigOK) SetPayload(payload *models.ListConfigResponse) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ListConfigOK) 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
+		}
+	}
+}
+
+/*ListConfigDefault Generic error response.
+
+swagger:response listConfigDefault
+*/
+type ListConfigDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewListConfigDefault creates ListConfigDefault with default headers values
+func NewListConfigDefault(code int) *ListConfigDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &ListConfigDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the list config default response
+func (o *ListConfigDefault) WithStatusCode(code int) *ListConfigDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the list config default response
+func (o *ListConfigDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the list config default response
+func (o *ListConfigDefault) WithPayload(payload *models.Error) *ListConfigDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the list config default response
+func (o *ListConfigDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ListConfigDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/list_config_urlbuilder.go

@@ -0,0 +1,128 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+
+	"github.com/go-openapi/swag"
+)
+
+// ListConfigURL generates an URL for the list config operation
+type ListConfigURL struct {
+	Limit  *int32
+	Offset *int32
+
+	_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 *ListConfigURL) WithBasePath(bp string) *ListConfigURL {
+	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 *ListConfigURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *ListConfigURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/configs"
+
+	_basePath := o._basePath
+	_result.Path = golangswaggerpaths.Join(_basePath, _path)
+
+	qs := make(url.Values)
+
+	var limitQ string
+	if o.Limit != nil {
+		limitQ = swag.FormatInt32(*o.Limit)
+	}
+	if limitQ != "" {
+		qs.Set("limit", limitQ)
+	}
+
+	var offsetQ string
+	if o.Offset != nil {
+		offsetQ = swag.FormatInt32(*o.Offset)
+	}
+	if offsetQ != "" {
+		qs.Set("offset", offsetQ)
+	}
+
+	_result.RawQuery = qs.Encode()
+
+	return &_result, nil
+}
+
+// Must is a helper function to panic when the url builder returns an error
+func (o *ListConfigURL) 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 *ListConfigURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *ListConfigURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on ListConfigURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on ListConfigURL")
+	}
+
+	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 *ListConfigURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/list_groups.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// ListGroupsHandlerFunc turns a function with the right signature into a list groups handler
+type ListGroupsHandlerFunc func(ListGroupsParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn ListGroupsHandlerFunc) Handle(params ListGroupsParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// ListGroupsHandler interface for that can handle valid list groups params
+type ListGroupsHandler interface {
+	Handle(ListGroupsParams, interface{}) middleware.Responder
+}
+
+// NewListGroups creates a new http.Handler for the list groups operation
+func NewListGroups(ctx *middleware.Context, handler ListGroupsHandler) *ListGroups {
+	return &ListGroups{Context: ctx, Handler: handler}
+}
+
+/*ListGroups swagger:route GET /api/v1/groups AdminAPI listGroups
+
+List Groups
+
+*/
+type ListGroups struct {
+	Context *middleware.Context
+	Handler ListGroupsHandler
+}
+
+func (o *ListGroups) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewListGroupsParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/list_groups_parameters.go

@@ -0,0 +1,130 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+	"github.com/go-openapi/runtime/middleware"
+	"github.com/go-openapi/strfmt"
+	"github.com/go-openapi/swag"
+)
+
+// NewListGroupsParams creates a new ListGroupsParams object
+// no default values defined in spec.
+func NewListGroupsParams() ListGroupsParams {
+
+	return ListGroupsParams{}
+}
+
+// ListGroupsParams contains all the bound params for the list groups operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters ListGroups
+type ListGroupsParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+
+	/*
+	  In: query
+	*/
+	Limit *int32
+	/*
+	  In: query
+	*/
+	Offset *int32
+}
+
+// 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 NewListGroupsParams() beforehand.
+func (o *ListGroupsParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
+	var res []error
+
+	o.HTTPRequest = r
+
+	qs := runtime.Values(r.URL.Query())
+
+	qLimit, qhkLimit, _ := qs.GetOK("limit")
+	if err := o.bindLimit(qLimit, qhkLimit, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	qOffset, qhkOffset, _ := qs.GetOK("offset")
+	if err := o.bindOffset(qOffset, qhkOffset, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}
+
+// bindLimit binds and validates parameter Limit from query.
+func (o *ListGroupsParams) bindLimit(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	value, err := swag.ConvertInt32(raw)
+	if err != nil {
+		return errors.InvalidType("limit", "query", "int32", raw)
+	}
+	o.Limit = &value
+
+	return nil
+}
+
+// bindOffset binds and validates parameter Offset from query.
+func (o *ListGroupsParams) bindOffset(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	value, err := swag.ConvertInt32(raw)
+	if err != nil {
+		return errors.InvalidType("offset", "query", "int32", raw)
+	}
+	o.Offset = &value
+
+	return nil
+}

restapi/operations/admin_api/list_groups_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// ListGroupsOKCode is the HTTP code returned for type ListGroupsOK
+const ListGroupsOKCode int = 200
+
+/*ListGroupsOK A successful response.
+
+swagger:response listGroupsOK
+*/
+type ListGroupsOK struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.ListGroupsResponse `json:"body,omitempty"`
+}
+
+// NewListGroupsOK creates ListGroupsOK with default headers values
+func NewListGroupsOK() *ListGroupsOK {
+
+	return &ListGroupsOK{}
+}
+
+// WithPayload adds the payload to the list groups o k response
+func (o *ListGroupsOK) WithPayload(payload *models.ListGroupsResponse) *ListGroupsOK {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the list groups o k response
+func (o *ListGroupsOK) SetPayload(payload *models.ListGroupsResponse) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ListGroupsOK) 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
+		}
+	}
+}
+
+/*ListGroupsDefault Generic error response.
+
+swagger:response listGroupsDefault
+*/
+type ListGroupsDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewListGroupsDefault creates ListGroupsDefault with default headers values
+func NewListGroupsDefault(code int) *ListGroupsDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &ListGroupsDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the list groups default response
+func (o *ListGroupsDefault) WithStatusCode(code int) *ListGroupsDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the list groups default response
+func (o *ListGroupsDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the list groups default response
+func (o *ListGroupsDefault) WithPayload(payload *models.Error) *ListGroupsDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the list groups default response
+func (o *ListGroupsDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ListGroupsDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/list_groups_urlbuilder.go

@@ -0,0 +1,128 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+
+	"github.com/go-openapi/swag"
+)
+
+// ListGroupsURL generates an URL for the list groups operation
+type ListGroupsURL struct {
+	Limit  *int32
+	Offset *int32
+
+	_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 *ListGroupsURL) WithBasePath(bp string) *ListGroupsURL {
+	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 *ListGroupsURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *ListGroupsURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/groups"
+
+	_basePath := o._basePath
+	_result.Path = golangswaggerpaths.Join(_basePath, _path)
+
+	qs := make(url.Values)
+
+	var limitQ string
+	if o.Limit != nil {
+		limitQ = swag.FormatInt32(*o.Limit)
+	}
+	if limitQ != "" {
+		qs.Set("limit", limitQ)
+	}
+
+	var offsetQ string
+	if o.Offset != nil {
+		offsetQ = swag.FormatInt32(*o.Offset)
+	}
+	if offsetQ != "" {
+		qs.Set("offset", offsetQ)
+	}
+
+	_result.RawQuery = qs.Encode()
+
+	return &_result, nil
+}
+
+// Must is a helper function to panic when the url builder returns an error
+func (o *ListGroupsURL) 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 *ListGroupsURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *ListGroupsURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on ListGroupsURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on ListGroupsURL")
+	}
+
+	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 *ListGroupsURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/list_policies.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// ListPoliciesHandlerFunc turns a function with the right signature into a list policies handler
+type ListPoliciesHandlerFunc func(ListPoliciesParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn ListPoliciesHandlerFunc) Handle(params ListPoliciesParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// ListPoliciesHandler interface for that can handle valid list policies params
+type ListPoliciesHandler interface {
+	Handle(ListPoliciesParams, interface{}) middleware.Responder
+}
+
+// NewListPolicies creates a new http.Handler for the list policies operation
+func NewListPolicies(ctx *middleware.Context, handler ListPoliciesHandler) *ListPolicies {
+	return &ListPolicies{Context: ctx, Handler: handler}
+}
+
+/*ListPolicies swagger:route GET /api/v1/policies AdminAPI listPolicies
+
+List Policies
+
+*/
+type ListPolicies struct {
+	Context *middleware.Context
+	Handler ListPoliciesHandler
+}
+
+func (o *ListPolicies) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewListPoliciesParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/list_policies_parameters.go

@@ -0,0 +1,130 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+	"github.com/go-openapi/runtime/middleware"
+	"github.com/go-openapi/strfmt"
+	"github.com/go-openapi/swag"
+)
+
+// NewListPoliciesParams creates a new ListPoliciesParams object
+// no default values defined in spec.
+func NewListPoliciesParams() ListPoliciesParams {
+
+	return ListPoliciesParams{}
+}
+
+// ListPoliciesParams contains all the bound params for the list policies operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters ListPolicies
+type ListPoliciesParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+
+	/*
+	  In: query
+	*/
+	Limit *int32
+	/*
+	  In: query
+	*/
+	Offset *int32
+}
+
+// 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 NewListPoliciesParams() beforehand.
+func (o *ListPoliciesParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
+	var res []error
+
+	o.HTTPRequest = r
+
+	qs := runtime.Values(r.URL.Query())
+
+	qLimit, qhkLimit, _ := qs.GetOK("limit")
+	if err := o.bindLimit(qLimit, qhkLimit, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	qOffset, qhkOffset, _ := qs.GetOK("offset")
+	if err := o.bindOffset(qOffset, qhkOffset, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}
+
+// bindLimit binds and validates parameter Limit from query.
+func (o *ListPoliciesParams) bindLimit(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	value, err := swag.ConvertInt32(raw)
+	if err != nil {
+		return errors.InvalidType("limit", "query", "int32", raw)
+	}
+	o.Limit = &value
+
+	return nil
+}
+
+// bindOffset binds and validates parameter Offset from query.
+func (o *ListPoliciesParams) bindOffset(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	value, err := swag.ConvertInt32(raw)
+	if err != nil {
+		return errors.InvalidType("offset", "query", "int32", raw)
+	}
+	o.Offset = &value
+
+	return nil
+}

restapi/operations/admin_api/list_policies_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// ListPoliciesOKCode is the HTTP code returned for type ListPoliciesOK
+const ListPoliciesOKCode int = 200
+
+/*ListPoliciesOK A successful response.
+
+swagger:response listPoliciesOK
+*/
+type ListPoliciesOK struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.ListPoliciesResponse `json:"body,omitempty"`
+}
+
+// NewListPoliciesOK creates ListPoliciesOK with default headers values
+func NewListPoliciesOK() *ListPoliciesOK {
+
+	return &ListPoliciesOK{}
+}
+
+// WithPayload adds the payload to the list policies o k response
+func (o *ListPoliciesOK) WithPayload(payload *models.ListPoliciesResponse) *ListPoliciesOK {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the list policies o k response
+func (o *ListPoliciesOK) SetPayload(payload *models.ListPoliciesResponse) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ListPoliciesOK) 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
+		}
+	}
+}
+
+/*ListPoliciesDefault Generic error response.
+
+swagger:response listPoliciesDefault
+*/
+type ListPoliciesDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewListPoliciesDefault creates ListPoliciesDefault with default headers values
+func NewListPoliciesDefault(code int) *ListPoliciesDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &ListPoliciesDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the list policies default response
+func (o *ListPoliciesDefault) WithStatusCode(code int) *ListPoliciesDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the list policies default response
+func (o *ListPoliciesDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the list policies default response
+func (o *ListPoliciesDefault) WithPayload(payload *models.Error) *ListPoliciesDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the list policies default response
+func (o *ListPoliciesDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ListPoliciesDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/list_policies_urlbuilder.go

@@ -0,0 +1,128 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+
+	"github.com/go-openapi/swag"
+)
+
+// ListPoliciesURL generates an URL for the list policies operation
+type ListPoliciesURL struct {
+	Limit  *int32
+	Offset *int32
+
+	_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 *ListPoliciesURL) WithBasePath(bp string) *ListPoliciesURL {
+	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 *ListPoliciesURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *ListPoliciesURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/policies"
+
+	_basePath := o._basePath
+	_result.Path = golangswaggerpaths.Join(_basePath, _path)
+
+	qs := make(url.Values)
+
+	var limitQ string
+	if o.Limit != nil {
+		limitQ = swag.FormatInt32(*o.Limit)
+	}
+	if limitQ != "" {
+		qs.Set("limit", limitQ)
+	}
+
+	var offsetQ string
+	if o.Offset != nil {
+		offsetQ = swag.FormatInt32(*o.Offset)
+	}
+	if offsetQ != "" {
+		qs.Set("offset", offsetQ)
+	}
+
+	_result.RawQuery = qs.Encode()
+
+	return &_result, nil
+}
+
+// Must is a helper function to panic when the url builder returns an error
+func (o *ListPoliciesURL) 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 *ListPoliciesURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *ListPoliciesURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on ListPoliciesURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on ListPoliciesURL")
+	}
+
+	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 *ListPoliciesURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/list_users.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// ListUsersHandlerFunc turns a function with the right signature into a list users handler
+type ListUsersHandlerFunc func(ListUsersParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn ListUsersHandlerFunc) Handle(params ListUsersParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// ListUsersHandler interface for that can handle valid list users params
+type ListUsersHandler interface {
+	Handle(ListUsersParams, interface{}) middleware.Responder
+}
+
+// NewListUsers creates a new http.Handler for the list users operation
+func NewListUsers(ctx *middleware.Context, handler ListUsersHandler) *ListUsers {
+	return &ListUsers{Context: ctx, Handler: handler}
+}
+
+/*ListUsers swagger:route GET /api/v1/users AdminAPI listUsers
+
+List Users
+
+*/
+type ListUsers struct {
+	Context *middleware.Context
+	Handler ListUsersHandler
+}
+
+func (o *ListUsers) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewListUsersParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/list_users_parameters.go

@@ -0,0 +1,130 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+	"github.com/go-openapi/runtime/middleware"
+	"github.com/go-openapi/strfmt"
+	"github.com/go-openapi/swag"
+)
+
+// NewListUsersParams creates a new ListUsersParams object
+// no default values defined in spec.
+func NewListUsersParams() ListUsersParams {
+
+	return ListUsersParams{}
+}
+
+// ListUsersParams contains all the bound params for the list users operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters ListUsers
+type ListUsersParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+
+	/*
+	  In: query
+	*/
+	Limit *int32
+	/*
+	  In: query
+	*/
+	Offset *int32
+}
+
+// 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 NewListUsersParams() beforehand.
+func (o *ListUsersParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
+	var res []error
+
+	o.HTTPRequest = r
+
+	qs := runtime.Values(r.URL.Query())
+
+	qLimit, qhkLimit, _ := qs.GetOK("limit")
+	if err := o.bindLimit(qLimit, qhkLimit, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	qOffset, qhkOffset, _ := qs.GetOK("offset")
+	if err := o.bindOffset(qOffset, qhkOffset, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}
+
+// bindLimit binds and validates parameter Limit from query.
+func (o *ListUsersParams) bindLimit(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	value, err := swag.ConvertInt32(raw)
+	if err != nil {
+		return errors.InvalidType("limit", "query", "int32", raw)
+	}
+	o.Limit = &value
+
+	return nil
+}
+
+// bindOffset binds and validates parameter Offset from query.
+func (o *ListUsersParams) bindOffset(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	value, err := swag.ConvertInt32(raw)
+	if err != nil {
+		return errors.InvalidType("offset", "query", "int32", raw)
+	}
+	o.Offset = &value
+
+	return nil
+}

restapi/operations/admin_api/list_users_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// ListUsersOKCode is the HTTP code returned for type ListUsersOK
+const ListUsersOKCode int = 200
+
+/*ListUsersOK A successful response.
+
+swagger:response listUsersOK
+*/
+type ListUsersOK struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.ListUsersResponse `json:"body,omitempty"`
+}
+
+// NewListUsersOK creates ListUsersOK with default headers values
+func NewListUsersOK() *ListUsersOK {
+
+	return &ListUsersOK{}
+}
+
+// WithPayload adds the payload to the list users o k response
+func (o *ListUsersOK) WithPayload(payload *models.ListUsersResponse) *ListUsersOK {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the list users o k response
+func (o *ListUsersOK) SetPayload(payload *models.ListUsersResponse) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ListUsersOK) 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
+		}
+	}
+}
+
+/*ListUsersDefault Generic error response.
+
+swagger:response listUsersDefault
+*/
+type ListUsersDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewListUsersDefault creates ListUsersDefault with default headers values
+func NewListUsersDefault(code int) *ListUsersDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &ListUsersDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the list users default response
+func (o *ListUsersDefault) WithStatusCode(code int) *ListUsersDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the list users default response
+func (o *ListUsersDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the list users default response
+func (o *ListUsersDefault) WithPayload(payload *models.Error) *ListUsersDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the list users default response
+func (o *ListUsersDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ListUsersDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/list_users_urlbuilder.go

@@ -0,0 +1,128 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+
+	"github.com/go-openapi/swag"
+)
+
+// ListUsersURL generates an URL for the list users operation
+type ListUsersURL struct {
+	Limit  *int32
+	Offset *int32
+
+	_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 *ListUsersURL) WithBasePath(bp string) *ListUsersURL {
+	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 *ListUsersURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *ListUsersURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/users"
+
+	_basePath := o._basePath
+	_result.Path = golangswaggerpaths.Join(_basePath, _path)
+
+	qs := make(url.Values)
+
+	var limitQ string
+	if o.Limit != nil {
+		limitQ = swag.FormatInt32(*o.Limit)
+	}
+	if limitQ != "" {
+		qs.Set("limit", limitQ)
+	}
+
+	var offsetQ string
+	if o.Offset != nil {
+		offsetQ = swag.FormatInt32(*o.Offset)
+	}
+	if offsetQ != "" {
+		qs.Set("offset", offsetQ)
+	}
+
+	_result.RawQuery = qs.Encode()
+
+	return &_result, nil
+}
+
+// Must is a helper function to panic when the url builder returns an error
+func (o *ListUsersURL) 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 *ListUsersURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *ListUsersURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on ListUsersURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on ListUsersURL")
+	}
+
+	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 *ListUsersURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/policy_info.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// PolicyInfoHandlerFunc turns a function with the right signature into a policy info handler
+type PolicyInfoHandlerFunc func(PolicyInfoParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn PolicyInfoHandlerFunc) Handle(params PolicyInfoParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// PolicyInfoHandler interface for that can handle valid policy info params
+type PolicyInfoHandler interface {
+	Handle(PolicyInfoParams, interface{}) middleware.Responder
+}
+
+// NewPolicyInfo creates a new http.Handler for the policy info operation
+func NewPolicyInfo(ctx *middleware.Context, handler PolicyInfoHandler) *PolicyInfo {
+	return &PolicyInfo{Context: ctx, Handler: handler}
+}
+
+/*PolicyInfo swagger:route GET /api/v1/policies/{name} AdminAPI policyInfo
+
+Policy info
+
+*/
+type PolicyInfo struct {
+	Context *middleware.Context
+	Handler PolicyInfoHandler
+}
+
+func (o *PolicyInfo) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewPolicyInfoParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/policy_info_parameters.go

@@ -0,0 +1,89 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// NewPolicyInfoParams creates a new PolicyInfoParams object
+// no default values defined in spec.
+func NewPolicyInfoParams() PolicyInfoParams {
+
+	return PolicyInfoParams{}
+}
+
+// PolicyInfoParams contains all the bound params for the policy info operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters PolicyInfo
+type PolicyInfoParams 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 NewPolicyInfoParams() beforehand.
+func (o *PolicyInfoParams) 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 *PolicyInfoParams) 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
+}

restapi/operations/admin_api/policy_info_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// PolicyInfoOKCode is the HTTP code returned for type PolicyInfoOK
+const PolicyInfoOKCode int = 200
+
+/*PolicyInfoOK A successful response.
+
+swagger:response policyInfoOK
+*/
+type PolicyInfoOK struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Policy `json:"body,omitempty"`
+}
+
+// NewPolicyInfoOK creates PolicyInfoOK with default headers values
+func NewPolicyInfoOK() *PolicyInfoOK {
+
+	return &PolicyInfoOK{}
+}
+
+// WithPayload adds the payload to the policy info o k response
+func (o *PolicyInfoOK) WithPayload(payload *models.Policy) *PolicyInfoOK {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the policy info o k response
+func (o *PolicyInfoOK) SetPayload(payload *models.Policy) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *PolicyInfoOK) 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
+		}
+	}
+}
+
+/*PolicyInfoDefault Generic error response.
+
+swagger:response policyInfoDefault
+*/
+type PolicyInfoDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewPolicyInfoDefault creates PolicyInfoDefault with default headers values
+func NewPolicyInfoDefault(code int) *PolicyInfoDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &PolicyInfoDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the policy info default response
+func (o *PolicyInfoDefault) WithStatusCode(code int) *PolicyInfoDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the policy info default response
+func (o *PolicyInfoDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the policy info default response
+func (o *PolicyInfoDefault) WithPayload(payload *models.Error) *PolicyInfoDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the policy info default response
+func (o *PolicyInfoDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *PolicyInfoDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/policy_info_urlbuilder.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// PolicyInfoURL generates an URL for the policy info operation
+type PolicyInfoURL 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 *PolicyInfoURL) WithBasePath(bp string) *PolicyInfoURL {
+	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 *PolicyInfoURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *PolicyInfoURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/policies/{name}"
+
+	name := o.Name
+	if name != "" {
+		_path = strings.Replace(_path, "{name}", name, -1)
+	} else {
+		return nil, errors.New("name is required on PolicyInfoURL")
+	}
+
+	_basePath := o._basePath
+	_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 *PolicyInfoURL) 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 *PolicyInfoURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *PolicyInfoURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on PolicyInfoURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on PolicyInfoURL")
+	}
+
+	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 *PolicyInfoURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/remove_group.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// RemoveGroupHandlerFunc turns a function with the right signature into a remove group handler
+type RemoveGroupHandlerFunc func(RemoveGroupParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn RemoveGroupHandlerFunc) Handle(params RemoveGroupParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// RemoveGroupHandler interface for that can handle valid remove group params
+type RemoveGroupHandler interface {
+	Handle(RemoveGroupParams, interface{}) middleware.Responder
+}
+
+// NewRemoveGroup creates a new http.Handler for the remove group operation
+func NewRemoveGroup(ctx *middleware.Context, handler RemoveGroupHandler) *RemoveGroup {
+	return &RemoveGroup{Context: ctx, Handler: handler}
+}
+
+/*RemoveGroup swagger:route DELETE /api/v1/groups/{name} AdminAPI removeGroup
+
+Remove group
+
+*/
+type RemoveGroup struct {
+	Context *middleware.Context
+	Handler RemoveGroupHandler
+}
+
+func (o *RemoveGroup) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewRemoveGroupParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/remove_group_parameters.go

@@ -0,0 +1,89 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// NewRemoveGroupParams creates a new RemoveGroupParams object
+// no default values defined in spec.
+func NewRemoveGroupParams() RemoveGroupParams {
+
+	return RemoveGroupParams{}
+}
+
+// RemoveGroupParams contains all the bound params for the remove group operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters RemoveGroup
+type RemoveGroupParams 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 NewRemoveGroupParams() beforehand.
+func (o *RemoveGroupParams) 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 *RemoveGroupParams) 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
+}

restapi/operations/admin_api/remove_group_responses.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// RemoveGroupNoContentCode is the HTTP code returned for type RemoveGroupNoContent
+const RemoveGroupNoContentCode int = 204
+
+/*RemoveGroupNoContent A successful response.
+
+swagger:response removeGroupNoContent
+*/
+type RemoveGroupNoContent struct {
+}
+
+// NewRemoveGroupNoContent creates RemoveGroupNoContent with default headers values
+func NewRemoveGroupNoContent() *RemoveGroupNoContent {
+
+	return &RemoveGroupNoContent{}
+}
+
+// WriteResponse to the client
+func (o *RemoveGroupNoContent) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+	rw.WriteHeader(204)
+}
+
+/*RemoveGroupDefault Generic error response.
+
+swagger:response removeGroupDefault
+*/
+type RemoveGroupDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewRemoveGroupDefault creates RemoveGroupDefault with default headers values
+func NewRemoveGroupDefault(code int) *RemoveGroupDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &RemoveGroupDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the remove group default response
+func (o *RemoveGroupDefault) WithStatusCode(code int) *RemoveGroupDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the remove group default response
+func (o *RemoveGroupDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the remove group default response
+func (o *RemoveGroupDefault) WithPayload(payload *models.Error) *RemoveGroupDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the remove group default response
+func (o *RemoveGroupDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *RemoveGroupDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/remove_group_urlbuilder.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// RemoveGroupURL generates an URL for the remove group operation
+type RemoveGroupURL 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 *RemoveGroupURL) WithBasePath(bp string) *RemoveGroupURL {
+	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 *RemoveGroupURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *RemoveGroupURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/groups/{name}"
+
+	name := o.Name
+	if name != "" {
+		_path = strings.Replace(_path, "{name}", name, -1)
+	} else {
+		return nil, errors.New("name is required on RemoveGroupURL")
+	}
+
+	_basePath := o._basePath
+	_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 *RemoveGroupURL) 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 *RemoveGroupURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *RemoveGroupURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on RemoveGroupURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on RemoveGroupURL")
+	}
+
+	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 *RemoveGroupURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/remove_policy.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// RemovePolicyHandlerFunc turns a function with the right signature into a remove policy handler
+type RemovePolicyHandlerFunc func(RemovePolicyParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn RemovePolicyHandlerFunc) Handle(params RemovePolicyParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// RemovePolicyHandler interface for that can handle valid remove policy params
+type RemovePolicyHandler interface {
+	Handle(RemovePolicyParams, interface{}) middleware.Responder
+}
+
+// NewRemovePolicy creates a new http.Handler for the remove policy operation
+func NewRemovePolicy(ctx *middleware.Context, handler RemovePolicyHandler) *RemovePolicy {
+	return &RemovePolicy{Context: ctx, Handler: handler}
+}
+
+/*RemovePolicy swagger:route DELETE /api/v1/policies/{name} AdminAPI removePolicy
+
+Remove policy
+
+*/
+type RemovePolicy struct {
+	Context *middleware.Context
+	Handler RemovePolicyHandler
+}
+
+func (o *RemovePolicy) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewRemovePolicyParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/remove_policy_parameters.go

@@ -0,0 +1,89 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// NewRemovePolicyParams creates a new RemovePolicyParams object
+// no default values defined in spec.
+func NewRemovePolicyParams() RemovePolicyParams {
+
+	return RemovePolicyParams{}
+}
+
+// RemovePolicyParams contains all the bound params for the remove policy operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters RemovePolicy
+type RemovePolicyParams 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 NewRemovePolicyParams() beforehand.
+func (o *RemovePolicyParams) 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 *RemovePolicyParams) 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
+}

restapi/operations/admin_api/remove_policy_responses.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// RemovePolicyNoContentCode is the HTTP code returned for type RemovePolicyNoContent
+const RemovePolicyNoContentCode int = 204
+
+/*RemovePolicyNoContent A successful response.
+
+swagger:response removePolicyNoContent
+*/
+type RemovePolicyNoContent struct {
+}
+
+// NewRemovePolicyNoContent creates RemovePolicyNoContent with default headers values
+func NewRemovePolicyNoContent() *RemovePolicyNoContent {
+
+	return &RemovePolicyNoContent{}
+}
+
+// WriteResponse to the client
+func (o *RemovePolicyNoContent) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+	rw.WriteHeader(204)
+}
+
+/*RemovePolicyDefault Generic error response.
+
+swagger:response removePolicyDefault
+*/
+type RemovePolicyDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewRemovePolicyDefault creates RemovePolicyDefault with default headers values
+func NewRemovePolicyDefault(code int) *RemovePolicyDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &RemovePolicyDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the remove policy default response
+func (o *RemovePolicyDefault) WithStatusCode(code int) *RemovePolicyDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the remove policy default response
+func (o *RemovePolicyDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the remove policy default response
+func (o *RemovePolicyDefault) WithPayload(payload *models.Error) *RemovePolicyDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the remove policy default response
+func (o *RemovePolicyDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *RemovePolicyDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/remove_policy_urlbuilder.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// RemovePolicyURL generates an URL for the remove policy operation
+type RemovePolicyURL 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 *RemovePolicyURL) WithBasePath(bp string) *RemovePolicyURL {
+	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 *RemovePolicyURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *RemovePolicyURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/policies/{name}"
+
+	name := o.Name
+	if name != "" {
+		_path = strings.Replace(_path, "{name}", name, -1)
+	} else {
+		return nil, errors.New("name is required on RemovePolicyURL")
+	}
+
+	_basePath := o._basePath
+	_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 *RemovePolicyURL) 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 *RemovePolicyURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *RemovePolicyURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on RemovePolicyURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on RemovePolicyURL")
+	}
+
+	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 *RemovePolicyURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/restart_service.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// RestartServiceHandlerFunc turns a function with the right signature into a restart service handler
+type RestartServiceHandlerFunc func(RestartServiceParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn RestartServiceHandlerFunc) Handle(params RestartServiceParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// RestartServiceHandler interface for that can handle valid restart service params
+type RestartServiceHandler interface {
+	Handle(RestartServiceParams, interface{}) middleware.Responder
+}
+
+// NewRestartService creates a new http.Handler for the restart service operation
+func NewRestartService(ctx *middleware.Context, handler RestartServiceHandler) *RestartService {
+	return &RestartService{Context: ctx, Handler: handler}
+}
+
+/*RestartService swagger:route POST /api/v1/service/restart AdminAPI restartService
+
+Restart Service
+
+*/
+type RestartService struct {
+	Context *middleware.Context
+	Handler RestartServiceHandler
+}
+
+func (o *RestartService) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewRestartServiceParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/restart_service_parameters.go

@@ -0,0 +1,62 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// NewRestartServiceParams creates a new RestartServiceParams object
+// no default values defined in spec.
+func NewRestartServiceParams() RestartServiceParams {
+
+	return RestartServiceParams{}
+}
+
+// RestartServiceParams contains all the bound params for the restart service operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters RestartService
+type RestartServiceParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+}
+
+// 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 NewRestartServiceParams() beforehand.
+func (o *RestartServiceParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
+	var res []error
+
+	o.HTTPRequest = r
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}

restapi/operations/admin_api/restart_service_responses.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// RestartServiceNoContentCode is the HTTP code returned for type RestartServiceNoContent
+const RestartServiceNoContentCode int = 204
+
+/*RestartServiceNoContent A successful response.
+
+swagger:response restartServiceNoContent
+*/
+type RestartServiceNoContent struct {
+}
+
+// NewRestartServiceNoContent creates RestartServiceNoContent with default headers values
+func NewRestartServiceNoContent() *RestartServiceNoContent {
+
+	return &RestartServiceNoContent{}
+}
+
+// WriteResponse to the client
+func (o *RestartServiceNoContent) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+	rw.WriteHeader(204)
+}
+
+/*RestartServiceDefault Generic error response.
+
+swagger:response restartServiceDefault
+*/
+type RestartServiceDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewRestartServiceDefault creates RestartServiceDefault with default headers values
+func NewRestartServiceDefault(code int) *RestartServiceDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &RestartServiceDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the restart service default response
+func (o *RestartServiceDefault) WithStatusCode(code int) *RestartServiceDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the restart service default response
+func (o *RestartServiceDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the restart service default response
+func (o *RestartServiceDefault) WithPayload(payload *models.Error) *RestartServiceDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the restart service default response
+func (o *RestartServiceDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *RestartServiceDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/restart_service_urlbuilder.go

@@ -0,0 +1,101 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// RestartServiceURL generates an URL for the restart service operation
+type RestartServiceURL 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 *RestartServiceURL) WithBasePath(bp string) *RestartServiceURL {
+	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 *RestartServiceURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *RestartServiceURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/service/restart"
+
+	_basePath := o._basePath
+	_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 *RestartServiceURL) 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 *RestartServiceURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *RestartServiceURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on RestartServiceURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on RestartServiceURL")
+	}
+
+	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 *RestartServiceURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/set_config.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// SetConfigHandlerFunc turns a function with the right signature into a set config handler
+type SetConfigHandlerFunc func(SetConfigParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn SetConfigHandlerFunc) Handle(params SetConfigParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// SetConfigHandler interface for that can handle valid set config params
+type SetConfigHandler interface {
+	Handle(SetConfigParams, interface{}) middleware.Responder
+}
+
+// NewSetConfig creates a new http.Handler for the set config operation
+func NewSetConfig(ctx *middleware.Context, handler SetConfigHandler) *SetConfig {
+	return &SetConfig{Context: ctx, Handler: handler}
+}
+
+/*SetConfig swagger:route PUT /api/v1/configs/{name} AdminAPI setConfig
+
+Set Configuration
+
+*/
+type SetConfig struct {
+	Context *middleware.Context
+	Handler SetConfigHandler
+}
+
+func (o *SetConfig) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewSetConfigParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/set_config_parameters.go

@@ -0,0 +1,120 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/minio/m3/mcs/models"
+)
+
+// NewSetConfigParams creates a new SetConfigParams object
+// no default values defined in spec.
+func NewSetConfigParams() SetConfigParams {
+
+	return SetConfigParams{}
+}
+
+// SetConfigParams contains all the bound params for the set config operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters SetConfig
+type SetConfigParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+
+	/*
+	  Required: true
+	  In: body
+	*/
+	Body *models.SetConfigRequest
+	/*
+	  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 NewSetConfigParams() beforehand.
+func (o *SetConfigParams) 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.SetConfigRequest
+		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)
+			}
+
+			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 *SetConfigParams) 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
+}

restapi/operations/admin_api/set_config_responses.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// SetConfigNoContentCode is the HTTP code returned for type SetConfigNoContent
+const SetConfigNoContentCode int = 204
+
+/*SetConfigNoContent A successful response.
+
+swagger:response setConfigNoContent
+*/
+type SetConfigNoContent struct {
+}
+
+// NewSetConfigNoContent creates SetConfigNoContent with default headers values
+func NewSetConfigNoContent() *SetConfigNoContent {
+
+	return &SetConfigNoContent{}
+}
+
+// WriteResponse to the client
+func (o *SetConfigNoContent) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+	rw.WriteHeader(204)
+}
+
+/*SetConfigDefault Generic error response.
+
+swagger:response setConfigDefault
+*/
+type SetConfigDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewSetConfigDefault creates SetConfigDefault with default headers values
+func NewSetConfigDefault(code int) *SetConfigDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &SetConfigDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the set config default response
+func (o *SetConfigDefault) WithStatusCode(code int) *SetConfigDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the set config default response
+func (o *SetConfigDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the set config default response
+func (o *SetConfigDefault) WithPayload(payload *models.Error) *SetConfigDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the set config default response
+func (o *SetConfigDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *SetConfigDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/set_config_urlbuilder.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// SetConfigURL generates an URL for the set config operation
+type SetConfigURL 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 *SetConfigURL) WithBasePath(bp string) *SetConfigURL {
+	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 *SetConfigURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *SetConfigURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/configs/{name}"
+
+	name := o.Name
+	if name != "" {
+		_path = strings.Replace(_path, "{name}", name, -1)
+	} else {
+		return nil, errors.New("name is required on SetConfigURL")
+	}
+
+	_basePath := o._basePath
+	_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 *SetConfigURL) 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 *SetConfigURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *SetConfigURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on SetConfigURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on SetConfigURL")
+	}
+
+	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 *SetConfigURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/set_policy.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// SetPolicyHandlerFunc turns a function with the right signature into a set policy handler
+type SetPolicyHandlerFunc func(SetPolicyParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn SetPolicyHandlerFunc) Handle(params SetPolicyParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// SetPolicyHandler interface for that can handle valid set policy params
+type SetPolicyHandler interface {
+	Handle(SetPolicyParams, interface{}) middleware.Responder
+}
+
+// NewSetPolicy creates a new http.Handler for the set policy operation
+func NewSetPolicy(ctx *middleware.Context, handler SetPolicyHandler) *SetPolicy {
+	return &SetPolicy{Context: ctx, Handler: handler}
+}
+
+/*SetPolicy swagger:route PUT /api/v1/set-policy/{name} AdminAPI setPolicy
+
+Set policy
+
+*/
+type SetPolicy struct {
+	Context *middleware.Context
+	Handler SetPolicyHandler
+}
+
+func (o *SetPolicy) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewSetPolicyParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/set_policy_parameters.go

@@ -0,0 +1,120 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/minio/m3/mcs/models"
+)
+
+// NewSetPolicyParams creates a new SetPolicyParams object
+// no default values defined in spec.
+func NewSetPolicyParams() SetPolicyParams {
+
+	return SetPolicyParams{}
+}
+
+// SetPolicyParams contains all the bound params for the set policy operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters SetPolicy
+type SetPolicyParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+
+	/*
+	  Required: true
+	  In: body
+	*/
+	Body *models.SetPolicyRequest
+	/*
+	  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 NewSetPolicyParams() beforehand.
+func (o *SetPolicyParams) 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.SetPolicyRequest
+		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)
+			}
+
+			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 *SetPolicyParams) 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
+}

restapi/operations/admin_api/set_policy_responses.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// SetPolicyNoContentCode is the HTTP code returned for type SetPolicyNoContent
+const SetPolicyNoContentCode int = 204
+
+/*SetPolicyNoContent A successful response.
+
+swagger:response setPolicyNoContent
+*/
+type SetPolicyNoContent struct {
+}
+
+// NewSetPolicyNoContent creates SetPolicyNoContent with default headers values
+func NewSetPolicyNoContent() *SetPolicyNoContent {
+
+	return &SetPolicyNoContent{}
+}
+
+// WriteResponse to the client
+func (o *SetPolicyNoContent) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
+
+	rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses
+
+	rw.WriteHeader(204)
+}
+
+/*SetPolicyDefault Generic error response.
+
+swagger:response setPolicyDefault
+*/
+type SetPolicyDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewSetPolicyDefault creates SetPolicyDefault with default headers values
+func NewSetPolicyDefault(code int) *SetPolicyDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &SetPolicyDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the set policy default response
+func (o *SetPolicyDefault) WithStatusCode(code int) *SetPolicyDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the set policy default response
+func (o *SetPolicyDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the set policy default response
+func (o *SetPolicyDefault) WithPayload(payload *models.Error) *SetPolicyDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the set policy default response
+func (o *SetPolicyDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *SetPolicyDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/set_policy_urlbuilder.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// SetPolicyURL generates an URL for the set policy operation
+type SetPolicyURL 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 *SetPolicyURL) WithBasePath(bp string) *SetPolicyURL {
+	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 *SetPolicyURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *SetPolicyURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/set-policy/{name}"
+
+	name := o.Name
+	if name != "" {
+		_path = strings.Replace(_path, "{name}", name, -1)
+	} else {
+		return nil, errors.New("name is required on SetPolicyURL")
+	}
+
+	_basePath := o._basePath
+	_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 *SetPolicyURL) 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 *SetPolicyURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *SetPolicyURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on SetPolicyURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on SetPolicyURL")
+	}
+
+	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 *SetPolicyURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/admin_api/update_group.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// UpdateGroupHandlerFunc turns a function with the right signature into a update group handler
+type UpdateGroupHandlerFunc func(UpdateGroupParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn UpdateGroupHandlerFunc) Handle(params UpdateGroupParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// UpdateGroupHandler interface for that can handle valid update group params
+type UpdateGroupHandler interface {
+	Handle(UpdateGroupParams, interface{}) middleware.Responder
+}
+
+// NewUpdateGroup creates a new http.Handler for the update group operation
+func NewUpdateGroup(ctx *middleware.Context, handler UpdateGroupHandler) *UpdateGroup {
+	return &UpdateGroup{Context: ctx, Handler: handler}
+}
+
+/*UpdateGroup swagger:route PUT /api/v1/groups/{name} AdminAPI updateGroup
+
+Update Group Members or Status
+
+*/
+type UpdateGroup struct {
+	Context *middleware.Context
+	Handler UpdateGroupHandler
+}
+
+func (o *UpdateGroup) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewUpdateGroupParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/admin_api/update_group_parameters.go

@@ -0,0 +1,120 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/minio/m3/mcs/models"
+)
+
+// NewUpdateGroupParams creates a new UpdateGroupParams object
+// no default values defined in spec.
+func NewUpdateGroupParams() UpdateGroupParams {
+
+	return UpdateGroupParams{}
+}
+
+// UpdateGroupParams contains all the bound params for the update group operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters UpdateGroup
+type UpdateGroupParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+
+	/*
+	  Required: true
+	  In: body
+	*/
+	Body *models.UpdateGroupRequest
+	/*
+	  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 NewUpdateGroupParams() beforehand.
+func (o *UpdateGroupParams) 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.UpdateGroupRequest
+		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)
+			}
+
+			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 *UpdateGroupParams) 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
+}

restapi/operations/admin_api/update_group_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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/m3/mcs/models"
+)
+
+// UpdateGroupOKCode is the HTTP code returned for type UpdateGroupOK
+const UpdateGroupOKCode int = 200
+
+/*UpdateGroupOK A successful response.
+
+swagger:response updateGroupOK
+*/
+type UpdateGroupOK struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Group `json:"body,omitempty"`
+}
+
+// NewUpdateGroupOK creates UpdateGroupOK with default headers values
+func NewUpdateGroupOK() *UpdateGroupOK {
+
+	return &UpdateGroupOK{}
+}
+
+// WithPayload adds the payload to the update group o k response
+func (o *UpdateGroupOK) WithPayload(payload *models.Group) *UpdateGroupOK {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the update group o k response
+func (o *UpdateGroupOK) SetPayload(payload *models.Group) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *UpdateGroupOK) 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
+		}
+	}
+}
+
+/*UpdateGroupDefault Generic error response.
+
+swagger:response updateGroupDefault
+*/
+type UpdateGroupDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewUpdateGroupDefault creates UpdateGroupDefault with default headers values
+func NewUpdateGroupDefault(code int) *UpdateGroupDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &UpdateGroupDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the update group default response
+func (o *UpdateGroupDefault) WithStatusCode(code int) *UpdateGroupDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the update group default response
+func (o *UpdateGroupDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the update group default response
+func (o *UpdateGroupDefault) WithPayload(payload *models.Error) *UpdateGroupDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the update group default response
+func (o *UpdateGroupDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *UpdateGroupDefault) 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
+		}
+	}
+}

restapi/operations/admin_api/update_group_urlbuilder.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 admin_api
+
+// 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"
+)
+
+// UpdateGroupURL generates an URL for the update group operation
+type UpdateGroupURL 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 *UpdateGroupURL) WithBasePath(bp string) *UpdateGroupURL {
+	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 *UpdateGroupURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *UpdateGroupURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/groups/{name}"
+
+	name := o.Name
+	if name != "" {
+		_path = strings.Replace(_path, "{name}", name, -1)
+	} else {
+		return nil, errors.New("name is required on UpdateGroupURL")
+	}
+
+	_basePath := o._basePath
+	_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 *UpdateGroupURL) 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 *UpdateGroupURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *UpdateGroupURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on UpdateGroupURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on UpdateGroupURL")
+	}
+
+	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 *UpdateGroupURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/mcs_api.go

@@ -0,0 +1,604 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 operations
+
+// This file was generated by the swagger tool.
+// Editing this file might prove futile when you re-run the swagger generate command
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/go-openapi/errors"
+	"github.com/go-openapi/loads"
+	"github.com/go-openapi/runtime"
+	"github.com/go-openapi/runtime/middleware"
+	"github.com/go-openapi/runtime/security"
+	"github.com/go-openapi/spec"
+	"github.com/go-openapi/strfmt"
+	"github.com/go-openapi/swag"
+
+	"github.com/minio/m3/mcs/restapi/operations/admin_api"
+	"github.com/minio/m3/mcs/restapi/operations/user_api"
+)
+
+// NewMcsAPI creates a new Mcs instance
+func NewMcsAPI(spec *loads.Document) *McsAPI {
+	return &McsAPI{
+		handlers:            make(map[string]map[string]http.Handler),
+		formats:             strfmt.Default,
+		defaultConsumes:     "application/json",
+		defaultProduces:     "application/json",
+		customConsumers:     make(map[string]runtime.Consumer),
+		customProducers:     make(map[string]runtime.Producer),
+		PreServerShutdown:   func() {},
+		ServerShutdown:      func() {},
+		spec:                spec,
+		ServeError:          errors.ServeError,
+		BasicAuthenticator:  security.BasicAuth,
+		APIKeyAuthenticator: security.APIKeyAuth,
+		BearerAuthenticator: security.BearerAuth,
+
+		JSONConsumer: runtime.JSONConsumer(),
+
+		JSONProducer: runtime.JSONProducer(),
+
+		AdminAPIAddGroupHandler: admin_api.AddGroupHandlerFunc(func(params admin_api.AddGroupParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.AddGroup has not yet been implemented")
+		}),
+		AdminAPIAddPolicyHandler: admin_api.AddPolicyHandlerFunc(func(params admin_api.AddPolicyParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.AddPolicy has not yet been implemented")
+		}),
+		AdminAPIAddUserHandler: admin_api.AddUserHandlerFunc(func(params admin_api.AddUserParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.AddUser has not yet been implemented")
+		}),
+		UserAPIBucketInfoHandler: user_api.BucketInfoHandlerFunc(func(params user_api.BucketInfoParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation user_api.BucketInfo has not yet been implemented")
+		}),
+		UserAPIBucketSetPolicyHandler: user_api.BucketSetPolicyHandlerFunc(func(params user_api.BucketSetPolicyParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation user_api.BucketSetPolicy has not yet been implemented")
+		}),
+		AdminAPIConfigInfoHandler: admin_api.ConfigInfoHandlerFunc(func(params admin_api.ConfigInfoParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.ConfigInfo has not yet been implemented")
+		}),
+		UserAPIDeleteBucketHandler: user_api.DeleteBucketHandlerFunc(func(params user_api.DeleteBucketParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation user_api.DeleteBucket has not yet been implemented")
+		}),
+		AdminAPIGroupInfoHandler: admin_api.GroupInfoHandlerFunc(func(params admin_api.GroupInfoParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.GroupInfo has not yet been implemented")
+		}),
+		UserAPIListBucketEventsHandler: user_api.ListBucketEventsHandlerFunc(func(params user_api.ListBucketEventsParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation user_api.ListBucketEvents has not yet been implemented")
+		}),
+		UserAPIListBucketsHandler: user_api.ListBucketsHandlerFunc(func(params user_api.ListBucketsParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation user_api.ListBuckets has not yet been implemented")
+		}),
+		AdminAPIListConfigHandler: admin_api.ListConfigHandlerFunc(func(params admin_api.ListConfigParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.ListConfig has not yet been implemented")
+		}),
+		AdminAPIListGroupsHandler: admin_api.ListGroupsHandlerFunc(func(params admin_api.ListGroupsParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.ListGroups has not yet been implemented")
+		}),
+		AdminAPIListPoliciesHandler: admin_api.ListPoliciesHandlerFunc(func(params admin_api.ListPoliciesParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.ListPolicies has not yet been implemented")
+		}),
+		AdminAPIListUsersHandler: admin_api.ListUsersHandlerFunc(func(params admin_api.ListUsersParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.ListUsers has not yet been implemented")
+		}),
+		UserAPILoginHandler: user_api.LoginHandlerFunc(func(params user_api.LoginParams) middleware.Responder {
+			return middleware.NotImplemented("operation user_api.Login has not yet been implemented")
+		}),
+		UserAPILoginDetailHandler: user_api.LoginDetailHandlerFunc(func(params user_api.LoginDetailParams) middleware.Responder {
+			return middleware.NotImplemented("operation user_api.LoginDetail has not yet been implemented")
+		}),
+		UserAPIMakeBucketHandler: user_api.MakeBucketHandlerFunc(func(params user_api.MakeBucketParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation user_api.MakeBucket has not yet been implemented")
+		}),
+		AdminAPIPolicyInfoHandler: admin_api.PolicyInfoHandlerFunc(func(params admin_api.PolicyInfoParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.PolicyInfo has not yet been implemented")
+		}),
+		AdminAPIRemoveGroupHandler: admin_api.RemoveGroupHandlerFunc(func(params admin_api.RemoveGroupParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.RemoveGroup has not yet been implemented")
+		}),
+		AdminAPIRemovePolicyHandler: admin_api.RemovePolicyHandlerFunc(func(params admin_api.RemovePolicyParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.RemovePolicy has not yet been implemented")
+		}),
+		AdminAPIRestartServiceHandler: admin_api.RestartServiceHandlerFunc(func(params admin_api.RestartServiceParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.RestartService has not yet been implemented")
+		}),
+		AdminAPISetConfigHandler: admin_api.SetConfigHandlerFunc(func(params admin_api.SetConfigParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.SetConfig has not yet been implemented")
+		}),
+		AdminAPISetPolicyHandler: admin_api.SetPolicyHandlerFunc(func(params admin_api.SetPolicyParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.SetPolicy has not yet been implemented")
+		}),
+		AdminAPIUpdateGroupHandler: admin_api.UpdateGroupHandlerFunc(func(params admin_api.UpdateGroupParams, principal interface{}) middleware.Responder {
+			return middleware.NotImplemented("operation admin_api.UpdateGroup has not yet been implemented")
+		}),
+
+		KeyAuth: func(token string, scopes []string) (interface{}, error) {
+			return nil, errors.NotImplemented("oauth2 bearer auth (key) has not yet been implemented")
+		},
+		// default authorizer is authorized meaning no requests are blocked
+		APIAuthorizer: security.Authorized(),
+	}
+}
+
+/*McsAPI the mcs API */
+type McsAPI struct {
+	spec            *loads.Document
+	context         *middleware.Context
+	handlers        map[string]map[string]http.Handler
+	formats         strfmt.Registry
+	customConsumers map[string]runtime.Consumer
+	customProducers map[string]runtime.Producer
+	defaultConsumes string
+	defaultProduces string
+	Middleware      func(middleware.Builder) http.Handler
+
+	// BasicAuthenticator generates a runtime.Authenticator from the supplied basic auth function.
+	// It has a default implementation in the security package, however you can replace it for your particular usage.
+	BasicAuthenticator func(security.UserPassAuthentication) runtime.Authenticator
+	// APIKeyAuthenticator generates a runtime.Authenticator from the supplied token auth function.
+	// It has a default implementation in the security package, however you can replace it for your particular usage.
+	APIKeyAuthenticator func(string, string, security.TokenAuthentication) runtime.Authenticator
+	// BearerAuthenticator generates a runtime.Authenticator from the supplied bearer token auth function.
+	// It has a default implementation in the security package, however you can replace it for your particular usage.
+	BearerAuthenticator func(string, security.ScopedTokenAuthentication) runtime.Authenticator
+
+	// JSONConsumer registers a consumer for the following mime types:
+	//   - application/json
+	JSONConsumer runtime.Consumer
+
+	// JSONProducer registers a producer for the following mime types:
+	//   - application/json
+	JSONProducer runtime.Producer
+
+	// KeyAuth registers a function that takes an access token and a collection of required scopes and returns a principal
+	// it performs authentication based on an oauth2 bearer token provided in the request
+	KeyAuth func(string, []string) (interface{}, error)
+
+	// APIAuthorizer provides access control (ACL/RBAC/ABAC) by providing access to the request and authenticated principal
+	APIAuthorizer runtime.Authorizer
+
+	// AdminAPIAddGroupHandler sets the operation handler for the add group operation
+	AdminAPIAddGroupHandler admin_api.AddGroupHandler
+	// AdminAPIAddPolicyHandler sets the operation handler for the add policy operation
+	AdminAPIAddPolicyHandler admin_api.AddPolicyHandler
+	// AdminAPIAddUserHandler sets the operation handler for the add user operation
+	AdminAPIAddUserHandler admin_api.AddUserHandler
+	// UserAPIBucketInfoHandler sets the operation handler for the bucket info operation
+	UserAPIBucketInfoHandler user_api.BucketInfoHandler
+	// UserAPIBucketSetPolicyHandler sets the operation handler for the bucket set policy operation
+	UserAPIBucketSetPolicyHandler user_api.BucketSetPolicyHandler
+	// AdminAPIConfigInfoHandler sets the operation handler for the config info operation
+	AdminAPIConfigInfoHandler admin_api.ConfigInfoHandler
+	// UserAPIDeleteBucketHandler sets the operation handler for the delete bucket operation
+	UserAPIDeleteBucketHandler user_api.DeleteBucketHandler
+	// AdminAPIGroupInfoHandler sets the operation handler for the group info operation
+	AdminAPIGroupInfoHandler admin_api.GroupInfoHandler
+	// UserAPIListBucketEventsHandler sets the operation handler for the list bucket events operation
+	UserAPIListBucketEventsHandler user_api.ListBucketEventsHandler
+	// UserAPIListBucketsHandler sets the operation handler for the list buckets operation
+	UserAPIListBucketsHandler user_api.ListBucketsHandler
+	// AdminAPIListConfigHandler sets the operation handler for the list config operation
+	AdminAPIListConfigHandler admin_api.ListConfigHandler
+	// AdminAPIListGroupsHandler sets the operation handler for the list groups operation
+	AdminAPIListGroupsHandler admin_api.ListGroupsHandler
+	// AdminAPIListPoliciesHandler sets the operation handler for the list policies operation
+	AdminAPIListPoliciesHandler admin_api.ListPoliciesHandler
+	// AdminAPIListUsersHandler sets the operation handler for the list users operation
+	AdminAPIListUsersHandler admin_api.ListUsersHandler
+	// UserAPILoginHandler sets the operation handler for the login operation
+	UserAPILoginHandler user_api.LoginHandler
+	// UserAPILoginDetailHandler sets the operation handler for the login detail operation
+	UserAPILoginDetailHandler user_api.LoginDetailHandler
+	// UserAPIMakeBucketHandler sets the operation handler for the make bucket operation
+	UserAPIMakeBucketHandler user_api.MakeBucketHandler
+	// AdminAPIPolicyInfoHandler sets the operation handler for the policy info operation
+	AdminAPIPolicyInfoHandler admin_api.PolicyInfoHandler
+	// AdminAPIRemoveGroupHandler sets the operation handler for the remove group operation
+	AdminAPIRemoveGroupHandler admin_api.RemoveGroupHandler
+	// AdminAPIRemovePolicyHandler sets the operation handler for the remove policy operation
+	AdminAPIRemovePolicyHandler admin_api.RemovePolicyHandler
+	// AdminAPIRestartServiceHandler sets the operation handler for the restart service operation
+	AdminAPIRestartServiceHandler admin_api.RestartServiceHandler
+	// AdminAPISetConfigHandler sets the operation handler for the set config operation
+	AdminAPISetConfigHandler admin_api.SetConfigHandler
+	// AdminAPISetPolicyHandler sets the operation handler for the set policy operation
+	AdminAPISetPolicyHandler admin_api.SetPolicyHandler
+	// AdminAPIUpdateGroupHandler sets the operation handler for the update group operation
+	AdminAPIUpdateGroupHandler admin_api.UpdateGroupHandler
+	// ServeError is called when an error is received, there is a default handler
+	// but you can set your own with this
+	ServeError func(http.ResponseWriter, *http.Request, error)
+
+	// PreServerShutdown is called before the HTTP(S) server is shutdown
+	// This allows for custom functions to get executed before the HTTP(S) server stops accepting traffic
+	PreServerShutdown func()
+
+	// ServerShutdown is called when the HTTP(S) server is shut down and done
+	// handling all active connections and does not accept connections any more
+	ServerShutdown func()
+
+	// Custom command line argument groups with their descriptions
+	CommandLineOptionsGroups []swag.CommandLineOptionsGroup
+
+	// User defined logger function.
+	Logger func(string, ...interface{})
+}
+
+// SetDefaultProduces sets the default produces media type
+func (o *McsAPI) SetDefaultProduces(mediaType string) {
+	o.defaultProduces = mediaType
+}
+
+// SetDefaultConsumes returns the default consumes media type
+func (o *McsAPI) SetDefaultConsumes(mediaType string) {
+	o.defaultConsumes = mediaType
+}
+
+// SetSpec sets a spec that will be served for the clients.
+func (o *McsAPI) SetSpec(spec *loads.Document) {
+	o.spec = spec
+}
+
+// DefaultProduces returns the default produces media type
+func (o *McsAPI) DefaultProduces() string {
+	return o.defaultProduces
+}
+
+// DefaultConsumes returns the default consumes media type
+func (o *McsAPI) DefaultConsumes() string {
+	return o.defaultConsumes
+}
+
+// Formats returns the registered string formats
+func (o *McsAPI) Formats() strfmt.Registry {
+	return o.formats
+}
+
+// RegisterFormat registers a custom format validator
+func (o *McsAPI) RegisterFormat(name string, format strfmt.Format, validator strfmt.Validator) {
+	o.formats.Add(name, format, validator)
+}
+
+// Validate validates the registrations in the McsAPI
+func (o *McsAPI) Validate() error {
+	var unregistered []string
+
+	if o.JSONConsumer == nil {
+		unregistered = append(unregistered, "JSONConsumer")
+	}
+
+	if o.JSONProducer == nil {
+		unregistered = append(unregistered, "JSONProducer")
+	}
+
+	if o.KeyAuth == nil {
+		unregistered = append(unregistered, "KeyAuth")
+	}
+
+	if o.AdminAPIAddGroupHandler == nil {
+		unregistered = append(unregistered, "admin_api.AddGroupHandler")
+	}
+	if o.AdminAPIAddPolicyHandler == nil {
+		unregistered = append(unregistered, "admin_api.AddPolicyHandler")
+	}
+	if o.AdminAPIAddUserHandler == nil {
+		unregistered = append(unregistered, "admin_api.AddUserHandler")
+	}
+	if o.UserAPIBucketInfoHandler == nil {
+		unregistered = append(unregistered, "user_api.BucketInfoHandler")
+	}
+	if o.UserAPIBucketSetPolicyHandler == nil {
+		unregistered = append(unregistered, "user_api.BucketSetPolicyHandler")
+	}
+	if o.AdminAPIConfigInfoHandler == nil {
+		unregistered = append(unregistered, "admin_api.ConfigInfoHandler")
+	}
+	if o.UserAPIDeleteBucketHandler == nil {
+		unregistered = append(unregistered, "user_api.DeleteBucketHandler")
+	}
+	if o.AdminAPIGroupInfoHandler == nil {
+		unregistered = append(unregistered, "admin_api.GroupInfoHandler")
+	}
+	if o.UserAPIListBucketEventsHandler == nil {
+		unregistered = append(unregistered, "user_api.ListBucketEventsHandler")
+	}
+	if o.UserAPIListBucketsHandler == nil {
+		unregistered = append(unregistered, "user_api.ListBucketsHandler")
+	}
+	if o.AdminAPIListConfigHandler == nil {
+		unregistered = append(unregistered, "admin_api.ListConfigHandler")
+	}
+	if o.AdminAPIListGroupsHandler == nil {
+		unregistered = append(unregistered, "admin_api.ListGroupsHandler")
+	}
+	if o.AdminAPIListPoliciesHandler == nil {
+		unregistered = append(unregistered, "admin_api.ListPoliciesHandler")
+	}
+	if o.AdminAPIListUsersHandler == nil {
+		unregistered = append(unregistered, "admin_api.ListUsersHandler")
+	}
+	if o.UserAPILoginHandler == nil {
+		unregistered = append(unregistered, "user_api.LoginHandler")
+	}
+	if o.UserAPILoginDetailHandler == nil {
+		unregistered = append(unregistered, "user_api.LoginDetailHandler")
+	}
+	if o.UserAPIMakeBucketHandler == nil {
+		unregistered = append(unregistered, "user_api.MakeBucketHandler")
+	}
+	if o.AdminAPIPolicyInfoHandler == nil {
+		unregistered = append(unregistered, "admin_api.PolicyInfoHandler")
+	}
+	if o.AdminAPIRemoveGroupHandler == nil {
+		unregistered = append(unregistered, "admin_api.RemoveGroupHandler")
+	}
+	if o.AdminAPIRemovePolicyHandler == nil {
+		unregistered = append(unregistered, "admin_api.RemovePolicyHandler")
+	}
+	if o.AdminAPIRestartServiceHandler == nil {
+		unregistered = append(unregistered, "admin_api.RestartServiceHandler")
+	}
+	if o.AdminAPISetConfigHandler == nil {
+		unregistered = append(unregistered, "admin_api.SetConfigHandler")
+	}
+	if o.AdminAPISetPolicyHandler == nil {
+		unregistered = append(unregistered, "admin_api.SetPolicyHandler")
+	}
+	if o.AdminAPIUpdateGroupHandler == nil {
+		unregistered = append(unregistered, "admin_api.UpdateGroupHandler")
+	}
+
+	if len(unregistered) > 0 {
+		return fmt.Errorf("missing registration: %s", strings.Join(unregistered, ", "))
+	}
+
+	return nil
+}
+
+// ServeErrorFor gets a error handler for a given operation id
+func (o *McsAPI) ServeErrorFor(operationID string) func(http.ResponseWriter, *http.Request, error) {
+	return o.ServeError
+}
+
+// AuthenticatorsFor gets the authenticators for the specified security schemes
+func (o *McsAPI) AuthenticatorsFor(schemes map[string]spec.SecurityScheme) map[string]runtime.Authenticator {
+	result := make(map[string]runtime.Authenticator)
+	for name := range schemes {
+		switch name {
+		case "key":
+			result[name] = o.BearerAuthenticator(name, o.KeyAuth)
+
+		}
+	}
+	return result
+}
+
+// Authorizer returns the registered authorizer
+func (o *McsAPI) Authorizer() runtime.Authorizer {
+	return o.APIAuthorizer
+}
+
+// ConsumersFor gets the consumers for the specified media types.
+// MIME type parameters are ignored here.
+func (o *McsAPI) ConsumersFor(mediaTypes []string) map[string]runtime.Consumer {
+	result := make(map[string]runtime.Consumer, len(mediaTypes))
+	for _, mt := range mediaTypes {
+		switch mt {
+		case "application/json":
+			result["application/json"] = o.JSONConsumer
+		}
+
+		if c, ok := o.customConsumers[mt]; ok {
+			result[mt] = c
+		}
+	}
+	return result
+}
+
+// ProducersFor gets the producers for the specified media types.
+// MIME type parameters are ignored here.
+func (o *McsAPI) ProducersFor(mediaTypes []string) map[string]runtime.Producer {
+	result := make(map[string]runtime.Producer, len(mediaTypes))
+	for _, mt := range mediaTypes {
+		switch mt {
+		case "application/json":
+			result["application/json"] = o.JSONProducer
+		}
+
+		if p, ok := o.customProducers[mt]; ok {
+			result[mt] = p
+		}
+	}
+	return result
+}
+
+// HandlerFor gets a http.Handler for the provided operation method and path
+func (o *McsAPI) HandlerFor(method, path string) (http.Handler, bool) {
+	if o.handlers == nil {
+		return nil, false
+	}
+	um := strings.ToUpper(method)
+	if _, ok := o.handlers[um]; !ok {
+		return nil, false
+	}
+	if path == "/" {
+		path = ""
+	}
+	h, ok := o.handlers[um][path]
+	return h, ok
+}
+
+// Context returns the middleware context for the mcs API
+func (o *McsAPI) Context() *middleware.Context {
+	if o.context == nil {
+		o.context = middleware.NewRoutableContext(o.spec, o, nil)
+	}
+
+	return o.context
+}
+
+func (o *McsAPI) initHandlerCache() {
+	o.Context() // don't care about the result, just that the initialization happened
+	if o.handlers == nil {
+		o.handlers = make(map[string]map[string]http.Handler)
+	}
+
+	if o.handlers["POST"] == nil {
+		o.handlers["POST"] = make(map[string]http.Handler)
+	}
+	o.handlers["POST"]["/api/v1/groups"] = admin_api.NewAddGroup(o.context, o.AdminAPIAddGroupHandler)
+	if o.handlers["POST"] == nil {
+		o.handlers["POST"] = make(map[string]http.Handler)
+	}
+	o.handlers["POST"]["/api/v1/policies"] = admin_api.NewAddPolicy(o.context, o.AdminAPIAddPolicyHandler)
+	if o.handlers["POST"] == nil {
+		o.handlers["POST"] = make(map[string]http.Handler)
+	}
+	o.handlers["POST"]["/api/v1/users"] = admin_api.NewAddUser(o.context, o.AdminAPIAddUserHandler)
+	if o.handlers["GET"] == nil {
+		o.handlers["GET"] = make(map[string]http.Handler)
+	}
+	o.handlers["GET"]["/api/v1/buckets/{name}"] = user_api.NewBucketInfo(o.context, o.UserAPIBucketInfoHandler)
+	if o.handlers["PUT"] == nil {
+		o.handlers["PUT"] = make(map[string]http.Handler)
+	}
+	o.handlers["PUT"]["/api/v1/buckets/{name}/set-policy"] = user_api.NewBucketSetPolicy(o.context, o.UserAPIBucketSetPolicyHandler)
+	if o.handlers["GET"] == nil {
+		o.handlers["GET"] = make(map[string]http.Handler)
+	}
+	o.handlers["GET"]["/api/v1/configs/{name}"] = admin_api.NewConfigInfo(o.context, o.AdminAPIConfigInfoHandler)
+	if o.handlers["DELETE"] == nil {
+		o.handlers["DELETE"] = make(map[string]http.Handler)
+	}
+	o.handlers["DELETE"]["/api/v1/buckets/{name}"] = user_api.NewDeleteBucket(o.context, o.UserAPIDeleteBucketHandler)
+	if o.handlers["GET"] == nil {
+		o.handlers["GET"] = make(map[string]http.Handler)
+	}
+	o.handlers["GET"]["/api/v1/groups/{name}"] = admin_api.NewGroupInfo(o.context, o.AdminAPIGroupInfoHandler)
+	if o.handlers["GET"] == nil {
+		o.handlers["GET"] = make(map[string]http.Handler)
+	}
+	o.handlers["GET"]["/api/v1/buckets/{bucket_name}/events"] = user_api.NewListBucketEvents(o.context, o.UserAPIListBucketEventsHandler)
+	if o.handlers["GET"] == nil {
+		o.handlers["GET"] = make(map[string]http.Handler)
+	}
+	o.handlers["GET"]["/api/v1/buckets"] = user_api.NewListBuckets(o.context, o.UserAPIListBucketsHandler)
+	if o.handlers["GET"] == nil {
+		o.handlers["GET"] = make(map[string]http.Handler)
+	}
+	o.handlers["GET"]["/api/v1/configs"] = admin_api.NewListConfig(o.context, o.AdminAPIListConfigHandler)
+	if o.handlers["GET"] == nil {
+		o.handlers["GET"] = make(map[string]http.Handler)
+	}
+	o.handlers["GET"]["/api/v1/groups"] = admin_api.NewListGroups(o.context, o.AdminAPIListGroupsHandler)
+	if o.handlers["GET"] == nil {
+		o.handlers["GET"] = make(map[string]http.Handler)
+	}
+	o.handlers["GET"]["/api/v1/policies"] = admin_api.NewListPolicies(o.context, o.AdminAPIListPoliciesHandler)
+	if o.handlers["GET"] == nil {
+		o.handlers["GET"] = make(map[string]http.Handler)
+	}
+	o.handlers["GET"]["/api/v1/users"] = admin_api.NewListUsers(o.context, o.AdminAPIListUsersHandler)
+	if o.handlers["POST"] == nil {
+		o.handlers["POST"] = make(map[string]http.Handler)
+	}
+	o.handlers["POST"]["/api/v1/login"] = user_api.NewLogin(o.context, o.UserAPILoginHandler)
+	if o.handlers["GET"] == nil {
+		o.handlers["GET"] = make(map[string]http.Handler)
+	}
+	o.handlers["GET"]["/api/v1/login"] = user_api.NewLoginDetail(o.context, o.UserAPILoginDetailHandler)
+	if o.handlers["POST"] == nil {
+		o.handlers["POST"] = make(map[string]http.Handler)
+	}
+	o.handlers["POST"]["/api/v1/buckets"] = user_api.NewMakeBucket(o.context, o.UserAPIMakeBucketHandler)
+	if o.handlers["GET"] == nil {
+		o.handlers["GET"] = make(map[string]http.Handler)
+	}
+	o.handlers["GET"]["/api/v1/policies/{name}"] = admin_api.NewPolicyInfo(o.context, o.AdminAPIPolicyInfoHandler)
+	if o.handlers["DELETE"] == nil {
+		o.handlers["DELETE"] = make(map[string]http.Handler)
+	}
+	o.handlers["DELETE"]["/api/v1/groups/{name}"] = admin_api.NewRemoveGroup(o.context, o.AdminAPIRemoveGroupHandler)
+	if o.handlers["DELETE"] == nil {
+		o.handlers["DELETE"] = make(map[string]http.Handler)
+	}
+	o.handlers["DELETE"]["/api/v1/policies/{name}"] = admin_api.NewRemovePolicy(o.context, o.AdminAPIRemovePolicyHandler)
+	if o.handlers["POST"] == nil {
+		o.handlers["POST"] = make(map[string]http.Handler)
+	}
+	o.handlers["POST"]["/api/v1/service/restart"] = admin_api.NewRestartService(o.context, o.AdminAPIRestartServiceHandler)
+	if o.handlers["PUT"] == nil {
+		o.handlers["PUT"] = make(map[string]http.Handler)
+	}
+	o.handlers["PUT"]["/api/v1/configs/{name}"] = admin_api.NewSetConfig(o.context, o.AdminAPISetConfigHandler)
+	if o.handlers["PUT"] == nil {
+		o.handlers["PUT"] = make(map[string]http.Handler)
+	}
+	o.handlers["PUT"]["/api/v1/set-policy/{name}"] = admin_api.NewSetPolicy(o.context, o.AdminAPISetPolicyHandler)
+	if o.handlers["PUT"] == nil {
+		o.handlers["PUT"] = make(map[string]http.Handler)
+	}
+	o.handlers["PUT"]["/api/v1/groups/{name}"] = admin_api.NewUpdateGroup(o.context, o.AdminAPIUpdateGroupHandler)
+}
+
+// Serve creates a http handler to serve the API over HTTP
+// can be used directly in http.ListenAndServe(":8000", api.Serve(nil))
+func (o *McsAPI) Serve(builder middleware.Builder) http.Handler {
+	o.Init()
+
+	if o.Middleware != nil {
+		return o.Middleware(builder)
+	}
+	return o.context.APIHandler(builder)
+}
+
+// Init allows you to just initialize the handler cache, you can then recompose the middleware as you see fit
+func (o *McsAPI) Init() {
+	if len(o.handlers) == 0 {
+		o.initHandlerCache()
+	}
+}
+
+// RegisterConsumer allows you to add (or override) a consumer for a media type.
+func (o *McsAPI) RegisterConsumer(mediaType string, consumer runtime.Consumer) {
+	o.customConsumers[mediaType] = consumer
+}
+
+// RegisterProducer allows you to add (or override) a producer for a media type.
+func (o *McsAPI) RegisterProducer(mediaType string, producer runtime.Producer) {
+	o.customProducers[mediaType] = producer
+}
+
+// AddMiddlewareFor adds a http middleware to existing handler
+func (o *McsAPI) AddMiddlewareFor(method, path string, builder middleware.Builder) {
+	um := strings.ToUpper(method)
+	if path == "/" {
+		path = ""
+	}
+	o.Init()
+	if h, ok := o.handlers[um][path]; ok {
+		o.handlers[method][path] = builder(h)
+	}
+}

restapi/operations/user_api/bucket_info.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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"
+)
+
+// BucketInfoHandlerFunc turns a function with the right signature into a bucket info handler
+type BucketInfoHandlerFunc func(BucketInfoParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn BucketInfoHandlerFunc) Handle(params BucketInfoParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// BucketInfoHandler interface for that can handle valid bucket info params
+type BucketInfoHandler interface {
+	Handle(BucketInfoParams, interface{}) middleware.Responder
+}
+
+// NewBucketInfo creates a new http.Handler for the bucket info operation
+func NewBucketInfo(ctx *middleware.Context, handler BucketInfoHandler) *BucketInfo {
+	return &BucketInfo{Context: ctx, Handler: handler}
+}
+
+/*BucketInfo swagger:route GET /api/v1/buckets/{name} UserAPI bucketInfo
+
+Bucket Info
+
+*/
+type BucketInfo struct {
+	Context *middleware.Context
+	Handler BucketInfoHandler
+}
+
+func (o *BucketInfo) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewBucketInfoParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/user_api/bucket_info_parameters.go

@@ -0,0 +1,89 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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"
+)
+
+// NewBucketInfoParams creates a new BucketInfoParams object
+// no default values defined in spec.
+func NewBucketInfoParams() BucketInfoParams {
+
+	return BucketInfoParams{}
+}
+
+// BucketInfoParams contains all the bound params for the bucket info operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters BucketInfo
+type BucketInfoParams 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 NewBucketInfoParams() beforehand.
+func (o *BucketInfoParams) 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 *BucketInfoParams) 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
+}

restapi/operations/user_api/bucket_info_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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/m3/mcs/models"
+)
+
+// BucketInfoOKCode is the HTTP code returned for type BucketInfoOK
+const BucketInfoOKCode int = 200
+
+/*BucketInfoOK A successful response.
+
+swagger:response bucketInfoOK
+*/
+type BucketInfoOK struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Bucket `json:"body,omitempty"`
+}
+
+// NewBucketInfoOK creates BucketInfoOK with default headers values
+func NewBucketInfoOK() *BucketInfoOK {
+
+	return &BucketInfoOK{}
+}
+
+// WithPayload adds the payload to the bucket info o k response
+func (o *BucketInfoOK) WithPayload(payload *models.Bucket) *BucketInfoOK {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the bucket info o k response
+func (o *BucketInfoOK) SetPayload(payload *models.Bucket) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *BucketInfoOK) 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
+		}
+	}
+}
+
+/*BucketInfoDefault Generic error response.
+
+swagger:response bucketInfoDefault
+*/
+type BucketInfoDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewBucketInfoDefault creates BucketInfoDefault with default headers values
+func NewBucketInfoDefault(code int) *BucketInfoDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &BucketInfoDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the bucket info default response
+func (o *BucketInfoDefault) WithStatusCode(code int) *BucketInfoDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the bucket info default response
+func (o *BucketInfoDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the bucket info default response
+func (o *BucketInfoDefault) WithPayload(payload *models.Error) *BucketInfoDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the bucket info default response
+func (o *BucketInfoDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *BucketInfoDefault) 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
+		}
+	}
+}

restapi/operations/user_api/bucket_info_urlbuilder.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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"
+)
+
+// BucketInfoURL generates an URL for the bucket info operation
+type BucketInfoURL 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 *BucketInfoURL) WithBasePath(bp string) *BucketInfoURL {
+	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 *BucketInfoURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *BucketInfoURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/buckets/{name}"
+
+	name := o.Name
+	if name != "" {
+		_path = strings.Replace(_path, "{name}", name, -1)
+	} else {
+		return nil, errors.New("name is required on BucketInfoURL")
+	}
+
+	_basePath := o._basePath
+	_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 *BucketInfoURL) 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 *BucketInfoURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *BucketInfoURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on BucketInfoURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on BucketInfoURL")
+	}
+
+	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 *BucketInfoURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/user_api/bucket_set_policy.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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"
+)
+
+// BucketSetPolicyHandlerFunc turns a function with the right signature into a bucket set policy handler
+type BucketSetPolicyHandlerFunc func(BucketSetPolicyParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn BucketSetPolicyHandlerFunc) Handle(params BucketSetPolicyParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// BucketSetPolicyHandler interface for that can handle valid bucket set policy params
+type BucketSetPolicyHandler interface {
+	Handle(BucketSetPolicyParams, interface{}) 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 /api/v1/buckets/{name}/set-policy UserAPI 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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/user_api/bucket_set_policy_parameters.go

@@ -0,0 +1,120 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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/minio/m3/mcs/models"
+)
+
+// NewBucketSetPolicyParams creates a new BucketSetPolicyParams object
+// no default values defined in 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)
+			}
+
+			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
+}

restapi/operations/user_api/bucket_set_policy_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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/m3/mcs/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.Error `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.Error) *BucketSetPolicyDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the bucket set policy default response
+func (o *BucketSetPolicyDefault) SetPayload(payload *models.Error) {
+	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
+		}
+	}
+}

restapi/operations/user_api/bucket_set_policy_urlbuilder.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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 = "/api/v1/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
+	_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()
+}

restapi/operations/user_api/delete_bucket.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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"
+)
+
+// DeleteBucketHandlerFunc turns a function with the right signature into a delete bucket handler
+type DeleteBucketHandlerFunc func(DeleteBucketParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn DeleteBucketHandlerFunc) Handle(params DeleteBucketParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// DeleteBucketHandler interface for that can handle valid delete bucket params
+type DeleteBucketHandler interface {
+	Handle(DeleteBucketParams, interface{}) 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 /api/v1/buckets/{name} UserAPI 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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/user_api/delete_bucket_parameters.go

@@ -0,0 +1,89 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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
+// no default values defined in 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
+}

restapi/operations/user_api/delete_bucket_responses.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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/m3/mcs/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.Error `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.Error) *DeleteBucketDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the delete bucket default response
+func (o *DeleteBucketDefault) SetPayload(payload *models.Error) {
+	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
+		}
+	}
+}

restapi/operations/user_api/delete_bucket_urlbuilder.go

@@ -0,0 +1,113 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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 = "/api/v1/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
+	_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()
+}

restapi/operations/user_api/list_bucket_events.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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"
+)
+
+// ListBucketEventsHandlerFunc turns a function with the right signature into a list bucket events handler
+type ListBucketEventsHandlerFunc func(ListBucketEventsParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn ListBucketEventsHandlerFunc) Handle(params ListBucketEventsParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// ListBucketEventsHandler interface for that can handle valid list bucket events params
+type ListBucketEventsHandler interface {
+	Handle(ListBucketEventsParams, interface{}) middleware.Responder
+}
+
+// NewListBucketEvents creates a new http.Handler for the list bucket events operation
+func NewListBucketEvents(ctx *middleware.Context, handler ListBucketEventsHandler) *ListBucketEvents {
+	return &ListBucketEvents{Context: ctx, Handler: handler}
+}
+
+/*ListBucketEvents swagger:route GET /api/v1/buckets/{bucket_name}/events UserAPI listBucketEvents
+
+List Bucket Events
+
+*/
+type ListBucketEvents struct {
+	Context *middleware.Context
+	Handler ListBucketEventsHandler
+}
+
+func (o *ListBucketEvents) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewListBucketEventsParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/user_api/list_bucket_events_parameters.go

@@ -0,0 +1,155 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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"
+	"github.com/go-openapi/runtime/middleware"
+	"github.com/go-openapi/strfmt"
+	"github.com/go-openapi/swag"
+)
+
+// NewListBucketEventsParams creates a new ListBucketEventsParams object
+// no default values defined in spec.
+func NewListBucketEventsParams() ListBucketEventsParams {
+
+	return ListBucketEventsParams{}
+}
+
+// ListBucketEventsParams contains all the bound params for the list bucket events operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters ListBucketEvents
+type ListBucketEventsParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+
+	/*
+	  Required: true
+	  In: path
+	*/
+	BucketName string
+	/*
+	  In: query
+	*/
+	Limit *int32
+	/*
+	  In: query
+	*/
+	Offset *int32
+}
+
+// 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 NewListBucketEventsParams() beforehand.
+func (o *ListBucketEventsParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
+	var res []error
+
+	o.HTTPRequest = r
+
+	qs := runtime.Values(r.URL.Query())
+
+	rBucketName, rhkBucketName, _ := route.Params.GetOK("bucket_name")
+	if err := o.bindBucketName(rBucketName, rhkBucketName, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	qLimit, qhkLimit, _ := qs.GetOK("limit")
+	if err := o.bindLimit(qLimit, qhkLimit, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	qOffset, qhkOffset, _ := qs.GetOK("offset")
+	if err := o.bindOffset(qOffset, qhkOffset, 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 *ListBucketEventsParams) 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
+}
+
+// bindLimit binds and validates parameter Limit from query.
+func (o *ListBucketEventsParams) bindLimit(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	value, err := swag.ConvertInt32(raw)
+	if err != nil {
+		return errors.InvalidType("limit", "query", "int32", raw)
+	}
+	o.Limit = &value
+
+	return nil
+}
+
+// bindOffset binds and validates parameter Offset from query.
+func (o *ListBucketEventsParams) bindOffset(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	value, err := swag.ConvertInt32(raw)
+	if err != nil {
+		return errors.InvalidType("offset", "query", "int32", raw)
+	}
+	o.Offset = &value
+
+	return nil
+}

restapi/operations/user_api/list_bucket_events_responses.go

@@ -0,0 +1,133 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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/m3/mcs/models"
+)
+
+// ListBucketEventsOKCode is the HTTP code returned for type ListBucketEventsOK
+const ListBucketEventsOKCode int = 200
+
+/*ListBucketEventsOK A successful response.
+
+swagger:response listBucketEventsOK
+*/
+type ListBucketEventsOK struct {
+
+	/*
+	  In: Body
+	*/
+	Payload *models.ListBucketEventsResponse `json:"body,omitempty"`
+}
+
+// NewListBucketEventsOK creates ListBucketEventsOK with default headers values
+func NewListBucketEventsOK() *ListBucketEventsOK {
+
+	return &ListBucketEventsOK{}
+}
+
+// WithPayload adds the payload to the list bucket events o k response
+func (o *ListBucketEventsOK) WithPayload(payload *models.ListBucketEventsResponse) *ListBucketEventsOK {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the list bucket events o k response
+func (o *ListBucketEventsOK) SetPayload(payload *models.ListBucketEventsResponse) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ListBucketEventsOK) 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
+		}
+	}
+}
+
+/*ListBucketEventsDefault Generic error response.
+
+swagger:response listBucketEventsDefault
+*/
+type ListBucketEventsDefault struct {
+	_statusCode int
+
+	/*
+	  In: Body
+	*/
+	Payload *models.Error `json:"body,omitempty"`
+}
+
+// NewListBucketEventsDefault creates ListBucketEventsDefault with default headers values
+func NewListBucketEventsDefault(code int) *ListBucketEventsDefault {
+	if code <= 0 {
+		code = 500
+	}
+
+	return &ListBucketEventsDefault{
+		_statusCode: code,
+	}
+}
+
+// WithStatusCode adds the status to the list bucket events default response
+func (o *ListBucketEventsDefault) WithStatusCode(code int) *ListBucketEventsDefault {
+	o._statusCode = code
+	return o
+}
+
+// SetStatusCode sets the status to the list bucket events default response
+func (o *ListBucketEventsDefault) SetStatusCode(code int) {
+	o._statusCode = code
+}
+
+// WithPayload adds the payload to the list bucket events default response
+func (o *ListBucketEventsDefault) WithPayload(payload *models.Error) *ListBucketEventsDefault {
+	o.Payload = payload
+	return o
+}
+
+// SetPayload sets the payload to the list bucket events default response
+func (o *ListBucketEventsDefault) SetPayload(payload *models.Error) {
+	o.Payload = payload
+}
+
+// WriteResponse to the client
+func (o *ListBucketEventsDefault) 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
+		}
+	}
+}

restapi/operations/user_api/list_bucket_events_urlbuilder.go

@@ -0,0 +1,138 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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"
+
+	"github.com/go-openapi/swag"
+)
+
+// ListBucketEventsURL generates an URL for the list bucket events operation
+type ListBucketEventsURL struct {
+	BucketName string
+
+	Limit  *int32
+	Offset *int32
+
+	_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 *ListBucketEventsURL) WithBasePath(bp string) *ListBucketEventsURL {
+	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 *ListBucketEventsURL) SetBasePath(bp string) {
+	o._basePath = bp
+}
+
+// Build a url path and query string
+func (o *ListBucketEventsURL) Build() (*url.URL, error) {
+	var _result url.URL
+
+	var _path = "/api/v1/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 ListBucketEventsURL")
+	}
+
+	_basePath := o._basePath
+	_result.Path = golangswaggerpaths.Join(_basePath, _path)
+
+	qs := make(url.Values)
+
+	var limitQ string
+	if o.Limit != nil {
+		limitQ = swag.FormatInt32(*o.Limit)
+	}
+	if limitQ != "" {
+		qs.Set("limit", limitQ)
+	}
+
+	var offsetQ string
+	if o.Offset != nil {
+		offsetQ = swag.FormatInt32(*o.Offset)
+	}
+	if offsetQ != "" {
+		qs.Set("offset", offsetQ)
+	}
+
+	_result.RawQuery = qs.Encode()
+
+	return &_result, nil
+}
+
+// Must is a helper function to panic when the url builder returns an error
+func (o *ListBucketEventsURL) 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 *ListBucketEventsURL) String() string {
+	return o.Must(o.Build()).String()
+}
+
+// BuildFull builds a full url with scheme, host, path and query string
+func (o *ListBucketEventsURL) BuildFull(scheme, host string) (*url.URL, error) {
+	if scheme == "" {
+		return nil, errors.New("scheme is required for a full url on ListBucketEventsURL")
+	}
+	if host == "" {
+		return nil, errors.New("host is required for a full url on ListBucketEventsURL")
+	}
+
+	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 *ListBucketEventsURL) StringFull(scheme, host string) string {
+	return o.Must(o.BuildFull(scheme, host)).String()
+}

restapi/operations/user_api/list_buckets.go

@@ -0,0 +1,88 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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"
+)
+
+// ListBucketsHandlerFunc turns a function with the right signature into a list buckets handler
+type ListBucketsHandlerFunc func(ListBucketsParams, interface{}) middleware.Responder
+
+// Handle executing the request and returning a response
+func (fn ListBucketsHandlerFunc) Handle(params ListBucketsParams, principal interface{}) middleware.Responder {
+	return fn(params, principal)
+}
+
+// ListBucketsHandler interface for that can handle valid list buckets params
+type ListBucketsHandler interface {
+	Handle(ListBucketsParams, interface{}) middleware.Responder
+}
+
+// NewListBuckets creates a new http.Handler for the list buckets operation
+func NewListBuckets(ctx *middleware.Context, handler ListBucketsHandler) *ListBuckets {
+	return &ListBuckets{Context: ctx, Handler: handler}
+}
+
+/*ListBuckets swagger:route GET /api/v1/buckets UserAPI listBuckets
+
+List Buckets
+
+*/
+type ListBuckets struct {
+	Context *middleware.Context
+	Handler ListBucketsHandler
+}
+
+func (o *ListBuckets) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	route, rCtx, _ := o.Context.RouteInfo(r)
+	if rCtx != nil {
+		r = rCtx
+	}
+	var Params = NewListBucketsParams()
+
+	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 interface{}
+	if uprinc != nil {
+		principal = uprinc
+	}
+
+	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)
+
+}

restapi/operations/user_api/list_buckets_parameters.go

@@ -0,0 +1,157 @@
+// Code generated by go-swagger; DO NOT EDIT.
+
+// This file is part of MinIO Console Server
+// Copyright (c) 2020 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 user_api
+
+// 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"
+	"github.com/go-openapi/runtime/middleware"
+	"github.com/go-openapi/strfmt"
+	"github.com/go-openapi/swag"
+)
+
+// NewListBucketsParams creates a new ListBucketsParams object
+// no default values defined in spec.
+func NewListBucketsParams() ListBucketsParams {
+
+	return ListBucketsParams{}
+}
+
+// ListBucketsParams contains all the bound params for the list buckets operation
+// typically these are obtained from a http.Request
+//
+// swagger:parameters ListBuckets
+type ListBucketsParams struct {
+
+	// HTTP Request Object
+	HTTPRequest *http.Request `json:"-"`
+
+	/*
+	  In: query
+	*/
+	Limit *int32
+	/*
+	  In: query
+	*/
+	Offset *int32
+	/*
+	  In: query
+	*/
+	SortBy *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 NewListBucketsParams() beforehand.
+func (o *ListBucketsParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
+	var res []error
+
+	o.HTTPRequest = r
+
+	qs := runtime.Values(r.URL.Query())
+
+	qLimit, qhkLimit, _ := qs.GetOK("limit")
+	if err := o.bindLimit(qLimit, qhkLimit, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	qOffset, qhkOffset, _ := qs.GetOK("offset")
+	if err := o.bindOffset(qOffset, qhkOffset, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	qSortBy, qhkSortBy, _ := qs.GetOK("sort_by")
+	if err := o.bindSortBy(qSortBy, qhkSortBy, route.Formats); err != nil {
+		res = append(res, err)
+	}
+
+	if len(res) > 0 {
+		return errors.CompositeValidationError(res...)
+	}
+	return nil
+}
+
+// bindLimit binds and validates parameter Limit from query.
+func (o *ListBucketsParams) bindLimit(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	value, err := swag.ConvertInt32(raw)
+	if err != nil {
+		return errors.InvalidType("limit", "query", "int32", raw)
+	}
+	o.Limit = &value
+
+	return nil
+}
+
+// bindOffset binds and validates parameter Offset from query.
+func (o *ListBucketsParams) bindOffset(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	value, err := swag.ConvertInt32(raw)
+	if err != nil {
+		return errors.InvalidType("offset", "query", "int32", raw)
+	}
+	o.Offset = &value
+
+	return nil
+}
+
+// bindSortBy binds and validates parameter SortBy from query.
+func (o *ListBucketsParams) bindSortBy(rawData []string, hasKey bool, formats strfmt.Registry) error {
+	var raw string
+	if len(rawData) > 0 {
+		raw = rawData[len(rawData)-1]
+	}
+
+	// Required: false
+	// AllowEmptyValue: false
+	if raw == "" { // empty values pass all other validations
+		return nil
+	}
+
+	o.SortBy = &raw
+
+	return nil
+}