← Back to branch summary

~snappy-dev/snappy/trunk-github

« back to all changes in this revision

Viewing changes to snappy/install.go

  • Committer: Zygmunt Krynicki
  • Date: 2016-02-05 11:26:28 UTC
  • mfrom: (1131)
  • mto: This revision was merged to the branch mainline in revision 1137.
  • Revision ID: git-v1:2f4cd12f5eb1dde16f4e7b59561026d0d125f377
Merge branch 'master' of github.com:ubuntu-core/snappy into cmd-output-testing

Show diffs side-by-side

added added

removed removed

Lines of Context:
snappy/install.go
23
23
        "fmt"
24
24
        "os"
25
25
        "sort"
26
 
        "strings"
27
26
 
28
27
        "github.com/ubuntu-core/snappy/logger"
29
28
        "github.com/ubuntu-core/snappy/progress"
35
34
type InstallFlags uint
36
35
 
37
36
const (
38
 
        // AllowUnauthenticated allows to install a snap even if it can not be authenticated
 
37
        // AllowUnauthenticated allows to install a snap even if it cannot be authenticated
39
38
        AllowUnauthenticated InstallFlags = 1 << iota
40
39
        // InhibitHooks will ensure that the hooks are not run
41
40
        InhibitHooks
45
44
        AllowGadget
46
45
)
47
46
 
48
 
func doUpdate(part Part, flags InstallFlags, meter progress.Meter) error {
49
 
        if _, err := part.Install(meter, flags); err == ErrSideLoaded {
 
47
func installRemote(mStore *SnapUbuntuStoreRepository, remoteSnap *RemoteSnapPart, flags InstallFlags, meter progress.Meter) (string, error) {
 
48
        downloadedSnap, err := mStore.Download(remoteSnap, meter)
 
49
        if err != nil {
 
50
                return "", fmt.Errorf("cannot download %s: %s", remoteSnap.Name(), err)
 
51
        }
 
52
        defer os.Remove(downloadedSnap)
 
53
 
 
54
        if err := remoteSnap.saveStoreManifest(); err != nil {
 
55
                return "", err
 
56
        }
 
57
 
 
58
        localSnap, err := (&Overlord{}).Install(downloadedSnap, remoteSnap.Origin(), flags, meter)
 
59
        if err != nil {
 
60
                return "", err
 
61
        }
 
62
 
 
63
        return localSnap.Name(), nil
 
64
}
 
65
 
 
66
func doUpdate(mStore *SnapUbuntuStoreRepository, part Part, flags InstallFlags, meter progress.Meter) error {
 
67
        _, err := installRemote(mStore, part.(*RemoteSnapPart), flags, meter)
 
68
        if err == ErrSideLoaded {
50
69
                logger.Noticef("Skipping sideloaded package: %s", part.Name())
51
70
                return nil
52
71
        } else if err != nil {
53
72
                return err
54
73
        }
 
74
 
55
75
        if err := GarbageCollect(part.Name(), flags, meter); err != nil {
56
76
                return err
57
77
        }
100
120
                return nil, ErrNotInstalled
101
121
        }
102
122
 
 
123
        mStore := NewUbuntuStoreSnapRepository()
103
124
        // zomg :-(
104
125
        // TODO: query the store for just this package, instead of this
105
 
        updates, err := ListUpdates()
 
126
        updates, err := mStore.Updates()
 
127
        if err != nil {
 
128
                return nil, fmt.Errorf("cannot get updates: %s", err)
 
129
        }
106
130
        upd := FindSnapsByName(QualifiedName(cur[0]), updates)
107
131
        if len(upd) < 1 {
108
 
                return nil, fmt.Errorf("no update found for %s", name)
 
132
                return nil, fmt.Errorf("cannot find any update for %q", name)
109
133
        }
110
134
 
111
 
        if err := doUpdate(upd[0], flags, meter); err != nil {
 
135
        if err := doUpdate(mStore, upd[0], flags, meter); err != nil {
112
136
                return nil, err
113
137
        }
114
138
 
124
148
// if updates where available and an error and nil if any of the updates
125
149
// fail to apply.
126
150
func UpdateAll(flags InstallFlags, meter progress.Meter) ([]Part, error) {
127
 
        updates, err := ListUpdates()
 
151
        mStore := NewUbuntuStoreSnapRepository()
 
152
        updates, err := mStore.Updates()
128
153
        if err != nil {
129
154
                return nil, err
130
155
        }
131
156
 
132
157
        for _, part := range updates {
133
158
                meter.Notify(fmt.Sprintf("Updating %s (%s)", part.Name(), part.Version()))
134
 
                if err := doUpdate(part, flags, meter); err != nil {
 
159
                if err := doUpdate(mStore, part, flags, meter); err != nil {
135
160
                        return nil, err
136
161
                }
137
162
        }
174
199
        }
175
200
 
176
201
        // check repos next
177
 
        mStore := NewMetaStoreRepository()
 
202
        mStore := NewUbuntuStoreSnapRepository()
178
203
        installed, err := NewMetaLocalRepository().Installed()
179
204
        if err != nil {
180
205
                return "", err
181
206
        }
182
207
 
183
 
        origin := ""
184
 
        idx := strings.IndexRune(name, '.')
185
 
        if idx > -1 {
186
 
                origin = name[idx+1:]
187
 
                name = name[:idx]
188
 
        }
189
 
 
190
 
        found, err := mStore.Details(name, origin)
 
208
        part, err := mStore.Snap(name)
191
209
        if err != nil {
192
210
                return "", err
193
211
        }
194
212
 
195
 
        for _, part := range found {
196
 
                cur := FindSnapsByNameAndVersion(QualifiedName(part), part.Version(), installed)
197
 
                if len(cur) != 0 {
198
 
                        return "", ErrAlreadyInstalled
199
 
                }
200
 
                if PackageNameActive(part.Name()) {
201
 
                        return "", ErrPackageNameAlreadyInstalled
202
 
                }
203
 
 
204
 
                // TODO block gadget snaps here once the store supports package types
205
 
 
206
 
                return part.Install(meter, flags)
207
 
        }
208
 
 
209
 
        return "", ErrPackageNotFound
 
213
        cur := FindSnapsByNameAndVersion(QualifiedName(part), part.Version(), installed)
 
214
        if len(cur) != 0 {
 
215
                return "", ErrAlreadyInstalled
 
216
        }
 
217
        if PackageNameActive(part.Name()) {
 
218
                return "", ErrPackageNameAlreadyInstalled
 
219
        }
 
220
 
 
221
        return installRemote(mStore, part, flags, meter)
210
222
}
211
223
 
212
224
// GarbageCollect removes all versions two older than the current active