Esempio n. 1
0
//AddRecord adds a record and returns true if updated.
func (m *Manager) AddRecord(thread string, stamp time.Time, contents map[string][]byte, sign bool) (bool, error) {
	r, err := record.New(m.self, thread, stamp, contents, sign)
	if log.If(err) {
		return false, err
	}
	m.mutex.Lock()
	defer m.mutex.Unlock()
	return m.recent.Add(r)
}
Esempio n. 2
0
func TestThread(t *testing.T) {
	const (
		rootPath = "test"
	)

	jsonstr := `
{
"max_connection":12,
"file_dir":".",
"run_dir":"rundir",
"option":"option"
} 
`
	if err := ioutil.WriteFile("test.json", []byte(jsonstr), 0644); err != nil {
		t.Error(err)
	}
	var cfg config.Config
	config.Load(rootPath, ".", &cfg)
	cfg.SetDefaults()
	self := peer.NewSelf(&cfg, rootPath)
	log.Println("start")
	cont := map[string][]byte{
		"test1": []byte("data1"),
		"test2": []byte("data2"),
	}
	r1, err := record.New(self, "testA", time.Now(), cont, true)
	if err != nil {
		t.Fatal(err)
	}
	cont2 := map[string][]byte{
		"test3": []byte("data1"),
		"test4": []byte("data2"),
	}
	r2, err := record.New(self, "testA", time.Now().Add(-time.Hour), cont2, true)
	if err != nil {
		t.Fatal(err)
	}
	cont3 := map[string][]byte{
		"test5": []byte("data1"),
		"test6": []byte("data2"),
	}
	r3, err := record.New(self, "testA", time.Now(), cont3, true)
	if err != nil {
		t.Fatal(err)
	}
	th, err := New(self, "testA", "")
	if err != nil {
		t.Fatal(err)
	}
	if _, err = th.Add(r1); err != nil {
		t.Fatal(err)
	}
	recs1, err := th.Slice(0, 3, nil)
	log.Println("1 length", len(recs1))
	if _, err = th.Add(r2); err != nil {
		t.Fatal(err)
	}
	recs2, err := th.Slice(0, 3, nil)
	log.Println("2 length", len(recs2))
	if _, err = th.Add(r3); err != nil {
		t.Fatal(err)
	}
	recs, err := th.Slice(0, 3, nil)
	if err != nil {
		t.Fatal(err)
	}
	if len(recs) != 3 {
		t.Fatal("illegal slice length", len(recs))
	}
	if !recs[0].Equals(r3) {
		t.Fatal("illegal slice")
	}
	if !recs[1].Equals(r1) {
		t.Fatal("illegal slice")
	}
	if !recs[2].Equals(r2) {
		t.Fatal("illegal slice")
	}
	cont4 := map[string][]byte{
		"test7": []byte("data1"),
		"test8": []byte("data2"),
	}
	r4, err := record.New(self, "testA", time.Now(), cont4, true)
	th2, err := New(self, "testA", "")
	if err != nil {
		t.Fatal(err)
	}
	updated, err := th2.Add(r1)
	if err != nil {
		t.Fatal(err)
	}
	if !updated {
		t.Fatal("illegal updated flag")
	}
	if _, err = th2.Add(r4); err != nil {
		t.Fatal(err)
	}
	if _, err = th2.Add(r3); err != nil {
		t.Fatal(err)
	}
	updated, err = th.Merge(th2.Key())
	if err != nil {
		t.Fatal(err)
	}
	if !updated {
		t.Fatal("illegal updated flag")
	}
	recs, err = th.Slice(0, 4, nil)
	if err != nil {
		t.Fatal(err)
	}
	if len(recs) != 4 {
		t.Fatal("illegal slice length", len(recs))
	}
	if !recs[0].Equals(r4) {
		t.Fatal("illegal slice")
	}
	if !recs[1].Equals(r3) {
		t.Fatal("illegal slice")
	}
	if !recs[2].Equals(r1) {
		t.Fatal("illegal slice")
	}
	if !recs[3].Equals(r2) {
		t.Fatal("illegal slice")
	}
}
Esempio n. 3
0
func TestThreadList(t *testing.T) {
	const (
		rootPath = "test"
	)

	jsonstr := `
{
"max_connection":12,
"file_dir":".",
"run_dir":"rundir",
"option":"option"
} 
`
	if err := ioutil.WriteFile("test.json", []byte(jsonstr), 0644); err != nil {
		t.Error(err)
	}
	var cfg config.Config
	config.Load(rootPath, ".", &cfg)
	cfg.SetDefaults()
	self := peer.NewSelf(&cfg, rootPath)
	log.Println("start")
	cont := map[string][]byte{
		"test1": []byte("data1"),
		"test2": []byte("data2"),
	}
	r1, err := record.New(self, "testA", time.Now(), cont, true)
	if err != nil {
		t.Fatal(err)
	}
	cont2 := map[string][]byte{
		"test3": []byte("data1"),
		"test4": []byte("data2"),
	}
	r2, err := record.New(self, "testB", time.Now(), cont2, true)
	if err != nil {
		t.Fatal(err)
	}
	cont3 := map[string][]byte{
		"test5": []byte("data1"),
		"test6": []byte("data2"),
	}
	r3, err := record.New(self, "testC", time.Now(), cont3, true)
	cont4 := map[string][]byte{
		"test7": []byte("data1"),
		"test8": []byte("data2"),
	}
	nowt := time.Now()
	r4, err := record.New(self, "testB", nowt, cont4, true)
	if err != nil {
		t.Fatal(err)
	}
	tl, err := NewList(self, "")
	if err != nil {
		t.Fatal(err)
	}
	if _, err = tl.Add(r1); err != nil {
		t.Fatal(err)
	}
	if _, err = tl.Add(r2); err != nil {
		t.Fatal(err)
	}
	if _, err = tl.Add(r3); err != nil {
		t.Fatal(err)
	}
	if _, err = tl.Add(r4); err != nil {
		t.Fatal(err)
	}
	th, err := tl.GetThread("testB")
	if err != nil {
		t.Fatal(err)
	}
	sl, err := th.Slice(0, 10, nil)
	if len(sl) != 2 {
		t.Fatal("illegal slice")
	}
	re, err := tl.Recent()
	if err != nil {
		t.Fatal(err)
	}
	if len(re) != 3 {
		t.Fatal("illegal recent")
	}
	if re[0].Thread != "testB" || !re[0].Stamp.Equal(nowt) {
		t.Fatal("illegal recent")
	}
	if re[1].Thread != "testC" {
		t.Fatal("illegal recent")
	}
	if re[2].Thread != "testA" {
		t.Fatal("illegal recent")
	}
	tl2, err := NewList(self, "")
	if err != nil {
		t.Fatal(err)
	}
	if _, err = tl2.Add(r1); err != nil {
		t.Fatal(err)
	}
	if _, err = tl2.Add(r3); err != nil {
		t.Fatal(err)
	}
	if _, err = tl2.Add(r4); err != nil {
		t.Fatal(err)
	}
	cont5 := map[string][]byte{
		"test9":  []byte("data1"),
		"test10": []byte("data2"),
	}
	r5, err := record.New(self, "testD", time.Now(), cont5, true)
	if _, err = tl2.Add(r5); err != nil {
		t.Fatal(err)
	}
	updated, err := tl.Merge(tl2.Key())
	if err != nil {
		t.Fatal(err)
	}
	if !updated {
		t.Fatal("illegal update flag")
	}
	re, err = tl.Recent()
	if err != nil {
		t.Fatal(err)
	}
	if len(re) != 4 {
		t.Fatal("illegal recent", len(re))
	}
	if re[0].Thread != "testD" {
		t.Fatal("illegal recent")
	}
	if re[1].Thread != "testB" {
		t.Fatal("illegal recent")
	}
	if re[2].Thread != "testC" {
		t.Fatal("illegal recent")
	}
	if re[3].Thread != "testA" {
		t.Fatal("illegal recent")
	}

}