예제 #1
0
파일: manager.go 프로젝트: utamaro/core
//New reeturns Manager obj.
func New(cfg *config.Config, rootPath string) (*Manager, error) {
	self := peer.NewSelf(cfg, rootPath)
	m := &Manager{
		self: self,
	}
	p := self.ToPeer()
	recent, err := p.ReadRecent()
	if log.If(err) {
		log.Println(err)
	}
	m.recent, err = thread.NewList(self, recent)
	m.peers, err = p.ReadPeers()
	log.If(err)
	if len(m.peers) == 0 {
		m.peers = self.LoadInitPeers()
	}
	m.tags, err = p.ReadTags()
	log.If(err)
	m.spams, err = p.ReadSpams()
	log.If(err)
	m.readThreads = self.ReadThreads()
	if err := self.StartListen(m.accept); log.If(err) {
		return nil, err
	}
	go func() {
		for {
			m.cron()
			time.Sleep(time.Hour)
		}
	}()
	return m, nil
}
예제 #2
0
파일: record_test.go 프로젝트: utamaro/core
func TestRecord(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)
	cont := map[string][]byte{
		"test1": []byte("data1"),
		"test2": []byte("data2"),
	}
	r, err := New(self, "test", time.Now(), cont, true)
	if err != nil {
		t.Fatal(err)
	}
	s, err := r.Signer()
	if err != nil {
		t.Fatal(err)
	}
	if s != self.NodeName() {
		t.Fatal("illegal singer")
	}

	dag, err := r.ToDAGNode()
	if err != nil {
		t.Fatal(err)
	}
	r2, err := FromDAGNode(self, dag, r.Sign)
	if err != nil {
		t.Fatal(err)
	}
	if !r.Equals(r2) {
		t.Fatal("illegal equals")
	}

}
예제 #3
0
파일: thread_test.go 프로젝트: utamaro/core
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")
	}
}
예제 #4
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")
	}

}