func (s *assertMgrSuite) SetUpTest(c *C) {
dirs.SetRootDir(c.MkDir())
rootPrivKey, _ := assertstest.GenerateKey(1024)
storePrivKey, _ := assertstest.GenerateKey(752)
s.storeSigning = assertstest.NewStoreStack("can0nical", rootPrivKey, storePrivKey)
s.restore = sysdb.InjectTrusted(s.storeSigning.Trusted)
dev1PrivKey, _ := assertstest.GenerateKey(752)
s.dev1Acct = assertstest.NewAccount(s.storeSigning, "developer1", nil, "")
err := s.storeSigning.Add(s.dev1Acct)
c.Assert(err, IsNil)
// developer signing
dev1AcctKey := assertstest.NewAccountKey(s.storeSigning, s.dev1Acct, nil, dev1PrivKey.PublicKey(), "")
err = s.storeSigning.Add(dev1AcctKey)
c.Assert(err, IsNil)
s.dev1Signing = assertstest.NewSigningDB(s.dev1Acct.AccountID(), dev1PrivKey)
s.state = state.New(nil)
mgr, err := assertstate.Manager(s.state)
c.Assert(err, IsNil)
s.mgr = mgr
s.state.Lock()
snapstate.ReplaceStore(s.state, &fakeStore{
state: s.state,
db: s.storeSigning,
})
s.state.Unlock()
}
func (s *deviceMgrSuite) SetUpTest(c *C) {
dirs.SetRootDir(c.MkDir())
rootPrivKey, _ := assertstest.GenerateKey(1024)
storePrivKey, _ := assertstest.GenerateKey(752)
s.storeSigning = assertstest.NewStoreStack("canonical", rootPrivKey, storePrivKey)
s.state = state.New(nil)
db, err := asserts.OpenDatabase(&asserts.DatabaseConfig{
Backstore: asserts.NewMemoryBackstore(),
Trusted: s.storeSigning.Trusted,
})
c.Assert(err, IsNil)
s.state.Lock()
assertstate.ReplaceDB(s.state, db)
s.state.Unlock()
err = db.Add(s.storeSigning.StoreAccountKey(""))
c.Assert(err, IsNil)
mgr, err := devicestate.Manager(s.state)
c.Assert(err, IsNil)
s.db = db
s.mgr = mgr
s.state.Lock()
snapstate.ReplaceStore(s.state, &fakeStore{
state: s.state,
db: s.storeSigning,
})
s.state.Unlock()
}
func (s *downloadSnapSuite) SetUpTest(c *C) {
s.fakeBackend = &fakeSnappyBackend{}
s.state = state.New(nil)
s.state.Lock()
defer s.state.Unlock()
s.fakeStore = &fakeStore{
state: s.state,
fakeBackend: s.fakeBackend,
}
snapstate.ReplaceStore(s.state, s.fakeStore)
var err error
s.snapmgr, err = snapstate.Manager(s.state)
c.Assert(err, IsNil)
s.snapmgr.AddForeignTaskHandlers(s.fakeBackend)
snapstate.SetSnapManagerBackend(s.snapmgr, s.fakeBackend)
s.reset = snapstate.MockReadInfo(s.fakeBackend.ReadInfo)
}
// New creates a new Overlord with all its state managers.
func New() (*Overlord, error) {
o := &Overlord{
loopTomb: new(tomb.Tomb),
}
backend := &overlordStateBackend{
path: dirs.SnapStateFile,
ensureBefore: o.ensureBefore,
requestRestart: o.requestRestart,
}
s, err := loadState(backend)
if err != nil {
return nil, err
}
o.stateEng = NewStateEngine(s)
snapMgr, err := snapstate.Manager(s)
if err != nil {
return nil, err
}
o.snapMgr = snapMgr
o.stateEng.AddManager(o.snapMgr)
assertMgr, err := assertstate.Manager(s)
if err != nil {
return nil, err
}
o.assertMgr = assertMgr
o.stateEng.AddManager(o.assertMgr)
ifaceMgr, err := ifacestate.Manager(s, nil)
if err != nil {
return nil, err
}
o.ifaceMgr = ifaceMgr
o.stateEng.AddManager(o.ifaceMgr)
hookMgr, err := hookstate.Manager(s)
if err != nil {
return nil, err
}
o.hookMgr = hookMgr
o.stateEng.AddManager(o.hookMgr)
configMgr, err := configstate.Manager(s, hookMgr)
if err != nil {
return nil, err
}
o.configMgr = configMgr
deviceMgr, err := devicestate.Manager(s)
if err != nil {
return nil, err
}
o.deviceMgr = deviceMgr
o.stateEng.AddManager(o.deviceMgr)
// setting up the store
authContext := auth.NewAuthContext(s, o.deviceMgr)
sto := storeNew(nil, authContext)
s.Lock()
snapstate.ReplaceStore(s, sto)
s.Unlock()
return o, nil
}
func (ms *mgrsSuite) mockStore(c *C) *httptest.Server {
var baseURL string
fillHit := func() string {
snapf, err := snap.Open(ms.serveSnapPath)
if err != nil {
panic(err)
}
info, err := snap.ReadInfoFromSnapFile(snapf, nil)
if err != nil {
panic(err)
}
hit := strings.Replace(fooSearchHit, "@URL@", baseURL+"/snap", -1)
hit = strings.Replace(hit, "@ICON@", baseURL+"/icon", -1)
hit = strings.Replace(hit, "@VERSION@", info.Version, -1)
hit = strings.Replace(hit, "@REVISION@", ms.serveRevision, -1)
return hit
}
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if strings.HasPrefix(r.URL.Path, "/assertions/") {
comps := strings.Split(r.URL.Path, "/")
ref := &asserts.Ref{
Type: asserts.Type(comps[2]),
PrimaryKey: comps[3:],
}
a, err := ref.Resolve(ms.storeSigning.Find)
if err == asserts.ErrNotFound {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
w.Write([]byte(`{"status": 404}`))
return
}
if err != nil {
panic(err)
}
w.Header().Set("Content-Type", asserts.MediaType)
w.WriteHeader(200)
w.Write(asserts.Encode(a))
return
}
switch r.URL.Path {
case "/details/foo":
w.WriteHeader(http.StatusOK)
io.WriteString(w, fillHit())
case "/metadata":
w.WriteHeader(http.StatusOK)
output := `{
"_embedded": {
"clickindex:package": [@HIT@]
}
}`
output = strings.Replace(output, "@HIT@", fillHit(), 1)
io.WriteString(w, output)
case "/snap":
snapR, err := os.Open(ms.serveSnapPath)
if err != nil {
panic(err)
}
io.Copy(w, snapR)
default:
panic("unexpected url path: " + r.URL.Path)
}
}))
c.Assert(mockServer, NotNil)
baseURL = mockServer.URL
detailsURL, err := url.Parse(baseURL + "/details/")
c.Assert(err, IsNil)
bulkURL, err := url.Parse(baseURL + "/metadata")
c.Assert(err, IsNil)
assertionsURL, err := url.Parse(baseURL + "/assertions/")
c.Assert(err, IsNil)
storeCfg := store.Config{
DetailsURI: detailsURL,
BulkURI: bulkURL,
AssertionsURI: assertionsURL,
}
mStore := store.New(&storeCfg, nil)
st := ms.o.State()
st.Lock()
snapstate.ReplaceStore(ms.o.State(), mStore)
st.Unlock()
return mockServer
}
func (ms *mgrsSuite) mockStore(c *C) *httptest.Server {
var baseURL string
fillHit := func(name string) string {
snapf, err := snap.Open(ms.serveSnapPath[name])
if err != nil {
panic(err)
}
info, err := snap.ReadInfoFromSnapFile(snapf, nil)
if err != nil {
panic(err)
}
hit := strings.Replace(searchHit, "@URL@", baseURL+"/snap/"+name, -1)
hit = strings.Replace(hit, "@NAME@", name, -1)
hit = strings.Replace(hit, "@SNAPID@", fakeSnapID(name), -1)
hit = strings.Replace(hit, "@ICON@", baseURL+"/icon", -1)
hit = strings.Replace(hit, "@VERSION@", info.Version, -1)
hit = strings.Replace(hit, "@REVISION@", ms.serveRevision[name], -1)
return hit
}
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
comps := strings.Split(r.URL.Path, "/")
if len(comps) == 0 {
panic("unexpected url path: " + r.URL.Path)
}
switch comps[1] {
case "assertions":
ref := &asserts.Ref{
Type: asserts.Type(comps[2]),
PrimaryKey: comps[3:],
}
a, err := ref.Resolve(ms.storeSigning.Find)
if err == asserts.ErrNotFound {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
w.Write([]byte(`{"status": 404}`))
return
}
if err != nil {
panic(err)
}
w.Header().Set("Content-Type", asserts.MediaType)
w.WriteHeader(200)
w.Write(asserts.Encode(a))
return
case "details":
w.WriteHeader(http.StatusOK)
io.WriteString(w, fillHit(comps[2]))
case "metadata":
dec := json.NewDecoder(r.Body)
var input struct {
Snaps []struct {
SnapID string `json:"snap_id"`
Revision int `json:"revision"`
} `json:"snaps"`
}
err := dec.Decode(&input)
if err != nil {
panic(err)
}
var hits []json.RawMessage
for _, s := range input.Snaps {
name := ms.serveIDtoName[s.SnapID]
if snap.R(s.Revision) == snap.R(ms.serveRevision[name]) {
continue
}
hits = append(hits, json.RawMessage(fillHit(name)))
}
w.WriteHeader(http.StatusOK)
output, err := json.Marshal(map[string]interface{}{
"_embedded": map[string]interface{}{
"clickindex:package": hits,
},
})
if err != nil {
panic(err)
}
w.Write(output)
case "snap":
snapR, err := os.Open(ms.serveSnapPath[comps[2]])
if err != nil {
panic(err)
}
io.Copy(w, snapR)
default:
panic("unexpected url path: " + r.URL.Path)
}
}))
c.Assert(mockServer, NotNil)
baseURL = mockServer.URL
detailsURL, err := url.Parse(baseURL + "/details/")
c.Assert(err, IsNil)
bulkURL, err := url.Parse(baseURL + "/metadata")
c.Assert(err, IsNil)
assertionsURL, err := url.Parse(baseURL + "/assertions/")
c.Assert(err, IsNil)
storeCfg := store.Config{
DetailsURI: detailsURL,
BulkURI: bulkURL,
AssertionsURI: assertionsURL,
}
mStore := store.New(&storeCfg, nil)
st := ms.o.State()
st.Lock()
snapstate.ReplaceStore(ms.o.State(), mStore)
st.Unlock()
return mockServer
}