コード例 #1
0
ファイル: server.go プロジェクト: reconquest/sould
// SetConfig from zhash.Hash instance which actually is representation of
// map[string]interface{}
// SetConfig validates specified configuration before using.
func (server *Server) SetConfig(config zhash.Hash) error {
	isMaster, err := config.GetBool("master")
	if err != nil && !zhash.IsNotFound(err) {
		return err
	}

	if isMaster {
		slaves, err := config.GetStringSlice("slaves")
		if err != nil && !zhash.IsNotFound(err) {
			return err
		}

		if len(slaves) == 0 {
			logger.Warning("slave servers is not specified")
		} else {
			_, err = config.GetInt("timeout")
			if err != nil {
				return err
			}
		}
	}

	_, err = config.GetString("storage")
	if err != nil {
		return err
	}

	_, err = config.GetString("http", "listen")
	if err != nil {
		return err
	}

	server.config = config

	return nil
}
コード例 #2
0
ファイル: main.go プロジェクト: kovetskiy/mark
func main() {
	args, err := godocs.Parse(usage, "mark 1.0", godocs.UsePager)
	if err != nil {
		panic(err)
	}

	var (
		username, _   = args["-u"].(string)
		password, _   = args["-p"].(string)
		targetURL, _  = args["-l"].(string)
		targetFile, _ = args["-f"].(string)
		dryRun        = args["--dry-run"].(bool)
		editLock      = args["-k"].(bool)
		trace         = args["--trace"].(bool)

		optionsFile, shouldReadOptions = args["-c"].(string)
	)

	if trace {
		logger.SetLevel(lorg.LevelTrace)
	}

	logFormat := `${time} ${level:[%s]:right:true} %s`

	if format := os.Getenv("LOG_FORMAT"); format != "" {
		logFormat = format
	}

	logger.SetFormat(colorgful.MustApplyDefaultTheme(
		logFormat,
		colorgful.Default,
	))

	config, err := getConfig(filepath.Join(os.Getenv("HOME"), ".config/mark"))
	if err != nil && !os.IsNotExist(err) {
		logger.Fatal(err)
	}

	if shouldReadOptions {
		optionsConfig, err := getConfig(optionsFile)
		if err != nil {
			logger.Fatalf(
				"can't read options config '%s': %s", optionsFile, err,
			)
		}

		targetURL, err = optionsConfig.GetString("url")
		if err != nil {
			logger.Fatal(
				"can't read `url` value from options file (%s): %s",
				optionsFile, err,
			)
		}

		targetFile, err = optionsConfig.GetString("file")
		if err != nil {
			logger.Fatal(
				"can't read `file` value from options file (%s): %s",
				optionsFile, err,
			)
		}
	}

	markdownData, err := ioutil.ReadFile(targetFile)
	if err != nil {
		logger.Fatal(err)
	}

	meta, err := extractMeta(markdownData)
	if err != nil {
		logger.Fatal(err)
	}

	htmlData := compileMarkdown(markdownData)

	if dryRun {
		fmt.Println(string(htmlData))
		os.Exit(0)
	}

	if username == "" {
		username, err = config.GetString("username")
		if err != nil {
			if zhash.IsNotFound(err) {
				logger.Fatal(
					"Confluence username should be specified using -u " +
						"flag or be stored in configuration file",
				)
			}

			logger.Fatalf(
				"can't read username configuration variable: %s", err,
			)
		}
	}

	if password == "" {
		password, err = config.GetString("password")
		if err != nil {
			if zhash.IsNotFound(err) {
				logger.Fatal(
					"Confluence password should be specified using -p " +
						"flag or be stored in configuration file",
				)
			}

			logger.Fatalf(
				"can't read password configuration variable: %s", err,
			)
		}
	}

	url, err := url.Parse(targetURL)
	if err != nil {
		logger.Fatal(err)
	}

	baseURL := url.Scheme + "://" + url.Host

	if url.Host == "" {
		baseURL, err = config.GetString("base_url")
		if err != nil {
			if zhash.IsNotFound(err) {
				logger.Fatal(
					"Confluence base URL should be specified using -l " +
						"flag or be stored in configuration file",
				)
			}

			logger.Fatalf(
				"can't read base_url configuration variable: %s", err,
			)
		}
	}

	baseURL = strings.TrimRight(baseURL, `/`)

	api := NewAPI(baseURL, username, password)

	pageID := url.Query().Get("pageId")

	if pageID != "" && meta != nil {
		logger.Warningf(
			`specified file contains metadata, ` +
				`but it will be ignore due specified command line URL`,
		)

		meta = nil
	}

	if pageID == "" && meta == nil {
		logger.Fatalf(
			`specified file doesn't contain metadata ` +
				`and URL is not specified via command line ` +
				`or doesn't contain pageId GET-parameter`,
		)
	}

	var target *PageInfo

	if meta != nil {
		page, err := resolvePage(api, meta)
		if err != nil {
			logger.Fatal(err)
		}

		target = page
	} else {
		if pageID == "" {
			logger.Fatalf("URL should provide 'pageId' GET-parameter")
		}

		page, err := api.getPageByID(pageID)
		if err != nil {
			logger.Fatal(err)
		}

		target = page
	}

	err = api.updatePage(
		target,
		MacroLayout{meta.Layout, [][]byte{htmlData}}.Render(),
	)
	if err != nil {
		logger.Fatal(err)
	}

	if editLock {
		logger.Infof(
			`edit locked on page '%s' by user '%s' to prevent manual edits`,
			target.Title,
			username,
		)

		err := api.setPagePermissions(target, RestrictionEdit, []Restriction{
			{User: username},
		})
		if err != nil {
			logger.Fatal(err)
		}
	}

	fmt.Printf(
		"page successfully updated: %s\n",
		baseURL+target.Links.Full,
	)

}