func (s *StateFileSuite) TestStates(c *gc.C) {
for i, t := range stateTests {
c.Logf("test %d", i)
path := filepath.Join(c.MkDir(), "uniter")
file := uniter.NewStateFile(path)
_, err := file.Read()
c.Assert(err, gc.Equals, uniter.ErrNoStateFile)
write := func() {
err := file.Write(t.st.Started, t.st.Op, t.st.OpStep, t.st.Hook, t.st.CharmURL)
c.Assert(err, gc.IsNil)
}
if t.err != "" {
c.Assert(write, gc.PanicMatches, "invalid uniter state: "+t.err)
err := utils.WriteYaml(path, &t.st)
c.Assert(err, gc.IsNil)
_, err = file.Read()
c.Assert(err, gc.ErrorMatches, "cannot read charm state at .*: invalid uniter state: "+t.err)
continue
}
write()
st, err := file.Read()
c.Assert(err, gc.IsNil)
c.Assert(*st, gc.DeepEquals, t.st)
}
}
// Write atomically writes to disk the relation state change in hi.
// It must be called after the respective hook was executed successfully.
// Write doesn't validate hi but guarantees that successive writes of
// the same hi are idempotent.
func (d *StateDir) Write(hi hook.Info) (err error) {
defer errors.Maskf(&err, "failed to write %q hook info for %q on state directory", hi.Kind, hi.RemoteUnit)
if hi.Kind == hooks.RelationBroken {
return d.Remove()
}
name := strings.Replace(hi.RemoteUnit, "/", "-", 1)
path := filepath.Join(d.path, name)
if hi.Kind == hooks.RelationDeparted {
if err = os.Remove(path); err != nil && !os.IsNotExist(err) {
return err
}
// If atomic delete succeeded, update own state.
delete(d.state.Members, hi.RemoteUnit)
return nil
}
di := diskInfo{&hi.ChangeVersion, hi.Kind == hooks.RelationJoined}
if err := utils.WriteYaml(path, &di); err != nil {
return err
}
// If write was successful, update own state.
d.state.Members[hi.RemoteUnit] = hi.ChangeVersion
if hi.Kind == hooks.RelationJoined {
d.state.ChangedPending = hi.RemoteUnit
} else {
d.state.ChangedPending = ""
}
return nil
}
// Write stores the supplied status information to disk.
func (f *StateFile) Write(code, info string) error {
st := state{
Code: code,
Info: info,
}
return errors.Trace(utils.WriteYaml(f.path, st))
}
// storeManifest stores, into dataPath, the supplied manifest for the supplied charm.
func (d *manifestDeployer) storeManifest(url *charm.URL, manifest set.Strings) error {
if err := os.MkdirAll(d.DataPath(manifestsDataPath), 0755); err != nil {
return err
}
name := charm.Quote(url.String())
path := filepath.Join(d.DataPath(manifestsDataPath), name)
return utils.WriteYaml(path, manifest.SortedValues())
}
// Write stores the supplied status information to disk.
func (f *StateFile) Write(code, info string, disconnected *Disconnected) error {
st := state{
Code: code,
Info: info,
Disconnected: disconnected,
}
return errors.Trace(utils.WriteYaml(f.path, st))
}
// Write stores the supplied state to the file.
func (f *StateFile) Write(started bool, op Op, step OpStep, hi *uhook.Info, url *charm.URL) error {
st := &State{
Started: started,
Op: op,
OpStep: step,
Hook: hi,
CharmURL: url,
}
if err := st.validate(); err != nil {
panic(err)
}
return utils.WriteYaml(f.path, st)
}
// CommitHook atomically writes to disk the storage state change in hi.
// It must be called after the respective hook was executed successfully.
// CommitHook doesn't validate hi but guarantees that successive writes
// of the same hi are idempotent.
func (d *stateFile) CommitHook(hi hook.Info) (err error) {
defer errors.DeferredAnnotatef(&err, "failed to write %q hook info for %q on state directory", hi.Kind, hi.StorageId)
if hi.Kind == hooks.StorageDetaching {
return d.Remove()
}
attached := true
di := diskInfo{&attached}
if err := utils.WriteYaml(d.path, &di); err != nil {
return err
}
// If write was successful, update own state.
d.state.attached = true
return nil
}
func (s *tmpfsFilesystemSource) writeFilesystemInfo(tag names.FilesystemTag, info storage.FilesystemInfo) error {
filename := s.filesystemInfoFile(tag)
if _, err := os.Stat(filename); err == nil {
return errors.Errorf("filesystem %v already exists", tag.Id())
}
if err := ensureDir(s.dirFuncs, filepath.Dir(filename)); err != nil {
return errors.Trace(err)
}
err := utils.WriteYaml(filename, filesystemInfo{&info.Size})
if err != nil {
return errors.Annotate(err, "writing filesystem info to disk")
}
return err
}
func (s *StateFileSuite) TestStates(c *gc.C) {
for i, t := range stateTests {
c.Logf("test %d", i)
path := filepath.Join(c.MkDir(), "uniter")
file := operation.NewStateFile(path)
_, err := file.Read()
c.Assert(err, gc.Equals, operation.ErrNoStateFile)
err = file.Write(&t.st)
if t.err == "" {
c.Assert(err, jc.ErrorIsNil)
} else {
c.Assert(err, gc.ErrorMatches, "invalid operation state: "+t.err)
err := utils.WriteYaml(path, &t.st)
c.Assert(err, jc.ErrorIsNil)
_, err = file.Read()
c.Assert(err, gc.ErrorMatches, `cannot read ".*": invalid operation state: `+t.err)
continue
}
st, err := file.Read()
c.Assert(err, jc.ErrorIsNil)
c.Assert(st, jc.DeepEquals, &t.st)
}
}
// WriteCharmURL writes a charm identity file into the supplied path.
func WriteCharmURL(path string, url *charm.URL) error {
return utils.WriteYaml(path, url.String())
}
func (s *upgradeStateContextSuite) writeOldState(c *gc.C, state *oldState) {
err := utils.WriteYaml(s.uniterStateFile, state)
c.Assert(err, jc.ErrorIsNil)
}
// Write stores the supplied state to the file.
func (f *StateFile) Write(st *State) error {
if err := st.validate(); err != nil {
return errors.Trace(err)
}
return utils.WriteYaml(f.path, st)
}