THIS IS A TEST INSTANCE ONLY! REPOSITORIES CAN BE DELETED AT ANY TIME!

You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

232 lines
7.0KB

  1. // Copyright 2014 The Gogs Authors. All rights reserved.
  2. // Use of this source code is governed by a MIT-style
  3. // license that can be found in the LICENSE file.
  4. package cmd
  5. import (
  6. "fmt"
  7. "net"
  8. "net/http"
  9. "net/http/fcgi"
  10. _ "net/http/pprof" // Used for debugging if enabled and a web server is running
  11. "os"
  12. "strings"
  13. "code.gitea.io/gitea/modules/log"
  14. "code.gitea.io/gitea/modules/setting"
  15. "code.gitea.io/gitea/routers"
  16. "code.gitea.io/gitea/routers/routes"
  17. context2 "github.com/gorilla/context"
  18. "github.com/unknwon/com"
  19. "github.com/urfave/cli"
  20. "golang.org/x/crypto/acme/autocert"
  21. ini "gopkg.in/ini.v1"
  22. )
  23. // CmdWeb represents the available web sub-command.
  24. var CmdWeb = cli.Command{
  25. Name: "web",
  26. Usage: "Start Gitea web server",
  27. Description: `Gitea web server is the only thing you need to run,
  28. and it takes care of all the other things for you`,
  29. Action: runWeb,
  30. Flags: []cli.Flag{
  31. cli.StringFlag{
  32. Name: "port, p",
  33. Value: "3000",
  34. Usage: "Temporary port number to prevent conflict",
  35. },
  36. cli.StringFlag{
  37. Name: "pid, P",
  38. Value: "/var/run/gitea.pid",
  39. Usage: "Custom pid file path",
  40. },
  41. },
  42. }
  43. func runHTTPRedirector() {
  44. source := fmt.Sprintf("%s:%s", setting.HTTPAddr, setting.PortToRedirect)
  45. dest := strings.TrimSuffix(setting.AppURL, "/")
  46. log.Info("Redirecting: %s to %s", source, dest)
  47. handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  48. target := dest + r.URL.Path
  49. if len(r.URL.RawQuery) > 0 {
  50. target += "?" + r.URL.RawQuery
  51. }
  52. http.Redirect(w, r, target, http.StatusTemporaryRedirect)
  53. })
  54. var err = runHTTP(source, context2.ClearHandler(handler))
  55. if err != nil {
  56. log.Fatal("Failed to start port redirection: %v", err)
  57. }
  58. }
  59. func runLetsEncrypt(listenAddr, domain, directory, email string, m http.Handler) error {
  60. certManager := autocert.Manager{
  61. Prompt: autocert.AcceptTOS,
  62. HostPolicy: autocert.HostWhitelist(domain),
  63. Cache: autocert.DirCache(directory),
  64. Email: email,
  65. }
  66. go func() {
  67. log.Info("Running Let's Encrypt handler on %s", setting.HTTPAddr+":"+setting.PortToRedirect)
  68. // all traffic coming into HTTP will be redirect to HTTPS automatically (LE HTTP-01 validation happens here)
  69. var err = runHTTP(setting.HTTPAddr+":"+setting.PortToRedirect, certManager.HTTPHandler(http.HandlerFunc(runLetsEncryptFallbackHandler)))
  70. if err != nil {
  71. log.Fatal("Failed to start the Let's Encrypt handler on port %s: %v", setting.PortToRedirect, err)
  72. }
  73. }()
  74. return runHTTPSWithTLSConfig(listenAddr, certManager.TLSConfig(), context2.ClearHandler(m))
  75. }
  76. func runLetsEncryptFallbackHandler(w http.ResponseWriter, r *http.Request) {
  77. if r.Method != "GET" && r.Method != "HEAD" {
  78. http.Error(w, "Use HTTPS", http.StatusBadRequest)
  79. return
  80. }
  81. // Remove the trailing slash at the end of setting.AppURL, the request
  82. // URI always contains a leading slash, which would result in a double
  83. // slash
  84. target := strings.TrimRight(setting.AppURL, "/") + r.URL.RequestURI()
  85. http.Redirect(w, r, target, http.StatusFound)
  86. }
  87. func runWeb(ctx *cli.Context) error {
  88. if os.Getppid() > 1 && len(os.Getenv("LISTEN_FDS")) > 0 {
  89. log.Info("Restarting Gitea on PID: %d from parent PID: %d", os.Getpid(), os.Getppid())
  90. } else {
  91. log.Info("Starting Gitea on PID: %d", os.Getpid())
  92. }
  93. // Set pid file setting
  94. if ctx.IsSet("pid") {
  95. setting.CustomPID = ctx.String("pid")
  96. }
  97. // Perform global initialization
  98. routers.GlobalInit()
  99. // Set up Macaron
  100. m := routes.NewMacaron()
  101. routes.RegisterRoutes(m)
  102. // Flag for port number in case first time run conflict.
  103. if ctx.IsSet("port") {
  104. setting.AppURL = strings.Replace(setting.AppURL, setting.HTTPPort, ctx.String("port"), 1)
  105. setting.HTTPPort = ctx.String("port")
  106. switch setting.Protocol {
  107. case setting.UnixSocket:
  108. case setting.FCGI:
  109. default:
  110. // Save LOCAL_ROOT_URL if port changed
  111. cfg := ini.Empty()
  112. if com.IsFile(setting.CustomConf) {
  113. // Keeps custom settings if there is already something.
  114. if err := cfg.Append(setting.CustomConf); err != nil {
  115. return fmt.Errorf("Failed to load custom conf '%s': %v", setting.CustomConf, err)
  116. }
  117. }
  118. defaultLocalURL := string(setting.Protocol) + "://"
  119. if setting.HTTPAddr == "0.0.0.0" {
  120. defaultLocalURL += "localhost"
  121. } else {
  122. defaultLocalURL += setting.HTTPAddr
  123. }
  124. defaultLocalURL += ":" + setting.HTTPPort + "/"
  125. cfg.Section("server").Key("LOCAL_ROOT_URL").SetValue(defaultLocalURL)
  126. if err := cfg.SaveTo(setting.CustomConf); err != nil {
  127. return fmt.Errorf("Error saving generated JWT Secret to custom config: %v", err)
  128. }
  129. }
  130. }
  131. listenAddr := setting.HTTPAddr
  132. if setting.Protocol != setting.UnixSocket {
  133. listenAddr += ":" + setting.HTTPPort
  134. }
  135. log.Info("Listen: %v://%s%s", setting.Protocol, listenAddr, setting.AppSubURL)
  136. if setting.LFS.StartServer {
  137. log.Info("LFS server enabled")
  138. }
  139. if setting.EnablePprof {
  140. go func() {
  141. log.Info("Starting pprof server on localhost:6060")
  142. log.Info("%v", http.ListenAndServe("localhost:6060", nil))
  143. }()
  144. }
  145. var err error
  146. switch setting.Protocol {
  147. case setting.HTTP:
  148. NoHTTPRedirector()
  149. err = runHTTP(listenAddr, context2.ClearHandler(m))
  150. case setting.HTTPS:
  151. if setting.EnableLetsEncrypt {
  152. err = runLetsEncrypt(listenAddr, setting.Domain, setting.LetsEncryptDirectory, setting.LetsEncryptEmail, context2.ClearHandler(m))
  153. break
  154. }
  155. if setting.RedirectOtherPort {
  156. go runHTTPRedirector()
  157. } else {
  158. NoHTTPRedirector()
  159. }
  160. err = runHTTPS(listenAddr, setting.CertFile, setting.KeyFile, context2.ClearHandler(m))
  161. case setting.FCGI:
  162. NoHTTPRedirector()
  163. // FCGI listeners are provided as stdin - this is orthogonal to the LISTEN_FDS approach
  164. // in graceful and systemD
  165. NoMainListener()
  166. var listener net.Listener
  167. listener, err = net.Listen("tcp", listenAddr)
  168. if err != nil {
  169. log.Fatal("Failed to bind %s: %v", listenAddr, err)
  170. }
  171. defer func() {
  172. if err := listener.Close(); err != nil {
  173. log.Fatal("Failed to stop server: %v", err)
  174. }
  175. }()
  176. err = fcgi.Serve(listener, context2.ClearHandler(m))
  177. case setting.UnixSocket:
  178. // This could potentially be inherited using LISTEN_FDS but currently
  179. // these cannot be inherited
  180. NoHTTPRedirector()
  181. NoMainListener()
  182. if err := os.Remove(listenAddr); err != nil && !os.IsNotExist(err) {
  183. log.Fatal("Failed to remove unix socket directory %s: %v", listenAddr, err)
  184. }
  185. var listener *net.UnixListener
  186. listener, err = net.ListenUnix("unix", &net.UnixAddr{Name: listenAddr, Net: "unix"})
  187. if err != nil {
  188. break // Handle error after switch
  189. }
  190. // FIXME: add proper implementation of signal capture on all protocols
  191. // execute this on SIGTERM or SIGINT: listener.Close()
  192. if err = os.Chmod(listenAddr, os.FileMode(setting.UnixSocketPermission)); err != nil {
  193. log.Fatal("Failed to set permission of unix socket: %v", err)
  194. }
  195. err = http.Serve(listener, context2.ClearHandler(m))
  196. default:
  197. log.Fatal("Invalid protocol: %s", setting.Protocol)
  198. }
  199. if err != nil {
  200. log.Critical("Failed to start server: %v", err)
  201. }
  202. log.Info("HTTP Listener: %s Closed", listenAddr)
  203. log.Close()
  204. return nil
  205. }