From 37a0db167ff92c6520f2aa9f0b91c23a3d097609 Mon Sep 17 00:00:00 2001 From: cwen0 Date: Tue, 10 Nov 2020 15:33:22 +0800 Subject: [PATCH] support network delay attack Signed-off-by: cwen0 --- cmd/chaos/ctl/command/network_command.go | 6 +- cmd/chaos/ctl/command/util.go | 3 +- pkg/bpm/bpm.go | 6 + pkg/core/network.go | 101 ++++++- pkg/server/chaosd/iptable.go | 24 +- pkg/server/chaosd/network_attack.go | 55 +++- pkg/server/chaosd/tc.go | 48 +++- pkg/server/serverpb/chaosdaemon.pb.go | 331 ++++++++++++++--------- pkg/server/serverpb/chaosdaemon.proto | 37 ++- pkg/utils/check.go | 11 +- pkg/utils/cidr.go | 69 +++++ pkg/utils/string.go | 26 ++ 12 files changed, 528 insertions(+), 189 deletions(-) create mode 100644 pkg/utils/cidr.go create mode 100644 pkg/utils/string.go diff --git a/cmd/chaos/ctl/command/network_command.go b/cmd/chaos/ctl/command/network_command.go index 09c2ea3..d40f8a7 100644 --- a/cmd/chaos/ctl/command/network_command.go +++ b/cmd/chaos/ctl/command/network_command.go @@ -50,13 +50,13 @@ func NewNetworkDelayCommand() *cobra.Command { "jitter time, time units: ns, us (or µs), ms, s, m, h.") cmd.Flags().StringVarP(&nFlag.Device, "device", "d", "", "the network interface to impact") cmd.Flags().StringVarP(&nFlag.EgressPort, "egress-port", "e", "", - "only impact egress traffic to these destination ports, use a ',' to separate or to indicate the range, such as 80, 8001-8010") + "only impact egress traffic to these destination ports, use a ',' to separate or to indicate the range, such as 80, 8001:8010. It can only be used in conjunction with -p tcp or -p udp") cmd.Flags().StringVarP(&nFlag.SourcePort, "source-port", "s", "", - "only impact egress traffic from these source ports, use a ',' to separate or to indicate the range, such as 80, 8001-8010") + "only impact egress traffic from these source ports, use a ',' to separate or to indicate the range, such as 80, 8001:8010. It can only be used in conjunction with -p tcp or -p udp") cmd.Flags().StringVarP(&nFlag.IPAddress, "ip", "i", "", "only impact egress traffic to these IP addresses") cmd.Flags().StringVarP(&nFlag.Hostname, "hostname", "h", "", "only impact traffic to these hostnames") cmd.Flags().StringVarP(&nFlag.IPProtocol, "protocol", "p", "", - "only impact traffic using this IP protocol, supported: TCP, UDP, ICMP") + "only impact traffic using this IP protocol, supported: tcp, udp, icmp, all") nFlag.Action = core.NetworkDelayAction return cmd diff --git a/cmd/chaos/ctl/command/util.go b/cmd/chaos/ctl/command/util.go index 980512b..aa92236 100644 --- a/cmd/chaos/ctl/command/util.go +++ b/cmd/chaos/ctl/command/util.go @@ -14,6 +14,8 @@ package command import ( + "github.com/spf13/cobra" + "github.com/chaos-mesh/chaos-daemon/pkg/bpm" "github.com/chaos-mesh/chaos-daemon/pkg/config" "github.com/chaos-mesh/chaos-daemon/pkg/container" @@ -21,7 +23,6 @@ import ( "github.com/chaos-mesh/chaos-daemon/pkg/server/chaosd" "github.com/chaos-mesh/chaos-daemon/pkg/store/dbstore" "github.com/chaos-mesh/chaos-daemon/pkg/store/experiment" - "github.com/spf13/cobra" ) func mustChaosdFromCmd(cmd *cobra.Command, conf *config.Config) *chaosd.Server { diff --git a/pkg/bpm/bpm.go b/pkg/bpm/bpm.go index fe73413..fb92ca0 100644 --- a/pkg/bpm/bpm.go +++ b/pkg/bpm/bpm.go @@ -232,6 +232,9 @@ type ProcessBuilder struct { // SetNetNS sets the net namespace of the process func (b *ProcessBuilder) SetNetNS(nsPath string) *ProcessBuilder { + if len(nsPath) == 0 { + return b + } return b.SetNS([]nsOption{{ Typ: NetNS, Path: nsPath, @@ -240,6 +243,9 @@ func (b *ProcessBuilder) SetNetNS(nsPath string) *ProcessBuilder { // SetPidNS sets the pid namespace of the process func (b *ProcessBuilder) SetPidNS(nsPath string) *ProcessBuilder { + if len(nsPath) == 0 { + return b + } return b.SetNS([]nsOption{{ Typ: PidNS, Path: nsPath, diff --git a/pkg/core/network.go b/pkg/core/network.go index 9ff214d..abab546 100644 --- a/pkg/core/network.go +++ b/pkg/core/network.go @@ -16,9 +16,14 @@ package core import ( "encoding/json" "fmt" - "github.com/chaos-mesh/chaos-daemon/pkg/utils" - "github.com/pingcap/errors" + "strconv" + "strings" "time" + + "github.com/pingcap/errors" + + pb "github.com/chaos-mesh/chaos-daemon/pkg/server/serverpb" + "github.com/chaos-mesh/chaos-daemon/pkg/utils" ) type NetworkCommand struct { @@ -68,20 +73,32 @@ func (n *NetworkCommand) validNetworkDelay() error { return errors.New("device is required") } - if !utils.CheckPorts(n.SourcePort) { - return errors.Errorf("source ports %s not valid", n.SourcePort) - } - - if !utils.CheckPorts(n.EgressPort) { - return errors.Errorf("egress ports %s not valid", n.EgressPort) - } - if !utils.CheckIPs(n.IPAddress) { return errors.Errorf("ip addressed %s not valid", n.IPAddress) } - if !utils.CheckIPProtocols(n.IPProtocol) { - return errors.Errorf("ip protocols %s not valid", n.IPProtocol) + return checkProtocolAndPorts(n.IPProtocol, n.SourcePort, n.EgressPort) +} + +func checkProtocolAndPorts(p string, sports string, dports string) error { + if !utils.CheckPorts(sports) { + return errors.Errorf("source ports %s not valid", sports) + } + + if !utils.CheckPorts(dports) { + return errors.Errorf("egress ports %s not valid", dports) + } + + if !utils.CheckIPProtocols(p) { + return errors.Errorf("ip protocols %s not valid", p) + } + + if len(sports) > 0 || len(dports) > 0 { + if p == "tcp" || p == "udp" { + return nil + } + + return errors.New("ip protocol is required") } return nil @@ -92,3 +109,63 @@ func (n *NetworkCommand) String() string { return string(data) } + +func (n *NetworkCommand) ToNetem() (*pb.Netem, error) { + delayTime, err := time.ParseDuration(n.Latency) + if err != nil { + return nil, errors.WithStack(err) + } + + jitter, err := time.ParseDuration(n.Jitter) + if err != nil { + return nil, errors.WithStack(err) + } + + corr, err := strconv.ParseFloat(n.Correlation, 32) + if err != nil { + return nil, errors.WithStack(err) + } + + netem := &pb.Netem{ + Device: n.Device, + Time: uint32(delayTime.Nanoseconds() / 1e3), + DelayCorr: float32(corr), + Jitter: uint32(jitter.Nanoseconds() / 1e3), + } + + return netem, nil +} + +func (n *NetworkCommand) ToIPSet(name string) (*pb.IPSet, error) { + var ( + cidrs []string + err error + ) + if len(n.IPAddress) > 0 { + cidrs, err = utils.ResolveCidrs(strings.Split(n.IPAddress, ",")) + if err != nil { + return nil, errors.WithStack(err) + } + } + + if len(n.Hostname) > 0 { + cs, err := utils.ResolveCidrs(strings.Split(n.Hostname, ",")) + if err != nil { + return nil, errors.WithStack(err) + } + cidrs = append(cidrs, cs...) + } + + return &pb.IPSet{ + Name: name, + Cidrs: cidrs, + }, nil +} + +func (n *NetworkCommand) NeedApplyIPSet() bool { + if len(n.IPAddress) > 0 || len(n.Hostname) > 0 { + return true + } + + return false +} diff --git a/pkg/server/chaosd/iptable.go b/pkg/server/chaosd/iptable.go index 0fa9805..b72e884 100644 --- a/pkg/server/chaosd/iptable.go +++ b/pkg/server/chaosd/iptable.go @@ -68,8 +68,8 @@ type iptablesChain struct { Rules []string } -func buildIptablesClient(ctx context.Context, nsPath string) iptablesClient { - return iptablesClient{ +func buildIptablesClient(ctx context.Context, nsPath string) *iptablesClient { + return &iptablesClient{ ctx, nsPath, } @@ -96,16 +96,28 @@ func (iptables *iptablesClient) setIptablesChain(chain *pb.Chain) error { return fmt.Errorf("unknown chain direction %d", chain.Direction) } + protocolAndPort := chain.Protocol + if len(protocolAndPort) > 0 { + if len(chain.SourcePorts) > 0 { + protocolAndPort += " " + chain.SourcePorts + } + + if len(chain.DestinationPorts) > 0 { + protocolAndPort += " " + chain.DestinationPorts + } + } + rules := []string{} for _, ipset := range chain.Ipsets { - rules = append(rules, fmt.Sprintf("-A %s -m set --match-set %s %s -j DROP -w 5", chain.Name, ipset, matchPart)) + rules = append(rules, fmt.Sprintf("-A %s -m set --match-set %s %s -j %s -w 5 %s", + chain.Name, ipset, matchPart, chain.Target, protocolAndPort)) } err := iptables.createNewChain(&iptablesChain{ Name: chain.Name, Rules: rules, }) if err != nil { - return err + return errors.WithStack(err) } if chain.Direction == pb.Chain_INPUT { @@ -113,14 +125,14 @@ func (iptables *iptablesClient) setIptablesChain(chain *pb.Chain) error { Name: "CHAOS-INPUT", }, "-A CHAOS-INPUT -j "+chain.Name) if err != nil { - return err + return errors.WithStack(err) } } else if chain.Direction == pb.Chain_OUTPUT { iptables.ensureRule(&iptablesChain{ Name: "CHAOS-OUTPUT", }, "-A CHAOS-OUTPUT -j "+chain.Name) if err != nil { - return err + return errors.WithStack(err) } } else { return fmt.Errorf("unknown direction %d", chain.Direction) diff --git a/pkg/server/chaosd/network_attack.go b/pkg/server/chaosd/network_attack.go index 0c5c08e..8a9e332 100644 --- a/pkg/server/chaosd/network_attack.go +++ b/pkg/server/chaosd/network_attack.go @@ -13,8 +13,61 @@ package chaosd -import "github.com/chaos-mesh/chaos-daemon/pkg/core" +import ( + "context" + "fmt" + + "github.com/google/uuid" + "github.com/pingcap/errors" + + "github.com/chaos-mesh/chaos-daemon/pkg/core" + pb "github.com/chaos-mesh/chaos-daemon/pkg/server/serverpb" +) func (s *Server) NetworkAttack(attack *core.NetworkCommand) (string, error) { + uid := uuid.New() + ipsetName := "" + if attack.NeedApplyIPSet() { + ipset, err := attack.ToIPSet(fmt.Sprintf("chaos-%s", uid.String())) + if err != nil { + return "", errors.WithStack(err) + } + + if err := flushIPSet(context.Background(), "", ipset); err != nil { + return "", errors.WithStack(err) + } + ipsetName = ipset.Name + } + + switch attack.Action { + case core.NetworkDelayAction: + netem, err := attack.ToNetem() + if err != nil { + return "", errors.WithStack(err) + } + tc := &pb.Tc{ + Type: pb.Tc_NETEM, + Netem: netem, + Ipset: ipsetName, + Protocol: attack.IPProtocol, + SourcePort: attack.SourcePort, + EgressPort: attack.EgressPort, + } + + in := &pb.TcsRequest{ + Tcs: []*pb.Tc{tc}, + } + + if err := s.SetNodeTcRules(context.Background(), in); err != nil { + return "", errors.WithStack(err) + } + + return uid.String(), nil + } + return "", nil } + +func (s *Server) applyIPSet(attack *core.NetworkCommand) error { + return nil +} diff --git a/pkg/server/chaosd/tc.go b/pkg/server/chaosd/tc.go index 5809347..f17ab32 100644 --- a/pkg/server/chaosd/tc.go +++ b/pkg/server/chaosd/tc.go @@ -76,6 +76,19 @@ func (s *Server) SetContainerTcRules(ctx context.Context, in *pb.TcsRequest) err nsPath := GetNsPath(pid, bpm.NetNS) tcClient := buildTcClient(ctx, nsPath) + iptables := buildIptablesClient(ctx, nsPath) + + return applyTCRules(ctx, tcClient, iptables, in) +} + +func (s *Server) SetNodeTcRules(ctx context.Context, in *pb.TcsRequest) error { + tcClient := buildTcClient(ctx, "") + iptables := buildIptablesClient(ctx, "") + + return applyTCRules(ctx, tcClient, iptables, in) +} + +func applyTCRules(ctx context.Context, tcClient *tcClient, iptables *iptablesClient, in *pb.TcsRequest) error { if err := tcClient.flush(); err != nil { return errors.WithStack(err) } @@ -133,8 +146,7 @@ func (s *Server) SetContainerTcRules(ctx context.Context, in *pb.TcsRequest) err parent := len(globalTc) band := 3 + len(filterTc) // 3 handlers for normal sfq on prio qdisc - err = tcClient.addPrio(parent, band) - if err != nil { + if err := tcClient.addPrio(parent, band); err != nil { log.Error("failed to add prio", zap.Error(err)) return errors.WithStack(err) } @@ -144,8 +156,6 @@ func (s *Server) SetContainerTcRules(ctx context.Context, in *pb.TcsRequest) err index := 0 currentHandler := parent + 3 // 3 handlers for sfq on prio qdisc - iptables := buildIptablesClient(ctx, nsPath) - // iptables chain has been initialized by previous grpc request to set iptables // and iptables rules are recovered by previous call too, so there is no need // to remove these rules here @@ -167,16 +177,36 @@ func (s *Server) SetContainerTcRules(ctx context.Context, in *pb.TcsRequest) err } } - chains = append(chains, &pb.Chain{ + ch := &pb.Chain{ Name: fmt.Sprintf("TC-TABLES-%d", index), Direction: pb.Chain_OUTPUT, Ipsets: []string{ipset}, Target: fmt.Sprintf("CLASSIFY --set-class %d:%d", parent, index+4), - }) + } + + // TODO: refactor this + tc := tcs[0] + if len(tc.Protocol) > 0 { + ch.Protocol = fmt.Sprintf("--protocol %s", tc.Protocol) + } + + if len(tc.SourcePort) > 0 || len(tc.EgressPort) > 0 { + ch.SourcePorts = fmt.Sprintf("--source-port %s", tc.SourcePort) + if strings.Contains(tc.SourcePort, ",") { + ch.SourcePorts = fmt.Sprintf("-m multiport --source-ports %s", tc.SourcePort) + } + + ch.DestinationPorts = fmt.Sprintf("--destination-port %s", tc.EgressPort) + if strings.Contains(tc.EgressPort, ",") { + ch.DestinationPorts = fmt.Sprintf("-m multiport --destination-ports %s", tc.EgressPort) + } + } + + chains = append(chains, ch) index++ } - if err = iptables.setIptablesChains(chains); err != nil { + if err := iptables.setIptablesChains(chains); err != nil { log.Error("failed to set iptables", zap.Error(err)) return errors.WithStack(err) } @@ -190,8 +220,8 @@ type tcClient struct { nsPath string } -func buildTcClient(ctx context.Context, nsPath string) tcClient { - return tcClient{ +func buildTcClient(ctx context.Context, nsPath string) *tcClient { + return &tcClient{ ctx, nsPath, } diff --git a/pkg/server/serverpb/chaosdaemon.pb.go b/pkg/server/serverpb/chaosdaemon.pb.go index 3db8d8c..10907bb 100644 --- a/pkg/server/serverpb/chaosdaemon.pb.go +++ b/pkg/server/serverpb/chaosdaemon.pb.go @@ -48,7 +48,7 @@ func (x Chain_Direction) String() string { return proto.EnumName(Chain_Direction_name, int32(x)) } func (Chain_Direction) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{16, 0} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{16, 0} } type ContainerAction_Action int32 @@ -71,7 +71,7 @@ func (x ContainerAction_Action) String() string { return proto.EnumName(ContainerAction_Action_name, int32(x)) } func (ContainerAction_Action) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{18, 0} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{18, 0} } type ExecStressRequest_Scope int32 @@ -94,7 +94,7 @@ func (x ExecStressRequest_Scope) String() string { return proto.EnumName(ExecStressRequest_Scope_name, int32(x)) } func (ExecStressRequest_Scope) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{19, 0} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{19, 0} } type Tc_Type int32 @@ -117,7 +117,7 @@ func (x Tc_Type) String() string { return proto.EnumName(Tc_Type_name, int32(x)) } func (Tc_Type) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{25, 0} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{25, 0} } type TcHandle struct { @@ -132,7 +132,7 @@ func (m *TcHandle) Reset() { *m = TcHandle{} } func (m *TcHandle) String() string { return proto.CompactTextString(m) } func (*TcHandle) ProtoMessage() {} func (*TcHandle) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{0} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{0} } func (m *TcHandle) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_TcHandle.Unmarshal(m, b) @@ -178,7 +178,7 @@ func (m *ContainerRequest) Reset() { *m = ContainerRequest{} } func (m *ContainerRequest) String() string { return proto.CompactTextString(m) } func (*ContainerRequest) ProtoMessage() {} func (*ContainerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{1} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{1} } func (m *ContainerRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ContainerRequest.Unmarshal(m, b) @@ -223,7 +223,7 @@ func (m *ContainerResponse) Reset() { *m = ContainerResponse{} } func (m *ContainerResponse) String() string { return proto.CompactTextString(m) } func (*ContainerResponse) ProtoMessage() {} func (*ContainerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{2} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{2} } func (m *ContainerResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ContainerResponse.Unmarshal(m, b) @@ -264,7 +264,7 @@ func (m *NetemRequest) Reset() { *m = NetemRequest{} } func (m *NetemRequest) String() string { return proto.CompactTextString(m) } func (*NetemRequest) ProtoMessage() {} func (*NetemRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{3} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{3} } func (m *NetemRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_NetemRequest.Unmarshal(m, b) @@ -313,21 +313,22 @@ func (m *NetemRequest) GetParent() *TcHandle { } type Netem struct { - Time uint32 `protobuf:"varint,1,opt,name=time,proto3" json:"time,omitempty"` - Jitter uint32 `protobuf:"varint,2,opt,name=jitter,proto3" json:"jitter,omitempty"` - DelayCorr float32 `protobuf:"fixed32,3,opt,name=delay_corr,json=delayCorr,proto3" json:"delay_corr,omitempty"` - Limit uint32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"` - Loss float32 `protobuf:"fixed32,5,opt,name=loss,proto3" json:"loss,omitempty"` - LossCorr float32 `protobuf:"fixed32,6,opt,name=loss_corr,json=lossCorr,proto3" json:"loss_corr,omitempty"` - Gap uint32 `protobuf:"varint,7,opt,name=gap,proto3" json:"gap,omitempty"` - Duplicate float32 `protobuf:"fixed32,8,opt,name=duplicate,proto3" json:"duplicate,omitempty"` - DuplicateCorr float32 `protobuf:"fixed32,9,opt,name=duplicate_corr,json=duplicateCorr,proto3" json:"duplicate_corr,omitempty"` - Reorder float32 `protobuf:"fixed32,10,opt,name=reorder,proto3" json:"reorder,omitempty"` - ReorderCorr float32 `protobuf:"fixed32,11,opt,name=reorder_corr,json=reorderCorr,proto3" json:"reorder_corr,omitempty"` - Corrupt float32 `protobuf:"fixed32,12,opt,name=corrupt,proto3" json:"corrupt,omitempty"` - CorruptCorr float32 `protobuf:"fixed32,13,opt,name=corrupt_corr,json=corruptCorr,proto3" json:"corrupt_corr,omitempty"` - Parent *TcHandle `protobuf:"bytes,14,opt,name=parent,proto3" json:"parent,omitempty"` - Handle *TcHandle `protobuf:"bytes,15,opt,name=handle,proto3" json:"handle,omitempty"` + Device string `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"` + Time uint32 `protobuf:"varint,2,opt,name=time,proto3" json:"time,omitempty"` + Jitter uint32 `protobuf:"varint,3,opt,name=jitter,proto3" json:"jitter,omitempty"` + DelayCorr float32 `protobuf:"fixed32,4,opt,name=delay_corr,json=delayCorr,proto3" json:"delay_corr,omitempty"` + Limit uint32 `protobuf:"varint,5,opt,name=limit,proto3" json:"limit,omitempty"` + Loss float32 `protobuf:"fixed32,6,opt,name=loss,proto3" json:"loss,omitempty"` + LossCorr float32 `protobuf:"fixed32,7,opt,name=loss_corr,json=lossCorr,proto3" json:"loss_corr,omitempty"` + Gap uint32 `protobuf:"varint,8,opt,name=gap,proto3" json:"gap,omitempty"` + Duplicate float32 `protobuf:"fixed32,9,opt,name=duplicate,proto3" json:"duplicate,omitempty"` + DuplicateCorr float32 `protobuf:"fixed32,10,opt,name=duplicate_corr,json=duplicateCorr,proto3" json:"duplicate_corr,omitempty"` + Reorder float32 `protobuf:"fixed32,11,opt,name=reorder,proto3" json:"reorder,omitempty"` + ReorderCorr float32 `protobuf:"fixed32,12,opt,name=reorder_corr,json=reorderCorr,proto3" json:"reorder_corr,omitempty"` + Corrupt float32 `protobuf:"fixed32,13,opt,name=corrupt,proto3" json:"corrupt,omitempty"` + CorruptCorr float32 `protobuf:"fixed32,14,opt,name=corrupt_corr,json=corruptCorr,proto3" json:"corrupt_corr,omitempty"` + Parent *TcHandle `protobuf:"bytes,15,opt,name=parent,proto3" json:"parent,omitempty"` + Handle *TcHandle `protobuf:"bytes,16,opt,name=handle,proto3" json:"handle,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -337,7 +338,7 @@ func (m *Netem) Reset() { *m = Netem{} } func (m *Netem) String() string { return proto.CompactTextString(m) } func (*Netem) ProtoMessage() {} func (*Netem) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{4} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{4} } func (m *Netem) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Netem.Unmarshal(m, b) @@ -357,6 +358,13 @@ func (m *Netem) XXX_DiscardUnknown() { var xxx_messageInfo_Netem proto.InternalMessageInfo +func (m *Netem) GetDevice() string { + if m != nil { + return m.Device + } + return "" +} + func (m *Netem) GetTime() uint32 { if m != nil { return m.Time @@ -474,7 +482,7 @@ func (m *TbfRequest) Reset() { *m = TbfRequest{} } func (m *TbfRequest) String() string { return proto.CompactTextString(m) } func (*TbfRequest) ProtoMessage() {} func (*TbfRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{5} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{5} } func (m *TbfRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_TbfRequest.Unmarshal(m, b) @@ -523,7 +531,7 @@ func (m *Tbf) Reset() { *m = Tbf{} } func (m *Tbf) String() string { return proto.CompactTextString(m) } func (*Tbf) ProtoMessage() {} func (*Tbf) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{6} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{6} } func (m *Tbf) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Tbf.Unmarshal(m, b) @@ -590,7 +598,7 @@ func (m *QdiscRequest) Reset() { *m = QdiscRequest{} } func (m *QdiscRequest) String() string { return proto.CompactTextString(m) } func (*QdiscRequest) ProtoMessage() {} func (*QdiscRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{7} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{7} } func (m *QdiscRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_QdiscRequest.Unmarshal(m, b) @@ -638,7 +646,7 @@ func (m *Qdisc) Reset() { *m = Qdisc{} } func (m *Qdisc) String() string { return proto.CompactTextString(m) } func (*Qdisc) ProtoMessage() {} func (*Qdisc) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{8} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{8} } func (m *Qdisc) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Qdisc.Unmarshal(m, b) @@ -698,7 +706,7 @@ func (m *EmatchFilterRequest) Reset() { *m = EmatchFilterRequest{} } func (m *EmatchFilterRequest) String() string { return proto.CompactTextString(m) } func (*EmatchFilterRequest) ProtoMessage() {} func (*EmatchFilterRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{9} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{9} } func (m *EmatchFilterRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_EmatchFilterRequest.Unmarshal(m, b) @@ -745,7 +753,7 @@ func (m *EmatchFilter) Reset() { *m = EmatchFilter{} } func (m *EmatchFilter) String() string { return proto.CompactTextString(m) } func (*EmatchFilter) ProtoMessage() {} func (*EmatchFilter) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{10} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{10} } func (m *EmatchFilter) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_EmatchFilter.Unmarshal(m, b) @@ -798,7 +806,7 @@ func (m *TcFilterRequest) Reset() { *m = TcFilterRequest{} } func (m *TcFilterRequest) String() string { return proto.CompactTextString(m) } func (*TcFilterRequest) ProtoMessage() {} func (*TcFilterRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{11} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{11} } func (m *TcFilterRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_TcFilterRequest.Unmarshal(m, b) @@ -843,7 +851,7 @@ func (m *TcFilter) Reset() { *m = TcFilter{} } func (m *TcFilter) String() string { return proto.CompactTextString(m) } func (*TcFilter) ProtoMessage() {} func (*TcFilter) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{12} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{12} } func (m *TcFilter) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_TcFilter.Unmarshal(m, b) @@ -882,7 +890,7 @@ func (m *IPSetsRequest) Reset() { *m = IPSetsRequest{} } func (m *IPSetsRequest) String() string { return proto.CompactTextString(m) } func (*IPSetsRequest) ProtoMessage() {} func (*IPSetsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{13} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{13} } func (m *IPSetsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_IPSetsRequest.Unmarshal(m, b) @@ -928,7 +936,7 @@ func (m *IPSet) Reset() { *m = IPSet{} } func (m *IPSet) String() string { return proto.CompactTextString(m) } func (*IPSet) ProtoMessage() {} func (*IPSet) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{14} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{14} } func (m *IPSet) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_IPSet.Unmarshal(m, b) @@ -974,7 +982,7 @@ func (m *IptablesChainsRequest) Reset() { *m = IptablesChainsRequest{} } func (m *IptablesChainsRequest) String() string { return proto.CompactTextString(m) } func (*IptablesChainsRequest) ProtoMessage() {} func (*IptablesChainsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{15} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{15} } func (m *IptablesChainsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_IptablesChainsRequest.Unmarshal(m, b) @@ -1013,6 +1021,9 @@ type Chain struct { Direction Chain_Direction `protobuf:"varint,2,opt,name=direction,proto3,enum=serverpb.Chain_Direction" json:"direction,omitempty"` Ipsets []string `protobuf:"bytes,3,rep,name=ipsets,proto3" json:"ipsets,omitempty"` Target string `protobuf:"bytes,4,opt,name=target,proto3" json:"target,omitempty"` + Protocol string `protobuf:"bytes,5,opt,name=protocol,proto3" json:"protocol,omitempty"` + SourcePorts string `protobuf:"bytes,6,opt,name=source_ports,json=sourcePorts,proto3" json:"source_ports,omitempty"` + DestinationPorts string `protobuf:"bytes,7,opt,name=destination_ports,json=destinationPorts,proto3" json:"destination_ports,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -1022,7 +1033,7 @@ func (m *Chain) Reset() { *m = Chain{} } func (m *Chain) String() string { return proto.CompactTextString(m) } func (*Chain) ProtoMessage() {} func (*Chain) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{16} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{16} } func (m *Chain) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Chain.Unmarshal(m, b) @@ -1070,6 +1081,27 @@ func (m *Chain) GetTarget() string { return "" } +func (m *Chain) GetProtocol() string { + if m != nil { + return m.Protocol + } + return "" +} + +func (m *Chain) GetSourcePorts() string { + if m != nil { + return m.SourcePorts + } + return "" +} + +func (m *Chain) GetDestinationPorts() string { + if m != nil { + return m.DestinationPorts + } + return "" +} + type TimeRequest struct { ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` Sec int64 `protobuf:"varint,2,opt,name=sec,proto3" json:"sec,omitempty"` @@ -1084,7 +1116,7 @@ func (m *TimeRequest) Reset() { *m = TimeRequest{} } func (m *TimeRequest) String() string { return proto.CompactTextString(m) } func (*TimeRequest) ProtoMessage() {} func (*TimeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{17} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{17} } func (m *TimeRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_TimeRequest.Unmarshal(m, b) @@ -1143,7 +1175,7 @@ func (m *ContainerAction) Reset() { *m = ContainerAction{} } func (m *ContainerAction) String() string { return proto.CompactTextString(m) } func (*ContainerAction) ProtoMessage() {} func (*ContainerAction) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{18} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{18} } func (m *ContainerAction) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ContainerAction.Unmarshal(m, b) @@ -1183,7 +1215,7 @@ func (m *ExecStressRequest) Reset() { *m = ExecStressRequest{} } func (m *ExecStressRequest) String() string { return proto.CompactTextString(m) } func (*ExecStressRequest) ProtoMessage() {} func (*ExecStressRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{19} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{19} } func (m *ExecStressRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ExecStressRequest.Unmarshal(m, b) @@ -1236,7 +1268,7 @@ func (m *ExecStressResponse) Reset() { *m = ExecStressResponse{} } func (m *ExecStressResponse) String() string { return proto.CompactTextString(m) } func (*ExecStressResponse) ProtoMessage() {} func (*ExecStressResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{20} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{20} } func (m *ExecStressResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ExecStressResponse.Unmarshal(m, b) @@ -1282,7 +1314,7 @@ func (m *CancelStressRequest) Reset() { *m = CancelStressRequest{} } func (m *CancelStressRequest) String() string { return proto.CompactTextString(m) } func (*CancelStressRequest) ProtoMessage() {} func (*CancelStressRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{21} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{21} } func (m *CancelStressRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CancelStressRequest.Unmarshal(m, b) @@ -1331,7 +1363,7 @@ func (m *ApplyIoChaosRequest) Reset() { *m = ApplyIoChaosRequest{} } func (m *ApplyIoChaosRequest) String() string { return proto.CompactTextString(m) } func (*ApplyIoChaosRequest) ProtoMessage() {} func (*ApplyIoChaosRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{22} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{22} } func (m *ApplyIoChaosRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ApplyIoChaosRequest.Unmarshal(m, b) @@ -1398,7 +1430,7 @@ func (m *ApplyIoChaosResponse) Reset() { *m = ApplyIoChaosResponse{} } func (m *ApplyIoChaosResponse) String() string { return proto.CompactTextString(m) } func (*ApplyIoChaosResponse) ProtoMessage() {} func (*ApplyIoChaosResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{23} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{23} } func (m *ApplyIoChaosResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ApplyIoChaosResponse.Unmarshal(m, b) @@ -1444,7 +1476,7 @@ func (m *TcsRequest) Reset() { *m = TcsRequest{} } func (m *TcsRequest) String() string { return proto.CompactTextString(m) } func (*TcsRequest) ProtoMessage() {} func (*TcsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{24} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{24} } func (m *TcsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_TcsRequest.Unmarshal(m, b) @@ -1483,6 +1515,9 @@ type Tc struct { Netem *Netem `protobuf:"bytes,2,opt,name=netem,proto3" json:"netem,omitempty"` Tbf *Tbf `protobuf:"bytes,3,opt,name=tbf,proto3" json:"tbf,omitempty"` Ipset string `protobuf:"bytes,4,opt,name=ipset,proto3" json:"ipset,omitempty"` + Protocol string `protobuf:"bytes,5,opt,name=protocol,proto3" json:"protocol,omitempty"` + SourcePort string `protobuf:"bytes,6,opt,name=sourcePort,proto3" json:"sourcePort,omitempty"` + EgressPort string `protobuf:"bytes,7,opt,name=egressPort,proto3" json:"egressPort,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -1492,7 +1527,7 @@ func (m *Tc) Reset() { *m = Tc{} } func (m *Tc) String() string { return proto.CompactTextString(m) } func (*Tc) ProtoMessage() {} func (*Tc) Descriptor() ([]byte, []int) { - return fileDescriptor_chaosdaemon_0c95b7b85afc739d, []int{25} + return fileDescriptor_chaosdaemon_37ba8eadb84dc86b, []int{25} } func (m *Tc) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Tc.Unmarshal(m, b) @@ -1540,6 +1575,27 @@ func (m *Tc) GetIpset() string { return "" } +func (m *Tc) GetProtocol() string { + if m != nil { + return m.Protocol + } + return "" +} + +func (m *Tc) GetSourcePort() string { + if m != nil { + return m.SourcePort + } + return "" +} + +func (m *Tc) GetEgressPort() string { + if m != nil { + return m.EgressPort + } + return "" +} + func init() { proto.RegisterType((*TcHandle)(nil), "serverpb.TcHandle") proto.RegisterType((*ContainerRequest)(nil), "serverpb.ContainerRequest") @@ -1942,95 +1998,100 @@ var _ChaosDaemon_serviceDesc = grpc.ServiceDesc{ Metadata: "chaosdaemon.proto", } -func init() { proto.RegisterFile("chaosdaemon.proto", fileDescriptor_chaosdaemon_0c95b7b85afc739d) } +func init() { proto.RegisterFile("chaosdaemon.proto", fileDescriptor_chaosdaemon_37ba8eadb84dc86b) } -var fileDescriptor_chaosdaemon_0c95b7b85afc739d = []byte{ - // 1382 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xdd, 0x6e, 0xdb, 0x36, - 0x14, 0x8e, 0x2c, 0xcb, 0xb1, 0x8e, 0xed, 0xc4, 0x61, 0xd3, 0x4c, 0x4b, 0xfa, 0x93, 0x0a, 0x08, - 0x36, 0x14, 0x83, 0x8b, 0x76, 0xc0, 0xba, 0xcb, 0xa5, 0x89, 0xdb, 0x7a, 0x6d, 0x1d, 0x4f, 0x51, - 0xb1, 0x01, 0xbb, 0xc8, 0x64, 0x89, 0x8e, 0xd5, 0xc8, 0x92, 0x2a, 0xd2, 0x45, 0x73, 0x33, 0x60, - 0x57, 0x7b, 0x90, 0xed, 0x62, 0xc0, 0x6e, 0xf6, 0x0c, 0x7b, 0x93, 0xbd, 0xc9, 0xc0, 0x43, 0xca, - 0x96, 0x93, 0xd8, 0x71, 0xb6, 0x2b, 0xf3, 0xfc, 0x7d, 0x3c, 0x3f, 0xd4, 0x47, 0x1a, 0x36, 0xfc, - 0xa1, 0x97, 0xb0, 0xc0, 0xa3, 0xa3, 0x24, 0x6e, 0xa5, 0x59, 0xc2, 0x13, 0x52, 0x65, 0x34, 0xfb, - 0x40, 0xb3, 0xb4, 0xbf, 0xbd, 0x73, 0x9a, 0x24, 0xa7, 0x11, 0x7d, 0x84, 0xfa, 0xfe, 0x78, 0xf0, - 0x88, 0x8e, 0x52, 0x7e, 0x2e, 0xdd, 0xec, 0xaf, 0xa0, 0xea, 0xfa, 0x2f, 0xbd, 0x38, 0x88, 0x28, - 0xd9, 0x04, 0x63, 0xe4, 0xbd, 0x4b, 0x32, 0x4b, 0xdb, 0xd5, 0x3e, 0x6f, 0x38, 0x52, 0x40, 0x6d, - 0x18, 0x27, 0x99, 0x55, 0x52, 0x5a, 0x21, 0xd8, 0x43, 0x68, 0x1e, 0x24, 0x31, 0xf7, 0xc2, 0x98, - 0x66, 0x0e, 0x7d, 0x3f, 0xa6, 0x8c, 0x93, 0xc7, 0x50, 0xf1, 0x7c, 0x1e, 0x26, 0x31, 0x02, 0xd4, - 0x9e, 0x7c, 0xda, 0xca, 0x73, 0x68, 0x4d, 0x7c, 0xf7, 0xd1, 0xc1, 0x51, 0x8e, 0xe4, 0x01, 0xd4, - 0xfd, 0xdc, 0x74, 0x12, 0x06, 0xb8, 0x87, 0xe9, 0xd4, 0x26, 0xba, 0x4e, 0x60, 0xef, 0xc1, 0x46, - 0x61, 0x27, 0x96, 0x26, 0x31, 0xa3, 0xa4, 0x09, 0x7a, 0x1a, 0x06, 0x2a, 0x51, 0xb1, 0xb4, 0xff, - 0xd2, 0xa0, 0xde, 0xa5, 0x9c, 0x8e, 0xf2, 0x6c, 0xf6, 0xc0, 0x88, 0x85, 0xac, 0x92, 0x59, 0x9f, - 0x26, 0x23, 0xdd, 0xa4, 0x75, 0x89, 0x0c, 0xc8, 0x43, 0xa8, 0x0c, 0xb1, 0x43, 0x96, 0x8e, 0x50, - 0x64, 0x0a, 0x95, 0xf7, 0xce, 0x51, 0x1e, 0xc2, 0x37, 0xf5, 0x32, 0x1a, 0x73, 0xab, 0x3c, 0xdf, - 0x57, 0x7a, 0xd8, 0x7f, 0xeb, 0x60, 0x60, 0x2e, 0x84, 0x40, 0x99, 0x87, 0x23, 0xaa, 0xea, 0xc1, - 0x35, 0xd9, 0x82, 0xca, 0xbb, 0x90, 0x73, 0x9a, 0x37, 0x5e, 0x49, 0xe4, 0x2e, 0x40, 0x40, 0x23, - 0xef, 0xfc, 0xc4, 0x4f, 0xb2, 0x0c, 0x33, 0x2a, 0x39, 0x26, 0x6a, 0x0e, 0x92, 0x0c, 0xc7, 0x15, - 0x85, 0xa3, 0x50, 0xee, 0xdf, 0x70, 0xa4, 0x20, 0x36, 0x88, 0x12, 0xc6, 0x2c, 0x03, 0xdd, 0x71, - 0x4d, 0x76, 0xc0, 0x14, 0xbf, 0x12, 0xa7, 0x82, 0x86, 0xaa, 0x50, 0x20, 0x4c, 0x13, 0xf4, 0x53, - 0x2f, 0xb5, 0x56, 0x65, 0x83, 0x4f, 0xbd, 0x94, 0xdc, 0x01, 0x33, 0x18, 0xa7, 0x51, 0xe8, 0x7b, - 0x9c, 0x5a, 0x55, 0xb5, 0x6d, 0xae, 0x20, 0x7b, 0xb0, 0x36, 0x11, 0x24, 0xa2, 0x89, 0x2e, 0x8d, - 0x89, 0x16, 0x61, 0x2d, 0x58, 0xcd, 0x68, 0x92, 0x05, 0x34, 0xb3, 0x00, 0xed, 0xb9, 0x28, 0xe6, - 0xa0, 0x96, 0x32, 0xbc, 0x86, 0xe6, 0x9a, 0xd2, 0xe5, 0xc1, 0xc2, 0x34, 0x4e, 0xb9, 0x55, 0x97, - 0xc1, 0x4a, 0x94, 0x43, 0xc4, 0xa5, 0x0c, 0x6e, 0xc8, 0x60, 0xa5, 0xc3, 0xe0, 0xe9, 0x60, 0xd6, - 0xae, 0x1b, 0x4c, 0x61, 0xe0, 0xeb, 0xd7, 0x0d, 0xdc, 0xee, 0x01, 0xb8, 0xfd, 0x41, 0x7e, 0xe8, - 0xee, 0x83, 0xce, 0xfb, 0x03, 0x75, 0xe4, 0x1a, 0x85, 0xb0, 0xfe, 0xc0, 0x11, 0x96, 0x65, 0x0e, - 0xfc, 0x2f, 0x1a, 0xe8, 0x6e, 0x7f, 0x20, 0x66, 0x96, 0x89, 0x5e, 0x0b, 0xb0, 0xb2, 0x83, 0xeb, - 0xe9, 0x74, 0x4b, 0xc5, 0xe9, 0x6e, 0x41, 0xa5, 0x3f, 0x1e, 0x0c, 0xa8, 0x3c, 0x0e, 0x0d, 0x47, - 0x49, 0x62, 0xc2, 0x29, 0xf5, 0xce, 0x4e, 0x10, 0xa6, 0x8c, 0x30, 0x55, 0xa1, 0x70, 0x04, 0xd4, - 0x0e, 0x98, 0xa3, 0x30, 0x3e, 0xe9, 0x8f, 0x33, 0xc6, 0xf1, 0x5c, 0x34, 0x9c, 0xea, 0x28, 0x8c, - 0x9f, 0x09, 0xd9, 0xfe, 0x01, 0xea, 0xdf, 0x05, 0x21, 0xf3, 0x0b, 0x1f, 0xd3, 0x7b, 0x21, 0x5f, - 0xfe, 0x98, 0xa4, 0x9b, 0xb4, 0x2e, 0x53, 0xdd, 0xaf, 0x1a, 0x18, 0x18, 0x53, 0x98, 0x88, 0x76, - 0x83, 0x89, 0x94, 0xae, 0xfd, 0x04, 0xc5, 0xc7, 0x74, 0x9e, 0xca, 0x8f, 0xd5, 0x74, 0x70, 0x2d, - 0x74, 0x5e, 0x76, 0xca, 0xac, 0xf2, 0xae, 0x2e, 0x74, 0x62, 0x6d, 0x0f, 0xe1, 0x56, 0x7b, 0xe4, - 0x71, 0x7f, 0xf8, 0x3c, 0x8c, 0xf8, 0x94, 0xc5, 0x5a, 0x50, 0x19, 0xa0, 0x42, 0xa5, 0xb5, 0x35, - 0xdd, 0x6a, 0xc6, 0x5d, 0x79, 0x2d, 0x53, 0xf3, 0xcf, 0x50, 0x2f, 0x86, 0x4a, 0xa2, 0xe5, 0xfe, - 0x10, 0x77, 0x30, 0x1d, 0x29, 0x14, 0xfa, 0x51, 0xba, 0xb6, 0x1f, 0x5f, 0xc0, 0xaa, 0x1f, 0x79, - 0x8c, 0x85, 0xc1, 0x02, 0x4e, 0xca, 0x5d, 0xec, 0x9f, 0x60, 0xdd, 0xf5, 0x67, 0xab, 0x7c, 0x78, - 0xa1, 0xca, 0x99, 0xf8, 0x9b, 0x57, 0x88, 0xd7, 0x88, 0xaa, 0xee, 0x06, 0x73, 0xb5, 0x7f, 0x84, - 0x46, 0xa7, 0x77, 0x4c, 0x39, 0xcb, 0xf3, 0xfa, 0x0c, 0x2a, 0x61, 0xca, 0x28, 0x67, 0x96, 0xb6, - 0xab, 0xcf, 0x9e, 0x34, 0x74, 0x74, 0x94, 0x79, 0x99, 0xa4, 0x1e, 0x83, 0x81, 0x31, 0x62, 0xfa, - 0xb1, 0xa7, 0xe8, 0xd5, 0x74, 0x70, 0x2d, 0x66, 0xe0, 0x87, 0x41, 0xc6, 0xac, 0x12, 0x1e, 0x09, - 0x29, 0xd8, 0x3e, 0xdc, 0xee, 0xa4, 0xdc, 0xeb, 0x47, 0x94, 0x1d, 0x0c, 0xbd, 0x30, 0x2e, 0xe6, - 0xe5, 0xa3, 0xe2, 0x72, 0x5e, 0xe8, 0xe8, 0x28, 0xf3, 0x32, 0x79, 0xfd, 0xa1, 0x81, 0x81, 0x41, - 0x57, 0x26, 0xf6, 0x14, 0xcc, 0x20, 0xcc, 0xa8, 0xbc, 0x48, 0x45, 0xf4, 0xda, 0xcc, 0x45, 0x2a, - 0xe2, 0x5a, 0x87, 0xb9, 0x83, 0x33, 0xf5, 0x15, 0x2c, 0xa0, 0x5a, 0xa7, 0x63, 0x49, 0x79, 0xa7, - 0xb6, 0xa0, 0xc2, 0xbd, 0xec, 0x94, 0xca, 0x2b, 0xc1, 0x74, 0x94, 0x64, 0xdb, 0x60, 0x4e, 0x70, - 0x88, 0x09, 0x46, 0xa7, 0xdb, 0x7b, 0xeb, 0x36, 0x57, 0x08, 0x40, 0xe5, 0xe8, 0xad, 0x2b, 0xd6, - 0x9a, 0xfd, 0x11, 0x6a, 0x6e, 0x38, 0xa2, 0x79, 0x17, 0x2e, 0x16, 0xa7, 0x5d, 0xbe, 0x2c, 0x9b, - 0xa0, 0x33, 0xea, 0x63, 0xe2, 0xba, 0x23, 0x96, 0x58, 0xa4, 0x50, 0xe9, 0xa8, 0xc2, 0x35, 0xd9, - 0x85, 0xba, 0x1f, 0x9d, 0x9d, 0x84, 0x01, 0x3b, 0x19, 0x79, 0xec, 0x4c, 0x91, 0x13, 0xf8, 0xd1, - 0x59, 0x27, 0x60, 0x6f, 0x3c, 0x76, 0x66, 0x9f, 0xc1, 0xfa, 0x85, 0x47, 0x03, 0xf9, 0x7a, 0xe6, - 0x7d, 0xb1, 0xf6, 0x64, 0x77, 0xee, 0xfb, 0xa2, 0x35, 0xfb, 0xcc, 0xb0, 0xef, 0x41, 0x45, 0x61, - 0x54, 0xa1, 0xfc, 0xaa, 0xf3, 0xfa, 0xb5, 0x2c, 0xf3, 0x45, 0xdb, 0xed, 0x75, 0x0e, 0x9b, 0x9a, - 0xfd, 0x9b, 0x06, 0x1b, 0xed, 0x8f, 0xd4, 0x3f, 0xe6, 0x19, 0x65, 0x93, 0x99, 0x3f, 0x05, 0x83, - 0xf9, 0x49, 0x4a, 0xd5, 0x76, 0x0f, 0x0a, 0x44, 0x70, 0xd1, 0xb7, 0x75, 0x2c, 0x1c, 0x1d, 0xe9, - 0x5f, 0xe8, 0x78, 0xa9, 0xd8, 0x71, 0x71, 0x85, 0x32, 0x8c, 0x4a, 0x32, 0xa6, 0xe8, 0x69, 0xaa, - 0xb0, 0xef, 0x83, 0x81, 0x28, 0xa4, 0x01, 0xe6, 0xc1, 0x51, 0xd7, 0xdd, 0xef, 0x74, 0xdb, 0x4e, - 0x73, 0x85, 0xac, 0x82, 0xde, 0x3b, 0x12, 0x59, 0x76, 0x81, 0x14, 0x37, 0x56, 0x4f, 0xa1, 0x6d, - 0xa8, 0x86, 0x31, 0xe3, 0x5e, 0xec, 0xe7, 0xe7, 0x68, 0x22, 0xcb, 0x0d, 0xbd, 0x8c, 0x8b, 0x19, - 0xaa, 0x91, 0x4c, 0x15, 0xf6, 0x11, 0xdc, 0x3a, 0x10, 0x6e, 0xd1, 0x6c, 0xd9, 0xff, 0x1d, 0xf0, - 0x77, 0x0d, 0x6e, 0xed, 0xa7, 0x69, 0x74, 0xde, 0x49, 0x0e, 0xc4, 0x83, 0x34, 0x47, 0xb4, 0x60, - 0x55, 0x0e, 0x82, 0x29, 0xc0, 0x5c, 0x14, 0x9d, 0xfa, 0x90, 0x44, 0x63, 0x05, 0x66, 0x3a, 0x4a, - 0xba, 0x74, 0xd0, 0xf4, 0xcb, 0x07, 0xad, 0x98, 0x66, 0x19, 0x33, 0x99, 0x93, 0xa6, 0x71, 0x31, - 0xcd, 0x1e, 0x6c, 0xce, 0x66, 0x39, 0xa7, 0x93, 0xfa, 0x0d, 0x3a, 0x09, 0xae, 0x3f, 0x29, 0xf7, - 0x1e, 0xe8, 0xdc, 0xcf, 0x89, 0xa2, 0x5e, 0x64, 0x3f, 0x47, 0x18, 0x96, 0xa1, 0x88, 0x3f, 0x35, - 0x28, 0xb9, 0x3e, 0xd9, 0x53, 0x57, 0x99, 0x3c, 0x80, 0x1b, 0x45, 0xa8, 0x96, 0x7b, 0x9e, 0x52, - 0x75, 0xbb, 0x4d, 0x9e, 0xba, 0xa5, 0x85, 0x4f, 0x5d, 0xf5, 0x38, 0xd1, 0xe7, 0x3e, 0x4e, 0x36, - 0xc1, 0x40, 0xce, 0x50, 0x44, 0x21, 0x05, 0x7b, 0x17, 0xca, 0x62, 0x2f, 0x41, 0x11, 0xdd, 0xb6, - 0xdb, 0x7e, 0xd3, 0x5c, 0x11, 0x27, 0xf4, 0xd9, 0x7e, 0xf7, 0xf0, 0xfb, 0xce, 0xa1, 0xfb, 0xb2, - 0xa9, 0x3d, 0xf9, 0xc7, 0x80, 0x1a, 0xb6, 0xf2, 0x10, 0xff, 0x81, 0x88, 0x0f, 0xf5, 0x98, 0x72, - 0xd7, 0x67, 0x64, 0xb3, 0x98, 0x72, 0xde, 0xa0, 0xed, 0xad, 0x96, 0xfc, 0x4b, 0xd2, 0xca, 0xff, - 0x92, 0xb4, 0xda, 0xe2, 0x2f, 0x89, 0xbd, 0x42, 0xbe, 0x81, 0xda, 0xf3, 0x68, 0xcc, 0x86, 0xf2, - 0x52, 0x20, 0x9f, 0x5c, 0x60, 0xff, 0x25, 0x10, 0xba, 0xb0, 0x71, 0x4c, 0xf9, 0x2c, 0x89, 0x93, - 0xfb, 0x05, 0x9c, 0xab, 0xe8, 0x7d, 0x61, 0x46, 0x0d, 0x51, 0x4b, 0x38, 0xa2, 0x47, 0x83, 0x01, - 0xa3, 0x9c, 0xdc, 0x2e, 0x94, 0x34, 0xa5, 0xc6, 0x05, 0x08, 0x87, 0xb0, 0xe1, 0x50, 0x3f, 0xf9, - 0x40, 0xb3, 0xff, 0x83, 0xd2, 0x86, 0xc6, 0x84, 0xe4, 0x5e, 0x85, 0x51, 0x44, 0xb6, 0xaf, 0x60, - 0xbf, 0xeb, 0x61, 0x5e, 0x17, 0x68, 0xf5, 0x05, 0xe5, 0xbd, 0x30, 0x58, 0x08, 0xb4, 0x73, 0xa5, - 0x4d, 0x7e, 0x2f, 0x88, 0xd6, 0x98, 0x32, 0x52, 0x92, 0x31, 0xb2, 0xb3, 0x80, 0x23, 0xb7, 0xef, - 0x5c, 0x6d, 0x9c, 0xa0, 0x7d, 0x0b, 0xeb, 0x45, 0x3e, 0x12, 0x78, 0x77, 0x0b, 0xfb, 0x5f, 0xa6, - 0xaa, 0x05, 0x75, 0x1e, 0x41, 0xbd, 0xf8, 0x8d, 0x17, 0x81, 0xae, 0x60, 0xa8, 0xed, 0x7b, 0xf3, - 0xcc, 0x79, 0x72, 0xfd, 0x0a, 0x6e, 0xf1, 0xe5, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x5a, 0x9a, - 0x7b, 0x53, 0x6b, 0x0f, 0x00, 0x00, +var fileDescriptor_chaosdaemon_37ba8eadb84dc86b = []byte{ + // 1461 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xdd, 0x72, 0xda, 0x46, + 0x14, 0x36, 0x08, 0x30, 0x3a, 0x80, 0x0d, 0x1b, 0xc7, 0x55, 0x71, 0xe2, 0x38, 0x9a, 0xf1, 0xb4, + 0x93, 0x76, 0xc8, 0x24, 0x9d, 0x69, 0x7a, 0x59, 0xc7, 0x26, 0x09, 0x4d, 0x82, 0xa9, 0xac, 0x4c, + 0x3b, 0xd3, 0x0b, 0x2a, 0xa4, 0x05, 0x14, 0x0b, 0x49, 0xd1, 0x2e, 0x9e, 0xf8, 0xa6, 0x33, 0xbd, + 0xea, 0x0b, 0xf4, 0x0d, 0xda, 0x07, 0xe8, 0xf3, 0xf4, 0xae, 0x6f, 0xd2, 0xd9, 0xb3, 0x2b, 0x10, + 0xfe, 0xc1, 0xb8, 0xbd, 0x62, 0xcf, 0xdf, 0xb7, 0xe7, 0x67, 0xf5, 0xed, 0x02, 0x0d, 0x77, 0xec, + 0x44, 0xcc, 0x73, 0xe8, 0x24, 0x0a, 0x5b, 0x71, 0x12, 0xf1, 0x88, 0x94, 0x19, 0x4d, 0xce, 0x68, + 0x12, 0x0f, 0x9a, 0x3b, 0xa3, 0x28, 0x1a, 0x05, 0xf4, 0x31, 0xea, 0x07, 0xd3, 0xe1, 0x63, 0x3a, + 0x89, 0xf9, 0xb9, 0x74, 0x33, 0xbf, 0x86, 0xb2, 0xed, 0xbe, 0x72, 0x42, 0x2f, 0xa0, 0x64, 0x0b, + 0x8a, 0x13, 0xe7, 0x7d, 0x94, 0x18, 0xb9, 0xbd, 0xdc, 0xe7, 0x35, 0x4b, 0x0a, 0xa8, 0xf5, 0xc3, + 0x28, 0x31, 0xf2, 0x4a, 0x2b, 0x04, 0x73, 0x0c, 0xf5, 0xc3, 0x28, 0xe4, 0x8e, 0x1f, 0xd2, 0xc4, + 0xa2, 0x1f, 0xa6, 0x94, 0x71, 0xf2, 0x04, 0x4a, 0x8e, 0xcb, 0xfd, 0x28, 0x44, 0x80, 0xca, 0xd3, + 0x4f, 0x5b, 0x69, 0x0e, 0xad, 0x99, 0xef, 0x01, 0x3a, 0x58, 0xca, 0x91, 0x3c, 0x84, 0xaa, 0x9b, + 0x9a, 0xfa, 0xbe, 0x87, 0x7b, 0xe8, 0x56, 0x65, 0xa6, 0xeb, 0x78, 0xe6, 0x3e, 0x34, 0x32, 0x3b, + 0xb1, 0x38, 0x0a, 0x19, 0x25, 0x75, 0xd0, 0x62, 0xdf, 0x53, 0x89, 0x8a, 0xa5, 0xf9, 0x57, 0x0e, + 0xaa, 0x5d, 0xca, 0xe9, 0x24, 0xcd, 0x66, 0x1f, 0x8a, 0xa1, 0x90, 0x55, 0x32, 0x9b, 0xf3, 0x64, + 0xa4, 0x9b, 0xb4, 0xae, 0x90, 0x01, 0x79, 0x04, 0xa5, 0x31, 0x76, 0xc8, 0xd0, 0x10, 0x8a, 0xcc, + 0xa1, 0xd2, 0xde, 0x59, 0xca, 0x43, 0xf8, 0xc6, 0x4e, 0x42, 0x43, 0x6e, 0x14, 0xae, 0xf7, 0x95, + 0x1e, 0xe6, 0xdf, 0x1a, 0x14, 0x31, 0x17, 0xb2, 0x0d, 0x25, 0x8f, 0x9e, 0xf9, 0x2e, 0xc5, 0x64, + 0x75, 0x4b, 0x49, 0x84, 0x40, 0x81, 0xfb, 0x13, 0xaa, 0x5a, 0x8f, 0x6b, 0xe1, 0xfb, 0xde, 0xe7, + 0x9c, 0x26, 0x98, 0x4d, 0xcd, 0x52, 0x12, 0xb9, 0x0f, 0xe0, 0xd1, 0xc0, 0x39, 0xef, 0xbb, 0x51, + 0x92, 0xe0, 0xee, 0x79, 0x4b, 0x47, 0xcd, 0x61, 0x94, 0xe0, 0x18, 0x03, 0x7f, 0xe2, 0x73, 0xa3, + 0x28, 0xc7, 0x88, 0x82, 0xd8, 0x20, 0x88, 0x18, 0x33, 0x4a, 0xe8, 0x8e, 0x6b, 0xb2, 0x03, 0xba, + 0xf8, 0x95, 0x38, 0xeb, 0x68, 0x28, 0x0b, 0x05, 0xc2, 0xd4, 0x41, 0x1b, 0x39, 0xb1, 0x51, 0x96, + 0x8d, 0x1f, 0x39, 0x31, 0xb9, 0x07, 0xba, 0x37, 0x8d, 0x03, 0xdf, 0x75, 0x38, 0x35, 0x74, 0xb5, + 0x6d, 0xaa, 0x20, 0xfb, 0xb0, 0x31, 0x13, 0x24, 0x22, 0xa0, 0x4b, 0x6d, 0xa6, 0x45, 0x58, 0x03, + 0xd6, 0x13, 0x1a, 0x25, 0x1e, 0x4d, 0x8c, 0x0a, 0xda, 0x53, 0x51, 0xcc, 0x47, 0x2d, 0x65, 0x78, + 0x15, 0xcd, 0x15, 0xa5, 0x4b, 0x83, 0x85, 0x69, 0x1a, 0x73, 0xa3, 0x26, 0x83, 0x95, 0x28, 0x87, + 0x8b, 0x4b, 0x19, 0xbc, 0x21, 0x83, 0x95, 0x0e, 0x83, 0xe7, 0x03, 0xdb, 0xbc, 0x69, 0x60, 0x99, + 0x83, 0x50, 0xbf, 0xe9, 0x20, 0x98, 0x3d, 0x00, 0x7b, 0x30, 0x4c, 0x0f, 0xe3, 0x03, 0xd0, 0xf8, + 0x60, 0xa8, 0x8e, 0x62, 0x2d, 0x13, 0x36, 0x18, 0x5a, 0xc2, 0xb2, 0xca, 0x87, 0xf0, 0x6b, 0x0e, + 0x34, 0x7b, 0x30, 0x14, 0x33, 0x4b, 0x44, 0xaf, 0x05, 0x58, 0xc1, 0xc2, 0xf5, 0x7c, 0xba, 0xf9, + 0xec, 0x74, 0xb7, 0xa1, 0x34, 0x98, 0x0e, 0x87, 0xf3, 0xa3, 0x22, 0x25, 0x31, 0xe1, 0x98, 0x3a, + 0xa7, 0x7d, 0x84, 0x29, 0x20, 0x4c, 0x59, 0x28, 0x2c, 0x01, 0xb5, 0x03, 0xfa, 0xc4, 0x0f, 0xfb, + 0x83, 0x69, 0xc2, 0xd2, 0xc3, 0x52, 0x9e, 0xf8, 0xe1, 0x73, 0x21, 0x9b, 0x3f, 0x42, 0xf5, 0x7b, + 0xcf, 0x67, 0x6e, 0xe6, 0x23, 0xfb, 0x20, 0xe4, 0xcb, 0x1f, 0x99, 0x74, 0x93, 0xd6, 0x55, 0xaa, + 0xfb, 0x2d, 0x07, 0x45, 0x8c, 0xc9, 0x4c, 0x24, 0x77, 0x8b, 0x89, 0xe4, 0x6f, 0xfc, 0x34, 0xc5, + 0xc7, 0x74, 0x1e, 0xcb, 0x8f, 0x58, 0xb7, 0x70, 0x2d, 0x74, 0x4e, 0x32, 0x62, 0x46, 0x61, 0x4f, + 0x13, 0x3a, 0xb1, 0x36, 0xc7, 0x70, 0xa7, 0x3d, 0x71, 0xb8, 0x3b, 0x7e, 0xe1, 0x07, 0x7c, 0xce, + 0x6e, 0x2d, 0x28, 0x0d, 0x51, 0xa1, 0xd2, 0xda, 0x9e, 0x6f, 0xb5, 0xe0, 0xae, 0xbc, 0x56, 0xa9, + 0xf9, 0x17, 0xa8, 0x66, 0x43, 0x25, 0x01, 0x73, 0x77, 0xac, 0x58, 0x40, 0x0a, 0x99, 0x7e, 0xe4, + 0x6f, 0xec, 0xc7, 0x97, 0xb0, 0xee, 0x06, 0x0e, 0x63, 0xbe, 0xb7, 0x84, 0xab, 0x52, 0x17, 0xf3, + 0x67, 0xd8, 0xb4, 0xdd, 0xc5, 0x2a, 0x1f, 0x5d, 0xa8, 0x72, 0x21, 0xfe, 0xf6, 0x15, 0xe2, 0xf5, + 0xa2, 0xaa, 0xbb, 0xc5, 0x5c, 0xcd, 0x9f, 0xa0, 0xd6, 0xe9, 0x9d, 0x50, 0xce, 0xd2, 0xbc, 0x3e, + 0x83, 0x92, 0x1f, 0x33, 0xca, 0x99, 0x91, 0xdb, 0xd3, 0x16, 0x4f, 0x1a, 0x3a, 0x5a, 0xca, 0xbc, + 0x4a, 0x52, 0x4f, 0xa0, 0x88, 0x31, 0x62, 0xfa, 0xa1, 0x33, 0x49, 0x49, 0x17, 0xd7, 0x62, 0x06, + 0xae, 0xef, 0x25, 0xcc, 0xc8, 0xe3, 0x91, 0x90, 0x82, 0xe9, 0xc2, 0xdd, 0x4e, 0xcc, 0x9d, 0x41, + 0x40, 0xd9, 0xe1, 0xd8, 0xf1, 0xc3, 0x6c, 0x5e, 0x2e, 0x2a, 0x2e, 0xe7, 0x85, 0x8e, 0x96, 0x32, + 0xaf, 0x92, 0xd7, 0xef, 0x79, 0x28, 0x62, 0xd0, 0x95, 0x89, 0x3d, 0x03, 0xdd, 0xf3, 0x13, 0x2a, + 0x2f, 0x58, 0x11, 0xbd, 0xb1, 0x70, 0xc1, 0x8a, 0xb8, 0xd6, 0x51, 0xea, 0x60, 0xcd, 0x7d, 0x05, + 0x0b, 0xa8, 0xd6, 0x69, 0x58, 0x52, 0xda, 0xa9, 0x6d, 0x28, 0x71, 0x27, 0x19, 0x51, 0x79, 0x55, + 0xe9, 0x96, 0x92, 0x48, 0x13, 0xca, 0xf8, 0x36, 0x70, 0xa3, 0x00, 0xbf, 0x7f, 0xdd, 0x9a, 0xc9, + 0xa2, 0x0a, 0x16, 0x4d, 0x13, 0x97, 0xf6, 0xe3, 0x28, 0xe1, 0xf2, 0xde, 0xd0, 0xad, 0x8a, 0xd4, + 0xf5, 0x84, 0x8a, 0x7c, 0x01, 0x0d, 0x8f, 0x32, 0xee, 0x87, 0x8e, 0xd8, 0x5d, 0xf9, 0xad, 0xa3, + 0x5f, 0x3d, 0x63, 0x40, 0x67, 0xd3, 0x04, 0x7d, 0x96, 0x33, 0xd1, 0xa1, 0xd8, 0xe9, 0xf6, 0xde, + 0xd9, 0xf5, 0x35, 0x02, 0x50, 0x3a, 0x7e, 0x67, 0x8b, 0x75, 0xce, 0xfc, 0x08, 0x15, 0xdb, 0x9f, + 0xd0, 0xb4, 0xe3, 0x17, 0x1b, 0x99, 0xbb, 0x7c, 0x61, 0xd7, 0x41, 0x63, 0xd4, 0xc5, 0x26, 0x69, + 0x96, 0x58, 0x62, 0x43, 0x85, 0x4a, 0x43, 0x15, 0xae, 0xc9, 0x1e, 0x54, 0xdd, 0xe0, 0xb4, 0xef, + 0x7b, 0xac, 0x3f, 0x71, 0xd8, 0xa9, 0x22, 0x42, 0x70, 0x83, 0xd3, 0x8e, 0xc7, 0xde, 0x3a, 0xec, + 0xd4, 0x3c, 0x85, 0xcd, 0x0b, 0x0f, 0x17, 0xf2, 0xcd, 0xc2, 0x1b, 0x67, 0xe3, 0xe9, 0xde, 0xb5, + 0x6f, 0x9c, 0xd6, 0xe2, 0x53, 0xc7, 0xdc, 0x85, 0x92, 0xc2, 0x28, 0x43, 0xe1, 0x75, 0xe7, 0xcd, + 0x1b, 0x59, 0xe6, 0xcb, 0xb6, 0xdd, 0xeb, 0x1c, 0xd5, 0x73, 0xe6, 0x1f, 0x39, 0x68, 0xb4, 0x3f, + 0x52, 0xf7, 0x84, 0x27, 0x94, 0xcd, 0xce, 0xd7, 0x33, 0x28, 0x32, 0x37, 0x8a, 0xa9, 0xda, 0xee, + 0x61, 0x86, 0x74, 0x2e, 0xfa, 0xb6, 0x4e, 0x84, 0xa3, 0x25, 0xfd, 0x33, 0xd3, 0xcd, 0x2f, 0x4c, + 0xf7, 0x1e, 0xe8, 0x0c, 0xa3, 0xa2, 0x84, 0x29, 0x2a, 0x9c, 0x2b, 0xcc, 0x07, 0x50, 0x44, 0x14, + 0x52, 0x03, 0xfd, 0xf0, 0xb8, 0x6b, 0x1f, 0x74, 0xba, 0x6d, 0xab, 0xbe, 0x46, 0xd6, 0x41, 0xeb, + 0x1d, 0x8b, 0x2c, 0xbb, 0x40, 0xb2, 0x1b, 0xab, 0xe7, 0x58, 0x13, 0xca, 0x7e, 0xc8, 0xb8, 0x13, + 0xce, 0x5e, 0x30, 0x33, 0x59, 0x6e, 0xe8, 0x24, 0xdc, 0x4e, 0x1f, 0x32, 0x9a, 0x35, 0x57, 0x98, + 0xc7, 0x70, 0xe7, 0x50, 0xb8, 0x05, 0x8b, 0x65, 0xff, 0x77, 0xc0, 0x3f, 0x73, 0x70, 0xe7, 0x20, + 0x8e, 0x83, 0xf3, 0x4e, 0x74, 0x28, 0x1e, 0xc5, 0x29, 0xa2, 0x01, 0xeb, 0x72, 0x10, 0x4c, 0x01, + 0xa6, 0xa2, 0xe8, 0xd4, 0x59, 0x14, 0x4c, 0x15, 0x98, 0x6e, 0x29, 0xe9, 0xd2, 0x41, 0xd3, 0x2e, + 0x1f, 0xb4, 0x6c, 0x9a, 0x05, 0xcc, 0xe4, 0x9a, 0x34, 0x8b, 0x17, 0xd3, 0xec, 0xc1, 0xd6, 0x62, + 0x96, 0xd7, 0x74, 0x52, 0xbb, 0x45, 0x27, 0xc1, 0x76, 0x67, 0xe5, 0xee, 0x82, 0xc6, 0xdd, 0x94, + 0x94, 0xaa, 0x59, 0xa6, 0xb5, 0x84, 0x61, 0xa5, 0x1b, 0x39, 0x0f, 0x79, 0xdb, 0x25, 0xfb, 0xea, + 0xda, 0x94, 0x07, 0xb0, 0x91, 0x85, 0x6a, 0xd9, 0xe7, 0x31, 0x55, 0x37, 0xe9, 0xec, 0xb9, 0x9d, + 0x5f, 0xfa, 0xdc, 0x56, 0x0f, 0x21, 0xed, 0xda, 0x87, 0xd0, 0x16, 0x14, 0x91, 0x9f, 0x14, 0x29, + 0x49, 0x61, 0x29, 0x27, 0xed, 0x02, 0xcc, 0xf9, 0x47, 0x31, 0x52, 0x46, 0x23, 0xec, 0x74, 0x24, + 0x0e, 0x17, 0xda, 0x25, 0x13, 0x65, 0x34, 0xe6, 0x1e, 0x14, 0x44, 0x1d, 0x82, 0x7e, 0xba, 0x6d, + 0xbb, 0xfd, 0xb6, 0xbe, 0x26, 0x4e, 0xff, 0xf3, 0x83, 0xee, 0xd1, 0x0f, 0x9d, 0x23, 0xfb, 0x55, + 0x3d, 0xf7, 0xf4, 0x9f, 0x22, 0x54, 0x70, 0x4c, 0x47, 0xf8, 0x0f, 0x4b, 0x90, 0xc0, 0x09, 0xe5, + 0xb6, 0xcb, 0xc8, 0x56, 0xb6, 0x1d, 0x69, 0xf3, 0x9b, 0xdb, 0x2d, 0xf9, 0x97, 0xab, 0x95, 0xfe, + 0xe5, 0x6a, 0xb5, 0xc5, 0x5f, 0x2e, 0x73, 0x8d, 0x7c, 0x0b, 0x95, 0x17, 0xc1, 0x94, 0x8d, 0xe5, + 0xe5, 0x46, 0x3e, 0xb9, 0x70, 0x8b, 0xad, 0x80, 0xd0, 0x85, 0xc6, 0x09, 0xe5, 0x8b, 0x97, 0x11, + 0x79, 0x90, 0xc1, 0xb9, 0xea, 0x9a, 0x5a, 0x9a, 0x51, 0x4d, 0xd4, 0xe2, 0x4f, 0xe8, 0xf1, 0x70, + 0x28, 0x5a, 0x7d, 0x37, 0x53, 0xd2, 0x9c, 0x76, 0x97, 0x20, 0x1c, 0x41, 0xc3, 0xa2, 0x6e, 0x74, + 0x46, 0x93, 0xff, 0x83, 0xd2, 0x86, 0xda, 0x8c, 0x40, 0x5f, 0xfb, 0x41, 0x40, 0x9a, 0x57, 0x30, + 0xeb, 0xcd, 0x30, 0x6f, 0x32, 0x94, 0xfd, 0x92, 0xf2, 0x9e, 0xef, 0x2d, 0x05, 0xda, 0xb9, 0xd2, + 0x26, 0xbf, 0x45, 0x44, 0xab, 0xcd, 0xd9, 0x2e, 0x4a, 0x18, 0xd9, 0x59, 0xc2, 0xbf, 0xcd, 0x7b, + 0x57, 0x1b, 0x67, 0x68, 0xdf, 0xc1, 0x66, 0x96, 0xeb, 0x04, 0xde, 0xfd, 0xcc, 0xfe, 0x97, 0x69, + 0x70, 0x49, 0x9d, 0xc7, 0x50, 0xcd, 0xf2, 0x47, 0x16, 0xe8, 0x0a, 0xf6, 0x6b, 0xee, 0x5e, 0x67, + 0x4e, 0x93, 0x1b, 0x94, 0x70, 0x8b, 0xaf, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x36, 0x34, 0xe6, + 0xce, 0x4b, 0x10, 0x00, 0x00, } diff --git a/pkg/server/serverpb/chaosdaemon.proto b/pkg/server/serverpb/chaosdaemon.proto index 32bd43f..095b8c8 100644 --- a/pkg/server/serverpb/chaosdaemon.proto +++ b/pkg/server/serverpb/chaosdaemon.proto @@ -45,21 +45,22 @@ message NetemRequest { } message Netem { - uint32 time = 1; - uint32 jitter = 2; - float delay_corr = 3; - uint32 limit = 4; - float loss = 5; - float loss_corr = 6; - uint32 gap = 7; - float duplicate = 8; - float duplicate_corr = 9; - float reorder = 10; - float reorder_corr = 11; - float corrupt = 12; - float corrupt_corr = 13; - TcHandle parent = 14; - TcHandle handle = 15; + string device = 1; + uint32 time = 2; + uint32 jitter = 3; + float delay_corr = 4; + uint32 limit = 5; + float loss = 6; + float loss_corr = 7; + uint32 gap = 8; + float duplicate = 9; + float duplicate_corr = 10; + float reorder = 11; + float reorder_corr = 12; + float corrupt = 13; + float corrupt_corr = 14; + TcHandle parent = 15; + TcHandle handle = 16; } message TbfRequest { @@ -131,6 +132,9 @@ message Chain { Direction direction = 2; repeated string ipsets = 3; string target = 4; + string protocol = 5; + string source_ports = 6; + string destination_ports = 7; } message TimeRequest { @@ -196,4 +200,7 @@ message Tc { Netem netem = 2; Tbf tbf = 3; string ipset = 4; + string protocol = 5; + string sourcePort = 6; + string egressPort = 7; } \ No newline at end of file diff --git a/pkg/utils/check.go b/pkg/utils/check.go index 0cdca38..ee946a5 100644 --- a/pkg/utils/check.go +++ b/pkg/utils/check.go @@ -30,7 +30,7 @@ func CheckPorts(p string) bool { return false } - ps := strings.Split(p, "-") + ps := strings.Split(p, ":") if len(ps) == 0 { if _, err := strconv.Atoi(p); err != nil { return false @@ -72,12 +72,9 @@ func CheckIPProtocols(p string) bool { return true } - pros := strings.Split(p, ",") - for _, protocol := range pros { - if protocol != "TCP" || protocol != "UDP" || protocol != "ICMP" { - return false - } + if p == "tcp" || p == "udp" || p == "icmp" || p == "all" { + return true } - return true + return false } diff --git a/pkg/utils/cidr.go b/pkg/utils/cidr.go new file mode 100644 index 0000000..8363661 --- /dev/null +++ b/pkg/utils/cidr.go @@ -0,0 +1,69 @@ +// Copyright 2020 Chaos Mesh Authors. +// +// 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, +// See the License for the specific language governing permissions and +// limitations under the License. + +package utils + +import ( + "net" + "strings" +) + +// IPToCidr converts from an ip to a full mask cidr +func IPToCidr(ip string) string { + // TODO: support IPv6 + return ip + "/32" +} + +// ResolveCidrs converts multiple cidrs/ips/domains into cidr +func ResolveCidrs(names []string) ([]string, error) { + cidrs := []string{} + for _, target := range names { + // TODO: resolve ip on every pods but not in controller, in case the dns server of these pods differ + cidr, err := ResolveCidr(target) + if err != nil { + return nil, err + } + + cidrs = append(cidrs, cidr...) + } + + return cidrs, nil +} + +// ResolveCidr converts cidr/ip/domain into cidr +func ResolveCidr(name string) ([]string, error) { + _, ipnet, err := net.ParseCIDR(name) + if err == nil { + return []string{ipnet.String()}, nil + } + + if net.ParseIP(name) != nil { + return []string{IPToCidr(name)}, nil + } + + addrs, err := net.LookupIP(name) + if err != nil { + return nil, err + } + + cidrs := []string{} + for _, addr := range addrs { + addr := addr.String() + + // TODO: support IPv6 + if strings.Contains(addr, ".") { + cidrs = append(cidrs, IPToCidr(addr)) + } + } + return cidrs, nil +} diff --git a/pkg/utils/string.go b/pkg/utils/string.go new file mode 100644 index 0000000..d0e31c8 --- /dev/null +++ b/pkg/utils/string.go @@ -0,0 +1,26 @@ +// Copyright 2020 Chaos Mesh Authors. +// +// 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, +// See the License for the specific language governing permissions and +// limitations under the License. + +package utils + +func RemoveDuplicateElement(languages []string) []string { + result := make([]string, 0, len(languages)) + temp := map[string]struct{}{} + for _, item := range languages { + if _, ok := temp[item]; !ok { + temp[item] = struct{}{} + result = append(result, item) + } + } + return result +}