1069331446

Committed 12 Nov 2023 09:28AM UTC coverage: 77.424% (-2.8%) from 80.241%

Build # 1069331446

Build Type

Pull #961

gitlab-ci

Committed by

kjaskiewiczz

Commit Message

feat: endpoint for bulk removal of releases by names

Changelog: Title
Ticket: MEN-6354

Signed-off-by: Krzysztof Jaskiewicz <krzysztof.jaskiewicz@northern.tech>

Pull Request Pull Request #961: add support for bulk removal of releases by names

Run Details

0 of 97 new or added lines in 5 files covered. (0.0%)

11 existing lines in 1 file now uncovered.

4009 of 5178 relevant lines covered (77.42%)

55.17 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

69.01

/app/app_releases.go

// Copyright 2023 Northern.tech AS
//
//        Licensed under the Apache License, Version 2.0 (the "License");
//        you may not use this file except in compliance with the License.
//        You may obtain a copy of the License at
//
//            http://www.apache.org/licenses/LICENSE-2.0
//
//        Unless required by applicable law or agreed to in writing, software
//        distributed under the License is distributed on an "AS IS" BASIS,
//        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//        See the License for the specific language governing permissions and
//        limitations under the License.

package app

import (
        "context"

        "github.com/pkg/errors"

        "github.com/mendersoftware/go-lib-micro/log"

        "github.com/mendersoftware/deployments/model"
        "github.com/mendersoftware/deployments/store"
)

// Errors expected from App interface
var (
        ErrReleaseNotFound = errors.New("release not found")
)

func (d *Deployments) updateReleaseEditArtifact(
        ctx context.Context,
        artifactToEdit *model.Image,
) error {

        if artifactToEdit == nil {
                return ErrEmptyArtifact
        }
        return d.db.UpdateReleaseArtifactDescription(
                ctx,
                artifactToEdit,
                artifactToEdit.ArtifactMeta.Name,
        )
}

func (d *Deployments) updateRelease(
        ctx context.Context,
        artifactToAdd *model.Image,
        artifactToRemove *model.Image,
) error {
        name := ""
        if artifactToRemove != nil {
                name = artifactToRemove.ArtifactMeta.Name
        } else if artifactToAdd != nil {
                name = artifactToAdd.ArtifactMeta.Name
        } else {
                return ErrEmptyArtifact
        }

        return d.db.UpdateReleaseArtifacts(ctx, artifactToAdd, artifactToRemove, name)
}

func (d *Deployments) ListReleaseTags(ctx context.Context) (model.Tags, error) {
        tags, err := d.db.ListReleaseTags(ctx)
        if err != nil {
                log.FromContext(ctx).
                        Errorf("failed to list release tags: %s", err)
                err = ErrModelInternal
        }
        return tags, err
}

func (d *Deployments) GetReleasesUpdateTypes(ctx context.Context) ([]string, error) {
        updateTypes, err := d.db.GetUpdateTypes(ctx)
        if err != nil {
                log.FromContext(ctx).
                        Errorf("failed to list release update types: %s", err)
                err = ErrModelInternal
        }
        return updateTypes, err
}

func (d *Deployments) ReplaceReleaseTags(
        ctx context.Context,
        releaseName string,
        tags model.Tags,
) error {
        err := d.db.ReplaceReleaseTags(ctx, releaseName, tags)
        if err != nil {
                switch err {
                case store.ErrNotFound:
                        err = ErrReleaseNotFound

                case model.ErrTooManyTags, model.ErrTooManyUniqueTags:
                        // pass

                default:
                        // Rewrite internal errors
                        log.FromContext(ctx).
                                Errorf("failed to replace tags in database: %s", err.Error())
                        err = ErrModelInternal
                }
        }
        return err
}

func (d *Deployments) UpdateRelease(
        ctx context.Context,
        releaseName string,
        release model.ReleasePatch,
) error {
        err := d.db.UpdateRelease(ctx, releaseName, release)
        if err != nil {
                switch err {
                case store.ErrNotFound:
                        err = ErrReleaseNotFound

                default:
                        // Rewrite internal errors
                        log.FromContext(ctx).
                                Errorf("failed to update release in the database: %s", err.Error())
                        err = ErrModelInternal
                }
        }
        return err
}

func (d *Deployments) DeleteReleases(
        ctx context.Context,
        releaseNames []string,
) ([]string, error) {
        ids, err := d.db.GetDeploymentIDsByArtifactNames(ctx, releaseNames)
        if err != nil || len(ids) > 0 {
                return ids, err
        }
        if err := d.db.DeleteImagesByNames(ctx, releaseNames); err != nil {
                return ids, err
        }
        err = d.db.DeleteReleasesByNames(ctx, releaseNames)
        return ids, err
}

1	// Copyright 2023 Northern.tech AS
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	package app
16
17	import (
18	"context"
19
20	"github.com/pkg/errors"
21
22	"github.com/mendersoftware/go-lib-micro/log"
23
24	"github.com/mendersoftware/deployments/model"
25	"github.com/mendersoftware/deployments/store"
26	)
27
28	// Errors expected from App interface
29	var (
30	ErrReleaseNotFound = errors.New("release not found")
31	)
32
33	func (d *Deployments) updateReleaseEditArtifact(
34	ctx context.Context,
35	artifactToEdit *model.Image,
36	) error {	×
37		×
38	if artifactToEdit == nil {	×
39	return ErrEmptyArtifact	×
40	}	×
41	return d.db.UpdateReleaseArtifactDescription(	×
42	ctx,	×
43	artifactToEdit,	×
44	artifactToEdit.ArtifactMeta.Name,	×
45	)	×
46	}
47
48	func (d *Deployments) updateRelease(
49	ctx context.Context,
50	artifactToAdd *model.Image,
51	artifactToRemove *model.Image,
52	) error {	1✔
53	name := ""	1✔
54	if artifactToRemove != nil {	2✔
55	name = artifactToRemove.ArtifactMeta.Name	1✔
56	} else if artifactToAdd != nil {	3✔
57	name = artifactToAdd.ArtifactMeta.Name	1✔
58	} else {	1✔
59	return ErrEmptyArtifact	×
60	}	×
61
62	return d.db.UpdateReleaseArtifacts(ctx, artifactToAdd, artifactToRemove, name)	1✔
63	}
64
65	func (d *Deployments) ListReleaseTags(ctx context.Context) (model.Tags, error) {	2✔
66	tags, err := d.db.ListReleaseTags(ctx)	2✔
67	if err != nil {	3✔
68	log.FromContext(ctx).	1✔
69	Errorf("failed to list release tags: %s", err)	1✔
70	err = ErrModelInternal	1✔
71	}	1✔
72	return tags, err	2✔
73	}
74
75	func (d *Deployments) GetReleasesUpdateTypes(ctx context.Context) ([]string, error) {	3✔
76	updateTypes, err := d.db.GetUpdateTypes(ctx)	3✔
77	if err != nil {	4✔
78	log.FromContext(ctx).	1✔
79	Errorf("failed to list release update types: %s", err)	1✔
80	err = ErrModelInternal	1✔
81	}	1✔
82	return updateTypes, err	3✔
83	}
84
85	func (d *Deployments) ReplaceReleaseTags(
86	ctx context.Context,
87	releaseName string,
88	tags model.Tags,
89	) error {	4✔
90	err := d.db.ReplaceReleaseTags(ctx, releaseName, tags)	4✔
91	if err != nil {	7✔
92	switch err {	3✔
93	case store.ErrNotFound:	1✔
94	err = ErrReleaseNotFound	1✔
95
96	case model.ErrTooManyTags, model.ErrTooManyUniqueTags:	1✔
97	// pass
98
99	default:	1✔
100	// Rewrite internal errors	1✔
101	log.FromContext(ctx).	1✔
102	Errorf("failed to replace tags in database: %s", err.Error())	1✔
103	err = ErrModelInternal	1✔
104	}
105	}
106	return err	4✔
107	}
108
109	func (d *Deployments) UpdateRelease(
110	ctx context.Context,
111	releaseName string,
112	release model.ReleasePatch,
113	) error {	4✔
114	err := d.db.UpdateRelease(ctx, releaseName, release)	4✔
115	if err != nil {	6✔
116	switch err {	2✔
117	case store.ErrNotFound:	1✔
118	err = ErrReleaseNotFound	1✔
119
120	default:	1✔
121	// Rewrite internal errors	1✔
122	log.FromContext(ctx).	1✔
123	Errorf("failed to update release in the database: %s", err.Error())	1✔
124	err = ErrModelInternal	1✔
125	}
126	}
127	return err	4✔
128	}
129
130	func (d *Deployments) DeleteReleases(
131	ctx context.Context,
132	releaseNames []string,
NEW 133	) ([]string, error) {	×
NEW 134	ids, err := d.db.GetDeploymentIDsByArtifactNames(ctx, releaseNames)	×
NEW 135	if err != nil \|\| len(ids) > 0 {	×
NEW 136	return ids, err	×
NEW 137	}	×
NEW 138	if err := d.db.DeleteImagesByNames(ctx, releaseNames); err != nil {	×
NEW 139	return ids, err	×
NEW 140	}	×
NEW 141	err = d.db.DeleteReleasesByNames(ctx, releaseNames)	×
NEW 142	return ids, err	×
143	}

mendersoftware / deployments / 1069331446

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous