Пример #1
0
func (s *hookManagerSuite) TestHookTask(c *C) {
	// Register a handler generator for the "test-hook" hook
	var calledContext *hookstate.Context
	mockHandler := hooktest.NewMockHandler()
	mockHandlerGenerator := func(context *hookstate.Context) hookstate.Handler {
		calledContext = context
		return mockHandler
	}

	s.manager.Register(regexp.MustCompile("test-hook"), mockHandlerGenerator)

	s.manager.Ensure()
	s.manager.Wait()

	s.state.Lock()
	defer s.state.Unlock()

	c.Assert(calledContext, NotNil, Commentf("Expected handler generator to be called with a valid context"))
	c.Check(calledContext.SnapName(), Equals, "test-snap")
	c.Check(calledContext.SnapRevision(), Equals, snap.R(1))
	c.Check(calledContext.HookName(), Equals, "test-hook")

	c.Check(s.command.Calls(), DeepEquals, [][]string{{
		"snap", "run", "--hook", "test-hook", "-r", "1", "test-snap",
	}})

	c.Check(mockHandler.BeforeCalled, Equals, true)
	c.Check(mockHandler.DoneCalled, Equals, true)
	c.Check(mockHandler.ErrorCalled, Equals, false)

	c.Check(s.task.Kind(), Equals, "run-hook")
	c.Check(s.task.Status(), Equals, state.DoneStatus)
	c.Check(s.change.Status(), Equals, state.DoneStatus)
}
Пример #2
0
// ContextTransaction retrieves the transaction cached within the context (and
// creates one if it hasn't already been cached).
func ContextTransaction(context *hookstate.Context) *Transaction {
	// Check for one already cached
	transaction, ok := context.Cached(cachedTransaction{}).(*Transaction)
	if ok {
		return transaction
	}

	// It wasn't already cached, so create and cache a new one
	transaction = NewTransaction(context.State())

	context.OnDone(func() error {
		transaction.Commit()
		return nil
	})

	context.Cache(cachedTransaction{}, transaction)
	return transaction
}
Пример #3
0
func getTransaction(context *hookstate.Context) (*configstate.Transaction, error) {
	context.Lock()
	defer context.Unlock()

	// Extract the transaction from the context. If none, make one and cache it
	// in the context.
	transaction, ok := context.Cached(cachedTransaction{}).(*configstate.Transaction)
	if !ok {
		var err error
		transaction, err = configstate.NewTransaction(context.State())
		if err != nil {
			return nil, fmt.Errorf("cannot create transaction: %s", err)
		}

		context.OnDone(func() error {
			transaction.Commit()
			return nil
		})

		context.Cache(cachedTransaction{}, transaction)
	}

	return transaction, nil
}