sql: use a closure to wrap transactions (#469)

This introduces the a `WithTransaction` function, which is then used for all transactional work in Steve.

Because `WithTransaction` takes care of all `Begin`s, `Commit`s and `Rollback`s, it eliminates the problem where forgotten open transactions can block all other operations (with long stalling and `SQLITE_BUSY` errors).

This also:

- merges together the disparate `DBClient` interfaces in one only `db.Client` interface with one unexported non-test implementation. I found this much easier to follow
- refactors the transaction package in order to make it as minimal as possible, and as close to the wrapped `sql.Tx` and `sql.Stmt` functions as possible, in order to reduce cognitive load when working with this part of the codebase
- simplifies tests accordingly
- adds a couple of known files to `.gitignore`
    
Credits to @tomleb for suggesting the approach: https://github.com/rancher/lasso/pull/121#pullrequestreview-2515872507

pkg/sqlcache/store/transaction_mocks_test.go

@@ -0,0 +1,157 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/rancher/steve/pkg/sqlcache/db/transaction (interfaces: Stmt,Client)
+//
+// Generated by this command:
+//
+//	mockgen --build_flags=--mod=mod -package store -destination ./transaction_mocks_test.go -mock_names Client=MockTXClient github.com/rancher/steve/pkg/sqlcache/db/transaction Stmt,Client
+//
+
+// Package store is a generated GoMock package.
+package store
+
+import (
+	context "context"
+	sql "database/sql"
+	reflect "reflect"
+
+	transaction "github.com/rancher/steve/pkg/sqlcache/db/transaction"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockStmt is a mock of Stmt interface.
+type MockStmt struct {
+	ctrl     *gomock.Controller
+	recorder *MockStmtMockRecorder
+}
+
+// MockStmtMockRecorder is the mock recorder for MockStmt.
+type MockStmtMockRecorder struct {
+	mock *MockStmt
+}
+
+// NewMockStmt creates a new mock instance.
+func NewMockStmt(ctrl *gomock.Controller) *MockStmt {
+	mock := &MockStmt{ctrl: ctrl}
+	mock.recorder = &MockStmtMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockStmt) EXPECT() *MockStmtMockRecorder {
+	return m.recorder
+}
+
+// Exec mocks base method.
+func (m *MockStmt) Exec(arg0 ...any) (sql.Result, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{}
+	for _, a := range arg0 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Exec", varargs...)
+	ret0, _ := ret[0].(sql.Result)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Exec indicates an expected call of Exec.
+func (mr *MockStmtMockRecorder) Exec(arg0 ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockStmt)(nil).Exec), arg0...)
+}
+
+// Query mocks base method.
+func (m *MockStmt) Query(arg0 ...any) (*sql.Rows, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{}
+	for _, a := range arg0 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Query", varargs...)
+	ret0, _ := ret[0].(*sql.Rows)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Query indicates an expected call of Query.
+func (mr *MockStmtMockRecorder) Query(arg0 ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockStmt)(nil).Query), arg0...)
+}
+
+// QueryContext mocks base method.
+func (m *MockStmt) QueryContext(arg0 context.Context, arg1 ...any) (*sql.Rows, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{arg0}
+	for _, a := range arg1 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "QueryContext", varargs...)
+	ret0, _ := ret[0].(*sql.Rows)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// QueryContext indicates an expected call of QueryContext.
+func (mr *MockStmtMockRecorder) QueryContext(arg0 any, arg1 ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryContext", reflect.TypeOf((*MockStmt)(nil).QueryContext), varargs...)
+}
+
+// MockTXClient is a mock of Client interface.
+type MockTXClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockTXClientMockRecorder
+}
+
+// MockTXClientMockRecorder is the mock recorder for MockTXClient.
+type MockTXClientMockRecorder struct {
+	mock *MockTXClient
+}
+
+// NewMockTXClient creates a new mock instance.
+func NewMockTXClient(ctrl *gomock.Controller) *MockTXClient {
+	mock := &MockTXClient{ctrl: ctrl}
+	mock.recorder = &MockTXClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockTXClient) EXPECT() *MockTXClientMockRecorder {
+	return m.recorder
+}
+
+// Exec mocks base method.
+func (m *MockTXClient) Exec(arg0 string, arg1 ...any) (sql.Result, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{arg0}
+	for _, a := range arg1 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Exec", varargs...)
+	ret0, _ := ret[0].(sql.Result)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Exec indicates an expected call of Exec.
+func (mr *MockTXClientMockRecorder) Exec(arg0 any, arg1 ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockTXClient)(nil).Exec), varargs...)
+}
+
+// Stmt mocks base method.
+func (m *MockTXClient) Stmt(arg0 *sql.Stmt) transaction.Stmt {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Stmt", arg0)
+	ret0, _ := ret[0].(transaction.Stmt)
+	return ret0
+}
+
+// Stmt indicates an expected call of Stmt.
+func (mr *MockTXClientMockRecorder) Stmt(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stmt", reflect.TypeOf((*MockTXClient)(nil).Stmt), arg0)
+}