func main() {
flag.Parse()
if flag.NArg() != 1 {
log.Fatal("filename not specified")
}
filename := flag.Args()[0]
h := &handler{
filename: filename,
c: make(chan bool),
}
// Watch file(s) for changes and trigger refresh
go h.watcher(h.filename)
http.HandleFunc("/ws/echo", h.reloadHandler)
http.Handle("/", h)
go http.ListenAndServe(":3000", nil)
err := http.ListenAndServe(":3000", nil)
if err != nil {
panic("Error: " + err.Error())
}
fmt.Println("Done")
}
func main() {
flag.Parse()
if arguments.pprof {
log.Println("pprof enabled")
go func() {
log.Println(http.ListenAndServe("localhost:6060", nil))
}()
fp, err := os.Create("backend.pprof")
if err != nil {
panic(err)
}
defer fp.Close()
pprof.StartCPUProfile(fp)
defer pprof.StopCPUProfile()
}
if err := loadTree(arguments.tree); err != nil {
log.Println(err)
os.Exit(-1)
}
http.Handle("/", http.FileServer(http.Dir(arguments.web)))
http.Handle("/render", websocket.Handler(renderServer))
log.Println("waiting for connections...")
if err := http.ListenAndServe(fmt.Sprintf(":%v", arguments.port), nil); err != nil {
log.Println(err)
os.Exit(-1)
}
}
// ListenAndServe method serve plots via http on port. HTML docs should be under the webRoot directory.
// This routine won't return so kick off any other processes as a goroutine.
func (l *Logger) ListenAndServe(port, webRoot string) {
var err error
if l.step != nil {
http.HandleFunc("/step", func(w http.ResponseWriter, r *http.Request) {
sendJSON(w, r, <-l.step)
})
http.HandleFunc("/start", func(w http.ResponseWriter, r *http.Request) {
l.start <- empty{}
})
}
http.HandleFunc("/stats/", l.statsHandler(len("/stats/")))
http.HandleFunc("/plot/List", func(w http.ResponseWriter, r *http.Request) {
sendJSON(w, r, l.options)
})
http.HandleFunc("/plot/Plot", func(w http.ResponseWriter, r *http.Request) {
sendJSON(w, r, l.plots)
})
http.HandleFunc("/plot/SVGPlot", func(w http.ResponseWriter, r *http.Request) {
send(w, r, l.svgplot, "image/svg+xml")
})
http.HandleFunc("/plot/Hist", l.histogramPlotHandler())
http.HandleFunc("/plot/", l.statsPlotHandler(len("/plot/")))
http.HandleFunc("/graph", l.graphHandler())
http.Handle("/", http.FileServer(http.Dir(webRoot)))
log.Println("starting web server on", port)
if Debug {
err = http.ListenAndServe(port, logRequests(http.DefaultServeMux))
} else {
err = http.ListenAndServe(port, nil)
}
log.Fatal(err)
}
func main() {
router := mux.NewRouter()
ctx := context.Background()
svc := yell.YellingService{}
yellHandler := httptransport.NewServer(
ctx,
yell.MakeYellEndpoint(svc),
yell.DecodeYellRequest,
yell.EncodeResponse,
)
composeHandler := httptransport.NewServer(
ctx,
compose.MakeComposeEndpoint(svc),
compose.DecodeComposeRequest,
compose.EncodeResponse,
)
router.HandleFunc("/", RootHandler)
router.PathPrefix("/static/").Handler(http.StripPrefix("/static/", http.FileServer(http.Dir(*staticPath))))
http.Handle("/yell", yellHandler)
http.Handle("/compose", composeHandler)
go http.ListenAndServe(":8080", nil)
go log.Fatal(http.ListenAndServe(":8081", router))
}
func main() {
rand.Seed(time.Now().UTC().UnixNano())
if len(os.Args) > 1 && os.Args[1] == "web" {
handler := func(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
for k, v := range r.Form {
if k == "height" {
height, _ = strconv.Atoi(strings.Join(v, ""))
} else if k == "width" {
width, _ = strconv.Atoi(strings.Join(v, ""))
} else if k == "color" {
color = v[0]
}
}
w.Header().Set("Content-Type", "image/svg+xml")
drawSVG(w, r)
}
http.HandleFunc("/", handler)
//!-http
log.Fatal(http.ListenAndServe("localhost:8000", nil))
return
}
http.HandleFunc("/draw", drawSVG)
log.Fatal(http.ListenAndServe("localhost:8000", nil))
}
func main() {
location2 = 0
location3 = 0
location1 = 0
mutliplexer := httprouter.New()
mutliplexer.GET("/keys", PingRedisPorts)
mutliplexer.GET("/keys/:key_id", GetOneKey)
mutliplexer.PUT("/keys/:key_id/:value", AddKeyValues)
mutliplexer.GET("/all", AllRedisKeyValues)
mutliplexer.GET("/mapping", GetMapping)
go http.ListenAndServe(":3000", mutliplexer)
go http.ListenAndServe(":3001", mutliplexer)
go http.ListenAndServe(":3002", mutliplexer)
select {}
}
func main() {
dataDirectory := flag.String("d", defaultDataDirectory, "Directory where dictionary files are located")
serviceListenPort := flag.Int("p", defaultServiceListenPort, "Service Listen Port")
adminListenPort := flag.Int("a", defaultAdminListenPort, "Admin Listen Port")
allowedOrigin := flag.String("c", handlers.AllowedOrigin, "CORS Allowed Origin")
flag.Parse()
log.Printf("Using data directory %s", *dataDirectory)
handlers.DataDirectory = *dataDirectory
handlers.LoadDictionaries()
r := mux.NewRouter()
r.HandleFunc("/twocents", handlers.MetaVersionsHandler).Methods("GET")
r.HandleFunc("/twocents/{version:v1}", handlers.MetaDictionariesHandler).Methods("GET")
r.HandleFunc("/twocents/{version:v1}/{dictionary}/{query}", handlers.TwoCentsHandlerV1).Methods("GET")
r.HandleFunc("/twocents/{version:v1}/{dictionary}/{query}/{limit:[0-9]+}", handlers.TwoCentsHandlerV1).Methods("GET")
r.HandleFunc("/twocents/{version:v1}/{dictionary}/{query}/{limit:[0-9]+}/{filter}", handlers.TwoCentsHandlerV1).Methods("GET")
http.Handle("/", r)
log.Printf("Service listening on port %d", *serviceListenPort)
go func() {
log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", *serviceListenPort), nil))
}()
log.Printf("Admin listening on port %d", *adminListenPort)
if *allowedOrigin != "" {
log.Printf("Setting CORS Origin to %s", *allowedOrigin)
handlers.AllowedOrigin = *allowedOrigin
}
//TODO: Find a better way to pass a different router to the admin server
http.ListenAndServe(fmt.Sprintf(":%d", *adminListenPort), &adminHandler{})
}
func main() {
if len(os.Args) > 1 {
switch os.Args[1] {
case "setup":
defer lazyblog.DefaultStore.Close()
lazyblog.Setup()
case "start":
defer lazyblog.DefaultStore.Close()
numUsers, err := lazyblog.NumUsers()
if err != nil {
panic(err)
}
if numUsers < 1 {
log.Fatalln("Please run setup before running start")
return
}
if os.Getenv("LAZYBLOG_ENV") == "dev" {
log.Fatalln(http.ListenAndServe(":3000", lazyblog.Router))
}
log.Fatalln(http.ListenAndServe(":80", lazyblog.Router))
default:
fmt.Println(usage)
}
} else {
fmt.Println(usage)
}
}
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 main() {
f := flag.String("config", "$HOME/.config/mallory.json", "config file")
flag.Parse()
L.Printf("Starting...\n")
c, err := m.NewConfig(*f)
if err != nil {
L.Fatalln(err)
}
L.Printf("Connecting remote SSH server: %s\n", c.File.RemoteServer)
smart, err := m.NewServer(m.SmartSrv, c)
if err != nil {
L.Fatalln(err)
}
normal, err := m.NewServer(m.NormalSrv, c)
if err != nil {
L.Fatalln(err)
}
go func() {
L.Printf("Local normal HTTP proxy: %s\n", c.File.LocalNormalServer)
L.Fatalln(http.ListenAndServe(c.File.LocalNormalServer, normal))
}()
L.Printf("Local smart HTTP proxy: %s\n", c.File.LocalSmartServer)
L.Fatalln(http.ListenAndServe(c.File.LocalSmartServer, smart))
}
func main() {
port := flag.Int("port", 6969, "port to serve websockets on")
cport := flag.Int("cport", 6868, "port to listen for control messages on")
nCpu := flag.Int("ncpu", runtime.NumCPU(), "number of cpus to use, defaults to number of processors available")
mgrVerbose := flag.Bool("verbose-merry-go-round", false, "Verbose output from merry-go-round carousels")
flag.Parse()
runtime.GOMAXPROCS(*nCpu)
mgr.VERBOSE = *mgrVerbose
ss := socketserver.NewSocketServer()
go func() {
bindAddr := fmt.Sprintf(":%d", *port)
fmt.Printf("SocketServer going up at: %s\n", bindAddr)
log.Fatal(http.ListenAndServe(bindAddr, ss))
}()
sc := control.NewSocketController(ss)
bindAddr := fmt.Sprintf(":%d", *cport)
fmt.Printf("SocketController going up at: %s\n", bindAddr)
log.Fatal(http.ListenAndServe(bindAddr, sc))
}
func main() {
flag.Parse()
if *uberClientId == "" || *uberClientSecret == "" || *httpsUrl == "" || *httpUrl == "" || *googleMapsApiKey == "" {
flag.PrintDefaults()
return
}
uberApiClient = &UberApiClient{
url: *uberApiHost,
clientSecret: *uberClientSecret,
clientId: *uberClientId,
}
mondoApiClient = &MondoApiClient{url: *mondoApiUrl}
router.HandleFunc("/", indexGet).Methods("GET").Name(Index)
router.HandleFunc("/login", loginPost).Methods("POST").Name(Login)
router.HandleFunc("/logout", logoutPost).Methods("POST").Name(Logout)
router.HandleFunc("/uber/setauthcode", uberSetAuthCodeGet).Methods("GET").Name(SetAuthCode)
router.HandleFunc("/mondo/webhook/{sessionId}", mondoWebhookPost).Methods("POST").Name(MondoWebhook)
router.PathPrefix("/").Handler(http.FileServer(http.Dir("./")))
go func() {
log.Printf("Listening on %s\n", *httpAddr)
log.Fatal(http.ListenAndServe(*httpAddr, middleware(router)))
}()
log.Printf("Listening on %s\n", *httpsAddr)
if strings.Contains(*httpsAddr, "443") {
log.Fatal(http.ListenAndServeTLS(*httpsAddr, *certFile, *keyFile, middleware(router)))
} else {
log.Fatal(http.ListenAndServe(*httpsAddr, middleware(router)))
}
}
func main() {
flag.Parse()
r := mux.NewRouter()
operatorPost := make(chan []byte)
clientPost := make(chan []byte)
clientGet := make(chan []byte)
gameToOperator := make(chan []byte)
r.Path("/frontend").Methods("GET").HandlerFunc(handleClientGet(clientGet))
r.Path("/frontend").Methods("POST").HandlerFunc(handleClientPost(clientPost))
r.Path("/move").Methods("POST").HandlerFunc(handleOperatorPost(operatorPost, gameToOperator))
go func() {
var previousGame []byte
for {
sendGameToClient := clientGet
if previousGame == nil {
sendGameToClient = nil
}
select {
case x := <-clientPost:
gameToOperator <- x
previousGame = nil
case x := <-operatorPost:
previousGame = x
case sendGameToClient <- previousGame:
}
}
}()
go func() {
http.ListenAndServe(":"+*port, r)
}()
http.ListenAndServe(":1337", r)
}
func main() {
// Setup the global variables and settings
err := models.Setup()
if err != nil {
fmt.Println(err)
}
wg := &sync.WaitGroup{}
wg.Add(1)
// Start the web servers
go func() {
defer wg.Done()
if config.Conf.AdminConf.UseTLS { // use TLS for Admin web server if available
Logger.Printf("Starting admin server at https://%s\n", config.Conf.AdminConf.ListenURL)
Logger.Fatal(http.ListenAndServeTLS(config.Conf.AdminConf.ListenURL, config.Conf.AdminConf.CertPath, config.Conf.AdminConf.KeyPath,
handlers.CombinedLoggingHandler(os.Stdout, controllers.CreateAdminRouter())))
} else {
Logger.Printf("Starting admin server at http://%s\n", config.Conf.AdminConf.ListenURL)
Logger.Fatal(http.ListenAndServe(config.Conf.AdminConf.ListenURL, handlers.CombinedLoggingHandler(os.Stdout, controllers.CreateAdminRouter())))
}
}()
wg.Add(1)
go func() {
defer wg.Done()
if config.Conf.PhishConf.UseTLS { // use TLS for Phish web server if available
Logger.Printf("Starting phishing server at https://%s\n", config.Conf.PhishConf.ListenURL)
Logger.Fatal(http.ListenAndServeTLS(config.Conf.PhishConf.ListenURL, config.Conf.PhishConf.CertPath, config.Conf.PhishConf.KeyPath,
handlers.CombinedLoggingHandler(os.Stdout, controllers.CreatePhishingRouter())))
} else {
Logger.Printf("Starting phishing server at http://%s\n", config.Conf.PhishConf.ListenURL)
Logger.Fatal(http.ListenAndServe(config.Conf.PhishConf.ListenURL, handlers.CombinedLoggingHandler(os.Stdout, controllers.CreatePhishingRouter())))
}
}()
wg.Wait()
}
func main() {
db, err := bolt.Open("proxy.db", 0600, nil)
if err != nil {
log.Fatal("Fatal: %s\n", err.Error())
}
defer db.Close()
adminServer := proxyAdminServer{db}
adminMux := bone.New()
adminMux.Get("/proxy", http.HandlerFunc(adminServer.GetProxies))
adminMux.Delete("/proxy/:id", http.HandlerFunc(adminServer.DeleteProxyIteraction))
adminMux.Post("/proxy", http.HandlerFunc(adminServer.NewProxyIteraction))
proxyServer := proxyServer{&http.Client{}, db}
mux := bone.New()
mux.Handle("/*", http.HandlerFunc(proxyServer.ProxyHandler))
go func(port string) {
log.Println("Starting admin server")
log.Fatal(http.ListenAndServe(port, adminMux))
}(":9080")
log.Println("Starting test proxy")
log.Fatal(http.ListenAndServe(":9090", mux))
}
func main() {
flag.Parse()
peers := gc.NewHTTPPool("http://localhost:" + *port)
peers.Set("http://localhost:8001", "http://localhost:8002")
cg = gc.NewGroup("QRCache", 1<<20, gc.GetterFunc(
func(ctx gc.Context, key string, dest gc.Sink) error {
fmt.Printf("asking for data of %s\n", key)
url := fmt.Sprintf("http://chart.apis.google.com/chart?chs=300x300&cht=qr&choe=UTF-8&chl=%s", key)
resp, err := http.Get(url)
if err != nil {
return nil
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil
}
value := base64.StdEncoding.EncodeToString(body)
dest.SetBytes([]byte(value))
return nil
}))
// run groupcache process in goroutine
go http.ListenAndServe("localhost:"+*port, peers)
http.Handle("/", http.HandlerFunc(QR))
err := http.ListenAndServe(*addr, nil)
if err != nil {
log.Fatal("ListenAndServe:", err)
}
}
func main() {
// Use all available cores
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
rout := NewRouter(*mongoUrl, *mongoDbName)
rout.ReloadRoutes()
log.Println("router: listening for requests on " + *pubAddr)
log.Println("router: listening for refresh on " + *apiAddr)
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
http.NotFound(w, r)
return
}
rout.ReloadRoutes()
})
go http.ListenAndServe(*pubAddr, rout)
go http.ListenAndServe(*apiAddr, nil)
<-quit
}
func (p *proxy) ListenAndServe() error {
addr, err := net.ResolveTCPAddr("tcp", net.JoinHostPort("", strconv.Itoa(p.port)))
if err != nil {
return err
}
p.addr = addr
done := make(chan error, 1)
go func() {
done <- http.ListenAndServe(p.addr.String(), p)
}()
select {
case err := <-done:
done <- err
default:
if addr, err := findAvailablePort(); err == nil {
go func(port int) {
p.codeViewerMux.Port = port
p.codeViewerMux.Addr = net.JoinHostPort("", strconv.Itoa(port))
done <- http.ListenAndServe(p.codeViewerMux.Addr, p.codeViewerMux.Handler)
}(addr.Port)
} else {
done <- err
}
}
err = <-done
p.shutdown()
return err
}
func main() {
go func() {
fmt.Println(http.ListenAndServe("localhost:9002", nil))
}()
host := "localhost:9001"
fmt.Println("starting server " + host + "..")
routing.RouteDirectory("assets")
routing.Route("/", actions.Root)
routing.Route("/login/", actions.Login)
routing.Route("/logout/", actions.Logout)
routing.Route("/api/{entity}/", actions.Api)
routing.Route("/{category}/", actions.Category)
routing.Route("/{category}/{post_url}/", actions.Post)
routing.RouteFile("/sitemap.xml", "public/sitemap.xml")
routing.RouteFile("/robots.txt", "public/robots.txt")
err := http.ListenAndServe(host, routing.Router())
if err != nil {
fmt.Println("Error serving " + host)
fmt.Println(err)
}
}
// Binds and runs the application on the given config port.
func (f *Fogo) Run() {
f.router.PathPrefix("/static/").Handler(http.StripPrefix("/static/", http.FileServer(http.Dir(f.config.AssetDirectory))))
if f.config.CatchAll {
f.router.PathPrefix("/").Handler(http.FileServer(http.Dir(f.config.AssetDirectory)))
}
port := f.config.Port
if f.config.PortIncrement {
for {
err := http.ListenAndServe(f.config.GetConnectionString(), f.router)
if err != nil {
if strings.Contains(err.Error(), BIND_ERR) {
port++
time.Sleep(100 * time.Millisecond)
} else {
f.logger.LogError(err)
os.Exit(2)
}
}
}
} else {
if err := http.ListenAndServe(f.config.GetConnectionString(), f.router); err != nil {
f.logger.LogError(err)
}
}
}
func serve() {
L.Printf("Starting...\n")
L.Printf("PID: %d\n", os.Getpid())
c, err := NewConfig(*FConfig)
if err != nil {
L.Fatalln(err)
}
L.Printf("Connecting remote SSH server: %s\n", c.File.RemoteServer)
wait := make(chan int)
go func() {
normal, err := NewServer(NormalSrv, c)
if err != nil {
L.Fatalln(err)
}
L.Printf("Local normal HTTP proxy: %s\n", c.File.LocalNormalServer)
L.Fatalln(http.ListenAndServe(c.File.LocalNormalServer, normal))
wait <- 1
}()
go func() {
smart, err := NewServer(SmartSrv, c)
if err != nil {
L.Fatalln(err)
}
L.Printf("Local smart HTTP proxy: %s\n", c.File.LocalSmartServer)
L.Fatalln(http.ListenAndServe(c.File.LocalSmartServer, smart))
wait <- 1
}()
<-wait
}
// Run the HTTP handler, which exposes an HTTP interface to control tasks
func (handler *HTTPHandler) Run() {
if handler.Logger == nil {
handler.Logger = log.New(os.Stdout, "[HTTPHandler] ", log.Ldate|log.Ltime)
}
m := martini.Classic()
http.ListenAndServe(handler.Host+":"+string(handler.Port), m)
// routing
m.Get("/tasks", handler.taskStatus)
m.Get("/tasks/:id", handler.taskStatus)
m.Get("/list", handler.taskList)
m.Get("/tasks/:id/start", handler.taskStart)
m.Put("/tasks/:id/start", handler.taskStart)
m.Post("/tasks/:id/start", handler.taskStart)
m.Get("/tasks/:id/list", handler.taskListWorkers)
m.Delete("/tasks", handler.taskStop)
m.Delete("/tasks/:id", handler.taskStop)
m.Put("/tasks/:id/stop", handler.taskStop)
m.Post("/tasks/:id/stop", handler.taskStop)
m.Get("/tasks/:id/set/:name/:value", handler.taskSetOption)
m.Post("/tasks/:id/set/:name/:value", handler.taskSetOption)
m.Put("/tasks/:id/set/:name/:value", handler.taskSetOption)
//m.Run()
address := fmt.Sprintf(":%d", handler.Port)
handler.Logger.Println("HTTP handler listening on", address)
handler.Logger.Fatalln(http.ListenAndServe(address, m))
}
// Run the application, start http and scp server.
func Run(appConfig Config) {
config = appConfig
// Connect to DB
db, err := lib.Connect()
if err != nil {
fmt.Printf("Failed to connect to db")
return
}
// Logging
log := logrus.New()
log.Level = logrus.DebugLevel
log.Out = os.Stdout
log.Formatter = &logrus.TextFormatter{}
// Websockets
ws := ws.NewServer()
// Shared dependencies between all controller
deps := dependencies.Dependencies{
Fs: afero.NewOsFs(),
Logger: log,
DB: db,
WS: ws,
}
ws.Dependencies = &deps
go ws.Start()
// // Start SCP
// scp := scp.Server{}
// scp.DB = deps.DB
// scp.Logger = deps.Logger
// scp.CertPath = "certs/scp.rsa"
// scp.BindAddr = config.SCPBindAddr
// go scp.ListenAndServe()
if config.Secure {
c := autocert.DirCache("certs")
m := autocert.Manager{
Cache: c,
Prompt: autocert.AcceptTOS,
HostPolicy: autocert.HostWhitelist("x.zqz.ca"),
}
s := &http.Server{
Addr: config.HTTPBindAddr,
TLSConfig: &tls.Config{GetCertificate: m.GetCertificate},
}
deps.Info("Listening for HTTP1.1 Connections", "addr", ":3001")
deps.Info("Listening for HTTP2 Connections", "addr", config.HTTPBindAddr)
go http.ListenAndServe(":3001", secureRedirect())
s.ListenAndServeTLS("", "")
} else {
deps.Info("Listening for HTTP1.1 Connections", "addr", config.HTTPBindAddr)
http.ListenAndServe(config.HTTPBindAddr, Routes(deps))
}
}
func main() {
// Parse the command-line flags.
flag.Parse()
// Start the dispatcher.
fmt.Println("Starting the dispatcher")
dispatcherWork = workers.Dispatcher{}
dispatcherWork.Start(*NWorkers, workerWorkHandler)
dispatcherHello = workers.Dispatcher{}
dispatcherHello.Start(*NWorkers, workerHelloHandler)
// Register our collector as an HTTP handler function.
log.Println("Registering the hanlders")
http.HandleFunc("/work", hanlderWork)
http.HandleFunc("/hello", hanlderHello)
// Start the HTTP server!
log.Println("HTTP server listening on", *HTTPAddr)
if err := http.ListenAndServe(*HTTPAddr, nil); err != nil {
fmt.Println(err.Error())
}
go func() {
log.Println(http.ListenAndServe("localhost:6060", nil))
}()
}
// Starts and runs the server given its configuration. (This function never returns.)
func RunServer(config *ServerConfig) {
PrettyPrint = config.Pretty
if os.Getenv("GOMAXPROCS") == "" && runtime.GOMAXPROCS(0) == 1 {
cpus := runtime.NumCPU()
if cpus > 1 {
runtime.GOMAXPROCS(cpus)
base.Log("Configured Go to use all %d CPUs; setenv GOMAXPROCS to override this", cpus)
}
}
sc := NewServerContext(config)
for _, dbConfig := range config.Databases {
if err := sc.AddDatabaseFromConfig(dbConfig); err != nil {
base.LogFatal("Error opening database: %v", err)
}
}
base.Log("Starting admin server on %s", *config.AdminInterface)
go func() {
if err := http.ListenAndServe(*config.AdminInterface, CreateAdminHandler(sc)); err != nil {
base.LogFatal("HTTP server failed: %v", err)
}
}()
base.Log("Starting server on %s ...", *config.Interface)
if err := http.ListenAndServe(*config.Interface, CreatePublicHandler(sc)); err != nil {
base.LogFatal("HTTP server failed: %v", err)
}
}
func main() {
db := NewDB()
r := httprouter.New()
r.ServeFiles("/static/*filepath", http.Dir("public"))
r.GET("/", todo.TodoListListing(db))
r.GET("/todo", todo.TodoListListing(db))
r.GET("/todo/add", todo.AddTodoListGet(db))
r.POST("/todo/add", todo.AddTodoListPost(db))
r.GET("/todo/view/:id", todo.TodoListDetail(db))
r.GET("/todo/edit/:id", todo.EditTodoListGet(db))
r.POST("/todo/edit/:id", todo.EditTodoListPost(db))
r.GET("/todo/add-item/:id", todo.AddTodoListItemGet(db))
r.POST("/todo/add-item/:id", todo.AddTodoListItemPost(db))
r.GET("/todo/delete/:id", todo.DeleteTodoList(db))
r.GET("/todo/delete-item/:todolistid/:todoitemid", todo.DeleteTodoListItem(db))
if os.Getenv("LOCAL_DEV") == "TRUE" {
http.ListenAndServe(":8080", r)
} else {
http.ListenAndServe(":"+os.Getenv("PORT"), r)
}
}
func ListenAndServe(addr string, handler http.Handler) error {
if handler == nil {
return http.ListenAndServe(addr, DefauleRouter)
}
return http.ListenAndServe(addr, handler)
}
func main() {
flag.Parse()
IPs = parseIPs()
MinPort, MaxPort = parsePorts()
thisAddr = canonicalAddr(*flag_addr, IPs)
var err error
thisHost, _, err = net.SplitHostPort(thisAddr)
util.FatalErr(err)
DetectMumax()
DetectGPUs()
LoadJobs()
http.HandleFunc("/do/", HandleRPC)
http.HandleFunc("/", HandleStatus)
httpfs.RegisterHandlers()
// Listen and serve on all interfaces
go func() {
log.Println("serving at", thisAddr)
// try to listen and serve on all interfaces other than thisAddr
// this is for convenience, errors are not fatal.
_, p, err := net.SplitHostPort(thisAddr)
Fatal(err)
ips := util.InterfaceAddrs()
for _, ip := range ips {
addr := net.JoinHostPort(ip, p)
if addr != thisAddr { // skip thisAddr, will start later and is fatal on error
go func() {
err := http.ListenAndServe(addr, nil)
if err != nil {
log.Println("info:", err, "(but still serving other interfaces)")
}
}()
}
}
// only on thisAddr, this server's unique address,
// we HAVE to be listening.
Fatal(http.ListenAndServe(thisAddr, nil))
}()
ProbePeer(thisAddr) // make sure we have ourself as peer
go FindPeers(IPs, MinPort, MaxPort)
go RunComputeService()
go LoopWatchdog()
go RunShareDecay()
// re-load jobs every hour so we don't stall on very exceptional circumstances
go func() {
for {
time.Sleep(1 * time.Hour)
LoadJobs()
}
}()
<-make(chan struct{}) // wait forever
}
func Run() {
// 开启最大核心数运行
runtime.GOMAXPROCS(runtime.NumCPU())
// 预绑定路由
Router()
// 开启websocket
go func() {
reporter.Println("[pholcus] websocket server Running on ", wsAddr)
if err := http.ListenAndServe(wsAddr, nil); err != nil {
reporter.Fatal("Websocket ListenAndServe: ", err)
}
}()
// 开启websocket log
go func() {
reporter.Println("[pholcus] websocket log server Running on ", wslogAddr)
if err := http.ListenAndServe(wslogAddr, nil); err != nil {
reporter.Fatal("Websocket Log ListenAndServe: ", err)
}
}()
// 开启http
reporter.Println("[pholcus] http server Running on ", addr)
err := http.ListenAndServe(addr, nil) //设置监听的端口
if err != nil {
reporter.Fatal("Http ListenAndServe: ", err)
}
}
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()
}
