Merge pull request #80 from mzbenami/mbenami/learn_action

add Learn action with LearnedFlow

Author: mzbenami

ovs/action.go

@@ -67,6 +67,9 @@ var (
 
 	// errOutputFieldEmpty is returned when OutputField is called with field set to the empty string.
 	errOutputFieldEmpty = errors.New("field for action output (output:field syntax) is empty")
+
+	// errLearnedNil is returned when Learn is called with a nil *LearnedFlow.
+	errLearnedNil = errors.New("learned flow for action learn is nil")
 )
 
 // Action strings in lower case, as those are compared to the lower case letters
@@ -190,6 +193,7 @@ const (
 	patOutputField                 = "output:%s"
 	patResubmitPort                = "resubmit:%s"
 	patResubmitPortTable           = "resubmit(%s,%s)"
+	patLearn                       = "learn(%s)"
 )
 
 // ConnectionTracking sends a packet through the host's connection tracker.
@@ -643,6 +647,37 @@ func (a *moveAction) MarshalText() ([]byte, error) {
 	return bprintf("move:%s->%s", a.src, a.dst), nil
 }
 
+// Learn dynamically installs a LearnedFlow.
+func Learn(learned *LearnedFlow) Action {
+	return &learnAction{
+		learned: learned,
+	}
+}
+
+// A learnAction is an Action used by Learn.
+type learnAction struct {
+	learned *LearnedFlow
+}
+
+// GoString implements Action.
+func (a *learnAction) GoString() string {
+	return fmt.Sprintf("ovs.Learn(%#v)", a.learned)
+}
+
+// MarshalText implements Action.
+func (a *learnAction) MarshalText() ([]byte, error) {
+	if a.learned == nil {
+		return nil, errLearnedNil
+	}
+
+	l, err := a.learned.MarshalText()
+	if err != nil {
+		return nil, err
+	}
+
+	return bprintf(patLearn, l), nil
+}
+
 // validARPOP indicates if an ARP OP is out of range. It should be in the range
 // 1-4.
 func validARPOP(op uint16) bool {

ovs/action_test.go

@@ -667,6 +667,60 @@ func TestOutputField(t *testing.T) {
 	}
 }
 
+func TestLearn(t *testing.T) {
+	var tests = []struct {
+		desc   string
+		a      Action
+		action string
+		err    error
+	}{
+		{
+			desc: "learn ok",
+			a: Learn(&LearnedFlow{
+				DeleteLearned:  true,
+				FinHardTimeout: 10,
+				Matches:        []Match{DataLinkType(0x800)},
+				Actions:        []Action{OutputField("in_port"), Load("2", "tp_dst")},
+			}),
+			action: `learn(priority=0,dl_type=0x0800,table=0,idle_timeout=0,fin_hard_timeout=10,delete_learned,output:in_port,load:2->tp_dst)`,
+		},
+		{
+			desc: "prohibited learned action, mod_tp_dst",
+			a: Learn(&LearnedFlow{
+				DeleteLearned:  true,
+				FinHardTimeout: 10,
+				Matches:        []Match{DataLinkType(0x800)},
+				Actions:        []Action{ModTransportDestinationPort(1)},
+			}),
+			err: errInvalidLearnedActions,
+		},
+		{
+			desc: "nil learned flow",
+			a:    Learn(nil),
+			err:  errLearnedNil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.desc, func(t *testing.T) {
+			action, err := tt.a.MarshalText()
+
+			if want, got := tt.err, err; want != got {
+				t.Fatalf("unexpected error:\n- want: %v\n-  got: %v",
+					want, got)
+			}
+			if err != nil {
+				return
+			}
+
+			if want, got := tt.action, string(action); want != got {
+				t.Fatalf("unexpected Action:\n- want: %q\n-  got: %q",
+					want, got)
+			}
+		})
+	}
+}
+
 func TestActionGoString(t *testing.T) {
 	tests := []struct {
 		a Action
@@ -748,6 +802,15 @@ func TestActionGoString(t *testing.T) {
 			a: OutputField("in_port"),
 			s: `ovs.OutputField("in_port")`,
 		},
+		{
+			a: Learn(&LearnedFlow{
+				DeleteLearned:  true,
+				FinHardTimeout: 10,
+				Matches:        []Match{DataLinkType(0x800)},
+				Actions:        []Action{OutputField("in_port")},
+			}),
+			s: `ovs.Learn(&ovs.LearnedFlow{Priority:0, InPort:0, Matches:[]ovs.Match{ovs.DataLinkType(0x0800)}, Table:0, IdleTimeout:0, Cookie:0x0, Actions:[]ovs.Action{ovs.OutputField("in_port")}, DeleteLearned:true, FinHardTimeout:10})`,
+		},
 	}
 
 	for _, tt := range tests {

ovs/actionparser_test.go

@@ -76,7 +76,7 @@ func Test_actionParser(t *testing.T) {
 					want, got)
 			}
 
-			as, err := (&Flow{Actions: actions}).marshalActions()
+			as, err := marshalActions(actions)
 			if err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}

ovs/flow.go

@@ -30,11 +30,12 @@ const (
 // Possible errors which may be encountered while marshaling or unmarshaling
 // a Flow.
 var (
-	errActionsWithDrop   = errors.New("Flow actions include drop, but multiple actions specified")
-	errInvalidActions    = errors.New("invalid actions for Flow")
-	errNoActions         = errors.New("no actions defined for Flow")
-	errNotEnoughElements = errors.New("not enough elements for valid Flow")
-	errPriorityNotFirst  = errors.New("priority field is not first in Flow")
+	errActionsWithDrop       = errors.New("Flow actions include drop, but multiple actions specified")
+	errInvalidActions        = errors.New("invalid actions for Flow")
+	errNoActions             = errors.New("no actions defined for Flow")
+	errNotEnoughElements     = errors.New("not enough elements for valid Flow")
+	errPriorityNotFirst      = errors.New("priority field is not first in Flow")
+	errInvalidLearnedActions = errors.New("invalid actions for LearnedFlow")
 )
 
 // A Protocol is an OpenFlow protocol designation accepted by Open vSwitch.
@@ -66,6 +67,20 @@ type Flow struct {
 	Actions     []Action
 }
 
+// A LearnedFlow is defined as part of the Learn action.
+type LearnedFlow struct {
+	Priority    int
+	InPort      int
+	Matches     []Match
+	Table       int
+	IdleTimeout int
+	Cookie      uint64
+	Actions     []Action
+
+	DeleteLearned  bool
+	FinHardTimeout int
+}
+
 var _ error = &FlowError{}
 
 // A FlowError is an error encountered while marshaling or unmarshaling
@@ -105,6 +120,10 @@ const (
 	hardAge     = "hard_age"
 	idleAge     = "idle_age"
 
+	// Variables used in LearnedFlows only.
+	deleteLearned  = "delete_learned"
+	finHardTimeout = "fin_hard_timeout"
+
 	portLOCAL = "LOCAL"
 )
 
@@ -120,12 +139,12 @@ func (f *Flow) MarshalText() ([]byte, error) {
 		}
 	}
 
-	actions, err := f.marshalActions()
+	actions, err := marshalActions(f.Actions)
 	if err != nil {
 		return nil, err
 	}
 
-	matches, err := f.marshalMatches()
+	matches, err := marshalMatches(f.Matches)
 	if err != nil {
 		return nil, err
 	}
@@ -183,6 +202,81 @@ func (f *Flow) MarshalText() ([]byte, error) {
 	return b, nil
 }
 
+// MarshalText marshals a LearnedFlow into its textual form.
+func (f *LearnedFlow) MarshalText() ([]byte, error) {
+	if len(f.Actions) == 0 {
+		return nil, &FlowError{
+			Err: errNoActions,
+		}
+	}
+
+	// A learned flow can have a limited set of actions, namely `load` and `output:field`.
+	for _, a := range f.Actions {
+		switch a.(type) {
+		case *loadSetFieldAction:
+			if a.(*loadSetFieldAction).typ != actionLoad {
+				return nil, errInvalidLearnedActions
+			}
+		case *outputFieldAction:
+		default:
+			return nil, errInvalidLearnedActions
+		}
+	}
+
+	actions, err := marshalActions(f.Actions)
+	if err != nil {
+		return nil, err
+	}
+
+	matches, err := marshalMatches(f.Matches)
+	if err != nil {
+		return nil, err
+	}
+
+	b := make([]byte, len(priorityBytes))
+	copy(b, priorityBytes)
+
+	b = strconv.AppendInt(b, int64(f.Priority), 10)
+
+	if f.InPort != 0 {
+		b = append(b, ","+inPort+"="...)
+
+		// Special case, InPortLOCAL is converted to the literal string LOCAL
+		if f.InPort == PortLOCAL {
+			b = append(b, portLOCAL...)
+		} else {
+			b = strconv.AppendInt(b, int64(f.InPort), 10)
+		}
+	}
+
+	if len(matches) > 0 {
+		b = append(b, ","+strings.Join(matches, ",")...)
+	}
+
+	b = append(b, ","+table+"="...)
+	b = strconv.AppendInt(b, int64(f.Table), 10)
+
+	b = append(b, ","+idleTimeout+"="...)
+	b = strconv.AppendInt(b, int64(f.IdleTimeout), 10)
+
+	b = append(b, ","+finHardTimeout+"="...)
+	b = strconv.AppendInt(b, int64(f.FinHardTimeout), 10)
+
+	if f.DeleteLearned {
+		b = append(b, ","+deleteLearned...)
+	}
+
+	if f.Cookie > 0 {
+		// Hexadecimal cookies are much easier to read.
+		b = append(b, ","+cookie+"="...)
+		b = append(b, paddedHexUint64(f.Cookie)...)
+	}
+
+	b = append(b, ","+strings.Join(actions, ",")...)
+
+	return b, nil
+}
+
 // UnmarshalText unmarshals flow text into a Flow.
 func (f *Flow) UnmarshalText(b []byte) error {
 	// Make a copy per documentation for encoding.TextUnmarshaler.
@@ -339,28 +433,28 @@ func (f *Flow) MatchFlow() *MatchFlow {
 	}
 }
 
-// marshalActions marshals all Actions in a Flow to their text form.
-func (f *Flow) marshalActions() ([]string, error) {
-	fns := make([]func() ([]byte, error), 0, len(f.Actions))
-	for _, fn := range f.Actions {
+// marshalActions marshals all provided Actions to their text form.
+func marshalActions(aa []Action) ([]string, error) {
+	fns := make([]func() ([]byte, error), 0, len(aa))
+	for _, fn := range aa {
 		fns = append(fns, fn.MarshalText)
 	}
 
-	return f.marshalFunctions(fns)
+	return marshalFunctions(fns)
 }
 
-// marshalMatches marshals all Matches in a Flow to their text form.
-func (f *Flow) marshalMatches() ([]string, error) {
-	fns := make([]func() ([]byte, error), 0, len(f.Matches))
-	for _, fn := range f.Matches {
+// marshalMatches marshals all provided Matches to their text form.
+func marshalMatches(mm []Match) ([]string, error) {
+	fns := make([]func() ([]byte, error), 0, len(mm))
+	for _, fn := range mm {
 		fns = append(fns, fn.MarshalText)
 	}
 
-	return f.marshalFunctions(fns)
+	return marshalFunctions(fns)
 }
 
 // marshalFunctions marshals a slice of functions to their text form.
-func (f *Flow) marshalFunctions(fns []func() ([]byte, error)) ([]string, error) {
+func marshalFunctions(fns []func() ([]byte, error)) ([]string, error) {
 	out := make([]string, 0, len(fns))
 	for _, fn := range fns {
 		o, err := fn()