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())) }
func main() { api := rest.NewApi() api.Use(rest.DefaultDevStack...) router, err := rest.MakeRouter( rest.Get("/test", testApi), rest.Post("/addTask", plain.AddTask), rest.Get("/getTasks", plain.GetTasks), rest.Post("/removeTask", plain.RemoveTask), rest.Post("/completeTask", plain.CloseTask), rest.Post("/rearrangeTasks", plain.RearrangeTasks), ) if err != nil { log.Fatal(err) } api.SetApp(router) http.Handle("/api/", http.StripPrefix("/api", api.MakeHandler())) http.Handle("/", http.StripPrefix("/", http.FileServer(http.Dir("frontend")))) log.Println("Listening...") http.ListenAndServe(":3000", 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 }
// 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 }
func initRoutes(restApi *rest.Api) { authController := &AuthController{} appController := &ApplicationController{} typesController := &TypesController{} router, err := rest.MakeRouter( rest.Put(authController.Path(), authController.RegisterUserHandler), rest.Post(authController.Path(), authController.LoginUserHandler), rest.Put("/:appId"+authController.Path(), authController.AppRegisterUserHandler), rest.Post("/:appId"+authController.Path(), authController.AppLoginUserHandler), rest.Post(appController.Path(), appController.CreateApplicationHandler), rest.Get(appController.Path(), appController.GetApplicationsHandler), rest.Get(appController.Path()+"/:appId", appController.GetApplicationHandler), rest.Delete(appController.Path()+"/:appId", appController.DeleteApplicationHandler), rest.Put(appController.Path()+"/:appId", appController.UpdateApplicationHandler), rest.Post("/:appId"+typesController.Path(), typesController.CreateTypeHandler), rest.Delete("/:appId"+typesController.Path()+"/:typeName", typesController.DeleteType), rest.Post("/:appId"+typesController.Path()+"/:typeName", typesController.InsertInTypeHandler), rest.Get("/:appId"+typesController.Path()+"/:typeName", typesController.GetTypeDataHandler), rest.Get("/:appId"+typesController.Path()+"/:typeName/:itemId", typesController.GetTypeItemById), rest.Put("/:appId"+typesController.Path()+"/:typeName/:itemId", typesController.UpdateTypeItemById), rest.Delete("/:appId"+typesController.Path()+"/:typeName/:itemId", typesController.DeleteTypeItemById), ) if err != nil { log.Fatal(err) } restApi.SetApp(router) }
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())) }
// Start start the http rest api plugin func (cli *HTTPAPIServer) Start(config map[string]interface{}) error { wwwroot, _ := utils.GetString("static", config, "") addr, _ := utils.GetString("listen", config, ":8080") secret, ok := utils.GetString("secret", config, randomString(128)) if !ok { logrus.Warnf("Plugins: httpapi: generated new secret: %s", secret) } jwt_middleware := &jwt.JWTMiddleware{ Key: []byte(secret), 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...) api.Use(&rest.IfMiddleware{ Condition: func(request *rest.Request) bool { return request.URL.Path != "/login" }, IfTrue: jwt_middleware, }) router, err := rest.MakeRouter( rest.Post("/login", jwt_middleware.LoginHandler), rest.Get("/refresh_token", jwt_middleware.RefreshHandler), rest.Get("/", getApiVersion), rest.Get("/sensors", getAllSensors), rest.Get("/sensors/:backend.:sensor", getSensor), rest.Get("/services", getAllServices), rest.Get("/services/:backend.:service", getService), rest.Post("/services/:backend.:service", callService), ) if err != nil { log.Fatal(err) } api.SetApp(router) http.Handle("/v1/", http.StripPrefix("/v1", api.MakeHandler())) if wwwroot != "" { logrus.Infof("Plugin: httpapi: service static content from %s", wwwroot) http.Handle("/ui/", http.StripPrefix("/ui", http.FileServer(http.Dir(wwwroot)))) } go func() { logrus.Infof("Plugin: httpapi: starting on %s", addr) manners.ListenAndServe(addr, http.DefaultServeMux) }() return nil }
func main() { var err error api := rest.NewApi() // Enable basic middlewares. api.Use(rest.DefaultDevStack...) // Enable CORS middleware. api.Use(&rest.CorsMiddleware{ RejectNonCorsRequests: false, OriginValidator: func(origin string, request *rest.Request) bool { return true }, AllowedMethods: []string{"GET", "POST", "PUT", "DELETE"}, AllowedHeaders: []string{ "Accept", "Content-Type", "X-Custom-Header", "Origin"}, AccessControlAllowCredentials: true, AccessControlMaxAge: 3600, }) // Enable token validation middleware. api.Use(&mw.AuthMW{}) router, err := rest.MakeRouter( // cards. rest.Get("/cards", GetUserCards), rest.Get("/cards/:cid", GetCard), rest.Post("/cards", CreateCard), rest.Put("/cards/:cid", UpdateCard), rest.Delete("/cards/:cid", DeleteCard), rest.Get("/challenge", GetChallenge), rest.Post("/results", SaveResult), // user endpoints. rest.Get("/users/:uid", GetUser), rest.Put("/users/:uid", UpdateUser), rest.Delete("/users/:uid", DeleteUser), // token rest.Post("/token", GetToken), // ping rest.Get("/ping", Ping), ) if err != nil { log.Fatal(err) } api.SetApp(router) log.Fatal(http.ListenAndServe(":8080", api.MakeHandler())) }
func main() { DataFile, err := os.Open(configFile) if err != nil { log.Fatal("Error opening Config file", err.Error()) os.Exit(2) } jsonParser := json.NewDecoder(DataFile) if err = jsonParser.Decode(&serverData); err != nil { log.Fatal("Error parsing config file", err.Error()) os.Exit(2) } Println(timeNow, " --- Config file ", configFile, " loaded") Println(timeNow, " --- Starting web server listener on host:", serverData.Host, "on port:", serverData.Port) 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), rest.Get("/index", Index), rest.Get("/messages", GetAllMessages), rest.Post("/messages", PostMessage), rest.Get("/countries/:code", GetMessage), // rest.Delete("/countries/:code", DeleteMessage), ) api.SetApp(api_router) http.Handle("/api/", http.StripPrefix("/api", api.MakeHandler())) log.Fatal(http.ListenAndServe(serverData.Host+":"+serverData.Port, nil)) }
// Serve a json api func Serve() { redisPool = newPool(redisServer, redisPassword) api := rest.NewApi() api.Use(&rest.IfMiddleware{ Condition: func(request *rest.Request) bool { return request.URL.Path != "/login" }, IfTrue: &tokenauth.AuthTokenMiddleware{ Realm: authRealm, Authenticator: func(token string) string { rd := redisPool.Get() defer rd.Close() user, _ := redis.String(rd.Do("GET", tokenNamespace+tokenauth.Hash(token))) return user }, }, IfFalse: &rest.AuthBasicMiddleware{ Realm: authRealm, Authenticator: func(user string, password string) bool { if user == "user" && password == "password" { return true } return false }, }, }) api.Use(rest.DefaultDevStack...) router, err := rest.MakeRouter( rest.Post("/login", login), rest.Get("/containers", list), rest.Get("/container/:id", inspect), rest.Post("/image/build", build), rest.Post("/image/run", create), rest.Get("/container/start/:id", start), rest.Get("/container/stop/:id", stop), ) if err != nil { log.Fatal(err) } api.SetApp(router) log.Println("Port", port) log.Fatal(http.ListenAndServe(":"+port, api.MakeHandler())) }
func (fx_api *FxDaemonApi) RunApiServer() { api := rest.NewApi() api.Use(rest.DefaultDevStack...) router, err := rest.MakeRouter( rest.Post("/childs", fx_api.ChildServers), rest.Post("/child/iplookup", fx_api.ChildServerIpLookup), rest.Post("/transfer/container", fx_api.TransferContainer), ) if err != nil { log.Fatal(err) } api.SetApp(router) log.Fatal(http.ListenAndServe(fx_api.Fxd.ListenHost, api.MakeHandler())) }
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() { // 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 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 (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() { 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() { 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())) }
// MakeHandler creates the api request handler func MakeHandler() *http.Handler { api := rest.NewApi() // Create the geospcail index on the data // FIXME: The collection is currently specified by the client collection := "thing" _, err := dbAPI.Index(variables.ServiceDBURL, token.BackendToken, collection, "location", "2dsphere") if err != nil { log.Println("ERROR setting index:", err) } // Make sure we want to enable auth if variables.EnableAuth != false { authMiddleware, err := CreateAuthMiddleware() if err != nil { log.Fatal(err) } api.Use(&rest.IfMiddleware{ // Only authenticate non login or register requests Condition: func(request *rest.Request) bool { return true }, IfTrue: authMiddleware, }) } api.Use(rest.DefaultProdStack...) router, err := rest.MakeRouter( // For checking what is near a location rest.Post(dbVariables.APIPathNearServer, PostNear), // For geting and saving things rest.Get(dbVariables.APIPathGetServer, GetDoc), rest.Post(dbVariables.APIPathSaveServer, PostSaveDoc), // // For user actions such as login // rest.Post(variables.APIPathLoginUserServer, PostLoginUser), // rest.Get(variables.APIPathRefreshUserServer, PostRefreshUser), // rest.Post(variables.APIPathRegisterUserServer, PostRegisterUser), // 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 (r *Controller) serveREST(conf *goconf.ConfigFile) { c, err := parseRESTConfig(conf) if err != nil { r.log.Err(fmt.Sprintf("Controller: parsing REST configurations: %v", err)) return } api := rest.NewApi() router, err := rest.MakeRouter( rest.Get("/api/v1/switch", r.listSwitch), rest.Post("/api/v1/switch", r.addSwitch), rest.Delete("/api/v1/switch/:id", r.removeSwitch), rest.Options("/api/v1/switch/:id", r.allowOrigin), rest.Get("/api/v1/port/:switchID", r.listPort), rest.Get("/api/v1/network", r.listNetwork), rest.Post("/api/v1/network", r.addNetwork), rest.Delete("/api/v1/network/:id", r.removeNetwork), rest.Options("/api/v1/network/:id", r.allowOrigin), rest.Get("/api/v1/ip/:networkID", r.listIP), rest.Get("/api/v1/host", r.listHost), rest.Post("/api/v1/host", r.addHost), rest.Delete("/api/v1/host/:id", r.removeHost), rest.Options("/api/v1/host/:id", r.allowOrigin), rest.Get("/api/v1/vip", r.listVIP), rest.Post("/api/v1/vip", r.addVIP), rest.Delete("/api/v1/vip/:id", r.removeVIP), rest.Options("/api/v1/vip/:id", r.allowOrigin), rest.Put("/api/v1/vip/:id", r.toggleVIP), ) if err != nil { r.log.Err(fmt.Sprintf("Controller: making a REST router: %v", err)) return } api.SetApp(router) addr := fmt.Sprintf(":%v", c.port) if c.tls.enable { err = http.ListenAndServeTLS(addr, c.tls.certFile, c.tls.keyFile, api.MakeHandler()) } else { err = http.ListenAndServe(addr, api.MakeHandler()) } if err != nil { r.log.Err(fmt.Sprintf("Controller: listening on HTTP: %v", err)) return } }
func main() { api := rest.NewApi() statusMw := &rest.StatusMiddleware{} api.Use(statusMw) api.Use(&rest.GzipMiddleware{}) api.Use(&rest.AccessLogJsonMiddleware{}) api.Use(rest.DefaultDevStack...) router, err := rest.MakeRouter( //used for service status reporting rest.Get("/data/.status", func(w rest.ResponseWriter, r *rest.Request) { w.WriteJson(statusMw.GetStatus()) }), rest.Post("/login", login), rest.Post("/refresh", refresh), rest.Post("/signup", signup), rest.Get("/data/:userid/smbgs", func(w rest.ResponseWriter, r *rest.Request) { checkAuth(w, r, getSmbgs) }), rest.Post("/data/:userid/smbgs", func(w rest.ResponseWriter, r *rest.Request) { checkAuth(w, r, postSmbgs) }), rest.Put("/data/:userid/smbgs", notImplemented), rest.Get("/data/:userid/notes", func(w rest.ResponseWriter, r *rest.Request) { checkAuth(w, r, getNotes) }), rest.Post("/data/:userid/notes", func(w rest.ResponseWriter, r *rest.Request) { checkAuth(w, r, postNotes) }), rest.Put("/data/:userid/notes", notImplemented), rest.Get("/data/:userid/basals", notImplemented), rest.Post("/data/:userid/basals", notImplemented), rest.Put("/data/:userid/basals", notImplemented), rest.Get("/data/:userid/boluses", notImplemented), rest.Post("/data/:userid/boluses", notImplemented), rest.Put("/data/:userid/boluses", notImplemented), rest.Get("/data/:userid/cbgs", notImplemented), rest.Post("/data/:userid/cbgs", notImplemented), rest.Put("/data/:userid/cbgs", notImplemented), ) if err != nil { log.Fatal(err) } api.SetApp(router) log.Println(http.ListenAndServe(":8090", api.MakeHandler())) }
func main() { // Static Files fs := http.FileServer(http.Dir("app/dist")) http.Handle("/", fs) log.Println("Listening...") go http.ListenAndServe(":8080", nil) // Api api := rest.NewApi() api.Use(rest.DefaultDevStack...) api.Use(&rest.CorsMiddleware{ RejectNonCorsRequests: false, OriginValidator: func(origin string, request *rest.Request) bool { return true // origin == "http://127.0.0.1" }, AllowedMethods: []string{"GET", "POST", "PUT", "OPTIONS", "DELETE"}, AllowedHeaders: []string{ "Accept", "Content-Type", "Authorization", "Origin"}, AccessControlAllowCredentials: true, AccessControlMaxAge: 3600, }) api.Use(AuthMiddleware()) router, err := rest.MakeRouter( rest.Post("/auth/login", restapi.Login), rest.Post("/auth/register", restapi.Register), rest.Post("/api/importurl", restapi.ImportUrl), rest.Get("/api/documents", restapi.GetAllDocuments), rest.Post("/api/documents", restapi.PostDocument), rest.Get("/api/documents/:id", restapi.GetDocument), rest.Put("/api/documents/:id", restapi.PutDocument), rest.Delete("/api/documents/:id", restapi.DeleteDocument), ) if err != nil { log.Fatal(err) } api.SetApp(router) log.Printf("Port %s\n", conf.Port) log.Fatal(http.ListenAndServe(":"+conf.Port, api.MakeHandler())) }
// Serve a json api func startAPI() { api := rest.NewApi() api.Use(AuthMiddleware()) api.Use(rest.DefaultDevStack...) router, err := rest.MakeRouter( rest.Post("/login", login), rest.Post("/register", register), rest.Get("/apps", list), rest.Get("/demo/:id", demo), rest.Get("/claim/:id", claim), ) if err != nil { log.Fatal(err) } api.SetApp(router) log.Printf("Port %s\n", Config.Port) log.Fatal(http.ListenAndServe(":"+Config.Port, api.MakeHandler())) }
func main() { api := rest.NewApi() api.Use(rest.DefaultDevStack...) router, err := rest.MakeRouter( rest.Post("/api/v1/images", HandleImageCreate), rest.Get("/api/v1/images", HandleImageList), rest.Post("/api/v1/instances", HandleInstanceCreate), rest.Post("/api/v1/instances/:instanceid", HandleInstanceStart), rest.Put("/api/v1/instances/:instanceid", HandleInstanceStop), rest.Get("/api/v1/instances", HandleInstanceList), rest.Get("/api/v1/instances/:instanceid", HandleInstanceInfo), rest.Delete("/api/v1/instances/:instanceid", HandleInstanceDestroy), ) if err != nil { log.Fatal(err) } api.SetApp(router) log.Fatal(http.ListenAndServe(listen, api.MakeHandler())) }
func (i *Impl) startChat() { api := rest.NewApi() api.Use(rest.DefaultDevStack...) router, err := rest.MakeRouter( rest.Get("/", APIIndex), rest.Get("/users/:user_id.json", i.APIUserShow), rest.Get("/users/:user_id/dialogs.json", i.APIDialogIndex), rest.Get("/users/:user_id/dialogs/:dialog_id/messages.json", i.APIMessageIndex), rest.Get("/users/:user_id/dialogs/:dialog_id.json", i.APIDialogShow), rest.Post("/users/:user_id/dialogs.json", i.APIDialogCreate), rest.Post("/users/:user_id/dialogs/:dialog_id/messages.json", i.APIMessageCreate), ) if err != nil { log.Fatal(err) } api.SetApp(router) fmt.Println("address: ", viper.GetString("bind_address")) log.Fatal(http.ListenAndServe(viper.GetString("bind_address"), api.MakeHandler())) }
func serveRestApi(conf *config) { api := rest.NewApi() api.Use(rest.DefaultDevStack...) router, err := rest.MakeRouter( // rest.Get("/groups", getGroupsHandler), // rest.Get("/contacts", getContactsHandler), rest.Post("/addcontactstogroup", addContactsToGroupHandler), rest.Post("/creategroup", createGroupHandler), rest.Post("/addcontact", addContactHandler), // rest.Delete("/removegroup"), // rest.Delete("/removecontact"), // rest.Delete("/removeuser"), ) if err != nil { log.Fatal(err) } api.SetApp(router) http.Handle("/api/", http.StripPrefix("/api", api.MakeHandler())) }
func getRouter() (rest.App, error) { mcPlugins := routes.McPlugins{} router, err := rest.MakeRouter( rest.Get("/plugins", mcPlugins.GetAllPlugins), rest.Post("/plugins", mcPlugins.PostPlugin), rest.Get("/plugins/:id", mcPlugins.GetPlugin), rest.Put("/plugins/:id", mcPlugins.PutPlugin), rest.Delete("/plugins/:id", mcPlugins.DeletePlugin), ) return router, err }
func (restapi *CyberBullyingEntryPointRestApiImpl) RegisterApi() { if restapi.Api == nil { restapi.SetApi(nil) } router, err := rest.MakeRouter( rest.Post("/api/signup", restapi.SignUpUser), rest.Post("/api/signin", restapi.SignUpUser), rest.Get("/api/#parentid/childinfo", restapi.GetChildInfo), rest.Post("/api/#parentid/childinfo", restapi.AddChildInfo), rest.Put("/api/#parentid/childinfo", restapi.UpdateChildInfo), rest.Get("/api/childbullydata/#parentid/#childid", restapi.GetChildBullyData), rest.Post("/api/childbullydata/#parentid/#childid", restapi.PostChildBullyData), rest.Post("/api/predict", restapi.PredictBullyData), ) if err != nil { restapi.LoggerImplPtr.Error(err.Error()) panic(err) } restapi.Api.SetApp(router) }
// NewRouter return the configured routes for this API func NewRouter(jwtmiddleware *jwt.JWTMiddleware, session *r.Session) rest.App { trips := models.Trips{ Conn: session, } router, err := rest.MakeRouter( rest.Post("/login", jwtmiddleware.LoginHandler), rest.Get("/refresh_token", jwtmiddleware.RefreshHandler), rest.Get("/trips", trips.GetAllTrips), rest.Get("/trips/:id", trips.GetTrip), rest.Post("/trips", trips.PostTrip), rest.Patch("/trips/:id/updatePlaces", trips.UpdateTripPlaces), rest.Delete("/trips/:id/deletePlace/:place", trips.DeleteTripPlaces), ) if err != nil { log.Fatal(err) } return router }
func Route() (rest.App, error) { return rest.MakeRouter( // 新增某个服务 rest.Post("/apps", restGuarder(handler.CreateAppsHandler)), // 获取所有服务的基本信息 rest.Get("/apps", restGuarder(handler.GetInfoAppsHandler)), // TODO 获取某一个服务的详细信息 rest.Get("/apps/*appId", restGuarder(handler.GetSingleAppsHandler)), // 删除某一个服务的所有实例 rest.Delete("/apps/*appId", restGuarder(handler.DeleteAppsHandler)), // 新增或者更新一批服务 rest.Post("/apps/updater", restGuarder(handler.CreateOrUpdateAppsHandler)), // 回滚一批服务 rest.Post("/apps/rollback", restGuarder(handler.RollbackAppsHandler)), // 新增一批组信息 rest.Post("/groups", restGuarder(handler.DeployGroupsHandler)), // 给新增容器获取一个IP rest.Get("/ipholder/*cId", restGuarder(handler.CreateIpForContainer)), // 给删除容器释放所占用的IP rest.Delete("/ipholder/*cId", restGuarder(handler.DeleteIpForContainer)), // 填写某个容器信息 rest.Post("/containers", restGuarder(handler.CreateContainerInfo)), // 更新容器状态 rest.Post("/containers/:cId/:cState", restGuarder(handler.UpdateStateContainerInfo)), // 软删除容器 rest.Delete("/containers/soft/*cId", restGuarder(handler.MaskContainerInfo)), ) }
func main() { api := rest.NewApi() api.Use(rest.DefaultDevStack...) router, err := rest.MakeRouter( // TODO http://docs.aws.amazon.com/AWSEC2/latest/APIReference/OperationList-query.html rest.Post("/api/v1/images", ImageCreate), rest.Get("/api/v1/images", ImageList), rest.Post("/api/v1/instances", InstanceCreate), rest.Post("/api/v1/instances/:instanceid", InstanceStart), rest.Put("/api/v1/instances/:instanceid", InstanceStop), rest.Get("/api/v1/instances", InstanceList), rest.Delete("/api/v1/instances/:instanceid", InstanceDestroy), ) if err != nil { log.Fatal(err) } api.SetApp(router) log.Fatal(http.ListenAndServe(listen, api.MakeHandler())) }