diff --git a/Makefile b/Makefile index 0e62ba5d9..f11da76c9 100644 --- a/Makefile +++ b/Makefile @@ -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 ..) diff --git a/restapi/admin_config.go b/restapi/admin_config.go index 9474b36e8..4d0f7af6f 100644 --- a/restapi/admin_config.go +++ b/restapi/admin_config.go @@ -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())}) } diff --git a/restapi/admin_groups.go b/restapi/admin_groups.go index 6da25ec0f..eb0b37c17 100644 --- a/restapi/admin_groups.go +++ b/restapi/admin_groups.go @@ -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())}) diff --git a/restapi/admin_policies.go b/restapi/admin_policies.go index fd82a69b1..24a017b1e 100644 --- a/restapi/admin_policies.go +++ b/restapi/admin_policies.go @@ -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())}) } diff --git a/restapi/admin_profiling.go b/restapi/admin_profiling.go index 643b66bb9..597e03630 100644 --- a/restapi/admin_profiling.go +++ b/restapi/admin_profiling.go @@ -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())}) diff --git a/restapi/admin_service.go b/restapi/admin_service.go index 4e7f3da9e..cb367fa56 100644 --- a/restapi/admin_service.go +++ b/restapi/admin_service.go @@ -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())}) } diff --git a/restapi/admin_users.go b/restapi/admin_users.go index 6a7089c67..a087627d0 100644 --- a/restapi/admin_users.go +++ b/restapi/admin_users.go @@ -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())}) diff --git a/restapi/configure_mcs.go b/restapi/configure_mcs.go index 31957d486..9cfa61340 100644 --- a/restapi/configure_mcs.go +++ b/restapi/configure_mcs.go @@ -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 diff --git a/restapi/operations/admin_api/add_group.go b/restapi/operations/admin_api/add_group.go index a5efd1ac3..1068ab5a9 100644 --- a/restapi/operations/admin_api/add_group.go +++ b/restapi/operations/admin_api/add_group.go @@ -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 diff --git a/restapi/operations/admin_api/add_policy.go b/restapi/operations/admin_api/add_policy.go index b8f7c4d06..763074765 100644 --- a/restapi/operations/admin_api/add_policy.go +++ b/restapi/operations/admin_api/add_policy.go @@ -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 diff --git a/restapi/operations/admin_api/add_user.go b/restapi/operations/admin_api/add_user.go index f64963e9a..2fe018780 100644 --- a/restapi/operations/admin_api/add_user.go +++ b/restapi/operations/admin_api/add_user.go @@ -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 diff --git a/restapi/operations/admin_api/config_info.go b/restapi/operations/admin_api/config_info.go index b64638690..5302bd2d0 100644 --- a/restapi/operations/admin_api/config_info.go +++ b/restapi/operations/admin_api/config_info.go @@ -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 diff --git a/restapi/operations/admin_api/group_info.go b/restapi/operations/admin_api/group_info.go index b06fa0738..82d78a3fc 100644 --- a/restapi/operations/admin_api/group_info.go +++ b/restapi/operations/admin_api/group_info.go @@ -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 diff --git a/restapi/operations/admin_api/list_config.go b/restapi/operations/admin_api/list_config.go index db64defba..aebc15105 100644 --- a/restapi/operations/admin_api/list_config.go +++ b/restapi/operations/admin_api/list_config.go @@ -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 diff --git a/restapi/operations/admin_api/list_groups.go b/restapi/operations/admin_api/list_groups.go index 47541d1ee..f3234427a 100644 --- a/restapi/operations/admin_api/list_groups.go +++ b/restapi/operations/admin_api/list_groups.go @@ -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 diff --git a/restapi/operations/admin_api/list_policies.go b/restapi/operations/admin_api/list_policies.go index 6b2975ac6..5aa7d8be2 100644 --- a/restapi/operations/admin_api/list_policies.go +++ b/restapi/operations/admin_api/list_policies.go @@ -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 diff --git a/restapi/operations/admin_api/list_users.go b/restapi/operations/admin_api/list_users.go index 4839942d2..c1001119f 100644 --- a/restapi/operations/admin_api/list_users.go +++ b/restapi/operations/admin_api/list_users.go @@ -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 diff --git a/restapi/operations/admin_api/policy_info.go b/restapi/operations/admin_api/policy_info.go index 3e6254653..f12656eea 100644 --- a/restapi/operations/admin_api/policy_info.go +++ b/restapi/operations/admin_api/policy_info.go @@ -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 diff --git a/restapi/operations/admin_api/profiling_start.go b/restapi/operations/admin_api/profiling_start.go index 14fa5d27c..b6a1832dd 100644 --- a/restapi/operations/admin_api/profiling_start.go +++ b/restapi/operations/admin_api/profiling_start.go @@ -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 diff --git a/restapi/operations/admin_api/profiling_stop.go b/restapi/operations/admin_api/profiling_stop.go index 2d0677be7..7ee42df5a 100644 --- a/restapi/operations/admin_api/profiling_stop.go +++ b/restapi/operations/admin_api/profiling_stop.go @@ -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 diff --git a/restapi/operations/admin_api/remove_group.go b/restapi/operations/admin_api/remove_group.go index ff597373b..76b83134b 100644 --- a/restapi/operations/admin_api/remove_group.go +++ b/restapi/operations/admin_api/remove_group.go @@ -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 diff --git a/restapi/operations/admin_api/remove_policy.go b/restapi/operations/admin_api/remove_policy.go index b7060c815..5864fab9f 100644 --- a/restapi/operations/admin_api/remove_policy.go +++ b/restapi/operations/admin_api/remove_policy.go @@ -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 diff --git a/restapi/operations/admin_api/restart_service.go b/restapi/operations/admin_api/restart_service.go index c013de50d..3b5b3adb3 100644 --- a/restapi/operations/admin_api/restart_service.go +++ b/restapi/operations/admin_api/restart_service.go @@ -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 diff --git a/restapi/operations/admin_api/set_config.go b/restapi/operations/admin_api/set_config.go index cbfa41618..417894c8b 100644 --- a/restapi/operations/admin_api/set_config.go +++ b/restapi/operations/admin_api/set_config.go @@ -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 diff --git a/restapi/operations/admin_api/set_policy.go b/restapi/operations/admin_api/set_policy.go index 9b91628a0..4b3f05766 100644 --- a/restapi/operations/admin_api/set_policy.go +++ b/restapi/operations/admin_api/set_policy.go @@ -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 diff --git a/restapi/operations/admin_api/update_group.go b/restapi/operations/admin_api/update_group.go index 93da50f0e..47fbcd2c8 100644 --- a/restapi/operations/admin_api/update_group.go +++ b/restapi/operations/admin_api/update_group.go @@ -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 diff --git a/restapi/operations/mcs_api.go b/restapi/operations/mcs_api.go index 18bf61bac..c7829ec8f 100644 --- a/restapi/operations/mcs_api.go +++ b/restapi/operations/mcs_api.go @@ -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) + }) } } diff --git a/restapi/operations/user_api/bucket_info.go b/restapi/operations/user_api/bucket_info.go index 4e4deda21..757640307 100644 --- a/restapi/operations/user_api/bucket_info.go +++ b/restapi/operations/user_api/bucket_info.go @@ -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 diff --git a/restapi/operations/user_api/bucket_set_policy.go b/restapi/operations/user_api/bucket_set_policy.go index aac9c386f..255e2124c 100644 --- a/restapi/operations/user_api/bucket_set_policy.go +++ b/restapi/operations/user_api/bucket_set_policy.go @@ -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 diff --git a/restapi/operations/user_api/delete_bucket.go b/restapi/operations/user_api/delete_bucket.go index 6cbdd388b..3ba3e5245 100644 --- a/restapi/operations/user_api/delete_bucket.go +++ b/restapi/operations/user_api/delete_bucket.go @@ -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 diff --git a/restapi/operations/user_api/list_bucket_events.go b/restapi/operations/user_api/list_bucket_events.go index bd2ad2c8d..d9b55a247 100644 --- a/restapi/operations/user_api/list_bucket_events.go +++ b/restapi/operations/user_api/list_bucket_events.go @@ -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 diff --git a/restapi/operations/user_api/list_buckets.go b/restapi/operations/user_api/list_buckets.go index 0952660cf..4483b128b 100644 --- a/restapi/operations/user_api/list_buckets.go +++ b/restapi/operations/user_api/list_buckets.go @@ -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 diff --git a/restapi/operations/user_api/make_bucket.go b/restapi/operations/user_api/make_bucket.go index 5ded63682..3d243a485 100644 --- a/restapi/operations/user_api/make_bucket.go +++ b/restapi/operations/user_api/make_bucket.go @@ -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 diff --git a/restapi/user_buckets.go b/restapi/user_buckets.go index 31e2346ca..c08e177c3 100644 --- a/restapi/user_buckets.go +++ b/restapi/user_buckets.go @@ -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())}) diff --git a/restapi/user_buckets_events.go b/restapi/user_buckets_events.go index b9a937f2b..c0148a717 100644 --- a/restapi/user_buckets_events.go +++ b/restapi/user_buckets_events.go @@ -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())})