1495380963

Committed 14 Oct 2024 03:35PM UTC coverage: 70.373% (-2.5%) from 72.904%

Build # 1495380963

Build Type

Pull #101

gitlab-ci

Committed by

mineralsfree

Commit Message

feat: tenant list added

Ticket: MEN-7568
Changelog: None

Signed-off-by: Mikita Pilinka <mikita.pilinka@northern.tech>

Pull Request Pull Request #101: feat: tenant list added

Run Details

4406 of 6391 branches covered (68.94%)

Branch coverage included in aggregate %.

88 of 183 new or added lines in 10 files covered. (48.09%)

2623 existing lines in 65 files now uncovered.

36673 of 51982 relevant lines covered (70.55%)

31.07 hits per line

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

75.0

/backend/services/iot-manager/client/iothub/client.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 iothub

import (
        "bytes"
        "context"
        "encoding/json"
        "fmt"
        "io"
        "net/http"
        "net/url"
        "strconv"
        "strings"
        "time"

        common "github.com/mendersoftware/mender-server/services/iot-manager/client"
        "github.com/mendersoftware/mender-server/services/iot-manager/model"

        "github.com/pkg/errors"
)

var (
        ErrNoCredentials = errors.New("no connection string configured for tenant")
)

const (
        uriTwin      = "/twins"
        uriDevices   = "/devices"
        uriQueryTwin = uriDevices + "/query"

        hdrKeyCount = "X-Ms-Max-Item-Count"

        // https://docs.microsoft.com/en-us/rest/api/iothub/service/devices
        APIVersion = "2021-04-12"
)

func uriDevice(id string) string {
        return uriDevices + "/" + url.QueryEscape(id)
}

const (
        defaultTTL = time.Minute
)

const (
        hdrKeyAuthorization = "Authorization"
)

//nolint:lll
//go:generate ../../../../utils/mockgen.sh
type Client interface {
        GetDeviceTwins(ctx context.Context, cs *model.ConnectionString, deviceIDs []string) ([]DeviceTwin, error)
        GetDeviceTwin(ctx context.Context, cs *model.ConnectionString, id string) (*DeviceTwin, error)
        UpdateDeviceTwin(ctx context.Context, cs *model.ConnectionString, id string, r *DeviceTwinUpdate) error

        GetDevice(ctx context.Context, cs *model.ConnectionString, id string) (*Device, error)
        // UpsertDevice create or update a device with the given ID. If a device
        // is created, the IoT Hub will generate a new 256-bit primary and
        // secondary key used to construct the device connection string:
        // primaryCS := &model.ConnectionString{
        //         HostName: cs.HostName,
        //         DeviceID: Device.DeviceID,
        //         Key:      Device.Auth.SymmetricKey.Primary,
        // }.String()
        // secondary := &model.ConnectionString{
        //         HostName: cs.HostName,
        //         DeviceID: Device.DeviceID,
        //         Key:      Device.Auth.SymmetricKey.Secondary,
        // }.String()
        UpsertDevice(ctx context.Context, cs *model.ConnectionString, id string, deviceUpdate ...*Device) (*Device, error)
        DeleteDevice(ctx context.Context, cs *model.ConnectionString, id string) error
}

type client struct {
        *http.Client
}

type Options struct {
        Client *http.Client
}

func NewOptions(opts ...*Options) *Options {
        opt := new(Options)
        for _, o := range opts {
                if o == nil {
                        continue
                }
                if o.Client != nil {
                        opt.Client = o.Client
                }
        }
        return opt
}

func (opt *Options) SetClient(client *http.Client) *Options {
        opt.Client = client
        return opt
}

func NewClient(options ...*Options) Client {
        opts := NewOptions(options...)
        if opts.Client == nil {
                opts.Client = new(http.Client)
        }
        // Make sure that we never follow redirects
        opts.Client.CheckRedirect = func(*http.Request, []*http.Request) error {
                return http.ErrUseLastResponse
        }
        return &client{
                Client: opts.Client,
        }
}

func (c *client) NewRequestWithContext(
        ctx context.Context,
        cs *model.ConnectionString,
        method, urlPath string,
        body io.Reader,
) (*http.Request, error) {
        if cs == nil {
                return nil, ErrNoCredentials
        } else if err := cs.Validate(); err != nil {
                return nil, errors.Wrap(err, "invalid connection string")
        }
        hostname := cs.HostName
        if cs.GatewayHostName != "" {
                hostname = cs.GatewayHostName
        }
        uri := "https://" + hostname + "/" +
                strings.TrimPrefix(urlPath, "/")
        if idx := strings.IndexRune(uri, '?'); idx < 0 {
                uri += "?"
        }
        uri += "api-version=" + APIVersion
        req, err := http.NewRequestWithContext(ctx, method, uri, body)
        if err != nil {
                return req, err
        }
        if body != nil {
                req.Header.Set(common.HdrKeyContentType, "application/json")
        }
        // Ensure that we set the correct Host header (in case GatewayHostName is set)
        req.Host = cs.HostName

        var expireAt time.Time
        if dl, ok := ctx.Deadline(); ok {
                expireAt = dl
        } else {
                expireAt = time.Now().Add(defaultTTL)
        }
        req.Header.Set(hdrKeyAuthorization, cs.Authorization(expireAt))

        return req, err
}

// GET /devices/{id}
func (c *client) GetDevice(
        ctx context.Context,
        cs *model.ConnectionString,
        id string,
) (*Device, error) {
        var dev = new(Device)
        req, err := c.NewRequestWithContext(
                ctx,
                cs,
                http.MethodGet,
                uriDevice(id),
                nil,
        )
        if err != nil {
                return nil, errors.Wrap(err, "iothub: failed to prepare request")
        }
        rsp, err := c.Do(req)
        if err != nil {
                return nil, errors.Wrap(err, "iothub: failed to execute request")
        }
        defer rsp.Body.Close()
        if rsp.StatusCode >= 400 {
                return nil, common.NewHTTPError(rsp.StatusCode)
        }
        dec := json.NewDecoder(rsp.Body)
        if err = dec.Decode(dev); err != nil {
                return nil, errors.Wrap(err, "iothub: failed to decode device")
        }
        return dev, nil
}

func (c *client) UpsertDevice(ctx context.Context,
        cs *model.ConnectionString,
        deviceID string,
        deviceUpdate ...*Device,
) (*Device, error) {
        dev := mergeDevices(deviceUpdate...)
        dev.DeviceID = deviceID
        etag := dev.ETag
        dev.ETag = ""
        b, _ := json.Marshal(*dev)
        req, err := c.NewRequestWithContext(
                ctx,
                cs,
                http.MethodPut,
                uriDevice(deviceID),
                bytes.NewReader(b),
        )
        if err != nil {
                return nil, errors.Wrap(err, "iothub: failed to prepare request")
        }
        if etag != "" {
                req.Header.Set("If-Match", `"`+etag+`"`)
        }
        rsp, err := c.Do(req)
        if err != nil {
                return nil, errors.Wrap(err, "iothub: failed to execute request")
        }
        defer rsp.Body.Close()
        if rsp.StatusCode >= 400 {
                return nil, common.NewHTTPError(rsp.StatusCode)
        }
        dec := json.NewDecoder(rsp.Body)
        if err = dec.Decode(dev); err != nil {
                return nil, errors.Wrap(err, "iothub: failed to decode updated device")
        }
        return dev, nil
}

func (c *client) DeleteDevice(ctx context.Context, cs *model.ConnectionString, id string) error {
        req, err := c.NewRequestWithContext(ctx,
                cs,
                http.MethodDelete,
                uriDevice(id),
                nil,
        )
        if err != nil {
                return errors.Wrap(err, "iothub: failed to prepare request")
        }
        req.Header.Set("If-Match", "*")
        rsp, err := c.Do(req)
        if err != nil {
                return errors.Wrap(err, "iothub: failed to execute request")
        }
        defer rsp.Body.Close()
        if rsp.StatusCode >= 400 {
                return common.NewHTTPError(rsp.StatusCode)
        }
        return nil
}

func (c *client) GetDeviceTwins(
        ctx context.Context, cs *model.ConnectionString, deviceIDs []string,
) ([]DeviceTwin, error) {
        if len(deviceIDs) == 0 {
                return []DeviceTwin{}, nil
        }
        SQLQuery := fmt.Sprintf(
                `{"query":"SELECT * FROM devices WHERE devices.deviceid IN ['%s']"}`,
                strings.Join(deviceIDs, "','"),
        )
        q := bytes.NewReader([]byte(SQLQuery))
        req, err := c.NewRequestWithContext(ctx, cs, http.MethodPost, uriQueryTwin, q)
        if err != nil {
                return nil, errors.Wrap(err, "iothub: failed to prepare request")
        }
        req.Header.Set(hdrKeyCount, strconv.Itoa(len(deviceIDs)))

        rsp, err := c.Do(req)
        if err != nil {
                return nil, errors.Wrap(err, "iothub: failed to fetch device twins")
        }
        defer rsp.Body.Close()
        if rsp.StatusCode >= 400 {
                return nil, common.NewHTTPError(rsp.StatusCode)
        }
        twins := make([]DeviceTwin, 0, len(deviceIDs))
        dec := json.NewDecoder(rsp.Body)
        if err = dec.Decode(&twins); err != nil {
                return nil, errors.Wrap(err, "iothub: failed to decode API response")
        }
        return twins, nil
}

func (c *client) GetDeviceTwin(
        ctx context.Context,
        cs *model.ConnectionString,
        id string,
) (*DeviceTwin, error) {
        uri := uriTwin + "/" + id
        req, err := c.NewRequestWithContext(ctx, cs, http.MethodGet, uri, nil)
        if err != nil {
                return nil, errors.Wrap(err, "iothub: failed to prepare request")
        }

        rsp, err := c.Do(req)
        if err != nil {
                return nil, errors.Wrap(err, "iothub: failed to fetch device twin")
        }
        defer rsp.Body.Close()
        if rsp.StatusCode >= 400 {
                return nil, common.NewHTTPError(rsp.StatusCode)
        }
        twin := new(DeviceTwin)
        dec := json.NewDecoder(rsp.Body)
        if err = dec.Decode(twin); err != nil {
                return nil, errors.Wrap(err, "iothub: failed to decode API response")
        }
        return twin, nil
}

func (c *client) UpdateDeviceTwin(
        ctx context.Context,
        cs *model.ConnectionString,
        id string,
        r *DeviceTwinUpdate,
) error {
        method := http.MethodPatch
        if r.Replace {
                method = http.MethodPut
        }

        b, _ := json.Marshal(r)

        req, err := c.NewRequestWithContext(ctx, cs, method, uriTwin+"/"+id, bytes.NewReader(b))
        if err != nil {
                return errors.Wrap(err, "iothub: failed to prepare request")
        }
        etag := r.ETag
        if etag != "" {
                req.Header.Set("If-Match", `"`+etag+`"`)
        }
        rsp, err := c.Do(req)
        if err != nil {
                return errors.Wrap(err, "iothub: failed to submit device twin update")
        }
        defer rsp.Body.Close()

        if rsp.StatusCode >= 400 {
                return common.NewHTTPError(rsp.StatusCode)
        }
        return 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 iothub
16
17	import (
18	"bytes"
19	"context"
20	"encoding/json"
21	"fmt"
22	"io"
23	"net/http"
24	"net/url"
25	"strconv"
26	"strings"
27	"time"
28
29	common "github.com/mendersoftware/mender-server/services/iot-manager/client"
30	"github.com/mendersoftware/mender-server/services/iot-manager/model"
31
32	"github.com/pkg/errors"
33	)
34
35	var (
36	ErrNoCredentials = errors.New("no connection string configured for tenant")
37	)
38
39	const (
40	uriTwin = "/twins"
41	uriDevices = "/devices"
42	uriQueryTwin = uriDevices + "/query"
43
44	hdrKeyCount = "X-Ms-Max-Item-Count"
45
46	// https://docs.microsoft.com/en-us/rest/api/iothub/service/devices
47	APIVersion = "2021-04-12"
48	)
49
50	func uriDevice(id string) string {	1✔
51	return uriDevices + "/" + url.QueryEscape(id)	1✔
52	}	1✔
53
54	const (
55	defaultTTL = time.Minute
56	)
57
58	const (
59	hdrKeyAuthorization = "Authorization"
60	)
61
62	//nolint:lll
63	//go:generate ../../../../utils/mockgen.sh
64	type Client interface {
65	GetDeviceTwins(ctx context.Context, cs *model.ConnectionString, deviceIDs []string) ([]DeviceTwin, error)
66	GetDeviceTwin(ctx context.Context, cs model.ConnectionString, id string) (DeviceTwin, error)
67	UpdateDeviceTwin(ctx context.Context, cs model.ConnectionString, id string, r DeviceTwinUpdate) error
68
69	GetDevice(ctx context.Context, cs model.ConnectionString, id string) (Device, error)
70	// UpsertDevice create or update a device with the given ID. If a device
71	// is created, the IoT Hub will generate a new 256-bit primary and
72	// secondary key used to construct the device connection string:
73	// primaryCS := &model.ConnectionString{
74	// HostName: cs.HostName,
75	// DeviceID: Device.DeviceID,
76	// Key: Device.Auth.SymmetricKey.Primary,
77	// }.String()
78	// secondary := &model.ConnectionString{
79	// HostName: cs.HostName,
80	// DeviceID: Device.DeviceID,
81	// Key: Device.Auth.SymmetricKey.Secondary,
82	// }.String()
83	UpsertDevice(ctx context.Context, cs model.ConnectionString, id string, deviceUpdate ...Device) (*Device, error)
84	DeleteDevice(ctx context.Context, cs *model.ConnectionString, id string) error
85	}
86
87	type client struct {
88	*http.Client
89	}
90
91	type Options struct {
92	Client *http.Client
93	}
94
95	func NewOptions(opts ...Options) Options {	1✔
96	opt := new(Options)	1✔
97	for _, o := range opts {	2✔
98	if o == nil {	2✔
99	continue	1✔
100	}
101	if o.Client != nil {	2✔
102	opt.Client = o.Client	1✔
103	}	1✔
104	}
105	return opt	1✔
106	}
107
108	func (opt Options) SetClient(client http.Client) *Options {	1✔
109	opt.Client = client	1✔
110	return opt	1✔
111	}	1✔
112
113	func NewClient(options ...*Options) Client {	1✔
114	opts := NewOptions(options...)	1✔
115	if opts.Client == nil {	1✔
116	opts.Client = new(http.Client)	×
117	}	×
118	// Make sure that we never follow redirects
119	opts.Client.CheckRedirect = func(http.Request, []http.Request) error {	1✔
120	return http.ErrUseLastResponse	×
121	}	×
122	return &client{	1✔
123	Client: opts.Client,	1✔
124	}	1✔
125	}
126
127	func (c *client) NewRequestWithContext(
128	ctx context.Context,
129	cs *model.ConnectionString,
130	method, urlPath string,
131	body io.Reader,
132	) (*http.Request, error) {	1✔
133	if cs == nil {	1✔
134	return nil, ErrNoCredentials	×
135	} else if err := cs.Validate(); err != nil {	2✔
136	return nil, errors.Wrap(err, "invalid connection string")	1✔
137	}	1✔
138	hostname := cs.HostName	1✔
139	if cs.GatewayHostName != "" {	1✔
140	hostname = cs.GatewayHostName	×
141	}	×
142	uri := "https://" + hostname + "/" +	1✔
143	strings.TrimPrefix(urlPath, "/")	1✔
144	if idx := strings.IndexRune(uri, '?'); idx < 0 {	2✔
145	uri += "?"	1✔
146	}	1✔
147	uri += "api-version=" + APIVersion	1✔
148	req, err := http.NewRequestWithContext(ctx, method, uri, body)	1✔
149	if err != nil {	2✔
150	return req, err	1✔
151	}	1✔
152	if body != nil {	2✔
153	req.Header.Set(common.HdrKeyContentType, "application/json")	1✔
154	}	1✔
155	// Ensure that we set the correct Host header (in case GatewayHostName is set)
156	req.Host = cs.HostName	1✔
157		1✔
158	var expireAt time.Time	1✔
159	if dl, ok := ctx.Deadline(); ok {	1✔
160	expireAt = dl	×
161	} else {	1✔
162	expireAt = time.Now().Add(defaultTTL)	1✔
163	}	1✔
164	req.Header.Set(hdrKeyAuthorization, cs.Authorization(expireAt))	1✔
165		1✔
166	return req, err	1✔
167	}
168
169	// GET /devices/{id}
170	func (c *client) GetDevice(
171	ctx context.Context,
172	cs *model.ConnectionString,
173	id string,
174	) (*Device, error) {	1✔
175	var dev = new(Device)	1✔
176	req, err := c.NewRequestWithContext(	1✔
177	ctx,	1✔
178	cs,	1✔
179	http.MethodGet,	1✔
180	uriDevice(id),	1✔
181	nil,	1✔
182	)	1✔
183	if err != nil {	2✔
184	return nil, errors.Wrap(err, "iothub: failed to prepare request")	1✔
185	}	1✔
186	rsp, err := c.Do(req)	1✔
187	if err != nil {	2✔
188	return nil, errors.Wrap(err, "iothub: failed to execute request")	1✔
189	}	1✔
190	defer rsp.Body.Close()	1✔
191	if rsp.StatusCode >= 400 {	2✔
192	return nil, common.NewHTTPError(rsp.StatusCode)	1✔
193	}	1✔
194	dec := json.NewDecoder(rsp.Body)	1✔
195	if err = dec.Decode(dev); err != nil {	2✔
196	return nil, errors.Wrap(err, "iothub: failed to decode device")	1✔
197	}	1✔
198	return dev, nil	1✔
199	}
200
201	func (c *client) UpsertDevice(ctx context.Context,
202	cs *model.ConnectionString,
203	deviceID string,
204	deviceUpdate ...*Device,
205	) (*Device, error) {	1✔
206	dev := mergeDevices(deviceUpdate...)	1✔
207	dev.DeviceID = deviceID	1✔
208	etag := dev.ETag	1✔
209	dev.ETag = ""	1✔
210	b, _ := json.Marshal(*dev)	1✔
211	req, err := c.NewRequestWithContext(	1✔
212	ctx,	1✔
213	cs,	1✔
214	http.MethodPut,	1✔
215	uriDevice(deviceID),	1✔
216	bytes.NewReader(b),	1✔
217	)	1✔
218	if err != nil {	2✔
219	return nil, errors.Wrap(err, "iothub: failed to prepare request")	1✔
220	}	1✔
221	if etag != "" {	2✔
222	req.Header.Set("If-Match", `"`+etag+`"`)	1✔
223	}	1✔
224	rsp, err := c.Do(req)	1✔
225	if err != nil {	2✔
226	return nil, errors.Wrap(err, "iothub: failed to execute request")	1✔
227	}	1✔
228	defer rsp.Body.Close()	1✔
229	if rsp.StatusCode >= 400 {	2✔
230	return nil, common.NewHTTPError(rsp.StatusCode)	1✔
231	}	1✔
232	dec := json.NewDecoder(rsp.Body)	1✔
233	if err = dec.Decode(dev); err != nil {	2✔
234	return nil, errors.Wrap(err, "iothub: failed to decode updated device")	1✔
235	}	1✔
236	return dev, nil	1✔
237	}
238
239	func (c client) DeleteDevice(ctx context.Context, cs model.ConnectionString, id string) error {	1✔
240	req, err := c.NewRequestWithContext(ctx,	1✔
241	cs,	1✔
242	http.MethodDelete,	1✔
243	uriDevice(id),	1✔
244	nil,	1✔
245	)	1✔
246	if err != nil {	2✔
247	return errors.Wrap(err, "iothub: failed to prepare request")	1✔
248	}	1✔
249	req.Header.Set("If-Match", "*")	1✔
250	rsp, err := c.Do(req)	1✔
251	if err != nil {	2✔
252	return errors.Wrap(err, "iothub: failed to execute request")	1✔
253	}	1✔
254	defer rsp.Body.Close()	1✔
255	if rsp.StatusCode >= 400 {	2✔
256	return common.NewHTTPError(rsp.StatusCode)	1✔
257	}	1✔
258	return nil	1✔
259	}
260
261	func (c *client) GetDeviceTwins(
262	ctx context.Context, cs *model.ConnectionString, deviceIDs []string,
263	) ([]DeviceTwin, error) {	1✔
264	if len(deviceIDs) == 0 {	2✔
265	return []DeviceTwin{}, nil	1✔
266	}	1✔
267	SQLQuery := fmt.Sprintf(	1✔
268	`{"query":"SELECT * FROM devices WHERE devices.deviceid IN ['%s']"}`,	1✔
269	strings.Join(deviceIDs, "','"),	1✔
270	)	1✔
271	q := bytes.NewReader([]byte(SQLQuery))	1✔
272	req, err := c.NewRequestWithContext(ctx, cs, http.MethodPost, uriQueryTwin, q)	1✔
273	if err != nil {	2✔
274	return nil, errors.Wrap(err, "iothub: failed to prepare request")	1✔
275	}	1✔
276	req.Header.Set(hdrKeyCount, strconv.Itoa(len(deviceIDs)))	1✔
277		1✔
278	rsp, err := c.Do(req)	1✔
279	if err != nil {	2✔
280	return nil, errors.Wrap(err, "iothub: failed to fetch device twins")	1✔
281	}	1✔
282	defer rsp.Body.Close()	1✔
283	if rsp.StatusCode >= 400 {	2✔
284	return nil, common.NewHTTPError(rsp.StatusCode)	1✔
285	}	1✔
286	twins := make([]DeviceTwin, 0, len(deviceIDs))	1✔
287	dec := json.NewDecoder(rsp.Body)	1✔
288	if err = dec.Decode(&twins); err != nil {	2✔
289	return nil, errors.Wrap(err, "iothub: failed to decode API response")	1✔
290	}	1✔
291	return twins, nil	1✔
292	}
293
294	func (c *client) GetDeviceTwin(
295	ctx context.Context,
296	cs *model.ConnectionString,
297	id string,
298	) (*DeviceTwin, error) {	×
299	uri := uriTwin + "/" + id	×
300	req, err := c.NewRequestWithContext(ctx, cs, http.MethodGet, uri, nil)	×
301	if err != nil {	×
302	return nil, errors.Wrap(err, "iothub: failed to prepare request")	×
303	}	×
304
305	rsp, err := c.Do(req)	×
306	if err != nil {	×
307	return nil, errors.Wrap(err, "iothub: failed to fetch device twin")	×
308	}	×
309	defer rsp.Body.Close()	×
310	if rsp.StatusCode >= 400 {	×
311	return nil, common.NewHTTPError(rsp.StatusCode)	×
312	}	×
313	twin := new(DeviceTwin)	×
314	dec := json.NewDecoder(rsp.Body)	×
315	if err = dec.Decode(twin); err != nil {	×
316	return nil, errors.Wrap(err, "iothub: failed to decode API response")	×
317	}	×
318	return twin, nil	×
319	}
320
321	func (c *client) UpdateDeviceTwin(
322	ctx context.Context,
323	cs *model.ConnectionString,
324	id string,
325	r *DeviceTwinUpdate,
UNCOV 326	) error {	×
UNCOV 327	method := http.MethodPatch	×
UNCOV 328	if r.Replace {	×
329	method = http.MethodPut	×
330	}	×
331
UNCOV 332	b, _ := json.Marshal(r)	×
UNCOV 333		×
UNCOV 334	req, err := c.NewRequestWithContext(ctx, cs, method, uriTwin+"/"+id, bytes.NewReader(b))	×
UNCOV 335	if err != nil {	×
336	return errors.Wrap(err, "iothub: failed to prepare request")	×
337	}	×
UNCOV 338	etag := r.ETag	×
UNCOV 339	if etag != "" {	×
340	req.Header.Set("If-Match", `"`+etag+`"`)	×
341	}	×
UNCOV 342	rsp, err := c.Do(req)	×
UNCOV 343	if err != nil {	×
344	return errors.Wrap(err, "iothub: failed to submit device twin update")	×
345	}	×
UNCOV 346	defer rsp.Body.Close()	×
UNCOV 347		×
UNCOV 348	if rsp.StatusCode >= 400 {	×
349	return common.NewHTTPError(rsp.StatusCode)	×
350	}	×
UNCOV 351	return nil	×
352	}

mendersoftware / mender-server / 1495380963

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