func main() {
dry := flag.Bool("dry", false, "dry-run: does not start the server (for testing purpose)")
configFile := flag.String("config", "/etc/gandalf.conf", "Gandalf configuration file")
flag.Parse()
err := config.ReadAndWatchConfigFile(*configFile)
if err != nil {
msg := `Could not find gandalf config file. Searched on %s.
For an example conf check gandalf/etc/gandalf.conf file.\n %s`
log.Panicf(msg, *configFile, err)
}
db.Connect()
router := pat.New()
router.Post("/user/:name/key", http.HandlerFunc(api.AddKey))
router.Del("/user/:name/key/:keyname", http.HandlerFunc(api.RemoveKey))
router.Get("/user/:name/keys", http.HandlerFunc(api.ListKeys))
router.Post("/user", http.HandlerFunc(api.NewUser))
router.Del("/user/:name", http.HandlerFunc(api.RemoveUser))
router.Post("/repository", http.HandlerFunc(api.NewRepository))
router.Post("/repository/grant", http.HandlerFunc(api.GrantAccess))
router.Del("/repository/revoke", http.HandlerFunc(api.RevokeAccess))
router.Del("/repository/:name", http.HandlerFunc(api.RemoveRepository))
router.Get("/repository/:name", http.HandlerFunc(api.GetRepository))
router.Put("/repository/:name", http.HandlerFunc(api.RenameRepository))
port, err := config.GetString("webserver:port")
if err != nil {
panic(err)
}
if !*dry {
log.Fatal(http.ListenAndServe(port, router))
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
// If filePath is defined and the file exists, Load gets the configuration from there, otherwise
// it looks for the filename, specified in NewConfig in the current users home directory. If no file can be found
// the function creates a file with the users default values.
///////////////////////////////////////////////////////////////////////////////////////////////////////
func (c *Config) Load(loadDefaults loadDefFn, filePath string, watchConfig bool) error {
if len(filePath) == 0 {
usr, err := user.Current()
if err != nil {
return err
}
filePath = path.Join(usr.HomeDir, c.configFileName)
}
loadDefaults(c)
if _, err := os.Stat(filePath); err == nil {
if watchConfig {
if err := config.ReadAndWatchConfigFile(filePath); err != nil {
return err
}
} else {
if err := config.ReadConfigFile(filePath); err != nil {
return err
}
}
} else {
if err = c.writeDefConfigFile(filePath); err != nil {
return err
}
}
return nil
}
func loadConfig(flags map[string]interface{}) string {
configFile, ok := flags["config"].(string)
if !ok {
configFile = "/etc/tsuru/tsuru.conf"
}
err := config.ReadAndWatchConfigFile(configFile)
if err != nil {
fatal(err)
}
return configFile
}
func (c *tokenCmd) Run(context *cmd.Context, client *cmd.Client) error {
err := config.ReadAndWatchConfigFile(c.config)
if err != nil {
return err
}
t, err := auth.CreateApplicationToken("tsr")
if err != nil {
return err
}
fmt.Fprintf(context.Stdout, t.Token)
return nil
}
func Run(flags map[string]interface{}) {
logger, err := syslog.NewLogger(syslog.LOG_INFO, stdlog.LstdFlags)
if err != nil {
stdlog.Fatal(err)
}
log.SetLogger(logger)
configFile, ok := flags["config"].(string)
if !ok {
configFile = "/etc/tsuru/tsuru.conf"
}
dry, ok := flags["dry"].(bool)
if !ok {
dry = false
}
err = config.ReadAndWatchConfigFile(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)
}
fmt.Printf("Using the database %q from the server %q.\n\n", dbName, connString)
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)
ticker := time.Tick(time.Minute)
fmt.Println("tsuru collector agent started...")
collect(ticker)
}
}
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.ReadAndWatchConfigFile(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)
}
fmt.Printf("Using the database %q from the server %q.\n\n", dbName, connString)
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)
ticker := time.Tick(time.Minute)
fmt.Println("tsuru collector agent started...")
collect(ticker)
}
}
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.ReadAndWatchConfigFile(*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)
}
fmt.Printf("Using the database %q from the server %q.\n\n", dbName, connString)
m := pat.New()
m.Get("/services/instances", AuthorizationRequiredHandler(ServicesInstancesHandler))
m.Post("/services/instances", AuthorizationRequiredHandler(CreateInstanceHandler))
m.Put("/services/instances/:instance/:app", AuthorizationRequiredHandler(BindHandler))
m.Del("/services/instances/:instance/:app", AuthorizationRequiredHandler(UnbindHandler))
m.Del("/services/c/instances/:name", AuthorizationRequiredHandler(RemoveServiceInstanceHandler))
m.Get("/services/instances/:instance/status", AuthorizationRequiredHandler(ServiceInstanceStatusHandler))
m.Get("/services", AuthorizationRequiredHandler(ServicesHandler))
m.Post("/services", AuthorizationRequiredHandler(CreateHandler))
m.Put("/services", AuthorizationRequiredHandler(UpdateHandler))
m.Del("/services/:name", AuthorizationRequiredHandler(DeleteHandler))
m.Get("/services/:name", AuthorizationRequiredHandler(ServiceInfoHandler))
m.Get("/services/c/:name/doc", AuthorizationRequiredHandler(Doc))
m.Get("/services/:name/doc", AuthorizationRequiredHandler(GetDocHandler))
m.Put("/services/:name/doc", AuthorizationRequiredHandler(AddDocHandler))
m.Put("/services/:service/:team", AuthorizationRequiredHandler(GrantServiceAccessToTeamHandler))
m.Del("/services/:service/:team", AuthorizationRequiredHandler(RevokeServiceAccessFromTeamHandler))
m.Del("/apps/:name", AuthorizationRequiredHandler(appDelete))
m.Get("/apps/:name/repository/clone", Handler(CloneRepositoryHandler))
m.Get("/apps/:name/avaliable", Handler(AppIsAvailableHandler))
m.Get("/apps/:name", AuthorizationRequiredHandler(AppInfo))
m.Post("/apps/:name", AuthorizationRequiredHandler(setCName))
m.Post("/apps/:name/run", AuthorizationRequiredHandler(RunCommand))
m.Get("/apps/:name/restart", AuthorizationRequiredHandler(RestartHandler))
m.Get("/apps/:name/env", AuthorizationRequiredHandler(GetEnv))
m.Post("/apps/:name/env", AuthorizationRequiredHandler(SetEnv))
m.Del("/apps/:name/env", AuthorizationRequiredHandler(UnsetEnv))
m.Get("/apps", AuthorizationRequiredHandler(AppList))
m.Post("/apps", AuthorizationRequiredHandler(CreateAppHandler))
m.Put("/apps/:name/units", AuthorizationRequiredHandler(AddUnitsHandler))
m.Del("/apps/:name/units", AuthorizationRequiredHandler(RemoveUnitsHandler))
m.Put("/apps/:app/:team", AuthorizationRequiredHandler(GrantAccessToTeamHandler))
m.Del("/apps/:app/:team", AuthorizationRequiredHandler(RevokeAccessFromTeamHandler))
m.Get("/apps/:name/log", AuthorizationRequiredHandler(appLog))
m.Post("/apps/:name/log", Handler(AddLogHandler))
m.Post("/users", Handler(CreateUser))
m.Post("/users/:email/tokens", Handler(Login))
m.Put("/users/password", AuthorizationRequiredHandler(ChangePassword))
m.Del("/users", AuthorizationRequiredHandler(RemoveUser))
m.Post("/users/keys", AuthorizationRequiredHandler(AddKeyToUser))
m.Del("/users/keys", AuthorizationRequiredHandler(RemoveKeyFromUser))
m.Get("/teams", AuthorizationRequiredHandler(ListTeams))
m.Post("/teams", AuthorizationRequiredHandler(CreateTeam))
m.Del("/teams/:name", AuthorizationRequiredHandler(RemoveTeam))
m.Put("/teams/:team/:user", AuthorizationRequiredHandler(AddUserToTeam))
m.Del("/teams/:team/:user", AuthorizationRequiredHandler(RemoveUserFromTeam))
m.Get("/healers", Handler(healers))
m.Get("/healers/:healer", Handler(healer))
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)
}
tls, _ := config.GetBool("use-tls")
if tls {
certFile, err := config.GetString("tls-cert-file")
if err != nil {
fatal(err)
}
keyFile, err := config.GetString("tls-key-file")
if err != nil {
fatal(err)
}
fmt.Printf("tsuru HTTP/TLS server listening at %s...\n", listen)
fatal(http.ListenAndServeTLS(listen, certFile, keyFile, m))
} else {
fmt.Printf("tsuru HTTP server listening at %s...\n", listen)
fatal(http.ListenAndServe(listen, m))
}
}
}
func RunServer(flags map[string]interface{}) {
logger, err := syslog.NewLogger(syslog.LOG_INFO, stdlog.LstdFlags)
if err != nil {
stdlog.Fatal(err)
}
log.SetLogger(logger)
configFile, ok := flags["config"].(string)
if !ok {
configFile = "/etc/tsuru/tsuru.conf"
}
dry, ok := flags["dry"].(bool)
if !ok {
dry = false
}
err = config.ReadAndWatchConfigFile(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)
}
fmt.Printf("Using the database %q from the server %q.\n\n", dbName, connString)
m := pat.New()
m.Get("/schema/app", authorizationRequiredHandler(appSchema))
m.Get("/services/instances", authorizationRequiredHandler(serviceInstances))
m.Post("/services/instances", authorizationRequiredHandler(createServiceInstance))
m.Put("/services/instances/:instance/:app", authorizationRequiredHandler(bindServiceInstance))
m.Del("/services/instances/:instance/:app", authorizationRequiredHandler(unbindServiceInstance))
m.Del("/services/c/instances/:name", authorizationRequiredHandler(removeServiceInstance))
m.Get("/services/instances/:instance/status", authorizationRequiredHandler(serviceInstanceStatus))
m.Get("/services", authorizationRequiredHandler(serviceList))
m.Post("/services", authorizationRequiredHandler(serviceCreate))
m.Put("/services", authorizationRequiredHandler(serviceUpdate))
m.Del("/services/:name", authorizationRequiredHandler(serviceDelete))
m.Get("/services/:name", authorizationRequiredHandler(serviceInfo))
m.Get("/services/:name/doc", authorizationRequiredHandler(serviceDoc))
m.Put("/services/:name/doc", authorizationRequiredHandler(serviceAddDoc))
m.Put("/services/:service/:team", authorizationRequiredHandler(grantServiceAccess))
m.Del("/services/:service/:team", authorizationRequiredHandler(revokeServiceAccess))
m.Del("/apps/:app", authorizationRequiredHandler(appDelete))
m.Get("/apps/:app", authorizationRequiredHandler(appInfo))
m.Post("/apps/:app", authorizationRequiredHandler(setCName))
m.Post("/apps/:app/run", authorizationRequiredHandler(runCommand))
m.Get("/apps/:app/restart", authorizationRequiredHandler(restart))
m.Get("/apps/:app/env", authorizationRequiredHandler(getEnv))
m.Post("/apps/:app/env", authorizationRequiredHandler(setEnv))
m.Del("/apps/:app/env", authorizationRequiredHandler(unsetEnv))
m.Get("/apps", authorizationRequiredHandler(appList))
m.Post("/apps", authorizationRequiredHandler(createApp))
m.Put("/apps/:app/units", authorizationRequiredHandler(addUnits))
m.Del("/apps/:app/units", authorizationRequiredHandler(removeUnits))
m.Put("/apps/:app/:team", authorizationRequiredHandler(grantAppAccess))
m.Del("/apps/:app/:team", authorizationRequiredHandler(revokeAppAccess))
m.Get("/apps/:app/log", authorizationRequiredHandler(appLog))
m.Post("/apps/:app/log", authorizationRequiredHandler(addLog))
m.Get("/platforms", authorizationRequiredHandler(platformList))
// These handlers don't use :app on purpose. Using :app means that only
// the token generate for the given app is valid, but these handlers
// use a token generated for Gandalf.
m.Get("/apps/:appname/available", authorizationRequiredHandler(appIsAvailable))
m.Get("/apps/:appname/repository/clone", authorizationRequiredHandler(cloneRepository))
if registrationEnabled, _ := config.GetBool("auth:user-registration"); registrationEnabled {
m.Post("/users", handler(createUser))
}
m.Post("/users/:email/password", handler(resetPassword))
m.Post("/users/:email/tokens", handler(login))
m.Del("/users/tokens", authorizationRequiredHandler(logout))
m.Put("/users/password", authorizationRequiredHandler(changePassword))
m.Del("/users", authorizationRequiredHandler(removeUser))
m.Post("/users/keys", authorizationRequiredHandler(addKeyToUser))
m.Del("/users/keys", authorizationRequiredHandler(removeKeyFromUser))
m.Post("/tokens", adminRequiredHandler(generateAppToken))
m.Get("/teams", authorizationRequiredHandler(teamList))
m.Post("/teams", authorizationRequiredHandler(createTeam))
m.Del("/teams/:name", authorizationRequiredHandler(removeTeam))
m.Put("/teams/:team/:user", authorizationRequiredHandler(addUserToTeam))
m.Del("/teams/:team/:user", authorizationRequiredHandler(removeUserFromTeam))
m.Get("/healers", authorizationRequiredHandler(healers))
m.Get("/healers/:healer", authorizationRequiredHandler(healer))
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)
}
tls, _ := config.GetBool("use-tls")
if tls {
certFile, err := config.GetString("tls-cert-file")
if err != nil {
fatal(err)
}
keyFile, err := config.GetString("tls-key-file")
if err != nil {
fatal(err)
}
fmt.Printf("tsuru HTTP/TLS server listening at %s...\n", listen)
fatal(http.ListenAndServeTLS(listen, certFile, keyFile, m))
} else {
listener, err := net.Listen("tcp", listen)
if err != nil {
fatal(err)
}
fmt.Printf("tsuru HTTP server listening at %s...\n", listen)
http.Handle("/", m)
fatal(http.Serve(listener, nil))
}
}
}