[lxc-devel] [lxd/master] Unexport some functions in main package

[tomponline on Github]

A non-text attachment was scrubbed...
Name: not available
Type: text/x-mailbox
Size: 366 bytes
Desc: not available
URL: <http://lists.linuxcontainers.org/pipermail/lxc-devel/attachments/20200316/cec38f33/attachment-0001.bin>
-------------- next part --------------
From b155380992671d8b1f1e894fe065039a41e33992 Mon Sep 17 00:00:00 2001
From: Thomas Parrott <thomas.parrott at canonical.com>
Date: Mon, 16 Mar 2020 16:51:11 +0000
Subject: [PATCH 1/9] lxd: Unexport NewMigrationSource

Signed-off-by: Thomas Parrott <thomas.parrott at canonical.com>
---
 lxd/instance_post.go     | 2 +-
 lxd/instance_snapshot.go | 2 +-
 lxd/migrate_instance.go  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/lxd/instance_post.go b/lxd/instance_post.go
index 069c3ba0ef..66e6940549 100644
--- a/lxd/instance_post.go
+++ b/lxd/instance_post.go
@@ -206,7 +206,7 @@ func containerPost(d *Daemon, r *http.Request) response.Response {
 		}
 
 		instanceOnly := req.InstanceOnly || req.ContainerOnly
-		ws, err := NewMigrationSource(inst, stateful, instanceOnly)
+		ws, err := newMigrationSource(inst, stateful, instanceOnly)
 		if err != nil {
 			return response.InternalError(err)
 		}
diff --git a/lxd/instance_snapshot.go b/lxd/instance_snapshot.go
index c6d577f901..53b17b0868 100644
--- a/lxd/instance_snapshot.go
+++ b/lxd/instance_snapshot.go
@@ -358,7 +358,7 @@ func snapshotPost(d *Daemon, r *http.Request, sc instance.Instance, containerNam
 			}
 		}
 
-		ws, err := NewMigrationSource(sc, reqNew.Live, true)
+		ws, err := newMigrationSource(sc, reqNew.Live, true)
 		if err != nil {
 			return response.SmartError(err)
 		}
diff --git a/lxd/migrate_instance.go b/lxd/migrate_instance.go
index b7110c2776..32313d2378 100644
--- a/lxd/migrate_instance.go
+++ b/lxd/migrate_instance.go
@@ -31,7 +31,7 @@ import (
 	"github.com/lxc/lxd/shared/logger"
 )
 
-func NewMigrationSource(inst instance.Instance, stateful bool, instanceOnly bool) (*migrationSourceWs, error) {
+func newMigrationSource(inst instance.Instance, stateful bool, instanceOnly bool) (*migrationSourceWs, error) {
 	ret := migrationSourceWs{migrationFields{instance: inst}, make(chan bool, 1)}
 	ret.instanceOnly = instanceOnly
 

From 894cd8dcb65f2f06985181f7ae0605055cd9b55e Mon Sep 17 00:00:00 2001
From: Thomas Parrott <thomas.parrott at canonical.com>
Date: Mon, 16 Mar 2020 16:52:02 +0000
Subject: [PATCH 2/9] lxd: Unexport NewDaemon

Signed-off-by: Thomas Parrott <thomas.parrott at canonical.com>
---
 lxd/daemon.go      | 4 ++--
 lxd/main_daemon.go | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/lxd/daemon.go b/lxd/daemon.go
index 9de17fb9e6..783ab7a3f1 100644
--- a/lxd/daemon.go
+++ b/lxd/daemon.go
@@ -146,7 +146,7 @@ func (m *IdentityClientWrapper) DeclaredIdentity(ctx context.Context, declared m
 }
 
 // NewDaemon returns a new Daemon object with the given configuration.
-func NewDaemon(config *DaemonConfig, os *sys.OS) *Daemon {
+func newDaemon(config *DaemonConfig, os *sys.OS) *Daemon {
 	lxdEvents := events.NewServer(daemon.Debug, daemon.Verbose)
 	devlxdEvents := events.NewServer(daemon.Debug, daemon.Verbose)
 
@@ -173,7 +173,7 @@ func DefaultDaemonConfig() *DaemonConfig {
 func DefaultDaemon() *Daemon {
 	config := DefaultDaemonConfig()
 	os := sys.DefaultOS()
-	return NewDaemon(config, os)
+	return newDaemon(config, os)
 }
 
 // APIEndpoint represents a URL in our API.
diff --git a/lxd/main_daemon.go b/lxd/main_daemon.go
index 69fddf8cd5..2680a12795 100644
--- a/lxd/main_daemon.go
+++ b/lxd/main_daemon.go
@@ -60,7 +60,7 @@ func (c *cmdDaemon) Run(cmd *cobra.Command, args []string) error {
 	conf := DefaultDaemonConfig()
 	conf.Group = c.flagGroup
 	conf.Trace = c.global.flagLogTrace
-	d := NewDaemon(conf, sys.DefaultOS())
+	d := newDaemon(conf, sys.DefaultOS())
 
 	err := d.Init()
 	if err != nil {

From 9595d4b5cc285a5fec4d6e04b3466739a48132bd Mon Sep 17 00:00:00 2001
From: Thomas Parrott <thomas.parrott at canonical.com>
Date: Mon, 16 Mar 2020 16:52:50 +0000
Subject: [PATCH 3/9] lxd: Unexport RestServer

Signed-off-by: Thomas Parrott <thomas.parrott at canonical.com>
---
 lxd/api.go    | 5 ++---
 lxd/daemon.go | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/lxd/api.go b/lxd/api.go
index 8f5a8316d0..70438ca6a5 100644
--- a/lxd/api.go
+++ b/lxd/api.go
@@ -15,9 +15,8 @@ import (
 	"github.com/lxc/lxd/shared/logger"
 )
 
-// RestServer creates an http.Server capable of handling requests against the LXD REST
-// API endpoint.
-func RestServer(d *Daemon) *http.Server {
+// RestServer creates an http.Server capable of handling requests against the LXD REST API endpoint.
+func restServer(d *Daemon) *http.Server {
 	/* Setup the web server */
 	mux := mux.NewRouter()
 	mux.StrictSlash(false)
diff --git a/lxd/daemon.go b/lxd/daemon.go
index 783ab7a3f1..b2d8d2c5bb 100644
--- a/lxd/daemon.go
+++ b/lxd/daemon.go
@@ -724,7 +724,7 @@ func (d *Daemon) init() error {
 		Dir:                  d.os.VarDir,
 		UnixSocket:           d.UnixSocket(),
 		Cert:                 certInfo,
-		RestServer:           RestServer(d),
+		RestServer:           restServer(d),
 		DevLxdServer:         DevLxdServer(d),
 		LocalUnixSocketGroup: d.config.Group,
 		NetworkAddress:       address,

From 338cefaeb5d8f7a48fb7d2c95f081f2f9e5b8a5d Mon Sep 17 00:00:00 2001
From: Thomas Parrott <thomas.parrott at canonical.com>
Date: Mon, 16 Mar 2020 16:53:49 +0000
Subject: [PATCH 4/9] lxd: Unexport DefaultDaemonConfig and DefaultDaemon

Signed-off-by: Thomas Parrott <thomas.parrott at canonical.com>
---
 lxd/daemon.go                | 8 ++++----
 lxd/main_activateifneeded.go | 2 +-
 lxd/main_daemon.go           | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/lxd/daemon.go b/lxd/daemon.go
index b2d8d2c5bb..37db4f1146 100644
--- a/lxd/daemon.go
+++ b/lxd/daemon.go
@@ -161,8 +161,8 @@ func newDaemon(config *DaemonConfig, os *sys.OS) *Daemon {
 	}
 }
 
-// DefaultDaemonConfig returns a DaemonConfig object with default values/
-func DefaultDaemonConfig() *DaemonConfig {
+// DefaultDaemonConfig returns a DaemonConfig object with default values.
+func defaultDaemonConfig() *DaemonConfig {
 	return &DaemonConfig{
 		RaftLatency:        3.0,
 		DqliteSetupTimeout: 36 * time.Hour, // Account for snap refresh lag
@@ -170,8 +170,8 @@ func DefaultDaemonConfig() *DaemonConfig {
 }
 
 // DefaultDaemon returns a new, un-initialized Daemon object with default values.
-func DefaultDaemon() *Daemon {
-	config := DefaultDaemonConfig()
+func defaultDaemon() *Daemon {
+	config := defaultDaemonConfig()
 	os := sys.DefaultOS()
 	return newDaemon(config, os)
 }
diff --git a/lxd/main_activateifneeded.go b/lxd/main_activateifneeded.go
index 1322c12f4a..99331ead84 100644
--- a/lxd/main_activateifneeded.go
+++ b/lxd/main_activateifneeded.go
@@ -52,7 +52,7 @@ func (c *cmdActivateifneeded) Run(cmd *cobra.Command, args []string) error {
 	}
 
 	// Don't start a full daemon, we just need DB access
-	d := DefaultDaemon()
+	d := defaultDaemon()
 
 	// Check if either the local database or the legacy local database
 	// files exists.
diff --git a/lxd/main_daemon.go b/lxd/main_daemon.go
index 2680a12795..2f041a3c51 100644
--- a/lxd/main_daemon.go
+++ b/lxd/main_daemon.go
@@ -57,7 +57,7 @@ func (c *cmdDaemon) Run(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	conf := DefaultDaemonConfig()
+	conf := defaultDaemonConfig()
 	conf.Group = c.flagGroup
 	conf.Trace = c.global.flagLogTrace
 	d := newDaemon(conf, sys.DefaultOS())

From 0c0c0ffdbbfdbc8bd4e1c0b7eba31f9770ea536e Mon Sep 17 00:00:00 2001
From: Thomas Parrott <thomas.parrott at canonical.com>
Date: Mon, 16 Mar 2020 16:55:50 +0000
Subject: [PATCH 5/9] lxd: Unexports AllowAuthenticated and
 AllowProjectPermission

Signed-off-by: Thomas Parrott <thomas.parrott at canonical.com>
---
 lxd/api_cluster.go              |  6 +--
 lxd/api_project.go              |  8 ++--
 lxd/certificates.go             |  4 +-
 lxd/daemon.go                   |  8 ++--
 lxd/events.go                   |  2 +-
 lxd/images.go                   | 32 ++++++++--------
 lxd/instance_logs.go            |  6 +--
 lxd/instances.go                | 68 ++++++++++++++++-----------------
 lxd/networks.go                 |  8 ++--
 lxd/operations.go               |  8 ++--
 lxd/profiles.go                 | 14 +++----
 lxd/resources.go                |  4 +-
 lxd/storage_pools.go            |  4 +-
 lxd/storage_volumes.go          | 48 +++++++++++------------
 lxd/storage_volumes_snapshot.go | 12 +++---
 15 files changed, 116 insertions(+), 116 deletions(-)

diff --git a/lxd/api_cluster.go b/lxd/api_cluster.go
index 2a668faab1..15b67a585a 100644
--- a/lxd/api_cluster.go
+++ b/lxd/api_cluster.go
@@ -32,21 +32,21 @@ import (
 var clusterCmd = APIEndpoint{
 	Path: "cluster",
 
-	Get: APIEndpointAction{Handler: clusterGet, AccessHandler: AllowAuthenticated},
+	Get: APIEndpointAction{Handler: clusterGet, AccessHandler: allowAuthenticated},
 	Put: APIEndpointAction{Handler: clusterPut},
 }
 
 var clusterNodesCmd = APIEndpoint{
 	Path: "cluster/members",
 
-	Get: APIEndpointAction{Handler: clusterNodesGet, AccessHandler: AllowAuthenticated},
+	Get: APIEndpointAction{Handler: clusterNodesGet, AccessHandler: allowAuthenticated},
 }
 
 var clusterNodeCmd = APIEndpoint{
 	Path: "cluster/members/{name}",
 
 	Delete: APIEndpointAction{Handler: clusterNodeDelete},
-	Get:    APIEndpointAction{Handler: clusterNodeGet, AccessHandler: AllowAuthenticated},
+	Get:    APIEndpointAction{Handler: clusterNodeGet, AccessHandler: allowAuthenticated},
 	Post:   APIEndpointAction{Handler: clusterNodePost},
 }
 
diff --git a/lxd/api_project.go b/lxd/api_project.go
index dc70c31d16..4630daf26c 100644
--- a/lxd/api_project.go
+++ b/lxd/api_project.go
@@ -26,7 +26,7 @@ var projectFeatures = []string{"features.images", "features.profiles", "features
 var projectsCmd = APIEndpoint{
 	Path: "projects",
 
-	Get:  APIEndpointAction{Handler: projectsGet, AccessHandler: AllowAuthenticated},
+	Get:  APIEndpointAction{Handler: projectsGet, AccessHandler: allowAuthenticated},
 	Post: APIEndpointAction{Handler: projectsPost},
 }
 
@@ -34,10 +34,10 @@ var projectCmd = APIEndpoint{
 	Path: "projects/{name}",
 
 	Delete: APIEndpointAction{Handler: projectDelete},
-	Get:    APIEndpointAction{Handler: projectGet, AccessHandler: AllowAuthenticated},
-	Patch:  APIEndpointAction{Handler: projectPatch, AccessHandler: AllowAuthenticated},
+	Get:    APIEndpointAction{Handler: projectGet, AccessHandler: allowAuthenticated},
+	Patch:  APIEndpointAction{Handler: projectPatch, AccessHandler: allowAuthenticated},
 	Post:   APIEndpointAction{Handler: projectPost},
-	Put:    APIEndpointAction{Handler: projectPut, AccessHandler: AllowAuthenticated},
+	Put:    APIEndpointAction{Handler: projectPut, AccessHandler: allowAuthenticated},
 }
 
 func projectsGet(d *Daemon, r *http.Request) response.Response {
diff --git a/lxd/certificates.go b/lxd/certificates.go
index bd18e8cee4..a236770bb1 100644
--- a/lxd/certificates.go
+++ b/lxd/certificates.go
@@ -28,7 +28,7 @@ import (
 var certificatesCmd = APIEndpoint{
 	Path: "certificates",
 
-	Get:  APIEndpointAction{Handler: certificatesGet, AccessHandler: AllowAuthenticated},
+	Get:  APIEndpointAction{Handler: certificatesGet, AccessHandler: allowAuthenticated},
 	Post: APIEndpointAction{Handler: certificatesPost, AllowUntrusted: true},
 }
 
@@ -36,7 +36,7 @@ var certificateCmd = APIEndpoint{
 	Path: "certificates/{fingerprint}",
 
 	Delete: APIEndpointAction{Handler: certificateDelete},
-	Get:    APIEndpointAction{Handler: certificateGet, AccessHandler: AllowAuthenticated},
+	Get:    APIEndpointAction{Handler: certificateGet, AccessHandler: allowAuthenticated},
 	Patch:  APIEndpointAction{Handler: certificatePatch},
 	Put:    APIEndpointAction{Handler: certificatePut},
 }
diff --git a/lxd/daemon.go b/lxd/daemon.go
index 37db4f1146..7e284c7661 100644
--- a/lxd/daemon.go
+++ b/lxd/daemon.go
@@ -201,16 +201,16 @@ type APIEndpointAction struct {
 	AllowUntrusted bool
 }
 
-// AllowAuthenticated is a AccessHandler which allows all requests.
+// allowAuthenticated is an AccessHandler which allows all requests.
 // This function doesn't do anything itself, except return the EmptySyncResponse that allows the request to
 // proceed. However in order to access any API route you must be authenticated, unless the handler's AllowUntrusted
 // property is set to true or you are an admin.
-func AllowAuthenticated(d *Daemon, r *http.Request) response.Response {
+func allowAuthenticated(d *Daemon, r *http.Request) response.Response {
 	return response.EmptySyncResponse
 }
 
-// AllowProjectPermission is a wrapper to check access against the project, its features and RBAC permission
-func AllowProjectPermission(feature string, permission string) func(d *Daemon, r *http.Request) response.Response {
+// allowProjectPermission is a wrapper to check access against the project, its features and RBAC permission
+func allowProjectPermission(feature string, permission string) func(d *Daemon, r *http.Request) response.Response {
 	return func(d *Daemon, r *http.Request) response.Response {
 		// Shortcut for speed
 		if d.userIsAdmin(r) {
diff --git a/lxd/events.go b/lxd/events.go
index e291f18da4..38b9760268 100644
--- a/lxd/events.go
+++ b/lxd/events.go
@@ -14,7 +14,7 @@ import (
 var eventsCmd = APIEndpoint{
 	Path: "events",
 
-	Get: APIEndpointAction{Handler: eventsGet, AccessHandler: AllowAuthenticated},
+	Get: APIEndpointAction{Handler: eventsGet, AccessHandler: allowAuthenticated},
 }
 
 type eventsServe struct {
diff --git a/lxd/images.go b/lxd/images.go
index bf3d166ad7..4ed760c364 100644
--- a/lxd/images.go
+++ b/lxd/images.go
@@ -52,16 +52,16 @@ var imagesCmd = APIEndpoint{
 	Path: "images",
 
 	Get:  APIEndpointAction{Handler: imagesGet, AllowUntrusted: true},
-	Post: APIEndpointAction{Handler: imagesPost, AccessHandler: AllowProjectPermission("images", "manage-images")},
+	Post: APIEndpointAction{Handler: imagesPost, AccessHandler: allowProjectPermission("images", "manage-images")},
 }
 
 var imageCmd = APIEndpoint{
 	Path: "images/{fingerprint}",
 
-	Delete: APIEndpointAction{Handler: imageDelete, AccessHandler: AllowProjectPermission("images", "manage-images")},
+	Delete: APIEndpointAction{Handler: imageDelete, AccessHandler: allowProjectPermission("images", "manage-images")},
 	Get:    APIEndpointAction{Handler: imageGet, AllowUntrusted: true},
-	Patch:  APIEndpointAction{Handler: imagePatch, AccessHandler: AllowProjectPermission("images", "manage-images")},
-	Put:    APIEndpointAction{Handler: imagePut, AccessHandler: AllowProjectPermission("images", "manage-images")},
+	Patch:  APIEndpointAction{Handler: imagePatch, AccessHandler: allowProjectPermission("images", "manage-images")},
+	Put:    APIEndpointAction{Handler: imagePut, AccessHandler: allowProjectPermission("images", "manage-images")},
 }
 
 var imageExportCmd = APIEndpoint{
@@ -73,30 +73,30 @@ var imageExportCmd = APIEndpoint{
 var imageSecretCmd = APIEndpoint{
 	Path: "images/{fingerprint}/secret",
 
-	Post: APIEndpointAction{Handler: imageSecret, AccessHandler: AllowProjectPermission("images", "view")},
+	Post: APIEndpointAction{Handler: imageSecret, AccessHandler: allowProjectPermission("images", "view")},
 }
 
 var imageRefreshCmd = APIEndpoint{
 	Path: "images/{fingerprint}/refresh",
 
-	Post: APIEndpointAction{Handler: imageRefresh, AccessHandler: AllowProjectPermission("images", "manage-images")},
+	Post: APIEndpointAction{Handler: imageRefresh, AccessHandler: allowProjectPermission("images", "manage-images")},
 }
 
 var imageAliasesCmd = APIEndpoint{
 	Path: "images/aliases",
 
-	Get:  APIEndpointAction{Handler: imageAliasesGet, AccessHandler: AllowProjectPermission("images", "view")},
-	Post: APIEndpointAction{Handler: imageAliasesPost, AccessHandler: AllowProjectPermission("images", "manage-images")},
+	Get:  APIEndpointAction{Handler: imageAliasesGet, AccessHandler: allowProjectPermission("images", "view")},
+	Post: APIEndpointAction{Handler: imageAliasesPost, AccessHandler: allowProjectPermission("images", "manage-images")},
 }
 
 var imageAliasCmd = APIEndpoint{
 	Path: "images/aliases/{name:.*}",
 
-	Delete: APIEndpointAction{Handler: imageAliasDelete, AccessHandler: AllowProjectPermission("images", "manage-images")},
+	Delete: APIEndpointAction{Handler: imageAliasDelete, AccessHandler: allowProjectPermission("images", "manage-images")},
 	Get:    APIEndpointAction{Handler: imageAliasGet, AllowUntrusted: true},
-	Patch:  APIEndpointAction{Handler: imageAliasPatch, AccessHandler: AllowProjectPermission("images", "manage-images")},
-	Post:   APIEndpointAction{Handler: imageAliasPost, AccessHandler: AllowProjectPermission("images", "manage-images")},
-	Put:    APIEndpointAction{Handler: imageAliasPut, AccessHandler: AllowProjectPermission("images", "manage-images")},
+	Patch:  APIEndpointAction{Handler: imageAliasPatch, AccessHandler: allowProjectPermission("images", "manage-images")},
+	Post:   APIEndpointAction{Handler: imageAliasPost, AccessHandler: allowProjectPermission("images", "manage-images")},
+	Put:    APIEndpointAction{Handler: imageAliasPut, AccessHandler: allowProjectPermission("images", "manage-images")},
 }
 
 /* We only want a single publish running at any one time.
@@ -943,7 +943,7 @@ func doImagesGet(d *Daemon, recursion bool, project string, public bool, clauses
 func imagesGet(d *Daemon, r *http.Request) response.Response {
 	project := projectParam(r)
 	filterStr := r.FormValue("filter")
-	public := d.checkTrustedClient(r) != nil || AllowProjectPermission("images", "view")(d, r) != response.EmptySyncResponse
+	public := d.checkTrustedClient(r) != nil || allowProjectPermission("images", "view")(d, r) != response.EmptySyncResponse
 
 	var clauses []filter.Clause
 	if filterStr != "" {
@@ -1537,7 +1537,7 @@ func imageValidSecret(fingerprint string, secret string) bool {
 func imageGet(d *Daemon, r *http.Request) response.Response {
 	project := projectParam(r)
 	fingerprint := mux.Vars(r)["fingerprint"]
-	public := d.checkTrustedClient(r) != nil || AllowProjectPermission("images", "view")(d, r) != response.EmptySyncResponse
+	public := d.checkTrustedClient(r) != nil || allowProjectPermission("images", "view")(d, r) != response.EmptySyncResponse
 	secret := r.FormValue("secret")
 
 	info, resp := doImageGet(d.cluster, project, fingerprint, false)
@@ -1737,7 +1737,7 @@ func imageAliasesGet(d *Daemon, r *http.Request) response.Response {
 func imageAliasGet(d *Daemon, r *http.Request) response.Response {
 	project := projectParam(r)
 	name := mux.Vars(r)["name"]
-	public := d.checkTrustedClient(r) != nil || AllowProjectPermission("images", "view")(d, r) != response.EmptySyncResponse
+	public := d.checkTrustedClient(r) != nil || allowProjectPermission("images", "view")(d, r) != response.EmptySyncResponse
 
 	_, alias, err := d.cluster.ImageAliasGet(project, name, !public)
 	if err != nil {
@@ -1885,7 +1885,7 @@ func imageExport(d *Daemon, r *http.Request) response.Response {
 	project := projectParam(r)
 	fingerprint := mux.Vars(r)["fingerprint"]
 
-	public := d.checkTrustedClient(r) != nil || AllowProjectPermission("images", "view")(d, r) != response.EmptySyncResponse
+	public := d.checkTrustedClient(r) != nil || allowProjectPermission("images", "view")(d, r) != response.EmptySyncResponse
 	secret := r.FormValue("secret")
 
 	var imgInfo *api.Image
diff --git a/lxd/instance_logs.go b/lxd/instance_logs.go
index 5edac53ff3..1fc437ab1d 100644
--- a/lxd/instance_logs.go
+++ b/lxd/instance_logs.go
@@ -24,8 +24,8 @@ var instanceLogCmd = APIEndpoint{
 		{Name: "vmLog", Path: "virtual-machines/{name}/logs/{file}"},
 	},
 
-	Delete: APIEndpointAction{Handler: containerLogDelete, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
-	Get:    APIEndpointAction{Handler: containerLogGet, AccessHandler: AllowProjectPermission("containers", "view")},
+	Delete: APIEndpointAction{Handler: containerLogDelete, AccessHandler: allowProjectPermission("containers", "operate-containers")},
+	Get:    APIEndpointAction{Handler: containerLogGet, AccessHandler: allowProjectPermission("containers", "view")},
 }
 
 var instanceLogsCmd = APIEndpoint{
@@ -36,7 +36,7 @@ var instanceLogsCmd = APIEndpoint{
 		{Name: "vmLogs", Path: "virtual-machines/{name}/logs"},
 	},
 
-	Get: APIEndpointAction{Handler: containerLogsGet, AccessHandler: AllowProjectPermission("containers", "view")},
+	Get: APIEndpointAction{Handler: containerLogsGet, AccessHandler: allowProjectPermission("containers", "view")},
 }
 
 func containerLogsGet(d *Daemon, r *http.Request) response.Response {
diff --git a/lxd/instances.go b/lxd/instances.go
index 7f9a93d7ad..b7f8366daf 100644
--- a/lxd/instances.go
+++ b/lxd/instances.go
@@ -25,8 +25,8 @@ var instancesCmd = APIEndpoint{
 		{Name: "vms", Path: "virtual-machines"},
 	},
 
-	Get:  APIEndpointAction{Handler: containersGet, AccessHandler: AllowProjectPermission("containers", "view")},
-	Post: APIEndpointAction{Handler: containersPost, AccessHandler: AllowProjectPermission("containers", "manage-containers")},
+	Get:  APIEndpointAction{Handler: containersGet, AccessHandler: allowProjectPermission("containers", "view")},
+	Post: APIEndpointAction{Handler: containersPost, AccessHandler: allowProjectPermission("containers", "manage-containers")},
 }
 
 var instanceCmd = APIEndpoint{
@@ -37,11 +37,11 @@ var instanceCmd = APIEndpoint{
 		{Name: "vm", Path: "virtual-machines/{name}"},
 	},
 
-	Get:    APIEndpointAction{Handler: containerGet, AccessHandler: AllowProjectPermission("containers", "view")},
-	Put:    APIEndpointAction{Handler: containerPut, AccessHandler: AllowProjectPermission("containers", "manage-containers")},
-	Delete: APIEndpointAction{Handler: containerDelete, AccessHandler: AllowProjectPermission("containers", "manage-containers")},
-	Post:   APIEndpointAction{Handler: containerPost, AccessHandler: AllowProjectPermission("containers", "manage-containers")},
-	Patch:  APIEndpointAction{Handler: containerPatch, AccessHandler: AllowProjectPermission("containers", "manage-containers")},
+	Get:    APIEndpointAction{Handler: containerGet, AccessHandler: allowProjectPermission("containers", "view")},
+	Put:    APIEndpointAction{Handler: containerPut, AccessHandler: allowProjectPermission("containers", "manage-containers")},
+	Delete: APIEndpointAction{Handler: containerDelete, AccessHandler: allowProjectPermission("containers", "manage-containers")},
+	Post:   APIEndpointAction{Handler: containerPost, AccessHandler: allowProjectPermission("containers", "manage-containers")},
+	Patch:  APIEndpointAction{Handler: containerPatch, AccessHandler: allowProjectPermission("containers", "manage-containers")},
 }
 
 var instanceStateCmd = APIEndpoint{
@@ -52,8 +52,8 @@ var instanceStateCmd = APIEndpoint{
 		{Name: "vmState", Path: "virtual-machines/{name}/state"},
 	},
 
-	Get: APIEndpointAction{Handler: containerState, AccessHandler: AllowProjectPermission("containers", "view")},
-	Put: APIEndpointAction{Handler: containerStatePut, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
+	Get: APIEndpointAction{Handler: containerState, AccessHandler: allowProjectPermission("containers", "view")},
+	Put: APIEndpointAction{Handler: containerStatePut, AccessHandler: allowProjectPermission("containers", "operate-containers")},
 }
 
 var instanceFileCmd = APIEndpoint{
@@ -64,9 +64,9 @@ var instanceFileCmd = APIEndpoint{
 		{Name: "vmFile", Path: "virtual-machines/{name}/files"},
 	},
 
-	Get:    APIEndpointAction{Handler: containerFileHandler, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
-	Post:   APIEndpointAction{Handler: containerFileHandler, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
-	Delete: APIEndpointAction{Handler: containerFileHandler, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
+	Get:    APIEndpointAction{Handler: containerFileHandler, AccessHandler: allowProjectPermission("containers", "operate-containers")},
+	Post:   APIEndpointAction{Handler: containerFileHandler, AccessHandler: allowProjectPermission("containers", "operate-containers")},
+	Delete: APIEndpointAction{Handler: containerFileHandler, AccessHandler: allowProjectPermission("containers", "operate-containers")},
 }
 
 var instanceSnapshotsCmd = APIEndpoint{
@@ -77,8 +77,8 @@ var instanceSnapshotsCmd = APIEndpoint{
 		{Name: "vmSnapshots", Path: "virtual-machines/{name}/snapshots"},
 	},
 
-	Get:  APIEndpointAction{Handler: containerSnapshotsGet, AccessHandler: AllowProjectPermission("containers", "view")},
-	Post: APIEndpointAction{Handler: containerSnapshotsPost, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
+	Get:  APIEndpointAction{Handler: containerSnapshotsGet, AccessHandler: allowProjectPermission("containers", "view")},
+	Post: APIEndpointAction{Handler: containerSnapshotsPost, AccessHandler: allowProjectPermission("containers", "operate-containers")},
 }
 
 var instanceSnapshotCmd = APIEndpoint{
@@ -89,10 +89,10 @@ var instanceSnapshotCmd = APIEndpoint{
 		{Name: "vmSnapshot", Path: "virtual-machines/{name}/snapshots/{snapshotName}"},
 	},
 
-	Get:    APIEndpointAction{Handler: containerSnapshotHandler, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
-	Post:   APIEndpointAction{Handler: containerSnapshotHandler, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
-	Delete: APIEndpointAction{Handler: containerSnapshotHandler, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
-	Put:    APIEndpointAction{Handler: containerSnapshotHandler, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
+	Get:    APIEndpointAction{Handler: containerSnapshotHandler, AccessHandler: allowProjectPermission("containers", "operate-containers")},
+	Post:   APIEndpointAction{Handler: containerSnapshotHandler, AccessHandler: allowProjectPermission("containers", "operate-containers")},
+	Delete: APIEndpointAction{Handler: containerSnapshotHandler, AccessHandler: allowProjectPermission("containers", "operate-containers")},
+	Put:    APIEndpointAction{Handler: containerSnapshotHandler, AccessHandler: allowProjectPermission("containers", "operate-containers")},
 }
 
 var instanceConsoleCmd = APIEndpoint{
@@ -103,9 +103,9 @@ var instanceConsoleCmd = APIEndpoint{
 		{Name: "vmConsole", Path: "virtual-machines/{name}/console"},
 	},
 
-	Get:    APIEndpointAction{Handler: containerConsoleLogGet, AccessHandler: AllowProjectPermission("containers", "view")},
-	Post:   APIEndpointAction{Handler: containerConsolePost, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
-	Delete: APIEndpointAction{Handler: containerConsoleLogDelete, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
+	Get:    APIEndpointAction{Handler: containerConsoleLogGet, AccessHandler: allowProjectPermission("containers", "view")},
+	Post:   APIEndpointAction{Handler: containerConsolePost, AccessHandler: allowProjectPermission("containers", "operate-containers")},
+	Delete: APIEndpointAction{Handler: containerConsoleLogDelete, AccessHandler: allowProjectPermission("containers", "operate-containers")},
 }
 
 var instanceExecCmd = APIEndpoint{
@@ -116,7 +116,7 @@ var instanceExecCmd = APIEndpoint{
 		{Name: "vmExec", Path: "virtual-machines/{name}/exec"},
 	},
 
-	Post: APIEndpointAction{Handler: containerExecPost, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
+	Post: APIEndpointAction{Handler: containerExecPost, AccessHandler: allowProjectPermission("containers", "operate-containers")},
 }
 
 var instanceMetadataCmd = APIEndpoint{
@@ -127,8 +127,8 @@ var instanceMetadataCmd = APIEndpoint{
 		{Name: "vmMetadata", Path: "virtual-machines/{name}/metadata"},
 	},
 
-	Get: APIEndpointAction{Handler: containerMetadataGet, AccessHandler: AllowProjectPermission("containers", "view")},
-	Put: APIEndpointAction{Handler: containerMetadataPut, AccessHandler: AllowProjectPermission("containers", "manage-containers")},
+	Get: APIEndpointAction{Handler: containerMetadataGet, AccessHandler: allowProjectPermission("containers", "view")},
+	Put: APIEndpointAction{Handler: containerMetadataPut, AccessHandler: allowProjectPermission("containers", "manage-containers")},
 }
 
 var instanceMetadataTemplatesCmd = APIEndpoint{
@@ -139,10 +139,10 @@ var instanceMetadataTemplatesCmd = APIEndpoint{
 		{Name: "vmMetadataTemplates", Path: "virtual-machines/{name}/metadata/templates"},
 	},
 
-	Get:    APIEndpointAction{Handler: containerMetadataTemplatesGet, AccessHandler: AllowProjectPermission("containers", "view")},
-	Post:   APIEndpointAction{Handler: containerMetadataTemplatesPostPut, AccessHandler: AllowProjectPermission("containers", "manage-containers")},
-	Put:    APIEndpointAction{Handler: containerMetadataTemplatesPostPut, AccessHandler: AllowProjectPermission("containers", "manage-containers")},
-	Delete: APIEndpointAction{Handler: containerMetadataTemplatesDelete, AccessHandler: AllowProjectPermission("containers", "manage-containers")},
+	Get:    APIEndpointAction{Handler: containerMetadataTemplatesGet, AccessHandler: allowProjectPermission("containers", "view")},
+	Post:   APIEndpointAction{Handler: containerMetadataTemplatesPostPut, AccessHandler: allowProjectPermission("containers", "manage-containers")},
+	Put:    APIEndpointAction{Handler: containerMetadataTemplatesPostPut, AccessHandler: allowProjectPermission("containers", "manage-containers")},
+	Delete: APIEndpointAction{Handler: containerMetadataTemplatesDelete, AccessHandler: allowProjectPermission("containers", "manage-containers")},
 }
 
 var instanceBackupsCmd = APIEndpoint{
@@ -153,8 +153,8 @@ var instanceBackupsCmd = APIEndpoint{
 		{Name: "vmBackups", Path: "virtual-machines/{name}/backups"},
 	},
 
-	Get:  APIEndpointAction{Handler: containerBackupsGet, AccessHandler: AllowProjectPermission("containers", "view")},
-	Post: APIEndpointAction{Handler: containerBackupsPost, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
+	Get:  APIEndpointAction{Handler: containerBackupsGet, AccessHandler: allowProjectPermission("containers", "view")},
+	Post: APIEndpointAction{Handler: containerBackupsPost, AccessHandler: allowProjectPermission("containers", "operate-containers")},
 }
 
 var instanceBackupCmd = APIEndpoint{
@@ -165,9 +165,9 @@ var instanceBackupCmd = APIEndpoint{
 		{Name: "vmBackup", Path: "virtual-machines/{name}/backups/{backupName}"},
 	},
 
-	Get:    APIEndpointAction{Handler: containerBackupGet, AccessHandler: AllowProjectPermission("containers", "view")},
-	Post:   APIEndpointAction{Handler: containerBackupPost, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
-	Delete: APIEndpointAction{Handler: containerBackupDelete, AccessHandler: AllowProjectPermission("containers", "operate-containers")},
+	Get:    APIEndpointAction{Handler: containerBackupGet, AccessHandler: allowProjectPermission("containers", "view")},
+	Post:   APIEndpointAction{Handler: containerBackupPost, AccessHandler: allowProjectPermission("containers", "operate-containers")},
+	Delete: APIEndpointAction{Handler: containerBackupDelete, AccessHandler: allowProjectPermission("containers", "operate-containers")},
 }
 
 var instanceBackupExportCmd = APIEndpoint{
@@ -178,7 +178,7 @@ var instanceBackupExportCmd = APIEndpoint{
 		{Name: "vmBackupExport", Path: "virtual-machines/{name}/backups/{backupName}/export"},
 	},
 
-	Get: APIEndpointAction{Handler: containerBackupExportGet, AccessHandler: AllowProjectPermission("containers", "view")},
+	Get: APIEndpointAction{Handler: containerBackupExportGet, AccessHandler: allowProjectPermission("containers", "view")},
 }
 
 type containerAutostartList []instance.Instance
diff --git a/lxd/networks.go b/lxd/networks.go
index 57a5e71d1c..43d60cda78 100644
--- a/lxd/networks.go
+++ b/lxd/networks.go
@@ -35,7 +35,7 @@ var networkCreateLock sync.Mutex
 var networksCmd = APIEndpoint{
 	Path: "networks",
 
-	Get:  APIEndpointAction{Handler: networksGet, AccessHandler: AllowAuthenticated},
+	Get:  APIEndpointAction{Handler: networksGet, AccessHandler: allowAuthenticated},
 	Post: APIEndpointAction{Handler: networksPost},
 }
 
@@ -43,7 +43,7 @@ var networkCmd = APIEndpoint{
 	Path: "networks/{name}",
 
 	Delete: APIEndpointAction{Handler: networkDelete},
-	Get:    APIEndpointAction{Handler: networkGet, AccessHandler: AllowAuthenticated},
+	Get:    APIEndpointAction{Handler: networkGet, AccessHandler: allowAuthenticated},
 	Patch:  APIEndpointAction{Handler: networkPatch},
 	Post:   APIEndpointAction{Handler: networkPost},
 	Put:    APIEndpointAction{Handler: networkPut},
@@ -52,13 +52,13 @@ var networkCmd = APIEndpoint{
 var networkLeasesCmd = APIEndpoint{
 	Path: "networks/{name}/leases",
 
-	Get: APIEndpointAction{Handler: networkLeasesGet, AccessHandler: AllowAuthenticated},
+	Get: APIEndpointAction{Handler: networkLeasesGet, AccessHandler: allowAuthenticated},
 }
 
 var networkStateCmd = APIEndpoint{
 	Path: "networks/{name}/state",
 
-	Get: APIEndpointAction{Handler: networkStateGet, AccessHandler: AllowAuthenticated},
+	Get: APIEndpointAction{Handler: networkStateGet, AccessHandler: allowAuthenticated},
 }
 
 // API endpoints
diff --git a/lxd/operations.go b/lxd/operations.go
index 423e466b2c..5d748ed89a 100644
--- a/lxd/operations.go
+++ b/lxd/operations.go
@@ -22,20 +22,20 @@ import (
 var operationCmd = APIEndpoint{
 	Path: "operations/{id}",
 
-	Delete: APIEndpointAction{Handler: operationDelete, AccessHandler: AllowAuthenticated},
-	Get:    APIEndpointAction{Handler: operationGet, AccessHandler: AllowAuthenticated},
+	Delete: APIEndpointAction{Handler: operationDelete, AccessHandler: allowAuthenticated},
+	Get:    APIEndpointAction{Handler: operationGet, AccessHandler: allowAuthenticated},
 }
 
 var operationsCmd = APIEndpoint{
 	Path: "operations",
 
-	Get: APIEndpointAction{Handler: operationsGet, AccessHandler: AllowAuthenticated},
+	Get: APIEndpointAction{Handler: operationsGet, AccessHandler: allowAuthenticated},
 }
 
 var operationWait = APIEndpoint{
 	Path: "operations/{id}/wait",
 
-	Get: APIEndpointAction{Handler: operationWaitGet, AccessHandler: AllowAuthenticated},
+	Get: APIEndpointAction{Handler: operationWaitGet, AccessHandler: allowAuthenticated},
 }
 
 var operationWebsocket = APIEndpoint{
diff --git a/lxd/profiles.go b/lxd/profiles.go
index 9647f8cb38..406f86cd35 100644
--- a/lxd/profiles.go
+++ b/lxd/profiles.go
@@ -28,18 +28,18 @@ import (
 var profilesCmd = APIEndpoint{
 	Path: "profiles",
 
-	Get:  APIEndpointAction{Handler: profilesGet, AccessHandler: AllowProjectPermission("profiles", "view")},
-	Post: APIEndpointAction{Handler: profilesPost, AccessHandler: AllowProjectPermission("profiles", "manage-profiles")},
+	Get:  APIEndpointAction{Handler: profilesGet, AccessHandler: allowProjectPermission("profiles", "view")},
+	Post: APIEndpointAction{Handler: profilesPost, AccessHandler: allowProjectPermission("profiles", "manage-profiles")},
 }
 
 var profileCmd = APIEndpoint{
 	Path: "profiles/{name}",
 
-	Delete: APIEndpointAction{Handler: profileDelete, AccessHandler: AllowProjectPermission("profiles", "manage-profiles")},
-	Get:    APIEndpointAction{Handler: profileGet, AccessHandler: AllowProjectPermission("profiles", "view")},
-	Patch:  APIEndpointAction{Handler: profilePatch, AccessHandler: AllowProjectPermission("profiles", "manage-profiles")},
-	Post:   APIEndpointAction{Handler: profilePost, AccessHandler: AllowProjectPermission("profiles", "manage-profiles")},
-	Put:    APIEndpointAction{Handler: profilePut, AccessHandler: AllowProjectPermission("profiles", "manage-profiles")},
+	Delete: APIEndpointAction{Handler: profileDelete, AccessHandler: allowProjectPermission("profiles", "manage-profiles")},
+	Get:    APIEndpointAction{Handler: profileGet, AccessHandler: allowProjectPermission("profiles", "view")},
+	Patch:  APIEndpointAction{Handler: profilePatch, AccessHandler: allowProjectPermission("profiles", "manage-profiles")},
+	Post:   APIEndpointAction{Handler: profilePost, AccessHandler: allowProjectPermission("profiles", "manage-profiles")},
+	Put:    APIEndpointAction{Handler: profilePut, AccessHandler: allowProjectPermission("profiles", "manage-profiles")},
 }
 
 /* This is used for both profiles post and profile put */
diff --git a/lxd/resources.go b/lxd/resources.go
index 78b257af9f..6bd12305d6 100644
--- a/lxd/resources.go
+++ b/lxd/resources.go
@@ -14,13 +14,13 @@ import (
 var api10ResourcesCmd = APIEndpoint{
 	Path: "resources",
 
-	Get: APIEndpointAction{Handler: api10ResourcesGet, AccessHandler: AllowAuthenticated},
+	Get: APIEndpointAction{Handler: api10ResourcesGet, AccessHandler: allowAuthenticated},
 }
 
 var storagePoolResourcesCmd = APIEndpoint{
 	Path: "storage-pools/{name}/resources",
 
-	Get: APIEndpointAction{Handler: storagePoolResourcesGet, AccessHandler: AllowAuthenticated},
+	Get: APIEndpointAction{Handler: storagePoolResourcesGet, AccessHandler: allowAuthenticated},
 }
 
 // /1.0/resources
diff --git a/lxd/storage_pools.go b/lxd/storage_pools.go
index 327e8ca2de..6c42e13fb7 100644
--- a/lxd/storage_pools.go
+++ b/lxd/storage_pools.go
@@ -26,7 +26,7 @@ var storagePoolCreateLock sync.Mutex
 var storagePoolsCmd = APIEndpoint{
 	Path: "storage-pools",
 
-	Get:  APIEndpointAction{Handler: storagePoolsGet, AccessHandler: AllowAuthenticated},
+	Get:  APIEndpointAction{Handler: storagePoolsGet, AccessHandler: allowAuthenticated},
 	Post: APIEndpointAction{Handler: storagePoolsPost},
 }
 
@@ -34,7 +34,7 @@ var storagePoolCmd = APIEndpoint{
 	Path: "storage-pools/{name}",
 
 	Delete: APIEndpointAction{Handler: storagePoolDelete},
-	Get:    APIEndpointAction{Handler: storagePoolGet, AccessHandler: AllowAuthenticated},
+	Get:    APIEndpointAction{Handler: storagePoolGet, AccessHandler: allowAuthenticated},
 	Patch:  APIEndpointAction{Handler: storagePoolPatch},
 	Put:    APIEndpointAction{Handler: storagePoolPut},
 }
diff --git a/lxd/storage_volumes.go b/lxd/storage_volumes.go
index ef724195d4..782729c5d8 100644
--- a/lxd/storage_volumes.go
+++ b/lxd/storage_volumes.go
@@ -29,55 +29,55 @@ import (
 var storagePoolVolumesCmd = APIEndpoint{
 	Path: "storage-pools/{name}/volumes",
 
-	Get:  APIEndpointAction{Handler: storagePoolVolumesGet, AccessHandler: AllowProjectPermission("storage-volumes", "view")},
-	Post: APIEndpointAction{Handler: storagePoolVolumesPost, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Get:  APIEndpointAction{Handler: storagePoolVolumesGet, AccessHandler: allowProjectPermission("storage-volumes", "view")},
+	Post: APIEndpointAction{Handler: storagePoolVolumesPost, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
 }
 
 var storagePoolVolumesTypeCmd = APIEndpoint{
 	Path: "storage-pools/{name}/volumes/{type}",
 
-	Get:  APIEndpointAction{Handler: storagePoolVolumesTypeGet, AccessHandler: AllowProjectPermission("storage-volumes", "view")},
-	Post: APIEndpointAction{Handler: storagePoolVolumesTypePost, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Get:  APIEndpointAction{Handler: storagePoolVolumesTypeGet, AccessHandler: allowProjectPermission("storage-volumes", "view")},
+	Post: APIEndpointAction{Handler: storagePoolVolumesTypePost, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
 }
 
 var storagePoolVolumeTypeContainerCmd = APIEndpoint{
 	Path: "storage-pools/{pool}/volumes/container/{name:.*}",
 
-	Delete: APIEndpointAction{Handler: storagePoolVolumeTypeContainerDelete, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Get:    APIEndpointAction{Handler: storagePoolVolumeTypeContainerGet, AccessHandler: AllowProjectPermission("storage-volumes", "view")},
-	Patch:  APIEndpointAction{Handler: storagePoolVolumeTypeContainerPatch, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Post:   APIEndpointAction{Handler: storagePoolVolumeTypeContainerPost, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Put:    APIEndpointAction{Handler: storagePoolVolumeTypeContainerPut, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Delete: APIEndpointAction{Handler: storagePoolVolumeTypeContainerDelete, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Get:    APIEndpointAction{Handler: storagePoolVolumeTypeContainerGet, AccessHandler: allowProjectPermission("storage-volumes", "view")},
+	Patch:  APIEndpointAction{Handler: storagePoolVolumeTypeContainerPatch, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Post:   APIEndpointAction{Handler: storagePoolVolumeTypeContainerPost, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Put:    APIEndpointAction{Handler: storagePoolVolumeTypeContainerPut, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
 }
 
 var storagePoolVolumeTypeVMCmd = APIEndpoint{
 	Path: "storage-pools/{pool}/volumes/virtual-machine/{name:.*}",
 
-	Delete: APIEndpointAction{Handler: storagePoolVolumeTypeVMDelete, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Get:    APIEndpointAction{Handler: storagePoolVolumeTypeVMGet, AccessHandler: AllowProjectPermission("storage-volumes", "view")},
-	Patch:  APIEndpointAction{Handler: storagePoolVolumeTypeVMPatch, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Post:   APIEndpointAction{Handler: storagePoolVolumeTypeVMPost, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Put:    APIEndpointAction{Handler: storagePoolVolumeTypeVMPut, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Delete: APIEndpointAction{Handler: storagePoolVolumeTypeVMDelete, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Get:    APIEndpointAction{Handler: storagePoolVolumeTypeVMGet, AccessHandler: allowProjectPermission("storage-volumes", "view")},
+	Patch:  APIEndpointAction{Handler: storagePoolVolumeTypeVMPatch, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Post:   APIEndpointAction{Handler: storagePoolVolumeTypeVMPost, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Put:    APIEndpointAction{Handler: storagePoolVolumeTypeVMPut, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
 }
 
 var storagePoolVolumeTypeCustomCmd = APIEndpoint{
 	Path: "storage-pools/{pool}/volumes/custom/{name}",
 
-	Delete: APIEndpointAction{Handler: storagePoolVolumeTypeCustomDelete, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Get:    APIEndpointAction{Handler: storagePoolVolumeTypeCustomGet, AccessHandler: AllowProjectPermission("storage-volumes", "view")},
-	Patch:  APIEndpointAction{Handler: storagePoolVolumeTypeCustomPatch, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Post:   APIEndpointAction{Handler: storagePoolVolumeTypeCustomPost, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Put:    APIEndpointAction{Handler: storagePoolVolumeTypeCustomPut, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Delete: APIEndpointAction{Handler: storagePoolVolumeTypeCustomDelete, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Get:    APIEndpointAction{Handler: storagePoolVolumeTypeCustomGet, AccessHandler: allowProjectPermission("storage-volumes", "view")},
+	Patch:  APIEndpointAction{Handler: storagePoolVolumeTypeCustomPatch, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Post:   APIEndpointAction{Handler: storagePoolVolumeTypeCustomPost, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Put:    APIEndpointAction{Handler: storagePoolVolumeTypeCustomPut, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
 }
 
 var storagePoolVolumeTypeImageCmd = APIEndpoint{
 	Path: "storage-pools/{pool}/volumes/image/{name}",
 
-	Delete: APIEndpointAction{Handler: storagePoolVolumeTypeImageDelete, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Get:    APIEndpointAction{Handler: storagePoolVolumeTypeImageGet, AccessHandler: AllowProjectPermission("storage-volumes", "view")},
-	Patch:  APIEndpointAction{Handler: storagePoolVolumeTypeImagePatch, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Post:   APIEndpointAction{Handler: storagePoolVolumeTypeImagePost, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Put:    APIEndpointAction{Handler: storagePoolVolumeTypeImagePut, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Delete: APIEndpointAction{Handler: storagePoolVolumeTypeImageDelete, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Get:    APIEndpointAction{Handler: storagePoolVolumeTypeImageGet, AccessHandler: allowProjectPermission("storage-volumes", "view")},
+	Patch:  APIEndpointAction{Handler: storagePoolVolumeTypeImagePatch, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Post:   APIEndpointAction{Handler: storagePoolVolumeTypeImagePost, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Put:    APIEndpointAction{Handler: storagePoolVolumeTypeImagePut, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
 }
 
 // /1.0/storage-pools/{name}/volumes
diff --git a/lxd/storage_volumes_snapshot.go b/lxd/storage_volumes_snapshot.go
index 75bfd9367c..9452ff93e2 100644
--- a/lxd/storage_volumes_snapshot.go
+++ b/lxd/storage_volumes_snapshot.go
@@ -22,17 +22,17 @@ import (
 var storagePoolVolumeSnapshotsTypeCmd = APIEndpoint{
 	Path: "storage-pools/{pool}/volumes/{type}/{name}/snapshots",
 
-	Get:  APIEndpointAction{Handler: storagePoolVolumeSnapshotsTypeGet, AccessHandler: AllowProjectPermission("storage-volumes", "view")},
-	Post: APIEndpointAction{Handler: storagePoolVolumeSnapshotsTypePost, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Get:  APIEndpointAction{Handler: storagePoolVolumeSnapshotsTypeGet, AccessHandler: allowProjectPermission("storage-volumes", "view")},
+	Post: APIEndpointAction{Handler: storagePoolVolumeSnapshotsTypePost, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
 }
 
 var storagePoolVolumeSnapshotTypeCmd = APIEndpoint{
 	Path: "storage-pools/{pool}/volumes/{type}/{name}/snapshots/{snapshotName}",
 
-	Delete: APIEndpointAction{Handler: storagePoolVolumeSnapshotTypeDelete, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Get:    APIEndpointAction{Handler: storagePoolVolumeSnapshotTypeGet, AccessHandler: AllowProjectPermission("storage-volumes", "view")},
-	Post:   APIEndpointAction{Handler: storagePoolVolumeSnapshotTypePost, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
-	Put:    APIEndpointAction{Handler: storagePoolVolumeSnapshotTypePut, AccessHandler: AllowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Delete: APIEndpointAction{Handler: storagePoolVolumeSnapshotTypeDelete, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Get:    APIEndpointAction{Handler: storagePoolVolumeSnapshotTypeGet, AccessHandler: allowProjectPermission("storage-volumes", "view")},
+	Post:   APIEndpointAction{Handler: storagePoolVolumeSnapshotTypePost, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
+	Put:    APIEndpointAction{Handler: storagePoolVolumeSnapshotTypePut, AccessHandler: allowProjectPermission("storage-volumes", "manage-storage-volumes")},
 }
 
 func storagePoolVolumeSnapshotsTypePost(d *Daemon, r *http.Request) response.Response {

From 172b68fdf8c110ed3219703a4ce9f5547a486418 Mon Sep 17 00:00:00 2001
From: Thomas Parrott <thomas.parrott at canonical.com>
Date: Mon, 16 Mar 2020 16:57:04 +0000
Subject: [PATCH 6/9] lxd: Unexports DevLxdServer

Signed-off-by: Thomas Parrott <thomas.parrott at canonical.com>
---
 lxd/daemon.go | 2 +-
 lxd/devlxd.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/lxd/daemon.go b/lxd/daemon.go
index 7e284c7661..e68bc9d210 100644
--- a/lxd/daemon.go
+++ b/lxd/daemon.go
@@ -725,7 +725,7 @@ func (d *Daemon) init() error {
 		UnixSocket:           d.UnixSocket(),
 		Cert:                 certInfo,
 		RestServer:           restServer(d),
-		DevLxdServer:         DevLxdServer(d),
+		DevLxdServer:         devLxdServer(d),
 		LocalUnixSocketGroup: d.config.Group,
 		NetworkAddress:       address,
 		ClusterAddress:       clusterAddress,
diff --git a/lxd/devlxd.go b/lxd/devlxd.go
index c231cdd3b2..b7871737ee 100644
--- a/lxd/devlxd.go
+++ b/lxd/devlxd.go
@@ -30,7 +30,7 @@ import (
 
 // DevLxdServer creates an http.Server capable of handling requests against the
 // /dev/lxd Unix socket endpoint created inside containers.
-func DevLxdServer(d *Daemon) *http.Server {
+func devLxdServer(d *Daemon) *http.Server {
 	return &http.Server{
 		Handler:   devLxdAPI(d),
 		ConnState: pidMapper.ConnStateHandler,

From ccd4b8e683641fb4c50a94c24d6babccac6a1c7e Mon Sep 17 00:00:00 2001
From: Thomas Parrott <thomas.parrott at canonical.com>
Date: Mon, 16 Mar 2020 16:57:59 +0000
Subject: [PATCH 7/9] lxd: Unexports daemon feature functions

Signed-off-by: Thomas Parrott <thomas.parrott at canonical.com>
---
 lxd/daemon.go            | 8 ++++----
 lxd/main_checkfeature.go | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/lxd/daemon.go b/lxd/daemon.go
index e68bc9d210..ad56b4c891 100644
--- a/lxd/daemon.go
+++ b/lxd/daemon.go
@@ -590,28 +590,28 @@ func (d *Daemon) init() error {
 
 	// Look for kernel features
 	logger.Infof("Kernel features:")
-	d.os.NetnsGetifaddrs = CanUseNetnsGetifaddrs()
+	d.os.NetnsGetifaddrs = canUseNetnsGetifaddrs()
 	if d.os.NetnsGetifaddrs {
 		logger.Infof(" - netnsid-based network retrieval: yes")
 	} else {
 		logger.Infof(" - netnsid-based network retrieval: no")
 	}
 
-	d.os.UeventInjection = CanUseUeventInjection()
+	d.os.UeventInjection = canUseUeventInjection()
 	if d.os.UeventInjection {
 		logger.Infof(" - uevent injection: yes")
 	} else {
 		logger.Infof(" - uevent injection: no")
 	}
 
-	d.os.SeccompListener = CanUseSeccompListener()
+	d.os.SeccompListener = canUseSeccompListener()
 	if d.os.SeccompListener {
 		logger.Infof(" - seccomp listener: yes")
 	} else {
 		logger.Infof(" - seccomp listener: no")
 	}
 
-	d.os.SeccompListenerContinue = CanUseSeccompListenerContinue()
+	d.os.SeccompListenerContinue = canUseSeccompListenerContinue()
 	if d.os.SeccompListenerContinue {
 		logger.Infof(" - seccomp listener continue syscalls: yes")
 	} else {
diff --git a/lxd/main_checkfeature.go b/lxd/main_checkfeature.go
index ac167bdbbc..c3e5c7091b 100644
--- a/lxd/main_checkfeature.go
+++ b/lxd/main_checkfeature.go
@@ -311,7 +311,7 @@ static bool is_empty_string(char *s)
 */
 import "C"
 
-func CanUseNetnsGetifaddrs() bool {
+func canUseNetnsGetifaddrs() bool {
 	if !bool(C.is_empty_string(&C.errbuf[0])) {
 		logger.Debugf("%s", C.GoString(&C.errbuf[0]))
 	}
@@ -319,14 +319,14 @@ func CanUseNetnsGetifaddrs() bool {
 	return bool(C.netnsid_aware)
 }
 
-func CanUseUeventInjection() bool {
+func canUseUeventInjection() bool {
 	return bool(C.uevent_aware)
 }
 
-func CanUseSeccompListener() bool {
+func canUseSeccompListener() bool {
 	return bool(C.seccomp_notify_aware > 0)
 }
 
-func CanUseSeccompListenerContinue() bool {
+func canUseSeccompListenerContinue() bool {
 	return bool(C.seccomp_notify_aware == 2)
 }

From 424154d55fbde6832ca4b5a889a80b62d9539f86 Mon Sep 17 00:00:00 2001
From: Thomas Parrott <thomas.parrott at canonical.com>
Date: Mon, 16 Mar 2020 16:59:09 +0000
Subject: [PATCH 8/9] lxd: Unexports migration setup functions

Signed-off-by: Thomas Parrott <thomas.parrott at canonical.com>
---
 lxd/instances_post.go          | 2 +-
 lxd/migrate_instance.go        | 2 +-
 lxd/migrate_storage_volumes.go | 4 ++--
 lxd/storage_volumes.go         | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/lxd/instances_post.go b/lxd/instances_post.go
index 95ce2e9b75..a4fcc8f036 100644
--- a/lxd/instances_post.go
+++ b/lxd/instances_post.go
@@ -313,7 +313,7 @@ func createFromMigration(d *Daemon, project string, req *api.InstancesPost) resp
 		Refresh:      req.Source.Refresh,
 	}
 
-	sink, err := NewMigrationSink(&migrationArgs)
+	sink, err := newMigrationSink(&migrationArgs)
 	if err != nil {
 		return response.InternalError(err)
 	}
diff --git a/lxd/migrate_instance.go b/lxd/migrate_instance.go
index 32313d2378..3c63cc2ae5 100644
--- a/lxd/migrate_instance.go
+++ b/lxd/migrate_instance.go
@@ -699,7 +699,7 @@ func (s *migrationSourceWs) Do(state *state.State, migrateOp *operations.Operati
 	return nil
 }
 
-func NewMigrationSink(args *MigrationSinkArgs) (*migrationSink, error) {
+func newMigrationSink(args *MigrationSinkArgs) (*migrationSink, error) {
 	sink := migrationSink{
 		src:     migrationFields{instance: args.Instance, instanceOnly: args.InstanceOnly},
 		dest:    migrationFields{instanceOnly: args.InstanceOnly},
diff --git a/lxd/migrate_storage_volumes.go b/lxd/migrate_storage_volumes.go
index d7e51710d2..d02e1a24ba 100644
--- a/lxd/migrate_storage_volumes.go
+++ b/lxd/migrate_storage_volumes.go
@@ -17,7 +17,7 @@ import (
 	"github.com/lxc/lxd/shared/logger"
 )
 
-func NewStorageMigrationSource(volumeOnly bool) (*migrationSourceWs, error) {
+func newStorageMigrationSource(volumeOnly bool) (*migrationSourceWs, error) {
 	ret := migrationSourceWs{migrationFields{}, make(chan bool, 1)}
 	ret.volumeOnly = volumeOnly
 
@@ -144,7 +144,7 @@ func (s *migrationSourceWs) DoStorage(state *state.State, projectName string, po
 	return nil
 }
 
-func NewStorageMigrationSink(args *MigrationSinkArgs) (*migrationSink, error) {
+func newStorageMigrationSink(args *MigrationSinkArgs) (*migrationSink, error) {
 	sink := migrationSink{
 		src:    migrationFields{volumeOnly: args.VolumeOnly},
 		dest:   migrationFields{volumeOnly: args.VolumeOnly},
diff --git a/lxd/storage_volumes.go b/lxd/storage_volumes.go
index 782729c5d8..a3a52e62ce 100644
--- a/lxd/storage_volumes.go
+++ b/lxd/storage_volumes.go
@@ -474,7 +474,7 @@ func doVolumeMigration(d *Daemon, projectName string, poolName string, req *api.
 		VolumeOnly: req.Source.VolumeOnly,
 	}
 
-	sink, err := NewStorageMigrationSink(&migrationArgs)
+	sink, err := newStorageMigrationSink(&migrationArgs)
 	if err != nil {
 		return response.InternalError(err)
 	}
@@ -634,7 +634,7 @@ func storagePoolVolumeTypePost(d *Daemon, r *http.Request, volumeTypeName string
 
 // storagePoolVolumeTypePostMigration handles volume migration type POST requests.
 func storagePoolVolumeTypePostMigration(state *state.State, projectName, poolName, volumeName string, req api.StorageVolumePost) response.Response {
-	ws, err := NewStorageMigrationSource(req.VolumeOnly)
+	ws, err := newStorageMigrationSource(req.VolumeOnly)
 	if err != nil {
 		return response.InternalError(err)
 	}

From 211ddcf99ef8b0ae4c0e65d0afd911aca7ab7910 Mon Sep 17 00:00:00 2001
From: Thomas Parrott <thomas.parrott at canonical.com>
Date: Mon, 16 Mar 2020 17:00:45 +0000
Subject: [PATCH 9/9] lxd: Unexports forwarded response helpers

Signed-off-by: Thomas Parrott <thomas.parrott at canonical.com>
---
 lxd/api_1.0.go                  |  6 +++---
 lxd/images.go                   |  2 +-
 lxd/instance_backup.go          | 12 ++++++------
 lxd/instance_console.go         |  2 +-
 lxd/instance_delete.go          |  2 +-
 lxd/instance_file.go            |  2 +-
 lxd/instance_get.go             |  2 +-
 lxd/instance_logs.go            |  6 +++---
 lxd/instance_metadata.go        | 10 +++++-----
 lxd/instance_patch.go           |  2 +-
 lxd/instance_post.go            |  2 +-
 lxd/instance_put.go             |  2 +-
 lxd/instance_snapshot.go        |  6 +++---
 lxd/instance_state.go           |  4 ++--
 lxd/networks.go                 |  4 ++--
 lxd/resources.go                |  4 ++--
 lxd/response.go                 | 12 ++++++------
 lxd/storage_pools.go            |  2 +-
 lxd/storage_volumes.go          | 24 ++++++++++++------------
 lxd/storage_volumes_snapshot.go | 20 ++++++++++----------
 20 files changed, 63 insertions(+), 63 deletions(-)

diff --git a/lxd/api_1.0.go b/lxd/api_1.0.go
index d54eff5c72..4d4bbbb6a6 100644
--- a/lxd/api_1.0.go
+++ b/lxd/api_1.0.go
@@ -120,7 +120,7 @@ func api10Get(d *Daemon, r *http.Request) response.Response {
 	}
 
 	// If a target was specified, forward the request to the relevant node.
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
@@ -251,7 +251,7 @@ func api10Get(d *Daemon, r *http.Request) response.Response {
 
 func api10Put(d *Daemon, r *http.Request) response.Response {
 	// If a target was specified, forward the request to the relevant node.
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
@@ -299,7 +299,7 @@ func api10Put(d *Daemon, r *http.Request) response.Response {
 
 func api10Patch(d *Daemon, r *http.Request) response.Response {
 	// If a target was specified, forward the request to the relevant node.
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
diff --git a/lxd/images.go b/lxd/images.go
index 4ed760c364..0941eac153 100644
--- a/lxd/images.go
+++ b/lxd/images.go
@@ -706,7 +706,7 @@ func imagesPost(d *Daemon, r *http.Request) response.Response {
 		if name != "" {
 			post.Seek(0, 0)
 			r.Body = post
-			resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+			resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 			if err != nil {
 				cleanup(builddir, post)
 				return response.SmartError(err)
diff --git a/lxd/instance_backup.go b/lxd/instance_backup.go
index db052da76b..4701d6cd4f 100644
--- a/lxd/instance_backup.go
+++ b/lxd/instance_backup.go
@@ -31,7 +31,7 @@ func containerBackupsGet(d *Daemon, r *http.Request) response.Response {
 	cname := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, cname, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, cname, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -82,7 +82,7 @@ func containerBackupsPost(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node.
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -203,7 +203,7 @@ func containerBackupGet(d *Daemon, r *http.Request) response.Response {
 	backupName := mux.Vars(r)["backupName"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -231,7 +231,7 @@ func containerBackupPost(d *Daemon, r *http.Request) response.Response {
 	backupName := mux.Vars(r)["backupName"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -290,7 +290,7 @@ func containerBackupDelete(d *Daemon, r *http.Request) response.Response {
 	backupName := mux.Vars(r)["backupName"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -336,7 +336,7 @@ func containerBackupExportGet(d *Daemon, r *http.Request) response.Response {
 	backupName := mux.Vars(r)["backupName"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, proj, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, proj, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
diff --git a/lxd/instance_console.go b/lxd/instance_console.go
index 6c20df161a..2c51563bad 100644
--- a/lxd/instance_console.go
+++ b/lxd/instance_console.go
@@ -333,7 +333,7 @@ func containerConsoleLogGet(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Forward the request if the container is remote.
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
diff --git a/lxd/instance_delete.go b/lxd/instance_delete.go
index 4b6c022998..d09cd72fad 100644
--- a/lxd/instance_delete.go
+++ b/lxd/instance_delete.go
@@ -20,7 +20,7 @@ func containerDelete(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
diff --git a/lxd/instance_file.go b/lxd/instance_file.go
index 297fea5af2..c1f3c031ee 100644
--- a/lxd/instance_file.go
+++ b/lxd/instance_file.go
@@ -24,7 +24,7 @@ func containerFileHandler(d *Daemon, r *http.Request) response.Response {
 	project := projectParam(r)
 	name := mux.Vars(r)["name"]
 
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
diff --git a/lxd/instance_get.go b/lxd/instance_get.go
index 800fcc771a..9dbe7ab21e 100644
--- a/lxd/instance_get.go
+++ b/lxd/instance_get.go
@@ -18,7 +18,7 @@ func containerGet(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
diff --git a/lxd/instance_logs.go b/lxd/instance_logs.go
index 1fc437ab1d..484dc52ad9 100644
--- a/lxd/instance_logs.go
+++ b/lxd/instance_logs.go
@@ -57,7 +57,7 @@ func containerLogsGet(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -110,7 +110,7 @@ func containerLogGet(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, projectName, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, projectName, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -147,7 +147,7 @@ func containerLogDelete(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
diff --git a/lxd/instance_metadata.go b/lxd/instance_metadata.go
index 5fe5bc428f..6cdd557163 100644
--- a/lxd/instance_metadata.go
+++ b/lxd/instance_metadata.go
@@ -29,7 +29,7 @@ func containerMetadataGet(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -90,7 +90,7 @@ func containerMetadataPut(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -144,7 +144,7 @@ func containerMetadataTemplatesGet(d *Daemon, r *http.Request) response.Response
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -238,7 +238,7 @@ func containerMetadataTemplatesPostPut(d *Daemon, r *http.Request) response.Resp
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -311,7 +311,7 @@ func containerMetadataTemplatesDelete(d *Daemon, r *http.Request) response.Respo
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
diff --git a/lxd/instance_patch.go b/lxd/instance_patch.go
index eb95714cd7..5d2bcc2234 100644
--- a/lxd/instance_patch.go
+++ b/lxd/instance_patch.go
@@ -32,7 +32,7 @@ func containerPatch(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
diff --git a/lxd/instance_post.go b/lxd/instance_post.go
index 66e6940549..b48974c624 100644
--- a/lxd/instance_post.go
+++ b/lxd/instance_post.go
@@ -130,7 +130,7 @@ func containerPost(d *Daemon, r *http.Request) response.Response {
 	// and we'll either forward the request or load the container.
 	if targetNode == "" || !sourceNodeOffline {
 		// Handle requests targeted to a container on a different node.
-		resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+		resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 		if err != nil {
 			return response.SmartError(err)
 		}
diff --git a/lxd/instance_put.go b/lxd/instance_put.go
index ca3b6523f8..49f430783c 100644
--- a/lxd/instance_put.go
+++ b/lxd/instance_put.go
@@ -36,7 +36,7 @@ func containerPut(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
diff --git a/lxd/instance_snapshot.go b/lxd/instance_snapshot.go
index 53b17b0868..d9545732e1 100644
--- a/lxd/instance_snapshot.go
+++ b/lxd/instance_snapshot.go
@@ -34,7 +34,7 @@ func containerSnapshotsGet(d *Daemon, r *http.Request) response.Response {
 	cname := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, projectName, cname, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, projectName, cname, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -100,7 +100,7 @@ func containerSnapshotsPost(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -195,7 +195,7 @@ func containerSnapshotHandler(d *Daemon, r *http.Request) response.Response {
 	containerName := mux.Vars(r)["name"]
 	snapshotName := mux.Vars(r)["snapshotName"]
 
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, containerName, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, containerName, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
diff --git a/lxd/instance_state.go b/lxd/instance_state.go
index 180d2d8dd8..88f3dcc0cc 100644
--- a/lxd/instance_state.go
+++ b/lxd/instance_state.go
@@ -27,7 +27,7 @@ func containerState(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
@@ -57,7 +57,7 @@ func containerStatePut(d *Daemon, r *http.Request) response.Response {
 	name := mux.Vars(r)["name"]
 
 	// Handle requests targeted to a container on a different node
-	resp, err := ForwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
+	resp, err := forwardedResponseIfContainerIsRemote(d, r, project, name, instanceType)
 	if err != nil {
 		return response.SmartError(err)
 	}
diff --git a/lxd/networks.go b/lxd/networks.go
index 43d60cda78..f87fd0b2e7 100644
--- a/lxd/networks.go
+++ b/lxd/networks.go
@@ -327,7 +327,7 @@ func doNetworksCreate(d *Daemon, req api.NetworksPost, withDatabase bool) error
 
 func networkGet(d *Daemon, r *http.Request) response.Response {
 	// If a target was specified, forward the request to the relevant node.
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
@@ -883,7 +883,7 @@ func networkShutdown(s *state.State) error {
 
 func networkStateGet(d *Daemon, r *http.Request) response.Response {
 	// If a target was specified, forward the request to the relevant node.
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
diff --git a/lxd/resources.go b/lxd/resources.go
index 6bd12305d6..620deecdfa 100644
--- a/lxd/resources.go
+++ b/lxd/resources.go
@@ -27,7 +27,7 @@ var storagePoolResourcesCmd = APIEndpoint{
 // Get system resources
 func api10ResourcesGet(d *Daemon, r *http.Request) response.Response {
 	// If a target was specified, forward the request to the relevant node.
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
@@ -45,7 +45,7 @@ func api10ResourcesGet(d *Daemon, r *http.Request) response.Response {
 // Get resources for a specific storage pool
 func storagePoolResourcesGet(d *Daemon, r *http.Request) response.Response {
 	// If a target was specified, forward the request to the relevant node.
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
diff --git a/lxd/response.go b/lxd/response.go
index 1cd459dbcb..c071d78204 100644
--- a/lxd/response.go
+++ b/lxd/response.go
@@ -9,9 +9,9 @@ import (
 	"github.com/lxc/lxd/lxd/response"
 )
 
-// ForwardedResponseIfTargetIsRemote redirects a request to the request has a
+// forwardedResponseIfTargetIsRemote redirects a request to the request has a
 // targetNode parameter pointing to a node which is not the local one.
-func ForwardedResponseIfTargetIsRemote(d *Daemon, request *http.Request) response.Response {
+func forwardedResponseIfTargetIsRemote(d *Daemon, request *http.Request) response.Response {
 	targetNode := queryParam(request, "target")
 	if targetNode == "" {
 		return nil
@@ -37,10 +37,10 @@ func ForwardedResponseIfTargetIsRemote(d *Daemon, request *http.Request) respons
 	return nil
 }
 
-// ForwardedResponseIfContainerIsRemote redirects a request to the node running
+// forwardedResponseIfContainerIsRemote redirects a request to the node running
 // the container with the given name. If the container is local, nothing gets
 // done and nil is returned.
-func ForwardedResponseIfContainerIsRemote(d *Daemon, r *http.Request, project, name string, instanceType instancetype.Type) (response.Response, error) {
+func forwardedResponseIfContainerIsRemote(d *Daemon, r *http.Request, project, name string, instanceType instancetype.Type) (response.Response, error) {
 	cert := d.endpoints.NetworkCert()
 	client, err := cluster.ConnectIfContainerIsRemote(d.cluster, project, name, cert, instanceType)
 	if err != nil {
@@ -52,14 +52,14 @@ func ForwardedResponseIfContainerIsRemote(d *Daemon, r *http.Request, project, n
 	return response.ForwardedResponse(client, r), nil
 }
 
-// ForwardedResponseIfVolumeIsRemote redirects a request to the node hosting
+// forwardedResponseIfVolumeIsRemote redirects a request to the node hosting
 // the volume with the given pool ID, name and type. If the container is local,
 // nothing gets done and nil is returned. If more than one node has a matching
 // volume, an error is returned.
 //
 // This is used when no targetNode is specified, and saves users some typing
 // when the volume name/type is unique to a node.
-func ForwardedResponseIfVolumeIsRemote(d *Daemon, r *http.Request, poolID int64, volumeName string, volumeType int) response.Response {
+func forwardedResponseIfVolumeIsRemote(d *Daemon, r *http.Request, poolID int64, volumeName string, volumeType int) response.Response {
 	if queryParam(r, "target") != "" {
 		return nil
 	}
diff --git a/lxd/storage_pools.go b/lxd/storage_pools.go
index 6c42e13fb7..ae672da73f 100644
--- a/lxd/storage_pools.go
+++ b/lxd/storage_pools.go
@@ -287,7 +287,7 @@ func storagePoolsPostCluster(d *Daemon, req api.StoragePoolsPost) error {
 // Get a single storage pool.
 func storagePoolGet(d *Daemon, r *http.Request) response.Response {
 	// If a target was specified, forward the request to the relevant node.
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
diff --git a/lxd/storage_volumes.go b/lxd/storage_volumes.go
index a3a52e62ce..ffed539d37 100644
--- a/lxd/storage_volumes.go
+++ b/lxd/storage_volumes.go
@@ -262,7 +262,7 @@ func storagePoolVolumesTypeGet(d *Daemon, r *http.Request) response.Response {
 // /1.0/storage-pools/{name}/volumes/{type}
 // Create a storage volume in a given storage pool.
 func storagePoolVolumesTypePost(d *Daemon, r *http.Request) response.Response {
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
@@ -363,7 +363,7 @@ func doVolumeCreateOrCopy(d *Daemon, projectName, poolName string, req *api.Stor
 // /1.0/storage-pools/{name}/volumes/{type}
 // Create a storage volume of a given volume type in a given storage pool.
 func storagePoolVolumesPost(d *Daemon, r *http.Request) response.Response {
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
@@ -572,7 +572,7 @@ func storagePoolVolumeTypePost(d *Daemon, r *http.Request, volumeTypeName string
 	}
 	r.Body = shared.BytesReadCloser{Buf: &buf}
 
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
@@ -583,7 +583,7 @@ func storagePoolVolumeTypePost(d *Daemon, r *http.Request, volumeTypeName string
 		return response.BadRequest(err)
 	}
 
-	resp = ForwardedResponseIfVolumeIsRemote(d, r, poolID, volumeName, volumeType)
+	resp = forwardedResponseIfVolumeIsRemote(d, r, poolID, volumeName, volumeType)
 	if resp != nil {
 		return resp
 	}
@@ -801,12 +801,12 @@ func storagePoolVolumeTypeGet(d *Daemon, r *http.Request, volumeTypeName string)
 		return response.SmartError(err)
 	}
 
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
 
-	resp = ForwardedResponseIfVolumeIsRemote(d, r, poolID, volumeName, volumeType)
+	resp = forwardedResponseIfVolumeIsRemote(d, r, poolID, volumeName, volumeType)
 	if resp != nil {
 		return resp
 	}
@@ -880,12 +880,12 @@ func storagePoolVolumeTypePut(d *Daemon, r *http.Request, volumeTypeName string)
 		return response.SmartError(err)
 	}
 
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
 
-	resp = ForwardedResponseIfVolumeIsRemote(d, r, pool.ID(), volumeName, volumeType)
+	resp = forwardedResponseIfVolumeIsRemote(d, r, pool.ID(), volumeName, volumeType)
 	if resp != nil {
 		return resp
 	}
@@ -1010,12 +1010,12 @@ func storagePoolVolumeTypePatch(d *Daemon, r *http.Request, volumeTypeName strin
 		return response.SmartError(err)
 	}
 
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
 
-	resp = ForwardedResponseIfVolumeIsRemote(d, r, pool.ID(), volumeName, volumeType)
+	resp = forwardedResponseIfVolumeIsRemote(d, r, pool.ID(), volumeName, volumeType)
 	if resp != nil {
 		return resp
 	}
@@ -1103,7 +1103,7 @@ func storagePoolVolumeTypeDelete(d *Daemon, r *http.Request, volumeTypeName stri
 		return response.BadRequest(fmt.Errorf("Invalid storage volume type %q", volumeTypeName))
 	}
 
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
@@ -1113,7 +1113,7 @@ func storagePoolVolumeTypeDelete(d *Daemon, r *http.Request, volumeTypeName stri
 		return response.SmartError(err)
 	}
 
-	resp = ForwardedResponseIfVolumeIsRemote(d, r, poolID, volumeName, volumeType)
+	resp = forwardedResponseIfVolumeIsRemote(d, r, poolID, volumeName, volumeType)
 	if resp != nil {
 		return resp
 	}
diff --git a/lxd/storage_volumes_snapshot.go b/lxd/storage_volumes_snapshot.go
index 9452ff93e2..0fcf2ce444 100644
--- a/lxd/storage_volumes_snapshot.go
+++ b/lxd/storage_volumes_snapshot.go
@@ -96,12 +96,12 @@ func storagePoolVolumeSnapshotsTypePost(d *Daemon, r *http.Request) response.Res
 		return response.SmartError(err)
 	}
 
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
 
-	resp = ForwardedResponseIfVolumeIsRemote(d, r, poolID, volumeName, volumeType)
+	resp = forwardedResponseIfVolumeIsRemote(d, r, poolID, volumeName, volumeType)
 	if resp != nil {
 		return resp
 	}
@@ -261,7 +261,7 @@ func storagePoolVolumeSnapshotTypePost(d *Daemon, r *http.Request) response.Resp
 		return response.SmartError(err)
 	}
 
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
@@ -272,7 +272,7 @@ func storagePoolVolumeSnapshotTypePost(d *Daemon, r *http.Request) response.Resp
 	}
 
 	fullSnapshotName := fmt.Sprintf("%s/%s", volumeName, snapshotName)
-	resp = ForwardedResponseIfVolumeIsRemote(d, r, poolID, fullSnapshotName, volumeType)
+	resp = forwardedResponseIfVolumeIsRemote(d, r, poolID, fullSnapshotName, volumeType)
 	if resp != nil {
 		return resp
 	}
@@ -327,7 +327,7 @@ func storagePoolVolumeSnapshotTypeGet(d *Daemon, r *http.Request) response.Respo
 		return response.SmartError(err)
 	}
 
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
@@ -338,7 +338,7 @@ func storagePoolVolumeSnapshotTypeGet(d *Daemon, r *http.Request) response.Respo
 	}
 
 	fullSnapshotName := fmt.Sprintf("%s/%s", volumeName, snapshotName)
-	resp = ForwardedResponseIfVolumeIsRemote(d, r, poolID, fullSnapshotName, volumeType)
+	resp = forwardedResponseIfVolumeIsRemote(d, r, poolID, fullSnapshotName, volumeType)
 	if resp != nil {
 		return resp
 	}
@@ -389,7 +389,7 @@ func storagePoolVolumeSnapshotTypePut(d *Daemon, r *http.Request) response.Respo
 		return response.SmartError(err)
 	}
 
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
@@ -400,7 +400,7 @@ func storagePoolVolumeSnapshotTypePut(d *Daemon, r *http.Request) response.Respo
 	}
 
 	fullSnapshotName := fmt.Sprintf("%s/%s", volumeName, snapshotName)
-	resp = ForwardedResponseIfVolumeIsRemote(d, r, poolID, fullSnapshotName, volumeType)
+	resp = forwardedResponseIfVolumeIsRemote(d, r, poolID, fullSnapshotName, volumeType)
 	if resp != nil {
 		return resp
 	}
@@ -473,7 +473,7 @@ func storagePoolVolumeSnapshotTypeDelete(d *Daemon, r *http.Request) response.Re
 		return response.SmartError(err)
 	}
 
-	resp := ForwardedResponseIfTargetIsRemote(d, r)
+	resp := forwardedResponseIfTargetIsRemote(d, r)
 	if resp != nil {
 		return resp
 	}
@@ -484,7 +484,7 @@ func storagePoolVolumeSnapshotTypeDelete(d *Daemon, r *http.Request) response.Re
 	}
 
 	fullSnapshotName := fmt.Sprintf("%s/%s", volumeName, snapshotName)
-	resp = ForwardedResponseIfVolumeIsRemote(d, r, poolID, fullSnapshotName, volumeType)
+	resp = forwardedResponseIfVolumeIsRemote(d, r, poolID, fullSnapshotName, volumeType)
 	if resp != nil {
 		return resp
 	}