func main() {

	router1 := httprouter.New()
	router1.GET("/keys", GetKeyServer3000)
	router1.PUT("/keys/:key_id/:value", PutServer1)
	server := http.Server{
		Addr:    "0.0.0.0:3000",
		Handler: router1,
	}
	router2 := httprouter.New()
	router2.GET("/keys", GetKeyServer3001)
	router2.PUT("/keys/:key_id/:value", PutServer2)

	go func() {
		http.ListenAndServe("localhost:3001", router2)
	}()

	router3 := httprouter.New()
	router3.GET("/keys", GetKeyServer3002)
	router3.PUT("/keys/:key_id/:value", PutServer3)

	go func() {
		http.ListenAndServe("localhost:3002", router3)
	}()

	server.ListenAndServe()

}

func APIHandler(conf *Config) http.Handler {
	api := &API{
		conf: conf,
	}
	if conf.Cache {
		if err := api.cacheDashboardJS(); err != nil {
			panic(err)
		}
	}

	router := httprouter.New()
	router2 := httprouter.New()

	prefixPath := func(p string) string {
		return path.Join(conf.PathPrefix, p)
	}

	router.HandlerFunc("GET", status.Path, status.HealthyHandler.ServeHTTP)

	router.POST(prefixPath("/user/sessions"), api.WrapHandler(api.Login))
	router.DELETE(prefixPath("/user/session"), api.WrapHandler(api.Logout))

	router.GET(prefixPath("/config"), api.WrapHandler(api.GetConfig))

	router.NotFound = router2.ServeHTTP
	router2.GET(prefixPath("/*path"), api.WrapHandler(api.ServeAsset))

	return httphelper.ContextInjector("dashboard",
		httphelper.NewRequestLogger(
			api.CorsHandler(router)))
}

func runHTTPListeners(d db.DB) {
	httpMux := htr.New()
	httpsMux := htr.New()

	// httpMux.SetupRoutes()
	err := api.SetupRoutes(
		httpsMux,
		api.Auth(d),
		api.User(d),
		api.Task(d),
	)

	if err != nil {
		log.Fatalf("router setup failed: %s\n", err.Error())
	}

	var (
		httpErr  = make(chan error)
		httpsErr = make(chan error)
	)

	println("Listening on HTTP 25000")
	println("Listening on HTTPS 25001")

	go func() { httpErr <- http.ListenAndServeTLS(":25001", "cert.pem", "key.key", httpsMux) }()
	go func() { httpsErr <- http.ListenAndServe(":25000", httpMux) }()

	var e error
	select {
	case e = <-httpErr:
	case e = <-httpsErr:
	}
	log.Fatalf("error serving http(s): %s", e.Error())
}

func main() {
	flag.Parse()

	// initialize database
	db, err := bolt.Open(*database, 0600, &bolt.Options{Timeout: 1 * time.Second})
	if err != nil {
		log.Fatalf("Could not open database: %s", err)
	}
	defer db.Close()

	if err := db.Update(initBuckets); err != nil {
		log.Fatal(err)
	}

	hookStore := &HookStore{db}

	// webhooks
	hh := &HookHandler{hookStore, db}
	router := httprouter.New()
	router.GET("/h/:id", hh.ReceiveHook)
	router.POST("/h/:id", hh.ReceiveHook)

	go func() {
		log.Printf("Listening on %s", *listenAddr)
		log.Print(http.ListenAndServe(*listenAddr, router))
	}()

	hooks, err := hookStore.List()
	if err != nil {
		log.Fatal("Fail to load hooks")
	}
	ist := NewIssueStatusTracker(NewIssueAPI(), hooks, db)

	// admin interface
	ah := &AdminHandler{hooks: hookStore, ist: ist}
	arouter := httprouter.New()
	arouter.Handler("GET", "/public/*path", http.StripPrefix("/public", http.FileServer(http.Dir("public"))))
	arouter.GET("/", ah.Index)
	arouter.Handler("GET", "/hooks", http.RedirectHandler("/", http.StatusMovedPermanently))

	arouter.GET("/hooks/new", ah.NewHook)
	arouter.POST("/hooks", ah.CreateHook)
	arouter.GET("/hooks/edit/:id", ah.EditHook)
	arouter.POST("/hooks/edit/:id", ah.UpdateHook)

	arouter.GET("/hooks/edit/:id/add", ah.AddComponent)
	arouter.POST("/hooks/edit/:id/create", ah.CreateComponent)
	arouter.GET("/hooks/edit/:id/edit/:c", ah.EditComponent)
	arouter.POST("/hooks/edit/:id/update/:c", ah.UpdateComponent)

	go func() {
		log.Printf("Admin interface on %s", *adminAddr)
		log.Print(http.ListenAndServe(*adminAddr, arouter))
	}()

	ist.RefreshIssues()
	ist.StartPolling()
}

func New(e *engine.Engine) *App {

	if e == nil {
		panic("httphandler.New(e *engine.Engine): e is nil")
	}

	app := &App{
		engine: e,
		mux:    http.NewServeMux(),
	}

	// ---------------------------------------------------------------------------

	var (
		ordersRouter     = httprouter.New()
		orderItemsRouter = httprouter.New()
		productsRouter   = httprouter.New()
	)

	productsRouter.POST("/products/", app.createProductHandler)
	productsRouter.GET("/products/:id", app.loadProductHandler)
	productsRouter.GET("/products/", app.listProductsHandler)
	productsRouter.PUT("/products/:id", app.updateProductHandler)

	ordersRouter.POST("/orders/", app.createOrderHandler)
	ordersRouter.GET("/orders/:id", app.loadOrderHandler)
	ordersRouter.GET("/orders/", app.listOrdersHandler)
	ordersRouter.PUT("/orders/:id", app.updateOrderHandler)

	orderItemsRouter.POST("/orders/:orderID/items/", app.createOrderItemHandler)
	orderItemsRouter.GET("/orders/:orderID/items/:productID", app.loadOrderItemHandler)
	orderItemsRouter.GET("/orders/:orderID/items/", app.listOrderItemsHandler)
	orderItemsRouter.PUT("/orders/:orderID/items/:productID", app.updateOrderItemHandler)
	orderItemsRouter.DELETE("/orders/:orderID/items/:productID", app.removeOrderItemHandler)

	// (facepalm) using httphandler here was not the best decision:
	app.mux.HandleFunc("/orders/", func(w http.ResponseWriter, r *http.Request) {
		if strings.Contains(r.URL.Path, "/items") {
			orderItemsRouter.ServeHTTP(w, r)
		} else {
			ordersRouter.ServeHTTP(w, r)
		}
	})

	app.mux.Handle("/", productsRouter)

	// ---------------------------------------------------------------------------

	return app
}

func loadHttpRouter(routes []route) http.Handler {
	router := httprouter.New()
	for _, route := range routes {
		router.Handle(route.method, route.path, httpRouterHandle)
	}
	return router
}

func main() {
	router := httprouter.New()
	router.GET("/", Index)
	router.GET("/user/*name", Index)

	log.Fatal(http.ListenAndServe(":8080", router))
}

func (c *context) attachRoutes() {
	c.router = httprouter.New()

	_routes := *c.routes
	for i := range _routes {
		// Individual Controller calls per routes are expected to happen from here
		d := D{c: c, actions: _routes[i].actions, data: make(map[string]interface{})}
		switch _routes[i].method {
		case "GET":
			c.router.GET(_routes[i].url, d.call)
			break
		case "POST":
			c.router.POST(_routes[i].url, d.call)
			break
		case "PUT":
			c.router.PUT(_routes[i].url, d.call)
			break
		case "DELETE":
			c.router.DELETE(_routes[i].url, d.call)
			break
		case "OPTIONS":
			c.router.OPTIONS(_routes[i].url, d.call)
			break
		default:
			break
		}
	}
}

func main() {
	routes, err := ParseRoutes(".")
	if err != nil {
		log.Fatal(err)
	}
	db, err = GetDbConnection()
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()
	router := httprouter.New()
	for _, route := range routes {
		if route.Method == "GET" {
			router.GET(route.Path, handler(route))
		}
		if route.Method == "POST" {
			router.POST(route.Path, handler(route))
		}
		if route.Method == "PUT" {
			router.PUT(route.Path, handler(route))
		}
		if route.Method == "DELETE" {
			router.DELETE(route.Path, handler(route))
		}
	}
	port := "8080"
	if len(os.Args) > 1 {
		port = os.Args[1]
	}
	log.Fatal(http.ListenAndServe(":"+port, router))
}

// newStatusServer allocates and returns a statusServer.
func newStatusServer(
	db *client.DB,
	gossip *gossip.Gossip,
	metricSource metricMarshaler,
	ctx *base.Context,
	rpcCtx *rpc.Context,
	stores *storage.Stores,
) *statusServer {
	server := &statusServer{
		db:           db,
		gossip:       gossip,
		metricSource: metricSource,
		router:       httprouter.New(),
		rpcCtx:       rpcCtx,
		stores:       stores,
	}

	server.router.GET(statusLogFilesListPattern, server.handleLogFilesList)
	server.router.GET(statusLogFilePattern, server.handleLogFile)
	server.router.GET(statusLogsPattern, server.handleLogs)
	// TODO(tschottdorf): significant overlap with /debug/pprof/goroutine,
	// except that this one allows querying by NodeID.
	server.router.GET(statusStacksPattern, server.handleStacks)
	server.router.GET(statusMetricsPattern, server.handleMetrics)
	server.router.GET(statusVars, server.handleVars)

	return server
}

func (this *Monitor) setupRoutes() {
	this.router = httprouter.New()
	this.router.GET("/ver", this.versionHandler)
	this.router.GET("/metrics", this.metricsHandler)
	this.router.PUT("/set", this.configHandler)
	this.router.POST("/alertHook", this.alertHookHandler) // zabbix will call me on alert event
}

// NewAPIWithMarshalers does the same as NewAPIWithBaseURL with the addition
// of a set of marshalers that provide a way to interact with clients that
// use a serialization format other than JSON. The marshalers map is indexed
// by the MIME content type to use for a given request-response pair. If the
// client provides an Accept header the server will respond using the client's
// preferred content type, otherwise it will respond using whatever content
// type the client provided in its Content-Type request header.
func NewAPIWithMarshalers(prefix string, baseURL string, marshalers map[string]ContentMarshaler) *API {
	if len(marshalers) == 0 {
		panic("marshaler map must not be empty")
	}

	// Add initial and trailing slash to prefix
	prefixSlashes := strings.Trim(prefix, "/")
	if len(prefixSlashes) > 0 {
		prefixSlashes = "/" + prefixSlashes + "/"
	} else {
		prefixSlashes = "/"
	}

	router := httprouter.New()
	router.MethodNotAllowed = notAllowedHandler{marshalers: marshalers}

	info := information{prefix: prefix, baseURL: baseURL}

	return &API{
		router:     router,
		prefix:     prefixSlashes,
		info:       info,
		marshalers: marshalers,
	}
}

// New returns a new *router to be used to configure the endpoints
func New() *Router {
	r := Router{}
	r.router = httprouter.New()
	r.middleware = nil

	return &r
}

// newStatusServer allocates and returns a statusServer.
func newStatusServer(
	db *client.DB,
	gossip *gossip.Gossip,
	metricSource json.Marshaler,
	ctx *base.Context,
	rpcCtx *rpc.Context,
	stores *storage.Stores,
) *statusServer {
	// Create an http client with a timeout
	httpClient, err := ctx.GetHTTPClient()
	if err != nil {
		log.Error(err)
		return nil
	}

	server := &statusServer{
		db:           db,
		gossip:       gossip,
		metricSource: metricSource,
		router:       httprouter.New(),
		rpcCtx:       rpcCtx,
		proxyClient:  httpClient,
		stores:       stores,
	}

	server.router.GET(statusLogFilesListPattern, server.handleLogFilesList)
	server.router.GET(statusLogFilePattern, server.handleLogFile)
	server.router.GET(statusLogsPattern, server.handleLogs)
	// TODO(tschottdorf): significant overlap with /debug/pprof/goroutine,
	// except that this one allows querying by NodeID.
	server.router.GET(statusStacksPattern, server.handleStacks)
	server.router.GET(statusMetricsPattern, server.handleMetrics)

	return server
}

func main() {
	Values[1] = "z"
	Values[2] = "y"
	Values[3] = "x"
	Values[4] = "q"
	Values[5] = "w"
	Values[6] = "v"
	Values[7] = "u"
	Values[8] = "t"
	Values[9] = "s"
	Values[10] = "r"

	for _, each := range ListOfServers {
		HashingMapping[calculateHashValue(each)] = each
	}

	for k, _ := range Values {
		HashingMapping[calculateHashValue(strconv.Itoa(k))] = strconv.Itoa(k)
	}

	for k, _ := range HashingMapping {
		SortedHashingMappingKeys = append(SortedHashingMappingKeys, k)
	}

	sort.Strings(SortedHashingMappingKeys)
	mux := httprouter.New()
	mux.PUT("/keys/:key/:value", putDataTo)
	mux.GET("/keys/:key", getRequest)
	server := http.Server{
		Addr:    "0.0.0.0:8000",
		Handler: mux,
	}
	server.ListenAndServe()
}

// NewServer returns a new front-end web server that handles HTTP requests for the app.
func NewServer() *Server {
	router := httprouter.New()
	server := &Server{mux: router}
	router.GET("/", server.Root)
	router.POST("/slack/:slackAlpha/:slackBeta/:slackGamma", server.Slack)
	return server
}

func main() {
	flag.Parse()
	addr := Host + ":" + Port

	logger.Info("botyardq", "path", DBPath, "host", Host, "port", Port)

	broker = NewBroker(DBPath)
	err := broker.Init()
	if err != nil {
		logger.Error("broker", "err", err)
		os.Exit(1)
	}

	router := httprouter.New()
	router.POST("/v1/queues/:queue", PushHandler)
	router.GET("/v1/queues/:queue", PopHandler)
	router.DELETE("/v1/queues/:queue/:id", DeleteHandler)

	logger.Info("Serving at " + addr)
	err = http.ListenAndServe(addr, router)
	if err != nil {
		log.Error("listen", "err", err)
		os.Exit(1)
	}

	logger.Info("bye")
}

func main() {
	var mongoServer, httpBinding string
	flag.StringVar(&mongoServer, "mongoServer", "", "The connection to the mongo server")
	flag.StringVar(&dbName, "dbName", "", "The database containing the crits collections")
	flag.StringVar(&httpBinding, "httpBinding", "", "The desired HTTP binding")
	flag.Parse()

	if mongoServer == "" || dbName == "" || httpBinding == "" {
		panic("Please set mongoServer, dbName, and httpBinding!")
	}

	var err error
	session, err = mgo.Dial(mongoServer)
	if err != nil {
		panic(err)
	}
	defer session.Close()

	session.SetMode(mgo.Monotonic, true)

	router := httprouter.New()
	router.GET("/:id", handler)
	log.Fatal(http.ListenAndServe(httpBinding, router))

}

func main() {
	defer shutdown.Exit()

	api := &API{}

	router := httprouter.New()
	router.POST("/databases", api.createDatabase)
	router.DELETE("/databases", api.dropDatabase)
	router.GET("/ping", api.ping)

	port := os.Getenv("PORT")
	if port == "" {
		port = "3000"
	}
	addr := ":" + port

	hb, err := discoverd.AddServiceAndRegister(serviceName+"-api", addr)
	if err != nil {
		shutdown.Fatal(err)
	}
	shutdown.BeforeExit(func() { hb.Close() })

	handler := httphelper.ContextInjector(serviceName+"-api", httphelper.NewRequestLogger(router))
	shutdown.Fatal(http.ListenAndServe(addr, handler))
}

func run() error {
	kingpin.Parse()

	db, err := newDB()
	if err != nil {
		return errgo.Mask(err)
	}
	keyPair, err := loadKeyPair()
	if err != nil {
		return errgo.Mask(err)
	}
	service := boltstorage.NewService(db)
	handler := sfhttp.NewHandler(keyPair, service)

	r := httprouter.New()
	handler.Register(r)

	var t tomb.Tomb
	if *httpFlag != "" {
		t.Go(func() error {
			return http.ListenAndServe(*httpFlag, r)
		})
	}
	if *httpsFlag != "" && *certFlag != "" && *keyFlag != "" {
		t.Go(func() error {
			return http.ListenAndServeTLS(*httpsFlag, *certFlag, *keyFlag, r)
		})
	}

	log.Printf("public key: %s", keyPair.PublicKey.Encode())
	return t.Wait()
}