func (ovs *overlordSuite) TestNew(c *C) { restore := patch.Mock(42, nil) defer restore() o, err := overlord.New() c.Assert(err, IsNil) c.Check(o, NotNil) c.Check(o.SnapManager(), NotNil) c.Check(o.AssertManager(), NotNil) c.Check(o.InterfaceManager(), NotNil) c.Check(o.DeviceManager(), NotNil) s := o.State() c.Check(s, NotNil) c.Check(o.Engine().State(), Equals, s) s.Lock() defer s.Unlock() var patchLevel int s.Get("patch-level", &patchLevel) c.Check(patchLevel, Equals, 42) // store is setup sto := snapstate.Store(s) c.Check(sto, FitsTypeOf, &store.Store{}) }
func doFetch(s *state.State, userID int, fetching func(asserts.Fetcher) error) error { // TODO: once we have a bulk assertion retrieval endpoint this approach will change user, err := userFromUserID(s, userID) if err != nil { return err } sto := snapstate.Store(s) retrieve := func(ref *asserts.Ref) (asserts.Assertion, error) { // TODO: ignore errors if already in db? return sto.Assertion(ref.Type, ref.PrimaryKey, user) } f := newFetcher(s, retrieve) s.Unlock() err = fetching(f) s.Lock() if err != nil { return err } // TODO: trigger w. caller a global sanity check if a is revoked // (but try to save as much possible still), // or err is a check error return f.commit() }
func getStore(c *Command) snapstate.StoreService { st := c.d.overlord.State() st.Lock() defer st.Unlock() return snapstate.Store(st) }
func (m *DeviceManager) doRequestSerial(t *state.Task, _ *tomb.Tomb) error { st := t.State() st.Lock() defer st.Unlock() cfg, err := getSerialRequestConfig(t) if err != nil { return err } device, err := auth.Device(st) if err != nil { return err } privKey, err := m.keyPair() if err == state.ErrNoState { return fmt.Errorf("internal error: cannot find device key pair") } if err != nil { return err } // make this idempotent, look if we have already a serial assertion // for privKey serials, err := assertstate.DB(st).FindMany(asserts.SerialType, map[string]string{ "brand-id": device.Brand, "model": device.Model, "device-key-sha3-384": privKey.PublicKey().ID(), }) if err != nil && err != asserts.ErrNotFound { return err } if len(serials) == 1 { // means we saved the assertion but didn't get to the end of the task device.Serial = serials[0].(*asserts.Serial).Serial() err := auth.SetDevice(st, device) if err != nil { return err } t.SetStatus(state.DoneStatus) return nil } if len(serials) > 1 { return fmt.Errorf("internal error: multiple serial assertions for the same device key") } serial, err := getSerial(t, privKey, device, cfg) if err == errPoll { t.Logf("Will poll for device serial assertion in 60 seconds") return &state.Retry{After: retryInterval} } if err != nil { // errors & retries return err } sto := snapstate.Store(st) // try to fetch the signing key of the serial st.Unlock() a, errAcctKey := sto.Assertion(asserts.AccountKeyType, []string{serial.SignKeyID()}, nil) st.Lock() if errAcctKey == nil { err := assertstate.Add(st, a) if err != nil { if !asserts.IsUnaccceptedUpdate(err) { return err } } } // add the serial assertion to the system assertion db err = assertstate.Add(st, serial) if err != nil { // if we had failed to fetch the signing key, retry in a bit if errAcctKey != nil { t.Errorf("cannot fetch signing key for the serial: %v", errAcctKey) return &state.Retry{After: retryInterval} } return err } if repeatRequestSerial == "after-add-serial" { // For testing purposes, ensure a crash in this state works. return &state.Retry{} } device.Serial = serial.Serial() err = auth.SetDevice(st, device) if err != nil { return err } t.SetStatus(state.DoneStatus) return nil }