예제 #1
0
파일: main.go 프로젝트: yetone/rest-layer
func main() {
	// Create a REST API handler
	api := rest.New()

	// Add a resource on /users[/:user_id]
	users := api.Bind("users", rest.NewResource(user, mem.NewHandler(), rest.Conf{
		// We allow all REST methods
		// (rest.ReadWrite is a shortcut for []rest.Mode{Create, Read, Update, Delete, List})
		AllowedModes: rest.ReadWrite,
	}))

	// Bind a sub resource on /users/:user_id/posts[/:post_id]
	// and reference the user on each post using the "user" field of the posts resource.
	posts := users.Bind("posts", "user", rest.NewResource(post, mem.NewHandler(), rest.Conf{
		// Posts can only be read, created and deleted, not updated
		AllowedModes: []rest.Mode{rest.Read, rest.List, rest.Create, rest.Delete},
	}))

	// Add a friendly alias to public posts
	// (equivalent to /users/:user_id/posts?filter=public=true)
	posts.Alias("public", url.Values{"filter": []string{"public=true"}})

	// Add cors support
	h := cors.New(cors.Options{OptionsPassthrough: true}).Handler(api)

	// Bind the API under /api/ path
	http.Handle("/api/", http.StripPrefix("/api/", h))

	// Serve it
	log.Print("Serving API on http://localhost:8080")
	if err := http.ListenAndServe(":8080", nil); err != nil {
		log.Fatal(err)
	}
}
예제 #2
0
func main() {
	r := mux.NewRouter().StrictSlash(true)

	var mgoConn = os.Getenv("MGOCONN")

	if mgoConn == "" {
		log.Fatal("No connection string found.")
	}

	log.Println(mgoConn)

	db := db.NewDatabase(mgoConn, "house")

	tc := controllers.NewTransactionController(db)
	hc := controllers.NewHomeController()

	r.HandleFunc("/", hc.HomeHandler).Methods("GET")
	r.HandleFunc("/transactions", tc.GetTransactionsHandler).Methods("GET")
	r.HandleFunc("/transactions/{id}", tc.GetTransactionHandler).Methods("GET")
	r.HandleFunc("/transactions", tc.PostTransactionHandler).Methods("POST")
	http.Handle("/", r)
	log.Println("Listening on port 8080")

	c := cors.New(cors.Options{
		AllowedOrigins: []string{"*"},
	})

	handler := c.Handler(r)
	log.Fatal(http.ListenAndServe(":8080", handler))
}
예제 #3
0
func Start(pipe *xeth.XEth, config RpcConfig) error {
	if rpclistener != nil {
		if fmt.Sprintf("%s:%d", config.ListenAddress, config.ListenPort) != rpclistener.Addr().String() {
			return fmt.Errorf("RPC service already running on %s ", rpclistener.Addr().String())
		}
		return nil // RPC service already running on given host/port
	}

	l, err := newStoppableTCPListener(fmt.Sprintf("%s:%d", config.ListenAddress, config.ListenPort))
	if err != nil {
		glog.V(logger.Error).Infof("Can't listen on %s:%d: %v", config.ListenAddress, config.ListenPort, err)
		return err
	}
	rpclistener = l

	var handler http.Handler
	if len(config.CorsDomain) > 0 {
		var opts cors.Options
		opts.AllowedMethods = []string{"POST"}
		opts.AllowedOrigins = []string{config.CorsDomain}

		c := cors.New(opts)
		handler = newStoppableHandler(c.Handler(JSONRPC(pipe)), l.stop)
	} else {
		handler = newStoppableHandler(JSONRPC(pipe), l.stop)
	}

	go http.Serve(l, handler)

	return nil
}
예제 #4
0
// NewAPI instantiates a new API with a resolver. Sync determines whether to
// sync the underlying repo with a remote origin
func NewAPI(resolver Resolver) http.Handler {
	api := API{resolver: resolver}
	router := httprouter.New()
	router.GET("/", Index)
	router.POST("/token", api.tokenFn())
	router.GET("/files/*path", api.wrap(GetFile))
	router.DELETE("/files/*path", api.wrap(DeleteFile))

	router.POST("/blobs", api.wrap(CreateBlob))
	router.GET("/blobs/:sha", api.wrap(GetBlob))

	router.POST("/trees", api.wrap(CreateTree))
	router.GET("/trees/:sha", api.wrap(GetTree))

	router.POST("/commits", api.wrap(CreateCommit))
	router.GET("/commits/:sha", api.wrap(GetCommit))

	router.GET("/refs/*ref", api.wrap(GetRef))
	router.PATCH("/refs/*ref", api.wrap(UpdateRef))

	corsHandler := cors.New(cors.Options{
		AllowedMethods:   []string{"GET", "POST", "PATCH", "PUT", "DELETE"},
		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type"},
		AllowCredentials: true,
	})

	return corsHandler.Handler(router)
}
예제 #5
0
func main() {
	// middleware
	middle := interpose.New()
	middle.Use(adaptors.FromNegroni(cors.New(cors.Options{
		// CORS
		AllowedOrigins: []string{"*"},
	})))

	// router
	router := pat.New()
	middle.UseHandler(router)

	router.Get("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		url := r.URL.Query().Get("url")

		if url != "" {
			encoded := imgbase64.FromRemote(url)
			fmt.Fprint(w, encoded)
		} else {
			fmt.Fprint(w, "/?url=<your-image-url> returns the base64 data-URI of that image.")
		}
	}))

	// listen
	port := os.Getenv("PORT")
	if port == "" {
		port = "5000"
	}
	log.Print("listening...")
	http.ListenAndServe(":"+port, middle)
}
예제 #6
0
func main() {
	flag.Parse()
	if *helpFlag {
		fmt.Fprintf(os.Stderr, "Usage of %s\n", os.Args[0])
		flag.PrintDefaults()
		os.Exit(1)
	}
	config := loadConfig(*configFile)

	logger := setupLogging(config.Log.File)

	mysqlDbmap := iamok.PrepareDBMap(config.MySql.ConnectionString)
	defer mysqlDbmap.Db.Close()

	mysqlDbmap.TraceOn("[gorp]", &Foo{})

	router := iamok.NewRouter()

	//Logs the http requests status
	logHandler := handlers.LoggingHandler(logger, router)
	c := cors.New(cors.Options{
		AllowedMethods: []string{"GET", "POST", "DELETE", "OPTIONS", "PUT"},
		AllowedHeaders: []string{"X-Requested-With", "Accept", "Content-Type"},
		Debug:          true,
	}) //for accepting CORS requests
	http.ListenAndServe(":8080", iamok.RecoveryHandler{Handler: c.Handler(logHandler)})
}
예제 #7
0
// Route handler for the server
func Handler() http.Handler {
	router := mux.NewRouter()

	// Set up the websocket server
	wsServer, err := socketio.NewServer(nil)
	if err != nil {
		log.Fatal(err)
	}
	wsServer.On("connection", func(so socketio.Socket) {
		log.Println("on connection")
		socket = so
	})
	router.Handle("/socket.io/", wsServer)

	// GET /clients
	// List all registered registration IDs
	router.HandleFunc("/clients", ListClients).Methods("GET")

	// POST /message
	// Send a new message
	router.HandleFunc("/message", SendMessage).Methods("POST")

	c := cors.New(cors.Options{
		AllowCredentials: true,
	})
	return c.Handler(router)
}
예제 #8
0
func main() {
	fmt.Println("Welcome to Sample bank Server:::::::")
	fmt.Println(time.Now())
	///DO db stuff
	appDb := AppDb{}
	appDb.initDb()
	appDb.initSchema()
	// appDb.createDummyData()

	c := cors.New(cors.Options{
		AllowedOrigins: []string{"http://localhost:3500"},
	})

	// c := cors.Default()
	r := mux.NewRouter().StrictSlash(false)
	accounts := r.Path("/accounts").Subrouter()
	accounts.Methods("GET").HandlerFunc(appDb.accountsHandler)
	accounts.Methods("POST").HandlerFunc(appDb.createClientsHandler)

	account := r.PathPrefix("/accounts/{id}").Subrouter()
	account.Methods("GET").HandlerFunc(appDb.accountHandler)
	account.Methods("PUT").HandlerFunc(appDb.updateAccountHandler)
	account.Methods("DELETE").HandlerFunc(appDb.deleteHandler)

	http.ListenAndServe(":8050", c.Handler(r))
}
예제 #9
0
func (self *API) Serve() error {
	self.router = httprouter.New()

	if err := self.loadRoutes(); err != nil {
		return err
	}

	go func() {
		dc := diecast.NewServer()
		dc.Address = self.Address
		dc.Port = self.Port + 1
		dc.LogLevel = `debug`

		if err := dc.Initialize(); err == nil {
			dc.Serve()
		}
	}()

	self.cors = cors.New(cors.Options{
		AllowedOrigins: []string{`*`},
		AllowedHeaders: []string{`*`},
	})

	self.server = negroni.New()
	self.server.Use(negroni.NewRecovery())
	self.server.Use(self.cors)
	self.server.UseHandler(self.router)

	self.server.Run(fmt.Sprintf("%s:%d", self.Address, self.Port))

	return nil
}
예제 #10
0
func (s *Server) Start() error {
	n := negroni.New()
	n.Use(cors.New(cors.Options{
		AllowCredentials: true,
	}))
	/*
		n.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,
		})
	*/
	n.Use(negroni.NewRecovery())
	n.Use(NewLogger())
	n.UseFunc(s.Auth.LoginRequired)
	n.UseHandler(s.Api.Handler())

	s.server = &graceful.Server{
		Timeout: 10 * time.Second,
		Server: &http.Server{
			Addr:    s.Config.BindAddress,
			Handler: n,
		},
	}

	s.listenAndGoServe()

	return nil
}
예제 #11
0
func StartHttp(cfg HttpConfig, codec codec.Codec, api shared.EthereumApi) error {
	if httpListener != nil {
		if fmt.Sprintf("%s:%d", cfg.ListenAddress, cfg.ListenPort) != httpListener.Addr().String() {
			return fmt.Errorf("RPC service already running on %s ", httpListener.Addr().String())
		}
		return nil // RPC service already running on given host/port
	}

	l, err := newStoppableTCPListener(fmt.Sprintf("%s:%d", cfg.ListenAddress, cfg.ListenPort))
	if err != nil {
		glog.V(logger.Error).Infof("Can't listen on %s:%d: %v", cfg.ListenAddress, cfg.ListenPort, err)
		return err
	}
	httpListener = l

	var handler http.Handler
	if len(cfg.CorsDomain) > 0 {
		var opts cors.Options
		opts.AllowedMethods = []string{"POST"}
		opts.AllowedOrigins = strings.Split(cfg.CorsDomain, " ")

		c := cors.New(opts)
		handler = newStoppableHandler(c.Handler(gethHttpHandler(codec, api)), l.stop)
	} else {
		handler = newStoppableHandler(gethHttpHandler(codec, api), l.stop)
	}

	go http.Serve(l, handler)

	return nil
}
예제 #12
0
// The main routine is going the "entry" point.
func main() {
	// Create a new router.
	router := mux.NewRouter()

	// RESTful defines operations
	// * GET for fetching data
	// * POST for inserting data
	// * PUT for updating existing data
	// * DELETE for deleting data
	router.HandleFunc("/contacts", ListContacts(MyContacts)).Methods("GET")
	router.HandleFunc("/contacts/{id}", UpdateContact(MyContacts)).Methods("PUT")

	// The info endpoint is for showing demonstration purposes only and is not subject to any task.
	router.HandleFunc("/info", InfoHandler).Methods("GET")

	// Print where to point the browser at.
	fmt.Printf("Listening on %s\n", "http://localhost:5678")

	// Cross origin resource requests
	c := cors.New(cors.Options{
		AllowedOrigins: []string{"*"},
		AllowedMethods: []string{"GET", "POST", "DELETE", "PUT"}},
	)

	// Start up the server and check for errors.
	listenOn := fmt.Sprintf("%s:%s", envHost, envPort)
	err := http.ListenAndServe(listenOn, c.Handler(router))
	if err != nil {
		log.Fatalf("Could not set up server because %s", err)
	}
}
예제 #13
0
// RunServer starts vertice httpd server.
func NewNegHandler() *negroni.Negroni {
	c := cors.New(cors.Options{
		AllowedOrigins: []string{"*"},
	})

	m := &delayedRouter{}
	for _, handler := range megdHandlerList {
		m.Add(handler.method, handler.path, handler.h)
	}

	m.Add("Get", "/", Handler(index))
	m.Add("Get", "/logs", Handler(logs))
	m.Add("Get", "/ping", Handler(ping))
	//we can use this as a single click Terminal launch for docker.
	//m.Add("Get", "/apps/{appname}/shell", websocket.Handler(remoteShellHandler))
	n := negroni.New()
	n.Use(negroni.NewRecovery())
	n.Use(c)
	n.Use(newLoggerMiddleware())
	n.UseHandler(m)
	n.Use(negroni.HandlerFunc(contextClearerMiddleware))
	n.Use(negroni.HandlerFunc(flushingWriterMiddleware))
	n.Use(negroni.HandlerFunc(errorHandlingMiddleware))
	n.Use(negroni.HandlerFunc(authTokenMiddleware))
	n.UseHandler(http.HandlerFunc(runDelayedHandler))
	return n
}
예제 #14
0
func main() {
	log.SetFlags(log.LstdFlags | log.Lshortfile)

	flag.Parse()

	// Connect to RethinkDB
	var err error
	session, err = r.Connect(r.ConnectOpts{
		Address: *rethinkAddress,
	})
	if err != nil {
		log.Fatal(err)
	}

	// Create the database and tables
	r.DbCreate(*rethinkName).Exec(session)
	r.Db(*rethinkName).TableCreate("invites").Exec(session)
	r.Db(*rethinkName).Table("invites").IndexCreate("email").Exec(session)
	r.Db(*rethinkName).Table("invites").IndexCreate("name").Exec(session)

	// Add a CORS middleware
	goji.Use(cors.New(cors.Options{
		AllowCredentials: true,
	}).Handler)

	// Add routes to goji
	goji.Get("/", index)
	goji.Post("/check", check)
	goji.Post("/free", free)
	goji.Post("/create", create)

	// Start the server
	goji.Serve()
}
예제 #15
0
func Example() {
	session, err := mgo.Dial("")
	if err != nil {
		log.Fatalf("Can't connect to MongoDB: %s", err)
	}
	db := "test_rest_layer"

	index := resource.NewIndex()

	users := index.Bind("users", user, mongo.NewHandler(session, db, "users"), resource.Conf{
		AllowedModes: resource.ReadWrite,
	})

	users.Bind("posts", "user", post, mongo.NewHandler(session, db, "posts"), resource.Conf{
		AllowedModes: resource.ReadWrite,
	})

	api, err := rest.NewHandler(index)
	if err != nil {
		log.Fatalf("Invalid API configuration: %s", err)
	}

	http.Handle("/", cors.New(cors.Options{OptionsPassthrough: true}).Handler(api))

	log.Print("Serving API on http://localhost:8080")
	if err := http.ListenAndServe(":8080", nil); err != nil {
		log.Fatal(err)
	}
}
예제 #16
0
func main() {
	router := NewRouter()

	// connect mongoDB
	log.Println("Starting mongodb session")
	var err error
	session, err = mgo.Dial("localhost")
	if err != nil {
		panic(err)
	}
	defer session.Close()
	session.SetMode(mgo.Monotonic, true)

	// instantiate db & tokens collection as variable
	db = session.DB("confessions")
	tokens = session.DB("confessions").C("tokens")

	//cors
	c := cors.New(cors.Options{
		AllowedOrigins: []string{"http://*****:*****@ localhost:8000")
}
예제 #17
0
파일: http.go 프로젝트: codeaudit/shift
// StartHTTP starts listening for RPC requests sent via HTTP.
func StartHttp(cfg HttpConfig, codec codec.Codec, api shared.EthereumApi) error {
	httpServerMu.Lock()
	defer httpServerMu.Unlock()

	addr := fmt.Sprintf("%s:%d", cfg.ListenAddress, cfg.ListenPort)
	if httpServer != nil {
		if addr != httpServer.Addr {
			return fmt.Errorf("RPC service already running on %s ", httpServer.Addr)
		}
		return nil // RPC service already running on given host/port
	}
	// Set up the request handler, wrapping it with CORS headers if configured.
	handler := http.Handler(&handler{codec, api})
	if len(cfg.CorsDomain) > 0 {
		opts := cors.Options{
			AllowedMethods: []string{"POST"},
			AllowedOrigins: strings.Split(cfg.CorsDomain, " "),
		}
		handler = cors.New(opts).Handler(handler)
	}
	// Start the server.
	s, err := listenHTTP(addr, handler)
	if err != nil {
		glog.V(logger.Error).Infof("Can't listen on %s:%d: %v", cfg.ListenAddress, cfg.ListenPort, err)
		return err
	}
	httpServer = s
	return nil
}
예제 #18
0
파일: main.go 프로젝트: MustWin/go-base
func setupMiddleware() []http.Handler {
	return []http.Handler{
		adaptors.HandlerFromNegroni(cors.New(cors.Options{
			AllowedOrigins:   viper.GetStringSlice("cors.allowed_origins"),
			AllowedMethods:   viper.GetStringSlice("cors.allowed_methods"),
			AllowCredentials: viper.GetBool("cors.allow_credentials"),
		})),
		adaptors.HandlerFromNegroni(negroni.HandlerFunc(secure.New(secure.Options{
			AllowedHosts:            []string{},
			SSLRedirect:             false,
			SSLTemporaryRedirect:    false,
			SSLHost:                 "",
			SSLProxyHeaders:         map[string]string{},
			STSSeconds:              0,
			STSIncludeSubdomains:    false,
			STSPreload:              false,
			ForceSTSHeader:          false,
			FrameDeny:               false,
			CustomFrameOptionsValue: "",
			ContentTypeNosniff:      false,
			BrowserXssFilter:        false,
			ContentSecurityPolicy:   "",
			IsDevelopment:           viper.GetString("environment") == "development",
		}).HandlerFuncWithNext)),
	}
}
예제 #19
0
파일: main.go 프로젝트: glycerine/origins
// setup prepares the internal HTTP handle, middleware, and resources.
func (s *Server) setup() {
	e := echo.New()
	s.core = e

	// Enable HTTP 2
	e.HTTP2(true)

	// Toggle debug
	e.SetDebug(s.Debug)

	// Setup middleware.
	e.Use(mw.Logger())
	e.Use(mw.Recover())
	e.Use(mw.Gzip())

	// Setup CORS.
	e.Use(cors.New(cors.Options{
		AllowedOrigins: s.AllowedHosts,
	}).Handler)

	// Add middleware for setting the server context.
	e.Use(s.serverContext)

	e.Get("/", httpRoot)
	e.Get("/domains", httpDomains)

	e.Get("/log/:domain", httpLog)
	e.Get("/log/:domain/entities", httpDomainEntities)
	e.Get("/log/:domain/attributes", httpDomainAttributes)
	e.Get("/log/:domain/values", httpDomainValues)

	e.Get("/timeline/:domain", httpTimeline)
}
예제 #20
0
파일: main.go 프로젝트: demipixel/Helen
func main() {
	helpers.InitLogger()
	config.SetupConstants()

	if config.Constants.ProfilerEnable {
		address := "localhost:" + config.Constants.ProfilerPort
		go func() {
			graceful.Run(address, 1*time.Second, nil)
		}()
		helpers.Logger.Debug("Running Profiler at %s", address)
	}

	pid := &pid.Instance{}
	if pid.Create() == nil {
		defer pid.Remove()
	}

	authority.RegisterTypes()
	helpers.InitAuthorization()
	database.Init()
	migrations.Do()
	stores.SetupStores()
	models.PaulingConnect()
	models.FumbleConnect()
	models.InitializeLobbySettings("./lobbySettingsData.json")

	StartPaulingListener()
	chelpers.InitDB()
	if config.Constants.SteamIDWhitelist != "" {
		go chelpers.WhitelistListener()
	}
	// lobby := models.NewLobby("cp_badlands", 10, "a", "a", 1)
	helpers.Logger.Debug("Starting the server")

	// init http server

	// init socket.io server
	server := wsevent.NewServer()
	nologin := wsevent.NewServer()

	broadcaster.Init(server, nologin)
	socket.ServerInit(server, nologin)
	routes.SetupHTTPRoutes(server, nologin)

	if val := os.Getenv("DEPLOYMENT_ENV"); strings.ToLower(val) != "production" {
		// init static FileServer
		// TODO be careful to set this to correct location when deploying
		http.HandleFunc("/static/", func(w http.ResponseWriter, r *http.Request) {
			http.ServeFile(w, r, r.URL.Path[1:])
		})
	}
	corsHandler := cors.New(cors.Options{
		AllowedOrigins:   config.Constants.AllowedCorsOrigins,
		AllowCredentials: true,
	}).Handler(http.DefaultServeMux)

	// start the server
	helpers.Logger.Debug("Serving at %s", config.Constants.Domain)
	graceful.Run(":"+config.Constants.Port, 1*time.Second, corsHandler)
}
예제 #21
0
func main() {

	//setup sessions
	/*
		sh := redis.NewSessionHolder()
		redisconfig := viper.GetStringMapString("redis")
		if _, ok := redisconfig["host"]; !ok {
			panic("failed to read redis host")
		}
		if _, ok := redisconfig["port"]; !ok {
			panic("failed to read redis port")
		}

		redisip, err := alias2ipaddr(redisconfig["host"])
		if err != nil {
			panic("failed to lookup redis IP address")
		}
		goji.Use(redis.BuildRedis(fmt.Sprintf("%s:%s", redisip, redisconfig["port"])))
		goji.Use(base.BuildSessionMiddleware(sh))
	*/

	c := cors.New(cors.Options{
		AllowedOrigins: []string{"*"},
	})
	goji.Use(c.Handler)

	//setup render middleware
	goji.Use(middleware.RenderMiddleware)

	//setup database
	/*
		dbconfig := viper.GetStringMapString("db")
		if _, ok := dbconfig["host"]; !ok {
			panic("failed to read db host")
		}
		if _, ok := dbconfig["name"]; !ok {
			panic("failed to read db name")
		}
		goji.Use(middleware.PostgresMiddleware)

		goji.Use(middleware.AuthMiddleware)
	*/

	//setup routes
	goji.Get("/home", controllers.IndexHandler)
	goji.Get("/healthcheck", controllers.HealthCheckHandler)
	goji.Get("/login", controllers.Login)
	goji.Get("/oauth2callback", controllers.OAuth2Callback)
	//goji.Get("/logout", controllers.Logout)

	//setup static assets
	goji.Use(gojistatic.Static("/go/src/bower_components", gojistatic.StaticOptions{SkipLogging: true, Prefix: "bower_components"}))
	goji.Use(gojistatic.Static("/go/src/frontend/js", gojistatic.StaticOptions{SkipLogging: true, Prefix: "js"}))

	//begin
	log.Info("Starting App...")

	flag.Set("bind", ":80")
	goji.Serve()
}
예제 #22
0
파일: main.go 프로젝트: rs/rest-layer
func main() {
	// Create a REST API resource index
	index := resource.NewIndex()

	// Add a resource on /users[/:user_id]
	users := index.Bind("users", user, mem.NewHandler(), resource.Conf{
		// We allow all REST methods
		// (rest.ReadWrite is a shortcut for []resource.Mode{resource.Create, resource.Read, resource.Update, resource.Delete, resource,List})
		AllowedModes: resource.ReadWrite,
	})

	// Bind a sub resource on /users/:user_id/posts[/:post_id]
	// and reference the user on each post using the "user" field of the posts resource.
	posts := users.Bind("posts", "user", post, mem.NewHandler(), resource.Conf{
		// Posts can only be read, created and deleted, not updated
		AllowedModes: []resource.Mode{resource.Read, resource.List, resource.Create, resource.Delete},
	})

	// Add a friendly alias to public posts
	// (equivalent to /users/:user_id/posts?filter={"published":true})
	posts.Alias("public", url.Values{"filter": []string{"{\"published\":true}"}})

	// Create API HTTP handler for the resource graph
	api, err := rest.NewHandler(index)
	if err != nil {
		log.Fatalf("Invalid API configuration: %s", err)
	}

	c := alice.New()

	// Add close notifier handler so context is cancelled when the client closes
	// the connection
	// c.Append(xhandler.CloseHandler)

	// Add timeout handler
	// c.Append(xhandler.TimeoutHandler(2 * time.Second))

	// Install a logger (see https://github.com/rs/xlog)
	c = c.Append(xlog.NewHandler(xlog.Config{}))
	resource.LoggerLevel = resource.LogLevelDebug
	resource.Logger = func(ctx context.Context, level resource.LogLevel, msg string, fields map[string]interface{}) {
		xlog.FromContext(ctx).OutputF(xlog.Level(level), 2, msg, fields)
	}

	// Log API access
	c = c.Append(xaccess.NewHandler())

	// Add CORS support with passthrough option on so rest-layer can still
	// handle OPTIONS method
	c = c.Append(cors.New(cors.Options{OptionsPassthrough: true}).Handler)

	// Bind the API under /api/ path
	http.Handle("/api/", http.StripPrefix("/api/", c.Then(api)))

	// Serve it
	log.Print("Serving API on http://localhost:8080")
	if err := http.ListenAndServe(":8080", nil); err != nil {
		log.Fatal(err)
	}
}
예제 #23
0
파일: server.go 프로젝트: clawio/clawiod
func (s *Server) corsHandler(h http.Handler) http.Handler {
	dirs := s.conf.GetDirectives()
	opts := cors.Options{}
	opts.AllowedOrigins = dirs.Server.CORSAccessControlAllowOrigin
	opts.AllowedMethods = dirs.Server.CORSAccessControlAllowMethods
	opts.AllowedHeaders = dirs.Server.CORSAccessControlAllowHeaders
	return cors.New(opts).Handler(h)
}
예제 #24
0
// CorsHandler handler for CORS (Cross Origin Resource Sharing)
func CorsHandler(h http.Handler) http.Handler {
	c := cors.New(cors.Options{
		AllowedOrigins: []string{"*"},
		AllowedMethods: []string{"GET", "HEAD", "POST", "PUT"},
		AllowedHeaders: []string{"*"},
	})
	return c.Handler(h)
}
예제 #25
0
func buildCORS(debug bool) *cors.Cors {
	return cors.New(cors.Options{
		AllowedOrigins: []string{"http://localhost*"},
		AllowedHeaders: []string{"*"},
		AllowedMethods: []string{"POST", "PATCH", "GET", "DELETE"},
		Debug:          debug,
	})
}
예제 #26
0
파일: main.go 프로젝트: wangjohn/mutombo
func CORSHandler() web.MiddlewareType {
	var c *cors.Cors
	c = cors.New(cors.Options{
		AllowedOrigins:   []string{"*"},
		AllowedMethods:   []string{"GET", "POST", "OPTIONS"},
		AllowCredentials: true,
	})
	return c.Handler
}
예제 #27
0
파일: echocors.go 프로젝트: steveoc64/godev
func Init(e *echo.Echo, Debug bool) {
	c := cors.New(cors.Options{
		AllowedOrigins:   []string{"*"},
		AllowedMethods:   []string{"GET", "POST", "DELETE", "PUT", "PATCH"},
		AllowCredentials: true,
		Debug:            Debug,
	})
	e.Use(standard.WrapMiddleware(c.Handler))
}
예제 #28
0
파일: router.go 프로젝트: nildev/api-host
func RegisterRoutes(r *mux.Router, cfg config.Config) {
	routes := gen.BuildRoutes()
	jwtMiddleware := jwtmiddleware.New(jwtmiddleware.Options{
		ValidationKeyGetter: func(token *jwt.Token) (interface{}, error) {
			return []byte(cfg.Secret), nil
		},
		// When set, the middleware verifies that tokens are signed with the specific signing algorithm
		// If the signing method is not constant the ValidationKeyGetter callback can be used to implement additional checks
		// Important to avoid security issues described here: https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/
		SigningMethod: jwt.SigningMethodHS256,
	})

	corsMlw := cors.New(cors.Options{
		AllowedOrigins:     cfg.CORSAllowedOrigins,
		AllowedMethods:     cfg.CORSAllowedMethods,
		AllowedHeaders:     cfg.CORSAllowedHeaders,
		ExposedHeaders:     cfg.CORSExposedHeaders,
		AllowCredentials:   cfg.CORSAllowCredentials,
		MaxAge:             cfg.CORSMaxAge,
		OptionsPassthrough: cfg.CORSOptionsPassThrough,
		Debug:              cfg.CORSDebug,
	})

	for _, rt := range routes {
		apiRouter := mux.NewRouter().StrictSlash(true)
		for _, route := range rt.Routes {
			handlerFunc := negroni.New()

			// Add CORS middleware
			handlerFunc.Use(corsMlw)

			// Add JWT middleware if route is protected
			if route.Protected {
				handlerFunc.Use(negroni.HandlerFunc(jwtMiddleware.HandlerWithNext))
			}

			apiRouter.
				Methods(route.Method...).
				Name(route.Name).
				Path(fmt.Sprintf("%s%s", rt.BasePattern, route.Pattern)).
				Queries(route.Queries...).
				HandlerFunc(route.HandlerFunc)

			// Add actual handler
			handlerFunc.Use(negroni.Wrap(apiRouter))
			r.PathPrefix(rt.BasePattern).Handler(handlerFunc)

			ctxLog.WithField("base-path", rt.BasePattern).
				WithField("protected", route.Protected).
				WithField("name", route.Name).
				WithField("path", fmt.Sprintf("%s%s", rt.BasePattern, route.Pattern)).
				WithField("method", route.Method).
				WithField("query", fmt.Sprintf("%+v", route.Queries)).
				Debugf("%+v", route)
		}
	}
}
예제 #29
0
func CORS(c *web.C, h http.Handler) http.Handler {
	cors := cors.New(cors.Options{
		AllowedOrigins: []string{"*"},
		AllowedHeaders: []string{"*"},
		AllowedMethods: []string{"GET", "POST", "PATCH"},
		Debug:          true,
	})

	return cors.Handler(h)
}
예제 #30
0
파일: main.go 프로젝트: nerdzeu/nerdz-api
func main() {
	// Initialize routes
	r := router.Init(nerdz.Configuration.EnableLog)
	// Enalble CORS globally
	r.Use(echo.WrapMiddleware(cors.New(cors.Options{}).Handler))
	// Recover from panics
	r.Use(middleware.Recover())
	// Start the router
	r.Start(":" + strconv.Itoa(int(nerdz.Configuration.Port)))
}