func APIRequest(url string, method string, model interface{}, token string) {
jwtMiddleware := &jwt.JWTMiddleware{
Key: SecretKey,
Realm: Realm,
Timeout: time.Hour,
MaxRefresh: time.Hour * 24,
Authenticator: func(userId string, password string) bool {
return Authenticator(userId, password)
},
}
api := rest.NewApi()
api.Use(&rest.IfMiddleware{
Condition: func(request *rest.Request) bool {
return CheckCondition(request)
},
IfTrue: jwtMiddleware,
})
api.SetApp(NewRouter(jwtMiddleware, testConn))
Request = test.MakeSimpleRequest(method, url, model)
if token != "" {
Request.Header.Set("Authorization", "Bearer "+token)
}
recorded := test.RunRequest(tst, api.MakeHandler(), Request)
Response = recorded.Recorder
}
func main() {
flag.Parse()
sm := newSyncMaster(*dbDir)
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
router, err := rest.MakeRouter(
&rest.Route{"GET", "/labels/since/:nonce/for/:mpk", sm.GetLabels},
&rest.Route{"POST", "/label", sm.CreateLabel},
&rest.Route{"POST", "/labels", sm.CreateLabels},
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
sm.logger.Info("Server started and listening on %s", *listenPort)
if *useTLS {
sm.logger.Info("Using SSL with certificate '%s' and keyfile '%s'", *certPath, *keyPath)
log.Fatal(http.ListenAndServeTLS(*listenPort, *certPath, *keyPath, api.MakeHandler()))
} else {
log.Fatal(http.ListenAndServe(*listenPort, api.MakeHandler()))
}
}
func main() {
svmw := SemVerMiddleware{
MinVersion: "1.0.0",
MaxVersion: "3.0.0",
}
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
router, err := rest.MakeRouter(
rest.Get("/#version/message", svmw.MiddlewareFunc(
func(w rest.ResponseWriter, req *rest.Request) {
version := req.Env["VERSION"].(*semver.Version)
if version.Major == 2 {
// http://en.wikipedia.org/wiki/Second-system_effect
w.WriteJson(map[string]string{
"Body": "Hello broken World!",
})
} else {
w.WriteJson(map[string]string{
"Body": "Hello World!",
})
}
},
)),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
http.Handle("/api/", http.StripPrefix("/api", api.MakeHandler()))
log.Fatal(http.ListenAndServe(":8080", nil))
}
// MakeHandler creates the api request handler
func MakeHandler() *http.Handler {
api := rest.NewApi()
authMiddleware, err := CreateAuthMiddleware()
if err != nil {
panic(err)
}
api.Use(&rest.IfMiddleware{
// Only authenticate non login or register requests
Condition: func(request *rest.Request) bool {
return (request.URL.Path != variables.APIPathLoginUserServer) && (request.URL.Path != variables.APIPathRegisterUserServer)
},
IfTrue: authMiddleware,
})
api.Use(rest.DefaultProdStack...)
router, err := rest.MakeRouter(
rest.Post(variables.APIPathLoginUserServer, authMiddleware.LoginHandler),
rest.Get(variables.APIPathRefreshUserServer, authMiddleware.RefreshHandler),
rest.Post(variables.APIPathRegisterUserServer, PostRegister),
rest.Get(variables.APIPathUserServer, GetUser),
rest.Post(variables.APIPathUserServer, PostUser),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
handler := api.MakeHandler()
return &handler
}
func main() {
fmt.Printf("grouch: a RESTful object store.\n")
// Open the config file
config := readConfig("./config.json")
fmt.Printf("Data directory: %s\n", config.Directory)
fmt.Printf("Mode: %s\n", config.Mode)
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
endpoint := "/" + config.Directory + "/#file"
router, err := rest.MakeRouter(
rest.Get(endpoint, func(w rest.ResponseWriter, req *rest.Request) {
file, err := ioutil.ReadFile(
config.Directory + "/" + req.PathParam("file"))
if err != nil {
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
fileContents := string(file)
w.WriteJson(&fileContents)
}),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
// NewRest configures REST api handlers and wrappers.
func NewRest() *rest.Api {
api := rest.NewApi()
api.MakeHandler()
api.Use(rest.DefaultDevStack...)
api.Use(&rest.CorsMiddleware{
RejectNonCorsRequests: false,
OriginValidator: func(origin string, request *rest.Request) bool {
return true
},
AllowedMethods: []string{"GET", "POST"},
AllowedHeaders: []string{
"Accept", "Content-Type", "X-Custom-Header", "Origin"},
AccessControlAllowCredentials: true,
AccessControlMaxAge: 3600,
})
router, err := rest.MakeRouter(
rest.Post("/translations", translations),
rest.Post("/suggestions", suggestions),
rest.Get("/health", health),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
return api
}
// TestGJRMiddlewareWithRaceCondition test GRJ middleware under race condition.
func TestGJRMiddlewareWithRaceCondition(t *testing.T) {
runtime.GOMAXPROCS(4)
api := rest.NewApi()
api.Use(NewGJRMiddleware(newRedisLimiter("5-M", "limitertests:gjrrace")))
api.SetApp(rest.AppSimple(func(w rest.ResponseWriter, r *rest.Request) {
w.WriteJson(map[string]string{"message": "ok"})
}))
handler := api.MakeHandler()
req := test.MakeSimpleRequest("GET", "http://localhost/", nil)
req.RemoteAddr = fmt.Sprintf("178.1.2.%d:180", Random(1, 90))
nbRequests := 100
successCount := 0
var wg sync.WaitGroup
wg.Add(nbRequests)
for i := 1; i <= nbRequests; i++ {
go func() {
recorded := test.RunRequest(t, handler, req)
if recorded.Recorder.Code == 200 {
successCount++
}
wg.Done()
}()
}
wg.Wait()
assert.Equal(t, 5, successCount)
}
func main() {
// context
ctx = context.Background()
// db
hoge.BuildInstances()
// redis
redis_pool := newPool()
ctx = context.WithValue(ctx, "redis", redis_pool)
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
router, err := rest.MakeRouter(
rest.Post("/test", baseHandlerFunc(controller.Test)),
)
// 存在しないルート時
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
httpErr := http.ListenAndServe(":9999", api.MakeHandler())
if httpErr != nil {
log.Fatal(err, "http error!!")
}
}
func main() {
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
//配置API跨域CORS
api.Use(&rest.CorsMiddleware{
RejectNonCorsRequests: false,
OriginValidator: func(origin string, req *rest.Request) bool {
return origin == req.Header.Get("Origin")
},
AllowedMethods: []string{"GET", "POST", "PUT"},
AllowedHeaders: []string{
"Accept", "Content-Type", "X-Custom-Header", "Origin"},
AccessControlAllowCredentials: true,
AccessControlMaxAge: 3600,
})
//设置API基本Router
router, err := rest.MakeRouter(
rest.Post("/:raw.json", RawWrite),
rest.Post("/auth/login/:id", AuthLogin),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
func main() {
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
router, err := rest.MakeRouter(
rest.Get("/message", func(w rest.ResponseWriter, req *rest.Request) {
for cpt := 1; cpt <= 10; cpt++ {
// wait 1 second
time.Sleep(time.Duration(1) * time.Second)
w.WriteJson(map[string]string{
"Message": fmt.Sprintf("%d seconds", cpt),
})
w.(http.ResponseWriter).Write([]byte("\n"))
// Flush the buffer to client
w.(http.Flusher).Flush()
}
}),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
server := &graceful.Server{
Timeout: 10 * time.Second,
Server: &http.Server{
Addr: ":8080",
Handler: api.MakeHandler(),
},
}
log.Fatal(server.ListenAndServe())
}
func (restapi *CyberBullyingEntryPointRestApiImpl) GetApi() (Api *rest.Api) {
if restapi.Api == nil {
restapi.Api = rest.NewApi()
restapi.Api.Use(rest.DefaultDevStack...)
}
return restapi.Api
}
func main() {
// context
ctx = context.Background()
db := initDb()
ctx = context.WithValue(ctx, "test", "aaabbbccc")
ctx = context.WithValue(ctx, "DB", db)
// redis
redis_pool := newPool()
ctx = context.WithValue(ctx, "redis", redis_pool)
str := ctx.Value("test")
log.Println(str)
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
router, err := rest.MakeRouter(
rest.Post("/test", baseHandlerFunc(controller.Test)),
)
// 存在しないルート時
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
log.Fatal(http.ListenAndServe(":9999", api.MakeHandler()))
}
func (app *App) StartServer(addr string, dbFileName string) {
err := app.InitDB(dbFileName)
if err != nil {
log.Fatal(err)
}
api := rest.NewApi()
api.Use(rest.DefaultProdStack...)
api.Use(&rest.CorsMiddleware{
RejectNonCorsRequests: false,
AllowedMethods: []string{"GET", "POST"},
AllowedHeaders: []string{
"Accept", "Content-Type", "Origin"},
AccessControlAllowCredentials: true,
AccessControlMaxAge: 2592000,
OriginValidator: func(origin string, request *rest.Request) bool {
return true
},
})
router, err := rest.MakeRouter(
rest.Get("/latest", app.GetLatest),
rest.Get("/last", app.GetLast),
rest.Get("/all", app.GetAll),
rest.Post("/postEntry", app.PostEntry),
//rest.Post("/postSignedEntry", app.PostJwtEntry),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
log.Fatal(http.ListenAndServe(addr, api.MakeHandler()))
}
func main() {
logit.Info.Println("cpmcontainerapi: containeragent starting")
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
router, err := rest.MakeRouter(
&rest.Route{"GET", "/status", cpmcontainerapi.Status},
&rest.Route{"POST", "/remotewritefile", cpmcontainerapi.RemoteWritefile},
&rest.Route{"POST", "/seed", cpmcontainerapi.Seed},
&rest.Route{"POST", "/startpg", cpmcontainerapi.StartPG},
&rest.Route{"POST", "/stoppg", cpmcontainerapi.StopPG},
&rest.Route{"POST", "/startpgonstandby", cpmcontainerapi.StartPGOnStandby},
&rest.Route{"POST", "/initdb", cpmcontainerapi.Initdb},
&rest.Route{"POST", "/startpgpool", cpmcontainerapi.StartPgpool},
&rest.Route{"POST", "/stoppgpool", cpmcontainerapi.StopPgpool},
&rest.Route{"POST", "/basebackup", cpmcontainerapi.Basebackup},
&rest.Route{"POST", "/failover", cpmcontainerapi.Failover},
&rest.Route{"POST", "/controldata", cpmcontainerapi.Controldata},
&rest.Route{"POST", "/badgergenerate", cpmcontainerapi.BadgerGenerate},
&rest.Route{"POST", "/restore", cpmcontainerapi.Restore},
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
http.Handle("/api/", http.StripPrefix("/api", api.MakeHandler()))
http.Handle("/static/", http.StripPrefix("/static", http.FileServer(http.Dir("/pgdata/pg_log"))))
log.Fatal(http.ListenAndServe(":10001", nil))
log.Fatal(http.ListenAndServeTLS(":10000", "/var/cpm/keys/cert.pem", "/var/cpm/keys/key.pem", nil))
}
func main() {
servePort := os.Getenv(servePortEnv)
if servePort == "" {
servePort = defaultServePort
}
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
router, err := rest.MakeRouter(
rest.Get("/rnd", genRndNumber),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
bindPort := fmt.Sprintf(":%s", servePort)
log.Printf("server listening on %s", bindPort)
log.Fatal(http.ListenAndServe(bindPort, api.MakeHandler()))
}
func main() {
logit.Info.Println("serveragent starting")
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
router, err := rest.MakeRouter(
&rest.Route{"POST", "/metrics/iostat", cpmserverapi.MetricIostat},
&rest.Route{"POST", "/metrics/df", cpmserverapi.MetricDf},
&rest.Route{"POST", "/metrics/mem", cpmserverapi.MetricMEM},
&rest.Route{"POST", "/metrics/cpu", cpmserverapi.MetricCPU},
&rest.Route{"POST", "/docker/inspect", cpmserverapi.DockerInspect},
&rest.Route{"POST", "/docker/remove", cpmserverapi.DockerRemove},
&rest.Route{"POST", "/docker/start", cpmserverapi.DockerStart},
&rest.Route{"POST", "/docker/stop", cpmserverapi.DockerStop},
&rest.Route{"POST", "/docker/run", cpmserverapi.DockerRun},
&rest.Route{"POST", "/disk/provision", cpmserverapi.DiskProvision},
&rest.Route{"POST", "/disk/delete", cpmserverapi.DiskDelete},
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
log.Fatal(http.ListenAndServe(":10001", api.MakeHandler()))
log.Fatal(http.ListenAndServeTLS(":10000", "/var/cpm/keys/cert.pem", "/var/cpm/keys/key.pem", api.MakeHandler()))
}
func main() {
//fmt.Fprintln(os.Stderr, "this is an error message to stderr using Fprintln")
logit.Info.Println("sleeping during startup to give DNS a chance")
sleepTime, _ := time.ParseDuration("7s")
time.Sleep(sleepTime)
task.LoadSchedules()
logit.Info.Println("taskserver starting")
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
router, err := rest.MakeRouter(
&rest.Route{"POST", "/status/add", task.StatusAdd},
&rest.Route{"POST", "/status/update", task.StatusUpdate},
&rest.Route{"POST", "/executenow", task.ExecuteNow},
&rest.Route{"POST", "/reload", task.Reload},
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
http.Handle("/api/", http.StripPrefix("/api", api.MakeHandler()))
log.Fatal(http.ListenAndServe(":13001", nil))
}
func main() {
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
/*
api.Use(&rest.CorsMiddleware{
RejectNonCorsRequests: false,
OriginValidator: func(origin string, request *rest.Request) bool {
return true
},
AllowedMethods: []string{"GET", "POST", "PUT"},
AllowedHeaders: []string{
"Accept", "Content-Type", "X-Custom-Header", "Origin"},
AccessControlAllowCredentials: true,
AccessControlMaxAge: 3600,
})
*/
router, err := rest.MakeRouter(
rest.Post("/test", test),
)
// 存在しないルート時
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
log.Fatal(http.ListenAndServe(":9999", api.MakeHandler()))
}
// TestRate tests ratelimit.Rate methods.
func TestGJRMiddleware(t *testing.T) {
api := rest.NewApi()
api.Use(NewGJRMiddleware(newRedisLimiter("10-M", "limitertests:gjr")))
var reset int64
api.SetApp(rest.AppSimple(func(w rest.ResponseWriter, r *rest.Request) {
reset = r.Env["ratelimit:reset"].(int64)
w.WriteJson(map[string]string{"message": "ok"})
}))
handler := api.MakeHandler()
req := test.MakeSimpleRequest("GET", "http://localhost/", nil)
req.RemoteAddr = fmt.Sprintf("178.1.2.%d:120", Random(1, 90))
i := 1
for i < 20 {
recorded := test.RunRequest(t, handler, req)
assert.True(t, math.Ceil(time.Since(time.Unix(reset, 0)).Seconds()) <= 60)
if i <= 10 {
recorded.BodyIs(`{"message":"ok"}`)
recorded.HeaderIs("X-Ratelimit-Limit", "10")
recorded.HeaderIs("X-Ratelimit-Remaining", fmt.Sprintf("%d", 10-i))
recorded.CodeIs(200)
} else {
recorded.BodyIs(`{"Error":"Limit exceeded"}`)
recorded.HeaderIs("X-Ratelimit-Limit", "10")
recorded.HeaderIs("X-Ratelimit-Remaining", "0")
recorded.CodeIs(429)
}
i++
}
}
func main() {
db := models.GormDB{}
rAdapt := controllers.RestAdapterImplementation{}
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
api.Use(&rest.CorsMiddleware{
RejectNonCorsRequests: false,
OriginValidator: func(origin string, request *rest.Request) bool {
//return origin == "http://my.other.host"
return true
},
AllowedMethods: []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
AllowedHeaders: []string{
"Accept", "Content-Type", "X-Custom-Header", "Origin"},
AccessControlAllowCredentials: true,
AccessControlMaxAge: 3600,
})
router, err := rAdapt.Init(&db)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
log.Fatal(http.ListenAndServe(":3001", api.MakeHandler()))
}
func main() {
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
api.SetApp(rest.AppSimple(func(w rest.ResponseWriter, r *rest.Request) {
conf := os.Getenv("CONFIG")
app := os.Getenv("APP")
w.Header().Set("Content-Type", "text/plain")
cmd := exec.Command("transporter", "run", "--config", conf, app)
outs, err := cmd.CombinedOutput()
out_cmds := fmt.Sprintf("==> Executing: %s\n", strings.Join(cmd.Args, " "))
w.(http.ResponseWriter).Write([]byte(out_cmds))
if err != nil {
out_errs := fmt.Sprintf("==> Error: %s\n", err.Error())
w.(http.ResponseWriter).Write([]byte(out_errs))
} else {
out_outs := fmt.Sprintf("==> Output: %s\n", string(outs))
w.(http.ResponseWriter).Write([]byte(out_outs))
}
}))
log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
func MsgServerStart() {
mqmsg := msgqueue.MqMsg{
Msg: message.NewMsg(),
}
persistent := PerMqAgent{
Msg: message.NewMsg(),
}
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
router, err := rest.MakeRouter(
//rest.Get("/test", msg.TestMsg),
rest.Get("/testmq/:mqid", msgqueue.DefaultMM.TestMq),
rest.Post("/send_msg/:mqid", mqmsg.PostMsg),
rest.Get("/receive_msg/:mqid", mqmsg.GetMsg),
rest.Post("/send/:mqid", persistent.PostMsg),
rest.Get("/receive/:mqid", persistent.GetMsg),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
log.Fatal(http.ListenAndServe(":"+ListenPort, api.MakeHandler()))
}
/*
Microservice for accessing data
*/
func main() {
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
api.Use(
&rest.AuthBasicMiddleware{
Realm: "Smart Alarm Clock REST API",
Authenticator: auth.AuthenticateByFile,
Authorizator: auth.AuthorizeRequest})
router, err := rest.MakeRouter(
rest.Get("/test/:time", view.GetJSONMessage),
rest.Get("/calendar/next/:id", view.GetNextCalendarEntry),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
apilog.Init()
calcom.InitApis()
log.Fatal(
http.ListenAndServeTLS(":1443",
"/etc/sac/keys/cert.pem",
"/etc/sac/keys/key.pem",
api.MakeHandler(),
),
)
}
func (s *server) StartServer() error {
api := rest.NewApi()
router, err := rest.MakeRouter(
// system
&rest.Route{"GET", "/v1/ping", s.ping},
&rest.Route{"GET", "/v1/version", s.version},
// v1
&rest.Route{"GET", "/v1/secrets/:type/:name", s.serveSecret},
)
if err != nil {
return err
}
api.SetApp(router)
go func() {
s.builder.Conf.Logger.Infof("Starting API on %d", s.builder.Conf.ApiPort)
// 192.168.99.1
if err := http.ListenAndServe(fmt.Sprintf("%s:%d", s.builder.Conf.ApiBinding, s.builder.Conf.ApiPort), api.MakeHandler()); err != nil {
s.builder.Conf.Logger.Errorf("Failed to start API %s", err.Error())
os.Exit(2)
}
}()
return nil
}
func main() {
jwt_middleware := &jwt.JWTMiddleware{
Key: []byte("secret key"),
Realm: "jwt auth",
Timeout: time.Hour,
MaxRefresh: time.Hour * 24,
Authenticator: func(userId string, password string) bool {
return userId == "admin" && password == "admin"
}}
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
// we use the IfMiddleware to remove certain paths from needing authentication
api.Use(&rest.IfMiddleware{
Condition: func(request *rest.Request) bool {
return request.URL.Path != "/login"
},
IfTrue: jwt_middleware,
})
api_router, _ := rest.MakeRouter(
rest.Post("/login", jwt_middleware.LoginHandler),
rest.Get("/auth_test", handle_auth),
rest.Get("/refresh_token", jwt_middleware.RefreshHandler),
)
api.SetApp(api_router)
http.Handle("/api/", http.StripPrefix("/api", api.MakeHandler()))
log.Fatal(http.ListenAndServe(":8080", nil))
}
func main() {
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
router, err := rest.MakeRouter(
rest.Get("/weather/#location", func(w rest.ResponseWriter, req *rest.Request) {
weather, err := GetWeather(req.PathParam("location"))
if err != nil {
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
//w.WriteJson(&weather)
//
w.WriteJson(
&WeatherResponse{
Location: fmt.Sprintf("%s", weather.CityName),
Temperature: KelvinToFarenheit(weather.Main.Temp),
},
)
}),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
func main() {
i := Impl{}
i.InitDB()
i.InitSchema()
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
api.Use(&rest.CorsMiddleware{
RejectNonCorsRequests: false,
OriginValidator: func(origin string, request *rest.Request) bool {
return true
},
AllowedMethods: []string{"GET", "POST", "PUT"},
AllowedHeaders: []string{
"Accept", "Content-Type", "X-Custom-Header", "Origin"},
AccessControlAllowCredentials: true,
AccessControlMaxAge: 3600,
})
router, err := rest.MakeRouter(
rest.Get("/services", i.GetAllServices),
rest.Post("/services", i.PostService),
rest.Get("/services/:id", i.GetService),
rest.Put("/services/:id", i.PutService),
rest.Delete("/services/:id", i.DeleteService),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
func main() {
dsn := fmt.Sprintf("user=%s dbname=%s sslmode=disable",
os.Getenv("DATABASE_USER"),
os.Getenv("DATABASE_NAME"))
db, err := gorm.Open("postgres", dsn)
fmt.Println(dsn)
if err != nil {
panic(err)
}
db.DB()
db.DB().Ping()
db.DB().SetMaxIdleConns(10)
db.DB().SetMaxOpenConns(100)
db.SingularTable(true)
db.LogMode(true)
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
accounts := &Accounts{Db: db}
router, err := rest.MakeRouter(
rest.Get("/users/:username", accounts.Detail),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
func (this *App) Run() {
apiServer := rest.NewApi()
apiServer.Use(rest.DefaultDevStack...)
// Cors
apiServer.Use(&rest.CorsMiddleware{
RejectNonCorsRequests: false,
OriginValidator: func(origin string, request *rest.Request) bool {
return true
},
AllowedMethods: []string{"GET", "POST", "PUT"},
AllowedHeaders: []string{
"Authorization", "Accept", "Content-Type", "X-Custom-Header", "Origin",
},
AccessControlAllowCredentials: true,
AccessControlMaxAge: 3600,
})
// Jsonp
apiServer.Use(&rest.JsonpMiddleware{
CallbackNameKey: "jsonp",
})
router, err := rest.MakeRouter(config.Routes...)
if err != nil {
log.Fatal(err)
}
apiServer.SetApp(router)
log.Info("Start serving, port=", this.Env.Port)
log.Fatal(http.ListenAndServe(this.Port(), apiServer.MakeHandler()))
}
func MakeApi() http.Handler {
api := rest.NewApi()
api.Use(rest.DefaultDevStack...)
jwtMiddleware := &jwt.JWTMiddleware{
Key: []byte("super secret key"),
Realm: "Spacebook",
Timeout: time.Hour,
MaxRefresh: time.Hour * 24,
Authenticator: authUser,
}
api.Use(&rest.IfMiddleware{
Condition: func(request *rest.Request) bool {
return request.URL.Path == "/pasteswithuser"
},
IfTrue: jwtMiddleware,
})
router, err := rest.MakeRouter(
&rest.Route{"GET", "/pastes/:id", GetPaste},
&rest.Route{"POST", "/pastes", PostPaste},
&rest.Route{"POST", "/pasteswithuser", PostPasteWithUser},
&rest.Route{"GET", "/pastes", GetAll},
&rest.Route{"POST", "/login", jwtMiddleware.LoginHandler},
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
return api.MakeHandler()
}
