Example #1
0
func (back *zkConfig) reregisterWatch(path string, logger log.Logger) error {
	logger = log.NewContext(logger).With(logkey.ZkPath, path)
	logger.Log("Reregistering watch")
	_, _, _, err := back.conn.ExistsW(path)
	if err != nil {
		logger.Log(log.Err, err, "Unable to reregistering watch")
		return errors.Annotatef(err, "unable to reregister watch for node %s", path)
	}
	return nil
}
Example #2
0
func (back *zkConfig) Watch(key string, callback backingCallbackFunction) error {
	back.rootLogger.Log(logkey.ZkMethod, "watch", logkey.ZkPath, key)
	path := back.configPath(key)
	_, _, _, err := back.conn.ExistsW(path)
	if err != nil {
		return errors.Annotatef(err, "cannot watch path %s", path)
	}
	back.callbacks.add(path, callback)

	return nil
}
Example #3
0
// Ini creates a backing config reader that reads properties from an Ini file
func Ini(filename string) (Reader, error) {
	file, err := ini.LoadFile(filename)
	if err != nil {
		return nil, errors.Annotatef(err, "Unable to open file %s", filename)
	}
	return &propertyFileDisco{
		filename: filename,
		file:     file,
	}, nil

}
Example #4
0
// Get returns the config value from zookeeper
func (back *zkConfig) Get(key string) ([]byte, error) {
	back.rootLogger.Log(logkey.ZkMethod, "get", logkey.ZkPath, key)
	pathToFetch := back.configPath(key)
	bytes, _, _, err := back.conn.GetW(pathToFetch)
	if err != nil {
		if err == zk.ErrNoNode {
			return nil, nil
		}
		return nil, errors.Annotatef(err, "cannot load zk node %s", pathToFetch)
	}
	return bytes, nil
}
Example #5
0
func (back *zkConfig) Write(key string, value []byte) error {
	back.rootLogger.Log(logkey.ZkMethod, "write", logkey.ZkPath, key)
	path := back.configPath(key)
	exists, stat, err := back.conn.Exists(path)
	if err != nil {
		return err
	}
	if !exists {
		if value == nil {
			return nil
		}
		_, err := back.conn.Create(path, value, 0, zk.WorldACL(zk.PermAll))
		return errors.Annotatef(err, "cannot create path %s", path)
	}
	if value == nil {
		err = back.conn.Delete(path, stat.Version)
	} else {
		stat, err = back.conn.Set(path, value, stat.Version)
	}

	return errors.Annotatef(err, "cannot change path %s", path)
}
Example #6
0
// Update the content of this config variable to newValue.
func (c *intConf) Update(newValue []byte) error {
	c.mutex.Lock()
	defer c.mutex.Unlock()
	oldValue := c.Get()
	if newValue == nil {
		atomic.StoreInt64(&c.currentVal, c.defaultVal)
	} else {
		newValueInt, err := strconv.ParseInt(string(newValue), 10, 64)
		if err != nil {
			return errors.Annotatef(err, "Unparsable float %s", string(newValue))
		}
		atomic.StoreInt64(&c.currentVal, newValueInt)
	}
	if oldValue != c.Get() {
		for _, w := range c.watches {
			w(&c.Int, oldValue)
		}
	}

	return nil
}
Example #7
0
// Update the content of this config variable to newValue.
func (c *floatConf) Update(newValue []byte) error {
	c.mutex.Lock()
	defer c.mutex.Unlock()
	oldValue := c.Get()
	if newValue == nil {
		atomic.StoreUint64(&c.currentVal, math.Float64bits(c.defaultVal))
	} else {
		newValueFloat, err := strconv.ParseFloat(string(newValue), 64)
		if err != nil {
			return errors.Annotatef(err, "unable to parse float %s", newValue)
		}
		atomic.StoreUint64(&c.currentVal, math.Float64bits(newValueFloat))
	}
	if oldValue != c.Get() {
		for _, w := range c.watches {
			w(&c.Float, oldValue)
		}
	}

	return nil
}