type hugoBuilder struct {
r *rootCommand
- cunfMu sync.Mutex
- conf_ *commonConfig
+ confmu sync.Mutex
+ conf *commonConfig
// May be nil.
s *serverCommand
errState hugoBuilderErrState
}
-func (c *hugoBuilder) conf() *commonConfig {
- c.cunfMu.Lock()
- defer c.cunfMu.Unlock()
- return c.conf_
+func (c *hugoBuilder) withConfE(fn func(conf *commonConfig) error) error {
+ c.confmu.Lock()
+ defer c.confmu.Unlock()
+ return fn(c.conf)
}
-func (c *hugoBuilder) setConf(conf *commonConfig) {
- c.cunfMu.Lock()
- defer c.cunfMu.Unlock()
- c.conf_ = conf
+func (c *hugoBuilder) withConf(fn func(conf *commonConfig)) {
+ c.confmu.Lock()
+ defer c.confmu.Unlock()
+ fn(c.conf)
+
}
type hugoBuilderErrState struct {
// Identifies changes to config (config.toml) files.
configSet := make(map[string]bool)
- configFiles := c.conf().configs.LoadingInfo.ConfigFiles
+ var configFiles []string
+ c.withConf(func(conf *commonConfig) {
+ configFiles = conf.configs.LoadingInfo.ConfigFiles
+ })
c.r.logger.Println("Watching for config changes in", strings.Join(configFiles, ", "))
for _, configFile := range configFiles {
fs := &countingStatFs{Fs: sourceFs.Fs}
syncer := fsync.NewSyncer()
- syncer.NoTimes = c.conf().configs.Base.NoTimes
- syncer.NoChmod = c.conf().configs.Base.NoChmod
- syncer.ChmodFilter = chmodFilter
+ c.withConf(func(conf *commonConfig) {
+ syncer.NoTimes = conf.configs.Base.NoTimes
+ syncer.NoChmod = conf.configs.Base.NoChmod
+ syncer.ChmodFilter = chmodFilter
+
+ syncer.DestFs = conf.fs.PublishDirStatic
+ // Now that we are using a unionFs for the static directories
+ // We can effectively clean the publishDir on initial sync
+ syncer.Delete = conf.configs.Base.CleanDestinationDir
+ })
+
syncer.SrcFs = fs
- syncer.DestFs = c.conf().fs.PublishDirStatic
- // Now that we are using a unionFs for the static directories
- // We can effectively clean the publishDir on initial sync
- syncer.Delete = c.conf().configs.Base.CleanDestinationDir
if syncer.Delete {
c.r.logger.Infoln("removing all files from destination that don't exist in static dirs")
}
if lang == "" {
// Not multihost
- for _, l := range c.conf().configs.Languages {
- langCount[l.Lang] = cnt
- }
+ c.withConf(func(conf *commonConfig) {
+ for _, l := range conf.configs.Languages {
+ langCount[l.Lang] = cnt
+ }
+ })
} else {
langCount[lang] = cnt
}
// Do not copy static files and build sites in parallel if cleanDestinationDir is enabled.
// This flag deletes all static resources in /public folder that are missing in /static,
// and it does so at the end of copyStatic() call.
- if c.conf().configs.Base.CleanDestinationDir {
+ var cleanDestinationDir bool
+ c.withConf(func(conf *commonConfig) {
+ cleanDestinationDir = conf.configs.Base.CleanDestinationDir
+ })
+ if cleanDestinationDir {
if err := copyStaticFunc(); err != nil {
return err
}
}
if ev.Op&fsnotify.Remove == fsnotify.Remove || ev.Op&fsnotify.Rename == fsnotify.Rename {
- configFiles := c.conf().configs.LoadingInfo.ConfigFiles
- for _, configFile := range configFiles {
- counter := 0
- for watcher.Add(configFile) != nil {
- counter++
- if counter >= 100 {
- break
+ c.withConf(func(conf *commonConfig) {
+ for _, configFile := range conf.configs.LoadingInfo.ConfigFiles {
+ counter := 0
+ for watcher.Add(configFile) != nil {
+ counter++
+ if counter >= 100 {
+ break
+ }
+ time.Sleep(100 * time.Millisecond)
}
- time.Sleep(100 * time.Millisecond)
}
- }
+ })
}
// Config file(s) changed. Need full rebuild.
// recursively add new directories to watch list
// When mkdir -p is used, only the top directory triggers an event (at least on OSX)
if ev.Op&fsnotify.Create == fsnotify.Create {
- if s, err := c.conf().fs.Source.Stat(ev.Name); err == nil && s.Mode().IsDir() {
- _ = helpers.SymbolicWalk(c.conf().fs.Source, ev.Name, walkAdder)
- }
+ c.withConf(func(conf *commonConfig) {
+ if s, err := conf.fs.Source.Stat(ev.Name); err == nil && s.Mode().IsDir() {
+ _ = helpers.SymbolicWalk(conf.fs.Source, ev.Name, walkAdder)
+ }
+ })
}
if staticSyncer.isStatic(h, ev.Name) {
}
func (c *hugoBuilder) hugo() (*hugolib.HugoSites, error) {
- h, err := c.r.HugFromConfig(c.conf())
- if err != nil {
+ var h *hugolib.HugoSites
+ if err := c.withConfE(func(conf *commonConfig) error {
+ var err error
+ h, err = c.r.HugFromConfig(conf)
+ return err
+
+ }); err != nil {
return nil, err
}
+
if c.s != nil {
// A running server, register the media types.
for _, s := range h.Sites {
}
func (c *hugoBuilder) hugoTry() *hugolib.HugoSites {
- h, _ := c.r.HugFromConfig(c.conf())
+ var h *hugolib.HugoSites
+ c.withConf(func(conf *commonConfig) {
+ h, _ = c.r.HugFromConfig(conf)
+ })
return h
}
return err
}
- c.setConf(conf)
+ c.conf = conf
if c.onConfigLoaded != nil {
if err := c.onConfigLoaded(false); err != nil {
return err
return err
}
if c.fastRenderMode {
- // Make sure we always render the home pages
- for _, l := range c.conf().configs.Languages {
- langPath := h.GetLangSubDir(l.Lang)
- if langPath != "" {
- langPath = langPath + "/"
+ c.withConf(func(conf *commonConfig) {
+ // Make sure we always render the home pages
+ for _, l := range conf.configs.Languages {
+ langPath := h.GetLangSubDir(l.Lang)
+ if langPath != "" {
+ langPath = langPath + "/"
+ }
+ home := h.PrependBasePath("/"+langPath, false)
+ visited[home] = true
}
- home := h.PrependBasePath("/"+langPath, false)
- visited[home] = true
- }
+ })
}
return h.Build(hugolib.BuildCfg{NoBuildLock: true, RecentlyVisited: visited, ErrRecovery: c.errState.wasErr()}, events...)
}
func (c *hugoBuilder) reloadConfig() error {
c.r.Reset()
c.r.configVersionID.Add(1)
- oldConf := c.conf()
- conf, err := c.r.ConfigFromConfig(c.r.configVersionID.Load(), c.conf())
- if err != nil {
- return err
- }
- sameLen := len(oldConf.configs.Languages) == len(conf.configs.Languages)
- if !sameLen {
- if oldConf.configs.IsMultihost || conf.configs.IsMultihost {
- return errors.New("multihost change detected, please restart server")
+
+ if err := c.withConfE(func(conf *commonConfig) error {
+ oldConf := conf
+ newConf, err := c.r.ConfigFromConfig(c.r.configVersionID.Load(), conf)
+ if err != nil {
+ return err
+ }
+ sameLen := len(oldConf.configs.Languages) == len(newConf.configs.Languages)
+ if !sameLen {
+ if oldConf.configs.IsMultihost || newConf.configs.IsMultihost {
+ return errors.New("multihost change detected, please restart server")
+ }
}
+ c.conf = newConf
+ return nil
+ }); err != nil {
+ return err
}
- c.setConf(conf)
+
if c.onConfigLoaded != nil {
if err := c.onConfigLoaded(true); err != nil {
return err
"github.com/gohugoio/hugo/common/hugo"
"github.com/gohugoio/hugo/common/types"
"github.com/gohugoio/hugo/common/urls"
+ "github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/hugofs"
"github.com/gohugoio/hugo/hugofs/files"
func (f *fileServer) createEndpoint(i int) (*http.ServeMux, net.Listener, string, string, error) {
r := f.c.r
- conf := f.c.conf()
baseURL := f.baseURLs[i]
root := f.roots[i]
port := f.c.serverPorts[i].p
}
}
- httpFs := afero.NewHttpFs(conf.fs.PublishDirServer)
+ var httpFs *afero.HttpFs
+ f.c.withConf(func(conf *commonConfig) {
+ httpFs = afero.NewHttpFs(conf.fs.PublishDirServer)
+ })
+
fs := filesOnlyFs{httpFs.Dir(path.Join("/", root))}
if i == 0 && f.c.fastRenderMode {
r.Println("Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender")
}
port = 1313
- if lrport := conf.configs.GetFirstLanguageConfig().BaseURLLiveReload().Port(); lrport != 0 {
- port = lrport
- }
+ f.c.withConf(func(conf *commonConfig) {
+ if lrport := conf.configs.GetFirstLanguageConfig().BaseURLLiveReload().Port(); lrport != 0 {
+ port = lrport
+ }
+ })
lr := *u
lr.Host = fmt.Sprintf("%s:%d", lr.Hostname(), port)
fmt.Fprint(w, injectLiveReloadScript(r, lr))
w.Header().Set("Pragma", "no-cache")
}
- serverConfig := f.c.conf().configs.Base.Server
+ var serverConfig config.Server
+ f.c.withConf(func(conf *commonConfig) {
+ serverConfig = conf.configs.Base.Server
+ })
// Ignore any query params for the operations below.
requestURI, _ := url.PathUnescape(strings.TrimSuffix(r.RequestURI, "?"+r.URL.RawQuery))
if root != "" {
path = filepath.Join(root, path)
}
- fs := f.c.conf().getFs().PublishDir
+ var fs afero.Fs
+ f.c.withConf(func(conf *commonConfig) {
+ fs = conf.fs.PublishDir
+ })
fi, err := fs.Stat(path)
}
if !reloaded && c.fastRenderMode {
- c.conf().fs.PublishDir = hugofs.NewHashingFs(c.conf().fs.PublishDir, c.changeDetector)
- c.conf().fs.PublishDirStatic = hugofs.NewHashingFs(c.conf().fs.PublishDirStatic, c.changeDetector)
+ c.withConf(func(conf *commonConfig) {
+ conf.fs.PublishDir = hugofs.NewHashingFs(conf.fs.PublishDir, c.changeDetector)
+ conf.fs.PublishDirStatic = hugofs.NewHashingFs(conf.fs.PublishDirStatic, c.changeDetector)
+ })
}
return nil
if len(c.serverPorts) == 0 {
panic("no server ports set")
}
- isMultiHost := c.conf().configs.IsMultihost
- for i, language := range c.conf().configs.Languages {
- var serverPort int
- if isMultiHost {
- serverPort = c.serverPorts[i].p
- } else {
- serverPort = c.serverPorts[0].p
- }
- langConfig := c.conf().configs.LanguageConfigMap[language.Lang]
- baseURLStr, err := c.fixURL(langConfig.BaseURL, c.r.baseURL, serverPort)
- if err != nil {
- return nil
- }
- baseURL, err := urls.NewBaseURLFromString(baseURLStr)
- if err != nil {
- return fmt.Errorf("failed to create baseURL from %q: %s", baseURLStr, err)
- }
+ return c.withConfE(func(conf *commonConfig) error {
+ for i, language := range conf.configs.Languages {
+ isMultiHost := conf.configs.IsMultihost
+ var serverPort int
+ if isMultiHost {
+ serverPort = c.serverPorts[i].p
+ } else {
+ serverPort = c.serverPorts[0].p
+ }
+ langConfig := conf.configs.LanguageConfigMap[language.Lang]
+ baseURLStr, err := c.fixURL(langConfig.BaseURL, c.r.baseURL, serverPort)
+ if err != nil {
+ return err
+ }
+ baseURL, err := urls.NewBaseURLFromString(baseURLStr)
+ if err != nil {
+ return fmt.Errorf("failed to create baseURL from %q: %s", baseURLStr, err)
+ }
- baseURLLiveReload := baseURL
- if c.liveReloadPort != -1 {
- baseURLLiveReload, _ = baseURLLiveReload.WithPort(c.liveReloadPort)
+ baseURLLiveReload := baseURL
+ if c.liveReloadPort != -1 {
+ baseURLLiveReload, _ = baseURLLiveReload.WithPort(c.liveReloadPort)
+ }
+ langConfig.C.SetBaseURL(baseURL, baseURLLiveReload)
}
- langConfig.C.SetBaseURL(baseURL, baseURLLiveReload)
- }
- return nil
+ return nil
+ })
}
func (c *serverCommand) getErrorWithContext() any {
func (c *serverCommand) createServerPorts(cd *simplecobra.Commandeer) error {
flags := cd.CobraCommand.Flags()
- isMultiHost := c.conf().configs.IsMultihost
- c.serverPorts = make([]serverPortListener, 1)
- if isMultiHost {
- if !c.serverAppend {
- return errors.New("--appendPort=false not supported when in multihost mode")
- }
- c.serverPorts = make([]serverPortListener, len(c.conf().configs.Languages))
- }
- currentServerPort := c.serverPort
- for i := 0; i < len(c.serverPorts); i++ {
- l, err := net.Listen("tcp", net.JoinHostPort(c.serverInterface, strconv.Itoa(currentServerPort)))
- if err == nil {
- c.serverPorts[i] = serverPortListener{ln: l, p: currentServerPort}
- } else {
- if i == 0 && flags.Changed("port") {
- // port set explicitly by user -- he/she probably meant it!
- return fmt.Errorf("server startup failed: %s", err)
+ var cerr error
+ c.withConf(func(conf *commonConfig) {
+ isMultiHost := conf.configs.IsMultihost
+ c.serverPorts = make([]serverPortListener, 1)
+ if isMultiHost {
+ if !c.serverAppend {
+ cerr = errors.New("--appendPort=false not supported when in multihost mode")
+ return
}
- c.r.Println("port", currentServerPort, "already in use, attempting to use an available port")
- l, sp, err := helpers.TCPListen()
- if err != nil {
- return fmt.Errorf("unable to find alternative port to use: %s", err)
+ c.serverPorts = make([]serverPortListener, len(conf.configs.Languages))
+ }
+ currentServerPort := c.serverPort
+ for i := 0; i < len(c.serverPorts); i++ {
+ l, err := net.Listen("tcp", net.JoinHostPort(c.serverInterface, strconv.Itoa(currentServerPort)))
+ if err == nil {
+ c.serverPorts[i] = serverPortListener{ln: l, p: currentServerPort}
+ } else {
+ if i == 0 && flags.Changed("port") {
+ // port set explicitly by user -- he/she probably meant it!
+ cerr = fmt.Errorf("server startup failed: %s", err)
+ return
+ }
+ c.r.Println("port", currentServerPort, "already in use, attempting to use an available port")
+ l, sp, err := helpers.TCPListen()
+ if err != nil {
+ cerr = fmt.Errorf("unable to find alternative port to use: %s", err)
+ return
+ }
+ c.serverPorts[i] = serverPortListener{ln: l, p: sp.Port}
}
- c.serverPorts[i] = serverPortListener{ln: l, p: sp.Port}
+
+ currentServerPort = c.serverPorts[i].p + 1
}
+ })
- currentServerPort = c.serverPorts[i].p + 1
- }
- return nil
+ return cerr
}
// fixURL massages the baseURL into a form needed for serving
}
func (c *serverCommand) serve() error {
- isMultiHost := c.conf().configs.IsMultihost
- var err error
- h, err := c.r.HugFromConfig(c.conf())
- if err != nil {
- return err
- }
- r := c.r
-
var (
baseURLs []string
roots []string
+ h *hugolib.HugoSites
)
+ err := c.withConfE(func(conf *commonConfig) error {
+ isMultiHost := conf.configs.IsMultihost
+ var err error
+ h, err = c.r.HugFromConfig(conf)
+ if err != nil {
+ return err
+ }
- if isMultiHost {
- for _, l := range c.conf().configs.ConfigLangs() {
- baseURLs = append(baseURLs, l.BaseURL().String())
- roots = append(roots, l.Language().Lang)
+ if isMultiHost {
+ for _, l := range conf.configs.ConfigLangs() {
+ baseURLs = append(baseURLs, l.BaseURL().String())
+ roots = append(roots, l.Language().Lang)
+ }
+ } else {
+ l := conf.configs.GetFirstLanguageConfig()
+ baseURLs = []string{l.BaseURL().String()}
+ roots = []string{""}
}
- } else {
- l := c.conf().configs.GetFirstLanguageConfig()
- baseURLs = []string{l.BaseURL().String()}
- roots = []string{""}
+
+ return nil
+ })
+
+ if err != nil {
+ return err
}
// Cache it here. The HugoSites object may be unavailable later on due to intermittent configuration errors.
mu.HandleFunc(u.Path+"/livereload.js", livereload.ServeJS)
mu.HandleFunc(u.Path+"/livereload", livereload.Handler)
}
- r.Printf("Web Server is available at %s (bind address %s)\n", serverURL, c.serverInterface)
+ c.r.Printf("Web Server is available at %s (bind address %s)\n", serverURL, c.serverInterface)
wg1.Go(func() error {
err = srv.Serve(listener)
if err != nil && err != http.ErrServerClosed {
}
- r.Println("Press Ctrl+C to stop")
+ c.r.Println("Press Ctrl+C to stop")
err = func() error {
for {
}()
if err != nil {
- r.Println("Error:", err)
+ c.r.Println("Error:", err)
}
if h := c.hugoTry(); h != nil {
publishDir = filepath.Join(publishDir, sourceFs.PublishFolder)
}
- conf := s.c.conf().configs.Base
- fs := s.c.conf().fs
syncer := fsync.NewSyncer()
- syncer.NoTimes = conf.NoTimes
- syncer.NoChmod = conf.NoChmod
- syncer.ChmodFilter = chmodFilter
- syncer.SrcFs = sourceFs.Fs
- syncer.DestFs = fs.PublishDir
- if c.s != nil && c.s.renderStaticToDisk {
- syncer.DestFs = fs.PublishDirStatic
- }
+ c.withConf(func(conf *commonConfig) {
+ syncer.NoTimes = conf.configs.Base.NoTimes
+ syncer.NoChmod = conf.configs.Base.NoChmod
+ syncer.ChmodFilter = chmodFilter
+ syncer.SrcFs = sourceFs.Fs
+ syncer.DestFs = conf.fs.PublishDir
+ if c.s != nil && c.s.renderStaticToDisk {
+ syncer.DestFs = conf.fs.PublishDirStatic
+ }
+ })
// prevent spamming the log on changes
logger := helpers.NewDistinctErrorLogger()
if _, err := sourceFs.Fs.Stat(relPath); herrors.IsNotExist(err) {
// If file doesn't exist in any static dir, remove it
logger.Println("File no longer exists in static dir, removing", relPath)
- _ = c.conf().fs.PublishDirStatic.RemoveAll(relPath)
+ c.withConf(func(conf *commonConfig) {
+ _ = conf.fs.PublishDirStatic.RemoveAll(relPath)
+ })
} else if err == nil {
// If file still exists, sync it
projects / brevno-suite / hugo / commitdiff