Add Journal.GetDataBytes() and Journal.GetDataValueBytes() methods

This allows to avoid extra string → []byte conversion overhead for cases
when journal field value is e.g. parsed (which usually requires []byte).

Author: Gregory Petrosyan

sdjournal/journal.go

@@ -257,6 +257,7 @@ package sdjournal
 //
 import "C"
 import (
+	"bytes"
 	"fmt"
 	"path/filepath"
 	"strings"
@@ -614,12 +615,10 @@ func (j *Journal) PreviousSkip(skip uint64) (uint64, error) {
 	return uint64(r), nil
 }
 
-// GetData gets the data object associated with a specific field from the
-// current journal entry.
-func (j *Journal) GetData(field string) (string, error) {
+func (j *Journal) getData(field string) (unsafe.Pointer, C.int, error) {
 	sd_journal_get_data, err := j.getFunction("sd_journal_get_data")
 	if err != nil {
-		return "", err
+		return nil, 0, err
 	}
 
 	f := C.CString(field)
@@ -633,12 +632,21 @@ func (j *Journal) GetData(field string) (string, error) {
 	j.mu.Unlock()
 
 	if r < 0 {
-		return "", fmt.Errorf("failed to read message: %d", syscall.Errno(-r))
+		return nil, 0, fmt.Errorf("failed to read message: %d", syscall.Errno(-r))
 	}
 
-	msg := C.GoStringN((*C.char)(d), C.int(l))
+	return d, C.int(l), nil
+}
+
+// GetData gets the data object associated with a specific field from the
+// current journal entry.
+func (j *Journal) GetData(field string) (string, error) {
+	d, l, err := j.getData(field)
+	if err != nil {
+		return "", err
+	}
 
-	return msg, nil
+	return C.GoStringN((*C.char)(d), l), nil
 }
 
 // GetDataValue gets the data object associated with a specific field from the
@@ -648,9 +656,32 @@ func (j *Journal) GetDataValue(field string) (string, error) {
 	if err != nil {
 		return "", err
 	}
+
 	return strings.SplitN(val, "=", 2)[1], nil
 }
 
+// GetDataBytes gets the data object associated with a specific field from the
+// current journal entry.
+func (j *Journal) GetDataBytes(field string) ([]byte, error) {
+	d, l, err := j.getData(field)
+	if err != nil {
+		return nil, err
+	}
+
+	return C.GoBytes(d, l), nil
+}
+
+// GetDataValueBytes gets the data object associated with a specific field from the
+// current journal entry, returning only the value of the object.
+func (j *Journal) GetDataValueBytes(field string) ([]byte, error) {
+	val, err := j.GetDataBytes(field)
+	if err != nil {
+		return nil, err
+	}
+
+	return bytes.SplitN(val, []byte("="), 2)[1], nil
+}
+
 // GetEntry returns a full representation of a journal entry with
 // all key-value pairs of data as well as address fields (cursor, realtime
 // timestamp and monotonic timestamp)

sdjournal/journal_test.go

@@ -178,53 +178,116 @@ func TestNewJournalFromDir(t *testing.T) {
 	j.Close()
 }
 
-func TestJournalGetEntry(t *testing.T) {
+func setupJournalRoundtrip() (*Journal, map[string]string, error) {
 	j, err := NewJournal()
 	if err != nil {
-		t.Fatalf("Error opening journal: %s", err)
+		return nil, nil, fmt.Errorf("Error opening journal: %s", err)
 	}
 
 	if j == nil {
-		t.Fatal("Got a nil journal")
+		return nil, nil, fmt.Errorf("Got a nil journal")
 	}
 
-	defer j.Close()
-
 	j.FlushMatches()
 
-	matchField := "TESTJOURNALGETENTRY"
+	matchField := "TESTJOURNALENTRY"
 	matchValue := fmt.Sprintf("%d", time.Now().UnixNano())
 	m := Match{Field: matchField, Value: matchValue}
 	err = j.AddMatch(m.String())
 	if err != nil {
-		t.Fatalf("Error adding matches to journal: %s", err)
+		return nil, nil, fmt.Errorf("Error adding matches to journal: %s", err)
 	}
 
-	want := fmt.Sprintf("test journal get entry message %s", time.Now())
-	err = journal.Send(want, journal.PriInfo, map[string]string{matchField: matchValue})
+	msg := fmt.Sprintf("test journal get entry message %s", time.Now())
+	data := map[string]string{matchField: matchValue}
+	err = journal.Send(msg, journal.PriInfo, data)
 	if err != nil {
-		t.Fatalf("Error writing to journal: %s", err)
+		return nil, nil, fmt.Errorf("Error writing to journal: %s", err)
 	}
 
 	time.Sleep(time.Duration(1) * time.Second)
 
 	n, err := j.Next()
 	if err != nil {
-		t.Fatalf("Error reading to journal: %s", err)
+		return nil, nil, fmt.Errorf("Error reading from journal: %s", err)
 	}
 
 	if n == 0 {
-		t.Fatalf("Error reading to journal: %s", io.EOF)
+		return nil, nil, fmt.Errorf("Error reading from journal: %s", io.EOF)
 	}
 
+	data["MESSAGE"] = msg
+
+	return j, data, nil
+}
+
+func TestJournalGetData(t *testing.T) {
+	j, wantEntry, err := setupJournalRoundtrip()
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	defer j.Close()
+
+	for k, v := range wantEntry {
+		data := fmt.Sprintf("%s=%s", k, v)
+
+		dataStr, err := j.GetData(k)
+		if err != nil {
+			t.Fatalf("GetData() error: %v", err)
+		}
+
+		if dataStr != data {
+			t.Fatalf("Invalid data for \"%s\": got %s, want %s", k, dataStr, data)
+		}
+
+		dataBytes, err := j.GetDataBytes(k)
+		if err != nil {
+			t.Fatalf("GetDataBytes() error: %v", err)
+		}
+
+		if string(dataBytes) != data {
+			t.Fatalf("Invalid data bytes for \"%s\": got %s, want %s", k, string(dataBytes), data)
+		}
+
+		valStr, err := j.GetDataValue(k)
+		if err != nil {
+			t.Fatalf("GetDataValue() error: %v", err)
+		}
+
+		if valStr != v {
+			t.Fatalf("Invalid data value for \"%s\": got %s, want %s", k, valStr, v)
+		}
+
+		valBytes, err := j.GetDataValueBytes(k)
+		if err != nil {
+			t.Fatalf("GetDataValueBytes() error: %v", err)
+		}
+
+		if string(valBytes) != v {
+			t.Fatalf("Invalid data value bytes for \"%s\": got %s, want %s", k, string(valBytes), v)
+		}
+	}
+}
+
+func TestJournalGetEntry(t *testing.T) {
+	j, wantEntry, err := setupJournalRoundtrip()
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	defer j.Close()
+
 	entry, err := j.GetEntry()
 	if err != nil {
 		t.Fatalf("Error getting the entry to journal: %s", err)
 	}
 
-	got := entry.Fields["MESSAGE"]
-	if got != want {
-		t.Fatalf("Bad result for entry.Fields[\"MESSAGE\"]: got %s, want %s", got, want)
+	for k, wantV := range wantEntry {
+		gotV := entry.Fields[k]
+		if gotV != wantV {
+			t.Fatalf("Bad result for entry.Fields[\"%s\"]: got %s, want %s", k, gotV, wantV)
+		}
 	}
 }