network limit tbf (chaos-mesh#350)

* proto and tbf server apply logic

* refactor common logic to netlink_linux and apply it in tbf_server

* [temp] remove limit in networkchaos

* make fmt and make yaml

* fix var

* add mock implementation

* fix missing grpc option

* rough implementation of API spec and controller

* implement InnerReconciler

* make fmt

* rename to bandwidth

* make

* fix api zero value parse issue

* fix remove tbf issue

* adjust type for bandwidth

* commit yaml and test

* fix tbf server test

* add unit support for rate

* add network bandwidth example

* add documentation

* make yaml

* make fmt

* update pb

* make yaml

* update log

* refactor netem with toQdiscFunc

* update based on comments

* update based on comments

* optional

* fix nil pointer dereference

* fix typo

* update document

* update document

* update based on comments

* add more doc

* add unit test and add license comment

* add comments for tbf

* fix comment

* add license comment

* fix ut

* add validation

* update licensed

* update code

* Revert "update licensed"

This reverts commit f7877b7.

* update license file to 2020

Co-authored-by: pingcap-github-bot <[email protected]>

Author: vincent178

api/v1alpha1/networkchaos_types.go

@@ -14,7 +14,9 @@
 package v1alpha1
 
 import (
+	"errors"
 	"strconv"
+	"strings"
 	"time"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -47,6 +49,9 @@ const (
 
 	// PartitionAction represents the chaos action of network partition of pods.
 	PartitionAction NetworkChaosAction = "partition"
+
+	// BandwidthAction represents the chaos action of network bandwidth of pods.
+	BandwidthAction NetworkChaosAction = "bandwidth"
 )
 
 // PartitionDirection represents the block direction from source to target
@@ -133,6 +138,10 @@ type NetworkChaosSpec struct {
 	// Corrupt represents the detail about corrupt action
 	Corrupt *CorruptSpec `json:"corrupt,omitempty"`
 
+	// Bandwidth represents the detail about bandwidth control action
+	// +optional
+	Bandwidth *BandwidthSpec `json:"bandwidth,omitempty"`
+
 	// Direction represents the partition direction
 	// +optional
 	Direction PartitionDirection `json:"direction"`
@@ -369,6 +378,83 @@ func (corrupt *CorruptSpec) ToNetem() (*chaosdaemonpb.Netem, error) {
 	}, nil
 }
 
+// BandwidthSpec defines detail of bandwidth limit.
+type BandwidthSpec struct {
+	// Rate is the speed knob. Allows bps, kbps, mbps, gbps, tbps unit. bps means bytes per second.
+	Rate string `json:"rate"`
+	// Limit is the number of bytes that can be queued waiting for tokens to become available.
+	// +kubebuilder:validation:Minimum=1
+	Limit uint32 `json:"limit"`
+	// Buffer is the maximum amount of bytes that tokens can be available for instantaneously.
+	// +kubebuilder:validation:Minimum=1
+	Buffer uint32 `json:"buffer"`
+	// Peakrate is the maximum depletion rate of the bucket.
+	// The peakrate does not need to be set, it is only necessary
+	// if perfect millisecond timescale shaping is required.
+	// +optional
+	Peakrate *uint64 `json:"peakrate,omitempty"`
+	// Minburst specifies the size of the peakrate bucket. For perfect
+	// accuracy, should be set to the MTU of the interface.  If a
+	// peakrate is needed, but some burstiness is acceptable, this
+	// size can be raised. A 3000 byte minburst allows around 3mbit/s
+	// of peakrate, given 1000 byte packets.
+	// +optional
+	Minburst *uint32 `json:"minburst,omitempty"`
+}
+
+// ToTbf converts BandwidthSpec to *chaosdaemonpb.Tbf
+// Bandwidth action use TBF under the hood.
+// TBF stands for Token Bucket Filter, is a classful queueing discipline available
+// for traffic control with the tc command.
+// http://man7.org/linux/man-pages/man8/tc-tbf.8.html
+func (spec *BandwidthSpec) ToTbf() (*chaosdaemonpb.Tbf, error) {
+	rate, err := convertUnitToBytes(spec.Rate)
+
+	if err != nil {
+		return nil, err
+	}
+
+	tbf := &chaosdaemonpb.Tbf{
+		Rate:   rate,
+		Limit:  spec.Limit,
+		Buffer: spec.Buffer,
+	}
+
+	if spec.Peakrate != nil && spec.Minburst != nil {
+		tbf.PeakRate = *spec.Peakrate
+		tbf.MinBurst = *spec.Minburst
+	}
+
+	return tbf, nil
+}
+
+func convertUnitToBytes(nu string) (uint64, error) {
+	// normalize input
+	s := strings.ToLower(strings.TrimSpace(nu))
+
+	for i, u := range []string{"tbps", "gbps", "mbps", "kbps", "bps"} {
+		if strings.HasSuffix(s, u) {
+			ts := strings.TrimSuffix(s, u)
+			s := strings.TrimSpace(ts)
+
+			n, err := strconv.ParseUint(s, 10, 64)
+
+			if err != nil {
+				return 0, err
+			}
+
+			// convert unit to bytes
+			for j := 4 - i; j > 0; j-- {
+				n = n * 1024
+			}
+
+			return n, nil
+		}
+	}
+
+	return 0, errors.New("invalid unit")
+}
+
 // ReorderSpec defines details of packet reorder.
 type ReorderSpec struct {
 	Reorder     string `json:"reorder"`

api/v1alpha1/networkchaos_types_test.go

@@ -80,4 +80,18 @@ var _ = Describe("NetworkChaos", func() {
 			Expect(nwChaos.GetNextRecover()).To(Equal(nTime))
 		})
 	})
+
+	Context("convertUnitToBytes", func() {
+		It("should convert number with unit successfully", func() {
+			n, err := convertUnitToBytes("  10   mbPs  ")
+			Expect(err).Should(Succeed())
+			Expect(n).To(Equal(uint64(10 * 1024 * 1024)))
+		})
+
+		It("should return error with invalid unit", func() {
+			n, err := convertUnitToBytes(" 10 cpbs")
+			Expect(err).Should(HaveOccurred())
+			Expect(n).To(Equal(uint64(0)))
+		})
+	})
 })

api/v1alpha1/zz_generated.deepcopy.go

@@ -39,6 +39,45 @@ spec:
                 action: partition, netem, delay, loss, duplicate, corrupt Default
                 action: delay'
               type: string
+            bandwidth:
+              description: Bandwidth represents the detail about bandwidth control
+                action
+              properties:
+                buffer:
+                  description: Buffer is the maximum amount of bytes that tokens can
+                    be available for instantaneously.
+                  format: int32
+                  minimum: 1
+                  type: integer
+                limit:
+                  description: Limit is the number of bytes that can be queued waiting
+                    for tokens to become available.
+                  format: int32
+                  minimum: 1
+                  type: integer
+                minburst:
+                  description: Minburst specifies the size of the peakrate bucket.
+                    For perfect accuracy, should be set to the MTU of the interface.  If
+                    a peakrate is needed, but some burstiness is acceptable, this
+                    size can be raised. A 3000 byte minburst allows around 3mbit/s
+                    of peakrate, given 1000 byte packets.
+                  format: int32
+                  type: integer
+                peakrate:
+                  description: Peakrate is the maximum depletion rate of the bucket.
+                    The peakrate does not need to be set, it is only necessary if
+                    perfect millisecond timescale shaping is required.
+                  format: int64
+                  type: integer
+                rate:
+                  description: Rate is the speed knob. Allows bps, kbps, mbps, gbps,
+                    tbps unit. bps means bytes per second.
+                  type: string
+              required:
+              - buffer
+              - limit
+              - rate
+              type: object
             corrupt:
               description: Corrupt represents the detail about corrupt action
               properties: