// ReadCharmURL reads a charm identity file from the supplied path.
func ReadCharmURL(path string) (*charm.URL, error) {
surl := ""
if err := utils.ReadYaml(path, &surl); err != nil {
return nil, err
}
return charm.ParseURL(surl)
}
func readUnsafe(opsfile string) (*operation.State, error) {
var st operation.State
if err := utils.ReadYaml(opsfile, &st); err != nil {
if os.IsNotExist(err) {
return nil, operation.ErrNoStateFile
}
}
return &st, nil
}
// Read reads the current meter status information from disk.
func (f *StateFile) Read() (string, string, error) {
var st state
if err := utils.ReadYaml(f.path, &st); err != nil {
if os.IsNotExist(err) {
return "", "", nil
}
return "", "", errors.Trace(err)
}
return st.Code, st.Info, nil
}
// Read reads a State from the file. If the file does not exist it returns
// ErrNoStateFile.
func (f *StateFile) Read() (*State, error) {
var st State
if err := utils.ReadYaml(f.path, &st); err != nil {
if os.IsNotExist(err) {
return nil, ErrNoStateFile
}
}
if err := st.validate(); err != nil {
return nil, errors.Errorf("cannot read %q: %v", f.path, err)
}
return &st, nil
}
func (s *tmpfsFilesystemSource) readFilesystemInfo(tag names.FilesystemTag) (storage.FilesystemInfo, error) {
var info filesystemInfo
if err := utils.ReadYaml(s.filesystemInfoFile(tag), &info); err != nil {
return storage.FilesystemInfo{}, errors.Annotate(err, "reading filesystem info from disk")
}
if info.Size == nil {
return storage.FilesystemInfo{}, errors.New("invalid filesystem info: missing size")
}
return storage.FilesystemInfo{
FilesystemId: tag.String(),
Size: *info.Size,
}, nil
}
// loadManifest loads, from dataPath, the manifest for the charm identified by the
// identity file at the supplied path within the charm directory.
func (d *manifestDeployer) loadManifest(urlFilePath string) (*charm.URL, set.Strings, error) {
url, err := ReadCharmURL(d.CharmPath(urlFilePath))
if err != nil {
return nil, nil, err
}
name := charm.Quote(url.String())
path := filepath.Join(d.DataPath(manifestsDataPath), name)
manifest := []string{}
err = utils.ReadYaml(path, &manifest)
if os.IsNotExist(err) {
logger.Warningf("manifest not found at %q: files from charm %q may be left unremoved", path, url)
err = nil
}
return url, set.NewStrings(manifest...), err
}
// ReadStateDir loads a StateDir from the subdirectory of dirPath named
// for the supplied RelationId. If the directory does not exist, no error
// is returned,
func ReadStateDir(dirPath string, relationId int) (d *StateDir, err error) {
d = &StateDir{
filepath.Join(dirPath, strconv.Itoa(relationId)),
State{relationId, map[string]int64{}, ""},
}
defer errors.Maskf(&err, "cannot load relation state from %q", d.path)
if _, err := os.Stat(d.path); os.IsNotExist(err) {
return d, nil
} else if err != nil {
return nil, err
}
fis, err := ioutil.ReadDir(d.path)
if err != nil {
return nil, err
}
for _, fi := range fis {
// Entries with names ending in "-" followed by an integer must be
// files containing valid unit data; all other names are ignored.
name := fi.Name()
i := strings.LastIndex(name, "-")
if i == -1 {
continue
}
svcName := name[:i]
unitId := name[i+1:]
if _, err := strconv.Atoi(unitId); err != nil {
continue
}
unitName := svcName + "/" + unitId
var info diskInfo
if err = utils.ReadYaml(filepath.Join(d.path, name), &info); err != nil {
return nil, fmt.Errorf("invalid unit file %q: %v", name, err)
}
if info.ChangeVersion == nil {
return nil, fmt.Errorf(`invalid unit file %q: "changed-version" not set`, name)
}
d.state.Members[unitName] = *info.ChangeVersion
if info.ChangedPending {
if d.state.ChangedPending != "" {
return nil, fmt.Errorf("%q and %q both have pending changed hooks", d.state.ChangedPending, unitName)
}
d.state.ChangedPending = unitName
}
}
return d, nil
}
// readStateFile loads a stateFile from the subdirectory of dirPath named
// for the supplied storage tag. If the directory does not exist, no error
// is returned.
func readStateFile(dirPath string, tag names.StorageTag) (d *stateFile, err error) {
filename := strings.Replace(tag.Id(), "/", "-", -1)
d = &stateFile{
filepath.Join(dirPath, filename),
state{storage: tag},
}
defer errors.DeferredAnnotatef(&err, "cannot load storage %q state from %q", tag.Id(), d.path)
if _, err := os.Stat(d.path); os.IsNotExist(err) {
return d, nil
} else if err != nil {
return nil, err
}
var info diskInfo
if err := utils.ReadYaml(d.path, &info); err != nil {
return nil, errors.Errorf("invalid storage state file %q: %v", d.path, err)
}
if info.Attached == nil {
return nil, errors.Errorf("invalid storage state file %q: missing 'attached'", d.path)
}
d.state.attached = *info.Attached
return d, nil
}
// load loads the "machine info" file and parse the content into the info
// object.
func (info *machineInfo) load() error {
return utils.ReadYaml(_MAASInstanceFilename, info)
}
