1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
// Copyright 2017 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 artifact
import (
"bytes"
"encoding/json"
"io"
"github.com/pkg/errors"
)
// WriteValidator is the interface that wraps the io.Writer interface and
// Validate method.
type WriteValidator interface {
io.Writer
Validate() error
}
// ErrValidatingData is an error returned by Validate() in case of
// invalid data.
var ErrValidatingData = errors.New("error validating data")
// Info contains the information about the format and the version
// of artifact archive.
type Info struct {
Format string `json:"format"`
Version int `json:"version"`
}
// Validate performs sanity checks on artifact info.
func (i Info) Validate() error {
if len(i.Format) == 0 || i.Version == 0 {
return ErrValidatingData
}
return nil
}
func decode(p []byte, data WriteValidator) error {
if len(p) == 0 {
return nil
}
dec := json.NewDecoder(bytes.NewReader(p))
for {
if err := dec.Decode(data); err != io.EOF {
break
} else if err != nil {
return err
}
}
return nil
}
func (i *Info) Write(p []byte) (n int, err error) {
if err := decode(p, i); err != nil {
return 0, err
}
return len(p), nil
}
// UpdateType provides information about the type of update.
// At the moment we are supporting only "rootfs-image" type.
type UpdateType struct {
Type string `json:"type"`
}
// HeaderInfo contains information of numner and type of update files
// archived in Mender metadata archive.
type HeaderInfo struct {
Updates []UpdateType `json:"updates"`
CompatibleDevices []string `json:"device_types_compatible"`
ArtifactName string `json:"artifact_name"`
}
// Validate checks if header-info structure is correct.
func (hi HeaderInfo) Validate() error {
if len(hi.Updates) == 0 || len(hi.CompatibleDevices) == 0 || len(hi.ArtifactName) == 0 {
return ErrValidatingData
}
for _, update := range hi.Updates {
if update == (UpdateType{}) {
return ErrValidatingData
}
}
return nil
}
func (hi *HeaderInfo) Write(p []byte) (n int, err error) {
if err := decode(p, hi); err != nil {
return 0, err
}
return len(p), nil
}
// TypeInfo provides information of type of individual updates
// archived in artifacts archive.
type TypeInfo struct {
Type string `json:"type"`
}
// Validate validates corectness of TypeInfo.
func (ti TypeInfo) Validate() error {
if len(ti.Type) == 0 {
return ErrValidatingData
}
return nil
}
func (ti *TypeInfo) Write(p []byte) (n int, err error) {
if err := decode(p, ti); err != nil {
return 0, err
}
return len(p), nil
}
// Metadata contains artifacts metadata information. The exact metadata fields
// are user-defined and are not specified. The only requirement is that those
// must be stored in a for of JSON.
// The fields which must exist are update-type dependent. In case of
// `rootfs-update` image type, there are no additional fields required.
type Metadata map[string]interface{}
// Validate check corecness of artifacts metadata. Since the exact format is
// not specified validation always succeeds.
func (m Metadata) Validate() error {
return nil
}
func (m *Metadata) Write(p []byte) (n int, err error) {
if err := decode(p, m); err != nil {
return 0, err
}
return len(p), nil
}
func (m *Metadata) Map() map[string]interface{} {
return map[string]interface{}(*m)
}
// Files represents the list of file names that make up the payload for given
// update.
type Files struct {
FileList []string `json:"files"`
}
// Validate checks format of Files.
func (f Files) Validate() error {
if len(f.FileList) == 0 {
return ErrValidatingData
}
for _, f := range f.FileList {
if len(f) == 0 {
return ErrValidatingData
}
}
return nil
}
func (f *Files) Write(p []byte) (n int, err error) {
if err := decode(p, f); err != nil {
return 0, err
}
return len(p), nil
}
|
