gitee.com/mirrors/Hugo-Go@v0.47.1/commands/commandeer.go (about) 1 // Copyright 2018 The Hugo Authors. All rights reserved. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // http://www.apache.org/licenses/LICENSE-2.0 7 // 8 // Unless required by applicable law or agreed to in writing, software 9 // distributed under the License is distributed on an "AS IS" BASIS, 10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 // See the License for the specific language governing permissions and 12 // limitations under the License. 13 14 package commands 15 16 import ( 17 "os" 18 "path/filepath" 19 "regexp" 20 "strings" 21 "sync" 22 "time" 23 24 "github.com/gohugoio/hugo/config" 25 26 "github.com/spf13/cobra" 27 28 "github.com/spf13/afero" 29 30 "github.com/gohugoio/hugo/hugolib" 31 32 "github.com/bep/debounce" 33 "github.com/gohugoio/hugo/common/types" 34 "github.com/gohugoio/hugo/deps" 35 "github.com/gohugoio/hugo/helpers" 36 "github.com/gohugoio/hugo/hugofs" 37 "github.com/gohugoio/hugo/langs" 38 ) 39 40 type commandeerHugoState struct { 41 *deps.DepsCfg 42 hugo *hugolib.HugoSites 43 fsCreate sync.Once 44 } 45 46 type commandeer struct { 47 *commandeerHugoState 48 49 // Currently only set when in "fast render mode". But it seems to 50 // be fast enough that we could maybe just add it for all server modes. 51 changeDetector *fileChangeDetector 52 53 // We need to reuse this on server rebuilds. 54 destinationFs afero.Fs 55 56 h *hugoBuilderCommon 57 ftch flagsToConfigHandler 58 59 visitedURLs *types.EvictingStringQueue 60 61 doWithCommandeer func(c *commandeer) error 62 63 // We watch these for changes. 64 configFiles []string 65 66 // Used in cases where we get flooded with events in server mode. 67 debounce func(f func()) 68 69 serverPorts []int 70 languagesConfigured bool 71 languages langs.Languages 72 73 configured bool 74 paused bool 75 } 76 77 func (c *commandeer) Set(key string, value interface{}) { 78 if c.configured { 79 panic("commandeer cannot be changed") 80 } 81 c.Cfg.Set(key, value) 82 } 83 84 func (c *commandeer) initFs(fs *hugofs.Fs) error { 85 c.destinationFs = fs.Destination 86 c.DepsCfg.Fs = fs 87 88 return nil 89 } 90 91 func newCommandeer(mustHaveConfigFile, running bool, h *hugoBuilderCommon, f flagsToConfigHandler, doWithCommandeer func(c *commandeer) error, subCmdVs ...*cobra.Command) (*commandeer, error) { 92 93 var rebuildDebouncer func(f func()) 94 if running { 95 // The time value used is tested with mass content replacements in a fairly big Hugo site. 96 // It is better to wait for some seconds in those cases rather than get flooded 97 // with rebuilds. 98 rebuildDebouncer, _, _ = debounce.New(4 * time.Second) 99 } 100 101 c := &commandeer{ 102 h: h, 103 ftch: f, 104 commandeerHugoState: &commandeerHugoState{}, 105 doWithCommandeer: doWithCommandeer, 106 visitedURLs: types.NewEvictingStringQueue(10), 107 debounce: rebuildDebouncer, 108 } 109 110 return c, c.loadConfig(mustHaveConfigFile, running) 111 } 112 113 type fileChangeDetector struct { 114 sync.Mutex 115 current map[string]string 116 prev map[string]string 117 118 irrelevantRe *regexp.Regexp 119 } 120 121 func (f *fileChangeDetector) OnFileClose(name, md5sum string) { 122 f.Lock() 123 defer f.Unlock() 124 f.current[name] = md5sum 125 } 126 127 func (f *fileChangeDetector) changed() []string { 128 if f == nil { 129 return nil 130 } 131 f.Lock() 132 defer f.Unlock() 133 var c []string 134 for k, v := range f.current { 135 vv, found := f.prev[k] 136 if !found || v != vv { 137 c = append(c, k) 138 } 139 } 140 141 return f.filterIrrelevant(c) 142 } 143 144 func (f *fileChangeDetector) filterIrrelevant(in []string) []string { 145 var filtered []string 146 for _, v := range in { 147 if !f.irrelevantRe.MatchString(v) { 148 filtered = append(filtered, v) 149 } 150 } 151 return filtered 152 } 153 154 func (f *fileChangeDetector) PrepareNew() { 155 if f == nil { 156 return 157 } 158 159 f.Lock() 160 defer f.Unlock() 161 162 if f.current == nil { 163 f.current = make(map[string]string) 164 f.prev = make(map[string]string) 165 return 166 } 167 168 f.prev = make(map[string]string) 169 for k, v := range f.current { 170 f.prev[k] = v 171 } 172 f.current = make(map[string]string) 173 } 174 175 func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error { 176 177 if c.DepsCfg == nil { 178 c.DepsCfg = &deps.DepsCfg{} 179 } 180 181 cfg := c.DepsCfg 182 c.configured = false 183 cfg.Running = running 184 185 var dir string 186 if c.h.source != "" { 187 dir, _ = filepath.Abs(c.h.source) 188 } else { 189 dir, _ = os.Getwd() 190 } 191 192 var sourceFs afero.Fs = hugofs.Os 193 if c.DepsCfg.Fs != nil { 194 sourceFs = c.DepsCfg.Fs.Source 195 } 196 197 doWithConfig := func(cfg config.Provider) error { 198 199 if c.ftch != nil { 200 c.ftch.flagsToConfig(cfg) 201 } 202 203 cfg.Set("workingDir", dir) 204 205 return nil 206 } 207 208 doWithCommandeer := func(cfg config.Provider) error { 209 c.Cfg = cfg 210 if c.doWithCommandeer == nil { 211 return nil 212 } 213 err := c.doWithCommandeer(c) 214 return err 215 } 216 217 config, configFiles, err := hugolib.LoadConfig( 218 hugolib.ConfigSourceDescriptor{Fs: sourceFs, Path: c.h.source, WorkingDir: dir, Filename: c.h.cfgFile}, 219 doWithCommandeer, 220 doWithConfig) 221 222 if err != nil { 223 if mustHaveConfigFile { 224 return err 225 } 226 if err != hugolib.ErrNoConfigFile { 227 return err 228 } 229 230 } 231 232 c.configFiles = configFiles 233 234 if l, ok := c.Cfg.Get("languagesSorted").(langs.Languages); ok { 235 c.languagesConfigured = true 236 c.languages = l 237 } 238 239 // This is potentially double work, but we need to do this one more time now 240 // that all the languages have been configured. 241 if c.doWithCommandeer != nil { 242 if err := c.doWithCommandeer(c); err != nil { 243 return err 244 } 245 } 246 247 logger, err := c.createLogger(config) 248 if err != nil { 249 return err 250 } 251 252 cfg.Logger = logger 253 254 createMemFs := config.GetBool("renderToMemory") 255 256 if createMemFs { 257 // Rendering to memoryFS, publish to Root regardless of publishDir. 258 config.Set("publishDir", "/") 259 } 260 261 c.fsCreate.Do(func() { 262 fs := hugofs.NewFrom(sourceFs, config) 263 264 if c.destinationFs != nil { 265 // Need to reuse the destination on server rebuilds. 266 fs.Destination = c.destinationFs 267 } else if createMemFs { 268 // Hugo writes the output to memory instead of the disk. 269 fs.Destination = new(afero.MemMapFs) 270 } 271 272 doLiveReload := !c.h.buildWatch && !config.GetBool("disableLiveReload") 273 fastRenderMode := doLiveReload && !config.GetBool("disableFastRender") 274 275 if fastRenderMode { 276 // For now, fast render mode only. It should, however, be fast enough 277 // for the full variant, too. 278 changeDetector := &fileChangeDetector{ 279 // We use this detector to decide to do a Hot reload of a single path or not. 280 // We need to filter out source maps and possibly some other to be able 281 // to make that decision. 282 irrelevantRe: regexp.MustCompile(`\.map$`), 283 } 284 changeDetector.PrepareNew() 285 fs.Destination = hugofs.NewHashingFs(fs.Destination, changeDetector) 286 c.changeDetector = changeDetector 287 } 288 289 err = c.initFs(fs) 290 if err != nil { 291 return 292 } 293 294 var h *hugolib.HugoSites 295 296 h, err = hugolib.NewHugoSites(*c.DepsCfg) 297 c.hugo = h 298 299 }) 300 301 if err != nil { 302 return err 303 } 304 305 cacheDir := config.GetString("cacheDir") 306 if cacheDir != "" { 307 if helpers.FilePathSeparator != cacheDir[len(cacheDir)-1:] { 308 cacheDir = cacheDir + helpers.FilePathSeparator 309 } 310 isDir, err := helpers.DirExists(cacheDir, sourceFs) 311 checkErr(cfg.Logger, err) 312 if !isDir { 313 mkdir(cacheDir) 314 } 315 config.Set("cacheDir", cacheDir) 316 } else { 317 config.Set("cacheDir", helpers.GetTempDir("hugo_cache", sourceFs)) 318 } 319 320 cfg.Logger.INFO.Println("Using config file:", config.ConfigFileUsed()) 321 322 themeDir := c.hugo.PathSpec.GetFirstThemeDir() 323 if themeDir != "" { 324 if _, err := sourceFs.Stat(themeDir); os.IsNotExist(err) { 325 return newSystemError("Unable to find theme Directory:", themeDir) 326 } 327 } 328 329 dir, themeVersionMismatch, minVersion := c.isThemeVsHugoVersionMismatch(sourceFs) 330 331 if themeVersionMismatch { 332 name := filepath.Base(dir) 333 cfg.Logger.ERROR.Printf("%s theme does not support Hugo version %s. Minimum version required is %s\n", 334 strings.ToUpper(name), helpers.CurrentHugoVersion.ReleaseVersion(), minVersion) 335 } 336 337 return nil 338 339 }