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)
}
}
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())
}
}
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())
}
}
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())
}
}