//ValidEntity validates Host fields
func (h *Host) ValidEntity() error {
glog.V(4).Info("Validating host")
//if err := validation.ValidHostID(entity.ID); err != nil {
// return fmt.Errorf("invalid hostid:'%s' for host Name:'%s' IP:%s", entity.ID, entity.Name, entity.IPAddr)
//}
trimmedID := strings.TrimSpace(h.ID)
violations := validation.NewValidationError()
violations.Add(validation.NotEmpty("Host.ID", h.ID))
violations.Add(validation.ValidHostID(h.ID))
violations.Add(validation.StringsEqual(h.ID, trimmedID, "leading and trailing spaces not allowed for host id"))
violations.Add(validation.ValidPort(h.RPCPort))
violations.Add(validation.NotEmpty("Host.PoolID", h.PoolID))
violations.Add(validation.IsIP(h.IPAddr))
//TODO: what should we be validating here? It doesn't seem to work for
glog.V(4).Infof("Validating IPAddr %v for host %s", h.IPAddr, h.ID)
ipAddr, err := net.ResolveIPAddr("ip4", h.IPAddr)
if err != nil {
glog.Errorf("Could not resolve: %s to an ip4 address: %v", h.IPAddr, err)
violations.Add(err)
} else if ipAddr.IP.IsLoopback() {
glog.Errorf("Can not use %s as host address because it is a loopback address", h.IPAddr)
violations.Add(errors.New("host ip can not be a loopback address"))
}
if len(violations.Errors) > 0 {
return violations
}
return nil
}
//ValidEntity validates Host fields
func (p *ResourcePool) ValidEntity() error {
glog.V(4).Info("Validating ResourcePool")
trimmedID := strings.TrimSpace(p.ID)
violations := validation.NewValidationError()
violations.Add(validation.NotEmpty("Pool.ID", p.ID))
violations.Add(validation.StringsEqual(p.ID, trimmedID, "leading and trailing spaces not allowed for pool id"))
trimmedRealm := strings.TrimSpace(p.Realm)
violations.Add(validation.NotEmpty("Pool.Realm", p.Realm))
violations.Add(validation.StringsEqual(p.Realm, trimmedRealm, "leading and trailing spaces not allowed for pool realm"))
if len(violations.Errors) > 0 {
return violations
}
return nil
}
//ValidEntity validates Host fields
func (u *User) ValidEntity() error {
glog.V(4).Info("Validating User")
trimmed := strings.TrimSpace(u.Name)
violations := validation.NewValidationError()
violations.Add(validation.NotEmpty("User.Name", u.Name))
violations.Add(validation.StringsEqual(u.Name, trimmed, "leading and trailing spaces not allowed for user name"))
violations.Add(validation.NotEmpty("User.Password", u.Password))
if len(violations.Errors) > 0 {
return violations
}
return nil
}
// Mount attempts to mount the nfsPath to the localPath
func Mount(driver Driver, remotePath, localPath string) error {
// check if the driver is installed
if err := driver.Installed(); err != nil {
return err
}
// validate that the remote path
if ok := func(remotePath string) bool {
parts := strings.Split(remotePath, ":")
if len(parts) != 2 {
return false
}
ip := net.ParseIP(parts[0])
if ip == nil {
return false
}
dest := filepath.Clean(parts[1])
return dest != "/" && filepath.IsAbs(dest)
}(remotePath); !ok {
return ErrMalformedNFSMountpoint
}
var mountInfo proc.NFSMountInfo
mountError := driver.Info(localPath, &mountInfo)
if mountError == proc.ErrMountPointNotFound {
// the mountpoint is not found so try to mount
glog.Infof("Creating new mount for %s -> %s", remotePath, localPath)
if err := driver.Mount(remotePath, localPath, time.Second*30); err != nil {
glog.Errorf("Error while creating mount point for %s -> %s: %s", remotePath, localPath, err)
return err
}
// get the mount point
mountError = driver.Info(localPath, &mountInfo)
}
if mountError != nil {
// we should have a mount point by now or bust
glog.Errorf("Could not get volume info for %s (mounting from %s): %s", localPath, remotePath, mountError)
return mountError
}
// validate mount info
glog.Infof("Mount Info: %+v", mountInfo)
verr := validation.NewValidationError()
verr.Add(validation.StringsEqual(remotePath, mountInfo.RemotePath, ""))
verr.Add(validation.StringsEqual("nfs4", mountInfo.FSType, fmt.Sprintf("%s not mounted nfs4, %s instead", mountInfo.LocalPath, mountInfo.FSType)))
verr.Add(func(fsid string) error {
if fsiduint, err := strconv.ParseUint(fsid, 16, 64); err != nil || fsiduint == 0 {
return fmt.Errorf("invalid fsid: %s", fsid)
}
return nil
}(mountInfo.FSID))
if verr.HasError() {
// the mountpoint is stale or wrong, so unmount
glog.Warningf("Stale mount point at %s (mounting %s)", localPath, remotePath)
if err := driver.Unmount(localPath); err != nil {
glog.Errorf("Could not unmount %s: %s", localPath, err)
}
return verr
}
return nil
}