Remove the last k8s import on restapi (#877)

* Remove the last k8s import on restapi Signed-off-by: Daniel Valdivia <18384552+dvaldivia@users.noreply.github.com>
2021-07-19 17:17:56 -07:00
parent 2a6a6cab24
commit ff7c305345
35 changed files with 289 additions and 313 deletions
--- a/restapi/admin_arns.go
+++ b/restapi/admin_arns.go
@@ -54,7 +54,7 @@ func getArns(ctx context.Context, client MinioAdmin) (*models.ArnsResponse, erro
 func getArnsResponse(session *models.Principal) (*models.ArnsResponse, *models.Error) {
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -65,7 +65,7 @@ func getArnsResponse(session *models.Principal) (*models.ArnsResponse, *models.E
 	// serialize output
 	arnsList, err := getArns(ctx, adminClient)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return arnsList, nil
 }
--- a/restapi/admin_config.go
+++ b/restapi/admin_config.go
@@ -79,7 +79,7 @@ func listConfig(client MinioAdmin) ([]*models.ConfigDescription, error) {
 func getListConfigResponse(session *models.Principal) (*models.ListConfigResponse, *models.Error) {
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
@@ -87,7 +87,7 @@ func getListConfigResponse(session *models.Principal) (*models.ListConfigRespons

 	configDescs, err := listConfig(adminClient)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	listGroupsResponse := &models.ListConfigResponse{
 		Configurations: configDescs,
@@ -127,7 +127,7 @@ func getConfigResponse(session *models.Principal, params admin_api.ConfigInfoPar
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
@@ -135,7 +135,7 @@ func getConfigResponse(session *models.Principal, params admin_api.ConfigInfoPar

 	configkv, err := getConfig(ctx, adminClient, params.Name)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	configurationObj := &models.Configuration{
 		Name:      params.Name,
@@ -179,7 +179,7 @@ func buildConfig(configName *string, kvs []*models.ConfigurationKV) *string {
 func setConfigResponse(session *models.Principal, name string, configRequest *models.SetConfigRequest) (*models.SetConfigResponse, *models.Error) {
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
@@ -190,7 +190,7 @@ func setConfigResponse(session *models.Principal, name string, configRequest *mo

 	needsRestart, err := setConfigWithARNAccountID(ctx, adminClient, &configName, configRequest.KeyValues, configRequest.ArnResourceID)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return &models.SetConfigResponse{Restart: needsRestart}, nil
 }
--- a/restapi/admin_groups.go
+++ b/restapi/admin_groups.go
@@ -75,7 +75,7 @@ func getListGroupsResponse(session *models.Principal) (*models.ListGroupsRespons
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
@@ -83,7 +83,7 @@ func getListGroupsResponse(session *models.Principal) (*models.ListGroupsRespons

 	groups, err := adminClient.listGroups(ctx)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	// serialize output
@@ -109,7 +109,7 @@ func getGroupInfoResponse(session *models.Principal, params admin_api.GroupInfoP
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
@@ -117,7 +117,7 @@ func getGroupInfoResponse(session *models.Principal, params admin_api.GroupInfoP

 	groupDesc, err := groupInfo(ctx, adminClient, params.Name)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	groupResponse := &models.Group{
@@ -148,19 +148,19 @@ func getAddGroupResponse(session *models.Principal, params *models.AddGroupReque
 	ctx := context.Background()
 	// AddGroup request needed to proceed
 	if params == nil {
-		return PrepareError(errGroupBodyNotInRequest)
+		return prepareError(errGroupBodyNotInRequest)
 	}

 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
 	adminClient := AdminClient{Client: mAdmin}

 	if err := addGroup(ctx, adminClient, *params.Group, params.Members); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -184,18 +184,18 @@ func getRemoveGroupResponse(session *models.Principal, params admin_api.RemoveGr
 	ctx := context.Background()

 	if params.Name == "" {
-		return PrepareError(errGroupNameNotInRequest)
+		return prepareError(errGroupNameNotInRequest)
 	}
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// createad a MinIO Admin Client interface implementation
 	// defining the client to be used
 	adminClient := AdminClient{Client: mAdmin}

 	if err := removeGroup(ctx, adminClient, params.Name); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -257,10 +257,10 @@ func setGroupStatus(ctx context.Context, client MinioAdmin, group, status string
 func getUpdateGroupResponse(session *models.Principal, params admin_api.UpdateGroupParams) (*models.Group, *models.Error) {
 	ctx := context.Background()
 	if params.Name == "" {
-		return nil, PrepareError(errGroupNameNotInRequest)
+		return nil, prepareError(errGroupNameNotInRequest)
 	}
 	if params.Body == nil {
-		return nil, PrepareError(errGroupBodyNotInRequest)
+		return nil, prepareError(errGroupBodyNotInRequest)

 	}
 	expectedGroupUpdate := params.Body
@@ -268,7 +268,7 @@ func getUpdateGroupResponse(session *models.Principal, params admin_api.UpdateGr

 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
@@ -276,7 +276,7 @@ func getUpdateGroupResponse(session *models.Principal, params admin_api.UpdateGr

 	groupUpdated, err := groupUpdate(ctx, adminClient, groupName, expectedGroupUpdate)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	groupResponse := &models.Group{
 		Name:    groupUpdated.Name,
--- a/restapi/admin_info.go
+++ b/restapi/admin_info.go
@@ -792,7 +792,7 @@ func getAdminInfoResponse(session *models.Principal) (*models.AdminInfoResponse,
 	prometheusURL := getPrometheusURL()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	sessionResp, err2 := getUsageWidgetsForDeployment(prometheusURL, mAdmin)
@@ -814,7 +814,7 @@ func getUsageWidgetsForDeployment(prometheusURL string, mAdmin *madmin.AdminClie
 		// serialize output
 		usage, err := GetAdminInfo(ctx, adminClient)
 		if err != nil {
-			return nil, PrepareError(err)
+			return nil, prepareError(err)
 		}
 		sessionResp := &models.AdminInfoResponse{
 			Buckets: usage.Buckets,
--- a/restapi/admin_notification_endpoints.go
+++ b/restapi/admin_notification_endpoints.go
@@ -79,7 +79,7 @@ func getNotificationEndpoints(ctx context.Context, client MinioAdmin) (*models.N
 func getNotificationEndpointsResponse(session *models.Principal) (*models.NotifEndpointResponse, *models.Error) {
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -90,7 +90,7 @@ func getNotificationEndpointsResponse(session *models.Principal) (*models.NotifE
 	// serialize output
 	notfEndpointResp, err := getNotificationEndpoints(ctx, adminClient)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return notfEndpointResp, nil
 }
@@ -150,7 +150,7 @@ func addNotificationEndpoint(ctx context.Context, client MinioAdmin, params *adm
 func getAddNotificationEndpointResponse(session *models.Principal, params *admin_api.AddNotificationEndpointParams) (*models.SetNotificationEndpointResponse, *models.Error) {
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -161,7 +161,7 @@ func getAddNotificationEndpointResponse(session *models.Principal, params *admin
 	// serialize output
 	notfEndpointResp, err := addNotificationEndpoint(ctx, adminClient, params)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return notfEndpointResp, nil
 }
--- a/restapi/admin_policies.go
+++ b/restapi/admin_policies.go
@@ -102,7 +102,7 @@ func getListPoliciesWithBucketResponse(session *models.Principal, bucket string)
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
@@ -110,7 +110,7 @@ func getListPoliciesWithBucketResponse(session *models.Principal, bucket string)

 	policies, err := listPoliciesWithBucket(ctx, bucket, adminClient)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// serialize output
 	listPoliciesResponse := &models.ListPoliciesResponse{
@@ -180,7 +180,7 @@ func getListPoliciesResponse(session *models.Principal) (*models.ListPoliciesRes
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
@@ -188,7 +188,7 @@ func getListPoliciesResponse(session *models.Principal) (*models.ListPoliciesRes

 	policies, err := listPolicies(ctx, adminClient)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// serialize output
 	listPoliciesResponse := &models.ListPoliciesResponse{
@@ -203,7 +203,7 @@ func getListUsersForPolicyResponse(session *models.Principal, policy string) ([]
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -211,7 +211,7 @@ func getListUsersForPolicyResponse(session *models.Principal, policy string) ([]

 	users, err := listUsers(ctx, adminClient)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	var filteredUsers []string
@@ -231,7 +231,7 @@ func getListGroupsForPolicyResponse(session *models.Principal, policy string) ([
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -239,7 +239,7 @@ func getListGroupsForPolicyResponse(session *models.Principal, policy string) ([

 	groups, err := adminClient.listGroups(ctx)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	var filteredGroups []string
@@ -269,18 +269,18 @@ func removePolicy(ctx context.Context, client MinioAdmin, name string) error {
 func getRemovePolicyResponse(session *models.Principal, params admin_api.RemovePolicyParams) *models.Error {
 	ctx := context.Background()
 	if params.Name == "" {
-		return PrepareError(errPolicyNameNotInRequest)
+		return prepareError(errPolicyNameNotInRequest)
 	}
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
 	adminClient := AdminClient{Client: mAdmin}

 	if err := removePolicy(ctx, adminClient, params.Name); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -308,19 +308,19 @@ func addPolicy(ctx context.Context, client MinioAdmin, name, policy string) (*mo
 func getAddPolicyResponse(session *models.Principal, params *models.AddPolicyRequest) (*models.Policy, *models.Error) {
 	ctx := context.Background()
 	if params == nil {
-		return nil, PrepareError(errPolicyBodyNotInRequest)
+		return nil, prepareError(errPolicyBodyNotInRequest)
 	}

 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
 	adminClient := AdminClient{Client: mAdmin}
 	policy, err := addPolicy(ctx, adminClient, *params.Name, *params.Policy)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return policy, nil
 }
@@ -346,14 +346,14 @@ func getPolicyInfoResponse(session *models.Principal, params admin_api.PolicyInf
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
 	adminClient := AdminClient{Client: mAdmin}
 	policy, err := policyInfo(ctx, adminClient, params.Name)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return policy, nil
 }
@@ -371,18 +371,18 @@ func setPolicy(ctx context.Context, client MinioAdmin, name, entityName string,
 func getSetPolicyResponse(session *models.Principal, name string, params *models.SetPolicyRequest) *models.Error {
 	ctx := context.Background()
 	if name == "" {
-		return PrepareError(errPolicyNameNotInRequest)
+		return prepareError(errPolicyNameNotInRequest)
 	}
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
 	adminClient := AdminClient{Client: mAdmin}

 	if err := setPolicy(ctx, adminClient, name, *params.EntityName, *params.EntityType); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -391,14 +391,14 @@ func getSetPolicyMultipleResponse(session *models.Principal, name string, params
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
 	adminClient := AdminClient{Client: mAdmin}

 	if err := setPolicyMultipleEntities(ctx, adminClient, name, params.Users, params.Groups); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
--- a/restapi/admin_profiling.go
+++ b/restapi/admin_profiling.go
@@ -86,18 +86,18 @@ func startProfiling(ctx context.Context, client MinioAdmin, profilerType models.
 func getProfilingStartResponse(session *models.Principal, params *models.ProfilingStartRequest) (*models.StartProfilingList, *models.Error) {
 	ctx := context.Background()
 	if params == nil {
-		return nil, PrepareError(errPolicyBodyNotInRequest)
+		return nil, prepareError(errPolicyBodyNotInRequest)
 	}
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
 	adminClient := AdminClient{Client: mAdmin}
 	profilingItems, err := startProfiling(ctx, adminClient, *params.Type)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	profilingList := &models.StartProfilingList{
 		StartResults: profilingItems,
@@ -121,14 +121,14 @@ func getProfilingStopResponse(session *models.Principal) (io.ReadCloser, *models
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
 	adminClient := AdminClient{Client: mAdmin}
 	profilingData, err := stopProfiling(ctx, adminClient)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return profilingData, nil
 }
--- a/restapi/admin_remote_buckets.go
+++ b/restapi/admin_remote_buckets.go
@@ -410,14 +410,14 @@ func setMultiBucketReplicationResponse(session *models.Principal, params user_ap
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
 		LogError("error creating Madmin Client:", err)
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	adminClient := AdminClient{Client: mAdmin}

 	mClient, err := newMinioClient(session)
 	if err != nil {
 		LogError("error creating MinIO Client:", err)
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -427,7 +427,7 @@ func setMultiBucketReplicationResponse(session *models.Principal, params user_ap

 	if replicationResults == nil {
 		err = errors.New("error setting buckets replication")
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	resParsed := []*models.MultiBucketResponseItem{}
@@ -454,14 +454,14 @@ func listExternalBucketsResponse(params user_api.ListExternalBucketsParams) (*mo
 	defer cancel()
 	remoteAdmin, err := newAdminFromCreds(*params.Body.AccessKey, *params.Body.SecretKey, *params.Body.TargetURL, *params.Body.UseTLS)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
 	remoteClient := AdminClient{Client: remoteAdmin}
 	buckets, err := getAccountInfo(ctx, remoteClient)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	// serialize output
@@ -514,7 +514,7 @@ func deleteReplicationRuleResponse(session *models.Principal, params user_api.De
 	err := deleteReplicationRule(ctx, session, params.BucketName, params.RuleID)

 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
--- a/restapi/admin_service.go
+++ b/restapi/admin_service.go
@@ -63,14 +63,14 @@ func getRestartServiceResponse(session *models.Principal) *models.Error {
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a MinIO Admin Client interface implementation
 	// defining the client to be used
 	adminClient := AdminClient{Client: mAdmin}

 	if err := serviceRestart(ctx, adminClient); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
--- a/restapi/admin_subscription.go
+++ b/restapi/admin_subscription.go
@@ -72,7 +72,7 @@ func getSubscriptionInfoResponse() (*models.License, *models.Error) {
 	// validate license key and obtain license info
 	licenseInfo, _, err := subscriptionValidate(client, licenseKey, "", "")
 	if err != nil {
-		return nil, PrepareError(errLicenseNotFound, nil, err)
+		return nil, prepareError(errLicenseNotFound, nil, err)
 	}
 	return licenseInfo, nil
 }
--- a/restapi/admin_tiers.go
+++ b/restapi/admin_tiers.go
@@ -133,7 +133,7 @@ func getTiers(ctx context.Context, client MinioAdmin) (*models.TierListResponse,
 func getTiersResponse(session *models.Principal) (*models.TierListResponse, *models.Error) {
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -144,7 +144,7 @@ func getTiersResponse(session *models.Principal) (*models.TierListResponse, *mod
 	// serialize output
 	tiersResp, err := getTiers(ctx, adminClient)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return tiersResp, nil
 }
@@ -223,7 +223,7 @@ func addTier(ctx context.Context, client MinioAdmin, params *admin_api.AddTierPa
 func getAddTierResponse(session *models.Principal, params *admin_api.AddTierParams) *models.Error {
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -234,7 +234,7 @@ func getAddTierResponse(session *models.Principal, params *admin_api.AddTierPara
 	// serialize output
 	errTier := addTier(ctx, adminClient, params)
 	if errTier != nil {
-		return PrepareError(errTier)
+		return prepareError(errTier)
 	}
 	return nil
 }
@@ -306,7 +306,7 @@ func getTier(ctx context.Context, client MinioAdmin, params *admin_api.GetTierPa
 func getGetTierResponse(session *models.Principal, params *admin_api.GetTierParams) (*models.Tier, *models.Error) {
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -317,7 +317,7 @@ func getGetTierResponse(session *models.Principal, params *admin_api.GetTierPara
 	// serialize output
 	addTierResp, err := getTier(ctx, adminClient, params)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return addTierResp, nil
 }
@@ -342,7 +342,7 @@ func editTierCredentials(ctx context.Context, client MinioAdmin, params *admin_a
 func getEditTierCredentialsResponse(session *models.Principal, params *admin_api.EditTierCredentialsParams) *models.Error {
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -353,7 +353,7 @@ func getEditTierCredentialsResponse(session *models.Principal, params *admin_api
 	// serialize output
 	err = editTierCredentials(ctx, adminClient, params)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
--- a/restapi/admin_users.go
+++ b/restapi/admin_users.go
@@ -145,7 +145,7 @@ func getListUsersResponse(session *models.Principal) (*models.ListUsersResponse,
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -153,7 +153,7 @@ func getListUsersResponse(session *models.Principal) (*models.ListUsersResponse,

 	users, err := listUsers(ctx, adminClient)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// serialize output
 	listUsersResponse := &models.ListUsersResponse{
@@ -191,7 +191,7 @@ func getUserAddResponse(session *models.Principal, params admin_api.AddUserParam
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -199,7 +199,7 @@ func getUserAddResponse(session *models.Principal, params admin_api.AddUserParam

 	user, err := addUser(ctx, adminClient, params.Body.AccessKey, params.Body.SecretKey, params.Body.Groups)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return user, nil
 }
@@ -214,11 +214,11 @@ func getRemoveUserResponse(session *models.Principal, params admin_api.RemoveUse

 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}

 	if session.AccountAccessKey == params.Name {
-		return PrepareError(errAvoidSelfAccountDelete)
+		return prepareError(errAvoidSelfAccountDelete)
 	}

 	// create a minioClient interface implementation
@@ -226,7 +226,7 @@ func getRemoveUserResponse(session *models.Principal, params admin_api.RemoveUse
 	adminClient := AdminClient{Client: mAdmin}

 	if err := removeUser(ctx, adminClient, params.Name); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}

 	return nil
@@ -247,7 +247,7 @@ func getUserInfoResponse(session *models.Principal, params admin_api.GetUserInfo

 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	// create a minioClient interface implementation
@@ -256,7 +256,7 @@ func getUserInfoResponse(session *models.Principal, params admin_api.GetUserInfo

 	user, err := getUserInfo(ctx, adminClient, params.Name)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	userInformation := &models.User{
@@ -362,7 +362,7 @@ func getUpdateUserGroupsResponse(session *models.Principal, params admin_api.Upd

 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	// create a minioClient interface implementation
@@ -372,7 +372,7 @@ func getUpdateUserGroupsResponse(session *models.Principal, params admin_api.Upd
 	user, err := updateUserGroups(ctx, adminClient, params.Name, params.Body.Groups)

 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	return user, nil
@@ -398,7 +398,7 @@ func getUpdateUserResponse(session *models.Principal, params admin_api.UpdateUse

 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	// create a minioClient interface implementation
@@ -410,13 +410,13 @@ func getUpdateUserResponse(session *models.Principal, params admin_api.UpdateUse
 	groups := params.Body.Groups

 	if err := setUserStatus(ctx, adminClient, name, status); err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	userElem, errUG := updateUserGroups(ctx, adminClient, name, groups)

 	if errUG != nil {
-		return nil, PrepareError(errUG)
+		return nil, prepareError(errUG)
 	}
 	return userElem, nil
 }
@@ -469,7 +469,7 @@ func getAddUsersListToGroupsResponse(session *models.Principal, params admin_api

 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}

 	// create a minioClient interface implementation
@@ -480,7 +480,7 @@ func getAddUsersListToGroupsResponse(session *models.Principal, params admin_api
 	groupsList := params.Body.Groups

 	if err := addUsersListToGroups(ctx, adminClient, usersList, groupsList); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}

 	return nil
@@ -490,7 +490,7 @@ func getListUsersWithAccessToBucketResponse(session *models.Principal, bucket st
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -519,7 +519,7 @@ func policyAllowsAndMatchesBucket(policy *iampolicy.Policy, bucket string) int {
 func listUsersWithAccessToBucket(ctx context.Context, adminClient MinioAdmin, bucket string) ([]string, *models.Error) {
 	users, err := adminClient.listUsers(ctx)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	var retval []string
 	akHasAccess := make(map[string]struct{})
@@ -597,7 +597,7 @@ func getChangeUserPasswordResponse(session *models.Principal, params admin_api.C
 	ctx := context.Background()
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -609,7 +609,7 @@ func getChangeUserPasswordResponse(session *models.Principal, params admin_api.C

 	// changes password of user to newSecretKey
 	if err := changeUserPassword(ctx, adminClient, user, newSecretKey); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
--- a/restapi/error.go
+++ b/restapi/error.go
@@ -8,7 +8,6 @@ import (
 	"github.com/go-openapi/swag"
 	"github.com/minio/console/models"
 	"github.com/minio/madmin-go"
-	k8sErrors "k8s.io/apimachinery/pkg/api/errors"
 )

 var (
@@ -16,8 +15,6 @@ var (
 	ErrorGeneric               = errors.New("an error occurred, please try again")
 	errInvalidCredentials      = errors.New("invalid Login")
 	errorGenericInvalidSession = errors.New("invalid session")
-	errorGenericUnauthorized   = errors.New("unauthorized")
-	errorGenericForbidden      = errors.New("forbidden")
 	// ErrorGenericNotFound Generic error for not found
 	ErrorGenericNotFound = errors.New("not found")
 	// Explicit error messages
@@ -38,26 +35,14 @@ var (
 	errAccessDenied                 = errors.New("access denied")
 )

-// PrepareError receives an error object and parse it against k8sErrors, returns the right error code paired with a generic error message
-func PrepareError(err ...error) *models.Error {
+// prepareError receives an error object and parse it against k8sErrors, returns the right error code paired with a generic error message
+func prepareError(err ...error) *models.Error {
 	errorCode := int32(500)
 	errorMessage := ErrorGeneric.Error()
 	if len(err) > 0 {
 		frame := getFrame(2)
 		fileParts := strings.Split(frame.File, "/")
 		LogError("original error -> (%s:%d: %v)", fileParts[len(fileParts)-1], frame.Line, err[0])
-		if k8sErrors.IsUnauthorized(err[0]) {
-			errorCode = 401
-			errorMessage = errorGenericUnauthorized.Error()
-		}
-		if k8sErrors.IsForbidden(err[0]) {
-			errorCode = 403
-			errorMessage = errorGenericForbidden.Error()
-		}
-		if k8sErrors.IsNotFound(err[0]) {
-			errorCode = 404
-			errorMessage = ErrorGenericNotFound.Error()
-		}
 		if err[0] == ErrorGenericNotFound {
 			errorCode = 404
 			errorMessage = ErrorGenericNotFound.Error()
--- a/restapi/user_account.go
+++ b/restapi/user_account.go
@@ -73,7 +73,7 @@ func getChangePasswordResponse(session *models.Principal, params user_api.Accoun
 		STSSecretAccessKey: *params.Body.CurrentSecretKey,
 	})
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// parentAccountClient will contain access and secret key credentials for the user
 	userClient := AdminClient{Client: parentAccountClient}
@@ -82,18 +82,18 @@ func getChangePasswordResponse(session *models.Principal, params user_api.Accoun

 	// currentSecretKey will compare currentSecretKey against the stored secret key inside the encrypted session
 	if err := changePassword(ctx, userClient, session, newSecretKey); err != nil {
-		return nil, PrepareError(errChangePassword, nil, err)
+		return nil, prepareError(errChangePassword, nil, err)
 	}
 	// user credentials are updated at this point, we need to generate a new admin client and authenticate using
 	// the new credentials
 	credentials, err := getConsoleCredentials(ctx, accessKey, newSecretKey)
 	if err != nil {
-		return nil, PrepareError(errInvalidCredentials, nil, err)
+		return nil, prepareError(errInvalidCredentials, nil, err)
 	}
 	// authenticate user and generate new session token
 	sessionID, err := login(credentials)
 	if err != nil {
-		return nil, PrepareError(errInvalidCredentials, nil, err)
+		return nil, prepareError(errInvalidCredentials, nil, err)
 	}
 	// serialize output
 	loginResponse := &models.LoginResponse{
@@ -108,7 +108,7 @@ func getUserHasPermissionsResponse(session *models.Principal, params user_api.Ha

 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -116,7 +116,7 @@ func getUserHasPermissionsResponse(session *models.Principal, params user_api.Ha

 	userPolicy, err := getAccountPolicy(ctx, adminClient)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	var perms []*models.PermissionAction
--- a/restapi/user_bucket_quota.go
+++ b/restapi/user_bucket_quota.go
@@ -54,7 +54,7 @@ func registerBucketQuotaHandlers(api *operations.ConsoleAPI) {
 func setBucketQuotaResponse(session *models.Principal, params user_api.SetBucketQuotaParams) *models.Error {
 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -102,7 +102,7 @@ func getBucketQuotaResponse(session *models.Principal, params user_api.GetBucket

 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	// create a minioClient interface implementation
--- a/restapi/user_buckets.go
+++ b/restapi/user_buckets.go
@@ -182,7 +182,7 @@ func doSetVersioning(client MCClient, state VersionState) error {
 func setBucketVersioningResponse(session *models.Principal, bucketName string, params *user_api.SetBucketVersioningParams) *models.Error {
 	s3Client, err := newS3BucketClient(session, bucketName, "")
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a mc S3Client interface implementation
 	// defining the client to be used
@@ -195,7 +195,7 @@ func setBucketVersioningResponse(session *models.Principal, bucketName string, p
 	}

 	if err := doSetVersioning(amcClient, versioningState); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -324,14 +324,14 @@ func getListBucketsResponse(session *models.Principal) (*models.ListBucketsRespo

 	mAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
 	adminClient := AdminClient{Client: mAdmin}
 	buckets, err := getAccountInfo(ctx, adminClient)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	// serialize output
@@ -354,11 +354,11 @@ func getMakeBucketResponse(session *models.Principal, br *models.MakeBucketReque
 	defer cancel()
 	// bucket request needed to proceed
 	if br == nil {
-		return PrepareError(errBucketBodyNotInRequest)
+		return prepareError(errBucketBodyNotInRequest)
 	}
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -370,7 +370,7 @@ func getMakeBucketResponse(session *models.Principal, br *models.MakeBucketReque
 	}

 	if err := makeBucket(ctx, minioClient, *br.Name, br.Locking); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}

 	// make sure to delete bucket if an error occurs after bucket was created
@@ -387,14 +387,14 @@ func getMakeBucketResponse(session *models.Principal, br *models.MakeBucketReque
 	if br.Versioning || br.Retention != nil {
 		s3Client, err := newS3BucketClient(session, *br.Name, "")
 		if err != nil {
-			return PrepareError(err)
+			return prepareError(err)
 		}
 		// create a mc S3Client interface implementation
 		// defining the client to be used
 		amcClient := mcClient{client: s3Client}

 		if err = doSetVersioning(amcClient, VersionEnable); err != nil {
-			return PrepareError(err)
+			return prepareError(err)
 		}
 	}

@@ -402,7 +402,7 @@ func getMakeBucketResponse(session *models.Principal, br *models.MakeBucketReque
 	if br.Quota != nil && br.Quota.Enabled != nil && *br.Quota.Enabled {
 		mAdmin, err := NewMinioAdminClient(session)
 		if err != nil {
-			return PrepareError(err)
+			return prepareError(err)
 		}
 		// create a minioClient interface implementation
 		// defining the client to be used
@@ -417,7 +417,7 @@ func getMakeBucketResponse(session *models.Principal, br *models.MakeBucketReque
 	if br.Retention != nil {
 		err = setBucketRetentionConfig(ctx, minioClient, *br.Name, *br.Retention.Mode, *br.Retention.Unit, br.Retention.Validity)
 		if err != nil {
-			return PrepareError(err)
+			return prepareError(err)
 		}
 	}
 	return nil
@@ -459,7 +459,7 @@ func getBucketSetPolicyResponse(session *models.Principal, bucketName string, re

 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -467,12 +467,12 @@ func getBucketSetPolicyResponse(session *models.Principal, bucketName string, re

 	// set bucket access policy
 	if err := setBucketAccessPolicy(ctx, minioClient, bucketName, *req.Access); err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// get updated bucket details and return it
 	bucket, err := getBucketInfo(minioClient, bucketName)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return bucket, nil
 }
@@ -485,19 +485,19 @@ func removeBucket(client MinioClient, bucketName string) error {
 // getDeleteBucketResponse performs removeBucket() to delete a bucket
 func getDeleteBucketResponse(session *models.Principal, params user_api.DeleteBucketParams) *models.Error {
 	if params.Name == "" {
-		return PrepareError(errBucketNameNotInRequest)
+		return prepareError(errBucketNameNotInRequest)
 	}
 	bucketName := params.Name

 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
 	minioClient := minioClient{client: mClient}
 	if err := removeBucket(minioClient, bucketName); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -535,7 +535,7 @@ func getBucketInfo(client MinioClient, bucketName string) (*models.Bucket, error
 func getBucketInfoResponse(session *models.Principal, params user_api.BucketInfoParams) (*models.Bucket, *models.Error) {
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -543,7 +543,7 @@ func getBucketInfoResponse(session *models.Principal, params user_api.BucketInfo

 	bucket, err := getBucketInfo(minioClient, params.Name)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return bucket, nil

@@ -593,13 +593,13 @@ func enableBucketEncryptionResponse(session *models.Principal, params user_api.E
 	defer cancel()
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
 	minioClient := minioClient{client: mClient}
 	if err := enableBucketEncryption(ctx, minioClient, params.BucketName, *params.Body.EncType, params.Body.KmsKeyID); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -615,13 +615,13 @@ func disableBucketEncryptionResponse(session *models.Principal, params user_api.
 	defer cancel()
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
 	minioClient := minioClient{client: mClient}
 	if err := disableBucketEncryption(ctx, minioClient, params.BucketName); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -642,14 +642,14 @@ func getBucketEncryptionInfoResponse(session *models.Principal, params user_api.
 	defer cancel()
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
 	minioClient := minioClient{client: mClient}
 	bucketInfo, err := getBucketEncryptionInfo(ctx, minioClient, params.BucketName)
 	if err != nil {
-		return nil, PrepareError(errSSENotConfigured, err)
+		return nil, prepareError(errSSENotConfigured, err)
 	}
 	return bucketInfo, nil
 }
@@ -689,14 +689,14 @@ func getSetBucketRetentionConfigResponse(session *models.Principal, params user_
 	defer cancel()
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
 	minioClient := minioClient{client: mClient}
 	err = setBucketRetentionConfig(ctx, minioClient, params.BucketName, *params.Body.Mode, *params.Body.Unit, params.Body.Validity)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -743,7 +743,7 @@ func getBucketRetentionConfigResponse(session *models.Principal, bucketName stri
 	defer cancel()
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -751,7 +751,7 @@ func getBucketRetentionConfigResponse(session *models.Principal, bucketName stri

 	config, err := getBucketRetentionConfig(ctx, minioClient, bucketName)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return config, nil
 }
@@ -800,7 +800,7 @@ func getBucketRewindResponse(session *models.Principal, params user_api.GetBucke
 	s3Client, err := newS3BucketClient(session, params.BucketName, prefix)
 	if err != nil {
 		LogError("error creating S3Client: %v", err)
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	// create a mc S3Client interface implementation
@@ -810,7 +810,7 @@ func getBucketRewindResponse(session *models.Principal, params user_api.GetBucke
 	parsedDate, errDate := time.Parse(time.RFC3339, params.Date)

 	if errDate != nil {
-		return nil, PrepareError(errDate)
+		return nil, prepareError(errDate)
 	}

 	var rewindItems []*models.RewindItem
--- a/restapi/user_buckets_events.go
+++ b/restapi/user_buckets_events.go
@@ -127,7 +127,7 @@ func listBucketEvents(client MinioClient, bucketName string) ([]*models.Notifica
 func getListBucketEventsResponse(session *models.Principal, params user_api.ListBucketEventsParams) (*models.ListBucketEventsResponse, *models.Error) {
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -135,7 +135,7 @@ func getListBucketEventsResponse(session *models.Principal, params user_api.List

 	bucketEvents, err := listBucketEvents(minioClient, params.BucketName)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// serialize output
 	listBucketsResponse := &models.ListBucketEventsResponse{
@@ -179,14 +179,14 @@ func getCreateBucketEventsResponse(session *models.Principal, bucketName string,
 	ctx := context.Background()
 	s3Client, err := newS3BucketClient(session, bucketName, "")
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a mc S3Client interface implementation
 	// defining the client to be used
 	mcClient := mcClient{client: s3Client}
 	err = createBucketEvent(ctx, mcClient, *eventReq.Configuration.Arn, eventReq.Configuration.Events, eventReq.Configuration.Prefix, eventReq.Configuration.Suffix, eventReq.IgnoreExisting)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -214,14 +214,14 @@ func getDeleteBucketEventsResponse(session *models.Principal, bucketName string,
 	ctx := context.Background()
 	s3Client, err := newS3BucketClient(session, bucketName, "")
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a mc S3Client interface implementation
 	// defining the client to be used
 	mcClient := mcClient{client: s3Client}
 	err = deleteBucketEventNotification(ctx, mcClient, arn, events, prefix, suffix)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
--- a/restapi/user_buckets_lifecycle.go
+++ b/restapi/user_buckets_lifecycle.go
@@ -98,7 +98,7 @@ func getBucketLifecycleResponse(session *models.Principal, params user_api.GetBu
 	ctx := context.Background()
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -106,7 +106,7 @@ func getBucketLifecycleResponse(session *models.Principal, params user_api.GetBu

 	bucketEvents, err := getBucketLifecycle(ctx, minioClient, params.BucketName)
 	if err != nil {
-		return nil, PrepareError(errBucketLifeCycleNotConfigured, err)
+		return nil, prepareError(errBucketLifeCycleNotConfigured, err)
 	}
 	return bucketEvents, nil
 }
@@ -233,7 +233,7 @@ func getAddBucketLifecycleResponse(session *models.Principal, params user_api.Ad
 	ctx := context.Background()
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -241,7 +241,7 @@ func getAddBucketLifecycleResponse(session *models.Principal, params user_api.Ad

 	err = addBucketLifecycle(ctx, minioClient, params)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}

 	return nil
--- a/restapi/user_log_search.go
+++ b/restapi/user_log_search.go
@@ -66,13 +66,13 @@ func getLogSearchResponse(params user_api.LogSearchParams) (*models.LogSearchRes
 func logSearch(endpoint string) (*models.LogSearchResponse, *models.Error) {
 	resp, err := http.Get(endpoint)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	body, err := ioutil.ReadAll(resp.Body)
 	resp.Body.Close()
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	if resp.StatusCode != 200 {
@@ -84,7 +84,7 @@ func logSearch(endpoint string) (*models.LogSearchResponse, *models.Error) {

 	var results []logsearchServer.ReqInfoRow
 	if err = json.Unmarshal(body, &results); err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	response := models.LogSearchResponse{
--- a/restapi/user_login.go
+++ b/restapi/user_login.go
@@ -163,11 +163,11 @@ func getLoginResponse(lr *models.LoginRequest) (*models.LoginResponse, *models.E
 	// prepare console credentials
 	consolCreds, err := getConsoleCredentials(ctx, *lr.AccessKey, *lr.SecretKey)
 	if err != nil {
-		return nil, PrepareError(errInvalidCredentials, nil, err)
+		return nil, prepareError(errInvalidCredentials, nil, err)
 	}
 	sessionID, err := login(consolCreds)
 	if err != nil {
-		return nil, PrepareError(errInvalidCredentials, nil, err)
+		return nil, prepareError(errInvalidCredentials, nil, err)
 	}
 	// serialize output
 	loginResponse := &models.LoginResponse{
@@ -188,7 +188,7 @@ func getLoginDetailsResponse() (*models.LoginDetails, *models.Error) {
 		// initialize new oauth2 client
 		oauth2Client, err := oauth2.NewOauth2ProviderClient(ctx, nil, GetConsoleSTSClient())
 		if err != nil {
-			return nil, PrepareError(err)
+			return nil, prepareError(err)
 		}
 		// Validate user against IDP
 		identityProvider := &auth.IdentityProvider{Client: oauth2Client}
@@ -221,18 +221,18 @@ func getLoginOauth2AuthResponse(lr *models.LoginOauth2AuthRequest) (*models.Logi
 		// initialize new oauth2 client
 		oauth2Client, err := oauth2.NewOauth2ProviderClient(ctx, nil, GetConsoleSTSClient())
 		if err != nil {
-			return nil, PrepareError(err)
+			return nil, prepareError(err)
 		}
 		// initialize new identity provider
 		identityProvider := auth.IdentityProvider{Client: oauth2Client}
 		// Validate user against IDP
 		userCredentials, err := verifyUserAgainstIDP(ctx, identityProvider, *lr.Code, *lr.State)
 		if err != nil {
-			return nil, PrepareError(errInvalidCredentials, nil, err)
+			return nil, prepareError(errInvalidCredentials, nil, err)
 		}
 		creds, err := userCredentials.Get()
 		if err != nil {
-			return nil, PrepareError(errInvalidCredentials, nil, err)
+			return nil, prepareError(errInvalidCredentials, nil, err)
 		}
 		// initialize admin client
 		mAdminClient, err := NewMinioAdminClient(&models.Principal{
@@ -241,14 +241,14 @@ func getLoginOauth2AuthResponse(lr *models.LoginOauth2AuthRequest) (*models.Logi
 			STSSessionToken:    creds.SessionToken,
 		})
 		if err != nil {
-			return nil, PrepareError(errInvalidCredentials, nil, err)
+			return nil, prepareError(errInvalidCredentials, nil, err)
 		}
 		userAdminClient := AdminClient{Client: mAdminClient}
 		// Obtain the current policy assigned to this user
 		// necessary for generating the list of allowed endpoints
 		policy, err := getAccountPolicy(ctx, userAdminClient)
 		if err != nil {
-			return nil, PrepareError(ErrorGeneric, nil, err)
+			return nil, prepareError(ErrorGeneric, nil, err)
 		}
 		// by default every user starts with an empty array of available actions
 		// therefore we would have access only to pages that doesn't require any privilege
@@ -265,7 +265,7 @@ func getLoginOauth2AuthResponse(lr *models.LoginOauth2AuthRequest) (*models.Logi
 			Actions:            actions,
 		})
 		if err != nil {
-			return nil, PrepareError(errInvalidCredentials, nil, err)
+			return nil, prepareError(errInvalidCredentials, nil, err)
 		}
 		// serialize output
 		loginResponse := &models.LoginResponse{
@@ -273,19 +273,19 @@ func getLoginOauth2AuthResponse(lr *models.LoginOauth2AuthRequest) (*models.Logi
 		}
 		return loginResponse, nil
 	}
-	return nil, PrepareError(ErrorGeneric)
+	return nil, prepareError(ErrorGeneric)
 }

 // getLoginOperatorResponse validate the provided service account token against k8s api
 func getLoginOperatorResponse(lmr *models.LoginOperatorRequest) (*models.LoginResponse, *models.Error) {
 	creds, err := NewConsoleCredentials("", *lmr.Jwt, "")
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	consoleCreds := ConsoleCredentials{ConsoleCredentials: creds, Actions: []string{}}
 	token, err := login(consoleCreds)
 	if err != nil {
-		return nil, PrepareError(errInvalidCredentials, nil, err)
+		return nil, prepareError(errInvalidCredentials, nil, err)
 	}
 	// serialize output
 	loginResponse := &models.LoginResponse{
--- a/restapi/user_objects.go
+++ b/restapi/user_objects.go
@@ -149,11 +149,11 @@ func getListObjectsResponse(session *models.Principal, params user_api.ListObjec
 	}
 	// bucket request needed to proceed
 	if params.BucketName == "" {
-		return nil, PrepareError(errBucketNameNotInRequest)
+		return nil, prepareError(errBucketNameNotInRequest)
 	}
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
@@ -161,7 +161,7 @@ func getListObjectsResponse(session *models.Principal, params user_api.ListObjec

 	objs, err := listBucketObjects(params.HTTPRequest.Context(), minioClient, params.BucketName, prefix, recursive, withVersions)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}

 	resp := &models.ListObjectsResponse{
@@ -232,14 +232,14 @@ func getDownloadObjectResponse(session *models.Principal, params user_api.Downlo
 	ctx := context.Background()
 	s3Client, err := newS3BucketClient(session, params.BucketName, params.Prefix)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a mc S3Client interface implementation
 	// defining the client to be used
 	mcClient := mcClient{client: s3Client}
 	object, err := downloadObject(ctx, mcClient, params.VersionID)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return object, nil
 }
@@ -263,7 +263,7 @@ func getDeleteObjectResponse(session *models.Principal, params user_api.DeleteOb
 	ctx := context.Background()
 	s3Client, err := newS3BucketClient(session, params.BucketName, params.Path)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a mc S3Client interface implementation
 	// defining the client to be used
@@ -278,7 +278,7 @@ func getDeleteObjectResponse(session *models.Principal, params user_api.DeleteOb
 	}
 	err = deleteObjects(ctx, mcClient, params.BucketName, params.Path, version, rec)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -386,13 +386,13 @@ func getUploadObjectResponse(session *models.Principal, params user_api.PostBuck
 	ctx := context.Background()
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
 	minioClient := minioClient{client: mClient}
 	if err := uploadFiles(ctx, minioClient, params); err != nil {
-		PrepareError(err, ErrorGeneric)
+		prepareError(err, ErrorGeneric)
 	}
 	return nil
 }
@@ -481,7 +481,7 @@ func getShareObjectResponse(session *models.Principal, params user_api.ShareObje
 	ctx := context.Background()
 	s3Client, err := newS3BucketClient(session, params.BucketName, params.Prefix)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a mc S3Client interface implementation
 	// defining the client to be used
@@ -492,7 +492,7 @@ func getShareObjectResponse(session *models.Principal, params user_api.ShareObje
 	}
 	url, err := getShareObjectURL(ctx, mcClient, params.VersionID, expireDuration)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return url, nil
 }
@@ -519,14 +519,14 @@ func getSetObjectLegalHoldResponse(session *models.Principal, params user_api.Pu
 	defer cancel()
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
 	minioClient := minioClient{client: mClient}
 	err = setObjectLegalHold(ctx, minioClient, params.BucketName, params.Prefix, params.VersionID, *params.Body.Status)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -546,14 +546,14 @@ func getSetObjectRetentionResponse(session *models.Principal, params user_api.Pu
 	defer cancel()
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
 	minioClient := minioClient{client: mClient}
 	err = setObjectRetention(ctx, minioClient, params.BucketName, params.VersionID, params.Prefix, params.Body)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -590,14 +590,14 @@ func deleteObjectRetentionResponse(session *models.Principal, params user_api.De
 	defer cancel()
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
 	minioClient := minioClient{client: mClient}
 	err = deleteObjectRetention(ctx, minioClient, params.BucketName, params.Prefix, params.VersionID)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
@@ -616,14 +616,14 @@ func getPutObjectTagsResponse(session *models.Principal, params user_api.PutObje
 	defer cancel()
 	mClient, err := newMinioClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a minioClient interface implementation
 	// defining the client to be used
 	minioClient := minioClient{client: mClient}
 	err = putObjectTags(ctx, minioClient, params.BucketName, params.Prefix, params.VersionID, params.Body.Tags)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
--- a/restapi/user_service_accounts.go
+++ b/restapi/user_service_accounts.go
@@ -97,7 +97,7 @@ func getCreateServiceAccountResponse(session *models.Principal, serviceAccount *

 	userAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO user Admin Client interface implementation
 	// defining the client to be used
@@ -105,7 +105,7 @@ func getCreateServiceAccountResponse(session *models.Principal, serviceAccount *

 	saCreds, err := createServiceAccount(ctx, userAdminClient, serviceAccount.Policy)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return saCreds, nil
 }
@@ -131,7 +131,7 @@ func getUserServiceAccountsResponse(session *models.Principal, user string) (mod

 	userAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	// create a MinIO user Admin Client interface implementation
 	// defining the client to be used
@@ -139,7 +139,7 @@ func getUserServiceAccountsResponse(session *models.Principal, user string) (mod

 	serviceAccounts, err := getUserServiceAccounts(ctx, userAdminClient, user)
 	if err != nil {
-		return nil, PrepareError(err)
+		return nil, prepareError(err)
 	}
 	return serviceAccounts, nil
 }
@@ -156,14 +156,14 @@ func getDeleteServiceAccountResponse(session *models.Principal, accessKey string

 	userAdmin, err := NewMinioAdminClient(session)
 	if err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	// create a MinIO user Admin Client interface implementation
 	// defining the client to be used
 	userAdminClient := AdminClient{Client: userAdmin}

 	if err := deleteServiceAccount(ctx, userAdminClient, accessKey); err != nil {
-		return PrepareError(err)
+		return prepareError(err)
 	}
 	return nil
 }
--- a/restapi/user_session.go
+++ b/restapi/user_session.go
@@ -39,7 +39,7 @@ func registerSessionHandlers(api *operations.ConsoleAPI) {
 func getSessionResponse(session *models.Principal) (*models.SessionResponse, *models.Error) {
 	// serialize output
 	if session == nil {
-		return nil, PrepareError(errorGenericInvalidSession)
+		return nil, prepareError(errorGenericInvalidSession)
 	}
 	sessionResp := &models.SessionResponse{
 		Pages:    acl.GetAuthorizedEndpoints(session.Actions),