Exemple #1
0
func main() {
	log.SetFlags(log.Lshortfile)

	conf := struct {
		GithubKey      string `envconf:",required"`
		GithubSecret   string `envconf:",required"`
		HTTP           string
		Postgres       string
		Statics        string `envconf:",required"`
		Templates      string `envconf:",required"`
		TemplatesCache bool
		Schema         string
	}{
		HTTP:           "localhost:8000",
		Postgres:       "user=paste password=paste dbname=paste sslmode=disable",
		Schema:         "schema.sql",
		TemplatesCache: false,
	}
	envconf.Must(envconf.LoadEnv(&conf))

	tmpl.MustLoadTemplates(conf.Templates, conf.TemplatesCache)

	ctx := context.Background()

	ctx = auth.WithOAuth(ctx, map[string]*oauth2.Config{
		"github": &oauth2.Config{
			ClientID:     conf.GithubKey,
			ClientSecret: conf.GithubSecret,
			Scopes:       []string{},
			Endpoint:     oauth2gh.Endpoint,
		},
	})

	statics = http.StripPrefix("/static", http.FileServer(http.Dir(conf.Statics)))

	ctx = web.WithRouter(ctx, router)
	ctx = cache.WithLocalCache(ctx, 1000)

	if db, err := sql.Open("postgres", conf.Postgres); err != nil {
		log.Fatalf("cannot connect to PostgreSQL: %s", err)
	} else {
		ctx = pg.WithDB(ctx, db)
		if conf.Schema != "" {
			log.Printf("loading schema from %q", conf.Schema)
			pg.MustLoadSchema(db, conf.Schema)
		}
	}

	app := &application{
		ctx: ctx,
		rt:  router,
	}
	log.Printf("running HTTP server: %s", conf.HTTP)
	if err := http.ListenAndServe(conf.HTTP, app); err != nil {
		log.Fatalf("HTTP server error: %s", err)
	}
}
Exemple #2
0
Fichier : bb.go Projet : husio/apps
func main() {
	conf := struct {
		HTTP     string
		Postgres string
	}{
		HTTP:     "localhost:8000",
		Postgres: "host=localhost port=5432 user=postgres dbname=bb sslmode=disable",
	}
	envconf.Must(envconf.LoadEnv(&conf))

	ctx := context.Background()

	ctx = auth.WithOAuth(ctx, map[string]*oauth2.Config{
		"google": &oauth2.Config{
			ClientID:     "352914691292-2h70272sb408r3vibe4jm4egote804ka.apps.googleusercontent.com",
			ClientSecret: "L_bgOHLCgNYL-3KG8a5u99mF",
			RedirectURL:  "http://bb.example.com:8000/login/success",
			Scopes: []string{
				"https://www.googleapis.com/auth/userinfo.profile",
				"https://www.googleapis.com/auth/userinfo.email",
			},
			Endpoint: oauth2google.Endpoint,
		},
	})

	ctx = cache.WithLocalCache(ctx, 1000)

	db, err := sql.Open("postgres", conf.Postgres)
	if err != nil {
		log.Fatal("cannot open database", "error", err.Error())
	}
	defer db.Close()
	ctx = pg.WithDB(ctx, db)
	go func() {
		if err := db.Ping(); err != nil {
			log.Error("cannot ping database", "error", err.Error())
		}
	}()

	app := bb.NewApp(ctx)
	log.Debug("running HTTP server", "address", conf.HTTP)
	if err := http.ListenAndServe(conf.HTTP, app); err != nil {
		log.Error("HTTP server error", "error", err.Error())
	}
}
Exemple #3
0
func main() {
	conf := struct {
		HTTP     string
		Postgres string
		Schema   string
	}{
		HTTP:     "localhost:8000",
		Postgres: "dbname=postgres user=postgres sslmode=disable",
	}
	if err := envconf.LoadEnv(&conf); err != nil {
		log.Fatal("cannot load configuration", "error", err.Error())
	}

	ctx, done := context.WithCancel(context.Background())
	defer done()

	db, err := sql.Open("postgres", conf.Postgres)
	if err != nil {
		log.Fatal("cannot connect to database", "error", err.Error())
	}
	defer db.Close()
	if err := db.Ping(); err != nil {
		log.Error("cannot ping database",
			"postgres", conf.Postgres,
			"error", err.Error())
	}
	ctx = pg.WithDB(ctx, db)

	if conf.Schema != "" {
		if err := pg.LoadSchema(db, conf.Schema); err != nil {
			log.Error("cannot load schema",
				"schema", conf.Schema,
				"error", err.Error())
		}
	}

	app := NewApplication(ctx)
	if err := http.ListenAndServe(conf.HTTP, app); err != nil {
		log.Error("HTTP server error", "error", err.Error())
	}
}
Exemple #4
0
func main() {
	conf := struct {
		HTTP string
	}{
		HTTP: "localhost:8000",
	}
	if err := envconf.LoadEnv(&conf); err != nil {
		log.Fatal("cannot load configuration", "error", err.Error())
	}

	ctx := context.Background()

	km, stop := keyManager()
	defer stop()
	ctx = keys.WithManager(ctx, km)

	app := NewApplication(ctx)
	if err := http.ListenAndServe(conf.HTTP, app); err != nil {
		log.Error("HTTP server error", "error", err.Error())
	}
}