mirrors/object-browser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Generate Swagger with models.Principal (#6)

Browse Source
This commit is contained in:
Daniel Valdivia
2020-04-02 12:06:52 -07:00
committed by GitHub
parent 44c6c9f46a
commit 2f922980f8
35 changed files with 224 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@@ -7,7 +7,7 @@ mcs:
swagger-gen:
@echo "Generating swagger server code from yaml"
@swagger generate server -A mcs --main-package=mcs --exclude-main -f ./swagger.yml -r NOTICE
@swagger generate server -A mcs --main-package=mcs --exclude-main -P models.Principal -f ./swagger.yml -r NOTICE
build:
@(cd portal-ui; yarn install; make build; cd ..)

6
restapi/admin_config.go
View File

@@ -32,7 +32,7 @@ import (
func registerConfigHandlers(api *operations.McsAPI) {
// List Configurations
api.AdminAPIListConfigHandler = admin_api.ListConfigHandlerFunc(func(params admin_api.ListConfigParams, principal interface{}) middleware.Responder {
api.AdminAPIListConfigHandler = admin_api.ListConfigHandlerFunc(func(params admin_api.ListConfigParams, principal *models.Principal) middleware.Responder {
configListResp, err := getListConfigResponse()
if err != nil {
return admin_api.NewListConfigDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
@@ -40,7 +40,7 @@ func registerConfigHandlers(api *operations.McsAPI) {
return admin_api.NewListConfigOK().WithPayload(configListResp)
})
// Configuration Info
api.AdminAPIConfigInfoHandler = admin_api.ConfigInfoHandlerFunc(func(params admin_api.ConfigInfoParams, principal interface{}) middleware.Responder {
api.AdminAPIConfigInfoHandler = admin_api.ConfigInfoHandlerFunc(func(params admin_api.ConfigInfoParams, principal *models.Principal) middleware.Responder {
config, err := getConfigResponse(params)
if err != nil {
return admin_api.NewConfigInfoDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
@@ -48,7 +48,7 @@ func registerConfigHandlers(api *operations.McsAPI) {
return admin_api.NewConfigInfoOK().WithPayload(config)
})
// Set Configuration
api.AdminAPISetConfigHandler = admin_api.SetConfigHandlerFunc(func(params admin_api.SetConfigParams, principal interface{}) middleware.Responder {
api.AdminAPISetConfigHandler = admin_api.SetConfigHandlerFunc(func(params admin_api.SetConfigParams, principal *models.Principal) 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())})
}

10
restapi/admin_groups.go
View File

@@ -33,7 +33,7 @@ import (
func registerGroupsHandlers(api *operations.McsAPI) {
// List Groups
api.AdminAPIListGroupsHandler = admin_api.ListGroupsHandlerFunc(func(params admin_api.ListGroupsParams, principal interface{}) middleware.Responder {
api.AdminAPIListGroupsHandler = admin_api.ListGroupsHandlerFunc(func(params admin_api.ListGroupsParams, principal *models.Principal) middleware.Responder {
listGroupsResponse, err := getListGroupsResponse()
if err != nil {
return admin_api.NewListGroupsDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
@@ -41,7 +41,7 @@ func registerGroupsHandlers(api *operations.McsAPI) {
return admin_api.NewListGroupsOK().WithPayload(listGroupsResponse)
})
// Group Info
api.AdminAPIGroupInfoHandler = admin_api.GroupInfoHandlerFunc(func(params admin_api.GroupInfoParams, principal interface{}) middleware.Responder {
api.AdminAPIGroupInfoHandler = admin_api.GroupInfoHandlerFunc(func(params admin_api.GroupInfoParams, principal *models.Principal) middleware.Responder {
groupInfo, err := getGroupInfoResponse(params)
if err != nil {
return admin_api.NewGroupInfoDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
@@ -49,21 +49,21 @@ func registerGroupsHandlers(api *operations.McsAPI) {
return admin_api.NewGroupInfoOK().WithPayload(groupInfo)
})
// Add Group
api.AdminAPIAddGroupHandler = admin_api.AddGroupHandlerFunc(func(params admin_api.AddGroupParams, principal interface{}) middleware.Responder {
api.AdminAPIAddGroupHandler = admin_api.AddGroupHandlerFunc(func(params admin_api.AddGroupParams, principal *models.Principal) 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 {
api.AdminAPIRemoveGroupHandler = admin_api.RemoveGroupHandlerFunc(func(params admin_api.RemoveGroupParams, principal *models.Principal) 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 {
api.AdminAPIUpdateGroupHandler = admin_api.UpdateGroupHandlerFunc(func(params admin_api.UpdateGroupParams, principal *models.Principal) middleware.Responder {
groupUpdateResp, err := getUpdateGroupResponse(params)
if err != nil {
return admin_api.NewUpdateGroupDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})

10
restapi/admin_policies.go
View File

@@ -32,7 +32,7 @@ import (
func registersPoliciesHandler(api *operations.McsAPI) {
// List Policies
api.AdminAPIListPoliciesHandler = admin_api.ListPoliciesHandlerFunc(func(params admin_api.ListPoliciesParams, principal interface{}) middleware.Responder {
api.AdminAPIListPoliciesHandler = admin_api.ListPoliciesHandlerFunc(func(params admin_api.ListPoliciesParams, principal *models.Principal) middleware.Responder {
listPoliciesResponse, err := getListPoliciesResponse()
if err != nil {
return admin_api.NewListPoliciesDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
@@ -40,7 +40,7 @@ func registersPoliciesHandler(api *operations.McsAPI) {
return admin_api.NewListPoliciesOK().WithPayload(listPoliciesResponse)
})
// Policy Info
api.AdminAPIPolicyInfoHandler = admin_api.PolicyInfoHandlerFunc(func(params admin_api.PolicyInfoParams, principal interface{}) middleware.Responder {
api.AdminAPIPolicyInfoHandler = admin_api.PolicyInfoHandlerFunc(func(params admin_api.PolicyInfoParams, principal *models.Principal) middleware.Responder {
policyInfo, err := getPolicyInfoResponse(params)
if err != nil {
return admin_api.NewPolicyInfoDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
@@ -48,7 +48,7 @@ func registersPoliciesHandler(api *operations.McsAPI) {
return admin_api.NewPolicyInfoOK().WithPayload(policyInfo)
})
// Add Policy
api.AdminAPIAddPolicyHandler = admin_api.AddPolicyHandlerFunc(func(params admin_api.AddPolicyParams, principal interface{}) middleware.Responder {
api.AdminAPIAddPolicyHandler = admin_api.AddPolicyHandlerFunc(func(params admin_api.AddPolicyParams, principal *models.Principal) middleware.Responder {
policyResponse, err := getAddPolicyResponse(params.Body)
if err != nil {
return admin_api.NewAddPolicyDefault(500).WithPayload(&models.Error{
@@ -59,14 +59,14 @@ func registersPoliciesHandler(api *operations.McsAPI) {
return admin_api.NewAddPolicyCreated().WithPayload(policyResponse)
})
// Remove Policy
api.AdminAPIRemovePolicyHandler = admin_api.RemovePolicyHandlerFunc(func(params admin_api.RemovePolicyParams, principal interface{}) middleware.Responder {
api.AdminAPIRemovePolicyHandler = admin_api.RemovePolicyHandlerFunc(func(params admin_api.RemovePolicyParams, principal *models.Principal) 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 {
api.AdminAPISetPolicyHandler = admin_api.SetPolicyHandlerFunc(func(params admin_api.SetPolicyParams, principal *models.Principal) 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())})
}

4
restapi/admin_profiling.go
View File

@@ -34,7 +34,7 @@ import (
func registerProfilingHandler(api *operations.McsAPI) {
// Start Profiling
api.AdminAPIProfilingStartHandler = admin_api.ProfilingStartHandlerFunc(func(params admin_api.ProfilingStartParams, principal interface{}) middleware.Responder {
api.AdminAPIProfilingStartHandler = admin_api.ProfilingStartHandlerFunc(func(params admin_api.ProfilingStartParams, principal *models.Principal) middleware.Responder {
profilingStartResponse, err := getProfilingStartResponse(params.Body)
if err != nil {
return admin_api.NewProfilingStartDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
@@ -42,7 +42,7 @@ func registerProfilingHandler(api *operations.McsAPI) {
return admin_api.NewProfilingStartCreated().WithPayload(profilingStartResponse)
})
// Stop and download profiling data
api.AdminAPIProfilingStopHandler = admin_api.ProfilingStopHandlerFunc(func(params admin_api.ProfilingStopParams, principal interface{}) middleware.Responder {
api.AdminAPIProfilingStopHandler = admin_api.ProfilingStopHandlerFunc(func(params admin_api.ProfilingStopParams, principal *models.Principal) middleware.Responder {
profilingStopResponse, err := getProfilingStopResponse()
if err != nil {
return admin_api.NewProfilingStopDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})

2
restapi/admin_service.go
View File

@@ -31,7 +31,7 @@ import (
func registerServiceHandlers(api *operations.McsAPI) {
// Restart Service
api.AdminAPIRestartServiceHandler = admin_api.RestartServiceHandlerFunc(func(params admin_api.RestartServiceParams, principal interface{}) middleware.Responder {
api.AdminAPIRestartServiceHandler = admin_api.RestartServiceHandlerFunc(func(params admin_api.RestartServiceParams, principal *models.Principal) middleware.Responder {
if err := getRestartServiceResponse(); err != nil {
return admin_api.NewRestartServiceDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
}

4
restapi/admin_users.go
View File

@@ -31,7 +31,7 @@ import (
func registerUsersHandlers(api *operations.McsAPI) {
// List Users
api.AdminAPIListUsersHandler = admin_api.ListUsersHandlerFunc(func(params admin_api.ListUsersParams, principal interface{}) middleware.Responder {
api.AdminAPIListUsersHandler = admin_api.ListUsersHandlerFunc(func(params admin_api.ListUsersParams, principal *models.Principal) middleware.Responder {
listUsersResponse, err := getListUsersResponse()
if err != nil {
return admin_api.NewListUsersDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
@@ -39,7 +39,7 @@ func registerUsersHandlers(api *operations.McsAPI) {
return admin_api.NewListUsersOK().WithPayload(listUsersResponse)
})
// Add User
api.AdminAPIAddUserHandler = admin_api.AddUserHandlerFunc(func(params admin_api.AddUserParams, principal interface{}) middleware.Responder {
api.AdminAPIAddUserHandler = admin_api.AddUserHandlerFunc(func(params admin_api.AddUserParams, principal *models.Principal) middleware.Responder {
userResponse, err := getUserAddResponse(params)
if err != nil {
return admin_api.NewAddUserDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})

2
restapi/configure_mcs.go
View File

@@ -58,7 +58,7 @@ func configureAPI(api *operations.McsAPI) http.Handler {
api.JSONProducer = runtime.JSONProducer()
// Applies when the "x-token" header is set
api.KeyAuth = func(token string, scopes []string) (interface{}, error) {
api.KeyAuth = func(token string, scopes []string) (*models.Principal, error) {
if sessions.GetInstance().ValidSession(token) {
prin := models.Principal(token)
return &prin, nil

12
restapi/operations/admin_api/add_group.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// AddGroupHandlerFunc turns a function with the right signature into a add group handler
type AddGroupHandlerFunc func(AddGroupParams, interface{}) middleware.Responder
type AddGroupHandlerFunc func(AddGroupParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn AddGroupHandlerFunc) Handle(params AddGroupParams, principal interface{}) middleware.Responder {
func (fn AddGroupHandlerFunc) Handle(params AddGroupParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// AddGroupHandler interface for that can handle valid add group params
type AddGroupHandler interface {
Handle(AddGroupParams, interface{}) middleware.Responder
Handle(AddGroupParams, *models.Principal) middleware.Responder
}
// NewAddGroup creates a new http.Handler for the add group operation
@@ -71,9 +73,9 @@ func (o *AddGroup) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/add_policy.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// AddPolicyHandlerFunc turns a function with the right signature into a add policy handler
type AddPolicyHandlerFunc func(AddPolicyParams, interface{}) middleware.Responder
type AddPolicyHandlerFunc func(AddPolicyParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn AddPolicyHandlerFunc) Handle(params AddPolicyParams, principal interface{}) middleware.Responder {
func (fn AddPolicyHandlerFunc) Handle(params AddPolicyParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// AddPolicyHandler interface for that can handle valid add policy params
type AddPolicyHandler interface {
Handle(AddPolicyParams, interface{}) middleware.Responder
Handle(AddPolicyParams, *models.Principal) middleware.Responder
}
// NewAddPolicy creates a new http.Handler for the add policy operation
@@ -71,9 +73,9 @@ func (o *AddPolicy) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/add_user.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// AddUserHandlerFunc turns a function with the right signature into a add user handler
type AddUserHandlerFunc func(AddUserParams, interface{}) middleware.Responder
type AddUserHandlerFunc func(AddUserParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn AddUserHandlerFunc) Handle(params AddUserParams, principal interface{}) middleware.Responder {
func (fn AddUserHandlerFunc) Handle(params AddUserParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// AddUserHandler interface for that can handle valid add user params
type AddUserHandler interface {
Handle(AddUserParams, interface{}) middleware.Responder
Handle(AddUserParams, *models.Principal) middleware.Responder
}
// NewAddUser creates a new http.Handler for the add user operation
@@ -71,9 +73,9 @@ func (o *AddUser) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/config_info.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// ConfigInfoHandlerFunc turns a function with the right signature into a config info handler
type ConfigInfoHandlerFunc func(ConfigInfoParams, interface{}) middleware.Responder
type ConfigInfoHandlerFunc func(ConfigInfoParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn ConfigInfoHandlerFunc) Handle(params ConfigInfoParams, principal interface{}) middleware.Responder {
func (fn ConfigInfoHandlerFunc) Handle(params ConfigInfoParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// ConfigInfoHandler interface for that can handle valid config info params
type ConfigInfoHandler interface {
Handle(ConfigInfoParams, interface{}) middleware.Responder
Handle(ConfigInfoParams, *models.Principal) middleware.Responder
}
// NewConfigInfo creates a new http.Handler for the config info operation
@@ -71,9 +73,9 @@ func (o *ConfigInfo) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/group_info.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// GroupInfoHandlerFunc turns a function with the right signature into a group info handler
type GroupInfoHandlerFunc func(GroupInfoParams, interface{}) middleware.Responder
type GroupInfoHandlerFunc func(GroupInfoParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn GroupInfoHandlerFunc) Handle(params GroupInfoParams, principal interface{}) middleware.Responder {
func (fn GroupInfoHandlerFunc) Handle(params GroupInfoParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// GroupInfoHandler interface for that can handle valid group info params
type GroupInfoHandler interface {
Handle(GroupInfoParams, interface{}) middleware.Responder
Handle(GroupInfoParams, *models.Principal) middleware.Responder
}
// NewGroupInfo creates a new http.Handler for the group info operation
@@ -71,9 +73,9 @@ func (o *GroupInfo) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/list_config.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// ListConfigHandlerFunc turns a function with the right signature into a list config handler
type ListConfigHandlerFunc func(ListConfigParams, interface{}) middleware.Responder
type ListConfigHandlerFunc func(ListConfigParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn ListConfigHandlerFunc) Handle(params ListConfigParams, principal interface{}) middleware.Responder {
func (fn ListConfigHandlerFunc) Handle(params ListConfigParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// ListConfigHandler interface for that can handle valid list config params
type ListConfigHandler interface {
Handle(ListConfigParams, interface{}) middleware.Responder
Handle(ListConfigParams, *models.Principal) middleware.Responder
}
// NewListConfig creates a new http.Handler for the list config operation
@@ -71,9 +73,9 @@ func (o *ListConfig) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/list_groups.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// ListGroupsHandlerFunc turns a function with the right signature into a list groups handler
type ListGroupsHandlerFunc func(ListGroupsParams, interface{}) middleware.Responder
type ListGroupsHandlerFunc func(ListGroupsParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn ListGroupsHandlerFunc) Handle(params ListGroupsParams, principal interface{}) middleware.Responder {
func (fn ListGroupsHandlerFunc) Handle(params ListGroupsParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// ListGroupsHandler interface for that can handle valid list groups params
type ListGroupsHandler interface {
Handle(ListGroupsParams, interface{}) middleware.Responder
Handle(ListGroupsParams, *models.Principal) middleware.Responder
}
// NewListGroups creates a new http.Handler for the list groups operation
@@ -71,9 +73,9 @@ func (o *ListGroups) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/list_policies.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// ListPoliciesHandlerFunc turns a function with the right signature into a list policies handler
type ListPoliciesHandlerFunc func(ListPoliciesParams, interface{}) middleware.Responder
type ListPoliciesHandlerFunc func(ListPoliciesParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn ListPoliciesHandlerFunc) Handle(params ListPoliciesParams, principal interface{}) middleware.Responder {
func (fn ListPoliciesHandlerFunc) Handle(params ListPoliciesParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// ListPoliciesHandler interface for that can handle valid list policies params
type ListPoliciesHandler interface {
Handle(ListPoliciesParams, interface{}) middleware.Responder
Handle(ListPoliciesParams, *models.Principal) middleware.Responder
}
// NewListPolicies creates a new http.Handler for the list policies operation
@@ -71,9 +73,9 @@ func (o *ListPolicies) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/list_users.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// ListUsersHandlerFunc turns a function with the right signature into a list users handler
type ListUsersHandlerFunc func(ListUsersParams, interface{}) middleware.Responder
type ListUsersHandlerFunc func(ListUsersParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn ListUsersHandlerFunc) Handle(params ListUsersParams, principal interface{}) middleware.Responder {
func (fn ListUsersHandlerFunc) Handle(params ListUsersParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// ListUsersHandler interface for that can handle valid list users params
type ListUsersHandler interface {
Handle(ListUsersParams, interface{}) middleware.Responder
Handle(ListUsersParams, *models.Principal) middleware.Responder
}
// NewListUsers creates a new http.Handler for the list users operation
@@ -71,9 +73,9 @@ func (o *ListUsers) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/policy_info.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// PolicyInfoHandlerFunc turns a function with the right signature into a policy info handler
type PolicyInfoHandlerFunc func(PolicyInfoParams, interface{}) middleware.Responder
type PolicyInfoHandlerFunc func(PolicyInfoParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn PolicyInfoHandlerFunc) Handle(params PolicyInfoParams, principal interface{}) middleware.Responder {
func (fn PolicyInfoHandlerFunc) Handle(params PolicyInfoParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// PolicyInfoHandler interface for that can handle valid policy info params
type PolicyInfoHandler interface {
Handle(PolicyInfoParams, interface{}) middleware.Responder
Handle(PolicyInfoParams, *models.Principal) middleware.Responder
}
// NewPolicyInfo creates a new http.Handler for the policy info operation
@@ -71,9 +73,9 @@ func (o *PolicyInfo) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/profiling_start.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// ProfilingStartHandlerFunc turns a function with the right signature into a profiling start handler
type ProfilingStartHandlerFunc func(ProfilingStartParams, interface{}) middleware.Responder
type ProfilingStartHandlerFunc func(ProfilingStartParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn ProfilingStartHandlerFunc) Handle(params ProfilingStartParams, principal interface{}) middleware.Responder {
func (fn ProfilingStartHandlerFunc) Handle(params ProfilingStartParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// ProfilingStartHandler interface for that can handle valid profiling start params
type ProfilingStartHandler interface {
Handle(ProfilingStartParams, interface{}) middleware.Responder
Handle(ProfilingStartParams, *models.Principal) middleware.Responder
}
// NewProfilingStart creates a new http.Handler for the profiling start operation
@@ -71,9 +73,9 @@ func (o *ProfilingStart) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/profiling_stop.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// ProfilingStopHandlerFunc turns a function with the right signature into a profiling stop handler
type ProfilingStopHandlerFunc func(ProfilingStopParams, interface{}) middleware.Responder
type ProfilingStopHandlerFunc func(ProfilingStopParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn ProfilingStopHandlerFunc) Handle(params ProfilingStopParams, principal interface{}) middleware.Responder {
func (fn ProfilingStopHandlerFunc) Handle(params ProfilingStopParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// ProfilingStopHandler interface for that can handle valid profiling stop params
type ProfilingStopHandler interface {
Handle(ProfilingStopParams, interface{}) middleware.Responder
Handle(ProfilingStopParams, *models.Principal) middleware.Responder
}
// NewProfilingStop creates a new http.Handler for the profiling stop operation
@@ -71,9 +73,9 @@ func (o *ProfilingStop) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/remove_group.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// RemoveGroupHandlerFunc turns a function with the right signature into a remove group handler
type RemoveGroupHandlerFunc func(RemoveGroupParams, interface{}) middleware.Responder
type RemoveGroupHandlerFunc func(RemoveGroupParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn RemoveGroupHandlerFunc) Handle(params RemoveGroupParams, principal interface{}) middleware.Responder {
func (fn RemoveGroupHandlerFunc) Handle(params RemoveGroupParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// RemoveGroupHandler interface for that can handle valid remove group params
type RemoveGroupHandler interface {
Handle(RemoveGroupParams, interface{}) middleware.Responder
Handle(RemoveGroupParams, *models.Principal) middleware.Responder
}
// NewRemoveGroup creates a new http.Handler for the remove group operation
@@ -71,9 +73,9 @@ func (o *RemoveGroup) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/remove_policy.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// RemovePolicyHandlerFunc turns a function with the right signature into a remove policy handler
type RemovePolicyHandlerFunc func(RemovePolicyParams, interface{}) middleware.Responder
type RemovePolicyHandlerFunc func(RemovePolicyParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn RemovePolicyHandlerFunc) Handle(params RemovePolicyParams, principal interface{}) middleware.Responder {
func (fn RemovePolicyHandlerFunc) Handle(params RemovePolicyParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// RemovePolicyHandler interface for that can handle valid remove policy params
type RemovePolicyHandler interface {
Handle(RemovePolicyParams, interface{}) middleware.Responder
Handle(RemovePolicyParams, *models.Principal) middleware.Responder
}
// NewRemovePolicy creates a new http.Handler for the remove policy operation
@@ -71,9 +73,9 @@ func (o *RemovePolicy) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/restart_service.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// RestartServiceHandlerFunc turns a function with the right signature into a restart service handler
type RestartServiceHandlerFunc func(RestartServiceParams, interface{}) middleware.Responder
type RestartServiceHandlerFunc func(RestartServiceParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn RestartServiceHandlerFunc) Handle(params RestartServiceParams, principal interface{}) middleware.Responder {
func (fn RestartServiceHandlerFunc) Handle(params RestartServiceParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// RestartServiceHandler interface for that can handle valid restart service params
type RestartServiceHandler interface {
Handle(RestartServiceParams, interface{}) middleware.Responder
Handle(RestartServiceParams, *models.Principal) middleware.Responder
}
// NewRestartService creates a new http.Handler for the restart service operation
@@ -71,9 +73,9 @@ func (o *RestartService) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/set_config.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// SetConfigHandlerFunc turns a function with the right signature into a set config handler
type SetConfigHandlerFunc func(SetConfigParams, interface{}) middleware.Responder
type SetConfigHandlerFunc func(SetConfigParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn SetConfigHandlerFunc) Handle(params SetConfigParams, principal interface{}) middleware.Responder {
func (fn SetConfigHandlerFunc) Handle(params SetConfigParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// SetConfigHandler interface for that can handle valid set config params
type SetConfigHandler interface {
Handle(SetConfigParams, interface{}) middleware.Responder
Handle(SetConfigParams, *models.Principal) middleware.Responder
}
// NewSetConfig creates a new http.Handler for the set config operation
@@ -71,9 +73,9 @@ func (o *SetConfig) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/set_policy.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// SetPolicyHandlerFunc turns a function with the right signature into a set policy handler
type SetPolicyHandlerFunc func(SetPolicyParams, interface{}) middleware.Responder
type SetPolicyHandlerFunc func(SetPolicyParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn SetPolicyHandlerFunc) Handle(params SetPolicyParams, principal interface{}) middleware.Responder {
func (fn SetPolicyHandlerFunc) Handle(params SetPolicyParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// SetPolicyHandler interface for that can handle valid set policy params
type SetPolicyHandler interface {
Handle(SetPolicyParams, interface{}) middleware.Responder
Handle(SetPolicyParams, *models.Principal) middleware.Responder
}
// NewSetPolicy creates a new http.Handler for the set policy operation
@@ -71,9 +73,9 @@ func (o *SetPolicy) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/admin_api/update_group.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// UpdateGroupHandlerFunc turns a function with the right signature into a update group handler
type UpdateGroupHandlerFunc func(UpdateGroupParams, interface{}) middleware.Responder
type UpdateGroupHandlerFunc func(UpdateGroupParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn UpdateGroupHandlerFunc) Handle(params UpdateGroupParams, principal interface{}) middleware.Responder {
func (fn UpdateGroupHandlerFunc) Handle(params UpdateGroupParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// UpdateGroupHandler interface for that can handle valid update group params
type UpdateGroupHandler interface {
Handle(UpdateGroupParams, interface{}) middleware.Responder
Handle(UpdateGroupParams, *models.Principal) middleware.Responder
}
// NewUpdateGroup creates a new http.Handler for the update group operation
@@ -71,9 +73,9 @@ func (o *UpdateGroup) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

57
restapi/operations/mcs_api.go
View File

@@ -36,6 +36,7 @@ import (
"github.com/go-openapi/strfmt"
"github.com/go-openapi/swag"
"github.com/minio/m3/mcs/models"
"github.com/minio/m3/mcs/restapi/operations/admin_api"
"github.com/minio/m3/mcs/restapi/operations/user_api"
)
@@ -62,46 +63,46 @@ func NewMcsAPI(spec *loads.Document) *McsAPI {
BinProducer: runtime.ByteStreamProducer(),
JSONProducer: runtime.JSONProducer(),
AdminAPIAddGroupHandler: admin_api.AddGroupHandlerFunc(func(params admin_api.AddGroupParams, principal interface{}) middleware.Responder {
AdminAPIAddGroupHandler: admin_api.AddGroupHandlerFunc(func(params admin_api.AddGroupParams, principal *models.Principal) 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 {
AdminAPIAddPolicyHandler: admin_api.AddPolicyHandlerFunc(func(params admin_api.AddPolicyParams, principal *models.Principal) 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 {
AdminAPIAddUserHandler: admin_api.AddUserHandlerFunc(func(params admin_api.AddUserParams, principal *models.Principal) 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 {
UserAPIBucketInfoHandler: user_api.BucketInfoHandlerFunc(func(params user_api.BucketInfoParams, principal *models.Principal) 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 {
UserAPIBucketSetPolicyHandler: user_api.BucketSetPolicyHandlerFunc(func(params user_api.BucketSetPolicyParams, principal *models.Principal) 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 {
AdminAPIConfigInfoHandler: admin_api.ConfigInfoHandlerFunc(func(params admin_api.ConfigInfoParams, principal *models.Principal) 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 {
UserAPIDeleteBucketHandler: user_api.DeleteBucketHandlerFunc(func(params user_api.DeleteBucketParams, principal *models.Principal) 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 {
AdminAPIGroupInfoHandler: admin_api.GroupInfoHandlerFunc(func(params admin_api.GroupInfoParams, principal *models.Principal) 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 {
UserAPIListBucketEventsHandler: user_api.ListBucketEventsHandlerFunc(func(params user_api.ListBucketEventsParams, principal *models.Principal) 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 {
UserAPIListBucketsHandler: user_api.ListBucketsHandlerFunc(func(params user_api.ListBucketsParams, principal *models.Principal) 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 {
AdminAPIListConfigHandler: admin_api.ListConfigHandlerFunc(func(params admin_api.ListConfigParams, principal *models.Principal) 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 {
AdminAPIListGroupsHandler: admin_api.ListGroupsHandlerFunc(func(params admin_api.ListGroupsParams, principal *models.Principal) 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 {
AdminAPIListPoliciesHandler: admin_api.ListPoliciesHandlerFunc(func(params admin_api.ListPoliciesParams, principal *models.Principal) 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 {
AdminAPIListUsersHandler: admin_api.ListUsersHandlerFunc(func(params admin_api.ListUsersParams, principal *models.Principal) 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 {
@@ -110,38 +111,38 @@ func NewMcsAPI(spec *loads.Document) *McsAPI {
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 {
UserAPIMakeBucketHandler: user_api.MakeBucketHandlerFunc(func(params user_api.MakeBucketParams, principal *models.Principal) 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 {
AdminAPIPolicyInfoHandler: admin_api.PolicyInfoHandlerFunc(func(params admin_api.PolicyInfoParams, principal *models.Principal) middleware.Responder {
return middleware.NotImplemented("operation admin_api.PolicyInfo has not yet been implemented")
}),
AdminAPIProfilingStartHandler: admin_api.ProfilingStartHandlerFunc(func(params admin_api.ProfilingStartParams, principal interface{}) middleware.Responder {
AdminAPIProfilingStartHandler: admin_api.ProfilingStartHandlerFunc(func(params admin_api.ProfilingStartParams, principal *models.Principal) middleware.Responder {
return middleware.NotImplemented("operation admin_api.ProfilingStart has not yet been implemented")
}),
AdminAPIProfilingStopHandler: admin_api.ProfilingStopHandlerFunc(func(params admin_api.ProfilingStopParams, principal interface{}) middleware.Responder {
AdminAPIProfilingStopHandler: admin_api.ProfilingStopHandlerFunc(func(params admin_api.ProfilingStopParams, principal *models.Principal) middleware.Responder {
return middleware.NotImplemented("operation admin_api.ProfilingStop has not yet been implemented")
}),
AdminAPIRemoveGroupHandler: admin_api.RemoveGroupHandlerFunc(func(params admin_api.RemoveGroupParams, principal interface{}) middleware.Responder {
AdminAPIRemoveGroupHandler: admin_api.RemoveGroupHandlerFunc(func(params admin_api.RemoveGroupParams, principal *models.Principal) 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 {
AdminAPIRemovePolicyHandler: admin_api.RemovePolicyHandlerFunc(func(params admin_api.RemovePolicyParams, principal *models.Principal) 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 {
AdminAPIRestartServiceHandler: admin_api.RestartServiceHandlerFunc(func(params admin_api.RestartServiceParams, principal *models.Principal) 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 {
AdminAPISetConfigHandler: admin_api.SetConfigHandlerFunc(func(params admin_api.SetConfigParams, principal *models.Principal) 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 {
AdminAPISetPolicyHandler: admin_api.SetPolicyHandlerFunc(func(params admin_api.SetPolicyParams, principal *models.Principal) 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 {
AdminAPIUpdateGroupHandler: admin_api.UpdateGroupHandlerFunc(func(params admin_api.UpdateGroupParams, principal *models.Principal) middleware.Responder {
return middleware.NotImplemented("operation admin_api.UpdateGroup has not yet been implemented")
}),
KeyAuth: func(token string, scopes []string) (interface{}, error) {
KeyAuth: func(token string, scopes []string) (*models.Principal, error) {
return nil, errors.NotImplemented("oauth2 bearer auth (key) has not yet been implemented")
},
// default authorizer is authorized meaning no requests are blocked
@@ -184,7 +185,7 @@ type McsAPI struct {
// 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)
KeyAuth func(string, []string) (*models.Principal, error)
// APIAuthorizer provides access control (ACL/RBAC/ABAC) by providing access to the request and authenticated principal
APIAuthorizer runtime.Authorizer
@@ -411,7 +412,9 @@ func (o *McsAPI) AuthenticatorsFor(schemes map[string]spec.SecurityScheme) map[s
for name := range schemes {
switch name {
case "key":
result[name] = o.BearerAuthenticator(name, o.KeyAuth)
result[name] = o.BearerAuthenticator(name, func(token string, scopes []string) (interface{}, error) {
return o.KeyAuth(token, scopes)
})
}
}

12
restapi/operations/user_api/bucket_info.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// BucketInfoHandlerFunc turns a function with the right signature into a bucket info handler
type BucketInfoHandlerFunc func(BucketInfoParams, interface{}) middleware.Responder
type BucketInfoHandlerFunc func(BucketInfoParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn BucketInfoHandlerFunc) Handle(params BucketInfoParams, principal interface{}) middleware.Responder {
func (fn BucketInfoHandlerFunc) Handle(params BucketInfoParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// BucketInfoHandler interface for that can handle valid bucket info params
type BucketInfoHandler interface {
Handle(BucketInfoParams, interface{}) middleware.Responder
Handle(BucketInfoParams, *models.Principal) middleware.Responder
}
// NewBucketInfo creates a new http.Handler for the bucket info operation
@@ -71,9 +73,9 @@ func (o *BucketInfo) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/user_api/bucket_set_policy.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// BucketSetPolicyHandlerFunc turns a function with the right signature into a bucket set policy handler
type BucketSetPolicyHandlerFunc func(BucketSetPolicyParams, interface{}) middleware.Responder
type BucketSetPolicyHandlerFunc func(BucketSetPolicyParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn BucketSetPolicyHandlerFunc) Handle(params BucketSetPolicyParams, principal interface{}) middleware.Responder {
func (fn BucketSetPolicyHandlerFunc) Handle(params BucketSetPolicyParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// BucketSetPolicyHandler interface for that can handle valid bucket set policy params
type BucketSetPolicyHandler interface {
Handle(BucketSetPolicyParams, interface{}) middleware.Responder
Handle(BucketSetPolicyParams, *models.Principal) middleware.Responder
}
// NewBucketSetPolicy creates a new http.Handler for the bucket set policy operation
@@ -71,9 +73,9 @@ func (o *BucketSetPolicy) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/user_api/delete_bucket.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// DeleteBucketHandlerFunc turns a function with the right signature into a delete bucket handler
type DeleteBucketHandlerFunc func(DeleteBucketParams, interface{}) middleware.Responder
type DeleteBucketHandlerFunc func(DeleteBucketParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn DeleteBucketHandlerFunc) Handle(params DeleteBucketParams, principal interface{}) middleware.Responder {
func (fn DeleteBucketHandlerFunc) Handle(params DeleteBucketParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// DeleteBucketHandler interface for that can handle valid delete bucket params
type DeleteBucketHandler interface {
Handle(DeleteBucketParams, interface{}) middleware.Responder
Handle(DeleteBucketParams, *models.Principal) middleware.Responder
}
// NewDeleteBucket creates a new http.Handler for the delete bucket operation
@@ -71,9 +73,9 @@ func (o *DeleteBucket) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/user_api/list_bucket_events.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// ListBucketEventsHandlerFunc turns a function with the right signature into a list bucket events handler
type ListBucketEventsHandlerFunc func(ListBucketEventsParams, interface{}) middleware.Responder
type ListBucketEventsHandlerFunc func(ListBucketEventsParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn ListBucketEventsHandlerFunc) Handle(params ListBucketEventsParams, principal interface{}) middleware.Responder {
func (fn ListBucketEventsHandlerFunc) Handle(params ListBucketEventsParams, principal *models.Principal) 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
Handle(ListBucketEventsParams, *models.Principal) middleware.Responder
}
// NewListBucketEvents creates a new http.Handler for the list bucket events operation
@@ -71,9 +73,9 @@ func (o *ListBucketEvents) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/user_api/list_buckets.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// ListBucketsHandlerFunc turns a function with the right signature into a list buckets handler
type ListBucketsHandlerFunc func(ListBucketsParams, interface{}) middleware.Responder
type ListBucketsHandlerFunc func(ListBucketsParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn ListBucketsHandlerFunc) Handle(params ListBucketsParams, principal interface{}) middleware.Responder {
func (fn ListBucketsHandlerFunc) Handle(params ListBucketsParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// ListBucketsHandler interface for that can handle valid list buckets params
type ListBucketsHandler interface {
Handle(ListBucketsParams, interface{}) middleware.Responder
Handle(ListBucketsParams, *models.Principal) middleware.Responder
}
// NewListBuckets creates a new http.Handler for the list buckets operation
@@ -71,9 +73,9 @@ func (o *ListBuckets) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

12
restapi/operations/user_api/make_bucket.go
View File

@@ -26,19 +26,21 @@ import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/m3/mcs/models"
)
// MakeBucketHandlerFunc turns a function with the right signature into a make bucket handler
type MakeBucketHandlerFunc func(MakeBucketParams, interface{}) middleware.Responder
type MakeBucketHandlerFunc func(MakeBucketParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn MakeBucketHandlerFunc) Handle(params MakeBucketParams, principal interface{}) middleware.Responder {
func (fn MakeBucketHandlerFunc) Handle(params MakeBucketParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// MakeBucketHandler interface for that can handle valid make bucket params
type MakeBucketHandler interface {
Handle(MakeBucketParams, interface{}) middleware.Responder
Handle(MakeBucketParams, *models.Principal) middleware.Responder
}
// NewMakeBucket creates a new http.Handler for the make bucket operation
@@ -71,9 +73,9 @@ func (o *MakeBucket) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
if aCtx != nil {
r = aCtx
}
var principal interface{}
var principal *models.Principal
if uprinc != nil {
principal = uprinc
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params

10
restapi/user_buckets.go
View File

@@ -36,7 +36,7 @@ import (
func registerBucketsHandlers(api *operations.McsAPI) {
// list buckets
api.UserAPIListBucketsHandler = user_api.ListBucketsHandlerFunc(func(params user_api.ListBucketsParams, principal interface{}) middleware.Responder {
api.UserAPIListBucketsHandler = user_api.ListBucketsHandlerFunc(func(params user_api.ListBucketsParams, principal *models.Principal) middleware.Responder {
listBucketsResponse, err := getListBucketsResponse()
if err != nil {
return user_api.NewListBucketsDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
@@ -44,14 +44,14 @@ func registerBucketsHandlers(api *operations.McsAPI) {
return user_api.NewListBucketsOK().WithPayload(listBucketsResponse)
})
// make bucket
api.UserAPIMakeBucketHandler = user_api.MakeBucketHandlerFunc(func(params user_api.MakeBucketParams, principal interface{}) middleware.Responder {
api.UserAPIMakeBucketHandler = user_api.MakeBucketHandlerFunc(func(params user_api.MakeBucketParams, principal *models.Principal) middleware.Responder {
if err := getMakeBucketResponse(params.Body); err != nil {
return user_api.NewMakeBucketDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
}
return user_api.NewMakeBucketCreated()
})
// delete bucket
api.UserAPIDeleteBucketHandler = user_api.DeleteBucketHandlerFunc(func(params user_api.DeleteBucketParams, principal interface{}) middleware.Responder {
api.UserAPIDeleteBucketHandler = user_api.DeleteBucketHandlerFunc(func(params user_api.DeleteBucketParams, principal *models.Principal) middleware.Responder {
if err := getDeleteBucketResponse(params); err != nil {
return user_api.NewMakeBucketDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
@@ -59,7 +59,7 @@ func registerBucketsHandlers(api *operations.McsAPI) {
return user_api.NewDeleteBucketNoContent()
})
// get bucket info
api.UserAPIBucketInfoHandler = user_api.BucketInfoHandlerFunc(func(params user_api.BucketInfoParams, principal interface{}) middleware.Responder {
api.UserAPIBucketInfoHandler = user_api.BucketInfoHandlerFunc(func(params user_api.BucketInfoParams, principal *models.Principal) middleware.Responder {
bucketInfoResp, err := getBucketInfoResponse(params)
if err != nil {
return user_api.NewBucketInfoDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
@@ -68,7 +68,7 @@ func registerBucketsHandlers(api *operations.McsAPI) {
return user_api.NewBucketInfoOK().WithPayload(bucketInfoResp)
})
// set bucket policy
api.UserAPIBucketSetPolicyHandler = user_api.BucketSetPolicyHandlerFunc(func(params user_api.BucketSetPolicyParams, principal interface{}) middleware.Responder {
api.UserAPIBucketSetPolicyHandler = user_api.BucketSetPolicyHandlerFunc(func(params user_api.BucketSetPolicyParams, principal *models.Principal) middleware.Responder {
bucketSetPolicyResp, err := getBucketSetPolicyResponse(params.Name, params.Body)
if err != nil {
return user_api.NewBucketSetPolicyDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})

2
restapi/user_buckets_events.go
View File

@@ -29,7 +29,7 @@ import (
)
func registerBucketEventsHandlers(api *operations.McsAPI) {
api.UserAPIListBucketEventsHandler = user_api.ListBucketEventsHandlerFunc(func(params user_api.ListBucketEventsParams, principal interface{}) middleware.Responder {
api.UserAPIListBucketEventsHandler = user_api.ListBucketEventsHandlerFunc(func(params user_api.ListBucketEventsParams, principal *models.Principal) middleware.Responder {
listBucketEventsResponse, err := getListBucketEventsResponse(params)
if err != nil {
return user_api.NewListBucketEventsDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})