コード例 #1
0
ファイル: format_test.go プロジェクト: rquelle/inspeqtor
func TestBasicServiceParsing(t *testing.T) {
	data, err := ioutil.ReadFile("fixtures/memcached.inq")
	if err != nil {
		t.Fatal(err)
	}

	s := lexer.NewLexer([]byte(data))
	p := parser.NewParser()
	obj, err := p.Parse(s)
	if err != nil {
		t.Fatal(err)
	}

	check := obj.(*ast.ProcessCheck)
	assert.Equal(t, "memcached", check.Name)
	assert.Equal(t, 2, len(check.Rules))
	assert.Equal(t, 4, len(check.Parameters))
	assert.Equal(t, "dev", check.Parameters["owner"])
	assert.Equal(t, "bar", check.Parameters["foo"])
	assert.Equal(t, "/foo", check.Parameters["endpoint"])
	assert.Equal(t, "whoa sp\"aces", check.Parameters["quoted"])
	assert.Equal(t, "cpu", check.Rules[1].Metric.Family)
	assert.Equal(t, "user", check.Rules[1].Metric.Name)

	var names []string
	for _, act := range check.Rules[0].Actions {
		names = append(names, act.Name())
	}
	sort.Strings(names)

	assert.Equal(t, "alert", names[0])
	assert.Equal(t, "reload", names[1])
	assert.Equal(t, "restart", names[2])
}
コード例 #2
0
ファイル: format_test.go プロジェクト: rquelle/inspeqtor
func TestMysqlParsing(t *testing.T) {
	data, err := ioutil.ReadFile("fixtures/mysql.inq")
	if err != nil {
		t.Fatal(err)
	}

	s := lexer.NewLexer([]byte(data))
	p := parser.NewParser()
	obj, err := p.Parse(s)
	if err != nil {
		t.Fatal(err)
	}

	check := obj.(*ast.ProcessCheck)
	assert.Equal(t, check.Name, "mysql")
	assert.Equal(t, len(check.Parameters), 0)
	assert.Equal(t, len(check.Rules), 4)
	assert.Equal(t, check.Rules[1].Threshold.Parsed, 50)
	assert.Equal(t, check.Rules[1].Threshold.Raw, "50")
	assert.Equal(t, check.Rules[1].Threshold.PerSec, false)

	assert.Equal(t, check.Rules[2].Threshold.Parsed, 1024)
	assert.Equal(t, check.Rules[2].Threshold.Raw, "1k/sec")
	assert.Equal(t, check.Rules[2].Threshold.PerSec, true)

	assert.Equal(t, check.Rules[3].Threshold.Parsed, 2)
	assert.Equal(t, check.Rules[3].Threshold.Raw, "2/sec")
	assert.Equal(t, check.Rules[3].Threshold.PerSec, true)
}
コード例 #3
0
ファイル: format_test.go プロジェクト: rquelle/inspeqtor
func TestBadAmount(t *testing.T) {
	data, err := ioutil.ReadFile("fixtures/bad_amount.inq")
	if err != nil {
		t.Fatal(err)
	}

	s := lexer.NewLexer([]byte(data))
	p := parser.NewParser()
	obj, err := p.Parse(s)
	assert.Nil(t, obj)
	assert.NotNil(t, err)
	assert.True(t, strings.Contains(err.Error(), "Invalid amount"))
}
コード例 #4
0
ファイル: format_test.go プロジェクト: rquelle/inspeqtor
func TestBasicHostParsing(t *testing.T) {
	data, err := ioutil.ReadFile("fixtures/host.inq")
	if err != nil {
		t.Fatal(err)
	}

	s := lexer.NewLexer([]byte(data))
	p := parser.NewParser()
	obj, err := p.Parse(s)
	if err != nil {
		t.Fatal(err)
	}

	check := obj.(*ast.HostCheck)
	assert.Equal(t, len(check.Rules), 3)
}
コード例 #5
0
ファイル: format_test.go プロジェクト: rquelle/inspeqtor
func TestExpose(t *testing.T) {
	data, err := ioutil.ReadFile("fixtures/inspeqtor.inq")
	if err != nil {
		t.Fatal(err)
	}

	s := lexer.NewLexer([]byte(data))
	p := parser.NewParser()
	obj, err := p.Parse(s)
	assert.NotNil(t, obj)
	assert.Nil(t, err)

	check := obj.(*ast.ProcessCheck)
	assert.Equal(t, check.Name, "inspeqtor")
	assert.Equal(t, len(check.Parameters), 0)
	assert.Equal(t, len(check.Rules), 0)
	assert.Equal(t, len(check.Exposed), 1)
	assert.Equal(t, "memstats", check.Exposed[0])
}
コード例 #6
0
ファイル: inq_parser.go プロジェクト: rquelle/inspeqtor
/*
Parses the service-specific rules in /etc/inspeqtor/services.d/*.inq
*/
func ParseServices(global *ConfigFile, confDir string) ([]Checkable, error) {
	util.Debug("Parsing config in " + confDir)
	files, err := filepath.Glob(confDir + "/*.inq")
	if err != nil {
		return nil, err
	}

	var checks []Checkable

	for _, filename := range files {
		util.DebugDebug("Parsing " + filename)
		data, err := ioutil.ReadFile(filename)
		if err != nil {
			return nil, err
		}

		s := lexer.NewLexer([]byte(data))
		p := parser.NewParser()
		obj, err := p.Parse(s)
		if err != nil {
			util.Warn("Unable to parse " + filename + ": " + err.Error())
			continue
		}

		switch x := obj.(type) {
		case *ast.ProcessCheck:
			svc, err := BuildService(global, x)
			if err != nil {
				return nil, err
			}
			util.DebugDebug("Service: %+v", *svc)
			checks = append(checks, svc)
		default:
			return nil, fmt.Errorf("Invalid configuration file: %s", filename)
		}
	}

	return checks, nil
}
コード例 #7
0
ファイル: inq_parser.go プロジェクト: rquelle/inspeqtor
/*
Parses the host-specific rules in /etc/inspeqtor/host.inq
*/
func ParseHost(global *ConfigFile, hostInq string) (*Host, error) {
	var host *Host

	result, err := util.FileExists(hostInq)
	if err != nil {
		return nil, err
	}
	if !result {
		return nil, fmt.Errorf("Missing required file: %s", hostInq)
	}

	util.DebugDebug("Parsing " + hostInq)
	data, err := ioutil.ReadFile(hostInq)
	if err != nil {
		return nil, err
	}

	s := lexer.NewLexer([]byte(data))
	p := parser.NewParser()
	obj, err := p.Parse(s)
	if err != nil {
		return nil, err
	}

	switch x := obj.(type) {
	case *ast.HostCheck:
		host, err = BuildHost(global, x)
		if err != nil {
			return nil, err
		}
		util.DebugDebug("Host: %+v", *host)
	default:
		return nil, fmt.Errorf("Invalid host.inq configuration file")
	}

	return host, nil
}