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 }