Exemple #1
0
func TestChannel(t *testing.T) {
	logger := New("logger", 1)

	lastValue := sync2.AtomicString{}
	svm := sync2.ServiceManager{}
	svm.Go(func(_ *sync2.ServiceManager) {
		ch := logger.Subscribe(nil)
		defer logger.Unsubscribe(ch)
		for svm.State() == sync2.SERVICE_RUNNING {
			lastValue.Set(<-ch)
		}
	})

	time.Sleep(10 * time.Millisecond)
	if sz := logger.size.Get(); sz != 1 {
		t.Errorf("want 1, got %d", sz)
	}
	logger.Send(&logMessage{"val2"})
	time.Sleep(10 * time.Millisecond)
	if lastValue.Get() != "val2\n" {
		t.Errorf("want val2\\n, got %q", lastValue.Get())
	}

	go logger.Send(&logMessage{"val3"})
	svm.Stop()
	time.Sleep(10 * time.Millisecond)
	if sz := logger.size.Get(); sz != 0 {
		t.Errorf("want 0, got %d", sz)
	}
}
func TestFileInfo(t *testing.T) {
	fname := path.Join(os.TempDir(), "binlog_streamer.test")
	writer, err := os.Create(fname)
	if err != nil {
		t.Fatal(err)
	}
	defer os.Remove(fname)
	var file fileInfo
	err = file.Init(fname, 0)
	if err != nil {
		t.Fatal(err)
	}
	ch := make(chan []byte, 10)
	var svm = sync2.ServiceManager{}
	svm.Go(func(svc *sync2.ServiceContext) error {
		for svm.State() == sync2.SERVICE_RUNNING {
			file.WaitForChange(svc)
			b := make([]byte, 128)
			n, err := file.handle.Read(b)
			if err != nil {
				ch <- []byte(err.Error())
			}
			file.Set(file.lastPos + int64(n))
			ch <- b[:n]
		}
		return nil
	})

	want := "Message1"
	writer.WriteString(want)
	writer.Sync()
	got := string(<-ch)
	if want != got {
		t.Errorf("want %v, got %v", want, got)
	}

	want = "Message2"
	writer.WriteString(want)
	writer.Sync()
	got = string(<-ch)
	if want != got {
		t.Errorf("want %v, got %v", want, got)
	}

	time.Sleep(200 * time.Millisecond)
	want = "Message3"
	writer.WriteString(want)
	writer.Sync()
	got = string(<-ch)
	if want != got {
		t.Errorf("want %v, got %v", want, got)
	}

	want = "EOF"
	svm.Stop()
	got = string(<-ch)
	if want != got {
		t.Errorf("want %v, got %v", want, got)
	}
}
Exemple #3
0
func (f *fileInfo) WaitForChange(svm *sync2.ServiceManager) error {
	for {
		// Stop waiting if we're shutting down
		if svm.State() != sync2.SERVICE_RUNNING {
			return io.EOF
		}
		time.Sleep(100 * time.Millisecond)
		fi, err := f.handle.Stat()
		if err != nil {
			return fmt.Errorf("stat error: %v", err)
		}
		if fi.Size() != f.pos {
			return nil
		}
	}
}
Exemple #4
0
func TestHTTP(t *testing.T) {
	l, err := net.Listen("tcp", ":0")
	if err != nil {
		t.Fatal(err)
	}
	addr := l.Addr().String()
	go http.Serve(l, nil)

	logger := New("logger", 1)
	logger.ServeLogs("/log")

	// This should not block
	logger.Send(&logMessage{"val1"})

	lastValue := sync2.AtomicString{}
	svm := sync2.ServiceManager{}
	svm.Go(func(_ *sync2.ServiceManager) {
		resp, err := http.Get(fmt.Sprintf("http://%s/log", addr))
		if err != nil {
			t.Fatal(err)
		}
		defer resp.Body.Close()
		buf := make([]byte, 100)
		for svm.State() == sync2.SERVICE_RUNNING {
			n, err := resp.Body.Read(buf)
			if err != nil {
				t.Fatal(err)
			}
			lastValue.Set(string(buf[:n]))
		}
	})

	time.Sleep(100 * time.Millisecond)
	if sz := logger.size.Get(); sz != 1 {
		t.Errorf("want 1, got %d", sz)
	}
	logger.Send(&logMessage{"val2"})
	time.Sleep(100 * time.Millisecond)
	if lastValue.Get() != "val2\n" {
		t.Errorf("want val2\\n, got %q", lastValue.Get())
	}

	// This part of the test is flaky.
	// Uncomment for one-time testing.
	/*
		// This send will unblock the http client
		// which will allow it to see the stop request
		// from svm.
		go logger.Send(&logMessage{"val3"})
		svm.Stop()
		// You have to send a few times before the writer
		// returns an error.
		for i := 0; i < 10; i++ {
			time.Sleep(100 * time.Millisecond)
			logger.Send(&logMessage{"val4"})
		}
		time.Sleep(100 * time.Millisecond)
		if sz := logger.size.Get(); sz != 0 {
			t.Errorf("want 0, got %d", sz)
		}
	*/
}