Ejemplo n.º 1
0
func (carbon *CarbonHandler) dial(URL string) {
	for attempts := 0; ; attempts++ {
		carbon.sleep(attempts)

		conn, err := net.DialTimeout("tcp", URL, CarbonDialTimeout)
		if err == nil {
			klog.KPrintf("meter.carbon.dial.info", "connected to '%s'", URL)
			carbon.connC <- msgConn{URL, conn}
			return
		}

		klog.KPrintf("meter.carbon.dial.error", "unable to connect to '%s': %s", URL, err)
	}
}
Ejemplo n.º 2
0
// Finish completes and returns the object. If errors were encountered during
// loading, they're all returned here as type Errors.
func (loader *Loader) Finish() (interface{}, error) {
	if loader.links != nil {
		for src, target := range loader.links {
			var value interface{}

			dst, err := loader.resolve(target, 0)

			klog.KPrintf("blueprint.loader.finish.debug", "src=%s, target=%s", src, dst)

			if err == nil {
				if value, err = dst.Get(loader.Values); err == nil && value == nil {
					err = fmt.Errorf("unable to link '%s' to nil value '%s'", src, dst)
				}
			}

			if err == nil {
				err = path.New(src).Set(loader.Values, value)
			}

			if err != nil {
				loader.ErrorAt(err, path.New(src))
			}
		}
	}

	// Required otherwise we set the type param on the error interface which
	// makes the error non-nil. One of those fun parts of the go language.
	if loader.errors != nil {
		return nil, loader.errors
	}
	return loader.Values, nil
}
Ejemplo n.º 3
0
// Link indicates that the object at the given src path should be equal to the
// value at the given target path. All links are resolved when calling Finish
// so there are no ordering constraints on links.
func (loader *Loader) Link(src, target path.P) {
	klog.KPrintf("blueprint.loader.link.debug", "src=%s, target=%s", src, target)

	if loader.links == nil {
		loader.links = make(map[string]path.P)
	}

	loader.links[src.String()] = target
}
Ejemplo n.º 4
0
// Type asserts the type of an object at the given path.  This is useful when
// dealing with interfaces which can't be pathed through unless they're
// associated with a concrete type.
func (loader *Loader) Type(src path.P, name string) {
	klog.KPrintf("blueprint.loader.type.debug", "src=%s, name=%s", src, name)

	if value, ok := New(name); !ok {
		loader.ErrorAt(fmt.Errorf("unknown type '%s'", name), src)

	} else if err := src.Set(loader.Values, value); err != nil {
		loader.ErrorAt(err, src)
	}
}
Ejemplo n.º 5
0
func (carbon *CarbonHandler) send(values map[string]float64) {
	ts := time.Now().Unix()

	for URL, conn := range carbon.conns {
		if conn == nil {
			continue
		}

		if err := carbon.write(conn, values, ts); err != nil {
			klog.KPrintf("meter.carbon.send.error", "error when sending to '%s': %s", URL, err)
			carbon.connect(URL)
		}
	}
}
Ejemplo n.º 6
0
// HandleMeters sends the given values to the configured remote HTTP endpoint.
func (handler *HTTPHandler) HandleMeters(values map[string]float64) {
	handler.Init()

	var body struct {
		Timestamp int64              `json:"timestamp"`
		Values    map[string]float64 `json:"values"`
	}

	body.Timestamp = time.Now().Unix()
	body.Values = values

	resp := handler.client.NewRequest(handler.Method).SetBody(body).Send()

	if err := resp.GetBody(nil); err != nil {
		klog.KPrintf("meter.http.send.error", "unable to send metrics: %s", err)
	}
}
Ejemplo n.º 7
0
// Barebone basic usage example of klog.
func Example_Simple() {

	// Default klog printer is a light wrapper around the standard log package
	// so we need to modify it a bit to make it work for our example.
	log.SetFlags(0)
	log.SetOutput(os.Stdout)
	log.SetPrefix("klog ")

	// KPrint and KPrintf are the only supported print functions where the first
	// argument is a key identifying the source of the log message. The key will
	// be used in future example to manipulate the log lines as they flow
	// through klog.
	klog.KPrint("a.b.c", "hello")
	klog.KPrintf("c.b.a", "%s", "world")

	// Output:
	// klog <a.b.c> hello
	// klog <c.b.a> world
}
Ejemplo n.º 8
0
// Add sets the object at the given path to value.
func (loader *Loader) Add(src path.P, value interface{}) {
	klog.KPrintf("blueprint.loader.add.debug", "src=%s, value={%T, %v}", src, value, value)

	err := src.Set(loader.Values, value)
	if err == nil {
		return
	}

	if err == path.ErrInvalidType {
		var typ reflect.Type
		if typ, err = src.Type(loader.Values); err == nil {
			if value, err = convert(typ, value); err == nil {
				err = src.Set(loader.Values, value)
			}
		}
	}

	loader.ErrorAt(err, src)
}