func (cmd *GroupStack) details(username string) (*modelhelper.StackDetails, error) {
user, err := modelhelper.GetUser(username)
if err != nil {
return nil, fmt.Errorf("unable to find a user %q: %s", username, err)
}
group, err := modelhelper.GetGroup(cmd.groupSlug)
if err != nil {
return nil, fmt.Errorf("unable to find a group %q: %s", cmd.groupSlug, err)
}
machine, err := modelhelper.GetMachineBySlug(user.ObjectId, cmd.machineSlug)
if err != nil {
return nil, fmt.Errorf("unable to find a machine slug=%q, userID=%q: %s", cmd.machineSlug, user.ObjectId.Hex(), err)
}
account, err := modelhelper.GetAccount(username)
if err != nil {
return nil, fmt.Errorf("unable to find an account for %q: %s", username, err)
}
sd := &modelhelper.StackDetails{
UserID: user.ObjectId,
AccountID: account.Id,
GroupID: group.Id,
UserName: user.Name,
GroupSlug: group.Slug,
MachineID: machine.ObjectId,
BaseID: bson.ObjectIdHex(cmd.baseID),
}
return sd, nil
}
func (cmd *GroupFixDomain) fixDomain(user string) (*dnsclient.Record, bson.ObjectId, error) {
u, err := modelhelper.GetUser(user)
if err != nil {
return nil, "", err
}
m, err := modelhelper.GetMachineBySlug(u.ObjectId, cmd.machine)
if err != nil {
return nil, "", fmt.Errorf("fixing failed for %q user: %s", user, err)
}
if m.IpAddress == "" {
return nil, "", errors.New("no ip address found for: " + user)
}
base := dnsZones[cmd.env]
if strings.HasSuffix(m.Domain, base) {
return nil, "", nil
}
if cmd.dry && m.State() != machinestate.Running {
DefaultUi.Warn(fmt.Sprintf("machine %q of user %q is not running (%s)",
m.ObjectId.Hex(), user, m.State()))
}
s := m.Domain
if i := strings.Index(s, user); i != -1 {
s = s[i+len(user):] + "." + base
}
return &dnsclient.Record{
Name: s,
IP: m.IpAddress,
Type: "A",
TTL: 300,
}, m.ObjectId, nil
}
// BuildMachine ensures the user and group of the spec are
// inserted into db.
func (spec *MachineSpec) BuildMachine(createUser bool) error {
// If MachineID is not nil, ensure it exists and reuse it if it does.
if spec.HasMachine() {
m, err := modelhelper.GetMachine(spec.Machine.ObjectId.Hex())
if err != nil {
return err
}
spec.Machine = *m
return nil
}
// If no existing group is provided, create or use 'hackathon' one,
// which will make VMs invisible to users until they're assigned
// to proper group before the hackathon.
if !spec.HasGroup() {
group, err := modelhelper.GetGroup("koding")
if err != nil {
return err
}
spec.Machine.Groups = []models.MachineGroup{{Id: group.Id}}
}
// If no existing user is provided, create one.
if !spec.HasUser() {
// Try to lookup user by username first.
user, err := modelhelper.GetUser(spec.Username())
if err != nil {
if !createUser {
return fmt.Errorf("user %q does not exist", spec.Username())
}
spec.User.ObjectId = bson.NewObjectId()
if spec.User.RegisteredAt.IsZero() {
spec.User.RegisteredAt = time.Now()
}
if spec.User.LastLoginDate.IsZero() {
spec.User.LastLoginDate = spec.User.RegisteredAt
}
if err = modelhelper.CreateUser(&spec.User); err != nil {
return err
}
user = &spec.User
}
spec.User.ObjectId = user.ObjectId
spec.User.Name = spec.Username()
}
// Ensure the user is assigned to the machine.
if len(spec.Machine.Users) == 0 {
spec.Machine.Users = []models.MachineUser{{
Sudo: true,
Owner: true,
}}
}
if spec.Machine.Users[0].Id == "" {
spec.Machine.Users[0].Id = spec.User.ObjectId
}
if spec.Machine.Users[0].Username == "" {
spec.Machine.Users[0].Username = spec.User.Name
}
// Lookup username for existing user.
if spec.Machine.Users[0].Username == "" {
user, err := modelhelper.GetUserById(spec.Machine.Users[0].Id.Hex())
if err != nil {
return err
}
spec.Machine.Users[0].Username = user.Name
}
// Lookup group and init Uid.
group, err := modelhelper.GetGroupById(spec.Machine.Groups[0].Id.Hex())
if err != nil {
return err
}
spec.Machine.Uid = fmt.Sprintf("u%c%c%c",
spec.Machine.Users[0].Username[0],
group.Slug[0],
spec.Machine.Provider[0],
)
m, err := modelhelper.GetMachineBySlug(spec.Machine.Users[0].Id, spec.Machine.Slug)
if err == mgo.ErrNotFound {
return nil
}
if err != nil {
return err
}
switch m.State() {
case machinestate.Building, machinestate.Starting:
return ErrAlreadyBuilding
case machinestate.Running:
return ErrAlreadyRunning
case machinestate.NotInitialized:
spec.Machine.ObjectId = m.ObjectId
return ErrRebuild
default:
return fmt.Errorf("machine state is %q; needs to be deleted and build "+
"again (jMachine.ObjectId = %q)", m.State(), m.ObjectId.Hex())
}
}