← Back to branch summary

~stephen-stewart/snapweb/hide-installer-for-oem

« back to all changes in this revision

Viewing changes to snappy/converge.go

Using package types to determine the resource name (ID) as frameworks and oem packages installed locally contain no origin/namespace by sergiusens approved by chipaca

Show diffs side-by-side

added added

removed removed

Lines of Context:
snappy/converge.go
29
29
)
30
30
 
31
31
type snapPkg struct {
 
32
        ID            string             `json:"id"`
32
33
        Name          string             `json:"name"`
33
34
        Origin        string             `json:"origin"`
34
35
        Version       string             `json:"version"`
59
60
// for easier stubbing during testing
60
61
var activeSnapByName = snappy.ActiveSnapByName
61
62
 
62
 
func (h *Handler) packagePayload(pkgName string) (snapPkg, error) {
 
63
func (h *Handler) packagePayload(resource string) (snapPkg, error) {
 
64
        var pkgName, namespace string
 
65
        if s := strings.Split(resource, "."); len(s) == 2 {
 
66
                pkgName = s[0]
 
67
                namespace = s[1]
 
68
        } else {
 
69
                pkgName = resource
 
70
        }
 
71
 
63
72
        snapQ := activeSnapByName(pkgName)
64
73
        if snapQ != nil {
65
 
                return h.snapQueryToPayload(snapQ), nil
 
74
                // the second check is for locally installed snaps that lose their origin.
 
75
                if snapQ.Namespace() == namespace || snapQ.Type() != snappy.SnapTypeApp {
 
76
                        return h.snapQueryToPayload(snapQ), nil
 
77
                }
66
78
        }
67
79
 
68
80
        mStore := snappy.NewMetaStoreRepository()
69
 
        found, err := mStore.Details(pkgName)
 
81
        found, err := mStore.Details(resource)
70
82
        if err == nil && len(found) != 0 {
71
83
                return h.snapQueryToPayload(found[0]), nil
72
84
        }
99
111
                if alias := remote.Alias; alias != nil {
100
112
                        remoteSnapQs = append(remoteSnapQs, h.snapQueryToPayload(alias))
101
113
                } else {
102
 
                        /*
103
 
                                TODO reenable once we can filter by type
104
 
                                for _, part := range remote.Parts {
105
 
                                        remoteSnapQs = append(remoteSnapQs, h.snapQueryToPayload(part))
106
 
                                }
107
 
                        */
 
114
                        for _, part := range remote.Parts {
 
115
                                remoteSnapQs = append(remoteSnapQs, h.snapQueryToPayload(part))
 
116
                        }
108
117
                }
109
118
        }
110
119
 
111
120
        return mergeSnaps(installedSnapQs, remoteSnapQs, installedOnly), nil
112
121
}
113
122
 
114
 
func (h *Handler) doRemovePackage(progress *webprogress.WebProgress, pkgName string) {
 
123
func (h *Handler) doRemovePackage(progress *webprogress.WebProgress, ID string) {
 
124
        pkgName := strings.Split(ID, ".")[0]
 
125
 
115
126
        err := snappy.Remove(pkgName, 0, progress)
116
127
        progress.ErrorChan <- err
117
128
        close(progress.ErrorChan)
118
129
}
119
130
 
120
 
func (h *Handler) removePackage(pkgName string) error {
121
 
        progress, err := h.statusTracker.Add(pkgName, webprogress.OperationRemove)
 
131
func (h *Handler) removePackage(ID string) error {
 
132
        progress, err := h.statusTracker.Add(ID, webprogress.OperationRemove)
122
133
        if err != nil {
123
134
                return err
124
135
        }
125
136
 
126
 
        go h.doRemovePackage(progress, pkgName)
 
137
        go h.doRemovePackage(progress, ID)
127
138
 
128
139
        return nil
129
140
}
130
141
 
131
 
func (h *Handler) doInstallPackage(progress *webprogress.WebProgress, pkgName string) {
132
 
        _, err := snappy.Install(pkgName, 0, progress)
 
142
func (h *Handler) doInstallPackage(progress *webprogress.WebProgress, ID string) {
 
143
        _, err := snappy.Install(ID, 0, progress)
133
144
        progress.ErrorChan <- err
134
145
        close(progress.ErrorChan)
135
146
}
136
147
 
137
 
func (h *Handler) installPackage(pkgName string) error {
138
 
        progress, err := h.statusTracker.Add(pkgName, webprogress.OperationInstall)
 
148
func (h *Handler) installPackage(ID string) error {
 
149
        progress, err := h.statusTracker.Add(ID, webprogress.OperationInstall)
139
150
        if err != nil {
140
151
                return err
141
152
        }
142
153
 
143
 
        go h.doInstallPackage(progress, pkgName)
 
154
        go h.doInstallPackage(progress, ID)
144
155
 
145
156
        return nil
146
157
}
178
189
        return snapPkgs
179
190
}
180
191
 
 
192
func isNamespaceless(snap snappy.Part) bool {
 
193
        return snap.Type() == snappy.SnapTypeOem || snap.Type() == snappy.SnapTypeFramework
 
194
}
 
195
 
181
196
func hasPortInformation(snap snappy.Part) bool {
182
197
        return snap.Type() == snappy.SnapTypeApp || snap.Type() == snappy.SnapTypeFramework
183
198
}
192
207
                Type:        snapQ.Type(),
193
208
        }
194
209
 
 
210
        if isNamespaceless(snapQ) {
 
211
                snap.ID = snapQ.Name()
 
212
        } else {
 
213
                snap.ID = snapQ.Name() + "." + snapQ.Namespace()
 
214
        }
 
215
 
195
216
        if hasPortInformation(snapQ) {
196
217
                if snapInstalled, ok := snapQ.(snappy.Services); ok {
197
218
                        port, uri := uiAccess(snapInstalled.Services())
201
222
        }
202
223
 
203
224
        if snapQ.IsInstalled() {
204
 
                iconPath, err := localIconPath(snapQ.Name(), snapQ.Icon())
 
225
                iconPath, err := localIconPath(snap.ID, snapQ.Icon())
205
226
                if err != nil {
206
227
                        log.Println("Icon path for installed package cannot be set", err)
207
228
                        iconPath = ""
214
235
                snap.DownloadSize = snapQ.DownloadSize()
215
236
        }
216
237
 
217
 
        if stat, ok := h.statusTracker.Get(snap.Name); ok {
 
238
        if stat, ok := h.statusTracker.Get(snap.ID); ok {
218
239
                snap.Status = stat.Status
219
240
                if stat.Done() {
220
 
                        defer h.statusTracker.Remove(snap.Name)
 
241
                        defer h.statusTracker.Remove(snap.ID)
221
242
 
222
243
                        if stat.Error != nil {
223
244
                                snap.Message = stat.Error.Error()