func (me *Coordinator) ServeHTTP(port int) {
me.Mux.HandleFunc("/",
func(w http.ResponseWriter, req *http.Request) {
me.rootHandler(w, req)
})
me.Mux.HandleFunc("/worker",
func(w http.ResponseWriter, req *http.Request) {
me.workerHandler(w, req)
})
me.Mux.HandleFunc("/workerkill",
func(w http.ResponseWriter, req *http.Request) {
me.killHandler(w, req)
})
rpcServer := rpc.NewServer()
if err := rpcServer.Register(me); err != nil {
log.Fatal(err)
}
me.Mux.HandleFunc(rpc.DefaultRPCPath,
func(w http.ResponseWriter, req *http.Request) {
rpcServer.ServeHTTP(w, req)
})
addr := fmt.Sprintf(":%d", port)
log.Println("Coordinator listening on", addr)
httpServer := http.Server{
Addr: addr,
Handler: me.Mux,
}
err := httpServer.ListenAndServe()
if err != nil {
log.Fatal("ListenAndServe: ", err.String())
}
}
func ListenAndServe(addr string) os.Error {
// TODO(kevlar): add instrumentation for examining modifications
server := http.Server{
Addr: addr,
Handler: DefaultServeMux,
}
return server.ListenAndServe()
}
func main() {
//Load logging configuration
l4g.LoadConfiguration("logging.xml")
//Load default config file
var configPath string
flag.StringVar(&configPath, "config", "/etc/gosolr/gosolr.cfg", "Path to the configuration file")
flag.Parse()
config = loadConfig(configPath)
//Load solr servers/cores from mysql db
solrServers = loadSolrServers(config)
prettyPrint(solrServers)
//Setup the http proxy stuff
for apiKey := range solrServers {
urlPath := "/" + apiKey
http.HandleFunc(urlPath, handleRequest)
}
var err os.Error
var srv http.Server
srv.Addr = config["default"]["host"] + ":" + config["default"]["port"]
srv.Handler = nil
if srv.ReadTimeout, err = strconv.Atoi64(config["default"]["read_timeout"]); err != nil {
l4g.Error("Configuration error. Bad read_timout value")
os.Exit(1)
}
if srv.WriteTimeout, err = strconv.Atoi64(config["default"]["write_timeout"]); err != nil {
l4g.Error("Configuration error. Bad write_timeout value")
os.Exit(1)
}
//If this were real, this should be TLS
if err := srv.ListenAndServe(); err != nil {
l4g.Error("Error starting server: %s", err.String())
os.Exit(1)
}
}
func main() {
flag.Parse()
readTemplates()
if *root == "" {
var err os.Error
*root, err = os.Getwd()
if err != nil {
log.Fatalf("Failed to getwd: %v", err)
}
}
fixupGitwebFiles()
latestGits := filepath.Join(*root, "latestgits")
os.Mkdir(latestGits, 0700)
if *gerritHost != "" {
go rsyncFromGerrit(latestGits)
}
mux := http.DefaultServeMux
mux.Handle("/favicon.ico", http.FileServer(http.Dir(filepath.Join(*root, "static"))))
mux.Handle("/robots.txt", http.FileServer(http.Dir(filepath.Join(*root, "static"))))
mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir(filepath.Join(*root, "static")))))
mux.Handle("/talks/", http.StripPrefix("/talks/", http.FileServer(http.Dir(filepath.Join(*root, "talks")))))
gerritUrl, _ := url.Parse("http://gerrit-proxy:8000/")
var gerritHandler http.Handler = http.NewSingleHostReverseProxy(gerritUrl)
if *httpsAddr != "" {
proxyHandler := gerritHandler
gerritHandler = http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
if req.TLS != nil {
proxyHandler.ServeHTTP(rw, req)
return
}
http.Redirect(rw, req, "https://camlistore.org"+req.URL.RawPath, http.StatusFound)
})
}
mux.Handle("/r/", gerritHandler)
testCgi := &cgi.Handler{Path: filepath.Join(*root, "test.cgi"),
Root: "/test.cgi",
}
mux.Handle("/test.cgi", testCgi)
mux.Handle("/test.cgi/foo", testCgi)
mux.Handle("/code", http.RedirectHandler("/code/", http.StatusFound))
if *gitwebScript != "" {
env := os.Environ()
env = append(env, "GITWEB_CONFIG="+filepath.Join(*root, "gitweb-camli.conf"))
env = append(env, "CAMWEB_ROOT="+filepath.Join(*root))
env = append(env, "CAMWEB_GITDIR="+latestGits)
mux.Handle("/code/", &fixUpGitwebUrls{&gitwebHandler{
Cgi: &cgi.Handler{
Path: *gitwebScript,
Root: "/code/",
Env: env,
},
Static: http.StripPrefix("/code/", http.FileServer(http.Dir(*gitwebFiles))),
}})
}
mux.HandleFunc("/", mainHandler)
var handler http.Handler = &noWwwHandler{Handler: mux}
if *logDir != "" || *logStdout {
handler = NewLoggingHandler(handler, *logDir, *logStdout)
}
errch := make(chan os.Error)
httpServer := &http.Server{
Addr: *httpAddr,
Handler: handler,
ReadTimeout: connTimeoutNanos,
WriteTimeout: connTimeoutNanos,
}
go func() {
errch <- httpServer.ListenAndServe()
}()
if *httpsAddr != "" {
log.Printf("Starting TLS server on %s", *httpsAddr)
httpsServer := new(http.Server)
*httpsServer = *httpServer
httpsServer.Addr = *httpsAddr
go func() {
errch <- httpsServer.ListenAndServeTLS(*tlsCertFile, *tlsKeyFile)
}()
}
log.Fatalf("Serve error: %v", <-errch)
}