func (s *S) TestReconnect(c *C) { l, err := net.Listen("tcp", ":0") c.Assert(err, IsNil) err = l.Close() c.Assert(err, IsNil) msgc := make(chan *rfc5424.Message) handler := func(msg *rfc5424.Message) { msgc <- msg } addr := l.Addr().String() _, err = s.discd.AddServiceAndRegister("test-reconnect", addr) c.Assert(err, IsNil) donec := make(chan struct{}) defer close(donec) sc, err := connect(s.discd, "test-reconnect", donec) c.Assert(err, IsNil) l, err = net.Listen("tcp", addr) c.Assert(err, IsNil) go runServer(l, handler) want := rfc5424.NewMessage(&rfc5424.Header{Version: 1}, []byte("test message")) _, err = sc.Write(rfc6587.Bytes(want)) c.Assert(err, IsNil) c.Assert(<-msgc, DeepEquals, want) }
func (s *S) TestAddSort(c *C) { b := NewBuffer() // add first message first := rfc5424.NewMessage(nil, []byte("msg1")) b.Add(first) c.Assert(b.Read(), DeepEquals, []*rfc5424.Message{first}) // add duplicate b.Add(first) c.Assert(b.Read(), DeepEquals, []*rfc5424.Message{first}) // add new, before head newHead := rfc5424.NewMessage(nil, []byte("msg2")) newHead.Timestamp = first.Timestamp.Add(-time.Second) b.Add(newHead) c.Assert(b.Read(), DeepEquals, []*rfc5424.Message{newHead, first}) // add new, tail newTail := rfc5424.NewMessage(nil, []byte("msg3")) newTail.Timestamp = first.Timestamp.Add(2 * time.Second) b.Add(newTail) c.Assert(b.Read(), DeepEquals, []*rfc5424.Message{newHead, first, newTail}) // add new between first and newTail between := rfc5424.NewMessage(nil, []byte("msg3")) between.Timestamp = first.Timestamp.Add(time.Second) b.Add(between) c.Assert(b.Read(), DeepEquals, []*rfc5424.Message{newHead, first, between, newTail}) }
func (_ *SnapshotTestSuite) TestRoundtrip(c *C) { want := []*rfc5424.Message{} got := []*rfc5424.Message{} for i := 0; i < 100; i++ { key := fmt.Sprintf("app-%d", i) hdr := rfc5424.Header{AppName: []byte(key)} for j := 0; j < 100; j++ { line := []byte(fmt.Sprintf("line %d\n", j)) want = append(want, rfc5424.NewMessage(&hdr, line)) } } r, w := io.Pipe() errc := make(chan error) go func() { err := WriteTo([][]*rfc5424.Message{want}, w) w.Close() errc <- err }() s := NewScanner(r) for s.Scan() { got = append(got, s.Message) } c.Assert(s.Err(), IsNil) c.Assert(<-errc, IsNil) c.Assert(want, DeepEquals, got) }
func (s *S) SetUpTest(c *C) { hdr := &rfc5424.Header{} s.data = make([]*rfc5424.Message, DefaultCapacity*2) for i := 0; i < len(s.data); i++ { line := []byte(fmt.Sprintf("line %d\n", i)) s.data[i] = rfc5424.NewMessage(hdr, line) } }
func newMessageForApp(appname, procID, msg string) *rfc5424.Message { return rfc5424.NewMessage( &rfc5424.Header{ AppName: []byte(appname), ProcID: []byte(procID), }, []byte(msg), ) }
func newMessageForApp(appname, procID, msg string) *rfc5424.Message { m := rfc5424.NewMessage( &rfc5424.Header{ AppName: []byte(appname), ProcID: []byte(procID), }, []byte(msg), ) m.StructuredData = []byte(`[flynn seq="1"]`) return m }
func newSeqMessage(hostname string, seq, timeDiff int) *rfc5424.Message { m := rfc5424.NewMessage( &rfc5424.Header{ AppName: []byte("foo"), ProcID: []byte("bar"), Timestamp: time.Date(2013, 7, 17, 16, 43, 41, 0, time.UTC).Add(time.Duration(timeDiff) * time.Second), Hostname: []byte(hostname), }, []byte("asdf"), ) m.StructuredData = []byte(fmt.Sprintf(`[flynn seq="%d"]`, seq)) return m }
func buildTestData(n int, hdr *rfc5424.Header) []*rfc5424.Message { data := make([]*rfc5424.Message, n) for i := range data { line := []byte(fmt.Sprintf("line %d\n", i)) msg := rfc5424.NewMessage(hdr, line) msg.StructuredData = []byte(fmt.Sprintf(`[flynn seq="%d"]`, i)) msg.Timestamp = timeNow data[i] = msg } return data }
func (s *LogStream) follow(r io.Reader, buffer, appID string, h *rfc5424.Header, wg *sync.WaitGroup) { defer wg.Done() defer close(s.done) l := s.m.appLog(appID) seqBuf := make([]byte, 10) sd := &rfc5424.StructuredData{ ID: []byte("flynn"), Params: []rfc5424.StructuredDataParam{{Name: []byte("seq")}}, } br := bufio.NewReaderSize(io.MultiReader(strings.NewReader(buffer), r), 10000) for { line, err := br.ReadSlice('\n') if err != nil && err != bufio.ErrBufferFull { // if the log was explicitly closed (because an update // is in progress), store the buffer and return so it // can be passed to the new flynn-host daemon. if s.closed.Load().(bool) { s.buf = string(line) return } if len(line) == 0 { // only return if there is no final line to return return } } if line[len(line)-1] == '\n' { line = line[:len(line)-1] } msg := rfc5424.NewMessage(h, line) cursor := &utils.HostCursor{ Time: msg.Timestamp, Seq: uint64(atomic.AddUint32(&s.m.msgSeq, 1)), } sd.Params[0].Value = strconv.AppendUint(seqBuf[:0], cursor.Seq, 10) var sdBuf bytes.Buffer sd.Encode(&sdBuf) msg.StructuredData = sdBuf.Bytes() l.Write(message{cursor, msg}) if err != nil && err != bufio.ErrBufferFull { return } } }
func (s *LogAggregatorTestSuite) TestNewMessageFromSyslog(c *C) { timestamp, err := time.Parse(time.RFC3339Nano, "2009-11-10T23:00:00.123450789Z") c.Assert(err, IsNil) m := NewMessageFromSyslog(rfc5424.NewMessage( &rfc5424.Header{ Hostname: []byte("a.b.flynn.local"), ProcID: []byte("web.flynn-abcd1234"), MsgID: []byte("ID1"), Timestamp: timestamp, }, []byte("testing message"), )) c.Assert(m.HostID, Equals, "a.b.flynn.local") c.Assert(m.JobID, Equals, "flynn-abcd1234") c.Assert(m.ProcessType, Equals, "web") c.Assert(m.Source, Equals, "app") c.Assert(m.Stream, Equals, "stdout") c.Assert(m.Timestamp, Equals, timestamp) }
func (m *LogMux) follow(r io.Reader, hdr *rfc5424.Header) { defer m.producerwg.Done() g := grohl.NewContext(grohl.Data{"at": "logmux_follow"}) s := bufio.NewScanner(r) for s.Scan() { msg := rfc5424.NewMessage(hdr, s.Bytes()) select { case m.logc <- msg: default: // throw away msg if logc buffer is full } } if s.Err() != nil { g.Log(grohl.Data{"status": "error", "err": s.Err()}) } }
func (s *S) TestDurableWrite(c *C) { l, err := net.Listen("tcp", ":0") c.Assert(err, IsNil) msgc := make(chan *rfc5424.Message) handler := func(msg *rfc5424.Message) { msgc <- msg } go runServer(l, handler) donec := make(chan struct{}) defer close(donec) sc, err := connect(s.discd, "test-broken", donec) c.Assert(err, IsNil) addr := l.Addr().String() _, err = s.discd.AddServiceAndRegister("test-broken", addr) c.Assert(err, IsNil) hdr := &rfc5424.Header{} for i := 0; i < 10; i++ { want := rfc5424.NewMessage(hdr, []byte(fmt.Sprintf("line %d", i+1))) _, err = sc.Write(rfc6587.Bytes(want)) c.Assert(err, IsNil) if i%2 == 0 { // break the underlying connection before the next Write c.Assert(sc.Conn.Close(), IsNil) } got := <-msgc c.Assert(want, DeepEquals, got) } }