func (uis *UIServer) getSpawnedHosts(w http.ResponseWriter, r *http.Request) {
user := MustHaveUser(r)
hosts, err := host.Find(host.ByUserWithRunningStatus(user.Username()))
if err != nil {
uis.LoggedError(w, r, http.StatusInternalServerError,
fmt.Errorf("Error finding running hosts for user %v: %v", user.Username(), err))
return
}
uis.WriteJSON(w, http.StatusOK, hosts)
}
func getHostsData(includeSpawnedHosts bool) (*hostsData, error) {
data := &hostsData{}
// get all of the hosts
var dbHosts []host.Host
var err error
if includeSpawnedHosts {
dbHosts, err = host.Find(host.IsRunning)
} else {
dbHosts, err = host.Find(host.ByUserWithRunningStatus(evergreen.User))
}
if err != nil {
return nil, err
}
// convert the hosts to the ui models
uiHosts := make([]uiHost, len(dbHosts))
for idx, dbHost := range dbHosts {
// we only need the distro id for the hosts page
dbHost.Distro = distro.Distro{Id: dbHost.Distro.Id}
host := uiHost{
Host: dbHost,
RunningTask: nil,
}
uiHosts[idx] = host
// get the task running on this host
task, err := model.FindTask(dbHost.RunningTask)
if err != nil {
return nil, err
}
if task != nil {
uiHosts[idx].RunningTask = task
}
}
data.Hosts = uiHosts
return data, nil
}
// Validate returns an instance of BadOptionsErr if the SpawnOptions object contains invalid
// data, SpawnLimitErr if the user is already at the spawned host limit, or some other untyped
// instance of Error if something fails during validation.
func (sm Spawn) Validate(so Options) error {
d, err := distro.FindOne(distro.ById(so.Distro))
if err != nil {
return BadOptionsErr{fmt.Sprintf("Invalid dist %v", so.Distro)}
}
if !d.SpawnAllowed {
return BadOptionsErr{fmt.Sprintf("Spawning not allowed for dist %v", so.Distro)}
}
// if the user already has too many active spawned hosts, deny the request
activeSpawnedHosts, err := host.Find(host.ByUserWithRunningStatus(so.UserName))
if err != nil {
return fmt.Errorf("Error occurred finding user's current hosts: %v", err)
}
if len(activeSpawnedHosts) >= MaxPerUser {
return SpawnLimitErr
}
// validate public key
rsa := "ssh-rsa"
dss := "ssh-dss"
isRSA := strings.HasPrefix(so.PublicKey, rsa)
isDSS := strings.HasPrefix(so.PublicKey, dss)
if !isRSA && !isDSS {
return BadOptionsErr{"key does not start with ssh-rsa or ssh-dss"}
}
sections := strings.Split(so.PublicKey, " ")
if len(sections) < 2 {
keyType := rsa
if sections[0] == dss {
keyType = dss
}
return BadOptionsErr{fmt.Sprintf("missing space after '%v'", keyType)}
}
// check for valid base64
if _, err = base64.StdEncoding.DecodeString(sections[1]); err != nil {
return BadOptionsErr{"key contains invalid base64 string"}
}
if d.UserData.File != "" {
if strings.TrimSpace(so.UserData) == "" {
return BadOptionsErr{}
}
var err error
switch d.UserData.Validate {
case distro.UserDataFormatFormURLEncoded:
_, err = url.ParseQuery(so.UserData)
case distro.UserDataFormatJSON:
var out map[string]interface{}
err = json.Unmarshal([]byte(so.UserData), &out)
case distro.UserDataFormatYAML:
var out map[string]interface{}
err = yaml.Unmarshal([]byte(so.UserData), &out)
}
if err != nil {
return BadOptionsErr{fmt.Sprintf("invalid %v: %v", d.UserData.Validate, err)}
}
}
return nil
}