libconfd

package module
v0.0.0-...-2849512 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 5, 2020 License: Apache-2.0 Imports: 28 Imported by: 2

README

libconfd

Build Status Go Report Card GoDoc License

mini confd lib, based on confd/memkv/secconf/logger.

Example

package main

import (
	"github.com/chai2010/libconfd"
)

func main() {
	cfg := libconfd.MustLoadConfig("./confd.toml")

	backendConfig := libconfd.MustLoadBackendConfig("./confd-backend.toml")
	backendClient := libconfd.MustNewBackendClient(backendConfig)

	libconfd.NewProcessor().Run(cfg, backendClient)
}

miniconfd (only support toml/etcd backend)

$ go run miniconfd.go -h

See etcdv3/miniconfd-etcdv3/miniconfd.go

Documentation

Overview

Package libconfd provides mini confd lib.

Example 
package main

import (
	"github.com/chai2010/libconfd"
)

func main() {
	cfg := libconfd.MustLoadConfig("./confd.toml")

	backendConfig := libconfd.MustLoadBackendConfig("./confd-backend.toml")
	backendClient := libconfd.MustNewBackendClient(backendConfig)

	libconfd.NewProcessor().Run(cfg, backendClient)
}

Output:
Example (Async) 
package main

import (
	"fmt"

	"github.com/chai2010/libconfd"
)

func main() {
	cfg := libconfd.MustLoadConfig("./confd.toml")

	backendConfig := libconfd.MustLoadBackendConfig("./confd-backend.toml")
	backendClient := libconfd.MustNewBackendClient(backendConfig)

	call := libconfd.NewProcessor().Go(cfg, backendClient)

	// do some thing

	call = <-call.Done // will be equal to call
	fmt.Println(call.Error)
}

Output:
Example (Close) 
package main

import (
	"os"
	"os/signal"

	"github.com/chai2010/libconfd"
)

func main() {
	cfg := libconfd.MustLoadConfig("./confd.toml")

	backendConfig := libconfd.MustLoadBackendConfig("./confd-backend.toml")
	backendClient := libconfd.MustNewBackendClient(backendConfig)

	p := libconfd.NewProcessor()

	go func() {
		defer p.Close()

		c := make(chan os.Signal, 1)
		signal.Notify(c, os.Interrupt, os.Kill)
		<-c
	}()

	p.Run(cfg, backendClient)
}

Output:
Example (Logger) 
package main

import (
	"github.com/chai2010/libconfd"
)

func main() {
	var logger = libconfd.GetLogger()

	logger.SetLevel("DEBUG")
	logger.Debug("1+1=2")
	logger.Info("hello")
}

Output:
Example (MultiAsync) 
package main

import (
	"fmt"
	"sync"

	"github.com/chai2010/libconfd"
)

func main() {
	cfg := libconfd.MustLoadConfig("./confd.toml")

	backendConfig := libconfd.MustLoadBackendConfig("./confd-backend.toml")
	backendClient := libconfd.MustNewBackendClient(backendConfig)

	var callList = []*libconfd.Call{
		libconfd.NewProcessor().Go(cfg, backendClient),
		libconfd.NewProcessor().Go(cfg, backendClient),
	}

	var wg sync.WaitGroup
	for i := 0; i < len(callList); i++ {
		wg.Add(1)
		go func(i int) {
			<-callList[i].Done
			wg.Done()
		}(i)
	}
	wg.Wait()

	fmt.Println("Done")
}

Output:
Example (MultiSync) 
package main

import (
	"github.com/chai2010/libconfd"
)

func main() {
	cfg := libconfd.MustLoadConfig("./confd.toml")

	backendConfig := libconfd.MustLoadBackendConfig("./confd-backend.toml")
	backendClient := libconfd.MustNewBackendClient(backendConfig)

	go libconfd.NewProcessor().Run(cfg, backendClient)
	go libconfd.NewProcessor().Run(cfg, backendClient)

	<-make(chan bool)
}

Output:
Example (Option) 
package main

import (
	"github.com/chai2010/libconfd"
)

func main() {
	cfg := libconfd.MustLoadConfig("./confd.toml")

	backendConfig := libconfd.MustLoadBackendConfig("./confd-backend.toml")
	backendClient := libconfd.MustNewBackendClient(backendConfig)

	libconfd.NewProcessor().Run(cfg, backendClient,
		libconfd.WithIntervalMode(),
	)
}

Output:

Index

Examples

Constants

View Source 
const TomlBackendType = "libconfd-backend-toml"

Variables

This section is empty.

Functions

func RegisterBackendClient 

func RegisterBackendClient(
	typeName string,
	newClient func(cfg *BackendConfig) (BackendClient, error),
)

Types

type Application 

type Application struct {
	// contains filtered or unexported fields
}

func NewApplication 

func NewApplication(cfg *Config, client BackendClient) *Application

func (*Application) GetValues 

func (p *Application) GetValues(keys ...string)

func (*Application) Info 

func (p *Application) Info(names ...string)

func (*Application) List 

func (p *Application) List(re string)

func (*Application) Make 

func (p *Application) Make(names ...string)

func (*Application) Run 

func (p *Application) Run(opts ...Options)

type BackendClient 

type BackendClient interface {
	Type() string
	GetValues(keys []string) (map[string]string, error)
	WatchPrefix(prefix string, keys []string, waitIndex uint64, stopChan chan bool) (uint64, error)
	WatchEnabled() bool
	Close() error
}

func MustNewBackendClient 

func MustNewBackendClient(cfg *BackendConfig, opts ...func(*BackendConfig)) BackendClient

func NewBackendClient 

func NewBackendClient(cfg *BackendConfig, opts ...func(*BackendConfig)) (BackendClient, error)

type BackendConfig 

type BackendConfig struct {
	Type string   `toml:"type" json:"type"`
	Host []string `toml:"host" json:"host"`

	UserName string `toml:"user" json:"user"`
	Password string `toml:"password" json:"password"`

	ClientCAKeys string `toml:"client_ca_keys" json:"client_ca_keys"`
	ClientCert   string `toml:"client_cert" json:"client_cert"`
	ClientKey    string `toml:"client_key" json:"client_key"`

	HookKeyAdjuster func(key string) (realKey string) `toml:"-" json:"-"`
}

func LoadBackendConfig 

func LoadBackendConfig(path string) (p *BackendConfig, err error)

func LoadBackendConfigFromJsonString 

func LoadBackendConfigFromJsonString(s string) (p *BackendConfig, err error)

func MustLoadBackendConfig 

func MustLoadBackendConfig(path string) *BackendConfig

func (*BackendConfig) Clone 

func (p *BackendConfig) Clone() *BackendConfig

type Call 

type Call struct {
	Config *Config
	Client BackendClient
	Error  error
	Done   chan *Call
}

type Config 

type Config struct {
	// The path to confd configs.
	// If the confdir is rel path, must convert to abs path.
	//
	// abspath = filepath.Join(ConfigPath, Config.ConfDir)
	//
	ConfDir string `toml:"confdir" json:"confdir"`

	// The backend polling interval in seconds. (10)
	Interval int `toml:"interval" json:"interval"`

	// Enable noop mode. Process all template resources; skip target update.
	Noop bool `toml:"noop" json:"noop"`

	// The string to prefix to keys. ("/")
	Prefix string `toml:"prefix" json:"prefix"`

	// sync without check_cmd and reload_cmd.
	SyncOnly bool `toml:"sync_only" json:"sync_only"`

	// level which confd should log messages
	// DEBUG/INFO/WARN/ERROR/PANIC
	LogLevel string `toml:"log_level" json:"log_level"`

	// run once and exit
	Onetime bool `toml:"onetime" json:"onetime"`

	// enable watch support
	Watch bool `toml:"watch" json:"watch"`

	// keep staged files
	KeepStageFile bool `toml:"keep_stage_file" json:"keep_stage_file"`

	// PGP secret keyring (for use with crypt functions)
	PGPPrivateKey string `toml:"pgp_private_key" json:"pgp_private_key"`

	FuncMap        template.FuncMap                               `toml:"-" json:"-"`
	FuncMapUpdater func(m template.FuncMap, basefn *TemplateFunc) `toml:"-" json:"-"`

	HookAbsKeyAdjuster  func(absKey string) (realKey string) `toml:"-" json:"-"`
	HookOnCheckCmdDone  func(trName, cmd string, err error)  `toml:"-" json:"-"`
	HookOnReloadCmdDone func(trName, cmd string, err error)  `toml:"-" json:"-"`
	HookOnUpdateDone    func(trName string, err error)       `toml:"-" json:"-"`
}

func LoadConfig 

func LoadConfig(path string) (p *Config, err error)

func LoadConfigFromJsonString 

func LoadConfigFromJsonString(s string) (p *Config, err error)

func MustLoadConfig 

func MustLoadConfig(path string) *Config

func (*Config) Clone 

func (p *Config) Clone() *Config

func (*Config) GetConfigDir 

func (p *Config) GetConfigDir() string

func (*Config) GetDefaultTemplateOutputDir 

func (p *Config) GetDefaultTemplateOutputDir() string

func (*Config) GetTemplateDir 

func (p *Config) GetTemplateDir() string

func (*Config) Save 

func (p *Config) Save(name string) error

func (*Config) Valid 

func (p *Config) Valid() error

type KVPair 

type KVPair struct {
	Key   string
	Value string
}

func (KVPair) String 

func (p KVPair) String() string

type KVStore 

type KVStore struct {
	// contains filtered or unexported fields
}

A KVStore represents an in-memory key-value store safe for concurrent access.

func NewKVStore 

func NewKVStore() *KVStore

New creates and initializes a new KVStore.

func (*KVStore) Del 

func (p *KVStore) Del(key string)

Delete deletes the KVPair associated with key.

func (*KVStore) Exists 

func (p *KVStore) Exists(key string) bool

Exists checks for the existence of key in the store.

func (*KVStore) Get 

func (p *KVStore) Get(key string) (kv KVPair, ok bool)

Get gets the KVPair associated with key. If there is no KVPair associated with key, Get returns KVPair{}, false.

func (*KVStore) GetAll 

func (p *KVStore) GetAll(pattern string) ([]KVPair, error)

GetAll returns a KVPair for all nodes with keys matching pattern. The syntax of patterns is the same as in path.Match.

func (*KVStore) GetAllValues 

func (p *KVStore) GetAllValues(pattern string) ([]string, error)

func (*KVStore) GetValue 

func (p *KVStore) GetValue(key string, v ...string) (s string, ok bool)

GetValue gets the value associated with key. If there are no values associated with key, GetValue returns "", false.

func (*KVStore) List 

func (p *KVStore) List(filePath string) []string

func (*KVStore) ListDir 

func (p *KVStore) ListDir(filePath string) []string

func (*KVStore) Purge 

func (s *KVStore) Purge()

func (*KVStore) Set 

func (s *KVStore) Set(key string, value string)

Set sets the KVPair entry associated with key to value.

type Logger 

type Logger interface {
	Assert(condition bool, v ...interface{})
	Assertln(condition bool, v ...interface{})
	Assertf(condition bool, format string, v ...interface{})
	Debug(v ...interface{})
	Debugln(v ...interface{})
	Debugf(format string, v ...interface{})
	Info(v ...interface{})
	Infoln(v ...interface{})
	Infof(format string, v ...interface{})
	Warning(v ...interface{})
	Warningln(v ...interface{})
	Warningf(format string, v ...interface{})
	Error(v ...interface{})
	Errorln(v ...interface{})
	Errorf(format string, v ...interface{})
	Panic(v ...interface{})
	Panicln(v ...interface{})
	Panicf(format string, v ...interface{})
	Fatal(v ...interface{})
	Fatalln(v ...interface{})
	Fatalf(format string, v ...interface{})

	// Level: DEBUG < INFO < WARN < ERROR < PANIC < FATAL
	GetLevel() string
	SetLevel(new string) (old string)
}

Logger interface

See https://github.com/chai2010/logger

func GetLogger 

func GetLogger() Logger

func NewStdLogger 

func NewStdLogger(out io.Writer, prefix, level string, flag int) Logger

NewStdLogger create new logger based on std log. If level is empty string, use WARN as the default level. If flag is zore, use 'log.LstdFlags|log.Lshortfile' as the default flag. Level: DEBUG < INFO < WARN < ERROR < PANIC < FATAL

func SetLogger 

func SetLogger(new Logger) (old Logger)

type Options 

type Options func(*Config)

func WithAbsKeyAdjuster 

func WithAbsKeyAdjuster(fn func(absKey string) (realKey string)) Options

func WithFuncMap 

func WithFuncMap(maps ...template.FuncMap) Options

func WithFuncMapUpdater 

func WithFuncMapUpdater(fn func(m template.FuncMap, basefn *TemplateFunc)) Options

func WithHookOnCheckCmdDone 

func WithHookOnCheckCmdDone(fn func(trName, cmd string, err error)) Options

func WithHookOnReloadCmdDone 

func WithHookOnReloadCmdDone(fn func(trName, cmd string, err error)) Options

func WithHookOnUpdateDone 

func WithHookOnUpdateDone(fn func(trName string, err error)) Options

func WithInterval 

func WithInterval(interval int) Options

func WithIntervalMode 

func WithIntervalMode() Options

func WithOnetimeMode 

func WithOnetimeMode() Options

func WithWatchMode 

func WithWatchMode() Options

type Processor 

type Processor struct {
	// contains filtered or unexported fields
}

func NewProcessor 

func NewProcessor() *Processor

func (*Processor) Close 

func (p *Processor) Close() error

func (*Processor) Go 

func (p *Processor) Go(cfg *Config, client BackendClient, opts ...Options) *Call

func (*Processor) Run 

func (p *Processor) Run(cfg *Config, client BackendClient, opts ...Options) error

type TemplateFunc 

type TemplateFunc struct {
	FuncMap       map[string]interface{}
	Store         *KVStore
	PGPPrivateKey []byte

	HookKeyAdjuster func(key string) (realKey string)
}

func NewTemplateFunc 

func NewTemplateFunc(
	store *KVStore, pgpPrivateKey []byte,
	hookKeyAdjuster func(key string) (realKey string),
) *TemplateFunc

func (TemplateFunc) Add 

func (_ TemplateFunc) Add(a, b int) int

func (TemplateFunc) Atoi 

func (_ TemplateFunc) Atoi(s string) int

func (TemplateFunc) Base 

func (_ TemplateFunc) Base(path string) string

func (TemplateFunc) Base64Decode 

func (_ TemplateFunc) Base64Decode(data string) string

func (TemplateFunc) Base64Encode 

func (_ TemplateFunc) Base64Encode(data string) string

func (TemplateFunc) Cget 

func (p TemplateFunc) Cget(key string) KVPair

func (TemplateFunc) Cgets 

func (p TemplateFunc) Cgets(pattern string) []KVPair

func (TemplateFunc) Cgetv 

func (p TemplateFunc) Cgetv(key string) string

func (TemplateFunc) Cgetvs 

func (p TemplateFunc) Cgetvs(pattern string) []string

func (TemplateFunc) Contains 

func (_ TemplateFunc) Contains(s, substr string) bool

func (TemplateFunc) Datetime 

func (_ TemplateFunc) Datetime() time.Time

func (TemplateFunc) Dir 

func (_ TemplateFunc) Dir(path string) string

func (TemplateFunc) Div 

func (_ TemplateFunc) Div(a, b int) int

func (TemplateFunc) Exists 

func (p TemplateFunc) Exists(key string) bool

func (TemplateFunc) FileExists 

func (_ TemplateFunc) FileExists(filepath string) bool

func (TemplateFunc) Get 

func (p TemplateFunc) Get(key string) KVPair

func (TemplateFunc) Getenv 

func (_ TemplateFunc) Getenv(key string, defaultValue ...string) string

getenv retrieves the value of the environment variable named by the key. It returns the value, which will the default value if the variable is not present. If no default value was given - returns "".

func (TemplateFunc) Gets 

func (p TemplateFunc) Gets(pattern string) []KVPair

func (TemplateFunc) Getv 

func (p TemplateFunc) Getv(key string, v ...string) string

func (TemplateFunc) Getvs 

func (p TemplateFunc) Getvs(pattern string) []string

func (TemplateFunc) Join 

func (_ TemplateFunc) Join(a []string, sep string) string

func (TemplateFunc) Json 

func (_ TemplateFunc) Json(data string) map[string]interface{}

func (TemplateFunc) JsonArray 

func (_ TemplateFunc) JsonArray(data string) []interface{}

func (TemplateFunc) LookupIP 

func (_ TemplateFunc) LookupIP(data string) []string

func (TemplateFunc) LookupIPV4 

func (_ TemplateFunc) LookupIPV4(data string) []string

func (TemplateFunc) LookupIPV6 

func (_ TemplateFunc) LookupIPV6(data string) []string

func (TemplateFunc) LookupSRV 

func (_ TemplateFunc) LookupSRV(service, proto, name string) []*net.SRV

func (TemplateFunc) Ls 

func (p TemplateFunc) Ls(filepath string) []string

func (TemplateFunc) Lsdir 

func (p TemplateFunc) Lsdir(filepath string) []string

func (TemplateFunc) Map 

func (_ TemplateFunc) Map(values ...interface{}) map[string]interface{}

Map creates a key-value map of string -> interface{} The i'th is the key and the i+1 is the value

func (TemplateFunc) Mod 

func (_ TemplateFunc) Mod(a, b int) int

func (TemplateFunc) Mul 

func (_ TemplateFunc) Mul(a, b int) int

func (TemplateFunc) ParseBool 

func (_ TemplateFunc) ParseBool(s string) bool

func (TemplateFunc) Replace 

func (_ TemplateFunc) Replace(s, old, new string, n int) string

func (TemplateFunc) Reverse 

func (_ TemplateFunc) Reverse(values interface{}) interface{}

reverse returns the array in reversed order works with []string and []KVPair

func (TemplateFunc) Seq 

func (_ TemplateFunc) Seq(first, last int) []int

seq creates a sequence of integers. It's named and used as GNU's seq. seq takes the first and the last element as arguments. So Seq(3, 5) will generate [3,4,5]

func (TemplateFunc) SortByLength 

func (_ TemplateFunc) SortByLength(values []string) []string

func (TemplateFunc) SortKVByLength 

func (_ TemplateFunc) SortKVByLength(values []KVPair) []KVPair

func (TemplateFunc) Split 

func (_ TemplateFunc) Split(s, sep string) []string

func (TemplateFunc) Sub 

func (_ TemplateFunc) Sub(a, b int) int

func (TemplateFunc) ToLower 

func (_ TemplateFunc) ToLower(s string) string

func (TemplateFunc) ToUpper 

func (_ TemplateFunc) ToUpper(s string) string

func (TemplateFunc) TrimSuffix 

func (_ TemplateFunc) TrimSuffix(s, suffix string) string

type TemplateResource 

type TemplateResource struct {
	Src           string      `toml:"src" json:"src"`
	Dest          string      `toml:"dest" json:"dest"`
	Prefix        string      `toml:"prefix" json:"prefix"`
	Keys          []string    `toml:"keys" json:"keys"`
	Mode          string      `toml:"mode" json:"mode"`
	Gid           int         `toml:"gid" json:"gid"`
	Uid           int         `toml:"uid" json:"uid"`
	CheckCmd      string      `toml:"check_cmd" json:"check_cmd"`
	ReloadCmd     string      `toml:"reload_cmd" json:"reload_cmd"`
	FileMode      os.FileMode `toml:"file_mode" json:"file_mode"`
	PGPPrivateKey []byte      `toml:"pgp_private_key" json:"pgp_private_key"`
}

TemplateResource is the representation of a parsed template resource.

func ListTemplateResource 

func ListTemplateResource(confdir string) ([]*TemplateResource, []string, error)

func LoadTemplateResourceFile 

func LoadTemplateResourceFile(confdir, name string) (*TemplateResource, error)

func (*TemplateResource) SaveFile 

func (p *TemplateResource) SaveFile(path string) error

func (*TemplateResource) TomlString 

func (p *TemplateResource) TomlString() string

type TemplateResourceProcessor 

type TemplateResourceProcessor struct {
	TemplateResource
	// contains filtered or unexported fields
}

func MakeAllTemplateResourceProcessor 

func MakeAllTemplateResourceProcessor(
	config *Config, client BackendClient,
) (
	[]*TemplateResourceProcessor,
	error,
)

func NewTemplateResourceProcessor 

func NewTemplateResourceProcessor(
	path string, config *Config, client BackendClient, res *TemplateResource,
) *TemplateResourceProcessor

NewTemplateResourceProcessor creates a NewTemplateResourceProcessor.

func (*TemplateResourceProcessor) Process 

func (p *TemplateResourceProcessor) Process(call *Call) (err error)

process is a convenience function that wraps calls to the three main tasks required to keep local configuration files in sync. First we gather vars from the store, then we stage a candidate configuration file, and finally sync things up. It returns an error if any.

type TomlBackend 

type TomlBackend struct {
	TOMLFile string
}

func NewTomlBackendClient 

func NewTomlBackendClient(cfg *BackendConfig) *TomlBackend

func (*TomlBackend) Close 

func (_ *TomlBackend) Close() error

func (*TomlBackend) GetValues 

func (p *TomlBackend) GetValues(keys []string) (m map[string]string, err error)

func (*TomlBackend) Type 

func (_ *TomlBackend) Type() string

func (*TomlBackend) WatchEnabled 

func (_ *TomlBackend) WatchEnabled() bool

func (*TomlBackend) WatchPrefix 

func (_ *TomlBackend) WatchPrefix(prefix string, keys []string, waitIndex uint64, stopChan chan bool) (uint64, error)

Source Files

View all Source files

Directories

Path Synopsis
etcdv3 module

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.