Config factories (#3)

Author: bivas

README.md

@@ -5,6 +5,7 @@
 Automate your review process with Rivi the review bot
 
 ## Usage
+Rivi can be run as a service which listens to incoming repository webhooks. This service must be internet facing to accept incoming requests (e.g. GitHub).
 ```
 Usage of rivi:
   -config string
@@ -19,6 +20,21 @@ Usage of rivi:
 $ rivi -port 9000 -config repo-x.yaml -config repo-y.yaml
 ```
 
+### Docker
+
+It is also possible to run Rivi as Docker container. Rivi's images are published to Docker Hub as `bivas/rivi`.
+
+You should visit [bivas/rivi](https://hub.docker.com/r/bivas/rivi/) Docker Hub page and check for published [tags](https://hub.docker.com/r/bivas/rivi/tags/).
+
+```
+$ docker run --detach \
+             --name rivi \
+             --publish 8080:8080 \
+             --env RIVI_CONFIG_TOKEN=<rivi oath token> \
+             --volume /path/to/config/files:/config \
+             bivas/rivi rivi -config /config/repo-x.yaml
+```
+
 ## Requirements
 
 - Create a token with `repo` permissions

bot/config.go

@@ -30,23 +30,53 @@ func (c *clientConfig) GetSecret() string {
 	return c.internal.GetString("secret")
 }
 
+type ActionConfig interface {
+	Name() string
+}
+
+type ActionConfigBuilder interface {
+	Build(config map[string]interface{}) (ActionConfig, error)
+}
+
 type Configuration interface {
 	GetClientConfig() ClientConfig
 	GetRoleMembers(role ...string) []string
 	GetRoles() []string
 	GetRules() []Rule
+	GetActionConfig(kind string) (ActionConfig, error)
 }
 
 var (
-	configSections = []string{"config", "roles", "rules"}
+	configSections       = []string{"config", "roles", "rules"}
+	actionConfigBuilders = make(map[string]ActionConfigBuilder)
 )
 
+func RegisterActionConfigBuilder(name string, builder ActionConfigBuilder) {
+	search := strings.ToLower(name)
+	_, exists := actionConfigBuilders[search]
+	if exists {
+		util.Logger.Error("action config build for %s exists!", name)
+	} else {
+		util.Logger.Debug("registering action config builder %s", name)
+		actionConfigBuilders[search] = builder
+	}
+}
+
 type config struct {
-	internal     map[string]*viper.Viper
-	clientConfig ClientConfig
-	rules        []Rule
-	roles        map[string][]string
-	rolesKeys    []string
+	internal      map[string]*viper.Viper
+	clientConfig  ClientConfig
+	rules         []Rule
+	roles         map[string][]string
+	rolesKeys     []string
+	actionConfigs map[string]ActionConfig
+}
+
+func (c *config) GetActionConfig(kind string) (ActionConfig, error) {
+	config, exists := c.actionConfigs[kind]
+	if !exists {
+		return nil, fmt.Errorf("No such action config %s", kind)
+	}
+	return config, nil
 }
 
 func (c *config) getSection(path string) (string, *viper.Viper) {
@@ -70,7 +100,7 @@ func (c *config) GetRoleMembers(roles ...string) []string {
 			result = append(result, members...)
 		}
 	}
-	set := util.StringSet{}
+	set := util.StringSet{Transformer: strings.ToLower}
 	set.AddAll(result)
 	return set.Values()
 }
@@ -121,14 +151,30 @@ func (c *config) readRulesSection() error {
 }
 
 func (c *config) readSections() error {
-	if err := c.readConfigSection(); err != nil {
-		return err
+	sections := []func() error{
+		c.readConfigSection,
+		c.readRolesSection,
+		c.readRulesSection,
 	}
-	if err := c.readRolesSection(); err != nil {
-		return err
+	for _, section := range sections {
+		if err := section(); err != nil {
+			return err
+		}
 	}
-	if err := c.readRulesSection(); err != nil {
-		return err
+	c.actionConfigs = make(map[string]ActionConfig)
+	for kind, builder := range actionConfigBuilders {
+		util.Logger.Debug("Building configuration for %s", kind)
+		actionConfig := c.internal["root"].GetStringMap(kind)
+		if actionConfig == nil || len(actionConfig) == 0 {
+			util.Logger.Warning("No matching section for %s", kind)
+			continue
+		}
+		config, err := builder.Build(actionConfig)
+		if err != nil {
+			util.Logger.Error("Error while building %s config. %s", kind, err)
+			continue
+		}
+		c.actionConfigs[kind] = config
 	}
 	return nil
 }

bot/config_test.go

@@ -1,6 +1,7 @@
 package bot
 
 import (
+	"fmt"
 	"github.com/stretchr/testify/assert"
 	"os"
 	. "testing"
@@ -82,3 +83,38 @@ func TestEmptyConfigTest(t *T) {
 	assert.Equal(t, "token-from-env", c.GetClientConfig().GetOAuthToken(), "token from env")
 	assert.Equal(t, "secret-from-env", c.GetClientConfig().GetSecret(), "secret from env")
 }
+
+type testActionConfig struct {
+	key, value string
+}
+
+func (t *testActionConfig) Name() string {
+	return "test-section"
+}
+
+type testBuilder struct {
+}
+
+func (*testBuilder) Build(config map[string]interface{}) (ActionConfig, error) {
+	if len(config) != 1 {
+		return nil, fmt.Errorf("Wrong number of values")
+	}
+	for key, value := range config {
+		return &testActionConfig{key, value.(string)}, nil
+	}
+	return nil, fmt.Errorf("Should not reach here")
+}
+
+func TestActionConfigBuilder(t *T) {
+	RegisterActionConfigBuilder("test-section", &testBuilder{})
+	c, err := newConfiguration("config_test.yml")
+	if err != nil {
+		t.Fatalf("Got error during config read. %s", err)
+	}
+	result, err := c.GetActionConfig("test-section")
+	assert.Nil(t, err, "should contain section")
+	exact, ok := result.(*testActionConfig)
+	assert.True(t, ok, "should be of test action config type")
+	assert.Equal(t, "key", exact.key, "key")
+	assert.Equal(t, "value", exact.value, "value")
+}

bot/config_test.yml

@@ -15,6 +15,9 @@ roles:
   testers:
       - user2
 
+test-section:
+  key: value
+
 rules:
   rule1:
       condition:

bot/mock/configuration.go

@@ -23,6 +23,10 @@ type MockConfiguration struct {
 	RoleMembers      map[string][]string
 }
 
+func (m *MockConfiguration) GetActionConfig(kind string) (bot.ActionConfig, error) {
+	panic("implement me")
+}
+
 func (m *MockConfiguration) GetClientConfig() bot.ClientConfig {
 	return m.MockClientConfig
 }

bot/rule.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"github.com/bivas/rivi/util"
 	"github.com/spf13/viper"
+	"strings"
 )
 
 type Action interface {
@@ -69,9 +70,15 @@ var actions map[string]ActionFactory = make(map[string]ActionFactory)
 var supportedActions []string = make([]string, 0)
 
 func RegisterAction(kind string, action ActionFactory) {
-	actions[kind] = action
-	supportedActions = append(supportedActions, kind)
-	util.Logger.Debug("running with support for %s", kind)
+	search := strings.ToLower(kind)
+	_, exists := actions[search]
+	if exists {
+		util.Logger.Error("action %s exists!", kind)
+	} else {
+		util.Logger.Debug("registering action %s", kind)
+		actions[search] = action
+		supportedActions = append(supportedActions, kind)
+	}
 }
 
 func buildActionsFromConfiguration(config *viper.Viper) []Action {