1622978334

Committed 13 Jan 2025 03:51PM UTC coverage: 72.802% (-3.8%) from 76.608%

Build # 1622978334

Build Type

Pull #300

gitlab-ci

Committed by

alfrunes

Commit Message

fix: Deployment device count should not exceed max devices

Added a condition to skip deployments when the device count reaches max
devices.

Changelog: Title
Ticket: MEN-7847
Signed-off-by: Alf-Rune Siqveland <alf.rune@northern.tech>

Pull Request Pull Request #300: fix: Deployment device count should not exceed max devices

Run Details

4251 of 6164 branches covered (68.96%)

Branch coverage included in aggregate %.

0 of 18 new or added lines in 1 file covered. (0.0%)

2544 existing lines in 83 files now uncovered.

42741 of 58384 relevant lines covered (73.21%)

21.49 hits per line

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

75.9

/backend/services/deployments/app/app_releases.go

// Copyright 2024 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/mender-server/pkg/log"

        "github.com/mendersoftware/mender-server/services/deployments/model"
        "github.com/mendersoftware/mender-server/services/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
}

func (d *Deployments) GetRelease(
        ctx context.Context,
        releaseName string,
) (*model.Release, error) {
        release, err := d.db.GetRelease(ctx, releaseName)
        switch err {
        case nil:
                return release, nil
        case store.ErrNotFound:
                return nil, ErrReleaseNotFound
        default:
                // Rewrite internal errors
                log.FromContext(ctx).
                        Errorf("failed to get release from database: %s", err.Error())
                return nil, ErrModelInternal
        }
}

1	// Copyright 2024 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/mender-server/pkg/log"
23
24	"github.com/mendersoftware/mender-server/services/deployments/model"
25	"github.com/mendersoftware/mender-server/services/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,
UNCOV 52	) error {	×
UNCOV 53	name := ""	×
UNCOV 54	if artifactToRemove != nil {	×
UNCOV 55	name = artifactToRemove.ArtifactMeta.Name	×
UNCOV 56	} else if artifactToAdd != nil {	×
UNCOV 57	name = artifactToAdd.ArtifactMeta.Name	×
UNCOV 58	} else {	×
59	return ErrEmptyArtifact	×
60	}	×
61
UNCOV 62	return d.db.UpdateReleaseArtifacts(ctx, artifactToAdd, artifactToRemove, name)	×
63	}
64
65	func (d *Deployments) ListReleaseTags(ctx context.Context) (model.Tags, error) {	1✔
66	tags, err := d.db.ListReleaseTags(ctx)	1✔
67	if err != nil {	2✔
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	1✔
73	}
74
75	func (d *Deployments) GetReleasesUpdateTypes(ctx context.Context) ([]string, error) {	1✔
76	updateTypes, err := d.db.GetUpdateTypes(ctx)	1✔
77	if err != nil {	2✔
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	1✔
83	}
84
85	func (d *Deployments) ReplaceReleaseTags(
86	ctx context.Context,
87	releaseName string,
88	tags model.Tags,
89	) error {	1✔
90	err := d.db.ReplaceReleaseTags(ctx, releaseName, tags)	1✔
91	if err != nil {	2✔
92	switch err {	1✔
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	1✔
107	}
108
109	func (d *Deployments) UpdateRelease(
110	ctx context.Context,
111	releaseName string,
112	release model.ReleasePatch,
113	) error {	1✔
114	err := d.db.UpdateRelease(ctx, releaseName, release)	1✔
115	if err != nil {	2✔
116	switch err {	1✔
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	1✔
128	}
129
130	func (d *Deployments) DeleteReleases(
131	ctx context.Context,
132	releaseNames []string,
133	) ([]string, error) {	1✔
134	ids, err := d.db.GetDeploymentIDsByArtifactNames(ctx, releaseNames)	1✔
135	if err != nil \|\| len(ids) > 0 {	2✔
136	return ids, err	1✔
137	}	1✔
138	if err := d.db.DeleteImagesByNames(ctx, releaseNames); err != nil {	2✔
139	return ids, err	1✔
140	}	1✔
141	err = d.db.DeleteReleasesByNames(ctx, releaseNames)	1✔
142	return ids, err	1✔
143	}
144
145	func (d *Deployments) GetRelease(
146	ctx context.Context,
147	releaseName string,
148	) (*model.Release, error) {	1✔
149	release, err := d.db.GetRelease(ctx, releaseName)	1✔
150	switch err {	1✔
151	case nil:	1✔
152	return release, nil	1✔
153	case store.ErrNotFound:	1✔
154	return nil, ErrReleaseNotFound	1✔
155	default:	1✔
156	// Rewrite internal errors	1✔
157	log.FromContext(ctx).	1✔
158	Errorf("failed to get release from database: %s", err.Error())	1✔
159	return nil, ErrModelInternal	1✔
160	}
161	}

mendersoftware / mender-server / 1622978334

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