//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
}
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")
}
}
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")
}
}
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")
}
}