From 0496a0837a156eae10ed97bd73bb30203ac8391e Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Sun, 15 Mar 2015 14:57:19 -0700 Subject: [PATCH] helper/backend: use logical package --- helper/backend/backend.go | 28 ++++++++-------- helper/backend/backend_test.go | 60 +++++++++++++++++----------------- helper/backend/testing.go | 8 ++--- 3 files changed, 48 insertions(+), 48 deletions(-) diff --git a/helper/backend/backend.go b/helper/backend/backend.go index 1b9700c1b1..7edf05407a 100644 --- a/helper/backend/backend.go +++ b/helper/backend/backend.go @@ -8,15 +8,15 @@ import ( "sync" "text/template" - "github.com/hashicorp/vault/vault" + "github.com/hashicorp/vault/logical" "github.com/mitchellh/go-wordwrap" ) -// Backend is an implementation of vault.LogicalBackend that allows +// Backend is an implementation of logical.Backend that allows // the implementer to code a backend using a much more programmer-friendly // framework that handles a lot of the routing and validation for you. // -// This is recommended over implementing vault.LogicalBackend directly. +// This is recommended over implementing logical.Backend directly. type Backend struct { // Paths are the various routes that the backend responds to. // This cannot be modified after construction (i.e. dynamically changing @@ -54,13 +54,13 @@ type Path struct { // Callbacks are the set of callbacks that are called for a given // operation. If a callback for a specific operation is not present, - // then vault.ErrUnsupportedOperation is automatically generated. + // then logical.ErrUnsupportedOperation is automatically generated. // // The help operation is the only operation that the Path will // automatically handle if the Help field is set. If both the Help // field is set and there is a callback registered here, then the // callback will be called. - Callbacks map[vault.Operation]OperationFunc + Callbacks map[logical.Operation]OperationFunc // Help is text describing how to use this path. This will be used // to auto-generate the help operation. The Path will automatically @@ -78,14 +78,14 @@ type Path struct { } // OperationFunc is the callback called for an operation on a path. -type OperationFunc func(*vault.Request, *FieldData) (*vault.Response, error) +type OperationFunc func(*logical.Request, *FieldData) (*logical.Response, error) -// vault.LogicalBackend impl. -func (b *Backend) HandleRequest(req *vault.Request) (*vault.Response, error) { +// logical.Backend impl. +func (b *Backend) HandleRequest(req *logical.Request) (*logical.Response, error) { // Find the matching route path, captures := b.route(req.Path) if path == nil { - return nil, vault.ErrUnsupportedPath + return nil, logical.ErrUnsupportedPath } // Build up the data for the route, with the URL taking priority @@ -105,13 +105,13 @@ func (b *Backend) HandleRequest(req *vault.Request) (*vault.Response, error) { callback, ok = path.Callbacks[req.Operation] } if !ok { - if req.Operation == vault.HelpOperation && path.HelpSynopsis != "" { + if req.Operation == logical.HelpOperation && path.HelpSynopsis != "" { callback = path.helpCallback ok = true } } if !ok { - return nil, vault.ErrUnsupportedOperation + return nil, logical.ErrUnsupportedOperation } // Call the callback with the request and the data @@ -121,7 +121,7 @@ func (b *Backend) HandleRequest(req *vault.Request) (*vault.Response, error) { }) } -// vault.LogicalBackend impl. +// logical.Backend impl. func (b *Backend) RootPaths() []string { // TODO return nil @@ -168,7 +168,7 @@ func (b *Backend) route(path string) (*Path, map[string]string) { return nil, nil } -func (p *Path) helpCallback(req *vault.Request, data *FieldData) (*vault.Response, error) { +func (p *Path) helpCallback(req *logical.Request, data *FieldData) (*logical.Response, error) { var tplData pathTemplateData tplData.Request = req.Path tplData.RoutePattern = p.Pattern @@ -210,7 +210,7 @@ func (p *Path) helpCallback(req *vault.Request, data *FieldData) (*vault.Respons return nil, fmt.Errorf("error executing template: %s", err) } - return vault.HelpResponse(buf.String(), nil), nil + return logical.HelpResponse(buf.String(), nil), nil } // FieldSchema is a basic schema to describe the format of a path field. diff --git a/helper/backend/backend_test.go b/helper/backend/backend_test.go index b1631b7040..7304c6ae07 100644 --- a/helper/backend/backend_test.go +++ b/helper/backend/backend_test.go @@ -4,7 +4,7 @@ import ( "reflect" "testing" - "github.com/hashicorp/vault/vault" + "github.com/hashicorp/vault/logical" ) func BenchmarkBackendRoute(b *testing.B) { @@ -36,12 +36,12 @@ func BenchmarkBackendRoute(b *testing.B) { } func TestBackend_impl(t *testing.T) { - var _ vault.LogicalBackend = new(Backend) + var _ logical.Backend = new(Backend) } func TestBackendHandleRequest(t *testing.T) { - callback := func(req *vault.Request, data *FieldData) (*vault.Response, error) { - return &vault.Response{ + callback := func(req *logical.Request, data *FieldData) (*logical.Response, error) { + return &logical.Response{ Data: map[string]interface{}{ "value": data.Get("value"), }, @@ -55,15 +55,15 @@ func TestBackendHandleRequest(t *testing.T) { Fields: map[string]*FieldSchema{ "value": &FieldSchema{Type: TypeInt}, }, - Callbacks: map[vault.Operation]OperationFunc{ - vault.ReadOperation: callback, + Callbacks: map[logical.Operation]OperationFunc{ + logical.ReadOperation: callback, }, }, }, } - resp, err := b.HandleRequest(&vault.Request{ - Operation: vault.ReadOperation, + resp, err := b.HandleRequest(&logical.Request{ + Operation: logical.ReadOperation, Path: "foo/bar", Data: map[string]interface{}{"value": "42"}, }) @@ -76,8 +76,8 @@ func TestBackendHandleRequest(t *testing.T) { } func TestBackendHandleRequest_404(t *testing.T) { - callback := func(req *vault.Request, data *FieldData) (*vault.Response, error) { - return &vault.Response{ + callback := func(req *logical.Request, data *FieldData) (*logical.Response, error) { + return &logical.Response{ Data: map[string]interface{}{ "value": data.Get("value"), }, @@ -91,19 +91,19 @@ func TestBackendHandleRequest_404(t *testing.T) { Fields: map[string]*FieldSchema{ "value": &FieldSchema{Type: TypeInt}, }, - Callbacks: map[vault.Operation]OperationFunc{ - vault.ReadOperation: callback, + Callbacks: map[logical.Operation]OperationFunc{ + logical.ReadOperation: callback, }, }, }, } - _, err := b.HandleRequest(&vault.Request{ - Operation: vault.ReadOperation, + _, err := b.HandleRequest(&logical.Request{ + Operation: logical.ReadOperation, Path: "foo/baz", Data: map[string]interface{}{"value": "84"}, }) - if err != vault.ErrUnsupportedPath { + if err != logical.ErrUnsupportedPath { t.Fatalf("err: %s", err) } } @@ -122,8 +122,8 @@ func TestBackendHandleRequest_help(t *testing.T) { }, } - resp, err := b.HandleRequest(&vault.Request{ - Operation: vault.HelpOperation, + resp, err := b.HandleRequest(&logical.Request{ + Operation: logical.HelpOperation, Path: "foo/bar", Data: map[string]interface{}{"value": "42"}, }) @@ -136,8 +136,8 @@ func TestBackendHandleRequest_help(t *testing.T) { } func TestBackendHandleRequest_unsupportedOperation(t *testing.T) { - callback := func(req *vault.Request, data *FieldData) (*vault.Response, error) { - return &vault.Response{ + callback := func(req *logical.Request, data *FieldData) (*logical.Response, error) { + return &logical.Response{ Data: map[string]interface{}{ "value": data.Get("value"), }, @@ -151,26 +151,26 @@ func TestBackendHandleRequest_unsupportedOperation(t *testing.T) { Fields: map[string]*FieldSchema{ "value": &FieldSchema{Type: TypeInt}, }, - Callbacks: map[vault.Operation]OperationFunc{ - vault.ReadOperation: callback, + Callbacks: map[logical.Operation]OperationFunc{ + logical.ReadOperation: callback, }, }, }, } - _, err := b.HandleRequest(&vault.Request{ - Operation: vault.WriteOperation, + _, err := b.HandleRequest(&logical.Request{ + Operation: logical.WriteOperation, Path: "foo/bar", Data: map[string]interface{}{"value": "84"}, }) - if err != vault.ErrUnsupportedOperation { + if err != logical.ErrUnsupportedOperation { t.Fatalf("err: %s", err) } } func TestBackendHandleRequest_urlPriority(t *testing.T) { - callback := func(req *vault.Request, data *FieldData) (*vault.Response, error) { - return &vault.Response{ + callback := func(req *logical.Request, data *FieldData) (*logical.Response, error) { + return &logical.Response{ Data: map[string]interface{}{ "value": data.Get("value"), }, @@ -184,15 +184,15 @@ func TestBackendHandleRequest_urlPriority(t *testing.T) { Fields: map[string]*FieldSchema{ "value": &FieldSchema{Type: TypeInt}, }, - Callbacks: map[vault.Operation]OperationFunc{ - vault.ReadOperation: callback, + Callbacks: map[logical.Operation]OperationFunc{ + logical.ReadOperation: callback, }, }, }, } - resp, err := b.HandleRequest(&vault.Request{ - Operation: vault.ReadOperation, + resp, err := b.HandleRequest(&logical.Request{ + Operation: logical.ReadOperation, Path: "foo/42", Data: map[string]interface{}{"value": "84"}, }) diff --git a/helper/backend/testing.go b/helper/backend/testing.go index 814fde7d09..e16d2aa7bc 100644 --- a/helper/backend/testing.go +++ b/helper/backend/testing.go @@ -5,7 +5,7 @@ import ( "os" "testing" - "github.com/hashicorp/vault/vault" + "github.com/hashicorp/vault/logical" ) // TestEnvVar must be set to a non-empty value for acceptance tests to run. @@ -21,7 +21,7 @@ type TestCase struct { PreCheck func() // Backend is the backend that will be mounted. - Backend vault.LogicalBackend + Backend logical.Backend // Steps are the set of operations that are run for this test case. Steps []TestStep @@ -36,7 +36,7 @@ type TestCase struct { // TestStep is a single step within a TestCase. type TestStep struct { // Operation is the operation to execute - Operation vault.Operation + Operation logical.Operation // Path is the request path. The mount prefix will be automatically added. Path string @@ -51,7 +51,7 @@ type TestStep struct { } // TestCheckFunc is the callback used for Check in TestStep. -type TestCheckFunc func(*vault.Response) error +type TestCheckFunc func(*logical.Response) error // TestTeardownFunc is the callback used for Teardown in TestCase. type TestTeardownFunc func() error