func main() {
middle := interpose.New()
router := mux.NewRouter()
router.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
fmt.Fprintf(w, `<h1>Welcome to the public page!</h1><p><a href="/protected/">Rabbit hole</a></p>`)
})
middle.UseHandler(router)
// Now we will define a sub-router that uses the BasicAuth middleware
// When you call any url starting with the path /protected, you will need to authenticate
protectedRouter := mux.NewRouter().Methods("GET").PathPrefix("/protected").Subrouter()
protectedRouter.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
fmt.Fprintf(w, "Welcome to the protected page!")
})
// Define middleware that pertains to the part of the site protected behind HTTP Auth
// and add the protected router to the protected middleware
protectedMiddlew := interpose.New()
protectedMiddlew.Use(middleware.BasicAuth("john", "doe"))
protectedMiddlew.UseHandler(protectedRouter)
// Add the protected middleware and its router to the main router
router.Methods("GET").PathPrefix("/protected").Handler(protectedMiddlew)
http.ListenAndServe(":3001", middle)
}
func main() {
configuration := readConfiguration()
dbSession := DBConnect(configuration.MongodbUrl)
DBEnsureIndicesAndDefaults(dbSession, configuration.MongodbDatabaseName)
// handle all requests by serving a file of the same name
fs := http.Dir(configuration.Webapp)
fileHandler := http.FileServer(fs)
// setup routes
router := mux.NewRouter()
router.Handle("/", http.RedirectHandler("/webapp/index.html", 302))
router.PathPrefix("/webapp").Handler(http.StripPrefix("/webapp", fileHandler))
authRouterBase := mux.NewRouter()
router.PathPrefix("/auth").Handler(negroni.New(DBMiddleware(dbSession, configuration.MongodbDatabaseName), negroni.Wrap(authRouterBase)))
authRouter := authRouterBase.PathPrefix("/auth").Subrouter()
authRouter.HandleFunc("/login", Login).Methods("POST")
apiRouterBase := mux.NewRouter()
router.PathPrefix("/api").Handler(negroni.New(DBMiddleware(dbSession, configuration.MongodbDatabaseName), JWTMiddleware(), negroni.Wrap(apiRouterBase)))
apiRouter := apiRouterBase.PathPrefix("/api").Subrouter()
apiRouter.HandleFunc("/me", Me).Methods("GET")
http.ListenAndServe(fmt.Sprintf(":%v", configuration.Port), router)
}
// BuildRoutes returns the routes for the application.
func BuildRoutes() http.Handler {
router := mux.NewRouter()
router.HandleFunc("/", HomeHandler)
router.HandleFunc("/login-success", LoginSuccessHandler)
router.HandleFunc("/verify", VerifyHandler)
router.HandleFunc("/logout", LogoutHandler)
router.HandleFunc("/game", GameHandler)
// profile routes with LoginRequiredMiddleware
profileRouter := mux.NewRouter()
profileRouter.HandleFunc("/profile", ProfileHandler)
router.PathPrefix("/profile").Handler(negroni.New(
negroni.HandlerFunc(LoginRequiredMiddleware),
negroni.Wrap(profileRouter),
))
// apply the base middleware to the main router
n := negroni.New(
negroni.HandlerFunc(CsrfMiddleware),
negroni.HandlerFunc(UserMiddleware),
)
n.UseHandler(router)
return n
}
func main() {
logger := log.NewLogger()
cfg := config.Default()
flag.StringVar(&cfg.WSAddress, "ws", cfg.WSAddress, "Websocket address")
flag.StringVar(&cfg.RESTAddress, "rest", cfg.RESTAddress, "REST address")
flag.StringVar(&cfg.Origin, "o", cfg.Origin, "Origin URL")
file := flag.String("config", "", "Config file")
flag.Parse()
if *file != "" {
err := config.FromFile(*file, &cfg)
if err != nil {
logger.Err.Fatal(err)
}
flag.Parse()
}
broker := pubsub.NewBroker()
go func() {
wsRouter := mux.NewRouter()
wsRouter.Handle("/{id}", handlers.WSHandler{Broker: broker, Config: cfg, Logger: logger})
logger.Out.Println("Listening websockets on", cfg.WSAddress)
logger.Err.Fatal(http.ListenAndServe(cfg.WSAddress, wsRouter))
}()
go func() {
restRouter := mux.NewRouter()
restRouter.Handle("/topic", handlers.List{Broker: broker, Logger: logger}).Methods("GET")
restRouter.Handle("/topic", handlers.Add{Broker: broker, Logger: logger}).Methods("POST")
restRouter.Handle("/topic/{id}", handlers.Pub{Broker: broker, Logger: logger}).Methods("POST")
restRouter.Handle("/topic/{id}", handlers.Del{Broker: broker, Logger: logger}).Methods("DELETE")
restRouter.Handle("/ping", handlers.Ping{Logger: logger}).Methods("GET")
logger.Out.Println("Listening REST on", cfg.RESTAddress)
logger.Err.Fatal(http.ListenAndServe(cfg.RESTAddress, restRouter))
}()
wait := make(chan struct{})
<-wait
}
func router(config clientConfig) *mux.Router {
r := mux.NewRouter()
r.HandleFunc("/", indexHandler(config))
r.Handle("/favicon.ico", http.NotFoundHandler())
authMiddleware := negroni.HandlerFunc(ShotgunAuthMiddleware(config))
entityRoutes := mux.NewRouter()
entityRoutes.Path("/{entity_type}/{id:[0-9]+}").HandlerFunc(entityGetHandler(config)).Methods("GET")
entityRoutes.Path("/{entity_type}/{id:[0-9]+}").HandlerFunc(entityUpdateHandler(config)).Methods("PATCH")
entityRoutes.Path("/{entity_type}/{id:[0-9]+}").
HandlerFunc(entityDeleteHandler(config)).Methods("DELETE")
entityRoutes.Path("/{entity_type}/{id:[0-9]+}/revive").
HandlerFunc(entityReviveHandler(config)).Methods("POST")
// entityRoutes.Path("/{entity_type}/{id:[0-9]+}/followers").
// HandlerFunc(entityGetFollowersHandler(config)).Methods("GET")
//entityRoutes.Path("/{entity_type}/{id:[0-9]+}/followers").
// HandlerFunc(entityAddFollowersHandler(config)).Methods("POST")
//entityRoutes.Path("/{entity_type}/{id:[0-9]+}/followers/{user_type}/{user_id:[0-9]+}").
// HandlerFunc(entityDeleteFollowersHandler(config)).Methods("DELETE")
entityRoutes.Path("/{entity_type}").HandlerFunc(entityGetAllHandler(config)).Methods("GET")
entityRoutes.Path("/{entity_type}").HandlerFunc(entityCreateHandler(config)).Methods("POST")
// Adds auth on the sub router so that / can be accessed freely.
r.PathPrefix("/{entity_type}").Handler(negroni.New(
authMiddleware,
negroni.Wrap(entityRoutes),
))
return r
}
func main() {
middle := interpose.New()
router := mux.NewRouter()
router.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
fmt.Fprintf(w, `<h1>Welcome to the public page!</h1><p><a href="/protected/">Rabbit hole</a></p>`)
})
middle.UseHandler(router)
// Now we will define a sub-router that uses the BasicAuth middleware
// When you call any url starting with the path /protected, you will need to authenticate
protectedRouter := mux.NewRouter().Methods("GET").PathPrefix("/protected").Subrouter()
protectedRouter.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
fmt.Fprintf(w, "Welcome to the protected page, %s!", context.Get(req, authKey))
})
protectedMiddlew := interpose.New()
protectedMiddlew.Use(middleware.BasicAuthFunc(func(user, pass string, req *http.Request) bool {
if middleware.SecureCompare(user, "admin") && middleware.SecureCompare(pass, "guessme") {
context.Set(req, authKey, user)
return true
} else {
return false
}
}))
protectedMiddlew.Use(context.ClearHandler)
protectedMiddlew.UseHandler(protectedRouter)
router.Methods("GET").PathPrefix("/protected").Handler(protectedMiddlew)
http.ListenAndServe(":3001", middle)
}
func TestTopicsCreateJson(t *testing.T) {
initTestDB()
defer closeTestDB()
// We try to create a topic for the first time.
body := "{\"name\":\"mssola\"}"
reader := strings.NewReader(body)
req, err := http.NewRequest("POST", "/topics", reader)
if err != nil {
t.Fatalf("Expected to be nil: %v", err)
}
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
m := mux.NewRouter()
m.HandleFunc("/topics", TopicsCreate)
m.ServeHTTP(w, req)
var topic Topic
decoder := json.NewDecoder(w.Body)
err = decoder.Decode(&topic)
if err != nil {
t.Fatalf("Expected to be nil: %v", err)
}
var t1 Topic
err = Db.SelectOne(&t1, "select * from topics")
if err != nil {
t.Fatalf("Expected to be nil: %v", err)
}
if t1.ID != topic.ID {
t.Fatalf("Got %v; Expected: %v", t1.ID, topic.ID)
}
if t1.Name != topic.Name {
t.Fatalf("Got %v; Expected: %v", t1.Name, topic.Name)
}
// Now let's try it with the same name.
reader2 := strings.NewReader(body)
req, err = http.NewRequest("POST", "/topics", reader2)
if err != nil {
t.Fatalf("Expected to be nil: %v", err)
}
req.Header.Set("Content-Type", "application/json")
w1 := httptest.NewRecorder()
m = mux.NewRouter()
m.HandleFunc("/topics", TopicsCreate)
m.ServeHTTP(w1, req)
var resp lib.Response
decoder = json.NewDecoder(w1.Body)
err = decoder.Decode(&resp)
if err != nil {
t.Fatalf("Expected to be nil: %v", err)
}
if resp.Error != "Failed!" {
t.Fatalf("Got %v; Expected: %v", resp.Error, "Failed!")
}
}
// MakeMuxer creates a http.Handler to manage all list operations. If
// a prefix is given, that prefix will be the first part of the
// url. This muxer will provide the following handlers and return a
// RESTful 404 on all others.
//
// GET prefix + / Get all lists.
// POST prefix + / Create a new list.
//
// GET prefix + /{key}/ Get the list for the given key.
// PUT prefix + /{key}/ Update the list with the given key.
// DELETE prefix + /{key}/ Delete the list with the given key.
//
// See the functions related to these urls for more details on what
// each one does and the requirements behind it.
func MakeMuxer(prefix string) http.Handler {
var m *mux.Router
// Pass through the prefix if we got one.
if prefix == "" {
m = mux.NewRouter()
} else {
m = mux.NewRouter().PathPrefix(prefix).Subrouter()
}
// Get all lists.
m.HandleFunc("/", GetAllLists).Methods("GET")
// Make a new list.
m.HandleFunc("/", PostList).Methods("POST")
// Singe list operations.
m.HandleFunc("/{key}/", GetList).Methods("GET")
m.HandleFunc("/{key}/", PutList).Methods("PUT")
m.HandleFunc("/{key}/", DeleteList).Methods("DELETE")
// Everything else fails.
m.HandleFunc("/{path:.*}", gorca.NotFoundFunc)
return m
}
func (a *Api) Run() error {
globalMux := http.NewServeMux()
authRouter := mux.NewRouter()
authRouter.HandleFunc("/auth/login", a.login).Methods("GET")
authRouter.HandleFunc("/auth/logout", a.logout).Methods("GET")
authRouter.HandleFunc("/auth/callback", a.authCallback).Methods("GET")
apiRouter := mux.NewRouter()
apiRouter.Handle("/api/domains", a.authRequiredMiddleware(http.HandlerFunc(a.domains))).Methods("GET")
apiRouter.Handle("/api/domains", a.authRequiredMiddleware(http.HandlerFunc(a.addDomain))).Methods("POST")
apiRouter.Handle("/api/domains/{prefix:.*}", a.authRequiredMiddleware(http.HandlerFunc(a.removeDomain))).Methods("DELETE")
apiRouter.HandleFunc("/api/ip", a.getIP).Methods("GET")
//globalMux.Handle("/api/", apiRouter)
globalMux.Handle("/api/", apiRouter)
globalMux.Handle("/auth/", authRouter)
// global handler
globalMux.Handle("/", http.FileServer(http.Dir("static")))
s := &http.Server{
Addr: a.listenAddr,
Handler: context.ClearHandler(globalMux),
}
if err := s.ListenAndServe(); err != nil {
return err
}
return http.ListenAndServe(a.listenAddr, context.ClearHandler(globalMux))
}
func main() {
finish := make(chan bool)
router1 := mux.NewRouter()
router1.HandleFunc("/keys", handleGetAllKey1).Methods("GET")
router1.HandleFunc("/keys/{key}", handleGetKey1).Methods("GET")
router1.HandleFunc("/keys/{key}/{value}", handlePutKey1).Methods("PUT")
go func() {
http.ListenAndServe(":3000", router1)
}()
router2 := mux.NewRouter()
router2.HandleFunc("/keys", handleGetAllKey2).Methods("GET")
router2.HandleFunc("/keys/{key}", handleGetKey2).Methods("GET")
router2.HandleFunc("/keys/{key}/{value}", handlePutKey2).Methods("PUT")
go func() {
http.ListenAndServe(":3001", router2)
}()
router3 := mux.NewRouter()
router3.HandleFunc("/keys", handleGetAllKey3).Methods("GET")
router3.HandleFunc("/keys/{key}", handleGetKey3).Methods("GET")
router3.HandleFunc("/keys/{key}/{value}", handlePutKey3).Methods("PUT")
go func() {
http.ListenAndServe(":3002", router3)
}()
<-finish
}
// Start the application
func (a *Application) Run() (errChan chan error) {
errChan = make(chan error)
clientMux := mux.NewRouter()
clientMux.HandleFunc("/status/", a.handlers.StatusHandler)
clientMux.HandleFunc("/realstatus/", a.handlers.RealStatusHandler)
clientMux.Handle("/", websocket.Server{Handler: a.handlers.PushSocketHandler,
Handshake: a.checkOrigin})
endpointMux := mux.NewRouter()
endpointMux.HandleFunc("/update/{key}", a.handlers.UpdateHandler)
endpointMux.HandleFunc("/status/", a.handlers.StatusHandler)
endpointMux.HandleFunc("/realstatus/", a.handlers.RealStatusHandler)
endpointMux.HandleFunc("/metrics/", a.handlers.MetricsHandler)
routeMux := mux.NewRouter()
routeMux.HandleFunc("/route/{uaid}", a.handlers.RouteHandler)
// Weigh the anchor!
go func() {
clientLn := a.server.ClientListener()
if a.log.ShouldLog(INFO) {
a.log.Info("app", "Starting WebSocket server",
LogFields{"addr": clientLn.Addr().String()})
}
clientSrv := &http.Server{
Handler: &LogHandler{clientMux, a.log},
ErrorLog: log.New(&LogWriter{a.log.Logger, "worker", ERROR}, "", 0)}
errChan <- clientSrv.Serve(clientLn)
}()
go func() {
endpointLn := a.server.EndpointListener()
if a.log.ShouldLog(INFO) {
a.log.Info("app", "Starting update server",
LogFields{"addr": endpointLn.Addr().String()})
}
endpointSrv := &http.Server{
Handler: &LogHandler{endpointMux, a.log},
ErrorLog: log.New(&LogWriter{a.log.Logger, "endpoint", ERROR}, "", 0)}
errChan <- endpointSrv.Serve(endpointLn)
}()
go func() {
routeLn := a.router.Listener()
if a.log.ShouldLog(INFO) {
a.log.Info("app", "Starting router",
LogFields{"addr": routeLn.Addr().String()})
}
routeSrv := &http.Server{
Handler: &LogHandler{routeMux, a.log},
ErrorLog: log.New(&LogWriter{a.log.Logger, "router", ERROR}, "", 0)}
errChan <- routeSrv.Serve(routeLn)
}()
return errChan
}
func Init(apps map[string]interface{}, router *mux.Router) {
Applications = apps
// /echo/* Endpoints
echoRouter := mux.NewRouter()
// /* Endpoints
pageRouter := mux.NewRouter()
for uri, meta := range Applications {
switch app := meta.(type) {
case EchoApplication:
handlerFunc := func(w http.ResponseWriter, r *http.Request) {
echoReq := r.Context().Value("echoRequest").(*EchoRequest)
echoResp := NewEchoResponse()
if echoReq.GetRequestType() == "LaunchRequest" {
if app.OnLaunch != nil {
app.OnLaunch(echoReq, echoResp)
}
} else if echoReq.GetRequestType() == "IntentRequest" {
if app.OnIntent != nil {
app.OnIntent(echoReq, echoResp)
}
} else if echoReq.GetRequestType() == "SessionEndedRequest" {
if app.OnSessionEnded != nil {
app.OnSessionEnded(echoReq, echoResp)
}
} else {
http.Error(w, "Invalid request.", http.StatusBadRequest)
}
json, _ := echoResp.String()
w.Header().Set("Content-Type", "application/json;charset=UTF-8")
w.Write(json)
}
if app.Handler != nil {
handlerFunc = app.Handler
}
echoRouter.HandleFunc(uri, handlerFunc).Methods("POST")
case StdApplication:
pageRouter.HandleFunc(uri, app.Handler).Methods(app.Methods)
}
}
router.PathPrefix("/echo/").Handler(negroni.New(
negroni.HandlerFunc(validateRequest),
negroni.HandlerFunc(verifyJSON),
negroni.Wrap(echoRouter),
))
router.PathPrefix("/").Handler(negroni.New(
negroni.Wrap(pageRouter),
))
}
// NewRouter will return the router specified by the server
// config. If no Router value is supplied, the server
// will default to using Gorilla mux.
func NewRouter(cfg *Config) Router {
switch cfg.RouterType {
case "fast", "httprouter":
return &FastRouter{httprouter.New()}
case "gorilla":
return &GorillaRouter{mux.NewRouter()}
default:
return &GorillaRouter{mux.NewRouter()}
}
}
func (a *ApiTestSuite) TestSetupApiRoutes() {
db := &job.MockDB{}
cache := job.NewMockCache()
r := mux.NewRouter()
SetupApiRoutes(r, cache, db)
a.NotNil(r)
a.IsType(r, mux.NewRouter())
}
func main() {
ren := render.New(render.Options{
Layout: "shared/layout",
IsDevelopment: true,
})
//sessions
store := cookiestore.New([]byte("secret"))
//db
// db, err := sqlx.Connect("postgres", os.Getenv("CONNECTIONSTRING"))
db, err := sqlx.Connect("postgres", "user=travisjones dbname=cm_app sslmode=disable")
if err != nil {
log.Println("Error initializing database...")
log.Fatalln(err)
}
c := ctx{db, ren}
n := negroni.New()
nauth := negroni.New()
//routers
router := mux.NewRouter()
authRouter := mux.NewRouter()
//AUTHORIZED ROUTES
authRouter.HandleFunc("/", c.Home)
router.Handle("/", nauth).Methods("GET")
//OPEN ROUTES
router.HandleFunc("/account/login", c.Login).Methods("GET")
router.HandleFunc("/account/login", c.LoginPost).Methods("POST")
router.HandleFunc("/account/signup", c.Signup).Methods("GET")
router.HandleFunc("/account/signup", c.SignupPost).Methods("POST")
router.HandleFunc("/account/logout", c.Logout).Methods("GET")
//Middleware
nauth.Use(negroni.HandlerFunc(RequireAuth))
nauth.UseHandler(authRouter)
//Sessions
n.Use(sessions.Sessions("authex", store))
n.Use(negroni.NewStatic(http.Dir("public")))
n.UseHandler(router)
n.Run(
fmt.Sprint(":", os.Getenv("PORT")),
)
}
func main() {
flag.Parse()
store.Init()
p := func(name string, handler http.HandlerFunc) http.Handler {
return prometheus.InstrumentHandler(name, handler)
}
router := mux.NewRouter()
router.Handle("/metrics", prometheus.Handler())
router.Handle("/", p("/", home))
router.Handle("/login", p("/login", login))
router.Handle("/verify", p("/verify", verify))
apiRouter := mux.NewRouter()
apiRouter.Handle("/api/logout", p("/logout", logout))
apiRouter.Handle("/api/user", p("/user", user))
apiRouter.Handle("/api/user/project", p("/user/project", userProject))
apiRouter.Handle("/api/project", p("/project", project))
apiRouter.Handle("/api/project/member", p("/task/member", member))
apiRouter.Handle("/api/task", p("/task", task))
apiRouter.Handle("/api/task/worker", p("/task/worker", worker))
apiRouter.Handle("/api/milestone", p("/milestone", milestone))
apiRouter.Handle("/api/friend", p("/friend", friend))
apiRouter.Handle("/api/chat", p("/chat", chat))
apiRouter.HandleFunc("/api/ws", ws)
router.PathPrefix("/api").Handler(negroni.New(
negroni.HandlerFunc(apiMiddleware),
negroni.Wrap(apiRouter),
))
adminRouter := mux.NewRouter()
adminRouter.Handle("/api/admin/user", p("/admin/user", adminUser))
adminRouter.Handle("/api/admin/project", p("/admin/project", adminProject))
router.PathPrefix("/api/admin").Handler(negroni.New(
negroni.HandlerFunc(adminMiddleware),
negroni.Wrap(adminRouter),
))
go h.run()
n := negroni.Classic()
n.UseHandler(router)
port := os.Getenv("PORT")
if port == "" {
port = "8080"
}
n.Run(":" + port)
}
func main() {
var err error
db, err = sqlx.Connect("postgres", "user=postgres password=postgres dbname=messenger sslmode=disable")
if err != nil {
log.Fatalln(err)
}
CreateSchema(false)
r := mux.NewRouter()
authBase := mux.NewRouter()
apiBase := mux.NewRouter()
auth := authBase.PathPrefix("/auth").Subrouter()
api := apiBase.PathPrefix("/api").Subrouter()
r.PathPrefix("/auth").Handler(negroni.New(
negroni.NewRecovery(),
negroni.NewLogger(),
negroni.Wrap(authBase),
))
jwtSecret = "a very secret string"
// must be authenticated to use api routes
jwtMiddleware := jwtmiddleware.New(jwtmiddleware.Options{
ValidationKeyGetter: func(token *jwt.Token) (interface{}, error) {
return []byte(jwtSecret), nil
},
SigningMethod: jwt.SigningMethodHS256,
UserProperty: "jwt_user",
})
r.PathPrefix("/api").Handler(negroni.New(
negroni.NewRecovery(),
negroni.NewLogger(),
negroni.HandlerFunc(jwtMiddleware.HandlerWithNext),
negroni.Wrap(apiBase),
))
// used to check if server is live
auth.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "pong")
}).Methods("POST")
auth.Path("/signup").HandlerFunc(Signup).Methods("POST")
auth.Path("/login").HandlerFunc(Login).Methods("POST")
api.Path("/messages").HandlerFunc(NewMessage).Methods("POST")
api.HandleFunc("/{user}/messages", GetUsersMessages).Methods("GET")
log.Fatal(http.ListenAndServe(":8080", r))
}
func main() {
middle := interpose.New()
// First call middleware that may manipulate HTTP headers, since
// they must be called before the HTTP body is manipulated
// Using Gorilla framework's combined logger
middle.Use(middleware.GorillaLog())
//Using Negroni's Gzip functionality
middle.Use(middleware.NegroniGzip(gzip.DefaultCompression))
// Now call middleware that can manipulate the HTTP body
// Define the router. Note that we can add the router to our
// middleware stack before we define the routes, if we want.
router := mux.NewRouter()
middle.UseHandler(router)
// Configure our router
router.HandleFunc("/{user}", func(w http.ResponseWriter, req *http.Request) {
fmt.Fprintf(w, "Welcome to the home page, %s!", mux.Vars(req)["user"])
})
// Define middleware that will apply to only some routes
greenMiddle := interpose.New()
// Tell the main router to send /green requests to our subrouter.
// Again, we can do this before defining the full middleware stack.
router.Methods("GET").PathPrefix("/green").Handler(greenMiddle)
// Within the secondary middleware, just like above, we want to call anything that
// will modify the HTTP headers before anything that will modify the body
greenMiddle.UseHandler(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
rw.Header().Set("X-Favorite-Color", "green")
}))
// Finally, define a sub-router based on our love of the color green
// When you call any url such as http://localhost:3001/green/man , you will
// also see an HTTP header sent called X-Favorite-Color with value "green"
greenRouter := mux.NewRouter().Methods("GET").PathPrefix("/green").Subrouter() //Headers("Accept", "application/json")
greenMiddle.UseHandler(greenRouter)
greenRouter.HandleFunc("/{user}", func(w http.ResponseWriter, req *http.Request) {
fmt.Fprintf(w, "Welcome to the home page, green %s!", mux.Vars(req)["user"])
})
http.ListenAndServe(":3001", middle)
}
func main() {
flag.Parse()
markers = make(map[string]map[string]string)
portString := strconv.Itoa(port)
stop := make(chan bool)
go func() {
for {
select {
case <-time.After(1 * time.Second):
update()
case <-stop:
return
}
}
}()
r := mux.NewRouter()
r.HandleFunc("/gps", gps)
http.Handle("/", &CorsServer{r})
fmt.Printf("bus-server listening on port %s\n", portString)
err := http.ListenAndServe(":"+portString, nil)
if err != nil {
panic(err)
}
}
func Main() {
config = LoadConfig()
BaseUrl = config.BaseUrl
ArticlePrefix = config.ArticlePrefix
log.LogTo(config.LogTo, config.LogLevel)
logger = log.NewPrefixLogger("MAIN")
db = newDb()
defer db.Close()
artclesPath := fmt.Sprintf("/%s", ArticlePrefix)
articlePath := fmt.Sprintf("/%s/{source_slug}/{article_slug}/{article_id:[0-9]+}", ArticlePrefix)
r := mux.NewRouter()
r.HandleFunc(articlePath, serve(articleHandler)).Methods("GET")
r.HandleFunc(articlePath, serve(reFetchArticleHandler)).Methods("PUT")
r.HandleFunc(artclesPath, serve(articlesHandler)).Methods("GET")
r.NotFoundHandler = http.HandlerFunc(unknownHandler)
port := "8080" //os.Getenv("PORT")
logger.Info("Listening on port %s\n", port)
http.ListenAndServe(":"+port, r)
}
func CreateRouter(server contracts.Server) (*mux.Router, error) {
r := mux.NewRouter()
m := map[string]map[string]HttpApiFunc{
"GET": {
"/replays/{id:[0-9]+}": server.GetReplay,
},
"POST": {
"/join": server.JoinMatch,
"/create": server.CreateMatch,
"/start": server.StartMatch,
},
}
for method, routes := range m {
for route, handler := range routes {
localRoute := route
localHandler := handler
localMethod := method
f := makeHttpHandler(localMethod, localRoute, localHandler)
r.Path(localRoute).Methods(localMethod).HandlerFunc(f)
}
}
return r, nil
}
func MakeTestServer(repository matchRepository) *negroni.Negroni {
server := negroni.New() // don't need all the middleware here or logging.
mx := mux.NewRouter()
initRoutes(mx, formatter, repository)
server.UseHandler(mx)
return server
}
func (t Twilio) Handler() *mux.Router {
m := mux.NewRouter()
m.Path("/sms").HandlerFunc(sms)
m.Path("/call/inbound").HandlerFunc(inboundCall)
m.Path("/call/outbound").HandlerFunc(outboundCall)
return m
}
func main() {
// configure the github oauth parameters
config := &auth.GitHubConfig{
&auth.Config{
ClientID: os.Getenv("GITHUB_CLIENT_ID"),
ClientSecret: os.Getenv("GITHUB_CLIENT_SECRET"),
CallbackURL: os.Getenv("GITHUB_CALLBACK_URL"),
},
}
auth.SetGitHubConfig(config)
// setup a store, in our case one using secure cookies
store := sessions.NewCookieStore([]byte("something-very-secret"))
s := auth.NewServer(store)
// configure a mux
r := mux.NewRouter()
r.PathPrefix(auth.PathPrefix).Handler(s.GetMux())
// add a wrapper to check the session for each request
o := auth.CheckSession(r, store)
// listen to the network
http.ListenAndServe(":5000", o)
}
// setupTestServer creates a listener for the rest requests.
func setupTestServer() {
router := mux.NewRouter()
// register handlers for cni
t := router.Headers("Content-Type", "application/json").Methods("POST").Subrouter()
t.HandleFunc(cniapi.EPAddURL, httpWrapper(stubAddPod))
t.HandleFunc(cniapi.EPDelURL, httpWrapper(stubDeletePod))
driverPath := cniapi.ContivCniSocket
os.Remove(driverPath)
os.MkdirAll(cniapi.PluginPath, 0700)
go func() {
l, err := net.ListenUnix("unix", &net.UnixAddr{Name: driverPath, Net: "unix"})
if err != nil {
panic(err)
}
logger.Infof("k8s test plugin listening on %s", driverPath)
http.Serve(l, router)
l.Close()
logger.Infof("k8s test plugin closing %s", driverPath)
}()
}
func setupDaemon(port int) {
router := mux.NewRouter()
router.HandleFunc("/", HomeHandler)
http.Handle("/", router)
http.Handle("/static/", http.FileServer(http.Dir(".")))
restHandler := rest.ResourceHandler{}
restHandler.SetRoutes(
rest.Route{"GET", "/api/test", RestTest},
)
restHandler.EnableGzip = true
restHandler.EnableLogAsJson = true
restHandler.EnableResponseStackTrace = true
restHandler.EnableStatusService = true
http.Handle("/api/", &restHandler)
err := http.ListenAndServe(fmt.Sprintf(":%d", port), handlers.CombinedLoggingHandler(os.Stdout, http.DefaultServeMux))
if err != nil {
log.Fatalln(err)
}
}
func TestReportPostHandler(t *testing.T) {
test := func(contentType string, encoder func(interface{}) ([]byte, error)) {
router := mux.NewRouter()
c := app.NewCollector(1 * time.Minute)
app.RegisterReportPostHandler(c, router)
ts := httptest.NewServer(router)
defer ts.Close()
b, err := encoder(fixture.Report)
if err != nil {
t.Fatalf("Content-Type %s: %s", contentType, err)
}
req, err := http.NewRequest("POST", ts.URL+"/api/report", bytes.NewReader(b))
if err != nil {
t.Fatalf("Error posting report: %v", err)
}
req.Header.Set("Content-Type", contentType)
resp, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatalf("Error posting report %v", err)
}
_, err = ioutil.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
t.Fatalf("Error posting report: %v", err)
}
if resp.StatusCode != http.StatusOK {
t.Fatalf("Error posting report: %d", resp.StatusCode)
}
ctx := context.Background()
report, err := c.Report(ctx)
if err != nil {
t.Error(err)
}
if want, have := fixture.Report.Endpoint.Nodes, report.Endpoint.Nodes; len(have) == 0 || len(want) != len(have) {
t.Fatalf("Content-Type %s: %v", contentType, test.Diff(have, want))
}
}
test("", func(v interface{}) ([]byte, error) {
buf := &bytes.Buffer{}
err := gob.NewEncoder(buf).Encode(v)
return buf.Bytes(), err
})
test("application/json", func(v interface{}) ([]byte, error) {
buf := &bytes.Buffer{}
err := codec.NewEncoder(buf, &codec.JsonHandle{}).Encode(v)
return buf.Bytes(), err
})
test("application/msgpack", func(v interface{}) ([]byte, error) {
buf := &bytes.Buffer{}
err := codec.NewEncoder(buf, &codec.MsgpackHandle{}).Encode(v)
return buf.Bytes(), err
})
}
func setupRoutes(cfg config.WebConfig) {
log.LogInfo("Theme templates mapped to '%v'", cfg.TemplateDir)
log.LogInfo("Theme static content mapped to '%v'", cfg.PublicDir)
r := mux.NewRouter()
// Static content
r.PathPrefix("/public/").Handler(http.StripPrefix("/public/",
http.FileServer(http.Dir(cfg.PublicDir))))
// Root
r.Path("/").Handler(handler(RootIndex)).Name("RootIndex").Methods("GET")
r.Path("/status").Handler(handler(RootStatus)).Name("RootStatus").Methods("GET")
r.Path("/link/{name}/{id}").Handler(handler(MailboxLink)).Name("MailboxLink").Methods("GET")
r.Path("/mailbox").Handler(handler(MailboxIndex)).Name("MailboxIndex").Methods("GET")
r.Path("/mailbox/{name}").Handler(handler(MailboxList)).Name("MailboxList").Methods("GET")
r.Path("/mailbox/{name}").Handler(handler(MailboxPurge)).Name("MailboxPurge").Methods("DELETE")
r.Path("/mailbox/{name}/{id}").Handler(handler(MailboxShow)).Name("MailboxShow").Methods("GET")
r.Path("/mailbox/{name}/{id}/html").Handler(handler(MailboxHtml)).Name("MailboxHtml").Methods("GET")
r.Path("/mailbox/{name}/{id}/source").Handler(handler(MailboxSource)).Name("MailboxSource").Methods("GET")
r.Path("/mailbox/{name}/{id}").Handler(handler(MailboxDelete)).Name("MailboxDelete").Methods("DELETE")
r.Path("/mailbox/dattach/{name}/{id}/{num}/{file}").Handler(handler(MailboxDownloadAttach)).Name("MailboxDownloadAttach").Methods("GET")
r.Path("/mailbox/vattach/{name}/{id}/{num}/{file}").Handler(handler(MailboxViewAttach)).Name("MailboxViewAttach").Methods("GET")
// Register w/ HTTP
Router = r
http.Handle("/", Router)
}
func main() {
dbHost := flag.String("dbhost", "localhost", "the database host")
dbPort := flag.Int("dbport", 5432, "the database port")
dbUser := flag.String("dbuser", "aclapp", "the database user")
dbSsl := flag.Bool("dbssl", false, "database ssl config")
dbName := flag.String("dbname", "acl", "the database name")
dbPassword := flag.String("dbpass", "", "database password")
flag.Parse()
config := pgmapper.DefaultConfig()
config.Host = *dbHost
config.Port = *dbPort
config.User = *dbUser
config.Ssl = *dbSsl
config.Database = *dbName
config.Password = *dbPassword
r := mux.NewRouter()
mapper, err := pgmapper.New(config)
if err != nil {
log.Fatal(err)
}
objectIdExtractor := idextractor.MuxIdExtractor("objectId")
userIdExtractor := idextractor.MuxIdExtractor("userId")
r.Methods("POST").Path("/objects").Handler(jwtware.New(addObjectHandler(mapper)))
r.Methods("DELETE").Path("/objects/{objectId}").Handler(jwtware.New(deleteObjectHandler(mapper, objectIdExtractor)))
r.Methods("GET").Path("/objects/{objectId}/permissions/{userId}").Handler(jwtware.New(getPermissionsHandler(mapper, objectIdExtractor, userIdExtractor)))
r.Methods("PUT").Path("/objects/{objectId}/permissions").Handler(jwtware.New(upsertPermissionsHandler(mapper, objectIdExtractor)))
r.Methods("PUT").Path("/sids/{sid}/permissions").Handler(jwtware.New(upsertMultiplePermissionsHandler(mapper, idextractor.MuxIdExtractor("sid"))))
log.Println("listening on 8080")
http.ListenAndServe(":8080", r)
}
//Start starts the c2b api server
//starts the callback listener
func (c2b *C2B) Start() {
r := mux.NewRouter()
r.HandleFunc("/", c2b.useMiddleware(
common.CheckHeader(),
))
r.HandleFunc("/{code}", c2b.useMiddleware(
common.CheckHeader(),
))
go func() {
server.ListenAndServe(c2b.address, r)
}()
go func() {
for {
select {
case trx := <-c2b.callback:
if trx == nil {
return
}
fmt.Println("Delaying by:", c2b.config.CallBackDelay)
time.Sleep(time.Second * time.Duration(c2b.config.CallBackDelay))
c2b.callClientCallBack(trx)
}
}
}()
fmt.Println("C2B started: ", c2b.address)
}