1
0
Fork 0

More in-mem and on-disk system test

master
Philip O'Toole 4 years ago
parent 8049d35431
commit 51c745ea23

@ -974,12 +974,9 @@ func (s *Store) Apply(l *raft.Log) (e interface{}) {
// been applied, but it wouldn't have created the on-disk database in that
// case since there were commands in the log. This is the very last chance
// to do convert from in-memory to on-disk.
b, err := s.db.Serialize()
b, _ := s.db.Serialize()
err := s.db.Close()
if err != nil {
e = &fsmGenericResponse{error: fmt.Errorf("serialize failed: %s", err)}
return
}
if err := s.db.Close(); err != nil {
e = &fsmGenericResponse{error: fmt.Errorf("close failed: %s", err)}
return
}

@ -19,6 +19,10 @@ import (
"github.com/rqlite/rqlite/testdata/x509"
)
const (
SnapshotInterval = time.Second
)
// Node represents a node under test.
type Node struct {
APIAddr string
@ -420,7 +424,7 @@ func mustNodeEncryptedOnDisk(dir string, enableSingle, httpEncrypt bool, tn stor
ID: id,
})
node.Store.SnapshotThreshold = 100
node.Store.SnapshotInterval = mustParseDuration("1s")
node.Store.SnapshotInterval = SnapshotInterval
if err := node.Store.Open(enableSingle); err != nil {
node.Deprovision()

@ -378,34 +378,47 @@ func Test_SingleNodeReopen(t *testing.T) {
// Test_SingleNodeReopen tests that a node can be re-opened OK, with
// a non-database command in the log.
func Test_SingleNodeNoopReopen(t *testing.T) {
dir := mustTempDir()
tn := mustNewOpenTransport("")
node := mustNodeEncrypted(dir, true, false, tn, "")
onDisk := false
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader")
}
for {
t.Logf("running test, on-disk=%v", onDisk)
if err := node.Noop("#1"); err != nil {
t.Fatalf("failed to write noop command: %s", err)
}
dir := mustTempDir()
tn := mustNewOpenTransport("")
node := mustNodeEncryptedOnDisk(dir, true, false, tn, "", false)
if err := node.Close(true); err != nil {
t.Fatalf("failed to close node")
}
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader")
}
if err := tn.Open("localhost:0"); err != nil {
t.Fatalf("failed to re-open transport: %s", err)
}
if err := node.Store.Open(true); err != nil {
t.Fatalf("failed to re-open store: %s", err)
}
if err := node.Service.Start(); err != nil {
t.Fatalf("failed to restart service: %s", err)
}
if err := node.Noop("#1"); err != nil {
t.Fatalf("failed to write noop command: %s", err)
}
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader")
if err := node.Close(true); err != nil {
t.Fatalf("failed to close node")
}
if err := tn.Open("localhost:0"); err != nil {
t.Fatalf("failed to re-open transport: %s", err)
}
if err := node.Store.Open(true); err != nil {
t.Fatalf("failed to re-open store: %s", err)
}
if err := node.Service.Start(); err != nil {
t.Fatalf("failed to restart service: %s", err)
}
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader")
}
node.Deprovision()
// Switch to other mode for another test.
onDisk = !onDisk
if onDisk == false {
break
}
}
}
@ -455,7 +468,6 @@ func Test_SingleNodeNoopSnapReopen(t *testing.T) {
}
node.Deprovision()
onDisk = !onDisk
if onDisk == false {
break
@ -469,6 +481,7 @@ func Test_SingleNodeNoopSnapReopen(t *testing.T) {
// contain database data. This shouldn't happen in real systems
func Test_SingleNodeNoopSnapLogsReopen(t *testing.T) {
onDisk := false
var raftAddr string
for {
t.Logf("running test, on-disk=%v", onDisk)
@ -476,6 +489,8 @@ func Test_SingleNodeNoopSnapLogsReopen(t *testing.T) {
dir := mustTempDir()
tn := mustNewOpenTransport("")
node := mustNodeEncryptedOnDisk(dir, true, false, tn, "", onDisk)
raftAddr = node.RaftAddr
t.Logf("node listening for Raft on %s", raftAddr)
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader")
@ -487,9 +502,8 @@ func Test_SingleNodeNoopSnapLogsReopen(t *testing.T) {
}
}
// Wait for a snapshot to happen.
time.Sleep(10 * time.Second)
// Wait for a snapshot to happen, and then write some more commands.
time.Sleep(5 * time.Second)
for i := 0; i < 5; i++ {
if err := node.Noop(fmt.Sprintf("%d", i)); err != nil {
t.Fatalf("failed to write noop command: %s", err)
@ -500,22 +514,66 @@ func Test_SingleNodeNoopSnapLogsReopen(t *testing.T) {
t.Fatalf("failed to close node")
}
if err := tn.Open("localhost:0"); err != nil {
// Reset network state in node.
if err := tn.Open(raftAddr); err != nil {
t.Fatalf("failed to re-open transport: %s", err)
}
if err := node.Store.Open(true); err != nil {
t.Fatalf("failed to re-open store: %s", err)
}
if err := node.Service.Start(); err != nil {
t.Fatalf("failed to restart service: %s", err)
}
// This testing tells service to restart with localhost:0
// again, so explicitly set the API address again.
node.APIAddr = node.Service.Addr().String()
if _, err := node.WaitForLeader(); err != nil {
t.Fatalf("node never became leader")
}
node.Deprovision()
// Ensure node is fully functional after restart.
tests := []struct {
stmt []interface{}
expected string
execute bool
}{
{
stmt: []interface{}{"CREATE TABLE foo (id integer not null primary key, name text, age integer)"},
expected: `{"results":[{}]}`,
execute: true,
},
{
stmt: []interface{}{"INSERT INTO foo(name, age) VALUES(?, ?)", "fiona", 20},
expected: `{"results":[{"last_insert_id":1,"rows_affected":1}]}`,
execute: true,
},
{
stmt: []interface{}{"SELECT * FROM foo WHERE NAME=?", "fiona"},
expected: `{"results":[{"columns":["id","name","age"],"types":["integer","text","integer"],"values":[[1,"fiona",20]]}]}`,
execute: false,
},
}
for i, tt := range tests {
var r string
var err error
if tt.execute {
r, err = node.ExecuteParameterized(tt.stmt)
} else {
r, err = node.QueryParameterized(tt.stmt)
}
if err != nil {
t.Fatalf(`test %d failed "%s": %s`, i, tt.stmt, err.Error())
}
if r != tt.expected {
t.Fatalf(`test %d received wrong result "%s" got: %s exp: %s`, i, tt.stmt, r, tt.expected)
}
}
node.Deprovision()
// Switch to other mode for another test.
onDisk = !onDisk
if onDisk == false {
break

Loading…
Cancel
Save