func (c *dumpconfigCmd) RunCommand(args []string) error {
var file string
switch {
case len(args) == 0:
file = osutil.UserServerConfigPath()
case len(args) == 1:
file = args[0]
default:
return errors.New("More than 1 argument not allowed")
}
cfg, err := serverinit.LoadFile(file)
if err != nil {
return err
}
cfg.Obj["handlerConfig"] = true
ll, err := json.MarshalIndent(cfg.Obj, "", " ")
if err != nil {
return err
}
_, err = os.Stdout.Write(ll)
return err
}
// loadConfig returns the server's parsed config file, locating it using the provided arg.
//
// The arg may be of the form:
// - empty, to mean automatic (will write a default high-level config if
// no cloud config is available)
// - a filepath absolute or relative to the user's configuration directory,
// - a URL
func loadConfig(arg string) (conf *serverinit.Config, isNewConfig bool, err error) {
if strings.HasPrefix(arg, "http://") || strings.HasPrefix(arg, "https://") {
contents, err := slurpURL(arg, 256<<10)
if err != nil {
return nil, false, err
}
conf, err = serverinit.Load(contents)
return conf, false, err
}
var absPath string
switch {
case arg == "":
absPath = osutil.UserServerConfigPath()
_, err = wkfs.Stat(absPath)
if err != nil {
if !os.IsNotExist(err) {
return
}
conf, err = serverinit.DefaultEnvConfig()
if err != nil || conf != nil {
return
}
err = wkfs.MkdirAll(osutil.CamliConfigDir(), 0700)
if err != nil {
return
}
log.Printf("Generating template config file %s", absPath)
if err = serverinit.WriteDefaultConfigFile(absPath, sqlite.CompiledIn()); err == nil {
isNewConfig = true
}
}
case filepath.IsAbs(arg):
absPath = arg
default:
absPath = filepath.Join(osutil.CamliConfigDir(), arg)
}
conf, err = serverinit.LoadFile(absPath)
return
}
func (c *reindexdpCmd) RunCommand(args []string) error {
var path string
var indexConf jsonconfig.Obj
switch len(args) {
case 0:
case 1:
path = args[0]
default:
return errors.New("More than 1 argument not allowed")
}
cfg, err := serverinit.LoadFile(osutil.UserServerConfigPath())
if err != nil {
return err
}
prefixes, ok := cfg.Obj["prefixes"].(map[string]interface{})
if !ok {
return fmt.Errorf("No 'prefixes' object in low-level (or converted) config file %s", osutil.UserServerConfigPath())
}
paths, confs := []string{}, []jsonconfig.Obj{}
for prefix, vei := range prefixes {
pmap, ok := vei.(map[string]interface{})
if !ok {
log.Printf("prefix %q value is a %T, not an object", prefix, vei)
continue
}
pconf := jsonconfig.Obj(pmap)
handlerType := pconf.RequiredString("handler")
handlerArgs := pconf.OptionalObject("handlerArgs")
// no pconf.Validate, as this is a recover tool
if handlerType != "storage-diskpacked" {
continue
}
log.Printf("handlerArgs of %q: %v", prefix, handlerArgs)
if handlerArgs == nil {
log.Printf("no handlerArgs for %q", prefix)
continue
}
aconf := jsonconfig.Obj(handlerArgs)
apath := aconf.RequiredString("path")
// no aconv.Validate, as this is a recover tool
if apath == "" {
log.Printf("path is missing for %q", prefix)
continue
}
if path != "" && path != apath {
continue
}
paths = append(paths, apath)
confs = append(confs, aconf)
}
if len(paths) == 0 {
return fmt.Errorf("Server config file %s doesn't specify a disk-packed storage handler.",
osutil.UserServerConfigPath())
}
if len(paths) > 1 {
return fmt.Errorf("Ambiguity. Server config file %s d specify more than 1 disk-packed storage handler. Please specify one of: %v", osutil.UserServerConfigPath(), paths)
}
path = paths[0]
if path == "" {
return errors.New("no path is given/found")
}
// If no index is specified, the default will be used (as on the regular path).
if mi := confs[0]["metaIndex"]; mi != nil {
if mi, ok := mi.(map[string]interface{}); ok {
indexConf = jsonconfig.Obj(mi)
}
}
log.Printf("indexConf: %v", indexConf)
return diskpacked.Reindex(path, c.overwrite, indexConf)
}