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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
// +build amd64,!windows arm64,!windows
package machine
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
url2 "net/url"
"os"
"path/filepath"
"runtime"
"strings"
"github.com/coreos/stream-metadata-go/fedoracoreos"
"github.com/coreos/stream-metadata-go/stream"
"github.com/pkg/errors"
digest "github.com/opencontainers/go-digest"
"github.com/sirupsen/logrus"
)
// These should eventually be moved into machine/qemu as
// they are specific to running qemu
var (
artifact string = "qemu"
Format string = "qcow2.xz"
)
type FcosDownload struct {
Download
}
func NewFcosDownloader(vmType, vmName, imageStream string) (DistributionDownload, error) {
info, err := getFCOSDownload(imageStream)
if err != nil {
return nil, err
}
urlSplit := strings.Split(info.Location, "/")
imageName := urlSplit[len(urlSplit)-1]
url, err := url2.Parse(info.Location)
if err != nil {
return nil, err
}
dataDir, err := GetDataDir(vmType)
if err != nil {
return nil, err
}
fcd := FcosDownload{
Download: Download{
Arch: getFcosArch(),
Artifact: artifact,
Format: Format,
ImageName: imageName,
LocalPath: filepath.Join(dataDir, imageName),
Sha256sum: info.Sha256Sum,
URL: url,
VMName: vmName,
},
}
fcd.Download.LocalUncompressedFile = fcd.getLocalUncompressedName()
return fcd, nil
}
func (f FcosDownload) getLocalUncompressedName() string {
uncompressedFilename := filepath.Join(filepath.Dir(f.LocalPath), f.VMName+"_"+f.ImageName)
return strings.TrimSuffix(uncompressedFilename, ".xz")
}
func (f FcosDownload) DownloadImage() error {
// check if the latest image is already present
ok, err := UpdateAvailable(&f.Download)
if err != nil {
return err
}
if !ok {
if err := DownloadVMImage(f.URL, f.LocalPath); err != nil {
return err
}
}
return Decompress(f.LocalPath, f.getLocalUncompressedName())
}
func (f FcosDownload) Get() *Download {
return &f.Download
}
type fcosDownloadInfo struct {
CompressionType string
Location string
Release string
Sha256Sum string
}
func UpdateAvailable(d *Download) (bool, error) {
// check the sha of the local image if it exists
// get the sha of the remote image
// == dont bother to pull
if _, err := os.Stat(d.LocalPath); os.IsNotExist(err) {
return false, nil
}
fd, err := os.Open(d.LocalPath)
if err != nil {
return false, err
}
defer func() {
if err := fd.Close(); err != nil {
logrus.Error(err)
}
}()
sum, err := digest.SHA256.FromReader(fd)
if err != nil {
return false, err
}
return sum.Encoded() == d.Sha256sum, nil
}
func getFcosArch() string {
var arch string
// TODO fill in more architectures
switch runtime.GOARCH {
case "arm64":
arch = "aarch64"
default:
arch = "x86_64"
}
return arch
}
// This should get Exported and stay put as it will apply to all fcos downloads
// getFCOS parses fedoraCoreOS's stream and returns the image download URL and the release version
func getFCOSDownload(imageStream string) (*fcosDownloadInfo, error) {
var (
fcosstable stream.Stream
streamType string
)
switch imageStream {
case "testing", "":
streamType = fedoracoreos.StreamNext
case "stable":
streamType = fedoracoreos.StreamStable
default:
return nil, errors.Errorf("invalid stream %s: valid streams are `testing` and `stable`", imageStream)
}
streamurl := fedoracoreos.GetStreamURL(streamType)
resp, err := http.Get(streamurl.String())
if err != nil {
return nil, err
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
defer func() {
if err := resp.Body.Close(); err != nil {
logrus.Error(err)
}
}()
if err := json.Unmarshal(body, &fcosstable); err != nil {
return nil, err
}
arch, ok := fcosstable.Architectures[getFcosArch()]
if !ok {
return nil, fmt.Errorf("unable to pull VM image: no targetArch in stream")
}
artifacts := arch.Artifacts
if artifacts == nil {
return nil, fmt.Errorf("unable to pull VM image: no artifact in stream")
}
qemu, ok := artifacts[artifact]
if !ok {
return nil, fmt.Errorf("unable to pull VM image: no qemu artifact in stream")
}
formats := qemu.Formats
if formats == nil {
return nil, fmt.Errorf("unable to pull VM image: no formats in stream")
}
qcow, ok := formats[Format]
if !ok {
return nil, fmt.Errorf("unable to pull VM image: no qcow2.xz format in stream")
}
disk := qcow.Disk
if disk == nil {
return nil, fmt.Errorf("unable to pull VM image: no disk in stream")
}
return &fcosDownloadInfo{
Location: disk.Location,
Release: qemu.Release,
Sha256Sum: disk.Sha256,
CompressionType: "xz",
}, nil
}
|
