Merge pull request #45 from datadrivers/feature/routing-rule-support

Add support for routing rules

Author: ruedigerblock

client.go

@@ -55,6 +55,11 @@ type Client interface {
 	RoleDelete(string) error
 	RoleRead(string) (*Role, error)
 	RoleUpdate(string, Role) error
+	RoutingRuleCreate(*RoutingRule) error
+	RoutingRuleDelete(string) error
+	RoutingRuleRead(string) (*RoutingRule, error)
+	RoutingRuleUpdate(*RoutingRule) error
+	RoutingRulesLists() ([]RoutingRule, error)
 	ScriptCreate(*Script) error
 	ScriptDelete(string) error
 	ScriptLists() ([]Script, error)

routing_rule.go

@@ -0,0 +1,124 @@
+package client
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+const (
+	routingRulesAPIEndpoint = "service/rest/v1/routing-rules"
+
+	RoutingRuleModeAllow RoutingRuleMode = "ALLOW"
+	RoutingRuleModeBlock RoutingRuleMode = "BLOCK"
+)
+
+type RoutingRuleMode string
+
+// RoutingRule is like a filter you can apply to groups in terms of security access and general component retrieval, and can reduce the number of repositories within a group accessed in order to retrieve an component.
+type RoutingRule struct {
+	// Name of the routing rule
+	Name string `json:"name"`
+
+	//Description of the routing rule
+	Description string `json:"description,omitempty"`
+
+	// The mode describe how to hande with mathing requests
+	// Possible values: "BLOCK" or "ALLOW"
+	Mode RoutingRuleMode `json:"mode"`
+
+	// Regular expressions used to identify request paths that are allowed or blocked (depending on above mode)
+	Matchers []string `json:"matchers"`
+}
+
+// IsValid checks the values of the enum RoutingRuleMode
+func (m RoutingRuleMode) IsValid() error {
+	switch m {
+	case RoutingRuleModeAllow, RoutingRuleModeBlock:
+		return nil
+	}
+	return fmt.Errorf("Invalid routing rule mode. Possible values are ALLOW or BLOCK")
+}
+
+func (c *client) RoutingRulesLists() ([]RoutingRule, error) {
+	body, resp, err := c.Get(routingRulesAPIEndpoint, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("%s", string(body))
+	}
+
+	var rules []RoutingRule
+	if err := json.Unmarshal(body, &rules); err != nil {
+		return nil, fmt.Errorf("could not unmarschal RoutingRules: %v", err)
+	}
+	return rules, nil
+}
+
+func (c *client) RoutingRuleRead(name string) (*RoutingRule, error) {
+	body, resp, err := c.Get(fmt.Sprintf("%s/%s", routingRulesAPIEndpoint, name), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("%s", string(body))
+	}
+	var rule RoutingRule
+	if err := json.Unmarshal(body, &rule); err != nil {
+		return nil, fmt.Errorf("could not unmarschal RoutingRules: %v", err)
+	}
+	return &rule, nil
+}
+
+func (c *client) RoutingRuleCreate(rule *RoutingRule) error {
+	if err := rule.Mode.IsValid(); err != nil {
+		return err
+	}
+	ioReader, err := jsonMarshalInterfaceToIOReader(rule)
+	if err != nil {
+		return err
+	}
+	body, resp, err := c.Post(routingRulesAPIEndpoint, ioReader)
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != http.StatusNoContent {
+		return fmt.Errorf("%s", string(body))
+	}
+
+	return nil
+}
+
+func (c *client) RoutingRuleUpdate(rule *RoutingRule) error {
+	ioReader, err := jsonMarshalInterfaceToIOReader(rule)
+	if err != nil {
+		return err
+	}
+
+	body, resp, err := c.Put(fmt.Sprintf("%s/%s", routingRulesAPIEndpoint, rule.Name), ioReader)
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
+		return fmt.Errorf("%s", string(body))
+	}
+
+	return nil
+}
+
+func (c *client) RoutingRuleDelete(name string) error {
+	body, resp, err := c.Delete(fmt.Sprintf("%s/%s", routingRulesAPIEndpoint, name))
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
+		return fmt.Errorf("%s", string(body))
+	}
+	return err
+}

routing_rule_test.go

@@ -0,0 +1,58 @@
+package client
+
+import (
+	"fmt"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func testRoutingRule(name string, mode RoutingRuleMode) *RoutingRule {
+	return &RoutingRule{
+		Name:        name,
+		Mode:        mode,
+		Description: fmt.Sprintf("Go client routing roule %s", name),
+		Matchers: []string{
+			"match1",
+		},
+	}
+}
+
+func TestRoutingRuleModeIsValid(t *testing.T) {
+	var mode RoutingRuleMode
+
+	mode = "allow"
+	assert.Error(t, mode.IsValid(), "Invalid routing rule mode. Possible values are ALLOW or BLOCK")
+	mode = "ALLOW"
+	assert.Nil(t, mode.IsValid())
+	mode = "BLOCK"
+	assert.Nil(t, mode.IsValid())
+}
+
+func TestRoutingRuleCreateReadUpdateDelete(t *testing.T) {
+	client := getTestClient()
+	name := "test-routing-rule"
+	createdRoutingRule := testRoutingRule(name, RoutingRuleModeAllow)
+
+	err := client.RoutingRuleCreate(createdRoutingRule)
+	assert.Nil(t, err)
+
+	readRoutingRule, err := client.RoutingRuleRead(name)
+	assert.Equal(t, createdRoutingRule, readRoutingRule)
+	assert.Nil(t, err)
+
+	updatedRoutingRule := testRoutingRule(name, RoutingRuleModeBlock)
+
+	err = client.RoutingRuleUpdate(updatedRoutingRule)
+	assert.Nil(t, err)
+
+	readRoutingRule, err = client.RoutingRuleRead(name)
+	assert.Equal(t, updatedRoutingRule, readRoutingRule)
+	assert.Nil(t, err)
+
+	err = client.RoutingRuleDelete(name)
+	assert.Nil(t, err)
+
+	readRoutingRule, err = client.RoutingRuleRead(name)
+	assert.Nil(t, readRoutingRule)
+	assert.Error(t, err, "Did not find a routing rule with the name 'test-routing-rule'")
+}

scripts/start-nexus.sh

@@ -1,7 +1,7 @@
 #!/bin/bash -e
 
 LOCAL_PORT=8081
-NEXUS_VERSION=3.25.1
+NEXUS_VERSION=3.29.0
 
 echo "Starting Nexus container..."
 docker run -d --rm -v "${PWD}/nexus.properties":/nexus-data/etc/nexus.properties \