Exemple #1
0
func TestSegmentMethods(t *testing.T) {
	engine, _ := origins.Init("memory", nil)

	id := uuid.NewV4()
	next := uuid.NewV4()

	now := chrono.Norm(time.Now().UTC())

	s := Segment{
		UUID:        &id,
		Transaction: 10,
		Domain:      "testing",
		Time:        now,
		Blocks:      5,
		Count:       4800,
		Bytes:       460800,
		Next:        &next,
		Base:        &next,
	}

	_, err := SetSegment(engine, "testing", &s)

	if err != nil {
		t.Error(err)
	}

	s2, err := GetSegment(engine, "testing", &id)

	if err != nil {
		t.Error(err)
	}

	assert.Equal(t, s.Transaction, s2.Transaction)
	assert.Equal(t, *s.Next, *s2.Next)
}
Exemple #2
0
func BenchmarkGetSegment(b *testing.B) {
	engine, _ := origins.Init("memory", nil)

	id := uuid.NewV4()
	next := uuid.NewV4()

	now := chrono.Norm(time.Now().UTC())

	s := &Segment{
		UUID:        &id,
		Transaction: 10,
		Domain:      "testing",
		Time:        now,
		Blocks:      5,
		Count:       4800,
		Bytes:       460800,
		Next:        &next,
		Base:        &next,
	}

	SetSegment(engine, "testing", s)

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		GetSegment(engine, "testing", &id)
	}
}
Exemple #3
0
func TestLogMethods(t *testing.T) {
	engine, _ := origins.Init("memory", nil)

	id := uuid.NewV4()

	l := Log{
		Name:   "commit",
		Domain: "testing",
		Head:   &id,
	}

	_, err := SetLog(engine, "testing", &l)

	if err != nil {
		t.Error(err)
	}

	l2, err := GetLog(engine, "testing", "commit")

	if err != nil {
		t.Error(err)
	}

	assert.Equal(t, l.Name, l2.Name)
	assert.Equal(t, l.Domain, l2.Domain)
	assert.Equal(t, *l.Head, *l2.Head)
}
Exemple #4
0
func TestSegment(t *testing.T) {
	engine, err := origins.Init("mem", nil)

	segment := NewSegment(engine, "test", 1)

	gen := testutil.NewRandGenerator("test", 1, 0)

	var (
		f *origins.Fact
		n = 10000
	)

	// Write facts to segment.
	for i := 0; i < n; i++ {
		f = gen.Next()

		if err = segment.Write(f); err != nil {
			t.Fatal(err)
		}
	}

	// Compare counts.
	if segment.Count != n {
		t.Errorf("segment: expected %d count, got %d", n, segment.Count)
	}

	// Compare expected number of blocks.
	if segment.Blocks != n/blockSize {
		t.Errorf("segment: expected %d blocks, got %d", n/blockSize, segment.Blocks)
	}

	// Validate the blocks have been written to storage (even though the
	// data has been committed).
	id := segment.UUID

	for i := 0; i < segment.Blocks; i++ {
		bl, _ := dal.GetBlock(engine, "test", id, i)

		if bl == nil {
			t.Errorf("segment: block %s.%d is nil", id, i)
		}
	}

	// Abort the segment.
	if err = segment.Abort(engine); err != nil {
		t.Error("segment: abort failed %s", err)
	}

	for i := 0; i < segment.Blocks; i++ {
		bl, _ := dal.GetBlock(engine, "test", id, i)

		if bl != nil {
			t.Fatalf("segment: %s.%d should be nil", id, i)
		}
	}
}
Exemple #5
0
func BenchmarkSetLog(b *testing.B) {
	engine, _ := origins.Init("memory", nil)

	id := uuid.NewV4()

	l := &Log{
		Name: "commit",
		Head: &id,
	}

	for i := 0; i < b.N; i++ {
		SetLog(engine, "testing", l)
	}
}
Exemple #6
0
func TestBlockMethods(t *testing.T) {
	engine, _ := origins.Init("memory", nil)

	id := uuid.NewV4()
	idx := 0

	f := &origins.Fact{
		Domain: "testing",

		Operation: origins.Assertion,

		Transaction: 5,

		Time: chrono.Norm(time.Now()),

		Entity: &origins.Ident{
			Domain: "testing",
			Name:   "field",
		},

		Attribute: &origins.Ident{
			Domain: "testing",
			Name:   "dataType",
		},

		Value: &origins.Ident{
			Name: "string",
		},
	}

	encoder := NewBlockEncoder()

	for i := 0; i < 1000; i++ {
		encoder.Write(f)
	}

	_, err := SetBlock(engine, "testing", &id, idx, encoder.Bytes())

	if err != nil {
		t.Error(err)
	}

	_, err = GetBlock(engine, "testing", &id, idx)

	if err != nil {
		t.Error(err)
	}
}
Exemple #7
0
// Initializes an in-memory store and generates n transactions each with m
// randomly generated facts that belong to one of the specified domains.
func randMultidomainStorage(domains []string, n, m int) storage.Engine {
	engine, _ := origins.Init("memory", nil)

	for i := 0; i < m; i++ {
		tx, _ := transactor.New(engine, transactor.Options{
			AllowDuplicates: true,
		})

		gen := testutil.NewMultidomainGenerator(domains, tx.ID, n)

		origins.Copy(gen, tx)
		tx.Commit()
	}

	return engine
}
Exemple #8
0
// Initializes an in-memory store and generates n transactions each with m
// facts randomly generated from the same dictionary of possible E, A, V values.
// Varying the size of the dictionary relative to the size of the store
// allows to guarantee repeating facts.
func randStorageWRepeats(domain string, n, m, eLen, aLen, vLen int) storage.Engine {
	engine, _ := origins.Init("memory", nil)

	dictionary := testutil.NewEAVDictionary(eLen, aLen, vLen)

	for i := 0; i < m; i++ {
		tx, _ := transactor.New(engine, transactor.Options{
			AllowDuplicates: true,
		})

		gen := testutil.NewDictionaryBasedGenerator(dictionary, domain, tx.ID, n)

		origins.Copy(gen, tx)
		tx.Commit()
	}

	return engine
}
Exemple #9
0
func setup() storage.Engine {
	engine, _ := origins.Init("memory", nil)

	data, _ := testutil.Asset("assets/origins.csv")

	iter := origins.NewCSVReader(bytes.NewBuffer(data))

	tx, _ := transactor.New(engine, transactor.Options{})

	// Write the facts.
	if _, err := origins.Copy(iter, tx); err != nil {
		panic(err)
	}

	tx.Commit()

	return engine
}
Exemple #10
0
func BenchmarkGetBlock(b *testing.B) {
	engine, _ := origins.Init("memory", nil)

	id := uuid.NewV4()
	idx := 0

	f := &origins.Fact{
		Domain: "testing",

		Operation: origins.Assertion,

		Transaction: 5,

		Time: chrono.Norm(time.Now()),

		Entity: &origins.Ident{
			Domain: "testing",
			Name:   "field",
		},

		Attribute: &origins.Ident{
			Domain: "testing",
			Name:   "dataType",
		},

		Value: &origins.Ident{
			Name: "string",
		},
	}

	encoder := NewBlockEncoder()

	for i := 0; i < 1000; i++ {
		encoder.Write(f)
	}

	SetBlock(engine, "testing", &id, idx, encoder.Bytes())

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		GetBlock(engine, "testing", &id, idx)
	}
}
Exemple #11
0
func benchSegmentSize(b *testing.B, n int) {
	engine, _ := origins.Init("mem", nil)

	var f *origins.Fact

	for i := 0; i < b.N; i++ {
		gen := testutil.NewRandGenerator("test", 1, n)
		segment := NewSegment(engine, "test", 1)

		for j := 0; j < n; j++ {
			f = gen.Next()
			segment.Write(f)
		}

		engine.Multi(func(tx storage.Tx) error {
			return segment.Commit(tx)
		})
	}
}
Exemple #12
0
func benchSegmentBlockSize(b *testing.B, bs int) {
	engine, _ := origins.Init("mem", nil)

	blockSize = bs

	var f *origins.Fact

	gen := testutil.NewRandGenerator("test", 1, 0)

	segment := NewSegment(engine, "test", 1)

	for i := 0; i < b.N; i++ {
		f = gen.Next()
		segment.Write(f)
	}

	engine.Multi(func(tx storage.Tx) error {
		return segment.Commit(tx)
	})

	blockSize = 1000
}
Exemple #13
0
// Commands can call this if it requires use of the store.
func initStorage() storage.Engine {
	// Name of the storage engine.
	name := viper.GetString("storage")
	path := viper.GetString("path")

	// Directory of the config file. Ensure the storage engine
	// path is resolved relative to the config file.
	dir := filepath.Dir(viper.ConfigFileUsed())
	path = filepath.Join(dir, path)

	// Supported options.
	opts := storage.Options{
		"path": path,
	}

	// Initialize the storage engine.
	engine, err := origins.Init(name, &opts)

	if err != nil {
		logrus.Fatal("storage:", err)
	}

	return engine
}