From 6d1ac00330ace58eeb7a9afaf5975c23eeea9a4a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jes=C3=BAs=20Espino?= <jespinog@gmail.com>
Date: Fri, 17 May 2019 17:03:05 +0200
Subject: [PATCH] Migrate Roles Layered store to Sync by default (#10790)

* Migrate Roles Layered store to Sync by default

* Fixing govet

* Addressing PR review comments
---
 api4/role_test.go                             |  30 ++--
 app/import_functions_test.go                  |  87 ++++-------
 app/migrations.go                             | 116 +++++++-------
 app/permissions.go                            |   4 +-
 app/permissions_migrations.go                 |   4 +-
 app/role.go                                   |  40 ++---
 store/layered_store.go                        |  42 ++---
 store/layered_store_supplier.go               |  14 +-
 store/local_cache_supplier_roles.go           |  54 +++----
 store/redis_supplier_roles.go                 |  40 +++--
 store/sqlstore/role_supplier.go               | 143 +++++++----------
 store/sqlstore/scheme_supplier.go             |  81 +++++-----
 store/store.go                                |  14 +-
 .../mocks/LayeredStoreDatabaseLayer.go        | 122 ++++++++++-----
 store/storetest/mocks/LayeredStoreSupplier.go | 122 ++++++++++-----
 store/storetest/mocks/RoleStore.go            | 123 ++++++++++-----
 store/storetest/role_store.go                 | 144 ++++++++----------
 store/storetest/scheme_store.go               | 104 ++++++-------
 18 files changed, 645 insertions(+), 639 deletions(-)

diff --git a/api4/role_test.go b/api4/role_test.go
index d26969c94d..0d1331e96a 100644
--- a/api4/role_test.go
+++ b/api4/role_test.go
@@ -24,9 +24,8 @@ func TestGetRole(t *testing.T) {
 		SchemeManaged: true,
 	}
 
-	res1 := <-th.App.Srv.Store.Role().Save(role)
-	assert.Nil(t, res1.Err)
-	role = res1.Data.(*model.Role)
+	role, err := th.App.Srv.Store.Role().Save(role)
+	assert.Nil(t, err)
 	defer th.App.Srv.Store.Job().Delete(role.Id)
 
 	received, resp := th.Client.GetRole(role.Id)
@@ -58,9 +57,8 @@ func TestGetRoleByName(t *testing.T) {
 		SchemeManaged: true,
 	}
 
-	res1 := <-th.App.Srv.Store.Role().Save(role)
-	assert.Nil(t, res1.Err)
-	role = res1.Data.(*model.Role)
+	role, err := th.App.Srv.Store.Role().Save(role)
+	assert.Nil(t, err)
 	defer th.App.Srv.Store.Job().Delete(role.Id)
 
 	received, resp := th.Client.GetRoleByName(role.Name)
@@ -106,19 +104,16 @@ func TestGetRolesByNames(t *testing.T) {
 		SchemeManaged: true,
 	}
 
-	res1 := <-th.App.Srv.Store.Role().Save(role1)
-	assert.Nil(t, res1.Err)
-	role1 = res1.Data.(*model.Role)
+	role1, err := th.App.Srv.Store.Role().Save(role1)
+	assert.Nil(t, err)
 	defer th.App.Srv.Store.Job().Delete(role1.Id)
 
-	res2 := <-th.App.Srv.Store.Role().Save(role2)
-	assert.Nil(t, res2.Err)
-	role2 = res2.Data.(*model.Role)
+	role2, err = th.App.Srv.Store.Role().Save(role2)
+	assert.Nil(t, err)
 	defer th.App.Srv.Store.Job().Delete(role2.Id)
 
-	res3 := <-th.App.Srv.Store.Role().Save(role3)
-	assert.Nil(t, res3.Err)
-	role3 = res3.Data.(*model.Role)
+	role3, err = th.App.Srv.Store.Role().Save(role3)
+	assert.Nil(t, err)
 	defer th.App.Srv.Store.Job().Delete(role3.Id)
 
 	// Check all three roles can be found.
@@ -158,9 +153,8 @@ func TestPatchRole(t *testing.T) {
 		SchemeManaged: true,
 	}
 
-	res1 := <-th.App.Srv.Store.Role().Save(role)
-	assert.Nil(t, res1.Err)
-	role = res1.Data.(*model.Role)
+	role, err := th.App.Srv.Store.Role().Save(role)
+	assert.Nil(t, err)
 	defer th.App.Srv.Store.Job().Delete(role.Id)
 
 	patch := &model.RolePatch{
diff --git a/app/import_functions_test.go b/app/import_functions_test.go
index dfecf618f4..e041434e60 100644
--- a/app/import_functions_test.go
+++ b/app/import_functions_test.go
@@ -105,55 +105,49 @@ func TestImportImportScheme(t *testing.T) {
 		assert.Equal(t, *data.Description, scheme.Description)
 		assert.Equal(t, *data.Scope, scheme.Scope)
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
@@ -177,55 +171,49 @@ func TestImportImportScheme(t *testing.T) {
 		assert.Equal(t, *data.Description, scheme.Description)
 		assert.Equal(t, *data.Scope, scheme.Scope)
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
@@ -330,55 +318,49 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) {
 		assert.Equal(t, *data.Description, scheme.Description)
 		assert.Equal(t, *data.Scope, scheme.Scope)
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
@@ -402,55 +384,49 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) {
 		assert.Equal(t, *data.Description, scheme.Description)
 		assert.Equal(t, *data.Scope, scheme.Scope)
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
 		}
 
-		if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); res.Err != nil {
+		if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil {
 			t.Fatalf("Should have found the imported role.")
 		} else {
-			role := res.Data.(*model.Role)
 			assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName)
 			assert.False(t, role.BuiltIn)
 			assert.True(t, role.SchemeManaged)
@@ -489,7 +465,7 @@ func TestImportImportRole(t *testing.T) {
 		t.Fatalf("Should have failed to import.")
 	}
 
-	if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err == nil {
+	if _, err := th.App.Srv.Store.Role().GetByName(rid1); err == nil {
 		t.Fatalf("Role should not have imported.")
 	}
 
@@ -500,7 +476,7 @@ func TestImportImportRole(t *testing.T) {
 		t.Fatalf("Should have succeeded.")
 	}
 
-	if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err == nil {
+	if _, err := th.App.Srv.Store.Role().GetByName(rid1); err == nil {
 		t.Fatalf("Role should not have imported as we are in dry run mode.")
 	}
 
@@ -511,7 +487,7 @@ func TestImportImportRole(t *testing.T) {
 		t.Fatalf("Should have failed to import.")
 	}
 
-	if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err == nil {
+	if _, err := th.App.Srv.Store.Role().GetByName(rid1); err == nil {
 		t.Fatalf("Role should not have imported.")
 	}
 
@@ -524,10 +500,9 @@ func TestImportImportRole(t *testing.T) {
 		t.Fatalf("Should have succeeded.")
 	}
 
-	if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err != nil {
+	if role, err := th.App.Srv.Store.Role().GetByName(rid1); err != nil {
 		t.Fatalf("Should have found the imported role.")
 	} else {
-		role := res.Data.(*model.Role)
 		assert.Equal(t, *data.Name, role.Name)
 		assert.Equal(t, *data.DisplayName, role.DisplayName)
 		assert.Equal(t, *data.Description, role.Description)
@@ -545,10 +520,9 @@ func TestImportImportRole(t *testing.T) {
 		t.Fatalf("Should have succeeded. %v", err)
 	}
 
-	if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err != nil {
+	if role, err := th.App.Srv.Store.Role().GetByName(rid1); err != nil {
 		t.Fatalf("Should have found the imported role.")
 	} else {
-		role := res.Data.(*model.Role)
 		assert.Equal(t, *data.Name, role.Name)
 		assert.Equal(t, *data.DisplayName, role.DisplayName)
 		assert.Equal(t, *data.Description, role.Description)
@@ -567,10 +541,9 @@ func TestImportImportRole(t *testing.T) {
 		t.Fatalf("Should have succeeded.")
 	}
 
-	if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err != nil {
+	if role, err := th.App.Srv.Store.Role().GetByName(rid1); err != nil {
 		t.Fatalf("Should have found the imported role.")
 	} else {
-		role := res.Data.(*model.Role)
 		assert.Equal(t, *data2.Name, role.Name)
 		assert.Equal(t, *data2.DisplayName, role.DisplayName)
 		assert.Equal(t, *data.Description, role.Description)
diff --git a/app/migrations.go b/app/migrations.go
index bd5014be1b..61817871ee 100644
--- a/app/migrations.go
+++ b/app/migrations.go
@@ -30,27 +30,29 @@ func (a *App) DoAdvancedPermissionsMigration() {
 	allSucceeded := true
 
 	for _, role := range roles {
-		if result := <-a.Srv.Store.Role().Save(role); result.Err != nil {
-			// If this failed for reasons other than the role already existing, don't mark the migration as done.
-			if result2 := <-a.Srv.Store.Role().GetByName(role.Name); result2.Err != nil {
-				mlog.Critical("Failed to migrate role to database.")
-				mlog.Critical(fmt.Sprint(result.Err))
+		_, err := a.Srv.Store.Role().Save(role)
+		if err == nil {
+			continue
+		}
+
+		// If this failed for reasons other than the role already existing, don't mark the migration as done.
+		fetchedRole, err := a.Srv.Store.Role().GetByName(role.Name)
+		if err != nil {
+			mlog.Critical("Failed to migrate role to database.", mlog.Err(err))
+			allSucceeded = false
+			continue
+		}
+
+		// If the role already existed, check it is the same and update if not.
+		if !reflect.DeepEqual(fetchedRole.Permissions, role.Permissions) ||
+			fetchedRole.DisplayName != role.DisplayName ||
+			fetchedRole.Description != role.Description ||
+			fetchedRole.SchemeManaged != role.SchemeManaged {
+			role.Id = fetchedRole.Id
+			if _, err = a.Srv.Store.Role().Save(role); err != nil {
+				// Role is not the same, but failed to update.
+				mlog.Critical("Failed to migrate role to database.", mlog.Err(err))
 				allSucceeded = false
-			} else {
-				// If the role already existed, check it is the same and update if not.
-				fetchedRole := result.Data.(*model.Role)
-				if !reflect.DeepEqual(fetchedRole.Permissions, role.Permissions) ||
-					fetchedRole.DisplayName != role.DisplayName ||
-					fetchedRole.Description != role.Description ||
-					fetchedRole.SchemeManaged != role.SchemeManaged {
-					role.Id = fetchedRole.Id
-					if result := <-a.Srv.Store.Role().Save(role); result.Err != nil {
-						// Role is not the same, but failed to update.
-						mlog.Critical("Failed to migrate role to database.")
-						mlog.Critical(fmt.Sprint(result.Err))
-						allSucceeded = false
-					}
-				}
 			}
 		}
 	}
@@ -63,7 +65,7 @@ func (a *App) DoAdvancedPermissionsMigration() {
 	if *config.ServiceSettings.DEPRECATED_DO_NOT_USE_AllowEditPost == model.ALLOW_EDIT_POST_ALWAYS {
 		*config.ServiceSettings.PostEditTimeLimit = -1
 		if err := a.SaveConfig(config, true); err != nil {
-			mlog.Error("Failed to update config in Advanced Permissions Phase 1 Migration.", mlog.String("error", err.Error()))
+			mlog.Error("Failed to update config in Advanced Permissions Phase 1 Migration.", mlog.Err(err))
 		}
 	}
 
@@ -73,8 +75,7 @@ func (a *App) DoAdvancedPermissionsMigration() {
 	}
 
 	if result := <-a.Srv.Store.System().Save(&system); result.Err != nil {
-		mlog.Critical("Failed to mark advanced permissions migration as completed.")
-		mlog.Critical(fmt.Sprint(result.Err))
+		mlog.Critical("Failed to mark advanced permissions migration as completed.", mlog.Err(result.Err))
 	}
 }
 
@@ -104,46 +105,40 @@ func (a *App) DoEmojisPermissionsMigration() {
 	case model.RESTRICT_EMOJI_CREATION_ALL:
 		role, err = a.GetRoleByName(model.SYSTEM_USER_ROLE_ID)
 		if err != nil {
-			mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
-			mlog.Critical(err.Error())
+			mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
 			return
 		}
 	case model.RESTRICT_EMOJI_CREATION_ADMIN:
 		role, err = a.GetRoleByName(model.TEAM_ADMIN_ROLE_ID)
 		if err != nil {
-			mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
-			mlog.Critical(err.Error())
+			mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
 			return
 		}
 	case model.RESTRICT_EMOJI_CREATION_SYSTEM_ADMIN:
 		role = nil
 	default:
-		mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
-		mlog.Critical("Invalid restrict emoji creation setting")
+		mlog.Critical("Failed to migrate emojis creation permissions from mattermost config. Invalid restrict emoji creation setting")
 		return
 	}
 
 	if role != nil {
 		role.Permissions = append(role.Permissions, model.PERMISSION_CREATE_EMOJIS.Id, model.PERMISSION_DELETE_EMOJIS.Id)
-		if result := <-a.Srv.Store.Role().Save(role); result.Err != nil {
-			mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
-			mlog.Critical(result.Err.Error())
+		if _, err = a.Srv.Store.Role().Save(role); err != nil {
+			mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
 			return
 		}
 	}
 
 	systemAdminRole, err = a.GetRoleByName(model.SYSTEM_ADMIN_ROLE_ID)
 	if err != nil {
-		mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
-		mlog.Critical(err.Error())
+		mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
 		return
 	}
 
 	systemAdminRole.Permissions = append(systemAdminRole.Permissions, model.PERMISSION_CREATE_EMOJIS.Id, model.PERMISSION_DELETE_EMOJIS.Id)
 	systemAdminRole.Permissions = append(systemAdminRole.Permissions, model.PERMISSION_DELETE_OTHERS_EMOJIS.Id)
-	if result := <-a.Srv.Store.Role().Save(systemAdminRole); result.Err != nil {
-		mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
-		mlog.Critical(result.Err.Error())
+	if _, err := a.Srv.Store.Role().Save(systemAdminRole); err != nil {
+		mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
 		return
 	}
 
@@ -153,8 +148,7 @@ func (a *App) DoEmojisPermissionsMigration() {
 	}
 
 	if result := <-a.Srv.Store.System().Save(&system); result.Err != nil {
-		mlog.Critical("Failed to mark emojis permissions migration as completed.")
-		mlog.Critical(fmt.Sprint(result.Err))
+		mlog.Critical("Failed to mark emojis permissions migration as completed.", mlog.Err(result.Err))
 	}
 }
 
@@ -167,32 +161,28 @@ func (a *App) DoGuestRolesCreationMigration() {
 	roles := model.MakeDefaultRoles()
 
 	allSucceeded := true
-	if result := <-a.Srv.Store.Role().GetByName(model.CHANNEL_GUEST_ROLE_ID); result.Err != nil {
-		if result := <-a.Srv.Store.Role().Save(roles[model.CHANNEL_GUEST_ROLE_ID]); result.Err != nil {
-			mlog.Critical("Failed to create new guest role to database.")
-			mlog.Critical(fmt.Sprint(result.Err))
+	if _, err := a.Srv.Store.Role().GetByName(model.CHANNEL_GUEST_ROLE_ID); err != nil {
+		if _, err := a.Srv.Store.Role().Save(roles[model.CHANNEL_GUEST_ROLE_ID]); err != nil {
+			mlog.Critical("Failed to create new guest role to database.", mlog.Err(err))
 			allSucceeded = false
 		}
 	}
-	if result := <-a.Srv.Store.Role().GetByName(model.TEAM_GUEST_ROLE_ID); result.Err != nil {
-		if result := <-a.Srv.Store.Role().Save(roles[model.TEAM_GUEST_ROLE_ID]); result.Err != nil {
-			mlog.Critical("Failed to create new guest role to database.")
-			mlog.Critical(fmt.Sprint(result.Err))
+	if _, err := a.Srv.Store.Role().GetByName(model.TEAM_GUEST_ROLE_ID); err != nil {
+		if _, err := a.Srv.Store.Role().Save(roles[model.TEAM_GUEST_ROLE_ID]); err != nil {
+			mlog.Critical("Failed to create new guest role to database.", mlog.Err(err))
 			allSucceeded = false
 		}
 	}
-	if result := <-a.Srv.Store.Role().GetByName(model.SYSTEM_GUEST_ROLE_ID); result.Err != nil {
-		if result := <-a.Srv.Store.Role().Save(roles[model.SYSTEM_GUEST_ROLE_ID]); result.Err != nil {
-			mlog.Critical("Failed to create new guest role to database.")
-			mlog.Critical(fmt.Sprint(result.Err))
+	if _, err := a.Srv.Store.Role().GetByName(model.SYSTEM_GUEST_ROLE_ID); err != nil {
+		if _, err := a.Srv.Store.Role().Save(roles[model.SYSTEM_GUEST_ROLE_ID]); err != nil {
+			mlog.Critical("Failed to create new guest role to database.", mlog.Err(err))
 			allSucceeded = false
 		}
 	}
 
 	resultSchemes := <-a.Srv.Store.Scheme().GetAllPage("", 0, 1000000)
 	if resultSchemes.Err != nil {
-		mlog.Critical("Failed to get all schemes.")
-		mlog.Critical(fmt.Sprint(resultSchemes.Err))
+		mlog.Critical("Failed to get all schemes.", mlog.Err(resultSchemes.Err))
 		allSucceeded = false
 	}
 	schemes := resultSchemes.Data.([]*model.Scheme)
@@ -206,12 +196,11 @@ func (a *App) DoGuestRolesCreationMigration() {
 				SchemeManaged: true,
 			}
 
-			if saveRoleResult := <-a.Srv.Store.Role().Save(teamGuestRole); saveRoleResult.Err != nil {
-				mlog.Critical("Failed to create new guest role for custom scheme.")
-				mlog.Critical(fmt.Sprint(saveRoleResult.Err))
+			if savedRole, err := a.Srv.Store.Role().Save(teamGuestRole); err != nil {
+				mlog.Critical("Failed to create new guest role for custom scheme.", mlog.Err(err))
 				allSucceeded = false
 			} else {
-				scheme.DefaultTeamGuestRole = saveRoleResult.Data.(*model.Role).Name
+				scheme.DefaultTeamGuestRole = savedRole.Name
 			}
 
 			// Channel Guest Role
@@ -222,18 +211,16 @@ func (a *App) DoGuestRolesCreationMigration() {
 				SchemeManaged: true,
 			}
 
-			if saveRoleResult := <-a.Srv.Store.Role().Save(channelGuestRole); saveRoleResult.Err != nil {
-				mlog.Critical("Failed to create new guest role for custom scheme.")
-				mlog.Critical(fmt.Sprint(saveRoleResult.Err))
+			if savedRole, err := a.Srv.Store.Role().Save(channelGuestRole); err != nil {
+				mlog.Critical("Failed to create new guest role for custom scheme.", mlog.Err(err))
 				allSucceeded = false
 			} else {
-				scheme.DefaultChannelGuestRole = saveRoleResult.Data.(*model.Role).Name
+				scheme.DefaultChannelGuestRole = savedRole.Name
 			}
 
 			result := <-a.Srv.Store.Scheme().Save(scheme)
 			if result.Err != nil {
-				mlog.Critical("Failed to update custom scheme.")
-				mlog.Critical(fmt.Sprint(result.Err))
+				mlog.Critical("Failed to update custom scheme.", mlog.Err(result.Err))
 				allSucceeded = false
 			}
 		}
@@ -249,8 +236,7 @@ func (a *App) DoGuestRolesCreationMigration() {
 	}
 
 	if result := <-a.Srv.Store.System().Save(&system); result.Err != nil {
-		mlog.Critical("Failed to mark guest roles creation migration as completed.")
-		mlog.Critical(fmt.Sprint(result.Err))
+		mlog.Critical("Failed to mark guest roles creation migration as completed.", mlog.Err(result.Err))
 	}
 }
 
diff --git a/app/permissions.go b/app/permissions.go
index e9fb6e25c7..67904883fa 100644
--- a/app/permissions.go
+++ b/app/permissions.go
@@ -48,8 +48,8 @@ func (a *App) ResetPermissionsSystem() *model.AppError {
 	}
 
 	// Purge all roles from the database.
-	if result := <-a.Srv.Store.Role().PermanentDeleteAll(); result.Err != nil {
-		return result.Err
+	if err := a.Srv.Store.Role().PermanentDeleteAll(); err != nil {
+		return err
 	}
 
 	// Remove the "System" table entry that marks the advanced permissions migration as done.
diff --git a/app/permissions_migrations.go b/app/permissions_migrations.go
index 8de718d27a..ada7f51d98 100644
--- a/app/permissions_migrations.go
+++ b/app/permissions_migrations.go
@@ -143,8 +143,8 @@ func (a *App) doPermissionsMigration(key string, migrationMap permissionsMap) *m
 
 	for _, role := range roles {
 		role.Permissions = applyPermissionsMap(role.Name, roleMap, migrationMap)
-		if result := <-a.Srv.Store.Role().Save(role); result.Err != nil {
-			return result.Err
+		if _, err := a.Srv.Store.Role().Save(role); err != nil {
+			return err
 		}
 	}
 
diff --git a/app/role.go b/app/role.go
index 8c48775433..17b683e767 100644
--- a/app/role.go
+++ b/app/role.go
@@ -12,35 +12,19 @@ import (
 )
 
 func (a *App) GetRole(id string) (*model.Role, *model.AppError) {
-	result := <-a.Srv.Store.Role().Get(id)
-	if result.Err != nil {
-		return nil, result.Err
-	}
-	return result.Data.(*model.Role), nil
+	return a.Srv.Store.Role().Get(id)
 }
 
 func (a *App) GetAllRoles() ([]*model.Role, *model.AppError) {
-	result := <-a.Srv.Store.Role().GetAll()
-	if result.Err != nil {
-		return nil, result.Err
-	}
-	return result.Data.([]*model.Role), nil
+	return a.Srv.Store.Role().GetAll()
 }
 
 func (a *App) GetRoleByName(name string) (*model.Role, *model.AppError) {
-	result := <-a.Srv.Store.Role().GetByName(name)
-	if result.Err != nil {
-		return nil, result.Err
-	}
-	return result.Data.(*model.Role), nil
+	return a.Srv.Store.Role().GetByName(name)
 }
 
 func (a *App) GetRolesByNames(names []string) ([]*model.Role, *model.AppError) {
-	result := <-a.Srv.Store.Role().GetByNames(names)
-	if result.Err != nil {
-		return nil, result.Err
-	}
-	return result.Data.([]*model.Role), nil
+	return a.Srv.Store.Role().GetByNames(names)
 }
 
 func (a *App) PatchRole(role *model.Role, patch *model.RolePatch) (*model.Role, *model.AppError) {
@@ -66,22 +50,18 @@ func (a *App) CreateRole(role *model.Role) (*model.Role, *model.AppError) {
 	role.BuiltIn = false
 	role.SchemeManaged = false
 
-	result := <-a.Srv.Store.Role().Save(role)
-	if result.Err != nil {
-		return nil, result.Err
-	}
-	return result.Data.(*model.Role), nil
+	return a.Srv.Store.Role().Save(role)
 
 }
 
 func (a *App) UpdateRole(role *model.Role) (*model.Role, *model.AppError) {
-	result := <-a.Srv.Store.Role().Save(role)
-	if result.Err != nil {
-		return nil, result.Err
+	savedRole, err := a.Srv.Store.Role().Save(role)
+	if err != nil {
+		return nil, err
 	}
-	a.sendUpdatedRoleEvent(role)
+	a.sendUpdatedRoleEvent(savedRole)
 
-	return role, nil
+	return savedRole, nil
 
 }
 
diff --git a/store/layered_store.go b/store/layered_store.go
index 64484c1aa0..6a53ffec0b 100644
--- a/store/layered_store.go
+++ b/store/layered_store.go
@@ -260,46 +260,32 @@ type LayeredRoleStore struct {
 	*LayeredStore
 }
 
-func (s *LayeredRoleStore) Save(role *model.Role) StoreChannel {
-	return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
-		return supplier.RoleSave(s.TmpContext, role)
-	})
+func (s *LayeredRoleStore) Save(role *model.Role) (*model.Role, *model.AppError) {
+	return s.LayerChainHead.RoleSave(s.TmpContext, role)
 }
 
-func (s *LayeredRoleStore) Get(roleId string) StoreChannel {
-	return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
-		return supplier.RoleGet(s.TmpContext, roleId)
-	})
+func (s *LayeredRoleStore) Get(roleId string) (*model.Role, *model.AppError) {
+	return s.LayerChainHead.RoleGet(s.TmpContext, roleId)
 }
 
-func (s *LayeredRoleStore) GetAll() StoreChannel {
-	return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
-		return supplier.RoleGetAll(s.TmpContext)
-	})
+func (s *LayeredRoleStore) GetAll() ([]*model.Role, *model.AppError) {
+	return s.LayerChainHead.RoleGetAll(s.TmpContext)
 }
 
-func (s *LayeredRoleStore) GetByName(name string) StoreChannel {
-	return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
-		return supplier.RoleGetByName(s.TmpContext, name)
-	})
+func (s *LayeredRoleStore) GetByName(name string) (*model.Role, *model.AppError) {
+	return s.LayerChainHead.RoleGetByName(s.TmpContext, name)
 }
 
-func (s *LayeredRoleStore) GetByNames(names []string) StoreChannel {
-	return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
-		return supplier.RoleGetByNames(s.TmpContext, names)
-	})
+func (s *LayeredRoleStore) GetByNames(names []string) ([]*model.Role, *model.AppError) {
+	return s.LayerChainHead.RoleGetByNames(s.TmpContext, names)
 }
 
-func (s *LayeredRoleStore) Delete(roldId string) StoreChannel {
-	return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
-		return supplier.RoleDelete(s.TmpContext, roldId)
-	})
+func (s *LayeredRoleStore) Delete(roldId string) (*model.Role, *model.AppError) {
+	return s.LayerChainHead.RoleDelete(s.TmpContext, roldId)
 }
 
-func (s *LayeredRoleStore) PermanentDeleteAll() StoreChannel {
-	return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
-		return supplier.RolePermanentDeleteAll(s.TmpContext)
-	})
+func (s *LayeredRoleStore) PermanentDeleteAll() *model.AppError {
+	return s.LayerChainHead.RolePermanentDeleteAll(s.TmpContext)
 }
 
 type LayeredSchemeStore struct {
diff --git a/store/layered_store_supplier.go b/store/layered_store_supplier.go
index 6ad24e5e69..8072f06329 100644
--- a/store/layered_store_supplier.go
+++ b/store/layered_store_supplier.go
@@ -32,13 +32,13 @@ type LayeredStoreSupplier interface {
 	ReactionsBulkGetForPosts(ctx context.Context, postIds []string, hints ...LayeredStoreHint) ([]*model.Reaction, *model.AppError)
 
 	// Roles
-	RoleSave(ctx context.Context, role *model.Role, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
-	RoleGet(ctx context.Context, roleId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
-	RoleGetAll(ctx context.Context, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
-	RoleGetByName(ctx context.Context, name string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
-	RoleGetByNames(ctx context.Context, names []string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
-	RoleDelete(ctx context.Context, roldId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
-	RolePermanentDeleteAll(ctx context.Context, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
+	RoleSave(ctx context.Context, role *model.Role, hints ...LayeredStoreHint) (*model.Role, *model.AppError)
+	RoleGet(ctx context.Context, roleId string, hints ...LayeredStoreHint) (*model.Role, *model.AppError)
+	RoleGetAll(ctx context.Context, hints ...LayeredStoreHint) ([]*model.Role, *model.AppError)
+	RoleGetByName(ctx context.Context, name string, hints ...LayeredStoreHint) (*model.Role, *model.AppError)
+	RoleGetByNames(ctx context.Context, names []string, hints ...LayeredStoreHint) ([]*model.Role, *model.AppError)
+	RoleDelete(ctx context.Context, roldId string, hints ...LayeredStoreHint) (*model.Role, *model.AppError)
+	RolePermanentDeleteAll(ctx context.Context, hints ...LayeredStoreHint) *model.AppError
 
 	// Schemes
 	SchemeSave(ctx context.Context, scheme *model.Scheme, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
diff --git a/store/local_cache_supplier_roles.go b/store/local_cache_supplier_roles.go
index b9a96a8f90..973ea6d1da 100644
--- a/store/local_cache_supplier_roles.go
+++ b/store/local_cache_supplier_roles.go
@@ -17,38 +17,43 @@ func (s *LocalCacheSupplier) handleClusterInvalidateRole(msg *model.ClusterMessa
 	}
 }
 
-func (s *LocalCacheSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
+func (s *LocalCacheSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
 	if len(role.Name) != 0 {
 		defer s.doInvalidateCacheCluster(s.roleCache, role.Name)
 	}
 	return s.Next().RoleSave(ctx, role, hints...)
 }
 
-func (s *LocalCacheSupplier) RoleGet(ctx context.Context, roleId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
+func (s *LocalCacheSupplier) RoleGet(ctx context.Context, roleId string, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
 	// Roles are cached by name, as that is most commonly how they are looked up.
 	// This means that no caching is supported on roles being looked up by ID.
 	return s.Next().RoleGet(ctx, roleId, hints...)
 }
 
-func (s *LocalCacheSupplier) RoleGetAll(ctx context.Context, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
+func (s *LocalCacheSupplier) RoleGetAll(ctx context.Context, hints ...LayeredStoreHint) ([]*model.Role, *model.AppError) {
 	// Roles are cached by name, as that is most commonly how they are looked up.
 	// This means that no caching is supported on roles being listed.
 	return s.Next().RoleGetAll(ctx, hints...)
 }
 
-func (s *LocalCacheSupplier) RoleGetByName(ctx context.Context, name string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
+func (s *LocalCacheSupplier) RoleGetByName(ctx context.Context, name string, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
 	if result := s.doStandardReadCache(ctx, s.roleCache, name, hints...); result != nil {
-		return result
+		return result.Data.(*model.Role), nil
 	}
 
-	result := s.Next().RoleGetByName(ctx, name, hints...)
+	role, err := s.Next().RoleGetByName(ctx, name, hints...)
+	if err != nil {
+		return nil, err
+	}
 
+	result := NewSupplierResult()
+	result.Data = role
 	s.doStandardAddToCache(ctx, s.roleCache, name, result, hints...)
 
-	return result
+	return role, nil
 }
 
-func (s *LocalCacheSupplier) RoleGetByNames(ctx context.Context, roleNames []string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
+func (s *LocalCacheSupplier) RoleGetByNames(ctx context.Context, roleNames []string, hints ...LayeredStoreHint) ([]*model.Role, *model.AppError) {
 	var foundRoles []*model.Role
 	var rolesToQuery []string
 
@@ -60,33 +65,30 @@ func (s *LocalCacheSupplier) RoleGetByNames(ctx context.Context, roleNames []str
 		}
 	}
 
-	result := s.Next().RoleGetByNames(ctx, rolesToQuery, hints...)
+	rolesFound, err := s.Next().RoleGetByNames(ctx, rolesToQuery, hints...)
 
-	if result.Data != nil {
-		rolesFound := result.Data.([]*model.Role)
-		for _, role := range rolesFound {
-			res := NewSupplierResult()
-			res.Data = role
-			s.doStandardAddToCache(ctx, s.roleCache, role.Name, res, hints...)
-		}
-		result.Data = append(foundRoles, result.Data.([]*model.Role)...)
+	for _, role := range rolesFound {
+		res := NewSupplierResult()
+		res.Data = role
+		s.doStandardAddToCache(ctx, s.roleCache, role.Name, res, hints...)
 	}
+	foundRoles = append(foundRoles, rolesFound...)
 
-	return result
+	return foundRoles, err
 }
 
-func (s *LocalCacheSupplier) RoleDelete(ctx context.Context, roleId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
-	result := s.Next().RoleDelete(ctx, roleId, hints...)
-
-	if result.Err == nil {
-		role := result.Data.(*model.Role)
-		s.doInvalidateCacheCluster(s.roleCache, role.Name)
+func (s *LocalCacheSupplier) RoleDelete(ctx context.Context, roleId string, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
+	role, err := s.Next().RoleDelete(ctx, roleId, hints...)
+	if err != nil {
+		return nil, err
 	}
 
-	return result
+	s.doInvalidateCacheCluster(s.roleCache, role.Name)
+
+	return role, nil
 }
 
-func (s *LocalCacheSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
+func (s *LocalCacheSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...LayeredStoreHint) *model.AppError {
 	defer s.roleCache.Purge()
 	defer s.doClearCacheCluster(s.roleCache)
 
diff --git a/store/redis_supplier_roles.go b/store/redis_supplier_roles.go
index 43501f8131..8b7175b86f 100644
--- a/store/redis_supplier_roles.go
+++ b/store/redis_supplier_roles.go
@@ -11,7 +11,7 @@ import (
 	"github.com/mattermost/mattermost-server/model"
 )
 
-func (s *RedisSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
+func (s *RedisSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
 	key := buildRedisKeyForRoleName(role.Name)
 
 	defer func() {
@@ -23,19 +23,19 @@ func (s *RedisSupplier) RoleSave(ctx context.Context, role *model.Role, hints ..
 	return s.Next().RoleSave(ctx, role, hints...)
 }
 
-func (s *RedisSupplier) RoleGet(ctx context.Context, roleId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
+func (s *RedisSupplier) RoleGet(ctx context.Context, roleId string, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
 	// Roles are cached by name, as that is most commonly how they are looked up.
 	// This means that no caching is supported on roles being looked up by ID.
 	return s.Next().RoleGet(ctx, roleId, hints...)
 }
 
-func (s *RedisSupplier) RoleGetAll(ctx context.Context, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
+func (s *RedisSupplier) RoleGetAll(ctx context.Context, hints ...LayeredStoreHint) ([]*model.Role, *model.AppError) {
 	// Roles are cached by name, as that is most commonly how they are looked up.
 	// This means that no caching is supported on roles being listed.
 	return s.Next().RoleGetAll(ctx, hints...)
 }
 
-func (s *RedisSupplier) RoleGetByName(ctx context.Context, name string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
+func (s *RedisSupplier) RoleGetByName(ctx context.Context, name string, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
 	key := buildRedisKeyForRoleName(name)
 
 	var role *model.Role
@@ -43,23 +43,21 @@ func (s *RedisSupplier) RoleGetByName(ctx context.Context, name string, hints ..
 	if err != nil {
 		mlog.Error("Redis encountered an error on read: " + err.Error())
 	} else if found {
-		result := NewSupplierResult()
-		result.Data = role
-		return result
+		return role, nil
 	}
 
-	result := s.Next().RoleGetByName(ctx, name, hints...)
+	role, appErr := s.Next().RoleGetByName(ctx, name, hints...)
 
-	if result.Err == nil {
-		if err := s.save(key, result.Data, REDIS_EXPIRY_TIME); err != nil {
+	if appErr == nil {
+		if err := s.save(key, role, REDIS_EXPIRY_TIME); err != nil {
 			mlog.Error("Redis encountered and error on write: " + err.Error())
 		}
 	}
 
-	return result
+	return role, appErr
 }
 
-func (s *RedisSupplier) RoleGetByNames(ctx context.Context, roleNames []string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
+func (s *RedisSupplier) RoleGetByNames(ctx context.Context, roleNames []string, hints ...LayeredStoreHint) ([]*model.Role, *model.AppError) {
 	var foundRoles []*model.Role
 	var rolesToQuery []string
 
@@ -76,27 +74,25 @@ func (s *RedisSupplier) RoleGetByNames(ctx context.Context, roleNames []string,
 		}
 	}
 
-	result := s.Next().RoleGetByNames(ctx, rolesToQuery, hints...)
+	rolesFound, appErr := s.Next().RoleGetByNames(ctx, rolesToQuery, hints...)
 
-	if result.Err == nil {
-		rolesFound := result.Data.([]*model.Role)
+	if appErr == nil {
 		for _, role := range rolesFound {
 			if err := s.save(buildRedisKeyForRoleName(role.Name), role, REDIS_EXPIRY_TIME); err != nil {
 				mlog.Error("Redis encountered and error on write: " + err.Error())
 			}
 		}
-		result.Data = append(foundRoles, result.Data.([]*model.Role)...)
+		foundRoles = append(foundRoles, rolesFound...)
 	}
 
-	return result
+	return foundRoles, appErr
 }
 
-func (s *RedisSupplier) RoleDelete(ctx context.Context, roleId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
-	result := s.Next().RoleGet(ctx, roleId, hints...)
+func (s *RedisSupplier) RoleDelete(ctx context.Context, roleId string, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
+	role, appErr := s.Next().RoleGet(ctx, roleId, hints...)
 
-	if result.Err == nil {
+	if appErr == nil {
 		defer func() {
-			role := result.Data.(*model.Role)
 			key := buildRedisKeyForRoleName(role.Name)
 
 			if err := s.client.Del(key).Err(); err != nil {
@@ -108,7 +104,7 @@ func (s *RedisSupplier) RoleDelete(ctx context.Context, roleId string, hints ...
 	return s.Next().RoleDelete(ctx, roleId, hints...)
 }
 
-func (s *RedisSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
+func (s *RedisSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...LayeredStoreHint) *model.AppError {
 	defer func() {
 		if keys, err := s.client.Keys("roles:*").Result(); err != nil {
 			mlog.Error("Redis encountered an error on read: " + err.Error())
diff --git a/store/sqlstore/role_supplier.go b/store/sqlstore/role_supplier.go
index a3f4f89036..e678fb3711 100644
--- a/store/sqlstore/role_supplier.go
+++ b/store/sqlstore/role_supplier.go
@@ -79,52 +79,43 @@ func initSqlSupplierRoles(sqlStore SqlStore) {
 	}
 }
 
-func (s *SqlSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
-	result := store.NewSupplierResult()
-
+func (s *SqlSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	// Check the role is valid before proceeding.
 	if !role.IsValidWithoutId() {
-		result.Err = model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.invalid_role.app_error", nil, "", http.StatusBadRequest)
-		return result
+		return nil, model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.invalid_role.app_error", nil, "", http.StatusBadRequest)
 	}
 
 	if len(role.Id) == 0 {
-		if transaction, err := s.GetMaster().Begin(); err != nil {
-			result.Err = model.NewAppError("SqlRoleStore.RoleSave", "store.sql_role.save.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
-			return result
-		} else {
-			defer finalizeTransaction(transaction)
-			result = s.createRole(ctx, role, transaction, hints...)
-
-			if result.Err != nil {
-				transaction.Rollback()
-			} else if err := transaction.Commit(); err != nil {
-				result.Err = model.NewAppError("SqlRoleStore.RoleSave", "store.sql_role.save_role.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
-			}
+		transaction, err := s.GetMaster().Begin()
+		if err != nil {
+			return nil, model.NewAppError("SqlRoleStore.RoleSave", "store.sql_role.save.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
 		}
-	} else {
-		dbRole := NewRoleFromModel(role)
-
-		dbRole.UpdateAt = model.GetMillis()
-		if rowsChanged, err := s.GetMaster().Update(dbRole); err != nil {
-			result.Err = model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.update.app_error", nil, err.Error(), http.StatusInternalServerError)
-		} else if rowsChanged != 1 {
-			result.Err = model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.update.app_error", nil, "no record to update", http.StatusInternalServerError)
+		defer finalizeTransaction(transaction)
+		createdRole, appErr := s.createRole(ctx, role, transaction, hints...)
+		if appErr != nil {
+			transaction.Rollback()
+			return nil, appErr
+		} else if err := transaction.Commit(); err != nil {
+			return nil, model.NewAppError("SqlRoleStore.RoleSave", "store.sql_role.save_role.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
 		}
-
-		result.Data = dbRole.ToModel()
+		return createdRole, nil
 	}
 
-	return result
+	dbRole := NewRoleFromModel(role)
+	dbRole.UpdateAt = model.GetMillis()
+	if rowsChanged, err := s.GetMaster().Update(dbRole); err != nil {
+		return nil, model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.update.app_error", nil, err.Error(), http.StatusInternalServerError)
+	} else if rowsChanged != 1 {
+		return nil, model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.update.app_error", nil, "no record to update", http.StatusInternalServerError)
+	}
+
+	return dbRole.ToModel(), nil
 }
 
-func (s *SqlSupplier) createRole(ctx context.Context, role *model.Role, transaction *gorp.Transaction, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
-	result := store.NewSupplierResult()
-
+func (s *SqlSupplier) createRole(ctx context.Context, role *model.Role, transaction *gorp.Transaction, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	// Check the role is valid before proceeding.
 	if !role.IsValidWithoutId() {
-		result.Err = model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.invalid_role.app_error", nil, "", http.StatusBadRequest)
-		return result
+		return nil, model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.invalid_role.app_error", nil, "", http.StatusBadRequest)
 	}
 
 	dbRole := NewRoleFromModel(role)
@@ -134,80 +125,60 @@ func (s *SqlSupplier) createRole(ctx context.Context, role *model.Role, transact
 	dbRole.UpdateAt = dbRole.CreateAt
 
 	if err := transaction.Insert(dbRole); err != nil {
-		result.Err = model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.insert.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.insert.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
-	result.Data = dbRole.ToModel()
-
-	return result
+	return dbRole.ToModel(), nil
 }
 
-func (s *SqlSupplier) RoleGet(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
-	result := store.NewSupplierResult()
-
+func (s *SqlSupplier) RoleGet(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	var dbRole Role
 
 	if err := s.GetReplica().SelectOne(&dbRole, "SELECT * from Roles WHERE Id = :Id", map[string]interface{}{"Id": roleId}); err != nil {
 		if err == sql.ErrNoRows {
-			result.Err = model.NewAppError("SqlRoleStore.Get", "store.sql_role.get.app_error", nil, "Id="+roleId+", "+err.Error(), http.StatusNotFound)
-		} else {
-			result.Err = model.NewAppError("SqlRoleStore.Get", "store.sql_role.get.app_error", nil, err.Error(), http.StatusInternalServerError)
+			return nil, model.NewAppError("SqlRoleStore.Get", "store.sql_role.get.app_error", nil, "Id="+roleId+", "+err.Error(), http.StatusNotFound)
 		}
+		return nil, model.NewAppError("SqlRoleStore.Get", "store.sql_role.get.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
-	result.Data = dbRole.ToModel()
-
-	return result
+	return dbRole.ToModel(), nil
 }
 
-func (s *SqlSupplier) RoleGetAll(ctx context.Context, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
-	result := store.NewSupplierResult()
-
+func (s *SqlSupplier) RoleGetAll(ctx context.Context, hints ...store.LayeredStoreHint) ([]*model.Role, *model.AppError) {
 	var dbRoles []Role
 
 	if _, err := s.GetReplica().Select(&dbRoles, "SELECT * from Roles", map[string]interface{}{}); err != nil {
 		if err == sql.ErrNoRows {
-			result.Err = model.NewAppError("SqlRoleStore.GetAll", "store.sql_role.get_all.app_error", nil, err.Error(), http.StatusNotFound)
-		} else {
-			result.Err = model.NewAppError("SqlRoleStore.GetAll", "store.sql_role.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
+			return nil, model.NewAppError("SqlRoleStore.GetAll", "store.sql_role.get_all.app_error", nil, err.Error(), http.StatusNotFound)
 		}
+		return nil, model.NewAppError("SqlRoleStore.GetAll", "store.sql_role.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	var roles []*model.Role
 	for _, dbRole := range dbRoles {
 		roles = append(roles, dbRole.ToModel())
 	}
-	result.Data = roles
-
-	return result
+	return roles, nil
 }
 
-func (s *SqlSupplier) RoleGetByName(ctx context.Context, name string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
-	result := store.NewSupplierResult()
-
+func (s *SqlSupplier) RoleGetByName(ctx context.Context, name string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	var dbRole Role
 
 	if err := s.GetReplica().SelectOne(&dbRole, "SELECT * from Roles WHERE Name = :Name", map[string]interface{}{"Name": name}); err != nil {
 		if err == sql.ErrNoRows {
-			result.Err = model.NewAppError("SqlRoleStore.GetByName", "store.sql_role.get_by_name.app_error", nil, "name="+name+",err="+err.Error(), http.StatusNotFound)
-		} else {
-			result.Err = model.NewAppError("SqlRoleStore.GetByName", "store.sql_role.get_by_name.app_error", nil, "name="+name+",err="+err.Error(), http.StatusInternalServerError)
+			return nil, model.NewAppError("SqlRoleStore.GetByName", "store.sql_role.get_by_name.app_error", nil, "name="+name+",err="+err.Error(), http.StatusNotFound)
 		}
+		return nil, model.NewAppError("SqlRoleStore.GetByName", "store.sql_role.get_by_name.app_error", nil, "name="+name+",err="+err.Error(), http.StatusInternalServerError)
 	}
 
-	result.Data = dbRole.ToModel()
-
-	return result
+	return dbRole.ToModel(), nil
 }
 
-func (s *SqlSupplier) RoleGetByNames(ctx context.Context, names []string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
-	result := store.NewSupplierResult()
-
+func (s *SqlSupplier) RoleGetByNames(ctx context.Context, names []string, hints ...store.LayeredStoreHint) ([]*model.Role, *model.AppError) {
 	var dbRoles []*Role
 
 	if len(names) == 0 {
-		result.Data = []*model.Role{}
-		return result
+		return []*model.Role{}, nil
 	}
 
 	var searchPlaceholders []string
@@ -220,7 +191,7 @@ func (s *SqlSupplier) RoleGetByNames(ctx context.Context, names []string, hints
 	searchTerm := "Name IN (" + strings.Join(searchPlaceholders, ", ") + ")"
 
 	if _, err := s.GetReplica().Select(&dbRoles, "SELECT * from Roles WHERE "+searchTerm, parameters); err != nil {
-		result.Err = model.NewAppError("SqlRoleStore.GetByNames", "store.sql_role.get_by_names.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlRoleStore.GetByNames", "store.sql_role.get_by_names.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	var roles []*model.Role
@@ -228,24 +199,17 @@ func (s *SqlSupplier) RoleGetByNames(ctx context.Context, names []string, hints
 		roles = append(roles, dbRole.ToModel())
 	}
 
-	result.Data = roles
-
-	return result
+	return roles, nil
 }
 
-func (s *SqlSupplier) RoleDelete(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
-	result := store.NewSupplierResult()
-
+func (s *SqlSupplier) RoleDelete(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	// Get the role.
 	var role *Role
 	if err := s.GetReplica().SelectOne(&role, "SELECT * from Roles WHERE Id = :Id", map[string]interface{}{"Id": roleId}); err != nil {
 		if err == sql.ErrNoRows {
-			result.Err = model.NewAppError("SqlRoleStore.Delete", "store.sql_role.get.app_error", nil, "Id="+roleId+", "+err.Error(), http.StatusNotFound)
-		} else {
-			result.Err = model.NewAppError("SqlRoleStore.Delete", "store.sql_role.get.app_error", nil, err.Error(), http.StatusInternalServerError)
+			return nil, model.NewAppError("SqlRoleStore.Delete", "store.sql_role.get.app_error", nil, "Id="+roleId+", "+err.Error(), http.StatusNotFound)
 		}
-
-		return result
+		return nil, model.NewAppError("SqlRoleStore.Delete", "store.sql_role.get.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	time := model.GetMillis()
@@ -253,22 +217,17 @@ func (s *SqlSupplier) RoleDelete(ctx context.Context, roleId string, hints ...st
 	role.UpdateAt = time
 
 	if rowsChanged, err := s.GetMaster().Update(role); err != nil {
-		result.Err = model.NewAppError("SqlRoleStore.Delete", "store.sql_role.delete.update.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlRoleStore.Delete", "store.sql_role.delete.update.app_error", nil, err.Error(), http.StatusInternalServerError)
 	} else if rowsChanged != 1 {
-		result.Err = model.NewAppError("SqlRoleStore.Delete", "store.sql_role.delete.update.app_error", nil, "no record to update", http.StatusInternalServerError)
-	} else {
-		result.Data = role.ToModel()
+		return nil, model.NewAppError("SqlRoleStore.Delete", "store.sql_role.delete.update.app_error", nil, "no record to update", http.StatusInternalServerError)
 	}
-
-	return result
+	return role.ToModel(), nil
 }
 
-func (s *SqlSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
-	result := store.NewSupplierResult()
-
+func (s *SqlSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...store.LayeredStoreHint) *model.AppError {
 	if _, err := s.GetMaster().Exec("DELETE FROM Roles"); err != nil {
-		result.Err = model.NewAppError("SqlRoleStore.PermanentDeleteAll", "store.sql_role.permanent_delete_all.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return model.NewAppError("SqlRoleStore.PermanentDeleteAll", "store.sql_role.permanent_delete_all.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
-	return result
+	return nil
 }
diff --git a/store/sqlstore/scheme_supplier.go b/store/sqlstore/scheme_supplier.go
index 5fd23fed32..ebd9a24242 100644
--- a/store/sqlstore/scheme_supplier.go
+++ b/store/sqlstore/scheme_supplier.go
@@ -75,33 +75,34 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
 	// Fetch the default system scheme roles to populate default permissions.
 	defaultRoleNames := []string{model.TEAM_ADMIN_ROLE_ID, model.TEAM_USER_ROLE_ID, model.TEAM_GUEST_ROLE_ID, model.CHANNEL_ADMIN_ROLE_ID, model.CHANNEL_USER_ROLE_ID, model.CHANNEL_GUEST_ROLE_ID}
 	defaultRoles := make(map[string]*model.Role)
-	if rolesResult := s.RoleGetByNames(ctx, defaultRoleNames); rolesResult.Err != nil {
-		result.Err = rolesResult.Err
+	roles, err := s.RoleGetByNames(ctx, defaultRoleNames)
+	if err != nil {
+		result.Err = err
 		return result
-	} else {
-		for _, role := range rolesResult.Data.([]*model.Role) {
-			switch role.Name {
-			case model.TEAM_ADMIN_ROLE_ID:
-				defaultRoles[model.TEAM_ADMIN_ROLE_ID] = role
-			case model.TEAM_USER_ROLE_ID:
-				defaultRoles[model.TEAM_USER_ROLE_ID] = role
-			case model.TEAM_GUEST_ROLE_ID:
-				defaultRoles[model.TEAM_GUEST_ROLE_ID] = role
-			case model.CHANNEL_ADMIN_ROLE_ID:
-				defaultRoles[model.CHANNEL_ADMIN_ROLE_ID] = role
-			case model.CHANNEL_USER_ROLE_ID:
-				defaultRoles[model.CHANNEL_USER_ROLE_ID] = role
-			case model.CHANNEL_GUEST_ROLE_ID:
-				defaultRoles[model.CHANNEL_GUEST_ROLE_ID] = role
-			}
-		}
+	}
 
-		if len(defaultRoles) != 6 {
-			result.Err = model.NewAppError("SqlSchemeStore.SaveScheme", "store.sql_scheme.save.retrieve_default_scheme_roles.app_error", nil, "", http.StatusInternalServerError)
-			return result
+	for _, role := range roles {
+		switch role.Name {
+		case model.TEAM_ADMIN_ROLE_ID:
+			defaultRoles[model.TEAM_ADMIN_ROLE_ID] = role
+		case model.TEAM_USER_ROLE_ID:
+			defaultRoles[model.TEAM_USER_ROLE_ID] = role
+		case model.TEAM_GUEST_ROLE_ID:
+			defaultRoles[model.TEAM_GUEST_ROLE_ID] = role
+		case model.CHANNEL_ADMIN_ROLE_ID:
+			defaultRoles[model.CHANNEL_ADMIN_ROLE_ID] = role
+		case model.CHANNEL_USER_ROLE_ID:
+			defaultRoles[model.CHANNEL_USER_ROLE_ID] = role
+		case model.CHANNEL_GUEST_ROLE_ID:
+			defaultRoles[model.CHANNEL_GUEST_ROLE_ID] = role
 		}
 	}
 
+	if len(defaultRoles) != 6 {
+		result.Err = model.NewAppError("SqlSchemeStore.SaveScheme", "store.sql_scheme.save.retrieve_default_scheme_roles.app_error", nil, "", http.StatusInternalServerError)
+		return result
+	}
+
 	// Create the appropriate default roles for the scheme.
 	if scheme.Scope == model.SCHEME_SCOPE_TEAM {
 		// Team Admin Role
@@ -112,11 +113,11 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
 			SchemeManaged: true,
 		}
 
-		if saveRoleResult := s.createRole(ctx, teamAdminRole, transaction); saveRoleResult.Err != nil {
-			result.Err = saveRoleResult.Err
+		if savedRole, err := s.createRole(ctx, teamAdminRole, transaction); err != nil {
+			result.Err = err
 			return result
 		} else {
-			scheme.DefaultTeamAdminRole = saveRoleResult.Data.(*model.Role).Name
+			scheme.DefaultTeamAdminRole = savedRole.Name
 		}
 
 		// Team User Role
@@ -127,11 +128,11 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
 			SchemeManaged: true,
 		}
 
-		if saveRoleResult := s.createRole(ctx, teamUserRole, transaction); saveRoleResult.Err != nil {
-			result.Err = saveRoleResult.Err
+		if savedRole, err := s.createRole(ctx, teamUserRole, transaction); err != nil {
+			result.Err = err
 			return result
 		} else {
-			scheme.DefaultTeamUserRole = saveRoleResult.Data.(*model.Role).Name
+			scheme.DefaultTeamUserRole = savedRole.Name
 		}
 
 		// Team Guest Role
@@ -142,11 +143,11 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
 			SchemeManaged: true,
 		}
 
-		if saveRoleResult := s.createRole(ctx, teamGuestRole, transaction); saveRoleResult.Err != nil {
-			result.Err = saveRoleResult.Err
+		if savedRole, err := s.createRole(ctx, teamGuestRole, transaction); err != nil {
+			result.Err = err
 			return result
 		} else {
-			scheme.DefaultTeamGuestRole = saveRoleResult.Data.(*model.Role).Name
+			scheme.DefaultTeamGuestRole = savedRole.Name
 		}
 	}
 	if scheme.Scope == model.SCHEME_SCOPE_TEAM || scheme.Scope == model.SCHEME_SCOPE_CHANNEL {
@@ -158,11 +159,11 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
 			SchemeManaged: true,
 		}
 
-		if saveRoleResult := s.createRole(ctx, channelAdminRole, transaction); saveRoleResult.Err != nil {
-			result.Err = saveRoleResult.Err
+		if savedRole, err := s.createRole(ctx, channelAdminRole, transaction); err != nil {
+			result.Err = err
 			return result
 		} else {
-			scheme.DefaultChannelAdminRole = saveRoleResult.Data.(*model.Role).Name
+			scheme.DefaultChannelAdminRole = savedRole.Name
 		}
 
 		// Channel User Role
@@ -173,11 +174,11 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
 			SchemeManaged: true,
 		}
 
-		if saveRoleResult := s.createRole(ctx, channelUserRole, transaction); saveRoleResult.Err != nil {
-			result.Err = saveRoleResult.Err
+		if savedRole, err := s.createRole(ctx, channelUserRole, transaction); err != nil {
+			result.Err = err
 			return result
 		} else {
-			scheme.DefaultChannelUserRole = saveRoleResult.Data.(*model.Role).Name
+			scheme.DefaultChannelUserRole = savedRole.Name
 		}
 
 		// Channel Guest Role
@@ -188,11 +189,11 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
 			SchemeManaged: true,
 		}
 
-		if saveRoleResult := s.createRole(ctx, channelGuestRole, transaction); saveRoleResult.Err != nil {
-			result.Err = saveRoleResult.Err
+		if savedRole, err := s.createRole(ctx, channelGuestRole, transaction); err != nil {
+			result.Err = err
 			return result
 		} else {
-			scheme.DefaultChannelGuestRole = saveRoleResult.Data.(*model.Role).Name
+			scheme.DefaultChannelGuestRole = savedRole.Name
 		}
 	}
 
diff --git a/store/store.go b/store/store.go
index 36cee04ef9..e9f4bd96f4 100644
--- a/store/store.go
+++ b/store/store.go
@@ -538,13 +538,13 @@ type PluginStore interface {
 }
 
 type RoleStore interface {
-	Save(role *model.Role) StoreChannel
-	Get(roleId string) StoreChannel
-	GetAll() StoreChannel
-	GetByName(name string) StoreChannel
-	GetByNames(names []string) StoreChannel
-	Delete(roldId string) StoreChannel
-	PermanentDeleteAll() StoreChannel
+	Save(role *model.Role) (*model.Role, *model.AppError)
+	Get(roleId string) (*model.Role, *model.AppError)
+	GetAll() ([]*model.Role, *model.AppError)
+	GetByName(name string) (*model.Role, *model.AppError)
+	GetByNames(names []string) ([]*model.Role, *model.AppError)
+	Delete(roldId string) (*model.Role, *model.AppError)
+	PermanentDeleteAll() *model.AppError
 }
 
 type SchemeStore interface {
diff --git a/store/storetest/mocks/LayeredStoreDatabaseLayer.go b/store/storetest/mocks/LayeredStoreDatabaseLayer.go
index 90dde216af..c3348fcd6c 100644
--- a/store/storetest/mocks/LayeredStoreDatabaseLayer.go
+++ b/store/storetest/mocks/LayeredStoreDatabaseLayer.go
@@ -1081,7 +1081,7 @@ func (_m *LayeredStoreDatabaseLayer) Role() store.RoleStore {
 }
 
 // RoleDelete provides a mock function with given fields: ctx, roldId, hints
-func (_m *LayeredStoreDatabaseLayer) RoleDelete(ctx context.Context, roldId string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreDatabaseLayer) RoleDelete(ctx context.Context, roldId string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -1091,20 +1091,29 @@ func (_m *LayeredStoreDatabaseLayer) RoleDelete(ctx context.Context, roldId stri
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 *model.Role
+	if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *model.Role); ok {
 		r0 = rf(ctx, roldId, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).(*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(context.Context, string, ...store.LayeredStoreHint) *model.AppError); ok {
+		r1 = rf(ctx, roldId, hints...)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // RoleGet provides a mock function with given fields: ctx, roleId, hints
-func (_m *LayeredStoreDatabaseLayer) RoleGet(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreDatabaseLayer) RoleGet(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -1114,20 +1123,29 @@ func (_m *LayeredStoreDatabaseLayer) RoleGet(ctx context.Context, roleId string,
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 *model.Role
+	if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *model.Role); ok {
 		r0 = rf(ctx, roleId, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).(*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(context.Context, string, ...store.LayeredStoreHint) *model.AppError); ok {
+		r1 = rf(ctx, roleId, hints...)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // RoleGetAll provides a mock function with given fields: ctx, hints
-func (_m *LayeredStoreDatabaseLayer) RoleGetAll(ctx context.Context, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreDatabaseLayer) RoleGetAll(ctx context.Context, hints ...store.LayeredStoreHint) ([]*model.Role, *model.AppError) {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -1137,20 +1155,29 @@ func (_m *LayeredStoreDatabaseLayer) RoleGetAll(ctx context.Context, hints ...st
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 []*model.Role
+	if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) []*model.Role); ok {
 		r0 = rf(ctx, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).([]*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(context.Context, ...store.LayeredStoreHint) *model.AppError); ok {
+		r1 = rf(ctx, hints...)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // RoleGetByName provides a mock function with given fields: ctx, name, hints
-func (_m *LayeredStoreDatabaseLayer) RoleGetByName(ctx context.Context, name string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreDatabaseLayer) RoleGetByName(ctx context.Context, name string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -1160,20 +1187,29 @@ func (_m *LayeredStoreDatabaseLayer) RoleGetByName(ctx context.Context, name str
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 *model.Role
+	if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *model.Role); ok {
 		r0 = rf(ctx, name, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).(*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(context.Context, string, ...store.LayeredStoreHint) *model.AppError); ok {
+		r1 = rf(ctx, name, hints...)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // RoleGetByNames provides a mock function with given fields: ctx, names, hints
-func (_m *LayeredStoreDatabaseLayer) RoleGetByNames(ctx context.Context, names []string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreDatabaseLayer) RoleGetByNames(ctx context.Context, names []string, hints ...store.LayeredStoreHint) ([]*model.Role, *model.AppError) {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -1183,20 +1219,29 @@ func (_m *LayeredStoreDatabaseLayer) RoleGetByNames(ctx context.Context, names [
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, []string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 []*model.Role
+	if rf, ok := ret.Get(0).(func(context.Context, []string, ...store.LayeredStoreHint) []*model.Role); ok {
 		r0 = rf(ctx, names, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).([]*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(context.Context, []string, ...store.LayeredStoreHint) *model.AppError); ok {
+		r1 = rf(ctx, names, hints...)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // RolePermanentDeleteAll provides a mock function with given fields: ctx, hints
-func (_m *LayeredStoreDatabaseLayer) RolePermanentDeleteAll(ctx context.Context, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreDatabaseLayer) RolePermanentDeleteAll(ctx context.Context, hints ...store.LayeredStoreHint) *model.AppError {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -1206,12 +1251,12 @@ func (_m *LayeredStoreDatabaseLayer) RolePermanentDeleteAll(ctx context.Context,
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) *model.AppError); ok {
 		r0 = rf(ctx, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).(*model.AppError)
 		}
 	}
 
@@ -1219,7 +1264,7 @@ func (_m *LayeredStoreDatabaseLayer) RolePermanentDeleteAll(ctx context.Context,
 }
 
 // RoleSave provides a mock function with given fields: ctx, role, hints
-func (_m *LayeredStoreDatabaseLayer) RoleSave(ctx context.Context, role *model.Role, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreDatabaseLayer) RoleSave(ctx context.Context, role *model.Role, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -1229,16 +1274,25 @@ func (_m *LayeredStoreDatabaseLayer) RoleSave(ctx context.Context, role *model.R
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, *model.Role, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 *model.Role
+	if rf, ok := ret.Get(0).(func(context.Context, *model.Role, ...store.LayeredStoreHint) *model.Role); ok {
 		r0 = rf(ctx, role, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).(*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(context.Context, *model.Role, ...store.LayeredStoreHint) *model.AppError); ok {
+		r1 = rf(ctx, role, hints...)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // Scheme provides a mock function with given fields:
diff --git a/store/storetest/mocks/LayeredStoreSupplier.go b/store/storetest/mocks/LayeredStoreSupplier.go
index 755ceda6a8..b8211491fb 100644
--- a/store/storetest/mocks/LayeredStoreSupplier.go
+++ b/store/storetest/mocks/LayeredStoreSupplier.go
@@ -741,7 +741,7 @@ func (_m *LayeredStoreSupplier) ReactionsBulkGetForPosts(ctx context.Context, po
 }
 
 // RoleDelete provides a mock function with given fields: ctx, roldId, hints
-func (_m *LayeredStoreSupplier) RoleDelete(ctx context.Context, roldId string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreSupplier) RoleDelete(ctx context.Context, roldId string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -751,20 +751,29 @@ func (_m *LayeredStoreSupplier) RoleDelete(ctx context.Context, roldId string, h
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 *model.Role
+	if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *model.Role); ok {
 		r0 = rf(ctx, roldId, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).(*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(context.Context, string, ...store.LayeredStoreHint) *model.AppError); ok {
+		r1 = rf(ctx, roldId, hints...)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // RoleGet provides a mock function with given fields: ctx, roleId, hints
-func (_m *LayeredStoreSupplier) RoleGet(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreSupplier) RoleGet(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -774,20 +783,29 @@ func (_m *LayeredStoreSupplier) RoleGet(ctx context.Context, roleId string, hint
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 *model.Role
+	if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *model.Role); ok {
 		r0 = rf(ctx, roleId, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).(*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(context.Context, string, ...store.LayeredStoreHint) *model.AppError); ok {
+		r1 = rf(ctx, roleId, hints...)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // RoleGetAll provides a mock function with given fields: ctx, hints
-func (_m *LayeredStoreSupplier) RoleGetAll(ctx context.Context, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreSupplier) RoleGetAll(ctx context.Context, hints ...store.LayeredStoreHint) ([]*model.Role, *model.AppError) {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -797,20 +815,29 @@ func (_m *LayeredStoreSupplier) RoleGetAll(ctx context.Context, hints ...store.L
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 []*model.Role
+	if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) []*model.Role); ok {
 		r0 = rf(ctx, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).([]*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(context.Context, ...store.LayeredStoreHint) *model.AppError); ok {
+		r1 = rf(ctx, hints...)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // RoleGetByName provides a mock function with given fields: ctx, name, hints
-func (_m *LayeredStoreSupplier) RoleGetByName(ctx context.Context, name string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreSupplier) RoleGetByName(ctx context.Context, name string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -820,20 +847,29 @@ func (_m *LayeredStoreSupplier) RoleGetByName(ctx context.Context, name string,
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 *model.Role
+	if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *model.Role); ok {
 		r0 = rf(ctx, name, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).(*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(context.Context, string, ...store.LayeredStoreHint) *model.AppError); ok {
+		r1 = rf(ctx, name, hints...)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // RoleGetByNames provides a mock function with given fields: ctx, names, hints
-func (_m *LayeredStoreSupplier) RoleGetByNames(ctx context.Context, names []string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreSupplier) RoleGetByNames(ctx context.Context, names []string, hints ...store.LayeredStoreHint) ([]*model.Role, *model.AppError) {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -843,20 +879,29 @@ func (_m *LayeredStoreSupplier) RoleGetByNames(ctx context.Context, names []stri
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, []string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 []*model.Role
+	if rf, ok := ret.Get(0).(func(context.Context, []string, ...store.LayeredStoreHint) []*model.Role); ok {
 		r0 = rf(ctx, names, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).([]*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(context.Context, []string, ...store.LayeredStoreHint) *model.AppError); ok {
+		r1 = rf(ctx, names, hints...)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // RolePermanentDeleteAll provides a mock function with given fields: ctx, hints
-func (_m *LayeredStoreSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...store.LayeredStoreHint) *model.AppError {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -866,12 +911,12 @@ func (_m *LayeredStoreSupplier) RolePermanentDeleteAll(ctx context.Context, hint
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) *model.AppError); ok {
 		r0 = rf(ctx, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).(*model.AppError)
 		}
 	}
 
@@ -879,7 +924,7 @@ func (_m *LayeredStoreSupplier) RolePermanentDeleteAll(ctx context.Context, hint
 }
 
 // RoleSave provides a mock function with given fields: ctx, role, hints
-func (_m *LayeredStoreSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
+func (_m *LayeredStoreSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
 	_va := make([]interface{}, len(hints))
 	for _i := range hints {
 		_va[_i] = hints[_i]
@@ -889,16 +934,25 @@ func (_m *LayeredStoreSupplier) RoleSave(ctx context.Context, role *model.Role,
 	_ca = append(_ca, _va...)
 	ret := _m.Called(_ca...)
 
-	var r0 *store.LayeredStoreSupplierResult
-	if rf, ok := ret.Get(0).(func(context.Context, *model.Role, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
+	var r0 *model.Role
+	if rf, ok := ret.Get(0).(func(context.Context, *model.Role, ...store.LayeredStoreHint) *model.Role); ok {
 		r0 = rf(ctx, role, hints...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
+			r0 = ret.Get(0).(*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(context.Context, *model.Role, ...store.LayeredStoreHint) *model.AppError); ok {
+		r1 = rf(ctx, role, hints...)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // SchemeDelete provides a mock function with given fields: ctx, schemeId, hints
diff --git a/store/storetest/mocks/RoleStore.go b/store/storetest/mocks/RoleStore.go
index c835e40f55..e19635796c 100644
--- a/store/storetest/mocks/RoleStore.go
+++ b/store/storetest/mocks/RoleStore.go
@@ -6,7 +6,6 @@ package mocks
 
 import mock "github.com/stretchr/testify/mock"
 import model "github.com/mattermost/mattermost-server/model"
-import store "github.com/mattermost/mattermost-server/store"
 
 // RoleStore is an autogenerated mock type for the RoleStore type
 type RoleStore struct {
@@ -14,95 +13,140 @@ type RoleStore struct {
 }
 
 // Delete provides a mock function with given fields: roldId
-func (_m *RoleStore) Delete(roldId string) store.StoreChannel {
+func (_m *RoleStore) Delete(roldId string) (*model.Role, *model.AppError) {
 	ret := _m.Called(roldId)
 
-	var r0 store.StoreChannel
-	if rf, ok := ret.Get(0).(func(string) store.StoreChannel); ok {
+	var r0 *model.Role
+	if rf, ok := ret.Get(0).(func(string) *model.Role); ok {
 		r0 = rf(roldId)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+		r1 = rf(roldId)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // Get provides a mock function with given fields: roleId
-func (_m *RoleStore) Get(roleId string) store.StoreChannel {
+func (_m *RoleStore) Get(roleId string) (*model.Role, *model.AppError) {
 	ret := _m.Called(roleId)
 
-	var r0 store.StoreChannel
-	if rf, ok := ret.Get(0).(func(string) store.StoreChannel); ok {
+	var r0 *model.Role
+	if rf, ok := ret.Get(0).(func(string) *model.Role); ok {
 		r0 = rf(roleId)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+		r1 = rf(roleId)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // GetAll provides a mock function with given fields:
-func (_m *RoleStore) GetAll() store.StoreChannel {
+func (_m *RoleStore) GetAll() ([]*model.Role, *model.AppError) {
 	ret := _m.Called()
 
-	var r0 store.StoreChannel
-	if rf, ok := ret.Get(0).(func() store.StoreChannel); ok {
+	var r0 []*model.Role
+	if rf, ok := ret.Get(0).(func() []*model.Role); ok {
 		r0 = rf()
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).([]*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func() *model.AppError); ok {
+		r1 = rf()
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // GetByName provides a mock function with given fields: name
-func (_m *RoleStore) GetByName(name string) store.StoreChannel {
+func (_m *RoleStore) GetByName(name string) (*model.Role, *model.AppError) {
 	ret := _m.Called(name)
 
-	var r0 store.StoreChannel
-	if rf, ok := ret.Get(0).(func(string) store.StoreChannel); ok {
+	var r0 *model.Role
+	if rf, ok := ret.Get(0).(func(string) *model.Role); ok {
 		r0 = rf(name)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+		r1 = rf(name)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // GetByNames provides a mock function with given fields: names
-func (_m *RoleStore) GetByNames(names []string) store.StoreChannel {
+func (_m *RoleStore) GetByNames(names []string) ([]*model.Role, *model.AppError) {
 	ret := _m.Called(names)
 
-	var r0 store.StoreChannel
-	if rf, ok := ret.Get(0).(func([]string) store.StoreChannel); ok {
+	var r0 []*model.Role
+	if rf, ok := ret.Get(0).(func([]string) []*model.Role); ok {
 		r0 = rf(names)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).([]*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func([]string) *model.AppError); ok {
+		r1 = rf(names)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // PermanentDeleteAll provides a mock function with given fields:
-func (_m *RoleStore) PermanentDeleteAll() store.StoreChannel {
+func (_m *RoleStore) PermanentDeleteAll() *model.AppError {
 	ret := _m.Called()
 
-	var r0 store.StoreChannel
-	if rf, ok := ret.Get(0).(func() store.StoreChannel); ok {
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func() *model.AppError); ok {
 		r0 = rf()
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.AppError)
 		}
 	}
 
@@ -110,17 +154,26 @@ func (_m *RoleStore) PermanentDeleteAll() store.StoreChannel {
 }
 
 // Save provides a mock function with given fields: role
-func (_m *RoleStore) Save(role *model.Role) store.StoreChannel {
+func (_m *RoleStore) Save(role *model.Role) (*model.Role, *model.AppError) {
 	ret := _m.Called(role)
 
-	var r0 store.StoreChannel
-	if rf, ok := ret.Get(0).(func(*model.Role) store.StoreChannel); ok {
+	var r0 *model.Role
+	if rf, ok := ret.Get(0).(func(*model.Role) *model.Role); ok {
 		r0 = rf(role)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.Role)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(*model.Role) *model.AppError); ok {
+		r1 = rf(role)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
diff --git a/store/storetest/role_store.go b/store/storetest/role_store.go
index d95a3697cd..6645224b1f 100644
--- a/store/storetest/role_store.go
+++ b/store/storetest/role_store.go
@@ -37,9 +37,8 @@ func testRoleStoreSave(t *testing.T, ss store.Store) {
 		SchemeManaged: false,
 	}
 
-	res1 := <-ss.Role().Save(r1)
-	assert.Nil(t, res1.Err)
-	d1 := res1.Data.(*model.Role)
+	d1, err := ss.Role().Save(r1)
+	assert.Nil(t, err)
 	assert.Len(t, d1.Id, 26)
 	assert.Equal(t, r1.Name, d1.Name)
 	assert.Equal(t, r1.DisplayName, d1.DisplayName)
@@ -54,9 +53,8 @@ func testRoleStoreSave(t *testing.T, ss store.Store) {
 		"delete_public_channel",
 	}
 
-	res2 := <-ss.Role().Save(d1)
-	assert.Nil(t, res2.Err)
-	d2 := res2.Data.(*model.Role)
+	d2, err := ss.Role().Save(d1)
+	assert.Nil(t, err)
 	assert.Len(t, d2.Id, 26)
 	assert.Equal(t, r1.Name, d2.Name)
 	assert.Equal(t, r1.DisplayName, d2.DisplayName)
@@ -78,8 +76,8 @@ func testRoleStoreSave(t *testing.T, ss store.Store) {
 		SchemeManaged: false,
 	}
 
-	res3 := <-ss.Role().Save(r3)
-	assert.NotNil(t, res3.Err)
+	_, err = ss.Role().Save(r3)
+	assert.NotNil(t, err)
 
 	// Try saving one with a duplicate "name" field.
 	r4 := &model.Role{
@@ -94,14 +92,14 @@ func testRoleStoreSave(t *testing.T, ss store.Store) {
 		SchemeManaged: false,
 	}
 
-	res4 := <-ss.Role().Save(r4)
-	assert.NotNil(t, res4.Err)
+	_, err = ss.Role().Save(r4)
+	assert.NotNil(t, err)
 }
 
 func testRoleStoreGetAll(t *testing.T, ss store.Store) {
-	prev := <-ss.Role().GetAll()
-	require.Nil(t, prev.Err)
-	prevCount := len(prev.Data.([]*model.Role))
+	prev, err := ss.Role().GetAll()
+	require.Nil(t, err)
+	prevCount := len(prev)
 
 	// Save a role to test with.
 	r1 := &model.Role{
@@ -116,8 +114,8 @@ func testRoleStoreGetAll(t *testing.T, ss store.Store) {
 		SchemeManaged: false,
 	}
 
-	res1 := <-ss.Role().Save(r1)
-	require.Nil(t, res1.Err)
+	_, err = ss.Role().Save(r1)
+	require.Nil(t, err)
 
 	r2 := &model.Role{
 		Name:        model.NewId(),
@@ -130,12 +128,11 @@ func testRoleStoreGetAll(t *testing.T, ss store.Store) {
 		},
 		SchemeManaged: false,
 	}
-	res2 := <-ss.Role().Save(r2)
-	require.Nil(t, res2.Err)
+	_, err = ss.Role().Save(r2)
+	require.Nil(t, err)
 
-	res3 := <-ss.Role().GetAll()
-	require.Nil(t, res3.Err)
-	data := res3.Data.([]*model.Role)
+	data, err := ss.Role().GetAll()
+	require.Nil(t, err)
 	assert.Len(t, data, prevCount+2)
 }
 
@@ -153,15 +150,13 @@ func testRoleStoreGet(t *testing.T, ss store.Store) {
 		SchemeManaged: false,
 	}
 
-	res1 := <-ss.Role().Save(r1)
-	assert.Nil(t, res1.Err)
-	d1 := res1.Data.(*model.Role)
+	d1, err := ss.Role().Save(r1)
+	assert.Nil(t, err)
 	assert.Len(t, d1.Id, 26)
 
 	// Get a valid role
-	res2 := <-ss.Role().Get(d1.Id)
-	assert.Nil(t, res2.Err)
-	d2 := res1.Data.(*model.Role)
+	d2, err := ss.Role().Get(d1.Id)
+	assert.Nil(t, err)
 	assert.Equal(t, d1.Id, d2.Id)
 	assert.Equal(t, r1.Name, d2.Name)
 	assert.Equal(t, r1.DisplayName, d2.DisplayName)
@@ -170,8 +165,8 @@ func testRoleStoreGet(t *testing.T, ss store.Store) {
 	assert.Equal(t, r1.SchemeManaged, d2.SchemeManaged)
 
 	// Get an invalid role
-	res3 := <-ss.Role().Get(model.NewId())
-	assert.NotNil(t, res3.Err)
+	_, err = ss.Role().Get(model.NewId())
+	assert.NotNil(t, err)
 }
 
 func testRoleStoreGetByName(t *testing.T, ss store.Store) {
@@ -188,15 +183,13 @@ func testRoleStoreGetByName(t *testing.T, ss store.Store) {
 		SchemeManaged: false,
 	}
 
-	res1 := <-ss.Role().Save(r1)
-	assert.Nil(t, res1.Err)
-	d1 := res1.Data.(*model.Role)
+	d1, err := ss.Role().Save(r1)
+	assert.Nil(t, err)
 	assert.Len(t, d1.Id, 26)
 
 	// Get a valid role
-	res2 := <-ss.Role().GetByName(d1.Name)
-	assert.Nil(t, res2.Err)
-	d2 := res1.Data.(*model.Role)
+	d2, err := ss.Role().GetByName(d1.Name)
+	assert.Nil(t, err)
 	assert.Equal(t, d1.Id, d2.Id)
 	assert.Equal(t, r1.Name, d2.Name)
 	assert.Equal(t, r1.DisplayName, d2.DisplayName)
@@ -205,8 +198,8 @@ func testRoleStoreGetByName(t *testing.T, ss store.Store) {
 	assert.Equal(t, r1.SchemeManaged, d2.SchemeManaged)
 
 	// Get an invalid role
-	res3 := <-ss.Role().GetByName(model.NewId())
-	assert.NotNil(t, res3.Err)
+	_, err = ss.Role().GetByName(model.NewId())
+	assert.NotNil(t, err)
 }
 
 func testRoleStoreGetByNames(t *testing.T, ss store.Store) {
@@ -245,26 +238,22 @@ func testRoleStoreGetByNames(t *testing.T, ss store.Store) {
 		SchemeManaged: false,
 	}
 
-	res1 := <-ss.Role().Save(r1)
-	assert.Nil(t, res1.Err)
-	d1 := res1.Data.(*model.Role)
+	d1, err := ss.Role().Save(r1)
+	assert.Nil(t, err)
 	assert.Len(t, d1.Id, 26)
 
-	res2 := <-ss.Role().Save(r2)
-	assert.Nil(t, res2.Err)
-	d2 := res2.Data.(*model.Role)
+	d2, err := ss.Role().Save(r2)
+	assert.Nil(t, err)
 	assert.Len(t, d2.Id, 26)
 
-	res3 := <-ss.Role().Save(r3)
-	assert.Nil(t, res3.Err)
-	d3 := res3.Data.(*model.Role)
+	d3, err := ss.Role().Save(r3)
+	assert.Nil(t, err)
 	assert.Len(t, d3.Id, 26)
 
 	// Get two valid roles.
 	n4 := []string{r1.Name, r2.Name}
-	res4 := <-ss.Role().GetByNames(n4)
-	assert.Nil(t, res4.Err)
-	roles4 := res4.Data.([]*model.Role)
+	roles4, err := ss.Role().GetByNames(n4)
+	assert.Nil(t, err)
 	assert.Len(t, roles4, 2)
 	assert.Contains(t, roles4, d1)
 	assert.Contains(t, roles4, d2)
@@ -272,16 +261,14 @@ func testRoleStoreGetByNames(t *testing.T, ss store.Store) {
 
 	// Get two invalid roles.
 	n5 := []string{model.NewId(), model.NewId()}
-	res5 := <-ss.Role().GetByNames(n5)
-	assert.Nil(t, res5.Err)
-	roles5 := res5.Data.([]*model.Role)
+	roles5, err := ss.Role().GetByNames(n5)
+	assert.Nil(t, err)
 	assert.Len(t, roles5, 0)
 
 	// Get one valid one and one invalid one.
 	n6 := []string{r1.Name, model.NewId()}
-	res6 := <-ss.Role().GetByNames(n6)
-	assert.Nil(t, res6.Err)
-	roles6 := res6.Data.([]*model.Role)
+	roles6, err := ss.Role().GetByNames(n6)
+	assert.Nil(t, err)
 	assert.Len(t, roles6, 1)
 	assert.Contains(t, roles6, d1)
 	assert.NotContains(t, roles6, d2)
@@ -302,33 +289,30 @@ func testRoleStoreDelete(t *testing.T, ss store.Store) {
 		SchemeManaged: false,
 	}
 
-	res1 := <-ss.Role().Save(r1)
-	assert.Nil(t, res1.Err)
-	d1 := res1.Data.(*model.Role)
+	d1, err := ss.Role().Save(r1)
+	assert.Nil(t, err)
 	assert.Len(t, d1.Id, 26)
 
 	// Check the role is there.
-	res2 := <-ss.Role().Get(d1.Id)
-	assert.Nil(t, res2.Err)
+	_, err = ss.Role().Get(d1.Id)
+	assert.Nil(t, err)
 
 	// Delete the role.
-	res3 := <-ss.Role().Delete(d1.Id)
-	assert.Nil(t, res3.Err)
+	_, err = ss.Role().Delete(d1.Id)
+	assert.Nil(t, err)
 
 	// Check the role is deleted there.
-	res4 := <-ss.Role().Get(d1.Id)
-	assert.Nil(t, res4.Err)
-	d2 := res4.Data.(*model.Role)
+	d2, err := ss.Role().Get(d1.Id)
+	assert.Nil(t, err)
 	assert.NotZero(t, d2.DeleteAt)
 
-	res5 := <-ss.Role().GetByName(d1.Name)
-	assert.Nil(t, res5.Err)
-	d3 := res5.Data.(*model.Role)
+	d3, err := ss.Role().GetByName(d1.Name)
+	assert.Nil(t, err)
 	assert.NotZero(t, d3.DeleteAt)
 
 	// Try and delete a role that does not exist.
-	res6 := <-ss.Role().Delete(model.NewId())
-	assert.NotNil(t, res6.Err)
+	_, err = ss.Role().Delete(model.NewId())
+	assert.NotNil(t, err)
 }
 
 func testRoleStorePermanentDeleteAll(t *testing.T, ss store.Store) {
@@ -356,17 +340,19 @@ func testRoleStorePermanentDeleteAll(t *testing.T, ss store.Store) {
 		SchemeManaged: false,
 	}
 
-	store.Must(ss.Role().Save(r1))
-	store.Must(ss.Role().Save(r2))
+	_, err := ss.Role().Save(r1)
+	require.Nil(t, err)
+	_, err = ss.Role().Save(r2)
+	require.Nil(t, err)
 
-	res1 := <-ss.Role().GetByNames([]string{r1.Name, r2.Name})
-	assert.Nil(t, res1.Err)
-	assert.Len(t, res1.Data.([]*model.Role), 2)
+	roles, err := ss.Role().GetByNames([]string{r1.Name, r2.Name})
+	assert.Nil(t, err)
+	assert.Len(t, roles, 2)
 
-	res2 := <-ss.Role().PermanentDeleteAll()
-	assert.Nil(t, res2.Err)
+	err = ss.Role().PermanentDeleteAll()
+	assert.Nil(t, err)
 
-	res3 := <-ss.Role().GetByNames([]string{r1.Name, r2.Name})
-	assert.Nil(t, res3.Err)
-	assert.Len(t, res3.Data.([]*model.Role), 0)
+	roles, err = ss.Role().GetByNames([]string{r1.Name, r2.Name})
+	assert.Nil(t, err)
+	assert.Len(t, roles, 0)
 }
diff --git a/store/storetest/scheme_store.go b/store/storetest/scheme_store.go
index c3d88d82c9..4753cc68e6 100644
--- a/store/storetest/scheme_store.go
+++ b/store/storetest/scheme_store.go
@@ -25,7 +25,7 @@ func TestSchemeStore(t *testing.T, ss store.Store) {
 }
 
 func createDefaultRoles(t *testing.T, ss store.Store) {
-	<-ss.Role().Save(&model.Role{
+	ss.Role().Save(&model.Role{
 		Name:        model.TEAM_ADMIN_ROLE_ID,
 		DisplayName: model.TEAM_ADMIN_ROLE_ID,
 		Permissions: []string{
@@ -33,7 +33,7 @@ func createDefaultRoles(t *testing.T, ss store.Store) {
 		},
 	})
 
-	<-ss.Role().Save(&model.Role{
+	ss.Role().Save(&model.Role{
 		Name:        model.TEAM_USER_ROLE_ID,
 		DisplayName: model.TEAM_USER_ROLE_ID,
 		Permissions: []string{
@@ -42,7 +42,7 @@ func createDefaultRoles(t *testing.T, ss store.Store) {
 		},
 	})
 
-	<-ss.Role().Save(&model.Role{
+	ss.Role().Save(&model.Role{
 		Name:        model.TEAM_GUEST_ROLE_ID,
 		DisplayName: model.TEAM_GUEST_ROLE_ID,
 		Permissions: []string{
@@ -50,7 +50,7 @@ func createDefaultRoles(t *testing.T, ss store.Store) {
 		},
 	})
 
-	<-ss.Role().Save(&model.Role{
+	ss.Role().Save(&model.Role{
 		Name:        model.CHANNEL_ADMIN_ROLE_ID,
 		DisplayName: model.CHANNEL_ADMIN_ROLE_ID,
 		Permissions: []string{
@@ -59,7 +59,7 @@ func createDefaultRoles(t *testing.T, ss store.Store) {
 		},
 	})
 
-	<-ss.Role().Save(&model.Role{
+	ss.Role().Save(&model.Role{
 		Name:        model.CHANNEL_USER_ROLE_ID,
 		DisplayName: model.CHANNEL_USER_ROLE_ID,
 		Permissions: []string{
@@ -68,7 +68,7 @@ func createDefaultRoles(t *testing.T, ss store.Store) {
 		},
 	})
 
-	<-ss.Role().Save(&model.Role{
+	ss.Role().Save(&model.Role{
 		Name:        model.CHANNEL_GUEST_ROLE_ID,
 		DisplayName: model.CHANNEL_GUEST_ROLE_ID,
 		Permissions: []string{
@@ -107,39 +107,33 @@ func testSchemeStoreSave(t *testing.T, ss store.Store) {
 	assert.Len(t, d1.DefaultChannelGuestRole, 26)
 
 	// Check the default roles were created correctly.
-	roleRes1 := <-ss.Role().GetByName(d1.DefaultTeamAdminRole)
-	assert.Nil(t, roleRes1.Err)
-	role1 := roleRes1.Data.(*model.Role)
+	role1, err := ss.Role().GetByName(d1.DefaultTeamAdminRole)
+	assert.Nil(t, err)
 	assert.Equal(t, role1.Permissions, []string{"delete_others_posts"})
 	assert.True(t, role1.SchemeManaged)
 
-	roleRes2 := <-ss.Role().GetByName(d1.DefaultTeamUserRole)
-	assert.Nil(t, roleRes2.Err)
-	role2 := roleRes2.Data.(*model.Role)
+	role2, err := ss.Role().GetByName(d1.DefaultTeamUserRole)
+	assert.Nil(t, err)
 	assert.Equal(t, role2.Permissions, []string{"view_team", "add_user_to_team"})
 	assert.True(t, role2.SchemeManaged)
 
-	roleRes3 := <-ss.Role().GetByName(d1.DefaultChannelAdminRole)
-	assert.Nil(t, roleRes3.Err)
-	role3 := roleRes3.Data.(*model.Role)
+	role3, err := ss.Role().GetByName(d1.DefaultChannelAdminRole)
+	assert.Nil(t, err)
 	assert.Equal(t, role3.Permissions, []string{"manage_public_channel_members", "manage_private_channel_members"})
 	assert.True(t, role3.SchemeManaged)
 
-	roleRes4 := <-ss.Role().GetByName(d1.DefaultChannelUserRole)
-	assert.Nil(t, roleRes4.Err)
-	role4 := roleRes4.Data.(*model.Role)
+	role4, err := ss.Role().GetByName(d1.DefaultChannelUserRole)
+	assert.Nil(t, err)
 	assert.Equal(t, role4.Permissions, []string{"read_channel", "create_post"})
 	assert.True(t, role4.SchemeManaged)
 
-	roleRes5 := <-ss.Role().GetByName(d1.DefaultTeamGuestRole)
-	assert.Nil(t, roleRes5.Err)
-	role5 := roleRes5.Data.(*model.Role)
+	role5, err := ss.Role().GetByName(d1.DefaultTeamGuestRole)
+	assert.Nil(t, err)
 	assert.Equal(t, role5.Permissions, []string{"view_team"})
 	assert.True(t, role5.SchemeManaged)
 
-	roleRes6 := <-ss.Role().GetByName(d1.DefaultChannelGuestRole)
-	assert.Nil(t, roleRes6.Err)
-	role6 := roleRes6.Data.(*model.Role)
+	role6, err := ss.Role().GetByName(d1.DefaultChannelGuestRole)
+	assert.Nil(t, err)
 	assert.Equal(t, role6.Permissions, []string{"read_channel", "create_post"})
 	assert.True(t, role6.SchemeManaged)
 
@@ -350,39 +344,33 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
 	assert.Len(t, d1.DefaultChannelGuestRole, 26)
 
 	// Check the default roles were created correctly.
-	roleRes1 := <-ss.Role().GetByName(d1.DefaultTeamAdminRole)
-	assert.Nil(t, roleRes1.Err)
-	role1 := roleRes1.Data.(*model.Role)
+	role1, err := ss.Role().GetByName(d1.DefaultTeamAdminRole)
+	assert.Nil(t, err)
 	assert.Equal(t, role1.Permissions, []string{"delete_others_posts"})
 	assert.True(t, role1.SchemeManaged)
 
-	roleRes2 := <-ss.Role().GetByName(d1.DefaultTeamUserRole)
-	assert.Nil(t, roleRes2.Err)
-	role2 := roleRes2.Data.(*model.Role)
+	role2, err := ss.Role().GetByName(d1.DefaultTeamUserRole)
+	assert.Nil(t, err)
 	assert.Equal(t, role2.Permissions, []string{"view_team", "add_user_to_team"})
 	assert.True(t, role2.SchemeManaged)
 
-	roleRes3 := <-ss.Role().GetByName(d1.DefaultChannelAdminRole)
-	assert.Nil(t, roleRes3.Err)
-	role3 := roleRes3.Data.(*model.Role)
+	role3, err := ss.Role().GetByName(d1.DefaultChannelAdminRole)
+	assert.Nil(t, err)
 	assert.Equal(t, role3.Permissions, []string{"manage_public_channel_members", "manage_private_channel_members"})
 	assert.True(t, role3.SchemeManaged)
 
-	roleRes4 := <-ss.Role().GetByName(d1.DefaultChannelUserRole)
-	assert.Nil(t, roleRes4.Err)
-	role4 := roleRes4.Data.(*model.Role)
+	role4, err := ss.Role().GetByName(d1.DefaultChannelUserRole)
+	assert.Nil(t, err)
 	assert.Equal(t, role4.Permissions, []string{"read_channel", "create_post"})
 	assert.True(t, role4.SchemeManaged)
 
-	roleRes5 := <-ss.Role().GetByName(d1.DefaultTeamGuestRole)
-	assert.Nil(t, roleRes5.Err)
-	role5 := roleRes5.Data.(*model.Role)
+	role5, err := ss.Role().GetByName(d1.DefaultTeamGuestRole)
+	assert.Nil(t, err)
 	assert.Equal(t, role5.Permissions, []string{"view_team"})
 	assert.True(t, role5.SchemeManaged)
 
-	roleRes6 := <-ss.Role().GetByName(d1.DefaultChannelGuestRole)
-	assert.Nil(t, roleRes6.Err)
-	role6 := roleRes6.Data.(*model.Role)
+	role6, err := ss.Role().GetByName(d1.DefaultChannelGuestRole)
+	assert.Nil(t, err)
 	assert.Equal(t, role6.Permissions, []string{"read_channel", "create_post"})
 	assert.True(t, role6.SchemeManaged)
 
@@ -395,34 +383,28 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
 	assert.NotZero(t, d2.DeleteAt)
 
 	// Check that the roles are deleted too.
-	roleRes7 := <-ss.Role().GetByName(d1.DefaultTeamAdminRole)
-	assert.Nil(t, roleRes7.Err)
-	role7 := roleRes7.Data.(*model.Role)
+	role7, err := ss.Role().GetByName(d1.DefaultTeamAdminRole)
+	assert.Nil(t, err)
 	assert.NotZero(t, role7.DeleteAt)
 
-	roleRes8 := <-ss.Role().GetByName(d1.DefaultTeamUserRole)
-	assert.Nil(t, roleRes8.Err)
-	role8 := roleRes8.Data.(*model.Role)
+	role8, err := ss.Role().GetByName(d1.DefaultTeamUserRole)
+	assert.Nil(t, err)
 	assert.NotZero(t, role8.DeleteAt)
 
-	roleRes9 := <-ss.Role().GetByName(d1.DefaultChannelAdminRole)
-	assert.Nil(t, roleRes9.Err)
-	role9 := roleRes9.Data.(*model.Role)
+	role9, err := ss.Role().GetByName(d1.DefaultChannelAdminRole)
+	assert.Nil(t, err)
 	assert.NotZero(t, role9.DeleteAt)
 
-	roleRes10 := <-ss.Role().GetByName(d1.DefaultChannelUserRole)
-	assert.Nil(t, roleRes10.Err)
-	role10 := roleRes10.Data.(*model.Role)
+	role10, err := ss.Role().GetByName(d1.DefaultChannelUserRole)
+	assert.Nil(t, err)
 	assert.NotZero(t, role10.DeleteAt)
 
-	roleRes11 := <-ss.Role().GetByName(d1.DefaultTeamGuestRole)
-	assert.Nil(t, roleRes11.Err)
-	role11 := roleRes11.Data.(*model.Role)
+	role11, err := ss.Role().GetByName(d1.DefaultTeamGuestRole)
+	assert.Nil(t, err)
 	assert.NotZero(t, role11.DeleteAt)
 
-	roleRes12 := <-ss.Role().GetByName(d1.DefaultChannelGuestRole)
-	assert.Nil(t, roleRes12.Err)
-	role12 := roleRes12.Data.(*model.Role)
+	role12, err := ss.Role().GetByName(d1.DefaultChannelGuestRole)
+	assert.Nil(t, err)
 	assert.NotZero(t, role12.DeleteAt)
 
 	// Try deleting a scheme that does not exist.
@@ -447,7 +429,7 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
 		Type:        model.TEAM_OPEN,
 		SchemeId:    &d4.Id,
 	}
-	t4, err := ss.Team().Save(t4)
+	t4, err = ss.Team().Save(t4)
 	require.Nil(t, err)
 
 	sres4 := <-ss.Scheme().Delete(d4.Id)