func (s *StateDirSuite) TestWrite(c *gc.C) {
for i, t := range writeTests {
c.Logf("test %d", i)
basedir := c.MkDir()
setUpDir(c, basedir, "123", map[string]string{
"foo-1": "change-version: 0\n",
"foo-2": "change-version: 0\n",
})
dir, err := relation.ReadStateDir(basedir, 123)
c.Assert(err, gc.IsNil)
for i, hi := range t.hooks {
c.Logf(" hook %d", i)
if i == len(t.hooks)-1 && t.err != "" {
err = dir.State().Validate(hi)
expect := fmt.Sprintf(`inappropriate %q for %q: %s`, hi.Kind, hi.RemoteUnit, t.err)
c.Assert(err, gc.ErrorMatches, expect)
} else {
err = dir.State().Validate(hi)
c.Assert(err, gc.IsNil)
err = dir.Write(hi)
c.Assert(err, gc.IsNil)
// Check that writing the same change again is OK.
err = dir.Write(hi)
c.Assert(err, gc.IsNil)
}
}
members := t.members
if members == nil && !t.deleted {
members = defaultMembers
}
assertState(c, dir, basedir, 123, members, t.pending, t.deleted)
}
}
// restoreRelations reconciles the local relation state dirs with the
// remote state of the corresponding relations.
func (u *Uniter) restoreRelations() error {
joinedRelations, err := u.getJoinedRelations()
if err != nil {
return err
}
knownDirs, err := relation.ReadAllStateDirs(u.relationsDir)
if err != nil {
return err
}
for id, dir := range knownDirs {
if rel, ok := joinedRelations[id]; ok {
if err := u.addRelation(rel, dir); err != nil {
return err
}
} else if err := dir.Remove(); err != nil {
return err
}
}
for id, rel := range joinedRelations {
if _, ok := knownDirs[id]; ok {
continue
}
dir, err := relation.ReadStateDir(u.relationsDir, id)
if err != nil {
return err
}
if err := u.addRelation(rel, dir); err != nil {
return err
}
}
return nil
}
func (s *RelationerSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
var err error
s.svc = s.AddTestingService(c, "u", s.AddTestingCharm(c, "riak"))
c.Assert(err, gc.IsNil)
rels, err := s.svc.Relations()
c.Assert(err, gc.IsNil)
c.Assert(rels, gc.HasLen, 1)
s.rel = rels[0]
_, unit := s.AddRelationUnit(c, "u/0")
s.dirPath = c.MkDir()
s.dir, err = relation.ReadStateDir(s.dirPath, s.rel.Id())
c.Assert(err, gc.IsNil)
s.hooks = make(chan hook.Info)
password, err := utils.RandomPassword()
c.Assert(err, gc.IsNil)
err = unit.SetPassword(password)
c.Assert(err, gc.IsNil)
s.st = s.OpenAPIAs(c, unit.Tag(), password)
s.uniter = s.st.Uniter()
c.Assert(s.uniter, gc.NotNil)
apiUnit, err := s.uniter.Unit(unit.Tag())
c.Assert(err, gc.IsNil)
apiRel, err := s.uniter.Relation(s.rel.Tag())
c.Assert(err, gc.IsNil)
s.apiRelUnit, err = apiRel.Unit(apiUnit)
c.Assert(err, gc.IsNil)
}
func (s *StateDirSuite) TestRemove(c *gc.C) {
basedir := c.MkDir()
dir, err := relation.ReadStateDir(basedir, 1)
c.Assert(err, gc.IsNil)
err = dir.Ensure()
c.Assert(err, gc.IsNil)
err = dir.Remove()
c.Assert(err, gc.IsNil)
err = dir.Remove()
c.Assert(err, gc.IsNil)
setUpDir(c, basedir, "99", map[string]string{
"foo-1": "change-version: 0\n",
})
dir, err = relation.ReadStateDir(basedir, 99)
c.Assert(err, gc.IsNil)
err = dir.Remove()
c.Assert(err, gc.ErrorMatches, ".*: directory not empty")
}
func (s *StateDirSuite) TestBadRelations(c *gc.C) {
for i, t := range badRelationsTests {
c.Logf("test %d", i)
basedir := c.MkDir()
reldir := setUpDir(c, basedir, "123", t.contents)
for _, subdir := range t.subdirs {
setUpDir(c, reldir, subdir, nil)
}
_, err := relation.ReadStateDir(basedir, 123)
expect := `cannot load relation state from ".*": ` + t.err
c.Assert(err, gc.ErrorMatches, expect)
}
}
func assertState(c *gc.C, dir *relation.StateDir, relsdir string, relationId int, members msi, pending string, deleted bool) {
expect := &relation.State{
RelationId: relationId,
Members: map[string]int64(members),
ChangedPending: pending,
}
c.Assert(dir.State(), gc.DeepEquals, expect)
if deleted {
_, err := os.Stat(filepath.Join(relsdir, strconv.Itoa(relationId)))
c.Assert(err, jc.Satisfies, os.IsNotExist)
} else {
fresh, err := relation.ReadStateDir(relsdir, relationId)
c.Assert(err, gc.IsNil)
c.Assert(fresh.State(), gc.DeepEquals, expect)
}
}
func (s *StateDirSuite) TestReadStateDirValid(c *gc.C) {
basedir := c.MkDir()
reldir := setUpDir(c, basedir, "123", map[string]string{
"foo-bar-1": "change-version: 99\n",
"foo-bar-1.preparing": "change-version: 100\n",
"baz-qux-7": "change-version: 101\nchanged-pending: true\n",
"nonsensical": "blah",
"27": "blah",
})
setUpDir(c, reldir, "ignored", nil)
dir, err := relation.ReadStateDir(basedir, 123)
c.Assert(err, gc.IsNil)
state := dir.State()
c.Assert(state.RelationId, gc.Equals, 123)
c.Assert(msi(state.Members), gc.DeepEquals, msi{"foo-bar/1": 99, "baz-qux/7": 101})
c.Assert(state.ChangedPending, gc.Equals, "baz-qux/7")
}
func (s *StateDirSuite) TestReadStateDirEmpty(c *gc.C) {
basedir := c.MkDir()
reldir := filepath.Join(basedir, "123")
dir, err := relation.ReadStateDir(basedir, 123)
c.Assert(err, gc.IsNil)
state := dir.State()
c.Assert(state.RelationId, gc.Equals, 123)
c.Assert(msi(state.Members), gc.DeepEquals, msi{})
c.Assert(state.ChangedPending, gc.Equals, "")
_, err = os.Stat(reldir)
c.Assert(err, jc.Satisfies, os.IsNotExist)
err = dir.Ensure()
c.Assert(err, gc.IsNil)
fi, err := os.Stat(reldir)
c.Assert(err, gc.IsNil)
c.Assert(fi, jc.Satisfies, os.FileInfo.IsDir)
}
// updateRelations responds to changes in the life states of the relations
// with the supplied ids. If any id corresponds to an alive relation not
// known to the unit, the uniter will join that relation and return its
// relationer in the added list.
func (u *Uniter) updateRelations(ids []int) (added []*Relationer, err error) {
for _, id := range ids {
if r, found := u.relationers[id]; found {
rel := r.ru.Relation()
if err := rel.Refresh(); err != nil {
return nil, fmt.Errorf("cannot update relation %q: %v", rel, err)
}
if rel.Life() == params.Dying {
if err := r.SetDying(); err != nil {
return nil, err
} else if r.IsImplicit() {
delete(u.relationers, id)
}
}
continue
}
// Relations that are not alive are simply skipped, because they
// were not previously known anyway.
rel, err := u.st.RelationById(id)
if err != nil {
if params.IsCodeNotFoundOrCodeUnauthorized(err) {
continue
}
return nil, err
}
if rel.Life() != params.Alive {
continue
}
// Make sure we ignore relations not implemented by the unit's charm.
ch, err := corecharm.ReadDir(u.charmPath)
if err != nil {
return nil, err
}
if ep, err := rel.Endpoint(); err != nil {
return nil, err
} else if !ep.ImplementedBy(ch) {
logger.Warningf("skipping relation with unknown endpoint %q", ep.Name)
continue
}
dir, err := relation.ReadStateDir(u.relationsDir, id)
if err != nil {
return nil, err
}
err = u.addRelation(rel, dir)
if err == nil {
added = append(added, u.relationers[id])
continue
}
e := dir.Remove()
if !params.IsCodeCannotEnterScope(err) {
return nil, err
}
if e != nil {
return nil, e
}
}
if ok, err := u.unit.IsPrincipal(); err != nil {
return nil, err
} else if ok {
return added, nil
}
// If no Alive relations remain between a subordinate unit's service
// and its principal's service, the subordinate must become Dying.
keepAlive := false
for _, r := range u.relationers {
scope := r.ru.Endpoint().Scope
if scope == corecharm.ScopeContainer && !r.dying {
keepAlive = true
break
}
}
if !keepAlive {
if err := u.unit.Destroy(); err != nil {
return nil, err
}
}
return added, nil
}
func (s *RelationerImplicitSuite) TestImplicitRelationer(c *gc.C) {
// Create a relationer for an implicit endpoint (mysql:juju-info).
mysql := s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
u, err := mysql.AddUnit()
c.Assert(err, gc.IsNil)
machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
err = u.AssignToMachine(machine)
c.Assert(err, gc.IsNil)
err = machine.SetAddresses(instance.NewAddress("blah", instance.NetworkCloudLocal))
c.Assert(err, gc.IsNil)
logging := s.AddTestingService(c, "logging", s.AddTestingCharm(c, "logging"))
eps, err := s.State.InferEndpoints([]string{"logging", "mysql"})
c.Assert(err, gc.IsNil)
rel, err := s.State.AddRelation(eps...)
c.Assert(err, gc.IsNil)
relsDir := c.MkDir()
dir, err := relation.ReadStateDir(relsDir, rel.Id())
c.Assert(err, gc.IsNil)
hooks := make(chan hook.Info)
password, err := utils.RandomPassword()
c.Assert(err, gc.IsNil)
err = u.SetPassword(password)
c.Assert(err, gc.IsNil)
st := s.OpenAPIAs(c, u.Tag(), password)
uniterState := st.Uniter()
c.Assert(uniterState, gc.NotNil)
apiUnit, err := uniterState.Unit(u.Tag())
c.Assert(err, gc.IsNil)
apiRel, err := uniterState.Relation(rel.Tag())
c.Assert(err, gc.IsNil)
apiRelUnit, err := apiRel.Unit(apiUnit)
c.Assert(err, gc.IsNil)
r := uniter.NewRelationer(apiRelUnit, dir, hooks)
c.Assert(r, jc.Satisfies, (*uniter.Relationer).IsImplicit)
// Join the relation.
err = r.Join()
c.Assert(err, gc.IsNil)
sub, err := logging.Unit("logging/0")
c.Assert(err, gc.IsNil)
// Join the other side; check no hooks are sent.
r.StartHooks()
defer func() { c.Assert(r.StopHooks(), gc.IsNil) }()
subru, err := rel.Unit(sub)
c.Assert(err, gc.IsNil)
err = subru.EnterScope(map[string]interface{}{"some": "data"})
c.Assert(err, gc.IsNil)
s.State.StartSync()
select {
case <-time.After(coretesting.ShortWait):
case <-hooks:
c.Fatalf("unexpected hook generated")
}
// Set it to Dying; check that the dir is removed immediately.
err = r.SetDying()
c.Assert(err, gc.IsNil)
path := strconv.Itoa(rel.Id())
ft.Removed{path}.Check(c, relsDir)
// Check that it left scope, by leaving scope on the other side and destroying
// the relation.
err = subru.LeaveScope()
c.Assert(err, gc.IsNil)
err = rel.Destroy()
c.Assert(err, gc.IsNil)
err = rel.Refresh()
c.Assert(err, jc.Satisfies, errors.IsNotFound)
// Verify that no other hooks were sent at any stage.
select {
case <-hooks:
c.Fatalf("unexpected hook generated")
default:
}
}