func main() {
flags.Parse(os.Args[1:])
// Override config file by the CONFIG env var, if specified.
if os.Getenv("CONFIG") != "" {
*confFile = os.Getenv("CONFIG")
}
// Read Config.
conf, err := config.New(*confFile)
if err != nil {
log.Fatal(err)
}
// Run QMD.
app, err := qmd.New(conf)
if err != nil {
log.Fatal(err)
}
go app.WatchScripts()
go app.StartWorkers()
go app.ListenQueue()
graceful.AddSignal(syscall.SIGINT, syscall.SIGTERM)
graceful.PreHook(app.Close)
// Start the API server.
log.Printf("Starting QMD API at %s\n", conf.Bind)
err = graceful.ListenAndServe(conf.Bind, rest.Routes(app))
if err != nil {
log.Fatal(err)
}
graceful.Wait()
}
func main() {
var err error
flags.Parse(os.Args[1:])
conf, err := server.NewConfigFromFile(*confFile, os.Getenv("CONFIG"))
if err != nil {
log.Fatal(err)
}
srv := server.New(conf)
if err := srv.Configure(); err != nil {
log.Fatal(err)
}
lg.Infof("** Imgry Server v%s at %s **", imgry.VERSION, srv.Config.Bind)
lg.Infof("** Engine: %s", srv.ImageEngine.Version())
graceful.AddSignal(syscall.SIGINT, syscall.SIGTERM)
graceful.Timeout(30 * time.Second)
graceful.PreHook(srv.Close)
graceful.PostHook(srv.Shutdown)
err = graceful.ListenAndServe(srv.Config.Bind, srv.NewRouter())
if err != nil {
lg.Fatal(err.Error())
}
graceful.Wait()
}
func main() {
var err error
flags.Parse(os.Args[1:])
conf, err := server.NewConfigFromFile(*confFile, os.Getenv("CONFIG"))
if err != nil {
log.Fatal(err)
}
srv := server.New(conf)
graceful.AddSignal(syscall.SIGINT, syscall.SIGTERM)
graceful.PreHook(func() { srv.Close() })
if err := srv.Configure(); err != nil {
log.Fatal(err)
}
lg.Infof("** Imgry Server v%s at %s **\n", imgry.VERSION, srv.Config.Server.Addr)
lg.Infof("** Engine: %s", imagick.Engine{}.Version())
err = graceful.ListenAndServe(srv.Config.Server.Addr, srv.NewRouter())
if err != nil {
lg.Fatal(err.Error())
}
graceful.Wait()
}
func main() {
flag.StringVar(&Config.bind, "bind", "127.0.0.1:8080",
"host to bind to (default: 127.0.0.1:8080)")
flag.StringVar(&Config.filesDir, "filespath", "files/",
"path to files directory")
flag.StringVar(&Config.metaDir, "metapath", "meta/",
"path to metadata directory")
flag.BoolVar(&Config.noLogs, "nologs", false,
"remove stdout output for each request")
flag.BoolVar(&Config.allowHotlink, "allowhotlink", false,
"Allow hotlinking of files")
flag.StringVar(&Config.siteName, "sitename", "linx",
"name of the site")
flag.StringVar(&Config.siteURL, "siteurl", "http://"+Config.bind+"/",
"site base url (including trailing slash)")
flag.Int64Var(&Config.maxSize, "maxsize", 4*1024*1024*1024,
"maximum upload file size in bytes (default 4GB)")
flag.StringVar(&Config.certFile, "certfile", "",
"path to ssl certificate (for https)")
flag.StringVar(&Config.keyFile, "keyfile", "",
"path to ssl key (for https)")
flag.BoolVar(&Config.fastcgi, "fastcgi", false,
"serve through fastcgi")
flag.BoolVar(&Config.remoteUploads, "remoteuploads", false,
"enable remote uploads")
flag.StringVar(&Config.contentSecurityPolicy, "contentsecuritypolicy",
"default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; referrer none;",
"value of default Content-Security-Policy header")
flag.StringVar(&Config.fileContentSecurityPolicy, "filecontentsecuritypolicy",
"default-src 'none'; img-src 'self'; object-src 'self'; media-src 'self'; sandbox; referrer none;",
"value of Content-Security-Policy header for file access")
flag.StringVar(&Config.xFrameOptions, "xframeoptions", "SAMEORIGIN",
"value of X-Frame-Options header")
flag.Parse()
mux := setup()
if Config.fastcgi {
listener, err := net.Listen("tcp", Config.bind)
if err != nil {
log.Fatal("Could not bind: ", err)
}
log.Printf("Serving over fastcgi, bound on %s, using siteurl %s", Config.bind, Config.siteURL)
fcgi.Serve(listener, mux)
} else if Config.certFile != "" {
log.Printf("Serving over https, bound on %s, using siteurl %s", Config.bind, Config.siteURL)
err := graceful.ListenAndServeTLS(Config.bind, Config.certFile, Config.keyFile, mux)
if err != nil {
log.Fatal(err)
}
} else {
log.Printf("Serving over http, bound on %s, using siteurl %s", Config.bind, Config.siteURL)
err := graceful.ListenAndServe(Config.bind, mux)
if err != nil {
log.Fatal(err)
}
}
}
// Serve starts the server
func (a *App) Serve() {
// External endpoints
external := web.New()
external.Use(server.StripTrailingSlashMiddleware())
external.Use(server.HeadersMiddleware())
external.Post("/", a.requestHandler.HandlerAuth)
externalPortString := fmt.Sprintf(":%d", *a.config.ExternalPort)
log.Println("Starting external server on", externalPortString)
go func() {
var err error
if a.config.TLS.CertificateFile != "" && a.config.TLS.PrivateKeyFile != "" {
err = graceful.ListenAndServeTLS(
externalPortString,
a.config.TLS.CertificateFile,
a.config.TLS.PrivateKeyFile,
external,
)
} else {
err = graceful.ListenAndServe(externalPortString, external)
}
if err != nil {
log.Fatal(err)
}
}()
// Internal endpoints
internal := web.New()
internal.Use(server.StripTrailingSlashMiddleware())
internal.Use(server.HeadersMiddleware())
internal.Post("/send", a.requestHandler.HandlerSend)
internal.Post("/receive", a.requestHandler.HandlerReceive)
internal.Post("/allow_access", a.requestHandler.HandlerAllowAccess)
internal.Post("/remove_access", a.requestHandler.HandlerRemoveAccess)
internalPortString := fmt.Sprintf(":%d", *a.config.InternalPort)
log.Println("Starting internal server on", internalPortString)
err := graceful.ListenAndServe(internalPortString, internal)
if err != nil {
log.Fatal(err)
}
}
//Server ...
func Server(port int) {
log.Info("Server start. Please visit http://localhost:" + strconv.Itoa(port))
log.Infoln("Press ctrl-c to stop")
http.Handle("/dashboard/blog/new", http.HandlerFunc(newBlogHandle))
http.Handle("/dashboard/generate", http.HandlerFunc(generateHandle))
http.Handle("/dashboard/deploy", http.HandlerFunc(deployHandle))
http.Handle("/dashboard/", http.StripPrefix("/dashboard/", http.FileServer(http.Dir(blog.ThemeDir+"/dashboard"))))
var config = blog.GetConfig()
http.Handle("/", http.FileServer(http.Dir(config.PublicDir)))
fmt.Println(blog.ThemeDir + "/dashboard")
if err := graceful.ListenAndServe(":"+strconv.Itoa(port), nil); err != nil {
log.Errorln("[Fail] fail to start server: ", err)
}
}
func main() {
// sets the maximum number of CPUs that can be executing simultaneously
runtime.GOMAXPROCS(runtime.NumCPU())
// override defaults via env vars
if os.Getenv("ES_HOST") != "" {
esHost = os.Getenv("ES_HOST")
}
if os.Getenv("ES_PORT") != "" {
esPort = os.Getenv("ES_PORT")
}
if os.Getenv("REDIS_HOST") != "" {
redisHost = os.Getenv("REDIS_HOST")
}
if os.Getenv("REDIS_PORT") != "" {
redisPort = os.Getenv("REDIS_PORT")
}
if os.Getenv("PUBLIC_DIR") != "" {
publicDir = os.Getenv("PUBLIC_DIR")
}
// log endpoints
log.Infof("Redis endpoint set to %s:%s", redisHost, redisPort)
log.Infof("Elasticsearch endpoint set to %s:%s", esHost, esPort)
// register available tiling types
tile.Register("heatmap", elastic.NewHeatmapTile(esHost, esPort))
tile.Register("topic_count", elastic.NewTopCountTile(esHost, esPort))
// register available meta data types
meta.Register("default", elastic.NewDefaultMeta(esHost, esPort))
// register available store types
store.Register("redis", redis.NewConnection(redisHost, redisPort))
// create server
app := api.New(publicDir)
// catch kill signals for graceful shutdown
graceful.AddSignal(syscall.SIGINT, syscall.SIGTERM)
// start server
log.Infof("Prism server listening on port %s", port)
err := graceful.ListenAndServe(":"+port, app)
if err != nil {
log.Error(err)
}
// wait until server gracefully exits
graceful.Wait()
}
// Serves the HTTP Application
func Serve(a *sir.ApplicationContext) {
// Create new Web Client
r := web.New()
// Register Routes
r.Get("/", sir.ApplicationHandler{a, statsHandler})
r.Post("/", sir.ApplicationHandler{a, register.RegisterHandler})
r.Get("/:instance_id", sir.ApplicationHandler{a, register.DetailsHandler})
r.Delete("/:instance_id", sir.ApplicationHandler{a, unregister.UnRegisterHandler})
// Setup Middleware
r.Use(JSONContentType)
r.Use(middleware.Logger)
// Serve the Application
graceful.ListenAndServe(":8000", r)
}
func (api *CassabonAPI) run() {
// Initialize API server
api.server = web.New()
// Define routes
api.server.Get("/", api.rootHandler)
api.server.Get("/paths", api.getPathHandler)
api.server.Get("/metrics", api.getMetricHandler)
api.server.Get("/healthcheck", api.healthHandler)
api.server.Delete("/paths", api.deletePathHandler)
api.server.Delete("/metrics", api.deleteMetricHandler)
api.server.NotFound(api.notFoundHandler)
api.server.Use(requestLogger)
config.G.Log.System.LogInfo("API initialized, serving!")
graceful.ListenAndServe(api.hostPort, api.server)
}
// Application Entrypoint
func main() {
// Message Hub
hub := socket.NewHub()
go hub.Run()
// WS Service
ws := socket.NewWSService(hub)
// Redis Subscription
s := pubsub.NewSubscription(
hub,
viper.GetString("redis_host"),
viper.GetString("redis_port"))
go s.Consume()
c := web.New()
// Middlewares
c.Use(middleware.SetupEnv)
c.Use(middleware.HMACVerification)
c.Use(middleware.CustomValidators)
c.Use(middleware.RedisClient)
// WS Connection Handler
c.Get("/", ws.Handler)
// Event REST endpoints
c.Post("/events/play", rest.PlayCreateHandler)
c.Post("/events/end", rest.EndCreateHandler)
c.Post("/events/pause", rest.PauseCreateHandler)
c.Post("/events/resume", rest.ResumeCreateHandler)
// Updates to Mute / Volume States
c.Put("/volume", rest.VolumeUpdateHandler)
c.Put("/mute", rest.MuteUpdateHandler)
// Get the next track from the playlist
c.Get("/playlist/next", rest.GetNextTrackHandler)
// Start Serving Web Application
log.Infof("Starting Server on :%s", viper.GetString("port"))
graceful.ListenAndServe(fmt.Sprintf(":%s", viper.GetString("port")), c)
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
// Parse the flags and store them as a conf struct
flag.Parse()
conf := skeletor.Conf{
Prod: *prod,
Version: version,
}
skeletor.SaveConf(&conf)
// Start the web server
graceful.AddSignal(syscall.SIGINT, syscall.SIGTERM)
app := api.New()
log.Println("Skeletor server listening on", *bind)
err := graceful.ListenAndServe(*bind, app)
if err != nil {
log.Fatal(err)
}
graceful.Wait()
}
func main() {
flag.StringVar(&Config.bind, "bind", "127.0.0.1:8080",
"host to bind to (default: 127.0.0.1:8080)")
flag.StringVar(&Config.filesDir, "filespath", "files/",
"path to files directory")
flag.StringVar(&Config.metaDir, "metapath", "meta/",
"path to metadata directory")
flag.BoolVar(&Config.noLogs, "nologs", false,
"remove stdout output for each request")
flag.BoolVar(&Config.allowHotlink, "allowhotlink", false,
"Allow hotlinking of files")
flag.StringVar(&Config.siteName, "sitename", "",
"name of the site")
flag.StringVar(&Config.siteURL, "siteurl", "",
"site base url (including trailing slash)")
flag.Int64Var(&Config.maxSize, "maxsize", 4*1024*1024*1024,
"maximum upload file size in bytes (default 4GB)")
flag.Uint64Var(&Config.maxExpiry, "maxexpiry", 0,
"maximum expiration time in seconds (default is 0, which is no expiry)")
flag.StringVar(&Config.certFile, "certfile", "",
"path to ssl certificate (for https)")
flag.StringVar(&Config.keyFile, "keyfile", "",
"path to ssl key (for https)")
flag.BoolVar(&Config.realIp, "realip", false,
"use X-Real-IP/X-Forwarded-For headers as original host")
flag.BoolVar(&Config.fastcgi, "fastcgi", false,
"serve through fastcgi")
flag.BoolVar(&Config.remoteUploads, "remoteuploads", false,
"enable remote uploads")
flag.StringVar(&Config.authFile, "authfile", "",
"path to a file containing newline-separated scrypted auth keys")
flag.StringVar(&Config.remoteAuthFile, "remoteauthfile", "",
"path to a file containing newline-separated scrypted auth keys for remote uploads")
flag.StringVar(&Config.contentSecurityPolicy, "contentsecuritypolicy",
"default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; frame-ancestors 'self'; referrer origin;",
"value of default Content-Security-Policy header")
flag.StringVar(&Config.fileContentSecurityPolicy, "filecontentsecuritypolicy",
"default-src 'none'; img-src 'self'; object-src 'self'; media-src 'self'; style-src 'self' 'unsafe-inline'; frame-ancestors 'self'; referrer origin;",
"value of Content-Security-Policy header for file access")
flag.StringVar(&Config.xFrameOptions, "xframeoptions", "SAMEORIGIN",
"value of X-Frame-Options header")
flag.Var(&Config.addHeaders, "addheader",
"Add an arbitrary header to the response. This option can be used multiple times.")
flag.StringVar(&Config.googleShorterAPIKey, "googleapikey", "",
"API Key for Google's URL Shortener.")
iniflags.Parse()
mux := setup()
if Config.fastcgi {
listener, err := net.Listen("tcp", Config.bind)
if err != nil {
log.Fatal("Could not bind: ", err)
}
log.Printf("Serving over fastcgi, bound on %s", Config.bind)
fcgi.Serve(listener, mux)
} else if Config.certFile != "" {
log.Printf("Serving over https, bound on %s", Config.bind)
err := graceful.ListenAndServeTLS(Config.bind, Config.certFile, Config.keyFile, mux)
if err != nil {
log.Fatal(err)
}
} else {
log.Printf("Serving over http, bound on %s", Config.bind)
err := graceful.ListenAndServe(Config.bind, mux)
if err != nil {
log.Fatal(err)
}
}
}