Merge pull request #330 from mergetb/unit-section-fix

unit: deserialize keeps all semantic data

Author: Luca Bruno

unit/deserialize.go

@@ -43,37 +43,99 @@ var (
 	ErrLineTooLong = fmt.Errorf("line too long (max %d bytes)", SYSTEMD_LINE_MAX)
 )
 
-// Deserialize parses a systemd unit file into a list of UnitOption objects.
+// DeserializeOptions parses a systemd unit file into a list of UnitOptions
+func DeserializeOptions(f io.Reader) (opts []*UnitOption, err error) {
+	_, options, err := deserializeAll(f)
+	return options, err
+}
+
+// DeserializeSections deserializes into a list of UnitSections.
+func DeserializeSections(f io.Reader) ([]*UnitSection, error) {
+	sections, _, err := deserializeAll(f)
+	return sections, err
+}
+
+// Deserialize parses a systemd unit file into a list of UnitOptions.
+// Note: this function is deprecated in favor of DeserializeOptions
+// and will be removed at a future date.
 func Deserialize(f io.Reader) (opts []*UnitOption, err error) {
-	lexer, optchan, errchan := newLexer(f)
+	return DeserializeOptions(f)
+}
+
+type lexDataType int
+
+const (
+	SEC lexDataType = iota
+	OPT
+)
+
+// lexChanData - support either datatype in the lex channel.
+// Poor man's union data type.
+type lexData struct {
+	Type    lexDataType
+	Option  *UnitOption
+	Section *UnitSection
+}
+
+// deserializeAll deserializes into UnitSections and UnitOptions.
+func deserializeAll(f io.Reader) ([]*UnitSection, []*UnitOption, error) {
+
+	lexer, lexchan, errchan := newLexer(f)
+
 	go lexer.lex()
 
-	for opt := range optchan {
-		opts = append(opts, &(*opt))
+	sections := []*UnitSection{}
+	options := []*UnitOption{}
+
+	for ld := range lexchan {
+		switch ld.Type {
+		case OPT:
+			if ld.Option != nil {
+				// add to options
+				opt := ld.Option
+				options = append(options, &(*opt))
+
+				// sanity check. "should not happen" as SEC is first in code flow.
+				if len(sections) == 0 {
+					return nil, nil, fmt.Errorf(
+						"Unit file misparse: option before section")
+				}
+
+				// add to newest section entries.
+				s := len(sections) - 1
+				sections[s].Entries = append(sections[s].Entries,
+					&UnitEntry{Name: opt.Name, Value: opt.Value})
+			}
+		case SEC:
+			if ld.Section != nil {
+				sections = append(sections, ld.Section)
+			}
+		}
 	}
 
-	err = <-errchan
-	return opts, err
+	err := <-errchan
+
+	return sections, options, err
 }
 
-func newLexer(f io.Reader) (*lexer, <-chan *UnitOption, <-chan error) {
-	optchan := make(chan *UnitOption)
+func newLexer(f io.Reader) (*lexer, <-chan *lexData, <-chan error) {
+	lexchan := make(chan *lexData)
 	errchan := make(chan error, 1)
 	buf := bufio.NewReader(f)
 
-	return &lexer{buf, optchan, errchan, ""}, optchan, errchan
+	return &lexer{buf, lexchan, errchan, ""}, lexchan, errchan
 }
 
 type lexer struct {
 	buf     *bufio.Reader
-	optchan chan *UnitOption
+	lexchan chan *lexData
 	errchan chan error
 	section string
 }
 
 func (l *lexer) lex() {
 	defer func() {
-		close(l.optchan)
+		close(l.lexchan)
 		close(l.errchan)
 	}()
 	next := l.lexNextSection
@@ -126,6 +188,12 @@ func (l *lexer) lexSectionSuffixFunc(section string) lexStep {
 			return nil, fmt.Errorf("found garbage after section name %s: %q", l.section, garbage)
 		}
 
+		l.lexchan <- &lexData{
+			Type:    SEC,
+			Section: &UnitSection{Section: section, Entries: []*UnitEntry{}},
+			Option:  nil,
+		}
+
 		return l.lexNextSectionOrOptionFunc(section), nil
 	}
 }
@@ -252,7 +320,11 @@ func (l *lexer) lexOptionValueFunc(section, name string, partial bytes.Buffer) l
 		} else {
 			val = strings.TrimSpace(val)
 		}
-		l.optchan <- &UnitOption{Section: section, Name: name, Value: val}
+		l.lexchan <- &lexData{
+			Type:    OPT,
+			Section: nil,
+			Option:  &UnitOption{Section: section, Name: name, Value: val},
+		}
 
 		return l.lexNextSectionOrOptionFunc(section), nil
 	}

unit/deserialize_test.go

@@ -277,7 +277,7 @@ Option=value
 	}
 
 	for i, tt := range tests {
-		output, err := Deserialize(bytes.NewReader(tt.input))
+		output, err := DeserializeOptions(bytes.NewReader(tt.input))
 		if err != nil {
 			t.Errorf("case %d: unexpected error parsing unit: %v", i, err)
 			continue
@@ -294,6 +294,95 @@ Option=value
 	}
 }
 
+func TestDeserializeSections(t *testing.T) {
+	tests := []struct {
+		input  []byte
+		output []*UnitSection
+	}{
+		// multiple options underneath a section
+		{
+			[]byte(`[Unit]
+Description=Foo
+Description=Bar
+Requires=baz.service
+After=baz.service
+`),
+			[]*UnitSection{
+				&UnitSection{
+					Section: "Unit",
+					Entries: []*UnitEntry{
+						&UnitEntry{"Description", "Foo"},
+						&UnitEntry{"Description", "Bar"},
+						&UnitEntry{"Requires", "baz.service"},
+						&UnitEntry{"After", "baz.service"},
+					},
+				},
+			},
+		},
+		{
+			[]byte(`[Route]
+Destination=10.0.0.1/24
+Gateway=10.0.10.1
+
+[Route]
+Destination=10.0.2.1/24
+Gateway=10.0.10.1
+`),
+			[]*UnitSection{
+				&UnitSection{
+					Section: "Route",
+					Entries: []*UnitEntry{
+						&UnitEntry{"Destination", "10.0.0.1/24"},
+						&UnitEntry{"Gateway", "10.0.10.1"},
+					},
+				},
+				&UnitSection{
+					Section: "Route",
+					Entries: []*UnitEntry{
+						&UnitEntry{"Destination", "10.0.2.1/24"},
+						&UnitEntry{"Gateway", "10.0.10.1"},
+					},
+				},
+			},
+		},
+	}
+
+	assert := func(expect, output []*UnitSection) error {
+		if len(expect) != len(output) {
+			return fmt.Errorf("expected %d sections, got %d", len(expect), len(output))
+		}
+
+		for i := range expect {
+			if !reflect.DeepEqual(expect[i], output[i]) {
+				return fmt.Errorf("item %d: expected %v, got %v", i, expect[i], output[i])
+			}
+		}
+
+		return nil
+	}
+
+	for i, tt := range tests {
+		output, err := DeserializeSections(bytes.NewReader(tt.input))
+		if err != nil {
+			t.Errorf("case %d: unexpected error parsing unit: %v", i, err)
+			continue
+		}
+
+		err = assert(tt.output, output)
+		if err != nil {
+			t.Errorf("case %d: %v", i, err)
+			t.Log("Expected options:")
+			for _, s := range tt.output {
+				t.Log(s)
+			}
+			t.Log("Actual options:")
+			for _, s := range output {
+				t.Log(s)
+			}
+		}
+	}
+}
+
 func TestDeserializeFail(t *testing.T) {
 	tests := [][]byte{
 		// malformed section header
@@ -319,7 +408,7 @@ Description=Foo
 	}
 
 	for i, tt := range tests {
-		output, err := Deserialize(bytes.NewReader(tt))
+		output, err := DeserializeOptions(bytes.NewReader(tt))
 		if err == nil {
 			t.Errorf("case %d: unexpected nil error", i)
 			t.Log("Output:")
@@ -371,7 +460,7 @@ ExecStartExecStartExecStartExecStartExecStartExecStartExecStartExecStartExecStar
 	}
 
 	for i, tt := range tests {
-		output, err := Deserialize(bytes.NewReader(tt))
+		output, err := DeserializeOptions(bytes.NewReader(tt))
 		if err != ErrLineTooLong {
 			t.Errorf("case %d: unexpected err: %v", i, err)
 			t.Log("Output:")

unit/section.go

@@ -0,0 +1,44 @@
+// Copyright 2020 CoreOS, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package unit
+
+// UnitEntry is a single line entry in a Unit file.
+type UnitEntry struct {
+	Name  string
+	Value string
+}
+
+// UnitSection is a section in a Unit file. The section name
+// and a list of entries in that section.
+type UnitSection struct {
+	Section string
+	Entries []*UnitEntry
+}
+
+// String implements the stringify interface for UnitEntry
+func (u *UnitEntry) String() string {
+	return "{Name: " + u.Name + ", " + "Value: " + u.Value + "}"
+}
+
+// String implements the stringify interface for UnitSection
+func (s *UnitSection) String() string {
+	result := "{Section: " + s.Section
+	for _, e := range s.Entries {
+		result += e.String()
+	}
+
+	result += "}"
+	return result
+}

unit/serialize.go

@@ -58,6 +58,29 @@ func Serialize(opts []*UnitOption) io.Reader {
 	return &buf
 }
 
+// SerializeSections will serializes the unit file from the given
+// UnitSections.
+func SerializeSections(sections []*UnitSection) io.Reader {
+
+	var buf bytes.Buffer
+
+	for i, s := range sections {
+		writeSectionHeader(&buf, s.Section)
+		writeNewline(&buf)
+
+		for _, e := range s.Entries {
+			writeOption(&buf, &UnitOption{s.Section, e.Name, e.Value})
+			writeNewline(&buf)
+		}
+
+		if i < len(sections)-1 {
+			writeNewline(&buf)
+		}
+	}
+
+	return &buf
+}
+
 func writeNewline(buf *bytes.Buffer) {
 	buf.WriteRune('\n')
 }