Beispiel #1
0
// standardHttp starts serving standard HTTP (api/web) requests, to be used by normal clients
func standardHttp(discovery bool) {
	m := martini.Classic()

	switch strings.ToLower(config.Config.AuthenticationMethod) {
	case "basic":
		{
			if config.Config.HTTPAuthUser == "" {
				// Still allowed; may be disallowed in future versions
				log.Warning("AuthenticationMethod is configured as 'basic' but HTTPAuthUser undefined. Running without authentication.")
			}
			m.Use(auth.Basic(config.Config.HTTPAuthUser, config.Config.HTTPAuthPassword))
		}
	case "multi":
		{
			if config.Config.HTTPAuthUser == "" {
				// Still allowed; may be disallowed in future versions
				log.Fatal("AuthenticationMethod is configured as 'multi' but HTTPAuthUser undefined")
			}

			m.Use(auth.BasicFunc(func(username, password string) bool {
				if username == "readonly" {
					// Will be treated as "read-only"
					return true
				}
				return auth.SecureCompare(username, config.Config.HTTPAuthUser) && auth.SecureCompare(password, config.Config.HTTPAuthPassword)
			}))
		}
	default:
		{
			// We inject a dummy User object because we have function signatures with User argument in api.go
			m.Map(auth.User(""))
		}
	}

	m.Use(gzip.All())
	// Render html templates from templates directory
	m.Use(render.Renderer(render.Options{
		Directory:       "resources",
		Layout:          "templates/layout",
		HTMLContentType: "text/html",
	}))
	m.Use(martini.Static("resources/public"))

	inst.SetMaintenanceOwner(logic.ThisHostname)

	log.Info("Starting HTTP")

	if discovery {
		go logic.ContinuousDiscovery()
	}
	inst.ReadClusterAliases()

	http.API.RegisterRequests(m)
	http.Web.RegisterRequests(m)

	// Serve
	if err := nethttp.ListenAndServe(config.Config.ListenAddress, m); err != nil {
		log.Fatale(err)
	}
}
Beispiel #2
0
func main() {
	m := martini.Classic()

	m.Use(gzip.All())

	// render html templates from templates directory
	m.Use(render.Renderer(render.Options{
		Layout: "layout",
	}))

	m.Use(DB())

	m.Get("/", func(r render.Render, db *mgo.Database) {
		data := map[string]interface{}{"quotes": GetAll(db)}
		r.HTML(200, "list", data)
	})

	m.Post("/", binding.Form(Quote{}), func(r render.Render, db *mgo.Database, quote Quote) {
		db.C("quotes").Insert(quote)
		data := map[string]interface{}{"quotes": GetAll(db)}
		r.HTML(200, "list", data)
	})

	m.Run()
}
Beispiel #3
0
func main() {
	log.Info("启动")
	//读取配置文件
	base.BaseConfig.Read("config.json")
	// 初始化数据库
	base.InitDb()
	// 检查文件完整性
	//err := base.CheckFiles()
	//if(err!=nil){
	//  log.Error(err)
	//  return
	//}
	m := martini.Classic()
	// gzip支持
	m.Use(gzip.All())
	// 模板支持
	m.Use(render.Renderer())
	//
	m.Get("/meta.js", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/javascript")
		w.Write([]byte(base.GetMetaJs()))
	})
	// websocket 支持
	m.Get("/ws", websocket.Handler(base.WsHandler).ServeHTTP)
	m.NotFound(func(r render.Render) {
		r.HTML(404, "404", nil)
	})
	log.Info(fmt.Sprintf("访问地址 http://localhost:%d", base.BaseConfig.Web.Port))
	// 端口号
	http.ListenAndServe(fmt.Sprintf(":%d", base.BaseConfig.Web.Port), m)
	// m.Run()
	log.Info("退出")
}
Beispiel #4
0
func App() *martini.ClassicMartini {
	m := martini.Classic()

	m.Use(gzip.All())

	m.Use(render.Renderer(render.Options{
		Directory: "templates",
	}))

	m.Use(cors.Allow(&cors.Options{
		AllowAllOrigins: true,
	}))

	m.Get("", Index)

	m.Group("/repos", func(r martini.Router) {
		r.Get("", ReposIndex)
		r.Get("/:name", ReposShow)
	})

	m.Group("/orgs", func(r martini.Router) {
		r.Get("", OrgsIndex)
		r.Get("/:id", OrgsShow)
	})

	m.Group("/users", func(r martini.Router) {
		r.Get("", UserIndex)
		r.Get("/:id", UserShow)
	})

	m.Get("/stats", StatsIndex)
	m.Get("/issues", IssuesIndex)

	return m
}
Beispiel #5
0
// Http starts serving HTTP (api/web) requests
func Http() {
	martini.Env = martini.Prod
	m := martini.Classic()
	if config.Config.HTTPAuthUser != "" {
		m.Use(auth.Basic(config.Config.HTTPAuthUser, config.Config.HTTPAuthPassword))
	}

	m.Use(gzip.All())
	// Render html templates from templates directory
	m.Use(render.Renderer(render.Options{
		Directory:       "resources",
		Layout:          "templates/layout",
		HTMLContentType: "text/html",
	}))
	m.Use(martini.Static("resources/public"))

	go agent.ContinuousOperation()

	log.Infof("Starting HTTP on port %d", config.Config.HTTPPort)

	http.API.RegisterRequests(m)

	// Serve
	if config.Config.UseSSL {
		log.Info("Serving via SSL")
		err := nethttp.ListenAndServeTLS(fmt.Sprintf(":%d", config.Config.HTTPPort), config.Config.SSLCertFile, config.Config.SSLPrivateKeyFile, m)
		if err != nil {
			log.Fatale(err)
		}
	} else {
		nethttp.ListenAndServe(fmt.Sprintf(":%d", config.Config.HTTPPort), m)
	}
}
Beispiel #6
0
func mount(war string) {

	m := martini.Classic()
	m.Handlers(martini.Recovery())
	m.Use(gzip.All())
	m.Use(martini.Static(war, martini.StaticOptions{SkipLogging: true}))
	//    m.Use(render.Renderer(render.Options{
	//        Extensions: []string{".html", ".shtml"},
	//    }))
	//	m.Use(render.Renderer())
	//    m.Use(midTextDefault)

	//map web
	m.Use(func(w http.ResponseWriter, c martini.Context) {
		web := &Web{w: w}
		c.Map(web)
	})

	m.Group("/test", func(api martini.Router) {
		api.Get("", mainHandler)
		api.Get("/1", test1Handler)
		api.Get("/2", test2Handler)
	})

	http.Handle("/", m)
}
Beispiel #7
0
// NewWebService creates a new web service ready to run.
func NewWebService() *martini.Martini {
	m := martini.New()
	m.Handlers(loggerMiddleware(), martini.Recovery(), gzip.All())
	r := newRouter()
	m.MapTo(r, (*martini.Routes)(nil))
	m.Action(r.Handle)
	return m
}
Beispiel #8
0
// Http starts serving HTTP (api/web) requests
func Http() {
	martini.Env = martini.Prod
	m := martini.Classic()
	if config.Config.HTTPAuthUser != "" {
		m.Use(auth.Basic(config.Config.HTTPAuthUser, config.Config.HTTPAuthPassword))
	}

	m.Use(gzip.All())
	// Render html templates from templates directory
	m.Use(render.Renderer(render.Options{
		Directory:       "resources",
		Layout:          "templates/layout",
		HTMLContentType: "text/html",
	}))
	m.Use(martini.Static("resources/public"))
	if config.Config.UseMutualTLS {
		m.Use(ssl.VerifyOUs(config.Config.SSLValidOUs))
	}

	go agent.ContinuousOperation()

	log.Infof("Starting HTTP on port %d", config.Config.HTTPPort)

	http.API.RegisterRequests(m)

	listenAddress := fmt.Sprintf(":%d", config.Config.HTTPPort)

	// Serve
	if config.Config.UseSSL {
		if len(config.Config.SSLCertFile) == 0 {
			log.Fatale(errors.New("UseSSL is true but SSLCertFile is unspecified"))
		}

		if len(config.Config.SSLPrivateKeyFile) == 0 {
			log.Fatale(errors.New("UseSSL is true but SSLPrivateKeyFile is unspecified"))
		}

		log.Info("Starting HTTPS listener")
		tlsConfig, err := ssl.NewTLSConfig(config.Config.SSLCAFile, config.Config.UseMutualTLS)
		if err != nil {
			log.Fatale(err)
		}
		if err = ssl.AppendKeyPair(tlsConfig, config.Config.SSLCertFile, config.Config.SSLPrivateKeyFile); err != nil {
			log.Fatale(err)
		}
		if err = ssl.ListenAndServeTLS(listenAddress, m, tlsConfig); err != nil {
			log.Fatale(err)
		}
	} else {
		log.Info("Starting HTTP listener")
		if err := nethttp.ListenAndServe(listenAddress, m); err != nil {
			log.Fatale(err)
		}
	}
	log.Info("Web server started")
}
Beispiel #9
0
func main() {
	fmt.Println("hello")
	go freeAlloc()
	m := martini.Classic()
	m.Handlers(gzip.All(), martini.Recovery())
	Mount(m, 100)
	log.Printf("start gateway on %s\n", 5050)

	log.Fatal(http.ListenAndServe(":5050", nil))
//	m.RunOnAddr(":5050")
}
Beispiel #10
0
func init() {
	// BASE_URL, AUTH_USER and AUTH_PASS, AWS_S3_BASE_URL are not required or else wercker tests would fail
	baseURL = os.Getenv("BASE_URL")
	authUser = os.Getenv("AUTH_USER")
	authPass = os.Getenv("AUTH_PASS")
	s3BaseURL = os.Getenv("AWS_S3_BASE_URL")

	if awsAuth, err := aws.EnvAuth(); err != nil {
		// not required or else wercker tests would fail
		log.Println(err)
	} else {
		// TODO(jrubin) allow region to be chosen by env variable
		s3Data := s3.New(awsAuth, aws.USWest2)
		s3Bucket = s3Data.Bucket(os.Getenv("AWS_S3_BUCKET_NAME"))
	}

	m = martini.Classic()

	m.Use(gzip.All())
	m.Use(render.Renderer())

	m.Get("/", func() string {
		return "hello, world"
	})

	m.Post(
		"/v1/transcribe",
		auth.Basic(authUser, authPass),
		strict.Accept("application/json"),
		strict.ContentType("application/x-www-form-urlencoded"),
		binding.Bind(transcribeData{}),
		binding.ErrorHandler,
		handleTranscribe,
	)

	m.Post(
		"/v1/transcribe/process",
		strict.ContentType("application/x-www-form-urlencoded"),
		binding.Bind(telapi.TranscribeCallbackData{}),
		binding.ErrorHandler,
		handleTranscribeProcess,
	)

	m.Post(
		"/v1/transcribe/upload",
		auth.Basic(authUser, authPass),
		strict.Accept("application/json"),
		binding.MultipartForm(transcribeUploadData{}),
		binding.ErrorHandler,
		handleTranscribeUpload,
	)

	m.Router.NotFound(strict.MethodNotAllowed, strict.NotFound)
}
Beispiel #11
0
func NewApiServer() http.Handler {
	m := martini.New()
	m.Use(martini.Recovery())
	m.Use(render.Renderer())
	m.Use(func(w http.ResponseWriter, req *http.Request, c martini.Context) {
		path := req.URL.Path
		if req.Method == "GET" && strings.HasPrefix(path, "/") {
			var remoteAddr = req.RemoteAddr
			var headerAddr string
			for _, key := range []string{"X-Real-IP", "X-Forwarded-For"} {
				if val := req.Header.Get(key); val != "" {
					headerAddr = val
					break
				}
			}
			fmt.Printf("API call %s from %s [%s]\n", path, remoteAddr, headerAddr)
			//if ip := strings.Split(remoteAddr,":");ip[0] != "172.17.140.52" {
			//	w.WriteHeader(404)
			//	return
			//}
		}
		c.Next()
	})
	api := &apiServer{Version: "1.00", Compile: "go"}
	api.Load()
	api.StartDaemonRoutines()
	m.Use(gzip.All())
	m.Use(func(req *http.Request, c martini.Context, w http.ResponseWriter) {
		if req.Method == "GET" && strings.HasPrefix(req.URL.Path, "/teampickwrwithoutjson") {
			w.Header().Set("Content-Type", "text/html; charset=utf-8")
		} else {
			w.Header().Set("Access-Control-Allow-Origin", "*")             //允许访问所有域
			w.Header().Add("Access-Control-Allow-Headers", "Content-Type") //header的类型
			w.Header().Set("Content-Type", "application/json; charset=utf-8")
		}
	})
	r := martini.NewRouter()
	r.Get("/", func(r render.Render) {
		r.Redirect("/overview")
	})
	r.Get("/overview", api.showOverview)
	r.Get("/fetch/:account_id", api.fetchId)
	r.Get("/fetchupdate", api.fetchUpdate)
	r.Get("/teampick/:herolist", api.teamPick)
	r.Get("/teampickwr/:herolist", api.teamPickWinRate)
	r.Get("/teampickwrwithoutjson/:herolist", api.teamPickWinRateWithoutJSON)
	m.MapTo(r, (*martini.Routes)(nil))
	m.Action(r.Handle)
	return m
}
Beispiel #12
0
func main() {
	var config, port, api string

	flag.StringVar(&config, "c", "config.json", "Config file")
	flag.StringVar(&port, "p", "8080", "Port")
	flag.StringVar(&api, "a", "DEFAULT", "API key")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, `Usage: %s [options]

Barycenter serves a JSON configuration file over HTTP
using basic authentication (so run it over SSL).

Run an endpoint as follows:

  %s -c config.json -a DEFAULT -p 8080

You can then make a request against the endpoint.

  curl -u DEFAULT: 127.0.0.1:8080

OPTIONS:
`, os.Args[0], os.Args[0])
		flag.PrintDefaults()
	}

	flag.Parse()

	if flag.NArg() != 0 {
		flag.Usage()
		os.Exit(1)
	}

	json, err := ioutil.ReadFile(config)
	if err != nil {
		log.Fatalf("Could not read configuration: %s", err)
	}

	m := martini.Classic()
	m.Use(gzip.All())
	m.Use(auth.Basic(api, ""))

	m.Get("/", func(w http.ResponseWriter, req *http.Request) string {
		w.Header().Set("Content-Type", "application/json; charset=utf-8")
		return string(json)
	})

	http.ListenAndServe(":"+port, m)
}
Beispiel #13
0
func main() {
	m := martini.Classic()

	//Make sure to include the Gzip middleware above other middleware that alter the response body (like the render middleware).
	m.Use(gzip.All())

	// render html templates from templates directory
	m.Use(render.Renderer(render.Options{
		Layout: "layout",
	}))

	controllers.RouterInit(m)

	m.Run()
}
Beispiel #14
0
func main() {
	var serverPort int
	var localhost bool

	flag.StringVar(&ledgerFileName, "f", "", "Ledger file name (*Required).")
	flag.StringVar(&reportConfigFileName, "r", "", "Report config file name (*Required).")
	flag.IntVar(&serverPort, "port", 8056, "Port to listen on.")
	flag.BoolVar(&localhost, "localhost", false, "Listen on localhost only.")

	flag.Parse()

	if len(ledgerFileName) == 0 || len(reportConfigFileName) == 0 {
		flag.Usage()
		return
	}

	go func() {
		for {
			var rLoadData reportConfigStruct
			toml.DecodeFile(reportConfigFileName, &rLoadData)
			reportConfigData = rLoadData
			time.Sleep(time.Minute * 5)
		}
	}()

	m := martini.Classic()
	m.Use(gzip.All())
	m.Use(staticbin.Static("public", Asset))

	m.Get("/ledger", ledgerHandler)
	m.Get("/accounts", accountsHandler)
	m.Get("/account/:accountName", accountHandler)
	m.Get("/report/:reportName", reportHandler)
	m.Get("/", func(w http.ResponseWriter, r *http.Request) {
		http.Redirect(w, r, "/accounts", http.StatusFound)
	})

	fmt.Println("Listening on port", serverPort)
	listenAddress := ""
	if localhost {
		listenAddress = fmt.Sprintf("127.0.0.1:%d", serverPort)
	} else {
		listenAddress = fmt.Sprintf(":%d", serverPort)
	}
	http.ListenAndServe(listenAddress, m)
}
Beispiel #15
0
func main() {
	m := martini.Classic()

	//Make sure to include the Gzip middleware above other middleware that alter the response body (like the render middleware).
	m.Use(gzip.All())

	// render html templates from templates directory
	m.Use(render.Renderer(render.Options{
		Layout: "layout",
	}))

	store := sessions.NewCookieStore([]byte("secret123"))
	m.Use(sessions.Sessions("mysession", store))

	controllers.RouterInit(m)

	models.ModelInit()

	m.Run()
}
Beispiel #16
0
func setupMartini(db *sql.DB, conf *config.Config, mediaManager *media.Manager) {
	m := martini.Classic()

	m.Use(auth.SpecAuth(conf.Auth.Username, conf.Auth.Password, conf.Auth.ApiPath))
	m.Use(gzip.All())

	m.Map(db)

	m.Map(conf)

	m.Map(mediaManager)

	rendererOption := render.Options{
		Layout: "layout",
		Funcs: []htmlTemplate.FuncMap{
			{
				"echoActiveLink":     blahTemplate.EchoActiveLink,
				"echoPageAction":     blahTemplate.EchoPageAction,
				"echoSelectSelected": blahTemplate.EchoSelectSelected,
				"echoMediaUpload":    blahTemplate.EchoMediaUpload,
				"echoMediaDisplay":   blahTemplate.EchoMediaDisplay,
				"echoTimestamp":      blahTemplate.EchoTimeStamp,
				"echoLanguage":       blahTemplate.EchoLanguage,
			},
		},
		IndentJSON: true,
	}

	m.Use(render.Renderer(rendererOption))

	entity.SetMediaBaseUrl(conf.Blah.BaseMediaUri)

	blahTemplate.Module(m)

	controller.Module(m, conf.Auth.ApiPath)

	m.Get("/", ShowWelcome)

	m.Run()
}
Beispiel #17
0
// agentsHttp startes serving agents API requests
func agentsHttp() {
	m := martini.Classic()
	m.Use(gzip.All())
	m.Use(render.Renderer())

	log.Info("Starting agents HTTP")

	go logic.ContinuousAgentsPoll()

	http.AgentsAPI.RegisterRequests(m)

	// Serve
	if config.Config.AgentsUseSSL {
		log.Info("Serving via SSL")
		err := nethttp.ListenAndServeTLS(":3001", config.Config.SSLCertFile, config.Config.SSLPrivateKeyFile, m)
		if err != nil {
			log.Fatale(err)
		}
	} else {
		nethttp.ListenAndServe(":3001", m)
	}
}
Beispiel #18
0
// agentsHttp startes serving agents HTTP or HTTPS API requests
func agentsHttp() {
	m := martini.Classic()
	m.Use(gzip.All())
	m.Use(render.Renderer())
	if config.Config.AgentsUseMutualTLS {
		m.Use(ssl.VerifyOUs(config.Config.AgentSSLValidOUs))
	}

	log.Info("Starting agents listener")

	agent.InitHttpClient()
	go logic.ContinuousAgentsPoll()

	http.AgentsAPI.URLPrefix = config.Config.URLPrefix
	http.AgentsAPI.RegisterRequests(m)

	// Serve
	if config.Config.AgentsUseSSL {
		log.Info("Starting agent HTTPS listener")
		tlsConfig, err := ssl.NewTLSConfig(config.Config.AgentSSLCAFile, config.Config.AgentsUseMutualTLS)
		if err != nil {
			log.Fatale(err)
		}
		tlsConfig.InsecureSkipVerify = config.Config.AgentSSLSkipVerify
		if err = ssl.AppendKeyPairWithPassword(tlsConfig, config.Config.AgentSSLCertFile, config.Config.AgentSSLPrivateKeyFile, agentSSLPEMPassword); err != nil {
			log.Fatale(err)
		}
		if err = ssl.ListenAndServeTLS(config.Config.AgentsServerPort, m, tlsConfig); err != nil {
			log.Fatale(err)
		}
	} else {
		log.Info("Starting agent HTTP listener")
		if err := nethttp.ListenAndServe(config.Config.AgentsServerPort, m); err != nil {
			log.Fatale(err)
		}
	}
	log.Info("Agent server started")
}
Beispiel #19
0
func NewApi() *martini.Martini {
	m := martini.New()

	// Setup middleware
	m.Use(martini.Recovery())
	m.Use(martini.Logger())
	m.Use(gzip.All())
	m.Use(func(w http.ResponseWriter, req *http.Request) {
		if req.URL.Path != "/mtg/cards/random" {
			w.Header().Set("Cache-Control", "public,max-age=3600")
		}
		w.Header().Set("Content-Type", "application/json; charset=utf-8")
		w.Header().Set("Access-Control-Allow-Origin", "*")
		w.Header().Set("License", "The textual information presented through this API about Magic: The Gathering is copyrighted by Wizards of the Coast.")
		w.Header().Set("Disclaimer", "This API is not produced, endorsed, supported, or affiliated with Wizards of the Coast.")
		w.Header().Set("Pricing", "store.tcgplayer.com allows you to buy cards from any of our vendors, all at the same time, in a simple checkout experience. Shop, Compare & Save with TCGplayer.com!")
		w.Header().Set("Strict-Transport-Security", "max-age=86400")
	})

	r := martini.NewRouter()

	r.Get("/ping", Ping)
	r.Get("/mtg/cards", HandleCards)
	r.Get("/mtg/cards/typeahead", HandleTypeahead)
	r.Get("/mtg/cards/random", HandleRandomCard)
	r.Get("/mtg/cards/:id", HandleCard)
	r.Get("/mtg/sets", HandleSets)
	r.Get("/mtg/sets/:id", HandleSet)
	r.Get("/mtg/colors", HandleTerm("colors"))
	r.Get("/mtg/supertypes", HandleTerm("supertypes"))
	r.Get("/mtg/subtypes", HandleTerm("subtypes"))
	r.Get("/mtg/types", HandleTerm("types"))
	r.NotFound(NotFound)

	m.Action(r.Handle)
	return m
}
Beispiel #20
0
func main() {
	store.Setup()

	m := martini.New()
	router := martini.NewRouter()

	router.NotFound(func() (int, []byte) {
		return 404, []byte("Requested page not found.")
	})

	m.Use(martini.Logger())
	m.Use(martini.Recovery())
	m.Use(gzip.All())

	m.Use(func(c martini.Context, w http.ResponseWriter) {
		w.Header().Set("Content-Type", "application/json; charset=utf-8")
	})

	router.Group("/chats", func(r martini.Router) {
		r.Get("/userchats/:userid", chat.GetChats)       // Get list of all chats for a user
		r.Get("/messages/:chatid", chat.ViewMessages)    // View chat messages for a chat
		r.Post("/newchat", chat.NewChat)                 // Create a new chat with specific users
		r.Post("/sendmessage/:chatid", chat.SendMessage) // Send message to a chat as a user
	})

	router.Group("/users", func(r martini.Router) {
		r.Get("/get", users.GetUsers)               // Get list of all users
		r.Get("/new/:userName", users.NewUser)      // Make a new user
		r.Post("/delete/:userid", users.DeleteUser) // Delete a user with a specific id
	})

	m.MapTo(router, (*martini.Routes)(nil))
	m.Action(router.Handle)

	m.Run()
}
Beispiel #21
0
// standardHttp starts serving HTTP or HTTPS (api/web) requests, to be used by normal clients
func standardHttp(discovery bool) {
	m := martini.Classic()

	switch strings.ToLower(config.Config.AuthenticationMethod) {
	case "basic":
		{
			if config.Config.HTTPAuthUser == "" {
				// Still allowed; may be disallowed in future versions
				log.Warning("AuthenticationMethod is configured as 'basic' but HTTPAuthUser undefined. Running without authentication.")
			}
			m.Use(auth.Basic(config.Config.HTTPAuthUser, config.Config.HTTPAuthPassword))
		}
	case "multi":
		{
			if config.Config.HTTPAuthUser == "" {
				// Still allowed; may be disallowed in future versions
				log.Fatal("AuthenticationMethod is configured as 'multi' but HTTPAuthUser undefined")
			}

			m.Use(auth.BasicFunc(func(username, password string) bool {
				if username == "readonly" {
					// Will be treated as "read-only"
					return true
				}
				return auth.SecureCompare(username, config.Config.HTTPAuthUser) && auth.SecureCompare(password, config.Config.HTTPAuthPassword)
			}))
		}
	default:
		{
			// We inject a dummy User object because we have function signatures with User argument in api.go
			m.Map(auth.User(""))
		}
	}

	m.Use(gzip.All())
	// Render html templates from templates directory
	m.Use(render.Renderer(render.Options{
		Directory:       "resources",
		Layout:          "templates/layout",
		HTMLContentType: "text/html",
	}))
	m.Use(martini.Static("resources/public"))
	if config.Config.UseMutualTLS {
		m.Use(ssl.VerifyOUs(config.Config.SSLValidOUs))
	}

	inst.SetMaintenanceOwner(process.ThisHostname)

	if discovery {
		log.Info("Starting Discovery")
		go logic.ContinuousDiscovery()
	}
	log.Info("Registering endpoints")
	http.API.RegisterRequests(m)
	http.Web.RegisterRequests(m)

	// Serve
	if config.Config.ListenSocket != "" {
		log.Infof("Starting HTTP listener on unix socket %v", config.Config.ListenSocket)
		unixListener, err := net.Listen("unix", config.Config.ListenSocket)
		if err != nil {
			log.Fatale(err)
		}
		defer unixListener.Close()
		if err := nethttp.Serve(unixListener, m); err != nil {
			log.Fatale(err)
		}
	} else if config.Config.UseSSL {
		log.Info("Starting HTTPS listener")
		tlsConfig, err := ssl.NewTLSConfig(config.Config.SSLCAFile, config.Config.UseMutualTLS)
		if err != nil {
			log.Fatale(err)
		}
		tlsConfig.InsecureSkipVerify = config.Config.SSLSkipVerify
		if err = ssl.AppendKeyPairWithPassword(tlsConfig, config.Config.SSLCertFile, config.Config.SSLPrivateKeyFile, sslPEMPassword); err != nil {
			log.Fatale(err)
		}
		if err = ssl.ListenAndServeTLS(config.Config.ListenAddress, m, tlsConfig); err != nil {
			log.Fatale(err)
		}
	} else {
		log.Infof("Starting HTTP listener on %+v", config.Config.ListenAddress)
		if err := nethttp.ListenAndServe(config.Config.ListenAddress, m); err != nil {
			log.Fatale(err)
		}
	}
	log.Info("Web server started")
}
Beispiel #22
0
func main() {
	m := martini.Classic()

	// Gzip all
	m.Use(gzip.All())

	// Create sessions cookie store
	store := sessions.NewCookieStore([]byte(utils.AppCfg.SecretKey()))
	m.Use(sessions.Sessions("pixelrelay", store))

	// Setup render options
	m.Use(render.Renderer(render.Options{
		Directory: "templates",                            // Specify what path to load the templates from.
		Layout:    "layout",                               // Specify a layout template. Layouts can call {{ yield }} to render the current template.
		Charset:   "UTF-8",                                // Sets encoding for json and html content-types.
		Delims:    render.Delims{Left: "{[", Right: "]}"}, // Sets delimiters to the specified strings.
	}))

	// Setup DB
	dbh := db.Init(&db.Dbh{})
	m.Map(dbh)

	// Setup static file handling
	opts := martini.StaticOptions{SkipLogging: false, Expires: utils.ExpiresHeader}
	m.Use(martini.Static("static", opts))

	// Auth user and assign to session
	m.Use(middleware.UserAuth(models.User{}, dbh))

	// Encoder for .html or .json encoding
	m.Use(encoder.MapEncoder)

	// Setup Page
	p := models.InitPage(&models.Page{})
	m.Map(p)

	// Set up routes
	m.Get("/", controllers.Index)

	// Images
	m.Get("/image/:name", middleware.VerifyFile, controllers.ImagePage)
	m.Get("/o/:name", middleware.VerifyFile, controllers.Image)
	m.Get("/i/:name", middleware.VerifyFile, controllers.ImageModified)
	m.Get("/t/:name", middleware.VerifyFile, controllers.Thumb)
	m.Get("/image/trash/:album/:name", middleware.AuthRequired, controllers.ImageTrash)
	m.Get("/image/recover/:album/:name", middleware.AuthRequired, controllers.ImageRecover)

	// Albums
	m.Get("/albums", controllers.Albums)
	m.Get("/album/:name", controllers.Album)
	m.Get("/album/:name/qr", controllers.QR)
	m.Get("/:user/albums", controllers.Albums)
	m.Get("/:user/album/:name", controllers.Album)
	m.Get("/album/:name/private/:state", controllers.AlbumPrivate)

	m.Get("/album/:name/:key", controllers.Album)

	m.Post("/album/create", middleware.AuthRequired, controllers.AlbumCreate)
	m.Post("/album/update", middleware.AuthRequired, controllers.AlbumUpdate)
	m.Post("/album/delete/:name", middleware.AuthRequired, controllers.AlbumDelete)
	m.Post("/album/recover/:name", middleware.AuthRequired, controllers.AlbumRecover)
	m.Post("/album/move", middleware.AuthRequired, controllers.AlbumMove)

	// Tag
	m.Get("/tags", controllers.Tags)
	m.Get("/tag/:tag", controllers.Tagged)
	m.Post("/tag", middleware.AuthRequired, controllers.TagImage)

	// Auth
	m.Get("/login", controllers.Login)
	m.Post("/login", binding.Bind(forms.Login{}), binding.ErrorHandler, controllers.LoginPost)
	m.Get("/logout", controllers.Logout)

	// Upload
	m.Post("/up", middleware.Verify, binding.MultipartForm(models.ImageUpload{}), controllers.UploadImage)

	// 404
	m.NotFound(controllers.NotFound)

	// Account
	m.Get("/account", middleware.AuthRequired, controllers.Account)

	// Profile
	m.Get("/profile/:name", controllers.Profile)

	// Testing
	m.Get("/test/hash", test.Hash)
	m.Get("/test/hash/:user_id/:image_id", test.Hash)
	m.Get("/test/list", middleware.AuthRequired, test.List)
	m.Get("/test/listdb", middleware.AuthRequired, test.ListDB)
	m.Get("/test/listt", middleware.AuthRequired, test.ListThumb)
	m.Get("/test/uploader", middleware.AuthRequired, test.Uploader)

	// Start server and begin listening for HTTP requests
	// Watch for non-https requests and redirect to https
	// If request method is POST and path is /up
	//   discard file and redirect to correct https route
	log.Printf("Listening for \x1b[32;1mHTTP\x1b[0m connections on \x1b[32;1m%s\x1b[0m\n", utils.AppCfg.ListenOn())
	go http.ListenAndServe(utils.AppCfg.ListenOn(), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		urlPath := r.URL.Path
		url := strings.Join([]string{utils.AppCfg.Url(), urlPath}, "")

		// Check if path is for the Upload controller.
		// Redirect client to HTTPS end point
		if urlPath == "/up" && r.Method == "POST" {
			ur := models.UploadResult{
				Code:   http.StatusFound,
				Result: "HTTPS Required",
				Name:   url,
			}
			log.Println(ur.String())

			// Move uploaded file to DevNull
			file, _, _ := r.FormFile("uploaded_file")
			defer file.Close()
			out, err := os.Create(os.DevNull)
			if err != nil {
				log.Println(err)
			}
			defer out.Close()
			_, err = io.Copy(out, file)
			if err != nil {
				log.Println(err)
			}

			// Respond with JSON that server requires HTTPS and correct path.
			w.Header().Set("X-Content-Type-Options", "nosniff")
			w.Header().Set("Expires", utils.ExpiresHeader())
			w.Header().Set("Content-Type", "application/json")
			fmt.Fprint(w, ur)
			return
		}

		log.Println("Redirect: ", url)
		http.Redirect(w, r, url, http.StatusFound)
	}))

	// Start server and begin listening for TLS requests
	log.Printf("Listening for \x1b[32;1mTLS\x1b[0m connections on \x1b[32;1m%s\x1b[0m\n", utils.AppCfg.TLSListenOn())
	go http.ListenAndServeTLS(utils.AppCfg.TLSListenOn(), "./tls/cert.pem", "./tls/key.pem", m)

	/******************************************
	*	INITIAL SETUP
	*
	*   Creates the initial tables
	*   Populates the default admin user
	*
	*   Potential security risks are present
	*   if this mode is left running.
	*	restart server with the "-init" flag
	*   unset.
	*
	*   usage: -init
	 */
	if *flagInit {
		fmt.Println("\x1b[31;1mInitial Setup flag (-init) has been set to \x1b[32;1mTRUE\x1b[0m")
		fmt.Println("\x1b[31;1mOnce setup is complete please restart server with this flag disabled.\x1b[0m")

		// Add default tables
		dbh.AddTables()

		su := martini.Classic()

		store := sessions.NewCookieStore([]byte(utils.AppCfg.SecretKey()))
		su.Use(sessions.Sessions("pixelrelay", store))
		su.Use(render.Renderer(render.Options{
			Directory: "templates", // Specify what path to load the templates from.
			Layout:    "layout",    // Specify a layout template. Layouts can call {{ yield }} to render the current template.
			Charset:   "UTF-8",     // Sets encoding for json and html content-types.
		}))
		su.Get("/setup", controllers.SetupAdmin)
		su.Post("/setup", binding.Bind(forms.SetupAdmin{}), binding.ErrorHandler, controllers.SetupAdminPost)
		// Start server and begin listening for requests
		log.Printf("Listening for connections on \x1b[32;1m%s\x1b[0m\n", utils.AppCfg.ListenOnSetup())

		go http.ListenAndServe(utils.AppCfg.ListenOnSetup(), su)
	}

	/******************************************
	*	MIGRATE DATABASE UPDATES
	*
	*   Migrates changes to database tables
	*
	*   You should backup the database before
	*   migrating. As there is a potential risk
	*   of data loss
	*
	*   usage: -migrate
	 */
	if *flagMigrate {
		dbh.MigrateDB()
	}

	select {}
}
Beispiel #23
0
func main() {
	var serverPort int
	var localhost bool

	flag.IntVar(&serverPort, "port", 8056, "Port to listen on.")
	flag.BoolVar(&localhost, "localhost", false, "Listen on localhost only.")

	flag.Parse()

	var cardata []Record
	var carmutex sync.RWMutex

	m := martini.Classic()

	m.Use(gzip.All())
	m.Use(staticbin.Static("public", Asset))

	carfunc := func(res http.ResponseWriter, r *http.Request) {
		fmt.Println(time.Now())
		decoder := json.NewDecoder(r.Body)
		var rec Record

		err := decoder.Decode(&rec)

		if err != nil {
			log.Println(err)
		}

		recTime := time.Unix(0, 0)
		recTime = recTime.Add(time.Millisecond * time.Duration(rec.Timestamp))
		rec.DateTime = recTime
		fmt.Println(recTime)

		for rName, reading := range rec.Readings {
			if reading != "" && reading != "NO DATA" {
				segs := validValue.FindAllStringSubmatch(reading, -1)
				if len(segs) > 0 && len(segs[0]) > 2 {
					val := segs[0][1]
					//fmt.Println(rName, strings.TrimSpace(segs[0][1]), strings.TrimSpace(segs[0][2]))
					switch rName {
					case "BAROMETRIC_PRESSURE":
						rec.BarometricPressure = val
					case "INTAKE_MANIFOLD_PRESSURE":
						rec.IntakeManifoldPressure = val
					case "ENGINE_RPM":
						rec.EngineRPM = val
					case "ENGINE_COOLANT_TEMP":
						rec.EngineCoolantTemp = val
					case "AMBIENT_AIR_TEMP":
						rec.AmbientAirTemp = val
					case "SPEED":
						rec.Speed = val
					case "THROTTLE_POS":
						rec.ThrottlePos = val
					case "AIR_INTAKE_TEMP":
						rec.AirIntakeTemp = val
					}
				}
			}
		}

		fmt.Println(rec)

		carmutex.Lock()
		// Get latest time clear all trip data if the time we are
		// receiving is over an hour after the last time received.
		if len(cardata) > 0 {
			recentTime := cardata[len(cardata)-1].DateTime
			if rec.DateTime.Sub(recentTime) > time.Hour {
				cardata = []Record{}
			}
		}

		// Append received record to trip.
		cardata = append(cardata, rec)
		carmutex.Unlock()
	}

	m.Put("/", carfunc)
	m.Put("/data", carfunc)
	m.Put("/data/", carfunc)

	carview := func(w http.ResponseWriter, r *http.Request) {
		type DataSet struct {
			FieldName string
			RGBColor  string
			Values    []string
		}
		var chartData struct {
			RangeStart, RangeEnd time.Time
			Labels               []string
			DataSets             []DataSet
		}

		carmutex.RLock()
		chartData.DataSets = []DataSet{
			{FieldName: "Speed (km/h)", RGBColor: "220,220,220", Values: make([]string, len(cardata))},
			{FieldName: "Throttle (%)", RGBColor: "151,187,205", Values: make([]string, len(cardata))},
			{FieldName: "RPM (x100)", RGBColor: "70, 191, 189", Values: make([]string, len(cardata))},
		}
		for rIdx, rec := range cardata {
			if chartData.RangeStart.IsZero() {
				chartData.RangeStart = rec.DateTime
			}
			chartData.RangeEnd = rec.DateTime
			chartData.Labels = append(chartData.Labels, rec.DateTime.Format("15:04:05"))
			chartData.DataSets[0].Values[rIdx] = rec.Speed
			chartData.DataSets[1].Values[rIdx] = rec.ThrottlePos
			rpm, _ := strconv.ParseInt(rec.EngineRPM, 10, 64)
			chartData.DataSets[2].Values[rIdx] = fmt.Sprint(rpm / 100)
		}
		carmutex.RUnlock()

		t, err := parseAssets("templates/template.linechart.html", "templates/template.nav.html")
		if err != nil {
			http.Error(w, err.Error(), 500)
			return
		}
		err = t.Execute(w, chartData)
		if err != nil {
			http.Error(w, err.Error(), 500)
		}
	}

	m.Get("/", func(w http.ResponseWriter, r *http.Request) {
		http.Redirect(w, r, "/carview", http.StatusFound)
	})
	m.Get("/carview", carview)

	fmt.Println("Listening on port", serverPort)
	listenAddress := ""
	if localhost {
		listenAddress = fmt.Sprintf("127.0.0.1:%d", serverPort)
	} else {
		listenAddress = fmt.Sprintf(":%d", serverPort)
	}
	http.ListenAndServe(listenAddress, m)
}
Beispiel #24
0
func main() {
	kingpin.UsageTemplate(kingpin.CompactUsageTemplate).Version("1.0").Author("Christoph Mewes")
	kingpin.CommandLine.Help = "HTTP application server to run the Raziel secret management"
	kingpin.Parse()

	if *configFile == "" {
		kingpin.FatalUsage("No configuration file (--config) given!")
	}

	// load config file
	err := loadConfigFile()
	if err != nil {
		kingpin.FatalUsage(err.Error())
	}

	// connect to database
	database, err := sqlx.Connect("mysql", config.Database.Source)
	if err != nil {
		kingpin.FatalUsage(err.Error())
	}

	validateMasterPassword(database)

	// init restriction handlers
	restrictionHandlers = make(map[string]RestrictionHandler)
	addRestrictionHandler(ApiKeyRestriction{})
	addRestrictionHandler(TlsCertRestriction{})
	addRestrictionHandler(OriginIpRestriction{})
	addRestrictionHandler(DateRestriction{})
	addRestrictionHandler(TimeRestriction{})
	addRestrictionHandler(FileRestriction{})
	addRestrictionHandler(HitLimitRestriction{})
	addRestrictionHandler(ThrottleRestriction{})

	// init templates
	templateManager = NewTemplateManager("templates")

	// setup basic Martini server

	martini.Env = martini.Dev

	if config.Environment == "production" || config.Environment == "prod" {
		martini.Env = martini.Prod
	}

	m := martini.New()
	m.Use(martini.Logger())
	m.Use(gzip.All())
	m.Use(martini.Recovery())
	m.Use(martini.Static("www"))
	m.Use(method.Override())

	// force all handlers to run inside a transaction

	m.Use(func(c martini.Context) {
		tx := database.MustBegin()

		defer func() {
			if r := recover(); r != nil {
				tx.Rollback()
				panic(r)
			}
		}()

		c.Map(tx)
		c.Next()

		err := tx.Commit()
		if err != nil {
			panic(err)
		}
	})

	// setup session and CSRF support

	duration, err := time.ParseDuration(config.Session.Lifetime)
	if err != nil {
		log.Fatal("Invalid session lifetime configured: " + err.Error())
	}

	sessions = NewSessionMiddleware(cookieOptions{
		Name:     config.Session.CookieName,
		MaxAge:   duration,
		HttpOnly: true,
		Secure:   config.Session.Secure,
	})

	sessions.Setup(m)

	// re-compile all templates on each hit

	if martini.Env != martini.Prod {
		m.Use(func() {
			templateManager.Init()
		})
	}

	// use a custom return handler to make our mini response structs possible
	// (this overwrites the existing handler)
	m.Map(newReturnHandler())

	r := martini.NewRouter()
	m.MapTo(r, (*martini.Routes)(nil))
	m.Action(r.Handle)

	martini := &martini.ClassicMartini{m, r}
	setupDashboardCtrl(martini)
	setupProfileCtrl(martini)
	setupLoginCtrl(martini)
	setupSecretsCtrl(martini)
	setupUsersCtrl(martini)
	setupConsumersCtrl(martini)
	setupAuditLogCtrl(martini)
	setupAccessLogCtrl(martini)
	setupDeliveryCtrl(martini)

	// setup our own http server and configure TLS
	srv := &http.Server{
		Addr:    config.Server.Listen,
		Handler: martini,
		TLSConfig: &tls.Config{
			CipherSuites: config.CipherSuites(),
		},
	}

	log.Fatal(srv.ListenAndServeTLS(config.Server.Certificate, config.Server.PrivateKey))
}
Beispiel #25
0
func init() {
	envFileName := martini.Env + ".env"
	err := godotenv.Load(envFileName)
	if err != nil {
		log.Fatalf("Error loading: %s", envFileName)
	}
	db = models.Connect()
	utils.GenKeyPairIfNone(os.Getenv("PRIVATE_KEY"), os.Getenv("PUBLIC_KEY"))
	PrivateKey = utils.GetKey(os.Getenv("PRIVATE_KEY"))
	PublicKey = utils.GetKey(os.Getenv("PUBLIC_KEY"))
	claims := map[string]interface{}{
		"user_id": 1,
		"role":    "admin",
		"exp":     time.Now().UTC().Add(time.Hour * 6).Unix(),
		"iat":     time.Now().UTC().Unix(),
	}
	auth, _ := utils.GenerateAuthToken(claims, PrivateKey)
	fmt.Println(auth)

	m = martini.New()
	// Setup middleware
	if os.Getenv("DEV_RUNNER") == "1" {
		m.Use(runnerMiddleware)
	}
	m.Use(analytics.Google(os.Getenv("GA")))
	m.Use(gzip.All())
	m.Use(martini.Recovery())
	m.Use(martini.Logger())
	m.Use(render.Renderer())
	m.Use(martini.Static("public"))
	m.Map(db)
	// Setup routes
	gr := martini.NewRouter()
	gr.Group("/api", func(r martini.Router) {

		r.Get(`/latest`, routes.LatestIndex)
		r.Get(`/popular`, routes.PopularIndex)

		r.Get(`/media`, routes.MediaIndex)
		r.Get(`/media/head/:id`, routes.MediaHead)
		r.Get(`/media/play/:id`, routes.MediaPlay)
		r.Post(`/media`, utils.LoginRequired(PublicKey), binding.Bind(models.Media{}), routes.MediaCreate)
		r.Get("/media/new", utils.LoginRequired(PublicKey), routes.MediaNew)
		r.Get(`/media/:slug`, routes.MediaGet)
		r.Put(`/media/:id`, utils.LoginRequired(PublicKey), binding.Bind(models.Media{}), routes.MediaUpdate)
		r.Delete(`/media/:id`, utils.LoginRequired(PublicKey), routes.MediaDelete)

		r.Get(`/groups`, routes.GroupsIndex)
		r.Post(`/groups`, utils.LoginRequired(PublicKey), binding.Bind(models.Group{}), routes.GroupCreate)
		r.Get("/groups/new", utils.LoginRequired(PublicKey), routes.GroupNew)
		r.Get(`/group/:slug`, routes.GroupGet)
		r.Get(`/group/:slug/media`, routes.MediaForGroupGet)
		r.Put(`/group/:id`, utils.LoginRequired(PublicKey), binding.Bind(models.Group{}), routes.GroupUpdate)
		r.Delete(`/group/:id`, utils.LoginRequired(PublicKey), routes.GroupDelete)
	})

	gr.Get(`/feed/:slug`, routes.FeedForGroupGet)
	gr.Get(`/stats`, utils.LoginRequired(PublicKey), workers.Stats)
	// Inject database

	// Add the router action
	m.Action(gr.Handle)
}
Beispiel #26
0
func init() {
	flag.Parse()
	m := martini.Classic()
	m.Use(gzip.All())
	m.Use(martini.Static("public"))
	store := sessions.NewCookieStore([]byte("dynamic-fab"))
	m.Use(sessions.Sessions("my_session", store))
	m.Use(render.Renderer(render.Options{
		Directory:  "views",
		Layout:     "layout",
		Extensions: []string{".tmpl", ".html"},
		Funcs: []template.FuncMap{
			{
				"StringsEqual": func(a, b string) bool {
					if strings.EqualFold(a, b) {
						return true
					}
					return false
				},
				"ShortenString": func(s string, l int) string {
					if len(s) <= l {
						return s
					}
					return fmt.Sprintf("%s...", s[:l])
				},
				"IntegerGreater": func(x interface{}, y interface{}) bool {

					if x == nil || y == nil {
						return false
					}

					var xint int = 0
					var yint int = 0

					xtyp := reflect.TypeOf(x)
					switch xtyp.Kind() {
					case reflect.Int:
						xint = int(x.(int))
					case reflect.Int32:
						xint = int(x.(int32))
					case reflect.Int16:
						xint = int(x.(int16))
					case reflect.Int64:
						xint = int(x.(int64))
					}

					ytyp := reflect.TypeOf(y)
					switch ytyp.Kind() {
					case reflect.Int:
						yint = int(y.(int))
					case reflect.Int32:
						yint = int(y.(int32))
					case reflect.Int16:
						yint = int(y.(int16))
					case reflect.Int64:
						yint = int(y.(int64))
					}

					if xint <= yint {
						return false
					}

					return true
				},
			},
		},
		Delims:          render.Delims{"{{", "}}"},
		Charset:         "UTF-8",
		IndentJSON:      true,
		HTMLContentType: "text/html",
	}))

	// Backend tasks
	m.Group("/admin", func(r martini.Router) {
		r.Get("", backend.Home)
		r.Get("/auth", auth.Index)
		r.Post("/auth", auth.Login)
		r.Get("/auth/out", auth.Logout)
	})

	m.Group("/admin/banners", func(r martini.Router) {
		r.Get("", auth.Check, bannerAdmin.Index)
		r.Get("/:id", auth.Check, bannerAdmin.Edit)
		r.Post("/:id", auth.Check, bannerAdmin.Save)
		r.Delete("/:id", auth.Check, bannerAdmin.Delete)
	})
	m.Group("/admin/content", func(r martini.Router) {
		r.Get("", auth.Check, contentAdmin.Index)
		r.Get("/:id", auth.Check, contentAdmin.Edit)
		r.Post("/:id", auth.Check, contentAdmin.Save)
		r.Delete("/:id", auth.Check, contentAdmin.Delete)
	})
	m.Group("/admin/testimonials", func(r martini.Router) {
		r.Get("", auth.Check, testimonialAdmin.Index)
		r.Get("/:id", auth.Check, testimonialAdmin.Edit)
		r.Post("/:id", auth.Check, testimonialAdmin.Save)
		r.Delete("/:id", auth.Check, testimonialAdmin.Delete)
	})
	m.Group("/admin/equipment", func(r martini.Router) {
		r.Get("", auth.Check, equipmentAdmin.Index)
		r.Get("/:id", auth.Check, equipmentAdmin.Edit)
		r.Post("/:id", auth.Check, equipmentAdmin.Save)
		r.Delete("/:id", auth.Check, equipmentAdmin.Delete)
	})
	m.Group("/admin/quotes", func(r martini.Router) {
		r.Get("", auth.Check, quoteAdmin.Index)
		r.Post("/heading", auth.Check, quoteAdmin.SetHeading)
		r.Get("/:id", auth.Check, quoteAdmin.View)
		r.Delete("/:id", auth.Check, quoteAdmin.Delete)
	})

	m.Group("/admin/about", func(r martini.Router) {
		r.Get("", auth.Check, aboutAdmin.Edit)
		r.Post("", auth.Check, aboutAdmin.Save)
	})

	m.Get("/blob/:id", banners.Serve)
	m.Group("/api/banners", func(r martini.Router) {
		r.Get("", banners.All)
		r.Get("/:id", banners.Get)
	})
	m.Group("/api/content", func(r martini.Router) {
		r.Get("", content.All)
		r.Get("/:id", content.Get)
	})
	m.Group("/api/testimonials", func(r martini.Router) {
		r.Get("", testimonial.All)
		r.Get("/:id", testimonial.Get)
	})
	m.Group("/api/equipment", func(r martini.Router) {
		r.Get("", equipment.All)
		r.Get("/:id", equipment.Get)
	})

	m.Group("/api/quote", func(r martini.Router) {
		r.Post("", quote.Submit)
		r.Get("/heading", quote.Heading)
	})
	m.Get("/api/aboutus", aboutus.Get)

	// m.Get("/adduser", auth.AddUser)

	// Serve Frontend
	m.Get("/**", func(rw http.ResponseWriter, req *http.Request, r render.Render) {
		bag := make(map[string]interface{}, 0)
		bag["Host"] = req.URL.Host
		r.HTML(200, "index", bag)
	})

	http.Handle("/", m)
}
Beispiel #27
0
func gzip_handler() martini.Handler {
	return gzip.All()
}