Docker/portainer
Docker/portainer
1
0
Fork 0
mirror of https://github.com/portainer/portainer.git synced 2025-07-24 15:59:41 +02:00
Code Issues Releases Activity

feat(dataservices): unify access methods and abstract away redundant code [EE-5628] (#9115)

Browse source
This commit is contained in:
andres-portainer 2023-06-22 18:28:07 -03:00 • committed by GitHub
parent 4c6bbe9a2f
commit 4cc96b4b30
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
171 changed files with 714 additions and 1590 deletions
Download patch file Download diff file Expand all files Collapse all files

2
api/http/handler/auth/authenticate.go
View file

@ -156,7 +156,7 @@ func (handler *Handler) syncUserTeamsWithLDAPGroups(user *portainer.User, settin
return nil
}
teams, err := handler.DataStore.Team().Teams()
teams, err := handler.DataStore.Team().ReadAll()
if err != nil {
return err
}

2
api/http/handler/customtemplates/customtemplate_create.go
View file

@ -39,7 +39,7 @@ func (handler *Handler) customTemplateCreate(w http.ResponseWriter, r *http.Requ
customTemplate.CreatedByUserID = tokenData.ID
customTemplates, err := handler.DataStore.CustomTemplate().CustomTemplates()
customTemplates, err := handler.DataStore.CustomTemplate().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve custom templates from the database", err)
}

6
api/http/handler/customtemplates/customtemplate_delete.go
View file

@ -38,7 +38,7 @@ func (handler *Handler) customTemplateDelete(w http.ResponseWriter, r *http.Requ
return httperror.InternalServerError("Unable to retrieve info from request context", err)
}
customTemplate, err := handler.DataStore.CustomTemplate().CustomTemplate(portainer.CustomTemplateID(customTemplateID))
customTemplate, err := handler.DataStore.CustomTemplate().Read(portainer.CustomTemplateID(customTemplateID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a custom template with the specified identifier inside the database", err)
} else if err != nil {
@ -55,7 +55,7 @@ func (handler *Handler) customTemplateDelete(w http.ResponseWriter, r *http.Requ
return httperror.Forbidden("Access denied to resource", httperrors.ErrResourceAccessDenied)
}
err = handler.DataStore.CustomTemplate().DeleteCustomTemplate(portainer.CustomTemplateID(customTemplateID))
err = handler.DataStore.CustomTemplate().Delete(portainer.CustomTemplateID(customTemplateID))
if err != nil {
return httperror.InternalServerError("Unable to remove the custom template from the database", err)
}
@ -66,7 +66,7 @@ func (handler *Handler) customTemplateDelete(w http.ResponseWriter, r *http.Requ
}
if resourceControl != nil {
err = handler.DataStore.ResourceControl().DeleteResourceControl(resourceControl.ID)
err = handler.DataStore.ResourceControl().Delete(resourceControl.ID)
if err != nil {
return httperror.InternalServerError("Unable to remove the associated resource control from the database", err)
}

2
api/http/handler/customtemplates/customtemplate_file.go
View file

@ -33,7 +33,7 @@ func (handler *Handler) customTemplateFile(w http.ResponseWriter, r *http.Reques
return httperror.BadRequest("Invalid custom template identifier route variable", err)
}
customTemplate, err := handler.DataStore.CustomTemplate().CustomTemplate(portainer.CustomTemplateID(customTemplateID))
customTemplate, err := handler.DataStore.CustomTemplate().Read(portainer.CustomTemplateID(customTemplateID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a custom template with the specified identifier inside the database", err)
} else if err != nil {

4
api/http/handler/customtemplates/customtemplate_git_fetch.go
View file

@ -34,7 +34,7 @@ func (handler *Handler) customTemplateGitFetch(w http.ResponseWriter, r *http.Re
return httperror.BadRequest("Invalid Custom template identifier route variable", err)
}
customTemplate, err := handler.DataStore.CustomTemplate().CustomTemplate(portainer.CustomTemplateID(customTemplateID))
customTemplate, err := handler.DataStore.CustomTemplate().Read(portainer.CustomTemplateID(customTemplateID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a custom template with the specified identifier inside the database", err)
} else if err != nil {
@ -78,7 +78,7 @@ func (handler *Handler) customTemplateGitFetch(w http.ResponseWriter, r *http.Re
if customTemplate.GitConfig.ConfigHash != commitHash {
customTemplate.GitConfig.ConfigHash = commitHash
err = handler.DataStore.CustomTemplate().UpdateCustomTemplate(customTemplate.ID, customTemplate)
err = handler.DataStore.CustomTemplate().Update(customTemplate.ID, customTemplate)
if err != nil {
return httperror.InternalServerError("Unable to persist custom template changes inside the database", err)
}

2
api/http/handler/customtemplates/customtemplate_inspect.go
View file

@ -32,7 +32,7 @@ func (handler *Handler) customTemplateInspect(w http.ResponseWriter, r *http.Req
return httperror.BadRequest("Invalid Custom template identifier route variable", err)
}
customTemplate, err := handler.DataStore.CustomTemplate().CustomTemplate(portainer.CustomTemplateID(customTemplateID))
customTemplate, err := handler.DataStore.CustomTemplate().Read(portainer.CustomTemplateID(customTemplateID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a custom template with the specified identifier inside the database", err)
} else if err != nil {

6
api/http/handler/customtemplates/customtemplate_list.go
View file

@ -30,12 +30,12 @@ func (handler *Handler) customTemplateList(w http.ResponseWriter, r *http.Reques
return httperror.BadRequest("Invalid Custom template type", err)
}
customTemplates, err := handler.DataStore.CustomTemplate().CustomTemplates()
customTemplates, err := handler.DataStore.CustomTemplate().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve custom templates from the database", err)
}
resourceControls, err := handler.DataStore.ResourceControl().ResourceControls()
resourceControls, err := handler.DataStore.ResourceControl().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve resource controls from the database", err)
}
@ -48,7 +48,7 @@ func (handler *Handler) customTemplateList(w http.ResponseWriter, r *http.Reques
}
if !securityContext.IsAdmin {
user, err := handler.DataStore.User().User(securityContext.UserID)
user, err := handler.DataStore.User().Read(securityContext.UserID)
if err != nil {
return httperror.InternalServerError("Unable to retrieve user information from the database", err)
}

6
api/http/handler/customtemplates/customtemplate_update.go
View file

@ -125,7 +125,7 @@ func (handler *Handler) customTemplateUpdate(w http.ResponseWriter, r *http.Requ
return httperror.BadRequest("Invalid request payload", err)
}
customTemplates, err := handler.DataStore.CustomTemplate().CustomTemplates()
customTemplates, err := handler.DataStore.CustomTemplate().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve custom templates from the database", err)
}
@ -136,7 +136,7 @@ func (handler *Handler) customTemplateUpdate(w http.ResponseWriter, r *http.Requ
}
}
customTemplate, err := handler.DataStore.CustomTemplate().CustomTemplate(portainer.CustomTemplateID(customTemplateID))
customTemplate, err := handler.DataStore.CustomTemplate().Read(portainer.CustomTemplateID(customTemplateID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a custom template with the specified identifier inside the database", err)
} else if err != nil {
@ -214,7 +214,7 @@ func (handler *Handler) customTemplateUpdate(w http.ResponseWriter, r *http.Requ
}
}
err = handler.DataStore.CustomTemplate().UpdateCustomTemplate(customTemplate.ID, customTemplate)
err = handler.DataStore.CustomTemplate().Update(customTemplate.ID, customTemplate)
if err != nil {
return httperror.InternalServerError("Unable to persist custom template changes inside the database", err)
}

4
api/http/handler/docker/containers/recreate.go
View file

@ -64,7 +64,7 @@ func (handler *Handler) recreate(w http.ResponseWriter, r *http.Request) *httper
}
func (handler *Handler) createResourceControl(oldContainerId string, newContainerId string) {
resourceControls, err := handler.dataStore.ResourceControl().ResourceControls()
resourceControls, err := handler.dataStore.ResourceControl().ReadAll()
if err != nil {
log.Error().Err(err).Msg("Exporting Resource Controls")
return
@ -90,7 +90,7 @@ func (handler *Handler) updateWebhook(oldContainerId string, newContainerId stri
}
webhook.ResourceID = newContainerId
err = handler.dataStore.Webhook().UpdateWebhook(webhook.ID, webhook)
err = handler.dataStore.Webhook().Update(webhook.ID, webhook)
if err != nil {
log.Error().Err(err).Int("webhookId", int(webhook.ID)).Msg("cannot update webhook")
}

2
api/http/handler/edgegroups/associated_endpoints.go
View file

@ -21,7 +21,7 @@ func GetEndpointsByTags(tx dataservices.DataStoreTx, tagIDs []portainer.TagID, p
tags := []portainer.Tag{}
for _, tagID := range tagIDs {
tag, err := tx.Tag().Tag(tagID)
tag, err := tx.Tag().Read(tagID)
if err != nil {
return nil, err
}

2
api/http/handler/edgegroups/edgegroup_create.go
View file

@ -55,7 +55,7 @@ func (handler *Handler) edgeGroupCreate(w http.ResponseWriter, r *http.Request)
var edgeGroup *portainer.EdgeGroup
err = handler.DataStore.UpdateTx(func(tx dataservices.DataStoreTx) error {
edgeGroups, err := tx.EdgeGroup().EdgeGroups()
edgeGroups, err := tx.EdgeGroup().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve Edge groups from the database", err)
}

6
api/http/handler/edgegroups/edgegroup_delete.go
View file

@ -50,7 +50,7 @@ func (handler *Handler) edgeGroupDelete(w http.ResponseWriter, r *http.Request)
}
func deleteEdgeGroup(tx dataservices.DataStoreTx, ID portainer.EdgeGroupID) error {
_, err := tx.EdgeGroup().EdgeGroup(ID)
_, err := tx.EdgeGroup().Read(ID)
if tx.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an Edge group with the specified identifier inside the database", err)
} else if err != nil {
@ -70,7 +70,7 @@ func deleteEdgeGroup(tx dataservices.DataStoreTx, ID portainer.EdgeGroupID) erro
}
}
edgeJobs, err := tx.EdgeJob().EdgeJobs()
edgeJobs, err := tx.EdgeJob().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve Edge jobs from the database", err)
}
@ -83,7 +83,7 @@ func deleteEdgeGroup(tx dataservices.DataStoreTx, ID portainer.EdgeGroupID) erro
}
}
err = tx.EdgeGroup().DeleteEdgeGroup(ID)
err = tx.EdgeGroup().Delete(ID)
if err != nil {
return httperror.InternalServerError("Unable to remove the Edge group from the database", err)
}

2
api/http/handler/edgegroups/edgegroup_inspect.go
View file

@ -42,7 +42,7 @@ func (handler *Handler) edgeGroupInspect(w http.ResponseWriter, r *http.Request)
}
func getEdgeGroup(tx dataservices.DataStoreTx, ID portainer.EdgeGroupID) (*portainer.EdgeGroup, error) {
edgeGroup, err := tx.EdgeGroup().EdgeGroup(ID)
edgeGroup, err := tx.EdgeGroup().Read(ID)
if tx.IsErrObjectNotFound(err) {
return nil, httperror.NotFound("Unable to find an Edge group with the specified identifier inside the database", err)
} else if err != nil {

4
api/http/handler/edgegroups/edgegroup_list.go
View file

@ -46,7 +46,7 @@ func (handler *Handler) edgeGroupList(w http.ResponseWriter, r *http.Request) *h
}
func getEdgeGroupList(tx dataservices.DataStoreTx) ([]decoratedEdgeGroup, error) {
edgeGroups, err := tx.EdgeGroup().EdgeGroups()
edgeGroups, err := tx.EdgeGroup().ReadAll()
if err != nil {
return nil, httperror.InternalServerError("Unable to retrieve Edge groups from the database", err)
}
@ -64,7 +64,7 @@ func getEdgeGroupList(tx dataservices.DataStoreTx) ([]decoratedEdgeGroup, error)
}
}
edgeJobs, err := tx.EdgeJob().EdgeJobs()
edgeJobs, err := tx.EdgeJob().ReadAll()
if err != nil {
return nil, httperror.InternalServerError("Unable to retrieve Edge jobs from the database", err)
}

14
api/http/handler/edgegroups/edgegroup_update.go
View file

@ -63,7 +63,7 @@ func (handler *Handler) edgeGroupUpdate(w http.ResponseWriter, r *http.Request)
var edgeGroup *portainer.EdgeGroup
err = handler.DataStore.UpdateTx(func(tx dataservices.DataStoreTx) error {
edgeGroup, err = tx.EdgeGroup().EdgeGroup(portainer.EdgeGroupID(edgeGroupID))
edgeGroup, err = tx.EdgeGroup().Read(portainer.EdgeGroupID(edgeGroupID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an Edge group with the specified identifier inside the database", err)
} else if err != nil {
@ -71,7 +71,7 @@ func (handler *Handler) edgeGroupUpdate(w http.ResponseWriter, r *http.Request)
}
if payload.Name != "" {
edgeGroups, err := tx.EdgeGroup().EdgeGroups()
edgeGroups, err := tx.EdgeGroup().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve Edge groups from the database", err)
}
@ -90,7 +90,7 @@ func (handler *Handler) edgeGroupUpdate(w http.ResponseWriter, r *http.Request)
return httperror.InternalServerError("Unable to retrieve environments from database", err)
}
endpointGroups, err := tx.EndpointGroup().EndpointGroups()
endpointGroups, err := tx.EndpointGroup().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve environment groups from database", err)
}
@ -119,7 +119,7 @@ func (handler *Handler) edgeGroupUpdate(w http.ResponseWriter, r *http.Request)
edgeGroup.PartialMatch = *payload.PartialMatch
}
err = tx.EdgeGroup().UpdateEdgeGroup(edgeGroup.ID, edgeGroup)
err = tx.EdgeGroup().Update(edgeGroup.ID, edgeGroup)
if err != nil {
return httperror.InternalServerError("Unable to persist Edge group changes inside the database", err)
}
@ -127,7 +127,7 @@ func (handler *Handler) edgeGroupUpdate(w http.ResponseWriter, r *http.Request)
newRelatedEndpoints := edge.EdgeGroupRelatedEndpoints(edgeGroup, endpoints, endpointGroups)
endpointsToUpdate := append(newRelatedEndpoints, oldRelatedEndpoints...)
edgeJobs, err := tx.EdgeJob().EdgeJobs()
edgeJobs, err := tx.EdgeJob().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to fetch Edge jobs", err)
}
@ -179,12 +179,12 @@ func (handler *Handler) updateEndpointStacks(tx dataservices.DataStoreTx, endpoi
return err
}
endpointGroup, err := tx.EndpointGroup().EndpointGroup(endpoint.GroupID)
endpointGroup, err := tx.EndpointGroup().Read(endpoint.GroupID)
if err != nil {
return err
}
edgeGroups, err := tx.EdgeGroup().EdgeGroups()
edgeGroups, err := tx.EdgeGroup().ReadAll()
if err != nil {
return err
}

2
api/http/handler/edgejobs/edgejob_create.go
View file

@ -285,5 +285,5 @@ func (handler *Handler) addAndPersistEdgeJob(tx dataservices.DataStoreTx, edgeJo
handler.ReverseTunnelService.AddEdgeJob(endpoint, edgeJob)
}
return tx.EdgeJob().Create(edgeJob.ID, edgeJob)
return tx.EdgeJob().CreateWithID(edgeJob.ID, edgeJob)
}

4
api/http/handler/edgejobs/edgejob_delete.go
View file

@ -55,7 +55,7 @@ func (handler *Handler) edgeJobDelete(w http.ResponseWriter, r *http.Request) *h
}
func (handler *Handler) deleteEdgeJob(tx dataservices.DataStoreTx, edgeJobID portainer.EdgeJobID) error {
edgeJob, err := tx.EdgeJob().EdgeJob(portainer.EdgeJobID(edgeJobID))
edgeJob, err := tx.EdgeJob().Read(portainer.EdgeJobID(edgeJobID))
if tx.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an Edge job with the specified identifier inside the database", err)
} else if err != nil {
@ -87,7 +87,7 @@ func (handler *Handler) deleteEdgeJob(tx dataservices.DataStoreTx, edgeJobID por
handler.ReverseTunnelService.RemoveEdgeJobFromEndpoint(endpointID, edgeJob.ID)
}
err = tx.EdgeJob().DeleteEdgeJob(edgeJob.ID)
err = tx.EdgeJob().Delete(edgeJob.ID)
if err != nil {
return httperror.InternalServerError("Unable to remove the Edge job from the database", err)
}

2
api/http/handler/edgejobs/edgejob_file.go
View file

@ -32,7 +32,7 @@ func (handler *Handler) edgeJobFile(w http.ResponseWriter, r *http.Request) *htt
return httperror.BadRequest("Invalid Edge job identifier route variable", err)
}
edgeJob, err := handler.DataStore.EdgeJob().EdgeJob(portainer.EdgeJobID(edgeJobID))
edgeJob, err := handler.DataStore.EdgeJob().Read(portainer.EdgeJobID(edgeJobID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an Edge job with the specified identifier inside the database", err)
} else if err != nil {

2
api/http/handler/edgejobs/edgejob_inspect.go
View file

@ -33,7 +33,7 @@ func (handler *Handler) edgeJobInspect(w http.ResponseWriter, r *http.Request) *
return httperror.BadRequest("Invalid Edge job identifier route variable", err)
}
edgeJob, err := handler.DataStore.EdgeJob().EdgeJob(portainer.EdgeJobID(edgeJobID))
edgeJob, err := handler.DataStore.EdgeJob().Read(portainer.EdgeJobID(edgeJobID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an Edge job with the specified identifier inside the database", err)
} else if err != nil {

2
api/http/handler/edgejobs/edgejob_list.go
View file

@ -21,7 +21,7 @@ import (
// @router /edge_jobs [get]
// GET request on /api/edge_jobs
func (handler *Handler) edgeJobList(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
edgeJobs, err := handler.DataStore.EdgeJob().EdgeJobs()
edgeJobs, err := handler.DataStore.EdgeJob().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve Edge jobs from the database", err)
}

4
api/http/handler/edgejobs/edgejob_tasklogs_clear.go
View file

@ -68,7 +68,7 @@ func (handler *Handler) edgeJobTasksClear(w http.ResponseWriter, r *http.Request
updateEdgeJobFn := func(edgeJob *portainer.EdgeJob, endpointID portainer.EndpointID, endpointsFromGroups []portainer.EndpointID) error {
mutationFn(edgeJob, endpointID, endpointsFromGroups)
return tx.EdgeJob().UpdateEdgeJob(edgeJob.ID, edgeJob)
return tx.EdgeJob().Update(edgeJob.ID, edgeJob)
}
return handler.clearEdgeJobTaskLogs(tx, portainer.EdgeJobID(edgeJobID), portainer.EndpointID(taskID), updateEdgeJobFn)
@ -88,7 +88,7 @@ func (handler *Handler) edgeJobTasksClear(w http.ResponseWriter, r *http.Request
}
func (handler *Handler) clearEdgeJobTaskLogs(tx dataservices.DataStoreTx, edgeJobID portainer.EdgeJobID, endpointID portainer.EndpointID, updateEdgeJob func(*portainer.EdgeJob, portainer.EndpointID, []portainer.EndpointID) error) error {
edgeJob, err := tx.EdgeJob().EdgeJob(portainer.EdgeJobID(edgeJobID))
edgeJob, err := tx.EdgeJob().Read(portainer.EdgeJobID(edgeJobID))
if tx.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an Edge job with the specified identifier inside the database", err)
} else if err != nil {

4
api/http/handler/edgejobs/edgejob_tasklogs_collect.go
View file

@ -39,7 +39,7 @@ func (handler *Handler) edgeJobTasksCollect(w http.ResponseWriter, r *http.Reque
}
err = handler.DataStore.UpdateTx(func(tx dataservices.DataStoreTx) error {
edgeJob, err := tx.EdgeJob().EdgeJob(portainer.EdgeJobID(edgeJobID))
edgeJob, err := tx.EdgeJob().Read(portainer.EdgeJobID(edgeJobID))
if tx.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an Edge job with the specified identifier inside the database", err)
} else if err != nil {
@ -64,7 +64,7 @@ func (handler *Handler) edgeJobTasksCollect(w http.ResponseWriter, r *http.Reque
edgeJob.Endpoints[endpointID] = meta
}
err = tx.EdgeJob().UpdateEdgeJob(edgeJob.ID, edgeJob)
err = tx.EdgeJob().Update(edgeJob.ID, edgeJob)
if err != nil {
return httperror.InternalServerError("Unable to persist Edge job changes in the database", err)
}

2
api/http/handler/edgejobs/edgejob_tasks_list.go
View file

@ -52,7 +52,7 @@ func (handler *Handler) edgeJobTasksList(w http.ResponseWriter, r *http.Request)
}
func listEdgeJobTasks(tx dataservices.DataStoreTx, edgeJobID portainer.EdgeJobID) ([]taskContainer, error) {
edgeJob, err := tx.EdgeJob().EdgeJob(portainer.EdgeJobID(edgeJobID))
edgeJob, err := tx.EdgeJob().Read(portainer.EdgeJobID(edgeJobID))
if tx.IsErrObjectNotFound(err) {
return nil, httperror.NotFound("Unable to find an Edge job with the specified identifier inside the database", err)
} else if err != nil {

6
api/http/handler/edgejobs/edgejob_update.go
View file

@ -76,7 +76,7 @@ func (handler *Handler) edgeJobUpdate(w http.ResponseWriter, r *http.Request) *h
}
func (handler *Handler) updateEdgeJob(tx dataservices.DataStoreTx, edgeJobID portainer.EdgeJobID, payload edgeJobUpdatePayload) (*portainer.EdgeJob, error) {
edgeJob, err := tx.EdgeJob().EdgeJob(portainer.EdgeJobID(edgeJobID))
edgeJob, err := tx.EdgeJob().Read(portainer.EdgeJobID(edgeJobID))
if tx.IsErrObjectNotFound(err) {
return nil, httperror.NotFound("Unable to find an Edge job with the specified identifier inside the database", err)
} else if err != nil {
@ -88,7 +88,7 @@ func (handler *Handler) updateEdgeJob(tx dataservices.DataStoreTx, edgeJobID por
return nil, httperror.InternalServerError("Unable to update Edge job", err)
}
err = tx.EdgeJob().UpdateEdgeJob(edgeJob.ID, edgeJob)
err = tx.EdgeJob().Update(edgeJob.ID, edgeJob)
if err != nil {
return nil, httperror.InternalServerError("Unable to persist Edge job changes inside the database", err)
}
@ -154,7 +154,7 @@ func (handler *Handler) updateEdgeSchedule(tx dataservices.DataStoreTx, edgeJob
if len(payload.EdgeGroups) > 0 {
for _, edgeGroupID := range payload.EdgeGroups {
_, err := tx.EdgeGroup().EdgeGroup(edgeGroupID)
_, err := tx.EdgeGroup().Read(edgeGroupID)
if err != nil {
return err
}

4
api/http/handler/endpointedge/endpoint_edgejob_logs.go
View file

@ -84,7 +84,7 @@ func (handler *Handler) getEdgeJobLobs(tx dataservices.DataStoreTx, endpointID p
return httperror.InternalServerError("Unable to find an environment with the specified identifier inside the database", err)
}
edgeJob, err := tx.EdgeJob().EdgeJob(portainer.EdgeJobID(edgeJobID))
edgeJob, err := tx.EdgeJob().Read(portainer.EdgeJobID(edgeJobID))
if tx.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an edge job with the specified identifier inside the database", err)
} else if err != nil {
@ -103,7 +103,7 @@ func (handler *Handler) getEdgeJobLobs(tx dataservices.DataStoreTx, endpointID p
edgeJob.Endpoints[endpoint.ID] = meta
}
err = tx.EdgeJob().UpdateEdgeJob(edgeJob.ID, edgeJob)
err = tx.EdgeJob().Update(edgeJob.ID, edgeJob)
handler.ReverseTunnelService.AddEdgeJob(endpoint, edgeJob)

4
api/http/handler/endpointgroups/endpointgroup_create.go
View file

@ -133,14 +133,14 @@ func (handler *Handler) createEndpointGroup(tx dataservices.DataStoreTx, payload
continue
}
tag, err := tx.Tag().Tag(tagID)
tag, err := tx.Tag().Read(tagID)
if err != nil {
return nil, httperror.InternalServerError("Unable to find a tag inside the database", err)
}
tag.EndpointGroups[endpointGroup.ID] = true
err = tx.Tag().UpdateTag(tagID, tag)
err = tx.Tag().Update(tagID, tag)
if err != nil {
return nil, httperror.InternalServerError("Unable to persist tag changes inside the database", err)
}

8
api/http/handler/endpointgroups/endpointgroup_delete.go
View file

@ -56,14 +56,14 @@ func (handler *Handler) endpointGroupDelete(w http.ResponseWriter, r *http.Reque
}
func (handler *Handler) deleteEndpointGroup(tx dataservices.DataStoreTx, endpointGroupID portainer.EndpointGroupID) error {
endpointGroup, err := tx.EndpointGroup().EndpointGroup(endpointGroupID)
endpointGroup, err := tx.EndpointGroup().Read(endpointGroupID)
if tx.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an environment group with the specified identifier inside the database", err)
} else if err != nil {
return httperror.InternalServerError("Unable to find an environment group with the specified identifier inside the database", err)
}
err = tx.EndpointGroup().DeleteEndpointGroup(endpointGroupID)
err = tx.EndpointGroup().Delete(endpointGroupID)
if err != nil {
return httperror.InternalServerError("Unable to remove the environment group from the database", err)
}
@ -103,14 +103,14 @@ func (handler *Handler) deleteEndpointGroup(tx dataservices.DataStoreTx, endpoin
continue
}
tag, err := tx.Tag().Tag(tagID)
tag, err := tx.Tag().Read(tagID)
if tx.IsErrObjectNotFound(err) {
return httperror.InternalServerError("Unable to find a tag inside the database", err)
}
delete(tag.EndpointGroups, endpointGroup.ID)
err = tx.Tag().UpdateTag(tagID, tag)
err = tx.Tag().Update(tagID, tag)
if err != nil {
return httperror.InternalServerError("Unable to persist tag changes inside the database", err)
}

2
api/http/handler/endpointgroups/endpointgroup_endpoint_add.go
View file

@ -58,7 +58,7 @@ func (handler *Handler) endpointGroupAddEndpoint(w http.ResponseWriter, r *http.
}
func (handler *Handler) addEndpoint(tx dataservices.DataStoreTx, endpointGroupID portainer.EndpointGroupID, endpointID portainer.EndpointID) error {
endpointGroup, err := tx.EndpointGroup().EndpointGroup(portainer.EndpointGroupID(endpointGroupID))
endpointGroup, err := tx.EndpointGroup().Read(portainer.EndpointGroupID(endpointGroupID))
if tx.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an environment group with the specified identifier inside the database", err)
} else if err != nil {

2
api/http/handler/endpointgroups/endpointgroup_endpoint_delete.go
View file

@ -57,7 +57,7 @@ func (handler *Handler) endpointGroupDeleteEndpoint(w http.ResponseWriter, r *ht
}
func (handler *Handler) removeEndpoint(tx dataservices.DataStoreTx, endpointGroupID portainer.EndpointGroupID, endpointID portainer.EndpointID) error {
_, err := tx.EndpointGroup().EndpointGroup(portainer.EndpointGroupID(endpointGroupID))
_, err := tx.EndpointGroup().Read(portainer.EndpointGroupID(endpointGroupID))
if tx.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an environment group with the specified identifier inside the database", err)
} else if err != nil {

2
api/http/handler/endpointgroups/endpointgroup_inspect.go
View file

@ -29,7 +29,7 @@ func (handler *Handler) endpointGroupInspect(w http.ResponseWriter, r *http.Requ
return httperror.BadRequest("Invalid environment group identifier route variable", err)
}
endpointGroup, err := handler.DataStore.EndpointGroup().EndpointGroup(portainer.EndpointGroupID(endpointGroupID))
endpointGroup, err := handler.DataStore.EndpointGroup().Read(portainer.EndpointGroupID(endpointGroupID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an environment group with the specified identifier inside the database", err)
} else if err != nil {

2
api/http/handler/endpointgroups/endpointgroup_list.go
View file

@ -22,7 +22,7 @@ import (
// @failure 500 "Server error"
// @router /endpoint_groups [get]
func (handler *Handler) endpointGroupList(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
endpointGroups, err := handler.DataStore.EndpointGroup().EndpointGroups()
endpointGroups, err := handler.DataStore.EndpointGroup().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve environment groups from the database", err)
}

12
api/http/handler/endpointgroups/endpointgroup_update.go
View file

@ -80,7 +80,7 @@ func (handler *Handler) endpointGroupUpdate(w http.ResponseWriter, r *http.Reque
}
func (handler *Handler) updateEndpointGroup(tx dataservices.DataStoreTx, endpointGroupID portainer.EndpointGroupID, payload endpointGroupUpdatePayload) (*portainer.EndpointGroup, error) {
endpointGroup, err := tx.EndpointGroup().EndpointGroup(portainer.EndpointGroupID(endpointGroupID))
endpointGroup, err := tx.EndpointGroup().Read(portainer.EndpointGroupID(endpointGroupID))
if tx.IsErrObjectNotFound(err) {
return nil, httperror.NotFound("Unable to find an environment group with the specified identifier inside the database", err)
} else if err != nil {
@ -121,14 +121,14 @@ func (handler *Handler) updateEndpointGroup(tx dataservices.DataStoreTx, endpoin
continue
}
tag, err := tx.Tag().Tag(tagID)
tag, err := tx.Tag().Read(tagID)
if err != nil {
return nil, httperror.InternalServerError("Unable to find a tag inside the database", err)
}
delete(tag.EndpointGroups, endpointGroup.ID)
err = tx.Tag().UpdateTag(tagID, tag)
err = tx.Tag().Update(tagID, tag)
if err != nil {
return nil, httperror.InternalServerError("Unable to persist tag changes inside the database", err)
}
@ -150,14 +150,14 @@ func (handler *Handler) updateEndpointGroup(tx dataservices.DataStoreTx, endpoin
continue
}
tag, err := tx.Tag().Tag(tagID)
tag, err := tx.Tag().Read(tagID)
if err != nil {
return nil, httperror.InternalServerError("Unable to find a tag inside the database", err)
}
tag.EndpointGroups[endpointGroup.ID] = true
err = tx.Tag().UpdateTag(tagID, tag)
err = tx.Tag().Update(tagID, tag)
if err != nil {
return nil, httperror.InternalServerError("Unable to persist tag changes inside the database", err)
}
@ -194,7 +194,7 @@ func (handler *Handler) updateEndpointGroup(tx dataservices.DataStoreTx, endpoin
}
}
err = tx.EndpointGroup().UpdateEndpointGroup(endpointGroup.ID, endpointGroup)
err = tx.EndpointGroup().Update(endpointGroup.ID, endpointGroup)
if err != nil {
return nil, httperror.InternalServerError("Unable to persist environment group changes inside the database", err)
}

4
api/http/handler/endpointgroups/endpoints.go
View file

@ -12,7 +12,7 @@ func (handler *Handler) updateEndpointRelations(tx dataservices.DataStoreTx, end
}
if endpointGroup == nil {
unassignedGroup, err := tx.EndpointGroup().EndpointGroup(portainer.EndpointGroupID(1))
unassignedGroup, err := tx.EndpointGroup().Read(portainer.EndpointGroupID(1))
if err != nil {
return err
}
@ -25,7 +25,7 @@ func (handler *Handler) updateEndpointRelations(tx dataservices.DataStoreTx, end
return err
}
edgeGroups, err := tx.EdgeGroup().EdgeGroups()
edgeGroups, err := tx.EdgeGroup().ReadAll()
if err != nil {
return err
}

2
api/http/handler/endpoints/endpoint_agent_versions.go
View file

@ -22,7 +22,7 @@ import (
// @router /endpoints/agent_versions [get]
func (handler *Handler) agentVersions(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
endpointGroups, err := handler.DataStore.EndpointGroup().EndpointGroups()
endpointGroups, err := handler.DataStore.EndpointGroup().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve environment groups from the database", err)
}

4
api/http/handler/endpoints/endpoint_create.go
View file

@ -222,12 +222,12 @@ func (handler *Handler) endpointCreate(w http.ResponseWriter, r *http.Request) *
return endpointCreationError
}
endpointGroup, err := handler.DataStore.EndpointGroup().EndpointGroup(endpoint.GroupID)
endpointGroup, err := handler.DataStore.EndpointGroup().Read(endpoint.GroupID)
if err != nil {
return httperror.InternalServerError("Unable to find an environment group inside the database", err)
}
edgeGroups, err := handler.DataStore.EdgeGroup().EdgeGroups()
edgeGroups, err := handler.DataStore.EdgeGroup().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve edge groups from the database", err)
}

10
api/http/handler/endpoints/endpoint_delete.go
View file

@ -50,7 +50,7 @@ func (handler *Handler) endpointDelete(w http.ResponseWriter, r *http.Request) *
}
}
err = handler.DataStore.Snapshot().DeleteSnapshot(portainer.EndpointID(endpointID))
err = handler.DataStore.Snapshot().Delete(portainer.EndpointID(endpointID))
if err != nil {
return httperror.InternalServerError("Unable to remove the snapshot from the database", err)
}
@ -79,7 +79,7 @@ func (handler *Handler) endpointDelete(w http.ResponseWriter, r *http.Request) *
}
}
edgeGroups, err := handler.DataStore.EdgeGroup().EdgeGroups()
edgeGroups, err := handler.DataStore.EdgeGroup().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve edge groups from the database", err)
}
@ -109,7 +109,7 @@ func (handler *Handler) endpointDelete(w http.ResponseWriter, r *http.Request) *
}
}
registries, err := handler.DataStore.Registry().Registries()
registries, err := handler.DataStore.Registry().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve registries from the database", err)
}
@ -118,7 +118,7 @@ func (handler *Handler) endpointDelete(w http.ResponseWriter, r *http.Request) *
registry := &registries[idx]
if _, ok := registry.RegistryAccesses[endpoint.ID]; ok {
delete(registry.RegistryAccesses, endpoint.ID)
err = handler.DataStore.Registry().UpdateRegistry(registry.ID, registry)
err = handler.DataStore.Registry().Update(registry.ID, registry)
if err != nil {
return httperror.InternalServerError("Unable to update registry accesses", err)
}
@ -129,7 +129,7 @@ func (handler *Handler) endpointDelete(w http.ResponseWriter, r *http.Request) *
return response.Empty(w)
}
edgeJobs, err := handler.DataStore.EdgeJob().EdgeJobs()
edgeJobs, err := handler.DataStore.EdgeJob().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve edge jobs from the database", err)
}

2
api/http/handler/endpoints/endpoint_delete_test.go
View file

@ -75,7 +75,7 @@ func TestEndpointDeleteEdgeGroupsConcurrently(t *testing.T) {
// Check that the edge group is consistent
edgeGroup, err := handler.DataStore.EdgeGroup().EdgeGroup(1)
edgeGroup, err := handler.DataStore.EdgeGroup().Read(1)
if err != nil {
t.Fatal("could not retrieve the edge group:", err)
}

2
api/http/handler/endpoints/endpoint_dockerhub_status.go
View file

@ -67,7 +67,7 @@ func (handler *Handler) endpointDockerhubStatus(w http.ResponseWriter, r *http.R
if registryID == 0 {
registry = &portainer.Registry{}
} else {
registry, err = handler.DataStore.Registry().Registry(portainer.RegistryID(registryID))
registry, err = handler.DataStore.Registry().Read(portainer.RegistryID(registryID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a registry with the specified identifier inside the database", err)
} else if err != nil {

2
api/http/handler/endpoints/endpoint_list.go
View file

@ -61,7 +61,7 @@ func (handler *Handler) endpointList(w http.ResponseWriter, r *http.Request) *ht
sortField, _ := request.RetrieveQueryParameter(r, "sort", true)
sortOrder, _ := request.RetrieveQueryParameter(r, "order", true)
endpointGroups, err := handler.DataStore.EndpointGroup().EndpointGroups()
endpointGroups, err := handler.DataStore.EndpointGroup().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve environment groups from the database", err)
}

4
api/http/handler/endpoints/endpoint_registries_list.go
View file

@ -31,7 +31,7 @@ func (handler *Handler) endpointRegistriesList(w http.ResponseWriter, r *http.Re
return httperror.InternalServerError("Unable to retrieve info from request context", err)
}
user, err := handler.DataStore.User().User(securityContext.UserID)
user, err := handler.DataStore.User().Read(securityContext.UserID)
if err != nil {
return httperror.InternalServerError("Unable to retrieve user from the database", err)
}
@ -50,7 +50,7 @@ func (handler *Handler) endpointRegistriesList(w http.ResponseWriter, r *http.Re
isAdmin := securityContext.IsAdmin
registries, err := handler.DataStore.Registry().Registries()
registries, err := handler.DataStore.Registry().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve registries from the database", err)
}

4
api/http/handler/endpoints/endpoint_registry_access.go
View file

@ -69,7 +69,7 @@ func (handler *Handler) endpointRegistryAccess(w http.ResponseWriter, r *http.Re
return httperror.Forbidden("User is not authorized", err)
}
registry, err := handler.DataStore.Registry().Registry(portainer.RegistryID(registryID))
registry, err := handler.DataStore.Registry().Read(portainer.RegistryID(registryID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find an environment with the specified identifier inside the database", err)
} else if err != nil {
@ -106,7 +106,7 @@ func (handler *Handler) endpointRegistryAccess(w http.ResponseWriter, r *http.Re
registry.RegistryAccesses[portainer.EndpointID(endpointID)] = registryAccess
handler.DataStore.Registry().UpdateRegistry(registry.ID, registry)
handler.DataStore.Registry().Update(registry.ID, registry)
return response.Empty(w)
}

4
api/http/handler/endpoints/filter.go
View file

@ -176,7 +176,7 @@ func (handler *Handler) filterEndpointsByQuery(filteredEndpoints []portainer.End
}
if query.search != "" {
tags, err := handler.DataStore.Tag().Tags()
tags, err := handler.DataStore.Tag().ReadAll()
if err != nil {
return nil, 0, errors.WithMessage(err, "Unable to retrieve tags from the database")
}
@ -244,7 +244,7 @@ func filterEndpointsByEdgeStack(endpoints []portainer.Endpoint, edgeStackId port
envIds := make([]portainer.EndpointID, 0)
for _, edgeGroupdId := range stack.EdgeGroups {
edgeGroup, err := datastore.EdgeGroup().EdgeGroup(edgeGroupdId)
edgeGroup, err := datastore.EdgeGroup().Read(edgeGroupdId)
if err != nil {
return nil, errors.WithMessage(err, "Unable to retrieve edge group from the database")
}

4
api/http/handler/endpoints/update_edge_relations.go
View file

@ -20,12 +20,12 @@ func (handler *Handler) updateEdgeRelations(tx dataservices.DataStoreTx, endpoin
return errors.WithMessage(err, "Unable to find environment relation inside the database")
}
endpointGroup, err := tx.EndpointGroup().EndpointGroup(endpoint.GroupID)
endpointGroup, err := tx.EndpointGroup().Read(endpoint.GroupID)
if err != nil {
return errors.WithMessage(err, "Unable to find environment group inside the database")
}
edgeGroups, err := tx.EdgeGroup().EdgeGroups()
edgeGroups, err := tx.EdgeGroup().ReadAll()
if err != nil {
return errors.WithMessage(err, "Unable to retrieve edge groups from the database")
}

6
api/http/handler/endpoints/utils_update_edge_groups.go
View file

@ -9,7 +9,7 @@ import (
)
func updateEnvironmentEdgeGroups(tx dataservices.DataStoreTx, newEdgeGroups []portainer.EdgeGroupID, environmentID portainer.EndpointID) (bool, error) {
edgeGroups, err := tx.EdgeGroup().EdgeGroups()
edgeGroups, err := tx.EdgeGroup().ReadAll()
if err != nil {
return false, errors.WithMessage(err, "Unable to retrieve edge groups from the database")
}
@ -34,14 +34,14 @@ func updateEnvironmentEdgeGroups(tx dataservices.DataStoreTx, newEdgeGroups []po
updateSet := func(groupIDs set.Set[portainer.EdgeGroupID], updateItem func(*portainer.EdgeGroup)) error {
for groupID := range groupIDs {
group, err := tx.EdgeGroup().EdgeGroup(groupID)
group, err := tx.EdgeGroup().Read(groupID)
if err != nil {
return errors.WithMessage(err, "Unable to find a Edge group inside the database")
}
updateItem(group)
err = tx.EdgeGroup().UpdateEdgeGroup(groupID, group)
err = tx.EdgeGroup().Update(groupID, group)
if err != nil {
return errors.WithMessage(err, "Unable to persist Edge group changes inside the database")
}

4
api/http/handler/endpoints/utils_update_edge_groups_test.go
View file

@ -34,7 +34,7 @@ func Test_updateEdgeGroups(t *testing.T) {
checkGroups := func(store *datastore.Store, is *assert.Assertions, groupIDs []portainer.EdgeGroupID, endpointID portainer.EndpointID) {
for _, groupID := range groupIDs {
group, err := store.EdgeGroup().EdgeGroup(groupID)
group, err := store.EdgeGroup().Read(groupID)
is.NoError(err)
for _, endpoint := range group.Endpoints {
@ -83,7 +83,7 @@ func Test_updateEdgeGroups(t *testing.T) {
for _, group := range endpointGroups {
group.Endpoints = append(group.Endpoints, testCase.endpoint.ID)
err = store.EdgeGroup().UpdateEdgeGroup(group.ID, &group)
err = store.EdgeGroup().Update(group.ID, &group)
is.NoError(err)
}

4
api/http/handler/endpoints/utils_update_tags.go
View file

@ -20,14 +20,14 @@ func updateEnvironmentTags(tx dataservices.DataStoreTx, newTags []portainer.TagI
updateSet := func(tagIDs set.Set[portainer.TagID], updateItem func(*portainer.Tag)) error {
for tagID := range tagIDs {
tag, err := tx.Tag().Tag(tagID)
tag, err := tx.Tag().Read(tagID)
if err != nil {
return errors.WithMessage(err, "Unable to find a tag inside the database")
}
updateItem(tag)
err = tx.Tag().UpdateTag(tagID, tag)
err = tx.Tag().Update(tagID, tag)
if err != nil {
return errors.WithMessage(err, "Unable to persist tag changes inside the database")
}

4
api/http/handler/endpoints/utils_update_tags_test.go
View file

@ -33,7 +33,7 @@ func Test_updateTags(t *testing.T) {
checkTags := func(store *datastore.Store, is *assert.Assertions, tagIDs []portainer.TagID, endpointID portainer.EndpointID) {
for _, tagID := range tagIDs {
tag, err := store.Tag().Tag(tagID)
tag, err := store.Tag().Read(tagID)
is.NoError(err)
_, ok := tag.Endpoints[endpointID]
@ -87,7 +87,7 @@ func Test_updateTags(t *testing.T) {
for _, tag := range endpointTags {
tag.Endpoints[testCase.endpoint.ID] = true
err = store.Tag().UpdateTag(tag.ID, &tag)
err = store.Tag().Update(tag.ID, &tag)
is.NoError(err)
}

2
api/http/handler/helm/helm_install.go
View file

@ -151,7 +151,7 @@ func (handler *Handler) applyPortainerLabelsToHelmAppManifest(r *http.Request, i
if err != nil {
return nil, errors.Wrap(err, "unable to retrieve user details from authentication token")
}
user, err := handler.dataStore.User().User(tokenData.ID)
user, err := handler.dataStore.User().Read(tokenData.ID)
if err != nil {
return nil, errors.Wrap(err, "unable to load user information from the database")
}

2
api/http/handler/hostmanagement/fdo/configure.go
View file

@ -78,7 +78,7 @@ func (handler *Handler) fdoConfigureDevice(w http.ResponseWriter, r *http.Reques
return httperror.BadRequest("Invalid request payload", err)
}
profile, err := handler.DataStore.FDOProfile().FDOProfile(portainer.FDOProfileID(payload.ProfileID))
profile, err := handler.DataStore.FDOProfile().Read(portainer.FDOProfileID(payload.ProfileID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a FDO Profile with the specified identifier inside the database", err)
} else if err != nil {

2
api/http/handler/hostmanagement/fdo/fdo.go
View file

@ -99,7 +99,7 @@ func (handler *Handler) fdoConfigure(w http.ResponseWriter, r *http.Request) *ht
return httperror.BadRequest("Error saving FDO settings", err)
}
profiles, err := handler.DataStore.FDOProfile().FDOProfiles()
profiles, err := handler.DataStore.FDOProfile().ReadAll()
if err != nil {
return httperror.InternalServerError("Error saving FDO settings", err)
}

2
api/http/handler/hostmanagement/fdo/profile_duplicate.go
View file

@ -31,7 +31,7 @@ func (handler *Handler) duplicateProfile(w http.ResponseWriter, r *http.Request)
return httperror.BadRequest("Bad request", errors.New("missing 'id' query parameter"))
}
originalProfile, err := handler.DataStore.FDOProfile().FDOProfile(portainer.FDOProfileID(id))
originalProfile, err := handler.DataStore.FDOProfile().Read(portainer.FDOProfileID(id))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a FDO Profile with the specified identifier inside the database", err)
} else if err != nil {

2
api/http/handler/hostmanagement/fdo/profile_inspect.go
View file

@ -33,7 +33,7 @@ func (handler *Handler) fdoProfileInspect(w http.ResponseWriter, r *http.Request
return httperror.BadRequest("Bad request", errors.New("missing 'id' query parameter"))
}
profile, err := handler.DataStore.FDOProfile().FDOProfile(portainer.FDOProfileID(id))
profile, err := handler.DataStore.FDOProfile().Read(portainer.FDOProfileID(id))
if err != nil {
return httperror.InternalServerError("Unable to retrieve Profile", err)
}

2
api/http/handler/hostmanagement/fdo/profile_list.go
View file

@ -22,7 +22,7 @@ import (
// @router /fdo/profiles [get]
func (handler *Handler) fdoProfileList(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
profiles, err := handler.DataStore.FDOProfile().FDOProfiles()
profiles, err := handler.DataStore.FDOProfile().ReadAll()
if err != nil {
return httperror.InternalServerError(err.Error(), err)
}

2
api/http/handler/hostmanagement/fdo/profile_update.go
View file

@ -37,7 +37,7 @@ func (handler *Handler) updateProfile(w http.ResponseWriter, r *http.Request) *h
return httperror.BadRequest("Invalid request payload", err)
}
profile, err := handler.DataStore.FDOProfile().FDOProfile(portainer.FDOProfileID(id))
profile, err := handler.DataStore.FDOProfile().Read(portainer.FDOProfileID(id))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a FDO Profile with the specified identifier inside the database", err)
} else if err != nil {

2
api/http/handler/hostmanagement/fdo/utils.go
View file

@ -1,7 +1,7 @@
package fdo
func (handler *Handler) checkUniqueProfileName(name string, id int) (bool, error) {
profiles, err := handler.DataStore.FDOProfile().FDOProfiles()
profiles, err := handler.DataStore.FDOProfile().ReadAll()
if err != nil {
return false, err
}

2
api/http/handler/kubernetes/config.go
View file

@ -75,7 +75,7 @@ func (handler *Handler) filterUserKubeEndpoints(r *http.Request) ([]portainer.En
return nil, httperror.InternalServerError("Unable to retrieve info from request context", err)
}
endpointGroups, err := handler.DataStore.EndpointGroup().EndpointGroups()
endpointGroups, err := handler.DataStore.EndpointGroup().ReadAll()
if err != nil {
return nil, httperror.InternalServerError("Unable to retrieve environment groups from the database", err)
}

4
api/http/handler/registries/registry_configure.go
View file

@ -118,7 +118,7 @@ func (handler *Handler) registryConfigure(w http.ResponseWriter, r *http.Request
return httperror.BadRequest("Invalid registry identifier route variable", err)
}
registry, err := handler.DataStore.Registry().Registry(portainer.RegistryID(registryID))
registry, err := handler.DataStore.Registry().Read(portainer.RegistryID(registryID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a registry with the specified identifier inside the database", err)
} else if err != nil {
@ -172,7 +172,7 @@ func (handler *Handler) registryConfigure(w http.ResponseWriter, r *http.Request
registry.ManagementConfiguration = syncConfig(registry)
registry.ManagementConfiguration.TLSConfig = tlsConfig
err = handler.DataStore.Registry().UpdateRegistry(registry.ID, registry)
err = handler.DataStore.Registry().Update(registry.ID, registry)
if err != nil {
return httperror.InternalServerError("Unable to persist registry changes inside the database", err)
}

2
api/http/handler/registries/registry_create.go
View file

@ -121,7 +121,7 @@ func (handler *Handler) registryCreate(w http.ResponseWriter, r *http.Request) *
registry.ManagementConfiguration = syncConfig(registry)
registries, err := handler.DataStore.Registry().Registries()
registries, err := handler.DataStore.Registry().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve registries from the database", err)
}

4
api/http/handler/registries/registry_delete.go
View file

@ -38,14 +38,14 @@ func (handler *Handler) registryDelete(w http.ResponseWriter, r *http.Request) *
return httperror.BadRequest("Invalid registry identifier route variable", err)
}
_, err = handler.DataStore.Registry().Registry(portainer.RegistryID(registryID))
_, err = handler.DataStore.Registry().Read(portainer.RegistryID(registryID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a registry with the specified identifier inside the database", err)
} else if err != nil {
return httperror.InternalServerError("Unable to find a registry with the specified identifier inside the database", err)
}
err = handler.DataStore.Registry().DeleteRegistry(portainer.RegistryID(registryID))
err = handler.DataStore.Registry().Delete(portainer.RegistryID(registryID))
if err != nil {
return httperror.InternalServerError("Unable to remove the registry from the database", err)
}

2
api/http/handler/registries/registry_inspect.go
View file

@ -40,7 +40,7 @@ func (handler *Handler) registryInspect(w http.ResponseWriter, r *http.Request)
return httperror.BadRequest("Invalid registry identifier route variable", err)
}
registry, err := handler.DataStore.Registry().Registry(portainer.RegistryID(registryID))
registry, err := handler.DataStore.Registry().Read(portainer.RegistryID(registryID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a registry with the specified identifier inside the database", err)
} else if err != nil {

2
api/http/handler/registries/registry_list.go
View file

@ -31,7 +31,7 @@ func (handler *Handler) registryList(w http.ResponseWriter, r *http.Request) *ht
return httperror.Forbidden("Permission denied to list registries, use /endpoints/:endpointId/registries route instead", httperrors.ErrResourceAccessDenied)
}
registries, err := handler.DataStore.Registry().Registries()
registries, err := handler.DataStore.Registry().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve registries from the database", err)
}

6
api/http/handler/registries/registry_update.go
View file

@ -71,14 +71,14 @@ func (handler *Handler) registryUpdate(w http.ResponseWriter, r *http.Request) *
return httperror.BadRequest("Invalid registry identifier route variable", err)
}
registry, err := handler.DataStore.Registry().Registry(portainer.RegistryID(registryID))
registry, err := handler.DataStore.Registry().Read(portainer.RegistryID(registryID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a registry with the specified identifier inside the database", err)
} else if err != nil {
return httperror.InternalServerError("Unable to find a registry with the specified identifier inside the database", err)
}
registries, err := handler.DataStore.Registry().Registries()
registries, err := handler.DataStore.Registry().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve registries from the database", err)
}
@ -177,7 +177,7 @@ func (handler *Handler) registryUpdate(w http.ResponseWriter, r *http.Request) *
registry.Quay = *payload.Quay
}
err = handler.DataStore.Registry().UpdateRegistry(registry.ID, registry)
err = handler.DataStore.Registry().Update(registry.ID, registry)
if err != nil {
return httperror.InternalServerError("Unable to persist registry changes inside the database", err)
}

4
api/http/handler/resourcecontrols/resourcecontrol_delete.go
View file

@ -28,14 +28,14 @@ func (handler *Handler) resourceControlDelete(w http.ResponseWriter, r *http.Req
return httperror.BadRequest("Invalid resource control identifier route variable", err)
}
_, err = handler.DataStore.ResourceControl().ResourceControl(portainer.ResourceControlID(resourceControlID))
_, err = handler.DataStore.ResourceControl().Read(portainer.ResourceControlID(resourceControlID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a resource control with the specified identifier inside the database", err)
} else if err != nil {
return httperror.InternalServerError("Unable to find a resource control with with the specified identifier inside the database", err)
}
err = handler.DataStore.ResourceControl().DeleteResourceControl(portainer.ResourceControlID(resourceControlID))
err = handler.DataStore.ResourceControl().Delete(portainer.ResourceControlID(resourceControlID))
if err != nil {
return httperror.InternalServerError("Unable to remove the resource control from the database", err)
}

4
api/http/handler/resourcecontrols/resourcecontrol_update.go
View file

@ -63,7 +63,7 @@ func (handler *Handler) resourceControlUpdate(w http.ResponseWriter, r *http.Req
return httperror.BadRequest("Invalid request payload", err)
}
resourceControl, err := handler.DataStore.ResourceControl().ResourceControl(portainer.ResourceControlID(resourceControlID))
resourceControl, err := handler.DataStore.ResourceControl().Read(portainer.ResourceControlID(resourceControlID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a resource control with the specified identifier inside the database", err)
} else if err != nil {
@ -106,7 +106,7 @@ func (handler *Handler) resourceControlUpdate(w http.ResponseWriter, r *http.Req
return httperror.Forbidden("Permission denied to update the resource control", httperrors.ErrResourceAccessDenied)
}
err = handler.DataStore.ResourceControl().UpdateResourceControl(resourceControl.ID, resourceControl)
err = handler.DataStore.ResourceControl().Update(resourceControl.ID, resourceControl)
if err != nil {
return httperror.InternalServerError("Unable to persist resource control changes inside the database", err)
}

2
api/http/handler/roles/role_list.go
View file

@ -19,7 +19,7 @@ import (
// @failure 500 "Server error"
// @router /roles [get]
func (handler *Handler) roleList(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
roles, err := handler.DataStore.Role().Roles()
roles, err := handler.DataStore.Role().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve authorization sets from the database", err)
}

4
api/http/handler/stacks/create_compose_stack.go
View file

@ -61,13 +61,13 @@ func (handler *Handler) checkAndCleanStackDupFromSwarm(w http.ResponseWriter, r
deployments.StopAutoupdate(stack.ID, stack.AutoUpdate.JobID, handler.Scheduler)
}
err = handler.DataStore.Stack().DeleteStack(stack.ID)
err = handler.DataStore.Stack().Delete(stack.ID)
if err != nil {
return err
}
if resourceControl != nil {
err = handler.DataStore.ResourceControl().DeleteResourceControl(resourceControl.ID)
err = handler.DataStore.ResourceControl().Delete(resourceControl.ID)
if err != nil {
log.Error().
Str("stack", fmt.Sprintf("%+v", stack)).

6
api/http/handler/stacks/create_kubernetes_stack.go
View file

@ -156,7 +156,7 @@ func (handler *Handler) createKubernetesStackFromFileContent(w http.ResponseWrit
return httperror.BadRequest("Invalid request payload", err)
}
user, err := handler.DataStore.User().User(userID)
user, err := handler.DataStore.User().Read(userID)
if err != nil {
return httperror.InternalServerError("Unable to load user information from the database", err)
}
@ -213,7 +213,7 @@ func (handler *Handler) createKubernetesStackFromGitRepository(w http.ResponseWr
return httperror.BadRequest("Invalid request payload", err)
}
user, err := handler.DataStore.User().User(userID)
user, err := handler.DataStore.User().Read(userID)
if err != nil {
return httperror.InternalServerError("Unable to load user information from the database", err)
}
@ -291,7 +291,7 @@ func (handler *Handler) createKubernetesStackFromManifestURL(w http.ResponseWrit
return httperror.BadRequest("Invalid request payload", err)
}
user, err := handler.DataStore.User().User(userID)
user, err := handler.DataStore.User().Read(userID)
if err != nil {
return httperror.InternalServerError("Unable to load user information from the database", err)
}

8
api/http/handler/stacks/handler.go
View file

@ -87,7 +87,7 @@ func NewHandler(bouncer security.BouncerService) *Handler {
}
func (handler *Handler) userCanAccessStack(securityContext *security.RestrictedRequestContext, endpointID portainer.EndpointID, resourceControl *portainer.ResourceControl) (bool, error) {
user, err := handler.DataStore.User().User(securityContext.UserID)
user, err := handler.DataStore.User().Read(securityContext.UserID)
if err != nil {
return false, err
}
@ -105,7 +105,7 @@ func (handler *Handler) userCanAccessStack(securityContext *security.RestrictedR
}
func (handler *Handler) userIsAdmin(userID portainer.UserID) (bool, error) {
user, err := handler.DataStore.User().User(userID)
user, err := handler.DataStore.User().Read(userID)
if err != nil {
return false, err
}
@ -116,7 +116,7 @@ func (handler *Handler) userIsAdmin(userID portainer.UserID) (bool, error) {
}
func (handler *Handler) userCanCreateStack(securityContext *security.RestrictedRequestContext, endpointID portainer.EndpointID) (bool, error) {
user, err := handler.DataStore.User().User(securityContext.UserID)
user, err := handler.DataStore.User().Read(securityContext.UserID)
if err != nil {
return false, err
}
@ -145,7 +145,7 @@ func (handler *Handler) userCanManageStacks(securityContext *security.Restricted
}
func (handler *Handler) checkUniqueStackName(endpoint *portainer.Endpoint, name string, stackID portainer.StackID) (bool, error) {
stacks, err := handler.DataStore.Stack().Stacks()
stacks, err := handler.DataStore.Stack().ReadAll()
if err != nil {
return false, err
}

8
api/http/handler/stacks/stack_associate.go
View file

@ -56,12 +56,12 @@ func (handler *Handler) stackAssociate(w http.ResponseWriter, r *http.Request) *
return httperror.InternalServerError("Unable to retrieve info from request context", err)
}
user, err := handler.DataStore.User().User(securityContext.UserID)
user, err := handler.DataStore.User().Read(securityContext.UserID)
if err != nil {
return httperror.InternalServerError("Unable to load user information from the database", err)
}
stack, err := handler.DataStore.Stack().Stack(portainer.StackID(stackID))
stack, err := handler.DataStore.Stack().Read(portainer.StackID(stackID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a stack with the specified identifier inside the database", err)
} else if err != nil {
@ -76,7 +76,7 @@ func (handler *Handler) stackAssociate(w http.ResponseWriter, r *http.Request) *
if resourceControl != nil {
resourceControl.ResourceID = fmt.Sprintf("%d_%s", endpointID, stack.Name)
err = handler.DataStore.ResourceControl().UpdateResourceControl(resourceControl.ID, resourceControl)
err = handler.DataStore.ResourceControl().Update(resourceControl.ID, resourceControl)
if err != nil {
return httperror.InternalServerError("Unable to persist resource control changes inside the database", err)
}
@ -112,7 +112,7 @@ func (handler *Handler) stackAssociate(w http.ResponseWriter, r *http.Request) *
stack.UpdateDate = 0
stack.UpdatedBy = ""
err = handler.DataStore.Stack().UpdateStack(stack.ID, stack)
err = handler.DataStore.Stack().Update(stack.ID, stack)
if err != nil {
return httperror.InternalServerError("Unable to persist the stack changes inside the database", err)
}

6
api/http/handler/stacks/stack_delete.go
View file

@ -57,7 +57,7 @@ func (handler *Handler) stackDelete(w http.ResponseWriter, r *http.Request) *htt
return httperror.BadRequest("Invalid stack identifier route variable", err)
}
stack, err := handler.DataStore.Stack().Stack(portainer.StackID(id))
stack, err := handler.DataStore.Stack().Read(portainer.StackID(id))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a stack with the specified identifier inside the database", err)
} else if err != nil {
@ -123,13 +123,13 @@ func (handler *Handler) stackDelete(w http.ResponseWriter, r *http.Request) *htt
return httperror.InternalServerError(err.Error(), err)
}
err = handler.DataStore.Stack().DeleteStack(portainer.StackID(id))
err = handler.DataStore.Stack().Delete(portainer.StackID(id))
if err != nil {
return httperror.InternalServerError("Unable to remove the stack from the database", err)
}
if resourceControl != nil {
err = handler.DataStore.ResourceControl().DeleteResourceControl(resourceControl.ID)
err = handler.DataStore.ResourceControl().Delete(resourceControl.ID)
if err != nil {
return httperror.InternalServerError("Unable to remove the associated resource control from the database", err)
}

2
api/http/handler/stacks/stack_file.go
View file

@ -39,7 +39,7 @@ func (handler *Handler) stackFile(w http.ResponseWriter, r *http.Request) *httpe
return httperror.BadRequest("Invalid stack identifier route variable", err)
}
stack, err := handler.DataStore.Stack().Stack(portainer.StackID(stackID))
stack, err := handler.DataStore.Stack().Read(portainer.StackID(stackID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a stack with the specified identifier inside the database", err)
} else if err != nil {

2
api/http/handler/stacks/stack_inspect.go
View file

@ -34,7 +34,7 @@ func (handler *Handler) stackInspect(w http.ResponseWriter, r *http.Request) *ht
return httperror.BadRequest("Invalid stack identifier route variable", err)
}
stack, err := handler.DataStore.Stack().Stack(portainer.StackID(stackID))
stack, err := handler.DataStore.Stack().Read(portainer.StackID(stackID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a stack with the specified identifier inside the database", err)
} else if err != nil {

6
api/http/handler/stacks/stack_list.go
View file

@ -46,13 +46,13 @@ func (handler *Handler) stackList(w http.ResponseWriter, r *http.Request) *httpe
return httperror.InternalServerError("Unable to retrieve environments from database", err)
}
stacks, err := handler.DataStore.Stack().Stacks()
stacks, err := handler.DataStore.Stack().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve stacks from the database", err)
}
stacks = filterStacks(stacks, &filters, endpoints)
resourceControls, err := handler.DataStore.ResourceControl().ResourceControls()
resourceControls, err := handler.DataStore.ResourceControl().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve resource controls from the database", err)
}
@ -69,7 +69,7 @@ func (handler *Handler) stackList(w http.ResponseWriter, r *http.Request) *httpe
return httperror.Forbidden("Permission denied to access orphaned stacks", httperrors.ErrUnauthorized)
}
user, err := handler.DataStore.User().User(securityContext.UserID)
user, err := handler.DataStore.User().Read(securityContext.UserID)
if err != nil {
return httperror.InternalServerError("Unable to retrieve user information from the database", err)
}

6
api/http/handler/stacks/stack_migrate.go
View file

@ -60,7 +60,7 @@ func (handler *Handler) stackMigrate(w http.ResponseWriter, r *http.Request) *ht
return httperror.BadRequest("Invalid request payload", err)
}
stack, err := handler.DataStore.Stack().Stack(portainer.StackID(stackID))
stack, err := handler.DataStore.Stack().Read(portainer.StackID(stackID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a stack with the specified identifier inside the database", err)
} else if err != nil {
@ -161,14 +161,14 @@ func (handler *Handler) stackMigrate(w http.ResponseWriter, r *http.Request) *ht
}
stack.Name = newName
err = handler.DataStore.Stack().UpdateStack(stack.ID, stack)
err = handler.DataStore.Stack().Update(stack.ID, stack)
if err != nil {
return httperror.InternalServerError("Unable to persist the stack changes inside the database", err)
}
if resourceControl != nil {
resourceControl.ResourceID = stackutils.ResourceControlID(stack.EndpointID, stack.Name)
err := handler.DataStore.ResourceControl().UpdateResourceControl(resourceControl.ID, resourceControl)
err := handler.DataStore.ResourceControl().Update(resourceControl.ID, resourceControl)
if err != nil {
return httperror.InternalServerError("Unable to persist the resource control changes", err)
}

4
api/http/handler/stacks/stack_start.go
View file

@ -43,7 +43,7 @@ func (handler *Handler) stackStart(w http.ResponseWriter, r *http.Request) *http
return httperror.InternalServerError("Unable to retrieve info from request context", err)
}
stack, err := handler.DataStore.Stack().Stack(portainer.StackID(stackID))
stack, err := handler.DataStore.Stack().Read(portainer.StackID(stackID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a stack with the specified identifier inside the database", err)
} else if err != nil {
@ -123,7 +123,7 @@ func (handler *Handler) stackStart(w http.ResponseWriter, r *http.Request) *http
}
stack.Status = portainer.StackStatusActive
err = handler.DataStore.Stack().UpdateStack(stack.ID, stack)
err = handler.DataStore.Stack().Update(stack.ID, stack)
if err != nil {
return httperror.InternalServerError("Unable to update stack status", err)
}

4
api/http/handler/stacks/stack_stop.go
View file

@ -41,7 +41,7 @@ func (handler *Handler) stackStop(w http.ResponseWriter, r *http.Request) *httpe
return httperror.InternalServerError("Unable to retrieve info from request context", err)
}
stack, err := handler.DataStore.Stack().Stack(portainer.StackID(stackID))
stack, err := handler.DataStore.Stack().Read(portainer.StackID(stackID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a stack with the specified identifier inside the database", err)
} else if err != nil {
@ -107,7 +107,7 @@ func (handler *Handler) stackStop(w http.ResponseWriter, r *http.Request) *httpe
}
stack.Status = portainer.StackStatusInactive
err = handler.DataStore.Stack().UpdateStack(stack.ID, stack)
err = handler.DataStore.Stack().Update(stack.ID, stack)
if err != nil {
return httperror.InternalServerError("Unable to update stack status", err)
}

6
api/http/handler/stacks/stack_update.go
View file

@ -77,7 +77,7 @@ func (handler *Handler) stackUpdate(w http.ResponseWriter, r *http.Request) *htt
return httperror.BadRequest("Invalid stack identifier route variable", err)
}
stack, err := handler.DataStore.Stack().Stack(portainer.StackID(stackID))
stack, err := handler.DataStore.Stack().Read(portainer.StackID(stackID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a stack with the specified identifier inside the database", err)
} else if err != nil {
@ -143,7 +143,7 @@ func (handler *Handler) stackUpdate(w http.ResponseWriter, r *http.Request) *htt
return updateError
}
user, err := handler.DataStore.User().User(securityContext.UserID)
user, err := handler.DataStore.User().Read(securityContext.UserID)
if err != nil {
return httperror.BadRequest("Cannot find context user", errors.Wrap(err, "failed to fetch the user"))
}
@ -151,7 +151,7 @@ func (handler *Handler) stackUpdate(w http.ResponseWriter, r *http.Request) *htt
stack.UpdateDate = time.Now().Unix()
stack.Status = portainer.StackStatusActive
err = handler.DataStore.Stack().UpdateStack(stack.ID, stack)
err = handler.DataStore.Stack().Update(stack.ID, stack)
if err != nil {
return httperror.InternalServerError("Unable to persist the stack changes inside the database", err)
}

6
api/http/handler/stacks/stack_update_git.go
View file

@ -65,7 +65,7 @@ func (handler *Handler) stackUpdateGit(w http.ResponseWriter, r *http.Request) *
return httperror.BadRequest("Invalid request payload", err)
}
stack, err := handler.DataStore.Stack().Stack(portainer.StackID(stackID))
stack, err := handler.DataStore.Stack().Read(portainer.StackID(stackID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a stack with the specified identifier inside the database", err)
} else if err != nil {
@ -103,7 +103,7 @@ func (handler *Handler) stackUpdateGit(w http.ResponseWriter, r *http.Request) *
return httperror.InternalServerError("Unable to retrieve info from request context", err)
}
user, err := handler.DataStore.User().User(securityContext.UserID)
user, err := handler.DataStore.User().Read(securityContext.UserID)
if err != nil {
return httperror.BadRequest("Cannot find context user", errors.Wrap(err, "failed to fetch the user"))
}
@ -181,7 +181,7 @@ func (handler *Handler) stackUpdateGit(w http.ResponseWriter, r *http.Request) *
}
//save the updated stack to DB
err = handler.DataStore.Stack().UpdateStack(stack.ID, stack)
err = handler.DataStore.Stack().Update(stack.ID, stack)
if err != nil {
return httperror.InternalServerError("Unable to persist the stack changes inside the database", err)
}

6
api/http/handler/stacks/stack_update_git_redeploy.go
View file

@ -56,7 +56,7 @@ func (handler *Handler) stackGitRedeploy(w http.ResponseWriter, r *http.Request)
return httperror.BadRequest("Invalid stack identifier route variable", err)
}
stack, err := handler.DataStore.Stack().Stack(portainer.StackID(stackID))
stack, err := handler.DataStore.Stack().Read(portainer.StackID(stackID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a stack with the specified identifier inside the database", err)
} else if err != nil {
@ -175,7 +175,7 @@ func (handler *Handler) stackGitRedeploy(w http.ResponseWriter, r *http.Request)
}
stack.GitConfig.ConfigHash = newHash
user, err := handler.DataStore.User().User(securityContext.UserID)
user, err := handler.DataStore.User().Read(securityContext.UserID)
if err != nil {
return httperror.BadRequest("Cannot find context user", errors.Wrap(err, "failed to fetch the user"))
}
@ -183,7 +183,7 @@ func (handler *Handler) stackGitRedeploy(w http.ResponseWriter, r *http.Request)
stack.UpdateDate = time.Now().Unix()
stack.Status = portainer.StackStatusActive
err = handler.DataStore.Stack().UpdateStack(stack.ID, stack)
err = handler.DataStore.Stack().Update(stack.ID, stack)
if err != nil {
return httperror.InternalServerError("Unable to persist the stack changes inside the database", errors.Wrap(err, "failed to update the stack"))
}

2
api/http/handler/tags/tag_create.go
View file

@ -59,7 +59,7 @@ func (handler *Handler) tagCreate(w http.ResponseWriter, r *http.Request) *httpe
}
func createTag(tx dataservices.DataStoreTx, payload tagCreatePayload) (*portainer.Tag, error) {
tags, err := tx.Tag().Tags()
tags, err := tx.Tag().ReadAll()
if err != nil {
return nil, httperror.InternalServerError("Unable to retrieve tags from the database", err)
}

14
api/http/handler/tags/tag_delete.go
View file

@ -54,7 +54,7 @@ func (handler *Handler) tagDelete(w http.ResponseWriter, r *http.Request) *httpe
}
func deleteTag(tx dataservices.DataStoreTx, tagID portainer.TagID) error {
tag, err := tx.Tag().Tag(tagID)
tag, err := tx.Tag().Read(tagID)
if tx.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a tag with the specified identifier inside the database", err)
} else if err != nil {
@ -75,13 +75,13 @@ func deleteTag(tx dataservices.DataStoreTx, tagID portainer.TagID) error {
}
for endpointGroupID := range tag.EndpointGroups {
endpointGroup, err := tx.EndpointGroup().EndpointGroup(endpointGroupID)
endpointGroup, err := tx.EndpointGroup().Read(endpointGroupID)
if err != nil {
return httperror.InternalServerError("Unable to retrieve environment group from the database", err)
}
endpointGroup.TagIDs = removeElement(endpointGroup.TagIDs, tagID)
err = tx.EndpointGroup().UpdateEndpointGroup(endpointGroup.ID, endpointGroup)
err = tx.EndpointGroup().Update(endpointGroup.ID, endpointGroup)
if err != nil {
return httperror.InternalServerError("Unable to update environment group", err)
}
@ -92,7 +92,7 @@ func deleteTag(tx dataservices.DataStoreTx, tagID portainer.TagID) error {
return httperror.InternalServerError("Unable to retrieve environments from the database", err)
}
edgeGroups, err := tx.EdgeGroup().EdgeGroups()
edgeGroups, err := tx.EdgeGroup().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve edge groups from the database", err)
}
@ -124,14 +124,14 @@ func deleteTag(tx dataservices.DataStoreTx, tagID portainer.TagID) error {
for _, edgeGroup := range edgeGroups {
edgeGroup.TagIDs = removeElement(edgeGroup.TagIDs, tagID)
err = tx.EdgeGroup().UpdateEdgeGroup(edgeGroup.ID, &edgeGroup)
err = tx.EdgeGroup().Update(edgeGroup.ID, &edgeGroup)
if err != nil {
return httperror.InternalServerError("Unable to update edge group", err)
}
}
}
err = tx.Tag().DeleteTag(tagID)
err = tx.Tag().Delete(tagID)
if err != nil {
return httperror.InternalServerError("Unable to remove the tag from the database", err)
}
@ -145,7 +145,7 @@ func updateEndpointRelations(tx dataservices.DataStoreTx, endpoint portainer.End
return err
}
endpointGroup, err := tx.EndpointGroup().EndpointGroup(endpoint.GroupID)
endpointGroup, err := tx.EndpointGroup().Read(endpoint.GroupID)
if err != nil {
return err
}

2
api/http/handler/tags/tag_delete_test.go
View file

@ -77,7 +77,7 @@ func TestTagDeleteEdgeGroupsConcurrently(t *testing.T) {
// Check that the edge group is consistent
edgeGroup, err := handler.DataStore.EdgeGroup().EdgeGroup(1)
edgeGroup, err := handler.DataStore.EdgeGroup().Read(1)
if err != nil {
t.Fatal("could not retrieve the edge group:", err)
}

2
api/http/handler/tags/tag_list.go
View file

@ -19,7 +19,7 @@ import (
// @failure 500 "Server error"
// @router /tags [get]
func (handler *Handler) tagList(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
tags, err := handler.DataStore.Tag().Tags()
tags, err := handler.DataStore.Tag().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve tags from the database", err)
}

4
api/http/handler/teammemberships/teammembership_delete.go
View file

@ -31,7 +31,7 @@ func (handler *Handler) teamMembershipDelete(w http.ResponseWriter, r *http.Requ
return httperror.BadRequest("Invalid membership identifier route variable", err)
}
membership, err := handler.DataStore.TeamMembership().TeamMembership(portainer.TeamMembershipID(membershipID))
membership, err := handler.DataStore.TeamMembership().Read(portainer.TeamMembershipID(membershipID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a team membership with the specified identifier inside the database", err)
} else if err != nil {
@ -47,7 +47,7 @@ func (handler *Handler) teamMembershipDelete(w http.ResponseWriter, r *http.Requ
return httperror.Forbidden("Permission denied to delete the membership", errors.ErrResourceAccessDenied)
}
err = handler.DataStore.TeamMembership().DeleteTeamMembership(portainer.TeamMembershipID(membershipID))
err = handler.DataStore.TeamMembership().Delete(portainer.TeamMembershipID(membershipID))
if err != nil {
return httperror.InternalServerError("Unable to remove the team membership from the database", err)
}

2
api/http/handler/teammemberships/teammembership_list.go
View file

@ -21,7 +21,7 @@ import (
// @failure 500 "Server error"
// @router /team_memberships [get]
func (handler *Handler) teamMembershipList(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
memberships, err := handler.DataStore.TeamMembership().TeamMemberships()
memberships, err := handler.DataStore.TeamMembership().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve team memberships from the database", err)
}

4
api/http/handler/teammemberships/teammembership_update.go
View file

@ -63,7 +63,7 @@ func (handler *Handler) teamMembershipUpdate(w http.ResponseWriter, r *http.Requ
return httperror.BadRequest("Invalid request payload", err)
}
membership, err := handler.DataStore.TeamMembership().TeamMembership(portainer.TeamMembershipID(membershipID))
membership, err := handler.DataStore.TeamMembership().Read(portainer.TeamMembershipID(membershipID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a team membership with the specified identifier inside the database", err)
} else if err != nil {
@ -85,7 +85,7 @@ func (handler *Handler) teamMembershipUpdate(w http.ResponseWriter, r *http.Requ
membership.TeamID = portainer.TeamID(payload.TeamID)
membership.Role = portainer.MembershipRole(payload.Role)
err = handler.DataStore.TeamMembership().UpdateTeamMembership(membership.ID, membership)
err = handler.DataStore.TeamMembership().Update(membership.ID, membership)
if err != nil {
return httperror.InternalServerError("Unable to persist membership changes inside the database", err)
}

4
api/http/handler/teams/team_delete.go
View file

@ -30,14 +30,14 @@ func (handler *Handler) teamDelete(w http.ResponseWriter, r *http.Request) *http
return httperror.BadRequest("Invalid team identifier route variable", err)
}
_, err = handler.DataStore.Team().Team(portainer.TeamID(teamID))
_, err = handler.DataStore.Team().Read(portainer.TeamID(teamID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a team with the specified identifier inside the database", err)
} else if err != nil {
return httperror.InternalServerError("Unable to find a team with the specified identifier inside the database", err)
}
err = handler.DataStore.Team().DeleteTeam(portainer.TeamID(teamID))
err = handler.DataStore.Team().Delete(portainer.TeamID(teamID))
if err != nil {
return httperror.InternalServerError("Unable to delete the team from the database", err)
}

2
api/http/handler/teams/team_inspect.go
View file

@ -42,7 +42,7 @@ func (handler *Handler) teamInspect(w http.ResponseWriter, r *http.Request) *htt
return httperror.Forbidden("Access denied to team", errors.ErrResourceAccessDenied)
}
team, err := handler.DataStore.Team().Team(portainer.TeamID(teamID))
team, err := handler.DataStore.Team().Read(portainer.TeamID(teamID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a team with the specified identifier inside the database", err)
} else if err != nil {

4
api/http/handler/teams/team_list.go
View file

@ -24,7 +24,7 @@ import (
// @failure 500 "Server error"
// @router /teams [get]
func (handler *Handler) teamList(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
teams, err := handler.DataStore.Team().Teams()
teams, err := handler.DataStore.Team().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve teams from the database", err)
}
@ -54,7 +54,7 @@ func (handler *Handler) teamList(w http.ResponseWriter, r *http.Request) *httper
return httperror.InternalServerError("Unable to retrieve endpoint from the database", err)
}
endpointGroup, err := handler.DataStore.EndpointGroup().EndpointGroup(endpoint.GroupID)
endpointGroup, err := handler.DataStore.EndpointGroup().Read(endpoint.GroupID)
if err != nil {
return httperror.InternalServerError("Unable to retrieve environment groups from the database", err)
}

4
api/http/handler/teams/team_update.go
View file

@ -48,7 +48,7 @@ func (handler *Handler) teamUpdate(w http.ResponseWriter, r *http.Request) *http
return httperror.BadRequest("Invalid request payload", err)
}
team, err := handler.DataStore.Team().Team(portainer.TeamID(teamID))
team, err := handler.DataStore.Team().Read(portainer.TeamID(teamID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a team with the specified identifier inside the database", err)
} else if err != nil {
@ -59,7 +59,7 @@ func (handler *Handler) teamUpdate(w http.ResponseWriter, r *http.Request) *http
team.Name = payload.Name
}
err = handler.DataStore.Team().UpdateTeam(team.ID, team)
err = handler.DataStore.Team().Update(team.ID, team)
if err != nil {
return httperror.NotFound("Unable to persist team changes inside the database", err)
}

2
api/http/handler/users/user_create_access_token.go
View file

@ -79,7 +79,7 @@ func (handler *Handler) userCreateAccessToken(w http.ResponseWriter, r *http.Req
return httperror.Forbidden("Permission denied to create user access token", httperrors.ErrUnauthorized)
}
user, err := handler.DataStore.User().User(portainer.UserID(userID))
user, err := handler.DataStore.User().Read(portainer.UserID(userID))
if err != nil {
return httperror.BadRequest("Unable to find a user", err)
}

6
api/http/handler/users/user_delete.go
View file

@ -45,7 +45,7 @@ func (handler *Handler) userDelete(w http.ResponseWriter, r *http.Request) *http
return httperror.Forbidden("Cannot remove your own user account. Contact another administrator", errAdminCannotRemoveSelf)
}
user, err := handler.DataStore.User().User(portainer.UserID(userID))
user, err := handler.DataStore.User().Read(portainer.UserID(userID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a user with the specified identifier inside the database", err)
} else if err != nil {
@ -64,7 +64,7 @@ func (handler *Handler) deleteAdminUser(w http.ResponseWriter, user *portainer.U
return handler.deleteUser(w, user)
}
users, err := handler.DataStore.User().Users()
users, err := handler.DataStore.User().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve users from the database", err)
}
@ -84,7 +84,7 @@ func (handler *Handler) deleteAdminUser(w http.ResponseWriter, user *portainer.U
}
func (handler *Handler) deleteUser(w http.ResponseWriter, user *portainer.User) *httperror.HandlerError {
err := handler.DataStore.User().DeleteUser(user.ID)
err := handler.DataStore.User().Delete(user.ID)
if err != nil {
return httperror.InternalServerError("Unable to remove user from the database", err)
}

2
api/http/handler/users/user_get_access_tokens.go
View file

@ -42,7 +42,7 @@ func (handler *Handler) userGetAccessTokens(w http.ResponseWriter, r *http.Reque
return httperror.Forbidden("Permission denied to get user access tokens", httperrors.ErrUnauthorized)
}
_, err = handler.DataStore.User().User(portainer.UserID(userID))
_, err = handler.DataStore.User().Read(portainer.UserID(userID))
if err != nil {
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a user with the specified identifier inside the database", err)

2
api/http/handler/users/user_inspect.go
View file

@ -42,7 +42,7 @@ func (handler *Handler) userInspect(w http.ResponseWriter, r *http.Request) *htt
return httperror.Forbidden("Permission denied inspect user", errors.ErrResourceAccessDenied)
}
user, err := handler.DataStore.User().User(portainer.UserID(userID))
user, err := handler.DataStore.User().Read(portainer.UserID(userID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a user with the specified identifier inside the database", err)
} else if err != nil {

4
api/http/handler/users/user_list.go
View file

@ -26,7 +26,7 @@ import (
// @failure 500 "Server error"
// @router /users [get]
func (handler *Handler) userList(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
users, err := handler.DataStore.User().Users()
users, err := handler.DataStore.User().ReadAll()
if err != nil {
return httperror.InternalServerError("Unable to retrieve users from the database", err)
}
@ -52,7 +52,7 @@ func (handler *Handler) userList(w http.ResponseWriter, r *http.Request) *httper
return httperror.InternalServerError("Unable to retrieve endpoint from the database", err)
}
endpointGroup, err := handler.DataStore.EndpointGroup().EndpointGroup(endpoint.GroupID)
endpointGroup, err := handler.DataStore.EndpointGroup().Read(endpoint.GroupID)
if err != nil {
return httperror.InternalServerError("Unable to retrieve environment groups from the database", err)
}

2
api/http/handler/users/user_remove_access_token.go
View file

@ -48,7 +48,7 @@ func (handler *Handler) userRemoveAccessToken(w http.ResponseWriter, r *http.Req
return httperror.Forbidden("Permission denied to get user access tokens", httperrors.ErrUnauthorized)
}
_, err = handler.DataStore.User().User(portainer.UserID(userID))
_, err = handler.DataStore.User().Read(portainer.UserID(userID))
if err != nil {
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a user with the specified identifier inside the database", err)

4
api/http/handler/users/user_update.go
View file

@ -87,7 +87,7 @@ func (handler *Handler) userUpdate(w http.ResponseWriter, r *http.Request) *http
return httperror.Forbidden("Permission denied to update user to administrator role", httperrors.ErrResourceAccessDenied)
}
user, err := handler.DataStore.User().User(portainer.UserID(userID))
user, err := handler.DataStore.User().Read(portainer.UserID(userID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a user with the specified identifier inside the database", err)
} else if err != nil {
@ -125,7 +125,7 @@ func (handler *Handler) userUpdate(w http.ResponseWriter, r *http.Request) *http
user.TokenIssueAt = time.Now().Unix()
}
err = handler.DataStore.User().UpdateUser(user.ID, user)
err = handler.DataStore.User().Update(user.ID, user)
if err != nil {
return httperror.InternalServerError("Unable to persist user changes inside the database", err)
}

4
api/http/handler/users/user_update_password.go
View file

@ -74,7 +74,7 @@ func (handler *Handler) userUpdatePassword(w http.ResponseWriter, r *http.Reques
return httperror.BadRequest("Invalid request payload", err)
}
user, err := handler.DataStore.User().User(portainer.UserID(userID))
user, err := handler.DataStore.User().Read(portainer.UserID(userID))
if handler.DataStore.IsErrObjectNotFound(err) {
return httperror.NotFound("Unable to find a user with the specified identifier inside the database", err)
} else if err != nil {
@ -97,7 +97,7 @@ func (handler *Handler) userUpdatePassword(w http.ResponseWriter, r *http.Reques
user.TokenIssueAt = time.Now().Unix()
err = handler.DataStore.User().UpdateUser(user.ID, user)
err = handler.DataStore.User().Update(user.ID, user)
if err != nil {
return httperror.InternalServerError("Unable to persist user changes inside the database", err)
}

2
api/http/handler/webhooks/webhook_delete.go
View file

@ -37,7 +37,7 @@ func (handler *Handler) webhookDelete(w http.ResponseWriter, r *http.Request) *h
return httperror.Forbidden("Not authorized to delete a webhook", errors.New("not authorized to delete a webhook"))
}
err = handler.DataStore.Webhook().DeleteWebhook(portainer.WebhookID(id))
err = handler.DataStore.Webhook().Delete(portainer.WebhookID(id))
if err != nil {
return httperror.InternalServerError("Unable to remove the webhook from the database", err)
}

2
api/http/handler/webhooks/webhook_execute.go
View file

@ -100,7 +100,7 @@ func (handler *Handler) executeServiceWebhook(
}
if registryID != 0 {
registry, err := handler.DataStore.Registry().Registry(registryID)
registry, err := handler.DataStore.Registry().Read(registryID)
if err != nil {
return httperror.InternalServerError("Error getting registry", err)
}

Some files were not shown because too many files have changed in this diff Show more