1445709825

Committed 09 Sep 2024 11:23AM UTC coverage: 86.917% (-0.3%) from 87.172%

Build # 1445709825

Build Type

Pull #303

gitlab-ci

Committed by

alfrunes

Commit Message

ci: update gitlab runner

Moving to deprecated docker gitlab public runner, to a self-hosted runner

Ticket: SEC-1133
Changelog: none

Signed-off-by: Roberto Giovanardi <roberto.giovanardi@northern.tech>
(cherry picked from commit bb026f77c)

Pull Request Pull Request #303: Cherry-pick MEN-7478 to 1.3.x (3.7.x)

Run Details

42 of 54 new or added lines in 2 files covered. (77.78%)

128 existing lines in 10 files now uncovered.

3169 of 3646 relevant lines covered (86.92%)

9.75 hits per line

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

94.05

/app/app_iot_core.go

// Copyright 2022 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/mendersoftware/go-lib-micro/log"
        "github.com/pkg/errors"

        "github.com/mendersoftware/iot-manager/client/iotcore"
        "github.com/mendersoftware/iot-manager/model"
)

func assertAWSIntegration(integration model.Integration) error {
        if err := integration.Validate(); err != nil {
                return ErrNoCredentials
        } else if integration.Credentials.Type != model.CredentialTypeAWS {
                return ErrNoCredentials
        }
        return nil
}

func (a *app) provisionIoTCoreDevice(
        ctx context.Context,
        deviceID string,
        integration model.Integration,
        device *iotcore.Device,
) error {
        if err := assertAWSIntegration(integration); err != nil {
                return err
        }

        dev, err := a.iotcoreClient.UpsertDevice(ctx,
                *integration.Credentials.AWSCredentials,
                deviceID,
                device,
                *integration.Credentials.AWSCredentials.DevicePolicyName)
        if err != nil {
                return errors.Wrap(err, "failed to update iotcore devices")
        }

        err = a.deployConfiguration(ctx, deviceID, dev)
        return err
}

func (a *app) setDeviceStatusIoTCore(ctx context.Context, deviceID string, status model.Status,
        integration model.Integration) error {
        if err := assertAWSIntegration(integration); err != nil {
                return err
        }
        _, err := a.iotcoreClient.UpsertDevice(
                ctx,
                *integration.Credentials.AWSCredentials,
                deviceID,
                &iotcore.Device{
                        Status: iotcore.NewStatusFromMenderStatus(status),
                },
                *integration.Credentials.AWSCredentials.DevicePolicyName,
        )
        return err

}

func (a *app) deployConfiguration(ctx context.Context, deviceID string, dev *iotcore.Device) error {
        if dev.Certificate != "" && dev.PrivateKey != "" && *dev.Endpoint != "" {
                err := a.wf.ProvisionExternalDevice(ctx, deviceID, map[string]string{
                        confKeyAWSCertificate: dev.Certificate,
                        confKeyAWSPrivateKey:  dev.PrivateKey,
                        confKeyAWSEndpoint:    *dev.Endpoint,
                })
                if err != nil {
                        return errors.Wrap(err, "failed to submit iotcore credentials to deviceconfig")
                }
        }
        return nil
}

func (a *app) decommissionIoTCoreDevice(ctx context.Context, deviceID string,
        integration model.Integration) error {
        if err := assertAWSIntegration(integration); err != nil {
                return err
        }
        err := a.iotcoreClient.DeleteDevice(ctx, *integration.Credentials.AWSCredentials, deviceID)
        if err != nil && err != iotcore.ErrDeviceNotFound {
                return errors.Wrap(err, "failed to delete IoT Core device")
        }
        return nil
}

func (a *app) syncIoTCoreDevices(
        ctx context.Context,
        deviceIDs []string,
        integration model.Integration,
        failEarly bool,
) error {
        if err := assertAWSIntegration(integration); err != nil {
                return err
        }
        l := log.FromContext(ctx)

        // Get device authentication
        devAuths, err := a.devauth.GetDevices(ctx, deviceIDs)
        if err != nil {
                return errors.Wrap(err, "app: failed to lookup device authentication")
        }

        statuses := make(map[string]model.Status, len(deviceIDs))
        for _, auth := range devAuths {
                statuses[auth.ID] = auth.Status
        }

        // Find devices that shouldn't exist
        var (
                i int
                j int = len(deviceIDs)
        )
        for i < j {
                id := deviceIDs[i]
                if _, ok := statuses[id]; !ok {
                        l.Warnf("Device '%s' does not have an auth set: deleting device", id)
                        err := a.DecommissionDevice(ctx, id)
                        if err != nil && !errors.Is(err, ErrDeviceNotFound) {
                                err = errors.Wrap(err, "app: failed to decommission device")
                                if failEarly {
                                        return err
                                }
                                l.Error(err)
                        }
                        // swap(deviceIDs[i], deviceIDs[j])
                        j--
                        tmp := deviceIDs[i]
                        deviceIDs[i] = deviceIDs[j]
                        deviceIDs[j] = tmp
                        deviceIDs = deviceIDs[:j]
                } else {
                        i++
                }
        }
        for _, deviceID := range deviceIDs {
                // Check if device exists in IoT Core
                dev, err := a.iotcoreClient.GetDevice(
                        ctx,
                        *integration.Credentials.AWSCredentials,
                        deviceID,
                )
                status, ok := statuses[deviceID]
                if err == iotcore.ErrDeviceNotFound {
                        if ok {
                                // Device should exist, let's provision the device.
                                err := a.provisionIoTCoreDevice(ctx, deviceID, integration, &iotcore.Device{
                                        Status: iotcore.NewStatusFromMenderStatus(status),
                                })
                                if err != nil {
                                        err = errors.Wrap(err, "failed to provision missing device")
                                        if failEarly {
                                                return err
                                        }
                                        l.Warn(err)
                                }
                        }
                } else if err != nil {
                        err = errors.Wrap(err, "app: failed to get Thing from IoT Core")
                        if failEarly {
                                return err
                        }
                        l.Warn(err)

                } else if dev.Status != iotcore.NewStatusFromMenderStatus(status) {
                        // Upsert device
                        err := a.setDeviceStatusIoTCore(ctx, dev.ID, status, integration)
                        if err != nil {
                                err = errors.Wrap(err, "failed to update device status")
                                if failEarly {
                                        return err
                                }
                                l.Warn(err)
                        }
                }
        }

        return nil
}

func (a *app) GetDeviceStateIoTCore(
        ctx context.Context,
        deviceID string,
        integration *model.Integration,
) (*model.DeviceState, error) {
        if err := assertAWSIntegration(*integration); err != nil {
                return nil, err
        }
        shadow, err := a.iotcoreClient.GetDeviceShadow(
                ctx,
                *integration.Credentials.AWSCredentials,
                deviceID,
        )
        if err != nil {
                if err == iotcore.ErrDeviceNotFound {
                        return nil, nil
                } else {
                        return nil, errors.Wrap(err, "failed to get the device shadow")
                }
        }
        return &shadow.Payload, nil
}

func (a *app) SetDeviceStateIoTCore(
        ctx context.Context,
        deviceID string,
        integration *model.Integration,
        state *model.DeviceState,
) (*model.DeviceState, error) {
        if state == nil {
                return nil, nil
        }
        if err := assertAWSIntegration(*integration); err != nil {
                return nil, err
        }
        shadow, err := a.iotcoreClient.UpdateDeviceShadow(
                ctx,
                *integration.Credentials.AWSCredentials,
                deviceID,
                iotcore.DeviceShadowUpdate{
                        State: iotcore.DesiredState{
                                Desired: state.Desired,
                        },
                },
        )
        if err != nil {
                if err == iotcore.ErrDeviceNotFound {
                        return nil, nil
                }
                return nil, err
        }
        return &shadow.Payload, nil
}

1	// Copyright 2022 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/mendersoftware/go-lib-micro/log"
21	"github.com/pkg/errors"
22
23	"github.com/mendersoftware/iot-manager/client/iotcore"
24	"github.com/mendersoftware/iot-manager/model"
25	)
26
27	func assertAWSIntegration(integration model.Integration) error {	34✔
28	if err := integration.Validate(); err != nil {	39✔
29	return ErrNoCredentials	5✔
30	} else if integration.Credentials.Type != model.CredentialTypeAWS {	34✔
31	return ErrNoCredentials	×
32	}	×
33	return nil	29✔
34	}
35
36	func (a *app) provisionIoTCoreDevice(
37	ctx context.Context,
38	deviceID string,
39	integration model.Integration,
40	device *iotcore.Device,
41	) error {	6✔
42	if err := assertAWSIntegration(integration); err != nil {	7✔
43	return err	1✔
44	}	1✔
45
46	dev, err := a.iotcoreClient.UpsertDevice(ctx,	5✔
47	*integration.Credentials.AWSCredentials,	5✔
48	deviceID,	5✔
49	device,	5✔
50	*integration.Credentials.AWSCredentials.DevicePolicyName)	5✔
51	if err != nil {	7✔
52	return errors.Wrap(err, "failed to update iotcore devices")	2✔
53	}	2✔
54
55	err = a.deployConfiguration(ctx, deviceID, dev)	3✔
56	return err	3✔
57	}
58
59	func (a *app) setDeviceStatusIoTCore(ctx context.Context, deviceID string, status model.Status,
60	integration model.Integration) error {	7✔
61	if err := assertAWSIntegration(integration); err != nil {	8✔
62	return err	1✔
63	}	1✔
64	_, err := a.iotcoreClient.UpsertDevice(	6✔
65	ctx,	6✔
66	*integration.Credentials.AWSCredentials,	6✔
67	deviceID,	6✔
68	&iotcore.Device{	6✔
69	Status: iotcore.NewStatusFromMenderStatus(status),	6✔
70	},	6✔
71	*integration.Credentials.AWSCredentials.DevicePolicyName,	6✔
72	)	6✔
73	return err	6✔
74
75	}
76
77	func (a app) deployConfiguration(ctx context.Context, deviceID string, dev iotcore.Device) error {	3✔
78	if dev.Certificate != "" && dev.PrivateKey != "" && *dev.Endpoint != "" {	6✔
79	err := a.wf.ProvisionExternalDevice(ctx, deviceID, map[string]string{	3✔
80	confKeyAWSCertificate: dev.Certificate,	3✔
81	confKeyAWSPrivateKey: dev.PrivateKey,	3✔
82	confKeyAWSEndpoint: *dev.Endpoint,	3✔
83	})	3✔
84	if err != nil {	4✔
85	return errors.Wrap(err, "failed to submit iotcore credentials to deviceconfig")	1✔
86	}	1✔
87	}
88	return nil	2✔
89	}
90
91	func (a *app) decommissionIoTCoreDevice(ctx context.Context, deviceID string,
92	integration model.Integration) error {	7✔
93	if err := assertAWSIntegration(integration); err != nil {	8✔
94	return err	1✔
95	}	1✔
96	err := a.iotcoreClient.DeleteDevice(ctx, *integration.Credentials.AWSCredentials, deviceID)	6✔
97	if err != nil && err != iotcore.ErrDeviceNotFound {	8✔
98	return errors.Wrap(err, "failed to delete IoT Core device")	2✔
99	}	2✔
100	return nil	4✔
101	}
102
103	func (a *app) syncIoTCoreDevices(
104	ctx context.Context,
105	deviceIDs []string,
106	integration model.Integration,
107	failEarly bool,
108	) error {	7✔
109	if err := assertAWSIntegration(integration); err != nil {	8✔
110	return err	1✔
111	}	1✔
112	l := log.FromContext(ctx)	6✔
113		6✔
114	// Get device authentication	6✔
115	devAuths, err := a.devauth.GetDevices(ctx, deviceIDs)	6✔
116	if err != nil {	7✔
117	return errors.Wrap(err, "app: failed to lookup device authentication")	1✔
118	}	1✔
119
120	statuses := make(map[string]model.Status, len(deviceIDs))	5✔
121	for _, auth := range devAuths {	16✔
122	statuses[auth.ID] = auth.Status	11✔
123	}	11✔
124
125	// Find devices that shouldn't exist
126	var (	5✔
127	i int	5✔
128	j int = len(deviceIDs)	5✔
129	)	5✔
130	for i < j {	19✔
131	id := deviceIDs[i]	14✔
132	if _, ok := statuses[id]; !ok {	17✔
133	l.Warnf("Device '%s' does not have an auth set: deleting device", id)	3✔
134	err := a.DecommissionDevice(ctx, id)	3✔
135	if err != nil && !errors.Is(err, ErrDeviceNotFound) {	4✔
136	err = errors.Wrap(err, "app: failed to decommission device")	1✔
137	if failEarly {	2✔
138	return err	1✔
139	}	1✔
140	l.Error(err)	×
141	}
142	// swap(deviceIDs[i], deviceIDs[j])
143	j--	2✔
144	tmp := deviceIDs[i]	2✔
145	deviceIDs[i] = deviceIDs[j]	2✔
146	deviceIDs[j] = tmp	2✔
147	deviceIDs = deviceIDs[:j]	2✔
148	} else {	11✔
149	i++	11✔
150	}	11✔
151	}
152	for _, deviceID := range deviceIDs {	15✔
153	// Check if device exists in IoT Core	11✔
154	dev, err := a.iotcoreClient.GetDevice(	11✔
155	ctx,	11✔
156	*integration.Credentials.AWSCredentials,	11✔
157	deviceID,	11✔
158	)	11✔
159	status, ok := statuses[deviceID]	11✔
160	if err == iotcore.ErrDeviceNotFound {	13✔
161	if ok {	4✔
162	// Device should exist, let's provision the device.	2✔
163	err := a.provisionIoTCoreDevice(ctx, deviceID, integration, &iotcore.Device{	2✔
164	Status: iotcore.NewStatusFromMenderStatus(status),	2✔
165	})	2✔
166	if err != nil {	3✔
167	err = errors.Wrap(err, "failed to provision missing device")	1✔
168	if failEarly {	2✔
169	return err	1✔
170	}	1✔
171	l.Warn(err)	×
172	}
173	}
174	} else if err != nil {	10✔
175	err = errors.Wrap(err, "app: failed to get Thing from IoT Core")	1✔
176	if failEarly {	2✔
177	return err	1✔
178	}	1✔
UNCOV 179	l.Warn(err)	×
180
181	} else if dev.Status != iotcore.NewStatusFromMenderStatus(status) {	11✔
182	// Upsert device	3✔
183	err := a.setDeviceStatusIoTCore(ctx, dev.ID, status, integration)	3✔
184	if err != nil {	4✔
185	err = errors.Wrap(err, "failed to update device status")	1✔
186	if failEarly {	2✔
187	return err	1✔
188	}	1✔
189	l.Warn(err)	×
190	}
191	}
192	}
193
194	return nil	1✔
195	}
196
197	func (a *app) GetDeviceStateIoTCore(
198	ctx context.Context,
199	deviceID string,
200	integration *model.Integration,
201	) (*model.DeviceState, error) {	4✔
202	if err := assertAWSIntegration(*integration); err != nil {	5✔
203	return nil, err	1✔
204	}	1✔
205	shadow, err := a.iotcoreClient.GetDeviceShadow(	3✔
206	ctx,	3✔
207	*integration.Credentials.AWSCredentials,	3✔
208	deviceID,	3✔
209	)	3✔
210	if err != nil {	5✔
211	if err == iotcore.ErrDeviceNotFound {	3✔
212	return nil, nil	1✔
213	} else {	2✔
214	return nil, errors.Wrap(err, "failed to get the device shadow")	1✔
215	}	1✔
216	}
217	return &shadow.Payload, nil	1✔
218	}
219
220	func (a *app) SetDeviceStateIoTCore(
221	ctx context.Context,
222	deviceID string,
223	integration *model.Integration,
224	state *model.DeviceState,
225	) (*model.DeviceState, error) {	3✔
226	if state == nil {	3✔
227	return nil, nil	×
228	}	×
229	if err := assertAWSIntegration(*integration); err != nil {	3✔
230	return nil, err	×
231	}	×
232	shadow, err := a.iotcoreClient.UpdateDeviceShadow(	3✔
233	ctx,	3✔
234	*integration.Credentials.AWSCredentials,	3✔
235	deviceID,	3✔
236	iotcore.DeviceShadowUpdate{	3✔
237	State: iotcore.DesiredState{	3✔
238	Desired: state.Desired,	3✔
239	},	3✔
240	},	3✔
241	)	3✔
242	if err != nil {	5✔
243	if err == iotcore.ErrDeviceNotFound {	3✔
244	return nil, nil	1✔
245	}	1✔
246	return nil, err	1✔
247	}
248	return &shadow.Payload, nil	1✔
249	}

mendersoftware / iot-manager / 1445709825

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