func TestGetMachinesByUsernameAndProvider(t *testing.T) {
db := modeltesthelper.NewMongoDB(t)
defer db.Close()
user := &models.User{Name: "testuser", ObjectId: bson.NewObjectId()}
defer modelhelper.RemoveUser(user.Name)
if err := modelhelper.CreateUser(user); err != nil {
t.Error(err)
}
// koding provider machine
m1 := &models.Machine{
ObjectId: bson.NewObjectId(),
Uid: bson.NewObjectId().Hex(),
Provider: "koding",
Users: []models.MachineUser{
{Id: user.ObjectId, Owner: true},
},
}
if err := modelhelper.CreateMachine(m1); err != nil {
t.Errorf(err.Error())
}
defer modelhelper.DeleteMachine(m1.ObjectId)
// non koding provider machine
m2 := &models.Machine{
ObjectId: bson.NewObjectId(),
Uid: bson.NewObjectId().Hex(),
Provider: "amazon",
Users: []models.MachineUser{
{Id: user.ObjectId, Owner: true},
},
}
if err := modelhelper.CreateMachine(m2); err != nil {
t.Errorf(err.Error())
}
defer modelhelper.DeleteMachine(m2.ObjectId)
// should only get koding provider machine
machines, err := modelhelper.GetMachinesByUsernameAndProvider(user.Name, m1.Provider)
if err != nil {
t.Error(err.Error())
}
if len(machines) != 1 {
t.Errorf("machine count should be 2, got: %d", len(machines))
}
}
func createMachine(t *testing.T) *models.Machine {
m := &models.Machine{
ObjectId: bson.NewObjectId(),
Uid: bson.NewObjectId().Hex(),
QueryString: (&protocol.Kite{ID: uuid.NewV4().String()}).String(),
IpAddress: utils.RandomString(),
RegisterURL: (&url.URL{
Scheme: "http",
Host: utils.RandomString() + ":56789",
Path: "/kite",
}).String(),
Provider: "koding",
Users: []models.MachineUser{
// real owner
{
Id: bson.NewObjectId(),
Sudo: true,
Owner: true,
Username: "******",
},
// secondary owner
{
Id: bson.NewObjectId(),
Sudo: false,
Owner: true,
},
// has sudo but not owner
{
Id: bson.NewObjectId(),
Sudo: true,
Owner: false,
},
// random user
{
Id: bson.NewObjectId(),
Sudo: false,
Owner: false,
},
},
CreatedAt: time.Now().UTC(),
Status: models.MachineStatus{
State: "running",
ModifiedAt: time.Now().UTC(),
},
Assignee: models.MachineAssignee{},
UserDeleted: false,
}
err := modelhelper.CreateMachine(m)
if err != nil {
t.Errorf("createMachine()=%s", err)
}
return m
}
// InsertMachine inserts the machine to DB and requests kloud to build it.
func (spec *MachineSpec) InsertMachine() error {
if spec.Machine.ObjectId.Valid() {
DefaultUi.Info(fmt.Sprintf("machine %q is going to be rebuilt", spec.Machine.ObjectId.Hex()))
return nil
}
user := spec.Machine.Users[0]
spec.Machine.ObjectId = bson.NewObjectId()
spec.Machine.CreatedAt = time.Now()
spec.Machine.Status.ModifiedAt = time.Now()
spec.Machine.Assignee.AssignedAt = time.Now()
spec.Machine.Credential = user.Username
spec.Machine.Uid = spec.finalizeUID()
spec.Machine.Domain = spec.Domain()
spec.Machine.Groups = nil
err := modelhelper.CreateMachine(&spec.Machine)
if err != nil {
return err
}
return nil
}
func testFixture(t *testing.T) (*models.User, *models.Group, *models.Machine, *models.Account, func()) {
var c cleaner
user := &models.User{
ObjectId: bson.NewObjectId(),
Name: "testuser",
}
if err := modelhelper.CreateUser(user); err != nil {
c.clean()
t.Fatalf("error creating user: %s", err)
}
c.add(user)
account := &models.Account{
Id: bson.NewObjectId(),
Profile: models.AccountProfile{
Nickname: user.Name,
FirstName: bson.NewObjectId().Hex(),
LastName: bson.NewObjectId().Hex(),
},
Type: "registered",
}
if err := modelhelper.CreateAccount(account); err != nil {
c.clean()
t.Fatalf("error creating account: %s", err)
}
c.add(account)
group, err := createGroup()
if err != nil {
c.clean()
t.Fatalf("error creating group: %s", err)
}
c.add(group)
machine := &models.Machine{
ObjectId: bson.NewObjectId(),
Uid: bson.NewObjectId().Hex(),
Provider: "koding",
Users: []models.MachineUser{
{
Id: user.ObjectId,
Owner: true,
},
},
}
if err := modelhelper.CreateMachine(machine); err != nil {
c.clean()
t.Fatalf("error creating machine: %s", err)
}
c.add(machine)
return user, group, machine, account, c.clean
}
func prepareMongoMachines() error {
userIDs := map[string]bson.ObjectId{}
for _, u := range []string{bober, john, blaster} {
user, _, err := modeltesthelper.CreateUser(u)
if err != nil {
return err
}
userIDs[u] = user.ObjectId
}
machines := []*models.Machine{
&models.Machine{
ObjectId: boberAws0,
IpAddress: "127.0.0.1",
Provider: "aws",
Label: "bober-aws-0",
Users: []models.MachineUser{
{
Id: userIDs[bober],
Sudo: true,
Owner: true,
Username: bober,
},
},
Status: models.MachineStatus{
State: "running",
Reason: "because it can",
},
GeneratedFrom: &models.MachineGeneratedFrom{
TemplateId: boberStack,
},
},
&models.Machine{
ObjectId: boberAws1,
Label: "bober-aws-1",
Users: []models.MachineUser{
{
Id: userIDs[bober],
Sudo: true,
Owner: true,
Username: bober,
},
{
Id: userIDs[john],
Approved: true,
Username: john,
},
{
Id: userIDs[blaster],
Approved: true,
Username: blaster,
},
},
GeneratedFrom: &models.MachineGeneratedFrom{
TemplateId: boberStack,
},
},
&models.Machine{
ObjectId: johnGoogle0,
Label: "john-google-0",
Users: []models.MachineUser{
{
Id: userIDs[john],
Sudo: true,
Owner: true,
Username: john,
},
{
Id: userIDs[bober],
Approved: true,
Username: bober,
},
{
Id: userIDs[blaster],
Username: blaster,
},
},
GeneratedFrom: &models.MachineGeneratedFrom{
TemplateId: johnStack,
},
},
&models.Machine{
ObjectId: blasterAws0,
Label: "blaster-aws-0",
Users: []models.MachineUser{
{
Id: userIDs[blaster],
Sudo: true,
Owner: true,
Username: blaster,
},
},
GeneratedFrom: &models.MachineGeneratedFrom{
TemplateId: blasterStack,
},
},
&models.Machine{
ObjectId: allKoding0,
Provider: modelhelper.MachineProviderKoding,
Users: []models.MachineUser{
{
Id: userIDs[blaster],
Sudo: true,
Owner: true,
Username: blaster,
},
},
},
}
for _, m := range machines {
if err := modelhelper.CreateMachine(m); err != nil {
return err
}
}
return nil
}
func prepareSingleWorkspace(creator, participant1, participant2 *socialapimodels.Account) (
*mongomodels.Machine, // m1
*mongomodels.Workspace, // m1 ws1
) {
ownerUser, err := modelhelper.GetUserByAccountId(creator.OldId)
So(err, ShouldBeNil)
participant1User, err := modelhelper.GetUserByAccountId(participant1.OldId)
So(err, ShouldBeNil)
participant2User, err := modelhelper.GetUserByAccountId(participant2.OldId)
So(err, ShouldBeNil)
// sample machine struct
m1 := &mongomodels.Machine{
ObjectId: bson.NewObjectId(),
Uid: bson.NewObjectId().Hex(),
Users: []mongomodels.MachineUser{
{ // real owner
Id: ownerUser.ObjectId,
Sudo: true,
Owner: true,
},
{ // secondary owner
Id: participant1User.ObjectId,
Sudo: false,
Owner: true,
Permanent: false,
},
{ // random
Id: participant2User.ObjectId,
Sudo: false,
Owner: true,
Permanent: false,
},
},
CreatedAt: time.Now().UTC(),
Status: mongomodels.MachineStatus{
State: "running",
ModifiedAt: time.Now().UTC(),
},
Assignee: mongomodels.MachineAssignee{},
UserDeleted: false,
}
So(modelhelper.CreateMachine(m1), ShouldBeNil)
//
// create the first channel
//
c1 := socialapimodels.NewChannel() // init channel
c1.CreatorId = creator.Id // set Creator id
c1.TypeConstant = socialapimodels.Channel_TYPE_COLLABORATION
So(c1.Create(), ShouldBeNil)
c1p1, err := c1.AddParticipant(creator.Id)
So(err, ShouldBeNil)
So(c1p1, ShouldNotBeNil)
c1p2, err := c1.AddParticipant(participant1.Id)
So(err, ShouldBeNil)
So(c1p2, ShouldNotBeNil)
c1p3, err := c1.AddParticipant(participant2.Id)
So(err, ShouldBeNil)
So(c1p3, ShouldNotBeNil)
m1ws1 := &mongomodels.Workspace{
ObjectId: bson.NewObjectId(),
OriginId: bson.ObjectIdHex(creator.OldId),
Name: "My Workspace",
Slug: "m1ws1",
ChannelId: strconv.FormatInt(c1.Id, 10),
MachineUID: m1.Uid,
MachineLabel: "koding-vm-0",
Owner: "cihangir",
RootPath: "/home/cihangir",
IsDefault: true,
}
So(modelhelper.CreateWorkspace(m1ws1), ShouldBeNil)
return m1, m1ws1
}
func CreateUser(opts *UserOptions) (*User, error) {
username := opts.Username
groupname := opts.Groupname
provider := opts.Provider
template := opts.Template
privateKey, publicKey, err := sshutil.TemporaryKey()
if err != nil {
return nil, err
}
labels, err := machineLabels([]byte(template))
if err != nil {
return nil, err
}
relationExists := true
// jAccounts
account, err := modelhelper.GetAccount(username)
if err == mgo.ErrNotFound {
relationExists = false
account = &models.Account{
Id: bson.NewObjectId(),
Profile: models.AccountProfile{
Nickname: username,
},
}
err = modelhelper.CreateAccount(account)
}
if err != nil {
return nil, errors.New("failure looking up jAccounts: " + err.Error())
}
// jGroups
group, err := modelhelper.GetGroup(groupname)
if err == mgo.ErrNotFound {
relationExists = false
group = &models.Group{
Id: bson.NewObjectId(),
Title: groupname,
Slug: groupname,
}
err = modelhelper.CreateGroup(group)
}
if err != nil {
return nil, errors.New("failure looking up jGroups: " + err.Error())
}
if !relationExists {
// add relation between use and group
relationship := &models.Relationship{
Id: bson.NewObjectId(),
TargetId: account.Id,
TargetName: "JAccount",
SourceId: group.Id,
SourceName: "JGroup",
As: "member",
}
err := modelhelper.AddRelationship(relationship)
if err != nil {
return nil, errors.New("failure insering relationship: " + err.Error())
}
}
// jUsers
user, err := modelhelper.GetUser(username)
if err == nil && len(user.SshKeys) != 0 {
publicKey = user.SshKeys[0].Key
}
if err == mgo.ErrNotFound {
user = &models.User{
ObjectId: bson.NewObjectId(),
Email: username + "@" + username + ".com",
LastLoginDate: time.Now().UTC(),
RegisteredAt: time.Now().UTC(),
Name: username, // bson equivelant is username
Password: "******",
Status: "confirmed",
SshKeys: []struct {
Title string `bson:"title"`
Key string `bson:"key"`
}{
{Key: publicKey},
},
}
err = modelhelper.CreateUser(user)
}
if err != nil {
return nil, errors.New("failure looking up jUsers: " + err.Error())
}
queryString := protocol.Kite{ID: opts.KlientID}.String()
cred := &models.Credential{
Id: bson.NewObjectId(),
Provider: opts.Provider,
Identifier: bson.NewObjectId().Hex(),
OriginId: account.Id,
}
credData := &models.CredentialData{
Id: bson.NewObjectId(),
Identifier: cred.Identifier,
OriginId: account.Id,
Meta: bson.M{
"queryString": queryString,
"memory": 0,
"cpu": 0,
"box": "",
},
}
if err := modelhelper.InsertCredential(cred, credData); err != nil {
return nil, err
}
relationship := &models.Relationship{
Id: bson.NewObjectId(),
TargetId: cred.Id,
TargetName: "JCredential",
SourceId: account.Id,
SourceName: "JAccount",
As: "owner",
}
if err := modelhelper.AddRelationship(relationship); err != nil {
return nil, err
}
// jComputeStack and jStackTemplates
stackTemplateId := bson.NewObjectId()
stackTemplate := &models.StackTemplate{
Id: stackTemplateId,
Credentials: map[string][]string{
"vagrant": {cred.Identifier},
},
}
stackTemplate.Template.Content = template
if err := modelhelper.CreateStackTemplate(stackTemplate); err != nil {
return nil, err
}
// later we can add more users with "Owner:false" to test sharing capabilities
users := []models.MachineUser{
{Id: user.ObjectId, Sudo: true, Owner: true},
}
machineIds := make([]bson.ObjectId, len(labels))
for i, label := range labels {
machineId := bson.NewObjectId()
machine := &models.Machine{
ObjectId: machineId,
Label: label,
Domain: username + ".dev.koding.io",
Provider: provider,
CreatedAt: time.Now().UTC(),
Users: users,
Meta: make(bson.M, 0),
Groups: make([]models.MachineGroup, 0),
Credential: username,
}
machine.Assignee.InProgress = false
machine.Assignee.AssignedAt = time.Now().UTC()
machine.Status.State = machinestate.NotInitialized.String()
machine.Status.ModifiedAt = time.Now().UTC()
machineIds[i] = machine.ObjectId
if err := modelhelper.CreateMachine(machine); err != nil {
return nil, err
}
}
computeStackID := bson.NewObjectId()
computeStack := &models.ComputeStack{
Id: computeStackID,
BaseStackId: stackTemplateId,
Machines: machineIds,
}
if err := modelhelper.CreateComputeStack(computeStack); err != nil {
return nil, err
}
return &User{
MachineIDs: machineIds,
MachineLabels: labels,
StackID: computeStackID.Hex(),
StackTemplateID: stackTemplate.Id.Hex(),
AccountID: account.Id,
CredID: cred.Id.Hex(),
CredDataID: credData.Id.Hex(),
PrivateKey: privateKey,
PublicKey: publicKey,
Identifiers: []string{cred.Identifier},
}, nil
}