func main() {
var (
configFile string
dry bool
)
logger, err := syslog.NewLogger(syslog.LOG_INFO, stdlog.LstdFlags)
if err != nil {
stdlog.Fatal(err)
}
log.SetLogger(logger)
flag.StringVar(&configFile, "config", "/etc/tsuru/tsuru.conf", "tsuru config file")
flag.BoolVar(&dry, "dry", false, "dry-run: does not start the agent (for testing purposes)")
flag.Parse()
err = config.ReadConfigFile(configFile)
if err != nil {
fatal(err)
}
connString, err := config.GetString("database:url")
if err != nil {
fatal(err)
}
dbName, err := config.GetString("database:name")
if err != nil {
fatal(err)
}
db.Session, err = db.Open(connString, dbName)
if err != nil {
fatal(err)
}
defer db.Session.Close()
fmt.Printf("Connected to MongoDB server at %s.\n", connString)
fmt.Printf("Using the database %q.\n\n", dbName)
if !dry {
provisioner, err := config.GetString("provisioner")
if err != nil {
fmt.Printf("Warning: %q didn't declare a provisioner, using default provisioner.\n", configFile)
provisioner = "juju"
}
app.Provisioner, err = provision.Get(provisioner)
if err != nil {
fatal(err)
}
fmt.Printf("Using %q provisioner.\n\n", provisioner)
qServer, err := config.GetString("queue-server")
if err != nil {
fatal(err)
}
fmt.Printf("Connected to queue server at %s.\n", qServer)
go handleMessages()
ticker := time.Tick(time.Minute)
fmt.Println("tsuru collector agent started...")
jujuCollect(ticker)
}
}
func (s *S) SetUpSuite(c *C) {
var err error
c.Assert(err, IsNil)
db.Session, err = db.Open("127.0.0.1:27017", "tsuru_service_bind_test")
c.Assert(err, IsNil)
s.user = auth.User{Email: "*****@*****.**"}
s.user.Create()
s.team = auth.Team{Name: "metallica", Users: []string{s.user.Email}}
db.Session.Teams().Insert(s.team)
}
func (s *S) SetUpSuite(c *C) {
var err error
db.Session, err = db.Open("127.0.0.1:27017", "tsuru_collector_test")
c.Assert(err, IsNil)
s.provisioner = ttesting.NewFakeProvisioner()
app.Provisioner = s.provisioner
err = config.ReadConfigFile("../etc/tsuru.conf")
c.Assert(err, IsNil)
config.Set("queue-server", "127.0.0.1:0")
}
func (s *S) SetUpSuite(c *C) {
var err error
s.setupConfig(c)
db.Session, err = db.Open("127.0.0.1:27017", "tsuru_service_consumption_test")
c.Assert(err, IsNil)
s.user = &auth.User{Email: "*****@*****.**", Password: "******"}
err = s.user.Create()
c.Assert(err, IsNil)
s.team = &auth.Team{Name: "Raul", Users: []string{s.user.Email}}
err = db.Session.Teams().Insert(s.team)
c.Assert(err, IsNil)
if err != nil {
c.Fail()
}
}
func BenchmarkUpdate(b *testing.B) {
b.StopTimer()
var err error
db.Session, err = db.Open("127.0.0.1:27017", "collector-benchmark")
if err != nil {
panic(err)
}
defer db.Session.Close()
defer db.Session.Apps().Database.DropDatabase()
_, names := getFakeApps()
defer db.Session.Apps().Remove(bson.M{"name": bson.M{"$in": names}})
fakeUnits := getFakeUnits(names)
b.StartTimer()
for i := 0; i < b.N; i++ {
update(fakeUnits)
}
}
func (s *S) SetUpSuite(c *C) {
var err error
err = config.ReadConfigFile("../etc/tsuru.conf")
c.Assert(err, IsNil)
db.Session, err = db.Open("127.0.0.1:27017", "tsuru_app_test")
c.Assert(err, IsNil)
s.rfs = &fsTesting.RecordingFs{}
file, err := s.rfs.Open("/dev/urandom")
c.Assert(err, IsNil)
file.Write([]byte{16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31})
fsystem = s.rfs
s.t = &tsuruTesting.T{}
s.createUserAndTeam(c)
s.t.StartAmzS3AndIAM(c)
s.t.SetGitConfs(c)
s.provisioner = tsuruTesting.NewFakeProvisioner()
Provisioner = s.provisioner
}
func main() {
logger, err := syslog.NewLogger(syslog.LOG_INFO, stdlog.LstdFlags)
if err != nil {
stdlog.Fatal(err)
}
log.SetLogger(logger)
configFile := flag.String("config", "/etc/tsuru/tsuru.conf", "tsuru config file")
dry := flag.Bool("dry", false, "dry-run: does not start the server (for testing purpose)")
flag.Parse()
err = config.ReadConfigFile(*configFile)
if err != nil {
fatal(err)
}
connString, err := config.GetString("database:url")
if err != nil {
fatal(err)
}
dbName, err := config.GetString("database:name")
if err != nil {
fatal(err)
}
db.Session, err = db.Open(connString, dbName)
if err != nil {
fatal(err)
}
defer db.Session.Close()
fmt.Printf("Connected to MongoDB server at %s.\n", connString)
fmt.Printf("Using the database %q.\n\n", dbName)
m := pat.New()
m.Get("/services/instances", AuthorizationRequiredHandler(consumption.ServicesInstancesHandler))
m.Post("/services/instances", AuthorizationRequiredHandler(consumption.CreateInstanceHandler))
m.Put("/services/instances/:instance/:app", AuthorizationRequiredHandler(api.BindHandler))
m.Del("/services/instances/:instance/:app", AuthorizationRequiredHandler(api.UnbindHandler))
m.Del("/services/c/instances/:name", AuthorizationRequiredHandler(consumption.RemoveServiceInstanceHandler))
m.Get("/services/instances/:instance/status", AuthorizationRequiredHandler(consumption.ServiceInstanceStatusHandler))
m.Get("/services", AuthorizationRequiredHandler(service_provision.ServicesHandler))
m.Post("/services", AuthorizationRequiredHandler(service_provision.CreateHandler))
m.Put("/services", AuthorizationRequiredHandler(service_provision.UpdateHandler))
m.Del("/services/:name", AuthorizationRequiredHandler(service_provision.DeleteHandler))
m.Get("/services/:name", AuthorizationRequiredHandler(consumption.ServiceInfoHandler))
m.Get("/services/c/:name/doc", AuthorizationRequiredHandler(consumption.Doc))
m.Get("/services/:name/doc", AuthorizationRequiredHandler(service_provision.GetDocHandler))
m.Put("/services/:name/doc", AuthorizationRequiredHandler(service_provision.AddDocHandler))
m.Put("/services/:service/:team", AuthorizationRequiredHandler(service_provision.GrantAccessToTeamHandler))
m.Del("/services/:service/:team", AuthorizationRequiredHandler(service_provision.RevokeAccessFromTeamHandler))
m.Del("/apps/:name", AuthorizationRequiredHandler(api.AppDelete))
m.Get("/apps/:name/repository/clone", Handler(api.CloneRepositoryHandler))
m.Get("/apps/:name/avaliable", Handler(api.AppIsAvaliableHandler))
m.Get("/apps/:name", AuthorizationRequiredHandler(api.AppInfo))
m.Post("/apps/:name/run", AuthorizationRequiredHandler(api.RunCommand))
m.Get("/apps/:name/restart", AuthorizationRequiredHandler(api.RestartHandler))
m.Get("/apps/:name/env", AuthorizationRequiredHandler(api.GetEnv))
m.Post("/apps/:name/env", AuthorizationRequiredHandler(api.SetEnv))
m.Del("/apps/:name/env", AuthorizationRequiredHandler(api.UnsetEnv))
m.Get("/apps", AuthorizationRequiredHandler(api.AppList))
m.Post("/apps", AuthorizationRequiredHandler(api.CreateAppHandler))
m.Put("/apps/:name/units", AuthorizationRequiredHandler(api.AddUnitsHandler))
m.Put("/apps/:app/:team", AuthorizationRequiredHandler(api.GrantAccessToTeamHandler))
m.Del("/apps/:app/:team", AuthorizationRequiredHandler(api.RevokeAccessFromTeamHandler))
m.Get("/apps/:name/log", AuthorizationRequiredHandler(api.AppLog))
m.Post("/apps/:name/log", Handler(api.AddLogHandler))
m.Post("/users", Handler(auth.CreateUser))
m.Post("/users/:email/tokens", Handler(auth.Login))
m.Put("/users/password", AuthorizationRequiredHandler(auth.ChangePassword))
m.Del("/users", AuthorizationRequiredHandler(auth.RemoveUser))
m.Post("/users/keys", AuthorizationRequiredHandler(auth.AddKeyToUser))
m.Del("/users/keys", AuthorizationRequiredHandler(auth.RemoveKeyFromUser))
m.Get("/teams", AuthorizationRequiredHandler(auth.ListTeams))
m.Post("/teams", AuthorizationRequiredHandler(auth.CreateTeam))
m.Del("/teams/:name", AuthorizationRequiredHandler(auth.RemoveTeam))
m.Put("/teams/:team/:user", AuthorizationRequiredHandler(auth.AddUserToTeam))
m.Del("/teams/:team/:user", AuthorizationRequiredHandler(auth.RemoveUserFromTeam))
if !*dry {
provisioner, err := config.GetString("provisioner")
if err != nil {
fmt.Printf("Warning: %q didn't declare a provisioner, using default provisioner.\n", configFile)
provisioner = "juju"
}
app.Provisioner, err = provision.Get(provisioner)
if err != nil {
fatal(err)
}
fmt.Printf("Using %q provisioner.\n\n", provisioner)
listen, err := config.GetString("listen")
if err != nil {
fatal(err)
}
fmt.Printf("tsuru HTTP server listening at %s...\n", listen)
fatal(http.ListenAndServe(listen, m))
}
}