Example #1
0
func (b clockBuilder) Build(conf config.Config) (i3.Producer, error) {
	c := Clock{}
	err := conf.ParseConfig(&c)
	if err != nil {
		return nil, err
	}

	switch conf.Name {
	case "":
		c.Name = Identifier
	default:
		c.Name = conf.Name
	}

	switch c.Location {
	case "":
		c.Instance = "Local"
	default:
		c.Instance = c.Location
	}

	return &i3.BaseProducerClicker{
		GeneratorClicker: &c,
		Interval:         1 * time.Second,
		Name:             "time",
	}, nil
}
Example #2
0
func (b CommandBuilder) Build(c config.Config) (p i3.Producer, err error) {
	conf := Command{}

	interval, err := time.ParseDuration(b.Interval)
	if err != nil {
		return
	}

	err = c.ParseConfig(&b)
	if err != nil {
		return
	}

	color, err := i3.ParseColor(b.Color)
	if err != nil {
		return
	}
	conf.Color = color

	p = &i3.BaseProducer{
		Generator: conf,
		Interval:  interval,
		Name:      Identifier,
	}

	return
}
Example #3
0
func (b cpuBuilder) Build(c config.Config) (p i3.Producer, err error) {
	conf := cpuConfig{}
	err = c.ParseConfig(&conf)
	if err != nil {
		return
	}

	interval, err := time.ParseDuration(conf.Interval)
	if err != nil {
		return
	}

	if b.perc {
		p = &CpuPerc{
			Name:          "cpu_util",
			WarnThreshold: conf.WarnThreshold,
			CritThreshold: conf.CritThreshold,
			Interval:      interval,
		}
	} else {
		p = &i3.BaseProducer{
			Generator: &Cpu{
				Name:          "cpu_load",
				WarnThreshold: conf.WarnThreshold,
				CritThreshold: conf.CritThreshold,
			},
			Interval: interval,
		}
	}

	return
}
Example #4
0
// Build implements config.Builder
func (b networkBuilder) Build(data config.Config) (p i3.Producer, err error) {
	var c generalConfig
	err = data.ParseConfig(&c)
	if err != nil {
		return
	}

	interval, err := time.ParseDuration(c.Interval)
	if err != nil {
		return
	}

	conf, err := buildNetworkConfig(c.Config)
	if err != nil {
		return
	}

	generator, err := conf.Device()
	if err != nil {
		return
	}

	p = &i3.BaseProducer{
		Generator: generator,
		Interval:  interval,
		Name:      "network",
	}

	return
}
func (b diskIOBuilder) Build(c config.Config) (p i3.Producer, err error) {
	conf := diskIOConfig{}
	err = c.ParseConfig(&conf)
	if err != nil {
		return
	}

	interval, err := time.ParseDuration(conf.Interval)
	if err != nil {
		return
	}

	return &DiskIOGenerator{
		WarnThreshold: conf.WarnThreshold,
		CritThreshold: conf.CritThreshold,
		Interval:      interval,
		Items:         conf.Items,
	}, nil
}
Example #6
0
func (b diskUsageBuilder) Build(c config.Config) (p i3.Producer, err error) {
	conf := diskUsageConfig{}
	err = c.ParseConfig(&conf)
	if err != nil {
		return
	}

	interval, err := time.ParseDuration(conf.Interval)
	if err != nil {
		return
	}

	conf.Options.Name = Identifier

	return &i3.BaseProducer{
		Generator: conf.Options,
		Interval:  interval,
		Name:      "disk usage",
	}, nil
}
Example #7
0
func (b batteryBuilder) Build(c config.Config) (i3.Producer, error) {
	conf := batteryConfig{}
	err := c.ParseConfig(&conf)
	if err != nil {
		return nil, err
	}

	interval, err := time.ParseDuration(conf.Interval)
	if err != nil {
		return nil, err
	}

	if ok := validateThreshold(conf.WarnThreshold); !ok {
		return nil, fmt.Errorf(
			"WarnThreshold for %v (%v) is outside acceptable range (0, 100)",
			conf.Identifier, conf.WarnThreshold,
		)
	}

	if ok := validateThreshold(conf.CritThreshold); !ok {
		return nil, fmt.Errorf(
			"CritThreshold for %v (%v) is outside acceptable range (0, 100)",
			conf.Identifier, conf.CritThreshold,
		)
	}

	bat := Battery{
		Name:          conf.Name,
		Identifier:    conf.Identifier,
		WarnThreshold: conf.WarnThreshold,
		CritThreshold: conf.CritThreshold,
	}

	return &i3.BaseProducer{
		Generator: &bat,
		Interval:  interval,
		Name:      conf.Identifier + "_bat",
	}, nil
}
Example #8
0
func (m memoryBuilder) Build(c config.Config) (Producer, error) {
	conf := MemoryConfig{}
	err := c.ParseConfig(&conf)
	if err != nil {
		return nil, err
	}

	interval, err := time.ParseDuration(conf.Interval)
	if err != nil {
		return nil, err
	}

	g := Memory{
		Name:          Identifier,
		WarnThreshold: conf.WarnThreshold,
		CritThreshold: conf.CritThreshold,
	}

	return &BaseProducer{
		Generator: g,
		Name:      Identifier,
		Interval:  interval,
	}, nil
}