cli

var BaseTcpCommand = &CommandProducer{
	Base: &cobra.Command{
		Use:   "tcp",
		Short: "Measures tcp-related timings and outliers",
	},
	TimeVisitor: func(ctx *VisitorContext, cmd *cobra.Command, commonOpts *skbtrace.TimeCommonOptions) {
		var opts tcpOptions
		RegisterInterfaceOptions(ctx, cmd, &opts.filterOpts)
		registerTcpOptions(cmd.PersistentFlags(), &opts)

		ctx.AddPreRun(cmd, func(cmd *cobra.Command, args []string) error {
			var extraKeys []string
			if cmd.Use == "retransmit" {
				extraKeys = tcpExtraKeysRetransmit
			}
			return buildTcpTimeOptions(&opts, commonOpts, extraKeys)
		})
	},
	Children: []*CommandProducer{
		TcpHandshakeCommand,
		TcpLifetimeCommand,
		TcpRetransmitsCommand,
	},
}

var CommonAggregateCommand = &CommandProducer{
	Base: &cobra.Command{
		Use:     "aggregate -P PROBE... -f FUNC [-a ARG] -k KEYS [INTERVAL]",
		Example: "aggregate -6 -P xmit -i eth1 -F 'inner-src == 2a02:6b8:...' -k outer-dst 2s",
		Short:   "Aggregates probe firings by specified set of keys",
		Aliases: []string{"aggr"},
		Args:    cobra.RangeArgs(0, 1),
	},

	TracerVisitor: &AggregateTracerCommand{
		Visitor: func(ctx *VisitorContext, cmd *cobra.Command, opts *skbtrace.TraceAggregateOptions) {
			flags := cmd.Flags()
			RegisterAggregateOptions(flags, opts)
			RegisterAggregateCommonOptions(flags, &opts.AggregateCommonOptions)
			RegisterTimeIntervalArg(ctx, cmd, &opts.Interval)
		},
	},
}

var CommonDumpTracerCommand = &CommandProducer{
	Base: &cobra.Command{
		Use:     "dump -P PROBE...",
		Example: "dump -6 -P free -F 'dst == 2a02:6b8:...' -K -o ipv6",
		Short:   "Prints requested rows each time probe is fired",
	},
	TracerVisitor: &DumpTracerCommand{
		Visitor: func(ctx *VisitorContext, cmd *cobra.Command, opts *skbtrace.TraceDumpOptions) {
			RegisterCommonDumpOptions(cmd.Flags(), &opts.CommonDumpOptions)
		},
	},
}

var CommonDuplicateCommand = &CommandProducer{
	Base: &cobra.Command{
		Use:     "duplicate",
		Short:   "Dumps objects when hit twice with the same set of keys",
		Aliases: []string{"dup"},
	},
	CommonVisitor: func(ctx *VisitorContext, cmd *cobra.Command, commonOpts *skbtrace.CommonOptions) {
		var opts skbtrace.DuplicateEventOptions
		PassCommonOptions(ctx, cmd, &opts.CommonOptions, commonOpts)

		flags := cmd.Flags()
		RegisterCommonDumpOptions(flags, &opts.CommonDumpOptions)
		flags.BoolVar(&opts.Exit, "exit", false,
			"exit after dumping first outlier.")

		cmd.Run = NewRun(ctx, func() (*skbtrace.Program, error) {
			return ctx.Builder.BuildDuplicateEvent(opts)
		})
	},
}

var CommonTimeItFromCommand = &CommandProducer{
	Base: &cobra.Command{
		Use:   "timeit",
		Short: "Measures time delta between two distinct events 'from' and 'to'",
	},
	TimeVisitor: func(ctx *VisitorContext, cmd *cobra.Command, opts *skbtrace.TimeCommonOptions) {

	},
	Children: []*CommandProducer{
		timeItFromCommand,
		ForwardCommand,
		BaseTcpCommand,
	},
}

var DefaultTimeSubcommands = []*CommandProducer{
	TimeAggregateCommand,
	TimeOutlierDumpSubcommand,
	TimeEventCountSubcommand,
}

var FieldsCommand = &CommandProducer{
	Base: &cobra.Command{
		Use:   "fields [ROW]",
		Short: "Shows list of known fields",
	},

	InfoVisitor: func(ctx *VisitorContext, cmd *cobra.Command) {
		cmd.Run = func(cmd *cobra.Command, args []string) {
			fieldGroups := ctx.Builder.FieldGroups()

			tw := tablewriter.NewWriter(ctx.Dependencies.Output())
			tw.SetHeader([]string{"ROW", "OBJECT", "FIELD", "KEY", "HELP"})
			tw.SetAutoMergeCells(true)
			tw.SetColWidth(80)
			tw.SetColMinWidth(4, 60)
			tw.SetRowLine(true)
			for _, fg := range fieldGroups {
				if fg.BaseFieldGroup != "" {
					help := fmt.Sprintf("Same fields as in %s (%s)", fg.Row, fg.Object)
					if fg.FieldAliasPrefix != "" {
						help = fmt.Sprintf("%s. Field aliases use prefix %s-*",
							help, fg.FieldAliasPrefix)
					}

					row := []string{
						fg.Row, fg.Object, "", "", help,
					}
					tw.Append(row)
					continue
				}

				for _, field := range fg.Fields {
					fieldName := field.Name
					if field.Alias != "" {
						fieldName = fmt.Sprintf("%s (%s)", field.Alias, fieldName)
					}

					row := []string{
						fg.Row, fg.Object, fieldName, field.FmtKey, field.Help,
					}
					tw.Append(row)
				}
			}
			tw.Render()
		}
	},
}

var ForwardCommand = &CommandProducer{
	Base: &cobra.Command{
		Use:     "forward {{--ingress|--egress} -i ITF|-i INITF -i OUTITF} [OPTIONS]",
		Example: "forward --ingress -i tapxx-0 -6",
		Short:   "Measures time spent forwarding a packet from ingress interface to egress interface",
	},
	TimeVisitor: func(ctx *VisitorContext, cmd *cobra.Command, opts *skbtrace.TimeCommonOptions) {
		var fwdOpts forwardOptions
		registerForwardOptions(cmd.PersistentFlags(), &fwdOpts)

		ctx.AddPreRun(cmd, func(cmd *cobra.Command, args []string) error {
			err := handleForwardFiltersInterface(ctx, &opts.FromSpec, skb.ProbeRecv,
				&opts.CommonOptions, &fwdOpts)
			if err != nil {
				return err
			}
			return handleForwardFiltersInterface(ctx, &opts.ToSpec, skb.ProbeXmit,
				&opts.CommonOptions, &fwdOpts)
		})

		cmd.Run = NewDefaultAggregateRun(ctx, opts)
	},
	Children: DefaultTimeSubcommands,
}

var ProbesCommand = &CommandProducer{
	Base: &cobra.Command{
		Use:   "probes",
		Short: "Shows list of known probes",
	},

	InfoVisitor: func(ctx *VisitorContext, cmd *cobra.Command) {
		cmd.Run = func(cmd *cobra.Command, args []string) {
			probes := ctx.Builder.Probes()

			tw := tablewriter.NewWriter(ctx.Dependencies.Output())
			tw.SetHeader([]string{"PROBE", "ARGS", "HELP"})
			tw.SetColWidth(80)
			tw.SetColMinWidth(2, 60)
			for _, probe := range probes {
				row := make([]string, 3)

				if len(probe.Aliases) == 0 {
					row[0] = probe.Name
				} else {
					row[0] = fmt.Sprintf("%s (%s)", probe.Aliases[0],
						strings.Join(append(probe.Aliases[1:], probe.Name), ", "))
				}

				var argNames []string
				for arg, obj := range probe.Args {
					argNames = append(argNames, fmt.Sprintf("%s(%s)", arg, obj))
				}
				row[1] = strings.Join(argNames, ", ")

				row[2] = probe.Help
				tw.Append(row)
			}
			tw.Render()
		}
	},
}

var RootCommand = CommandProducer{
	Base: &cobra.Command{
		Use:   "skbtrace",
		Short: rootShortHelp,
		Long:  rootHelp,
	},
	Children: []*CommandProducer{
		CommonDumpTracerCommand,
		CommonAggregateCommand,
		CommonTimeItFromCommand,
		CommonDuplicateCommand,
		ProbesCommand,
		FieldsCommand,
	},
}

var TcpHandshakeCommand = &CommandProducer{
	Base: &cobra.Command{
		Use:     "handshake {--inbound|--outbound} [--underlay] -i ITF",
		Example: "handshake --inbound -i tapxx-0 -6",
		Short:   "Measures time for TCP handshake",
	},
	TimeVisitor: func(ctx *VisitorContext, cmd *cobra.Command, opts *skbtrace.TimeCommonOptions) {
		ctx.AddPreRun(cmd, func(cmd *cobra.Command, args []string) error {
			opts.FromSpec.RawFilters = append(opts.FromSpec.RawFilters, "tcp-flags == S")
			opts.ToSpec.RawFilters = append(opts.ToSpec.RawFilters, "tcp-flags == A")
			return nil
		})
		cmd.Run = NewDefaultAggregateRun(ctx, opts)
	},
	Children: DefaultTimeSubcommands,
}

var TcpLifetimeCommand = &CommandProducer{
	Base: &cobra.Command{
		Use:   "lifetime {--inbound|--outbound}",
		Short: "Measures TCP connection lifetime from SYN to FIN/RST in the same direction",
	},
	TimeVisitor: func(ctx *VisitorContext, cmd *cobra.Command, opts *skbtrace.TimeCommonOptions) {
		ctx.AddPreRun(cmd, func(cmd *cobra.Command, args []string) error {
			opts.FromSpec.RawFilters = append(opts.FromSpec.RawFilters, "tcp-flags == S")
			opts.ToSpec.RawFilters = append(opts.ToSpec.RawFilters, "tcp-flags == F|FA|R")
			return nil
		})

		cmd.Run = NewDefaultAggregateRun(ctx, opts)
	},
	Children: DefaultTimeSubcommands,
}

var TcpRetransmitsCommand = &CommandProducer{
	Base: &cobra.Command{
		Use:   "retransmit",
		Short: "Detects duplicate packets",
	},
	TimeVisitor: func(ctx *VisitorContext, cmd *cobra.Command, commonOpts *skbtrace.TimeCommonOptions) {
		var opts skbtrace.DuplicateEventOptions
		RegisterCommonDumpOptions(cmd.Flags(), &opts.CommonDumpOptions)

		ctx.AddPreRun(cmd, func(cmd *cobra.Command, args []string) error {
			opts.CommonOptions = commonOpts.CommonOptions
			opts.Spec = commonOpts.FromSpec
			opts.Spec.Keys = append(opts.Spec.Keys, tcpExtraKeysRetransmit...)
			return nil
		})

		cmd.Run = NewRun(ctx, func() (*skbtrace.Program, error) {
			return ctx.Builder.BuildDuplicateEvent(opts)
		})
	},
}

var TimeAggregateCommand = &CommandProducer{
	Base: &cobra.Command{
		Use:     "aggregate [-f FUNC] [INTERVAL]",
		Aliases: []string{"aggr"},
		Short:   "Aggregates time delta using specified function",
		Args:    cobra.RangeArgs(0, 1),
	},
	TimeVisitor: func(ctx *VisitorContext, cmd *cobra.Command, commonOpts *skbtrace.TimeCommonOptions) {
		opts := skbtrace.TimeAggregateOptions{
			AggregateCommonOptions: skbtrace.AggregateCommonOptions{
				Interval: time.Second,
			},
			Func: skbtrace.AFHist,
		}

		flags := cmd.Flags()
		RegisterTimeIntervalArg(ctx, cmd, &opts.Interval)
		RegisterAggregateCommonOptions(flags, &opts.AggregateCommonOptions)
		PassTimeCommonOptions(ctx, cmd, &opts.TimeCommonOptions, commonOpts)

		cmd.Run = NewRun(ctx, func() (*skbtrace.Program, error) {
			return ctx.Builder.BuildTimeAggregate(opts)
		})
	},
}

var TimeEventCountSubcommand = &CommandProducer{
	Base: &cobra.Command{
		Use:   "evcount",
		Short: "Counts each time from or to probe is hit. Useful for testing filters.",
	},
	TimeVisitor: func(ctx *VisitorContext, cmd *cobra.Command, commonOpts *skbtrace.TimeCommonOptions) {
		cmd.Run = NewRun(ctx, func() (*skbtrace.Program, error) {
			return ctx.Builder.BuildTimeEventCount(*commonOpts)
		})
	},
}

var TimeOutlierDumpSubcommand = &CommandProducer{
	Base: &cobra.Command{
		Use:   "outliers -t THRESHOLD",
		Short: "Dumps structures that exceed specified threshold",
	},
	TimeVisitor: func(ctx *VisitorContext, cmd *cobra.Command, commonOpts *skbtrace.TimeCommonOptions) {
		var opts skbtrace.TimeOutlierDumpOptions
		PassTimeCommonOptions(ctx, cmd, &opts.TimeCommonOptions, commonOpts)

		flags := cmd.Flags()
		RegisterCommonDumpOptions(flags, &opts.CommonDumpOptions)
		flags.DurationVarP(&opts.OutlierThreshold, "threshold", "t",
			100*time.Millisecond,
			"Threshold for time delta. If hit, probe firing is considered an outlier.")
		flags.BoolVar(&opts.Exit, "exit", false,
			"Exit after dumping first outlier.")

		cmd.Run = NewRun(ctx, func() (*skbtrace.Program, error) {
			return ctx.Builder.BuildTimeOutlierDump(opts)
		})
	},
}