func TestActorClient(t *testing.T) {
config.Config.UseAuth = true
indexer.Initialize(config.Config)
c, _ := client.New("fooclient")
gob.Register(c)
c.Save()
c1, err := GetReqUser("fooclient")
if err != nil {
t.Errorf(err.Error())
}
y := c1.IsSelf(c)
if y == false {
t.Errorf("self not equal to self")
}
c2, _ := client.New("foo2client")
y = c1.IsSelf(c2)
if y != false {
t.Errorf("client %s was equal to client %s, but should not have been", c1.GetName(), c2.Name)
}
u, _ := user.New("foouser")
gob.Register(u)
u.Save()
y = c1.IsSelf(u)
if y != false {
t.Errorf("client %s was equal to user %s, but should not have been", c1.GetName(), u.Username)
}
c.Delete()
c2.Delete()
u.Delete()
}
func TestGobEncodeDecode(t *testing.T) {
indexer.Initialize(config.Config)
c, _ := New("foo")
saved := new(bytes.Buffer)
var err error
enc := gob.NewEncoder(saved)
defer func() {
if x := recover(); x != nil {
err = fmt.Errorf("Something went wrong encoding the data store with Gob")
}
}()
err = enc.Encode(c)
if err != nil {
t.Errorf(err.Error())
}
dec := gob.NewDecoder(saved)
c2 := new(Client)
err = dec.Decode(&c2)
if err != nil {
t.Errorf(err.Error())
}
if c2.Name != c.Name {
t.Errorf("saved user doesn't seem to be equal to original: %v vs %v", c2, c)
}
}
func TestShoveyCreation(t *testing.T) {
indexer.Initialize(config.Config)
nn := new(node.Node)
ns := new(node.NodeStatus)
gob.Register(nn)
gob.Register(ns)
nodes := make([]*node.Node, 5)
nodeNames := make([]string, 5)
for i := 0; i < 5; i++ {
n, _ := node.New(fmt.Sprintf("node-shove-%d", i))
n.Save()
err := n.UpdateStatus("up")
if err != nil {
t.Errorf(err.Error())
}
n.Save()
nodes[i] = n
nodeNames[i] = n.Name
}
z := new(Shovey)
zz := new(ShoveyRun)
gob.Register(z)
gob.Register(zz)
s, err := New("/bin/ls", 300, "100%", nodeNames)
if err != nil {
t.Errorf(err.Error())
}
s2, err := Get(s.RunID)
if err != nil {
t.Errorf(err.Error())
}
if s.RunID != s2.RunID {
t.Errorf("Run IDs should have been equal, but weren't. Got %s and %s", s.RunID, s2.RunID)
}
//err = s.Cancel()
//if err != nil {
// t.Errorf(err.Error())
//}
}
func TestActionAtADistance(t *testing.T) {
indexer.Initialize(config.Config)
n, _ := New("foo2")
gob.Register(n)
n.Normal["foo"] = "bar"
n.Save()
n2, _ := Get("foo2")
if n.Name != n2.Name {
t.Errorf("Node names should have been the same, but weren't, got %s and %s", n.Name, n2.Name)
}
if n.Normal["foo"] != n2.Normal["foo"] {
t.Errorf("Normal attribute 'foo' should have been equal between the two copies of the node, but weren't.")
}
n2.Normal["foo"] = "blerp"
if n.Normal["foo"] == n2.Normal["foo"] {
t.Errorf("Normal attribute 'foo' should not have been equal between the two copies of the node, but were.")
}
n2.Save()
n3, _ := Get("foo2")
if n3.Normal["foo"] != n2.Normal["foo"] {
t.Errorf("Normal attribute 'foo' should have been equal between the two copies of the node after saving a second time, but weren't.")
}
}
func main() {
config.ParseConfigOptions()
/* Here goes nothing, db... */
if config.UsingDB() {
var derr error
if config.Config.UseMySQL {
datastore.Dbh, derr = datastore.ConnectDB("mysql", config.Config.MySQL)
} else if config.Config.UsePostgreSQL {
datastore.Dbh, derr = datastore.ConnectDB("postgres", config.Config.PostgreSQL)
}
if derr != nil {
logger.Criticalf(derr.Error())
os.Exit(1)
}
}
gobRegister()
ds := datastore.New()
indexer.Initialize(config.Config)
if config.Config.FreezeData {
if config.Config.DataStoreFile != "" {
uerr := ds.Load(config.Config.DataStoreFile)
if uerr != nil {
logger.Criticalf(uerr.Error())
os.Exit(1)
}
}
ierr := indexer.LoadIndex()
if ierr != nil {
logger.Criticalf(ierr.Error())
os.Exit(1)
}
}
setSaveTicker()
setLogEventPurgeTicker()
/* handle import/export */
if config.Config.DoExport {
fmt.Printf("Exporting data to %s....\n", config.Config.ImpExFile)
err := exportAll(config.Config.ImpExFile)
if err != nil {
logger.Criticalf("Something went wrong during the export: %s", err.Error())
os.Exit(1)
}
fmt.Println("All done!")
os.Exit(0)
} else if config.Config.DoImport {
fmt.Printf("Importing data from %s....\n", config.Config.ImpExFile)
err := importAll(config.Config.ImpExFile)
if err != nil {
logger.Criticalf("Something went wrong during the import: %s", err.Error())
os.Exit(1)
}
if config.Config.FreezeData {
if config.Config.DataStoreFile != "" {
ds := datastore.New()
if err := ds.Save(config.Config.DataStoreFile); err != nil {
logger.Errorf(err.Error())
}
}
if err := indexer.SaveIndex(); err != nil {
logger.Errorf(err.Error())
}
}
if config.UsingDB() {
datastore.Dbh.Close()
}
fmt.Println("All done.")
os.Exit(0)
}
/* Set up serf */
if config.Config.UseSerf {
serferr := serfin.StartSerfin()
if serferr != nil {
logger.Criticalf(serferr.Error())
os.Exit(1)
}
errch := make(chan error)
go startEventMonitor(serfin.Serfer, errch)
err := <-errch
if err != nil {
logger.Criticalf(err.Error())
os.Exit(1)
}
startNodeMonitor()
}
/* Create default clients and users. Currently chef-validator,
* chef-webui, and admin. */
createDefaultActors()
handleSignals()
/* Register the various handlers, found in their own source files. */
http.HandleFunc("/authenticate_user", authenticateUserHandler)
http.HandleFunc("/clients", listHandler)
http.HandleFunc("/clients/", clientHandler)
http.HandleFunc("/cookbooks", cookbookHandler)
http.HandleFunc("/cookbooks/", cookbookHandler)
http.HandleFunc("/data", dataHandler)
http.HandleFunc("/data/", dataHandler)
http.HandleFunc("/environments", environmentHandler)
http.HandleFunc("/environments/", environmentHandler)
http.HandleFunc("/nodes", listHandler)
http.HandleFunc("/nodes/", nodeHandler)
http.HandleFunc("/principals/", principalHandler)
http.HandleFunc("/roles", listHandler)
http.HandleFunc("/roles/", roleHandler)
http.HandleFunc("/sandboxes", sandboxHandler)
http.HandleFunc("/sandboxes/", sandboxHandler)
http.HandleFunc("/search", searchHandler)
http.HandleFunc("/search/", searchHandler)
http.HandleFunc("/search/reindex", reindexHandler)
http.HandleFunc("/users", listHandler)
http.HandleFunc("/users/", userHandler)
http.HandleFunc("/file_store/", fileStoreHandler)
http.HandleFunc("/events", eventListHandler)
http.HandleFunc("/events/", eventHandler)
http.HandleFunc("/reports/", reportHandler)
http.HandleFunc("/universe", universeHandler)
http.HandleFunc("/shovey/", shoveyHandler)
http.HandleFunc("/status/", statusHandler)
/* TODO: figure out how to handle the root & not found pages */
http.HandleFunc("/", rootHandler)
listenAddr := config.ListenAddr()
var err error
srv := &http.Server{Addr: listenAddr, Handler: &interceptHandler{}}
if config.Config.UseSSL {
srv.TLSConfig = &tls.Config{MinVersion: tls.VersionTLS10}
err = srv.ListenAndServeTLS(config.Config.SSLCert, config.Config.SSLKey)
} else {
err = srv.ListenAndServe()
}
if err != nil {
logger.Criticalf("ListenAndServe: %s", err.Error())
os.Exit(1)
}
}
func makeSearchItems() int {
indexer.Initialize(config.Config)
/* Gotta populate the search index */
nodes := make([]*node.Node, 4)
roles := make([]*role.Role, 4)
envs := make([]*environment.ChefEnvironment, 4)
clients := make([]*client.Client, 4)
dbags := make([]*databag.DataBag, 4)
gob.Register(new(node.Node))
gob.Register(new(role.Role))
gob.Register(new(environment.ChefEnvironment))
gob.Register(new(client.Client))
gob.Register(new(databag.DataBag))
// circleci is sometimes weird about the index having everything. This
// *never* comes up locally. ??? Could possibly be because the indexer
// hasn't had a chance to finish indexing?
reindexObjs := make([]indexer.Indexable, 0, 4*5)
for i := 0; i < 4; i++ {
nodes[i], _ = node.New(fmt.Sprintf("node%d", i))
nodes[i].Default["baz"] = fmt.Sprintf("borb")
nodes[i].Default["blurg"] = fmt.Sprintf("b%d", i)
nodes[i].Save()
roles[i], _ = role.New(fmt.Sprintf("role%d", i))
roles[i].Save()
envs[i], _ = environment.New(fmt.Sprintf("env%d", i))
envs[i].Save()
clients[i], _ = client.New(fmt.Sprintf("client%d", i))
clients[i].Save()
dbags[i], _ = databag.New(fmt.Sprintf("databag%d", i))
dbags[i].Save()
dbi := make(map[string]interface{})
dbi["id"] = fmt.Sprintf("dbi%d", i)
dbi["foo"] = fmt.Sprintf("dbag_item_%d", i)
dbags[i].NewDBItem(dbi)
reindexObjs = append(reindexObjs, nodes[i])
reindexObjs = append(reindexObjs, roles[i])
reindexObjs = append(reindexObjs, envs[i])
reindexObjs = append(reindexObjs, clients[i])
dbis, _ := dbags[i].AllDBItems()
for _, d := range dbis {
reindexObjs = append(reindexObjs, d)
}
}
node1 = nodes[0]
node2 = nodes[1]
node3 = nodes[2]
node4 = nodes[3]
role1 = roles[0]
role2 = roles[1]
role3 = roles[2]
role4 = roles[3]
env1 = envs[0]
env2 = envs[1]
env3 = envs[2]
env4 = envs[3]
client1 = clients[0]
client2 = clients[1]
client3 = clients[2]
client4 = clients[3]
dbag1 = dbags[0]
dbag2 = dbags[1]
dbag3 = dbags[2]
dbag4 = dbags[3]
// Let the indexing functions catch up. This has not been a problem in
// The Real World™ (famous last words), but it's *definitely* a problem
// when running go test with GOMAXPROCS > 1.
time.Sleep(1 * time.Second)
/* Make this function return something so the compiler's happy building
* the tests. */
return 1
}
