// FilesystemAttachments returns all of the FilesystemAttachments for the // specified filesystem. func (st *State) FilesystemAttachments(filesystem names.FilesystemTag) ([]FilesystemAttachment, error) { attachments, err := st.filesystemAttachments(bson.D{{"filesystemid", filesystem.Id()}}) if err != nil { return nil, errors.Annotatef(err, "getting attachments for filesystem %q", filesystem.Id()) } return attachments, nil }
// SetFilesystemStatus sets the status of the specified filesystem. func (st *State) SetFilesystemStatus(tag names.FilesystemTag, status Status, info string, data map[string]interface{}) error { switch status { case StatusAttaching, StatusAttached, StatusDetaching, StatusDetached, StatusDestroying: case StatusError: if info == "" { return errors.Errorf("cannot set status %q without info", status) } case StatusPending: // If a filesystem is not yet provisioned, we allow its status // to be set back to pending (when a retry is to occur). v, err := st.Filesystem(tag) if err != nil { return errors.Trace(err) } _, err = v.Info() if errors.IsNotProvisioned(err) { break } return errors.Errorf("cannot set status %q", status) default: return errors.Errorf("cannot set invalid status %q", status) } return setStatus(st, setStatusParams{ badge: "filesystem", globalKey: filesystemGlobalKey(tag.Id()), status: status, message: info, rawData: data, }) }
func detachFilesystemOps(m names.MachineTag, f names.FilesystemTag) []txn.Op { return []txn.Op{{ C: filesystemAttachmentsC, Id: filesystemAttachmentId(m.Id(), f.Id()), Assert: isAliveDoc, Update: bson.D{{"$set", bson.D{{"life", Dying}}}}, }} }
func (m *mockFilesystemAccessor) provisionFilesystem(tag names.FilesystemTag) params.Filesystem { f := params.Filesystem{ FilesystemTag: tag.String(), Info: params.FilesystemInfo{ FilesystemId: "vol-" + tag.Id(), }, } m.provisionedFilesystems[tag.String()] = f return f }
// SetFilesystemInfo sets the FilesystemInfo for the specified filesystem. func (st *State) SetFilesystemInfo(tag names.FilesystemTag, info FilesystemInfo) (err error) { defer errors.DeferredAnnotatef(&err, "cannot set info for filesystem %q", tag.Id()) if info.FilesystemId == "" { return errors.New("filesystem ID not set") } fs, err := st.Filesystem(tag) if err != nil { return errors.Trace(err) } // If the filesystem is volume-backed, the volume must be provisioned // and attachment first. if volumeTag, err := fs.Volume(); err == nil { machineTag, ok := names.FilesystemMachine(tag) if !ok { return errors.Errorf("filesystem %s is not machine-scoped, but volume-backed", tag.Id()) } volumeAttachment, err := st.VolumeAttachment(machineTag, volumeTag) if err != nil { return errors.Trace(err) } if _, err := volumeAttachment.Info(); err != nil { return errors.Trace(err) } } else if errors.Cause(err) != ErrNoBackingVolume { return errors.Trace(err) } buildTxn := func(attempt int) ([]txn.Op, error) { if attempt > 0 { fs, err = st.Filesystem(tag) if err != nil { return nil, errors.Trace(err) } } // If the filesystem has parameters, unset them // when we set info for the first time, ensuring // that params and info are mutually exclusive. var unsetParams bool if params, ok := fs.Params(); ok { info.Pool = params.Pool unsetParams = true } else { // Ensure immutable properties do not change. oldInfo, err := fs.Info() if err != nil { return nil, err } if err := validateFilesystemInfoChange(info, oldInfo); err != nil { return nil, err } } ops := setFilesystemInfoOps(tag, info, unsetParams) return ops, nil } return st.run(buildTxn) }
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 }
// DetachFilesystem marks the filesystem attachment identified by the specified machine // and filesystem tags as Dying, if it is Alive. func (st *State) DetachFilesystem(machine names.MachineTag, filesystem names.FilesystemTag) (err error) { defer errors.DeferredAnnotatef(&err, "detaching filesystem %s from machine %s", filesystem.Id(), machine.Id()) buildTxn := func(attempt int) ([]txn.Op, error) { fsa, err := st.FilesystemAttachment(machine, filesystem) if err != nil { return nil, errors.Trace(err) } if fsa.Life() != Alive { return nil, jujutxn.ErrNoOperations } ops := detachFilesystemOps(machine, filesystem) return ops, nil } return st.run(buildTxn) }
// RemoveFilesystem removes the filesystem from state. RemoveFilesystem will // fail if there are any attachments remaining, or if the filesystem is not // Dying. Removing a volume-backed filesystem will cause the volume to be // destroyed. func (st *State) RemoveFilesystem(tag names.FilesystemTag) (err error) { defer errors.DeferredAnnotatef(&err, "removing filesystem %s", tag.Id()) buildTxn := func(attempt int) ([]txn.Op, error) { filesystem, err := st.Filesystem(tag) if errors.IsNotFound(err) { return nil, jujutxn.ErrNoOperations } else if err != nil { return nil, errors.Trace(err) } if filesystem.Life() != Dead { return nil, errors.New("filesystem is not dead") } return removeFilesystemOps(st, filesystem) } return st.run(buildTxn) }
func setFilesystemInfoOps(tag names.FilesystemTag, info FilesystemInfo, unsetParams bool) []txn.Op { asserts := isAliveDoc update := bson.D{ {"$set", bson.D{{"info", &info}}}, } if unsetParams { asserts = append(asserts, bson.DocElem{"info", bson.D{{"$exists", false}}}) asserts = append(asserts, bson.DocElem{"params", bson.D{{"$exists", true}}}) update = append(update, bson.DocElem{"$unset", bson.D{{"params", nil}}}) } return []txn.Op{{ C: filesystemsC, Id: tag.Id(), Assert: asserts, Update: update, }} }
func (s *rootfsFilesystemSource) mount(tag names.FilesystemTag, target string) error { fsPath := filepath.Join(s.storageDir, tag.Id()) if target == fsPath { return nil } logger.Debugf("mounting filesystem %q at %q", fsPath, target) if err := ensureDir(s.dirFuncs, target); err != nil { return errors.Trace(err) } mounted, err := s.tryBindMount(fsPath, target) if err != nil { return errors.Trace(err) } if mounted { return nil } // We couldn't bind-mount over the designated directory; // carry on and check if it's on the same filesystem. If // it is, and it's empty, then claim it as our own. if err := s.validateSameMountPoints(fsPath, target); err != nil { return err } // The first time we try to take the existing directory, we'll // ensure that it's empty and create a file to "claim" it. // Future attachments will simply ensure that the claim file // exists. targetClaimPath := filepath.Join(fsPath, "juju-target-claimed") _, err = s.dirFuncs.lstat(targetClaimPath) if err == nil { return nil } else if !os.IsNotExist(err) { return errors.Trace(err) } if err := ensureEmptyDir(s.dirFuncs, target); err != nil { return errors.Trace(err) } if err := s.dirFuncs.mkDirAll(targetClaimPath, 0755); err != nil { return errors.Annotate(err, "writing claim file") } return nil }
func setFilesystemAttachmentInfoOps( machine names.MachineTag, filesystem names.FilesystemTag, info FilesystemAttachmentInfo, unsetParams bool, ) []txn.Op { asserts := isAliveDoc update := bson.D{ {"$set", bson.D{{"info", &info}}}, } if unsetParams { asserts = append(asserts, bson.DocElem{"info", bson.D{{"$exists", false}}}) asserts = append(asserts, bson.DocElem{"params", bson.D{{"$exists", true}}}) update = append(update, bson.DocElem{"$unset", bson.D{{"params", nil}}}) } return []txn.Op{{ C: filesystemAttachmentsC, Id: filesystemAttachmentId(machine.Id(), filesystem.Id()), Assert: asserts, Update: update, }} }
// FilesystemAttachment returns the FilesystemAttachment corresponding to // the specified filesystem and machine. func (st *State) FilesystemAttachment(machine names.MachineTag, filesystem names.FilesystemTag) (FilesystemAttachment, error) { coll, cleanup := st.getCollection(filesystemAttachmentsC) defer cleanup() var att filesystemAttachment err := coll.FindId(filesystemAttachmentId(machine.Id(), filesystem.Id())).One(&att.doc) if err == mgo.ErrNotFound { return nil, errors.NotFoundf("filesystem %q on machine %q", filesystem.Id(), machine.Id()) } else if err != nil { return nil, errors.Annotatef(err, "getting filesystem %q on machine %q", filesystem.Id(), machine.Id()) } return &att, nil }
// FilesystemStatus returns the status of the specified filesystem. func (st *State) FilesystemStatus(tag names.FilesystemTag) (StatusInfo, error) { return getStatus(st, filesystemGlobalKey(tag.Id()), "filesystem") }
// SetFilesystemAttachmentInfo sets the FilesystemAttachmentInfo for the // specified filesystem attachment. func (st *State) SetFilesystemAttachmentInfo( machineTag names.MachineTag, filesystemTag names.FilesystemTag, info FilesystemAttachmentInfo, ) (err error) { defer errors.DeferredAnnotatef(&err, "cannot set info for filesystem attachment %s:%s", filesystemTag.Id(), machineTag.Id()) f, err := st.Filesystem(filesystemTag) if err != nil { return errors.Trace(err) } // Ensure filesystem is provisioned before setting attachment info. // A filesystem cannot go from being provisioned to unprovisioned, // so there is no txn.Op for this below. if _, err := f.Info(); err != nil { return errors.Trace(err) } // Also ensure the machine is provisioned. m, err := st.Machine(machineTag.Id()) if err != nil { return errors.Trace(err) } if _, err := m.InstanceId(); err != nil { return errors.Trace(err) } buildTxn := func(attempt int) ([]txn.Op, error) { fsa, err := st.FilesystemAttachment(machineTag, filesystemTag) if err != nil { return nil, errors.Trace(err) } // If the filesystem attachment has parameters, unset them // when we set info for the first time, ensuring that params // and info are mutually exclusive. _, unsetParams := fsa.Params() ops := setFilesystemAttachmentInfoOps(machineTag, filesystemTag, info, unsetParams) return ops, nil } return st.run(buildTxn) }
func (s *tmpfsFilesystemSource) filesystemInfoFile(tag names.FilesystemTag) string { return filepath.Join(s.storageDir, tag.Id()+".info") }
func (st *State) filesystemByTag(tag names.FilesystemTag) (*filesystem, error) { query := bson.D{{"_id", tag.Id()}} description := fmt.Sprintf("filesystem %q", tag.Id()) return st.filesystem(query, description) }
// RemoveFilesystemAttachment removes the filesystem attachment from state. // Removing a volume-backed filesystem attachment will cause the volume to // be detached. func (st *State) RemoveFilesystemAttachment(machine names.MachineTag, filesystem names.FilesystemTag) (err error) { defer errors.DeferredAnnotatef(&err, "removing attachment of filesystem %s from machine %s", filesystem.Id(), machine.Id()) buildTxn := func(attempt int) ([]txn.Op, error) { attachment, err := st.FilesystemAttachment(machine, filesystem) if errors.IsNotFound(err) && attempt > 0 { // We only ignore IsNotFound on attempts after the // first, since we expect the filesystem attachment to // be there initially. return nil, jujutxn.ErrNoOperations } if err != nil { return nil, errors.Trace(err) } if attachment.Life() != Dying { return nil, errors.New("filesystem attachment is not dying") } f, err := st.filesystemByTag(filesystem) if err != nil { return nil, errors.Trace(err) } ops := removeFilesystemAttachmentOps(machine, f) // If the filesystem is backed by a volume, the volume // attachment can and should be destroyed once the // filesystem attachment is removed. volumeAttachment, err := st.filesystemVolumeAttachment(machine, filesystem) if err != nil { if errors.Cause(err) != ErrNoBackingVolume && !errors.IsNotFound(err) { return nil, errors.Trace(err) } } else if volumeAttachment.Life() == Alive { ops = append(ops, detachVolumeOps(machine, volumeAttachment.Volume())...) } return ops, nil } return st.run(buildTxn) }