From e803a7f870ea530afaaf0e3c7917d26dcb2ecc4f Mon Sep 17 00:00:00 2001 From: "James O. D. Hunt" Date: Mon, 15 Apr 2019 09:44:57 +0100 Subject: [PATCH 1/7] agent: Return an error, not just an interface Make `newAgentConfig()` return an explicit error rather than handling the error scenario by simply returning the `error` object in the `interface{}` return type. The old behaviour was confusing and inconsistent with the other functions creating a new config type (shim, proxy, etc). Signed-off-by: James O. D. Hunt --- virtcontainers/agent.go | 10 +++++----- virtcontainers/agent_test.go | 7 ++++++- virtcontainers/sandbox.go | 6 +++++- 3 files changed, 16 insertions(+), 7 deletions(-) diff --git a/virtcontainers/agent.go b/virtcontainers/agent.go index 56721bf9a7..fb24cfa4b5 100644 --- a/virtcontainers/agent.go +++ b/virtcontainers/agent.go @@ -91,19 +91,19 @@ func newAgent(agentType AgentType) agent { } // newAgentConfig returns an agent config from a generic SandboxConfig interface. -func newAgentConfig(agentType AgentType, agentConfig interface{}) interface{} { +func newAgentConfig(agentType AgentType, agentConfig interface{}) (interface{}, error) { switch agentType { case NoopAgentType: - return nil + return nil, nil case KataContainersAgent: var kataAgentConfig KataAgentConfig err := mapstructure.Decode(agentConfig, &kataAgentConfig) if err != nil { - return err + return nil, err } - return kataAgentConfig + return kataAgentConfig, nil default: - return nil + return nil, nil } } diff --git a/virtcontainers/agent_test.go b/virtcontainers/agent_test.go index 4706bdaf4d..21840df61e 100644 --- a/virtcontainers/agent_test.go +++ b/virtcontainers/agent_test.go @@ -86,7 +86,12 @@ func TestNewAgentFromUnknownAgentType(t *testing.T) { } func testNewAgentConfig(t *testing.T, config SandboxConfig, expected interface{}) { - agentConfig := newAgentConfig(config.AgentType, config.AgentConfig) + agentConfig, err := newAgentConfig(config.AgentType, config.AgentConfig) + if err != nil { + t.Fatal(err) + + } + if reflect.DeepEqual(agentConfig, expected) == false { t.Fatal() } diff --git a/virtcontainers/sandbox.go b/virtcontainers/sandbox.go index 8d3046d46f..5ca4395422 100644 --- a/virtcontainers/sandbox.go +++ b/virtcontainers/sandbox.go @@ -583,7 +583,11 @@ func newSandbox(ctx context.Context, sandboxConfig SandboxConfig, factory Factor return nil, err } - agentConfig := newAgentConfig(sandboxConfig.AgentType, sandboxConfig.AgentConfig) + agentConfig, err := newAgentConfig(sandboxConfig.AgentType, sandboxConfig.AgentConfig) + if err != nil { + return nil, err + } + if err = s.agent.init(ctx, s, agentConfig); err != nil { return nil, err } From 97beb2b2d4862b41c879ba620deb312c74a7d5ce Mon Sep 17 00:00:00 2001 From: "James O. D. Hunt" Date: Mon, 15 Apr 2019 09:28:35 +0100 Subject: [PATCH 2/7] errors: Create a new standard error for invalid config Refactor a common error into a new standard error object. Signed-off-by: James O. D. Hunt --- virtcontainers/kata_agent.go | 6 +++--- virtcontainers/pkg/types/errors.go | 11 ++++++----- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/virtcontainers/kata_agent.go b/virtcontainers/kata_agent.go index e5f2844be2..80aa151cc1 100644 --- a/virtcontainers/kata_agent.go +++ b/virtcontainers/kata_agent.go @@ -189,7 +189,7 @@ func (k *kataAgent) init(ctx context.Context, sandbox *Sandbox, config interface } k.keepConn = c.LongLiveConn default: - return fmt.Errorf("Invalid config type") + return vcTypes.ErrInvalidConfigType } k.proxy, err = newProxy(sandbox.config.ProxyType) @@ -241,7 +241,7 @@ func (k *kataAgent) internalConfigure(h hypervisor, id, sharePath string, builti } k.keepConn = c.LongLiveConn default: - return fmt.Errorf("Invalid config type") + return vcTypes.ErrInvalidConfigType } } @@ -275,7 +275,7 @@ func (k *kataAgent) configure(h hypervisor, id, sharePath string, builtin bool, } k.vmSocket = s default: - return fmt.Errorf("Invalid config type") + return vcTypes.ErrInvalidConfigType } // Neither create shared directory nor add 9p device if hypervisor diff --git a/virtcontainers/pkg/types/errors.go b/virtcontainers/pkg/types/errors.go index 2140227080..097ee231b2 100644 --- a/virtcontainers/pkg/types/errors.go +++ b/virtcontainers/pkg/types/errors.go @@ -11,9 +11,10 @@ import ( // common error objects used for argument checking var ( - ErrNeedSandbox = errors.New("Sandbox must be specified") - ErrNeedSandboxID = errors.New("Sandbox ID cannot be empty") - ErrNeedContainerID = errors.New("Container ID cannot be empty") - ErrNeedState = errors.New("State cannot be empty") - ErrNoSuchContainer = errors.New("Container does not exist") + ErrNeedSandbox = errors.New("Sandbox must be specified") + ErrNeedSandboxID = errors.New("Sandbox ID cannot be empty") + ErrNeedContainerID = errors.New("Container ID cannot be empty") + ErrNeedState = errors.New("State cannot be empty") + ErrNoSuchContainer = errors.New("Container does not exist") + ErrInvalidConfigType = errors.New("Invalid config type") ) From ed248cef3b7774f6bd2e6f5647c4b25f815c1082 Mon Sep 17 00:00:00 2001 From: "James O. D. Hunt" Date: Fri, 22 Mar 2019 13:47:39 +0000 Subject: [PATCH 3/7] shim: Removed unused type and correct error message Removed the unused `KataShimConfig` type and updated an error message that incorrectly mentioned it. Signed-off-by: James O. D. Hunt --- virtcontainers/kata_shim.go | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/virtcontainers/kata_shim.go b/virtcontainers/kata_shim.go index cb1cd8e2d1..3cd7ceeab5 100644 --- a/virtcontainers/kata_shim.go +++ b/virtcontainers/kata_shim.go @@ -11,13 +11,6 @@ import ( type kataShim struct{} -// KataShimConfig is the structure providing specific configuration -// for kataShim implementation. -type KataShimConfig struct { - Path string - Debug bool -} - // start is the ccShim start implementation. // It starts the cc-shim binary with URL and token flags provided by // the proxy. @@ -28,7 +21,7 @@ func (s *kataShim) start(sandbox *Sandbox, params ShimParams) (int, error) { config, ok := newShimConfig(*(sandbox.config)).(ShimConfig) if !ok { - return -1, fmt.Errorf("Wrong shim config type, should be KataShimConfig type") + return -1, fmt.Errorf("Wrong shim config type, should be ShimConfig type") } if config.Path == "" { From 87d91710b9a00b75ce70038af82b69695aae08d5 Mon Sep 17 00:00:00 2001 From: "James O. D. Hunt" Date: Mon, 15 Apr 2019 10:39:11 +0100 Subject: [PATCH 4/7] utils: Remove code duplication Replace the two versions of `makeRuntimeConfigFileData()` with a single `MakeRuntimeConfigFileData()` in a new `katatestutils` package and a new `katautils.GetDefaultHypervisorConfig()` to query the default hypervisor details. This isn't ideal but a new package had to be created to avoid circular dependencies. It was also required since test code cannot be exported from a package. Signed-off-by: James O. D. Hunt --- cli/kata-env_test.go | 99 ++++++++++++------------------------ pkg/katatestutils/utils.go | 87 +++++++++++++++++++++++++++++++ pkg/katautils/config.go | 13 +++-- pkg/katautils/config_test.go | 74 ++++++++++++--------------- 4 files changed, 160 insertions(+), 113 deletions(-) create mode 100644 pkg/katatestutils/utils.go diff --git a/cli/kata-env_test.go b/cli/kata-env_test.go index 7ee8d2e8fb..3bb1b589c7 100644 --- a/cli/kata-env_test.go +++ b/cli/kata-env_test.go @@ -24,8 +24,7 @@ import ( specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/urfave/cli" - "strconv" - + "github.com/kata-containers/runtime/pkg/katatestutils" "github.com/kata-containers/runtime/pkg/katautils" "github.com/kata-containers/runtime/virtcontainers/pkg/oci" "github.com/stretchr/testify/assert" @@ -36,12 +35,6 @@ const testShimVersion = "shim version 0.1" const testNetmonVersion = "netmon version 0.1" const testHypervisorVersion = "QEMU emulator version 2.7.0+git.741f430a96-6.1, Copyright (c) 2003-2016 Fabrice Bellard and the QEMU Project developers" -const defaultVCPUCount uint32 = 1 -const defaultMaxVCPUCount uint32 = 0 -const defaultMemSize uint32 = 2048 // MiB -const defaultMsize9p uint32 = 8192 -const defaultGuestHookPath string = "" - var ( hypervisorDebug = false proxyDebug = false @@ -81,47 +74,6 @@ func createConfig(configPath string, fileData string) error { return nil } -func makeRuntimeConfigFileData(hypervisor, hypervisorPath, kernelPath, imagePath, kernelParams, machineType, shimPath, proxyPath, netmonPath, logPath string, disableBlock bool, blockDeviceDriver string, enableIOThreads bool, hotplugVFIOOnRootBus, disableNewNetNs bool) string { - return ` - # Runtime configuration file - - [hypervisor.` + hypervisor + `] - path = "` + hypervisorPath + `" - kernel = "` + kernelPath + `" - block_device_driver = "` + blockDeviceDriver + `" - kernel_params = "` + kernelParams + `" - image = "` + imagePath + `" - machine_type = "` + machineType + `" - default_vcpus = ` + strconv.FormatUint(uint64(defaultVCPUCount), 10) + ` - default_maxvcpus = ` + strconv.FormatUint(uint64(defaultMaxVCPUCount), 10) + ` - default_memory = ` + strconv.FormatUint(uint64(defaultMemSize), 10) + ` - disable_block_device_use = ` + strconv.FormatBool(disableBlock) + ` - enable_iothreads = ` + strconv.FormatBool(enableIOThreads) + ` - hotplug_vfio_on_root_bus = ` + strconv.FormatBool(hotplugVFIOOnRootBus) + ` - msize_9p = ` + strconv.FormatUint(uint64(defaultMsize9p), 10) + ` - enable_debug = ` + strconv.FormatBool(hypervisorDebug) + ` - guest_hook_path = "` + defaultGuestHookPath + `" - - [proxy.kata] - enable_debug = ` + strconv.FormatBool(proxyDebug) + ` - path = "` + proxyPath + `" - - [shim.kata] - path = "` + shimPath + `" - enable_debug = ` + strconv.FormatBool(shimDebug) + ` - - [agent.kata] - - [netmon] - path = "` + netmonPath + `" - enable_debug = ` + strconv.FormatBool(netmonDebug) + ` - - [runtime] - enable_debug = ` + strconv.FormatBool(runtimeDebug) + ` - enable_tracing = ` + strconv.FormatBool(runtimeTrace) + ` - disable_new_netns= ` + strconv.FormatBool(disableNewNetNs) -} - func makeRuntimeConfig(prefixDir string) (configFile string, config oci.RuntimeConfig, err error) { const logPath = "/log/path" hypervisorPath := filepath.Join(prefixDir, "hypervisor") @@ -172,23 +124,38 @@ func makeRuntimeConfig(prefixDir string) (configFile string, config oci.RuntimeC return "", oci.RuntimeConfig{}, err } - runtimeConfig := makeRuntimeConfigFileData( - "qemu", - hypervisorPath, - kernelPath, - imagePath, - kernelParams, - machineType, - shimPath, - proxyPath, - netmonPath, - logPath, - disableBlock, - blockStorageDriver, - enableIOThreads, - hotplugVFIOOnRootBus, - disableNewNetNs, - ) + hypConfig := katautils.GetDefaultHypervisorConfig() + + configFileOptions := katatestutils.RuntimeConfigOptions{ + Hypervisor: "qemu", + HypervisorPath: hypervisorPath, + KernelPath: kernelPath, + ImagePath: imagePath, + KernelParams: kernelParams, + MachineType: machineType, + ShimPath: shimPath, + ProxyPath: proxyPath, + NetmonPath: netmonPath, + LogPath: logPath, + DefaultGuestHookPath: hypConfig.GuestHookPath, + DisableBlock: disableBlock, + BlockDeviceDriver: blockStorageDriver, + EnableIOThreads: enableIOThreads, + HotplugVFIOOnRootBus: hotplugVFIOOnRootBus, + DisableNewNetNs: disableNewNetNs, + DefaultVCPUCount: hypConfig.NumVCPUs, + DefaultMaxVCPUCount: hypConfig.DefaultMaxVCPUs, + DefaultMemSize: hypConfig.MemorySize, + DefaultMsize9p: hypConfig.Msize9p, + HypervisorDebug: hypervisorDebug, + RuntimeDebug: runtimeDebug, + RuntimeTrace: runtimeTrace, + ProxyDebug: proxyDebug, + ShimDebug: shimDebug, + NetmonDebug: netmonDebug, + } + + runtimeConfig := katatestutils.MakeRuntimeConfigFileData(configFileOptions) configFile = path.Join(prefixDir, "runtime.toml") err = createConfig(configFile, runtimeConfig) diff --git a/pkg/katatestutils/utils.go b/pkg/katatestutils/utils.go new file mode 100644 index 0000000000..ef2dcc6549 --- /dev/null +++ b/pkg/katatestutils/utils.go @@ -0,0 +1,87 @@ +// Copyright (c) 2018-2019 Intel Corporation +// Copyright (c) 2018 HyperHQ Inc. +// +// SPDX-License-Identifier: Apache-2.0 +// + +package katatestutils + +import "strconv" + +type RuntimeConfigOptions struct { + Hypervisor string + HypervisorPath string + DefaultVCPUCount uint32 + DefaultMaxVCPUCount uint32 + DefaultMemSize uint32 + DefaultMsize9p uint32 + DefaultGuestHookPath string + KernelPath string + ImagePath string + KernelParams string + MachineType string + ShimPath string + ProxyPath string + NetmonPath string + LogPath string + BlockDeviceDriver string + AgentTraceMode string + AgentTraceType string + DisableBlock bool + EnableIOThreads bool + HotplugVFIOOnRootBus bool + DisableNewNetNs bool + HypervisorDebug bool + RuntimeDebug bool + RuntimeTrace bool + ProxyDebug bool + ShimDebug bool + NetmonDebug bool + AgentDebug bool + AgentTrace bool +} + +func MakeRuntimeConfigFileData(config RuntimeConfigOptions) string { + return ` + # Runtime configuration file + + [hypervisor.` + config.Hypervisor + `] + path = "` + config.HypervisorPath + `" + kernel = "` + config.KernelPath + `" + block_device_driver = "` + config.BlockDeviceDriver + `" + kernel_params = "` + config.KernelParams + `" + image = "` + config.ImagePath + `" + machine_type = "` + config.MachineType + `" + default_vcpus = ` + strconv.FormatUint(uint64(config.DefaultVCPUCount), 10) + ` + default_maxvcpus = ` + strconv.FormatUint(uint64(config.DefaultMaxVCPUCount), 10) + ` + default_memory = ` + strconv.FormatUint(uint64(config.DefaultMemSize), 10) + ` + disable_block_device_use = ` + strconv.FormatBool(config.DisableBlock) + ` + enable_iothreads = ` + strconv.FormatBool(config.EnableIOThreads) + ` + hotplug_vfio_on_root_bus = ` + strconv.FormatBool(config.HotplugVFIOOnRootBus) + ` + msize_9p = ` + strconv.FormatUint(uint64(config.DefaultMsize9p), 10) + ` + enable_debug = ` + strconv.FormatBool(config.HypervisorDebug) + ` + guest_hook_path = "` + config.DefaultGuestHookPath + `" + + [proxy.kata] + enable_debug = ` + strconv.FormatBool(config.ProxyDebug) + ` + path = "` + config.ProxyPath + `" + + [shim.kata] + path = "` + config.ShimPath + `" + enable_debug = ` + strconv.FormatBool(config.ShimDebug) + ` + + [agent.kata] + enable_debug = ` + strconv.FormatBool(config.AgentDebug) + ` + enable_tracing = ` + strconv.FormatBool(config.AgentTrace) + ` + trace_mode = "` + config.AgentTraceMode + `"` + ` + trace_type = "` + config.AgentTraceType + `"` + ` + + [netmon] + path = "` + config.NetmonPath + `" + enable_debug = ` + strconv.FormatBool(config.NetmonDebug) + ` + + [runtime] + enable_debug = ` + strconv.FormatBool(config.RuntimeDebug) + ` + enable_tracing = ` + strconv.FormatBool(config.RuntimeTrace) + ` + disable_new_netns= ` + strconv.FormatBool(config.DisableNewNetNs) +} diff --git a/pkg/katautils/config.go b/pkg/katautils/config.go index 1a434d7d53..24554d5b65 100644 --- a/pkg/katautils/config.go +++ b/pkg/katautils/config.go @@ -752,10 +752,8 @@ func updateRuntimeConfig(configPath string, tomlConf tomlConfig, config *oci.Run return nil } -func initConfig() (config oci.RuntimeConfig, err error) { - var defaultAgentConfig interface{} - - defaultHypervisorConfig := vc.HypervisorConfig{ +func GetDefaultHypervisorConfig() vc.HypervisorConfig { + return vc.HypervisorConfig{ HypervisorPath: defaultHypervisorPath, KernelPath: defaultKernelPath, ImagePath: defaultImagePath, @@ -767,6 +765,7 @@ func initConfig() (config oci.RuntimeConfig, err error) { DefaultMaxVCPUs: defaultMaxVCPUCount, MemorySize: defaultMemSize, MemOffset: defaultMemOffset, + DisableBlockDeviceUse: defaultDisableBlockDeviceUse, DefaultBridges: defaultBridgesCount, MemPrealloc: defaultEnableMemPrealloc, HugePages: defaultEnableHugePages, @@ -782,6 +781,10 @@ func initConfig() (config oci.RuntimeConfig, err error) { HotplugVFIOOnRootBus: defaultHotplugVFIOOnRootBus, GuestHookPath: defaultGuestHookPath, } +} + +func initConfig() (config oci.RuntimeConfig, err error) { + var defaultAgentConfig interface{} err = config.InterNetworkModel.SetModel(defaultInterNetworkingModel) if err != nil { @@ -792,7 +795,7 @@ func initConfig() (config oci.RuntimeConfig, err error) { config = oci.RuntimeConfig{ HypervisorType: defaultHypervisor, - HypervisorConfig: defaultHypervisorConfig, + HypervisorConfig: GetDefaultHypervisorConfig(), AgentType: defaultAgent, AgentConfig: defaultAgentConfig, ProxyType: defaultProxy, diff --git a/pkg/katautils/config_test.go b/pkg/katautils/config_test.go index b91dce21e8..0bb7065f28 100644 --- a/pkg/katautils/config_test.go +++ b/pkg/katautils/config_test.go @@ -15,11 +15,11 @@ import ( "path/filepath" "reflect" goruntime "runtime" - "strconv" "strings" "syscall" "testing" + "github.com/kata-containers/runtime/pkg/katatestutils" vc "github.com/kata-containers/runtime/virtcontainers" "github.com/kata-containers/runtime/virtcontainers/pkg/oci" "github.com/kata-containers/runtime/virtcontainers/utils" @@ -30,6 +30,7 @@ var ( hypervisorDebug = false proxyDebug = false runtimeDebug = false + runtimeTrace = false shimDebug = false netmonDebug = false ) @@ -43,46 +44,6 @@ type testRuntimeConfig struct { LogPath string } -func makeRuntimeConfigFileData(hypervisor, hypervisorPath, kernelPath, imagePath, kernelParams, machineType, shimPath, proxyPath, netmonPath, logPath string, disableBlock bool, blockDeviceDriver string, enableIOThreads bool, hotplugVFIOOnRootBus, disableNewNetNs bool) string { - return ` - # Runtime configuration file - - [hypervisor.` + hypervisor + `] - path = "` + hypervisorPath + `" - kernel = "` + kernelPath + `" - block_device_driver = "` + blockDeviceDriver + `" - kernel_params = "` + kernelParams + `" - image = "` + imagePath + `" - machine_type = "` + machineType + `" - default_vcpus = ` + strconv.FormatUint(uint64(defaultVCPUCount), 10) + ` - default_maxvcpus = ` + strconv.FormatUint(uint64(defaultMaxVCPUCount), 10) + ` - default_memory = ` + strconv.FormatUint(uint64(defaultMemSize), 10) + ` - disable_block_device_use = ` + strconv.FormatBool(disableBlock) + ` - enable_iothreads = ` + strconv.FormatBool(enableIOThreads) + ` - hotplug_vfio_on_root_bus = ` + strconv.FormatBool(hotplugVFIOOnRootBus) + ` - msize_9p = ` + strconv.FormatUint(uint64(defaultMsize9p), 10) + ` - enable_debug = ` + strconv.FormatBool(hypervisorDebug) + ` - guest_hook_path = "` + defaultGuestHookPath + `" - - [proxy.kata] - enable_debug = ` + strconv.FormatBool(proxyDebug) + ` - path = "` + proxyPath + `" - - [shim.kata] - path = "` + shimPath + `" - enable_debug = ` + strconv.FormatBool(shimDebug) + ` - - [agent.kata] - - [netmon] - path = "` + netmonPath + `" - enable_debug = ` + strconv.FormatBool(netmonDebug) + ` - - [runtime] - enable_debug = ` + strconv.FormatBool(runtimeDebug) + ` - disable_new_netns= ` + strconv.FormatBool(disableNewNetNs) -} - func createConfig(configPath string, fileData string) error { err := ioutil.WriteFile(configPath, []byte(fileData), testFileMode) @@ -121,7 +82,36 @@ func createAllRuntimeConfigFiles(dir, hypervisor string) (config testRuntimeConf hotplugVFIOOnRootBus := true disableNewNetNs := false - runtimeConfigFileData := makeRuntimeConfigFileData(hypervisor, hypervisorPath, kernelPath, imagePath, kernelParams, machineType, shimPath, proxyPath, netmonPath, logPath, disableBlockDevice, blockDeviceDriver, enableIOThreads, hotplugVFIOOnRootBus, disableNewNetNs) + configFileOptions := katatestutils.RuntimeConfigOptions{ + Hypervisor: "qemu", + HypervisorPath: hypervisorPath, + KernelPath: kernelPath, + ImagePath: imagePath, + KernelParams: kernelParams, + MachineType: machineType, + ShimPath: shimPath, + ProxyPath: proxyPath, + NetmonPath: netmonPath, + LogPath: logPath, + DefaultGuestHookPath: defaultGuestHookPath, + DisableBlock: disableBlockDevice, + BlockDeviceDriver: blockDeviceDriver, + EnableIOThreads: enableIOThreads, + HotplugVFIOOnRootBus: hotplugVFIOOnRootBus, + DisableNewNetNs: disableNewNetNs, + DefaultVCPUCount: defaultVCPUCount, + DefaultMaxVCPUCount: defaultMaxVCPUCount, + DefaultMemSize: defaultMemSize, + DefaultMsize9p: defaultMsize9p, + HypervisorDebug: hypervisorDebug, + RuntimeDebug: runtimeDebug, + RuntimeTrace: runtimeTrace, + ProxyDebug: proxyDebug, + ShimDebug: shimDebug, + NetmonDebug: netmonDebug, + } + + runtimeConfigFileData := katatestutils.MakeRuntimeConfigFileData(configFileOptions) configPath := path.Join(dir, "runtime.toml") err = createConfig(configPath, runtimeConfigFileData) From b309dc54806e27c24631ad7ac69e36bd3db02b72 Mon Sep 17 00:00:00 2001 From: "James O. D. Hunt" Date: Mon, 15 Apr 2019 10:52:42 +0100 Subject: [PATCH 5/7] agent: Provide explicit config options for the agent Previously, the agent behaviour was controlled entirely using the `kernel_params=` config option. This mechanism suffers from a subtle problem - the runtime is not aware of how the agent will behave. From now on, all significant agent options will be controlled from the agent section in the configuration file. This allows the runtime to be more aware of -- and in control of -- such agent settings. It would also allow the underlying kernel CLI options to be modified in the future if required. This PR adds the only useful agent option as an explicit option by adding an `enable_debug=true` option to the Kata agent section in `configuration.toml`. This allows controlling agent debug to be handled in the same manner as the other debug options. This change is somewhat foundational: it permits the agent to be handled consistently with other config file sections which is useful, but arguably not essential (the old way worked). However, the new way of handling agent options will be essential when introducing agent tracing control as the runtime must be aware of the agent trace mode to allow the runtime to modify its behaviour accordingly. Signed-off-by: James O. D. Hunt --- cli/config/configuration-fc.toml.in | 5 +++-- cli/config/configuration-qemu.toml.in | 5 +++-- cli/kata-env.go | 27 +++++++++++++++++++------ cli/kata-env_test.go | 29 +++++++++++++++++++++++++-- pkg/katautils/config.go | 26 +++++++++++++++++++++++- pkg/katautils/config_test.go | 13 ++++++++++++ virtcontainers/kata_agent.go | 13 ++++++++++++ virtcontainers/kata_agent_test.go | 23 +++++++++++++++++++++ virtcontainers/vm_test.go | 2 +- 9 files changed, 129 insertions(+), 14 deletions(-) diff --git a/cli/config/configuration-fc.toml.in b/cli/config/configuration-fc.toml.in index 2c2a14e790..7cc052b728 100644 --- a/cli/config/configuration-fc.toml.in +++ b/cli/config/configuration-fc.toml.in @@ -222,8 +222,9 @@ path = "@SHIMPATH@" #enable_tracing = true [agent.@PROJECT_TYPE@] -# There is no field for this section. The goal is only to be able to -# specify which type of agent the user wants to use. +# If enabled, make the agent display debug-level messages. +# (default: disabled) +#enable_debug = true [netmon] # If enabled, the network monitoring process gets started when the diff --git a/cli/config/configuration-qemu.toml.in b/cli/config/configuration-qemu.toml.in index a70ca97531..0c875fd4f2 100644 --- a/cli/config/configuration-qemu.toml.in +++ b/cli/config/configuration-qemu.toml.in @@ -274,8 +274,9 @@ path = "@SHIMPATH@" #enable_tracing = true [agent.@PROJECT_TYPE@] -# There is no field for this section. The goal is only to be able to -# specify which type of agent the user wants to use. +# If enabled, make the agent display debug-level messages. +# (default: disabled) +#enable_debug = true [netmon] # If enabled, the network monitoring process gets started when the diff --git a/cli/kata-env.go b/cli/kata-env.go index 8608bf97d1..0d6883bb75 100644 --- a/cli/kata-env.go +++ b/cli/kata-env.go @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2018 Intel Corporation +// Copyright (c) 2017-2019 Intel Corporation // // SPDX-License-Identifier: Apache-2.0 // @@ -27,7 +27,7 @@ import ( // // XXX: Increment for every change to the output format // (meaning any change to the EnvInfo type). -const formatVersion = "1.0.21" +const formatVersion = "1.0.22" // MetaInfo stores information on the format of the output itself type MetaInfo struct { @@ -112,7 +112,8 @@ type ShimInfo struct { // AgentInfo stores agent details type AgentInfo struct { - Type string + Type string + Debug bool } // DistroInfo stores host operating system distribution details. @@ -308,12 +309,23 @@ func getShimInfo(config oci.RuntimeConfig) (ShimInfo, error) { return shim, nil } -func getAgentInfo(config oci.RuntimeConfig) AgentInfo { +func getAgentInfo(config oci.RuntimeConfig) (AgentInfo, error) { agent := AgentInfo{ Type: string(config.AgentType), } - return agent + switch config.AgentType { + case vc.KataContainersAgent: + agentConfig, ok := config.AgentConfig.(vc.KataAgentConfig) + if !ok { + return AgentInfo{}, errors.New("cannot determine Kata agent config") + } + agent.Debug = agentConfig.Debug + default: + // Nothing useful to report for the other agent types + } + + return agent, nil } func getHypervisorInfo(config oci.RuntimeConfig) HypervisorInfo { @@ -361,7 +373,10 @@ func getEnvInfo(configFile string, config oci.RuntimeConfig) (env EnvInfo, err e return EnvInfo{}, err } - agent := getAgentInfo(config) + agent, err := getAgentInfo(config) + if err != nil { + return EnvInfo{}, err + } hypervisor := getHypervisorInfo(config) diff --git a/cli/kata-env_test.go b/cli/kata-env_test.go index 3bb1b589c7..23c0d65de1 100644 --- a/cli/kata-env_test.go +++ b/cli/kata-env_test.go @@ -42,6 +42,7 @@ var ( runtimeTrace = false shimDebug = false netmonDebug = false + agentDebug = false ) // makeVersionBinary creates a shell script with the specified file @@ -153,6 +154,7 @@ func makeRuntimeConfig(prefixDir string) (configFile string, config oci.RuntimeC ProxyDebug: proxyDebug, ShimDebug: shimDebug, NetmonDebug: netmonDebug, + AgentDebug: agentDebug, } runtimeConfig := katatestutils.MakeRuntimeConfigFileData(configFileOptions) @@ -206,8 +208,15 @@ func getExpectedShimDetails(config oci.RuntimeConfig) (ShimInfo, error) { } func getExpectedAgentDetails(config oci.RuntimeConfig) (AgentInfo, error) { + + agentConfig, ok := config.AgentConfig.(vc.KataAgentConfig) + if !ok { + return AgentInfo{}, fmt.Errorf("expected KataAgentConfig, got %T", config.AgentConfig) + } + return AgentInfo{ - Type: string(config.AgentType), + Type: string(config.AgentType), + Debug: agentConfig.Debug, }, nil } @@ -486,6 +495,7 @@ func TestEnvGetEnvInfo(t *testing.T) { runtimeDebug = toggle runtimeTrace = toggle shimDebug = toggle + agentDebug = toggle configFile, config, err := makeRuntimeConfig(tmpdir) assert.NoError(t, err) @@ -799,8 +809,23 @@ func TestEnvGetAgentInfo(t *testing.T) { expectedAgent, err := getExpectedAgentDetails(config) assert.NoError(t, err) - agent := getAgentInfo(config) + agent, err := getAgentInfo(config) + assert.NoError(t, err) + assert.Equal(t, expectedAgent, agent) + + agentConfig, ok := config.AgentConfig.(vc.KataAgentConfig) + assert.True(t, ok) + + agentConfig.Debug = true + config.AgentConfig = agentConfig + agent, err = getAgentInfo(config) + assert.NoError(t, err) + assert.True(t, agent.Debug) + + config.AgentConfig = "I am the wrong type" + _, err = getAgentInfo(config) + assert.Error(t, err) } func testEnvShowTOMLSettings(t *testing.T, tmpdir string, tmpfile *os.File) error { diff --git a/pkg/katautils/config.go b/pkg/katautils/config.go index 24554d5b65..354c83c258 100644 --- a/pkg/katautils/config.go +++ b/pkg/katautils/config.go @@ -136,6 +136,7 @@ type shim struct { } type agent struct { + Debug bool `toml:"enable_debug"` } type netmon struct { @@ -388,6 +389,10 @@ func (s shim) trace() bool { return s.Tracing } +func (a agent) debug() bool { + return a.Debug +} + func (n netmon) enable() bool { return n.Enable } @@ -630,21 +635,29 @@ func updateRuntimeConfigProxy(configPath string, tomlConf tomlConfig, config *oc func updateRuntimeConfigAgent(configPath string, tomlConf tomlConfig, config *oci.RuntimeConfig, builtIn bool) error { if builtIn { + var agentConfig vc.KataAgentConfig + + // If the agent config section isn't a Kata one, just default + // to everything being disabled. + agentConfig, _ = config.AgentConfig.(vc.KataAgentConfig) + config.AgentType = vc.KataContainersAgent config.AgentConfig = vc.KataAgentConfig{ LongLiveConn: true, UseVSock: config.HypervisorConfig.UseVSock, + Debug: agentConfig.Debug, } return nil } - for k := range tomlConf.Agent { + for k, agent := range tomlConf.Agent { switch k { case kataAgentTableType: config.AgentType = vc.KataContainersAgent config.AgentConfig = vc.KataAgentConfig{ UseVSock: config.HypervisorConfig.UseVSock, + Debug: agent.debug(), } default: return fmt.Errorf("%s agent type is not supported", k) @@ -705,6 +718,17 @@ func SetKernelParams(runtimeConfig *oci.RuntimeConfig) error { } } + // next, check for agent specific kernel params + if agentConfig, ok := runtimeConfig.AgentConfig.(vc.KataAgentConfig); ok { + params := vc.KataAgentKernelParams(agentConfig) + + for _, p := range params { + if err := (runtimeConfig).AddKernelParam(p); err != nil { + return err + } + } + } + // now re-add the user-specified values so that they take priority. for _, p := range userKernelParams { if err := (runtimeConfig).AddKernelParam(p); err != nil { diff --git a/pkg/katautils/config_test.go b/pkg/katautils/config_test.go index 0bb7065f28..163d9c9d39 100644 --- a/pkg/katautils/config_test.go +++ b/pkg/katautils/config_test.go @@ -33,6 +33,7 @@ var ( runtimeTrace = false shimDebug = false netmonDebug = false + agentDebug = false ) type testRuntimeConfig struct { @@ -109,6 +110,7 @@ func createAllRuntimeConfigFiles(dir, hypervisor string) (config testRuntimeConf ProxyDebug: proxyDebug, ShimDebug: shimDebug, NetmonDebug: netmonDebug, + AgentDebug: agentDebug, } runtimeConfigFileData := katatestutils.MakeRuntimeConfigFileData(configFileOptions) @@ -1197,6 +1199,17 @@ func TestShimDefaults(t *testing.T) { assert.True(s.trace()) } +func TestAgentDefaults(t *testing.T) { + assert := assert.New(t) + + a := agent{} + + assert.Equal(a.debug(), a.Debug) + + a.Debug = true + assert.Equal(a.debug(), a.Debug) +} + func TestGetDefaultConfigFilePaths(t *testing.T) { assert := assert.New(t) diff --git a/virtcontainers/kata_agent.go b/virtcontainers/kata_agent.go index 80aa151cc1..87cd4442f0 100644 --- a/virtcontainers/kata_agent.go +++ b/virtcontainers/kata_agent.go @@ -88,6 +88,7 @@ var ( type KataAgentConfig struct { LongLiveConn bool UseVSock bool + Debug bool } type kataVSOCK struct { @@ -175,6 +176,18 @@ func (k *kataAgent) generateVMSocket(id string, c KataAgentConfig) error { return nil } +// KataAgentKernelParams returns a list of Kata Agent specific kernel +// parameters. +func KataAgentKernelParams(config KataAgentConfig) []Param { + var params []Param + + if config.Debug { + params = append(params, Param{Key: "agent.log", Value: "debug"}) + } + + return params +} + func (k *kataAgent) init(ctx context.Context, sandbox *Sandbox, config interface{}) (err error) { // save k.ctx = sandbox.ctx diff --git a/virtcontainers/kata_agent_test.go b/virtcontainers/kata_agent_test.go index dfab29ed3f..b1e27f1d9e 100644 --- a/virtcontainers/kata_agent_test.go +++ b/virtcontainers/kata_agent_test.go @@ -934,3 +934,26 @@ func TestKataCleanupSandbox(t *testing.T) { t.Fatalf("%s still exists\n", dir) } } + +func TestKataAgentKernelParams(t *testing.T) { + assert := assert.New(t) + + config := KataAgentConfig{} + + params := KataAgentKernelParams(config) + assert.Empty(params) + + config.Debug = true + + params = KataAgentKernelParams(config) + assert.NotEmpty(params) + + assert.Len(params, 1) + + expected := Param{ + Key: "agent.log", + Value: "debug", + } + + assert.Equal(params[0], expected) +} diff --git a/virtcontainers/vm_test.go b/virtcontainers/vm_test.go index 90025d2381..7b3583b4bb 100644 --- a/virtcontainers/vm_test.go +++ b/virtcontainers/vm_test.go @@ -118,7 +118,7 @@ func TestVMConfigGrpc(t *testing.T) { HypervisorType: QemuHypervisor, HypervisorConfig: newQemuConfig(), AgentType: KataContainersAgent, - AgentConfig: KataAgentConfig{false, true}, + AgentConfig: KataAgentConfig{false, true, false}, ProxyType: NoopProxyType, } From b573d9bcb9e94c5fddbf0230f256e23afc28cc75 Mon Sep 17 00:00:00 2001 From: "James O. D. Hunt" Date: Wed, 24 Apr 2019 17:57:07 +0100 Subject: [PATCH 6/7] vendor: Update for agent tracing and fix issues Updated the agent vendoring for `StartTracing` and `StopTracing`. This only changed a single file - the auto-generated gRPC protocol buffer file. This change resolves four vendoring issues: - The github.com/kubernetes-incubator/cri-o project was renamed to github.com/cri-o/cri-o. Although github redirects, `dep` complains that it cannot find the old `github.com/kubernetes-incubator/cri-o` files under `vendor/` so remove the old config, relying on the existing (and in other respects identical) `dep` config. - There was a stale dependency on `github.com/clearcontainers/proxy` which should have been removed when the Clear Containers code was excised. - The latest version of the agent code vendored into the runtime prior to this commit was a merge commit (commit `48dd1c031530fce9bf16b0f6a7305979cedd8fc9`). This somehow confused `dep` which did *not* correctly pull in the latest version of the auto-generated gRPC code (`vendor/github.com/kata-containers/agent/protocols/grpc/agent.pb.go`). This is clear because commit `48dd1c031530fce9bf16b0f6a7305979cedd8fc9` is newer than the agent commit that introduced the `StartTracing` and `StopTracing` APIs (`00cf907afcb7c8e56f077cf45ae3615f612fdc9d`). Resolving the other two issues above seems to have resolved this issue as the correct version of this file has now been included in the vendoring, however note there is no change to the `dep` files as this version of `agent.pb.go` should already have been included (!) - Updating `agent.pb.go` also removed the `AddInterface` and `RemoveInterface` API calls which should again also have been removed already. Updated tests to remove these redundant calls. Signed-off-by: James O. D. Hunt --- Gopkg.lock | 62 +- Gopkg.toml | 4 - .../github.com/clearcontainers/proxy/COPYING | 202 ---- .../clearcontainers/proxy/api/doc.go | 84 -- .../clearcontainers/proxy/api/frame.go | 235 ----- .../clearcontainers/proxy/api/payload.go | 183 ---- .../clearcontainers/proxy/api/protocol.go | 213 ---- .../clearcontainers/proxy/client/client.go | 410 -------- .../agent/protocols/grpc/agent.pb.go | 970 ++++++++---------- .../github.com/mdlayher/vsock/conn_linux.go | 49 +- vendor/github.com/mdlayher/vsock/fd_linux.go | 6 +- .../mdlayher/vsock/listener_linux.go | 10 +- virtcontainers/kata_agent_test.go | 8 - 13 files changed, 488 insertions(+), 1948 deletions(-) delete mode 100644 vendor/github.com/clearcontainers/proxy/COPYING delete mode 100644 vendor/github.com/clearcontainers/proxy/api/doc.go delete mode 100644 vendor/github.com/clearcontainers/proxy/api/frame.go delete mode 100644 vendor/github.com/clearcontainers/proxy/api/payload.go delete mode 100644 vendor/github.com/clearcontainers/proxy/api/protocol.go delete mode 100644 vendor/github.com/clearcontainers/proxy/client/client.go diff --git a/Gopkg.lock b/Gopkg.lock index fd7ea6b329..4262b87e00 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -2,7 +2,7 @@ [[projects]] - digest = "1:79896046d0807ae89b74ae106b6cb0b346c201c02fc57b7c56017edad7493a61" + digest = "1:5d72bbcc9c8667b11c3dc3cbe681c5a6f71e5096744c0bf7726ab5c6425d5dc4" name = "github.com/BurntSushi/toml" packages = ["."] pruneopts = "NUT" @@ -10,7 +10,7 @@ version = "v0.3.1" [[projects]] - digest = "1:26b14a6dc72ace253599e969997d5ecf2143c63833c015179786bc756c76eaa4" + digest = "1:2be791e7b333ff7c06f8fb3dc18a7d70580e9399dbdffd352621d067ff260b6e" name = "github.com/Microsoft/go-winio" packages = ["."] pruneopts = "NUT" @@ -18,7 +18,7 @@ version = "v0.4.12" [[projects]] - digest = "1:e4eec8e05fe8611837a9b34a787cf9c714a2fd9228a0a1f41dd2ccccbaa21b7e" + digest = "1:a8e16b4caf3575365c9aa3380d9418f31dd0b810596faebfe3a15c37fabeee4a" name = "github.com/Microsoft/hcsshim" packages = [ ".", @@ -65,16 +65,6 @@ revision = "ccb8e960c48f04d6935e72476ae4a51028f9e22f" version = "v9" -[[projects]] - digest = "1:f1bb062def4356e0ffacbf80952a122489df3d26887249a6d351f5b3c98d4c16" - name = "github.com/clearcontainers/proxy" - packages = [ - "api", - "client", - ] - pruneopts = "NUT" - revision = "1d2a6a3ea132a86abd0731408b7dc34f2fc17d55" - [[projects]] branch = "master" digest = "1:8ecb89af7dfe3ac401bdb0c9390b134ef96a97e85f732d2b0604fb7b3977839f" @@ -99,7 +89,7 @@ revision = "0650fd9eeb50bab4fc99dceb9f2e14cf58f36e7f" [[projects]] - digest = "1:c572858cf95490994cee8faa84a57a8942f735e1a8b6a5a7876d13192754c05e" + digest = "1:b1ddab63ebf3a38cdc2a80fa1f00c45e8dc98e27387968ccc0e5275a43f6cb5e" name = "github.com/containerd/containerd" packages = [ "api/events", @@ -120,7 +110,7 @@ revision = "f05672357f56f26751a521175c5a96fc21fa8603" [[projects]] - digest = "1:4f06807f78ebb5fd6d5fcd539885c0a0be60732eda47189a7feb486ff60a519d" + digest = "1:e7c346f795db5a431ca8bd284faed7aa5b4d544ba6538b20a39b968473f47774" name = "github.com/containerd/cri-containerd" packages = [ "pkg/annotations", @@ -216,7 +206,7 @@ version = "v0.3.3" [[projects]] - digest = "1:2cbc5d9ad66b4eb1e82862757985de8c24d8ca299500e669998694329d05bfc9" + digest = "1:351337e3b022de09e72306f1f9711314cc4bd407c15e8d328e218c655fd55731" name = "github.com/firecracker-microvm/firecracker-go-sdk" packages = [ "client", @@ -228,7 +218,7 @@ [[projects]] branch = "master" - digest = "1:e30aea4f7e276dc80a7041b9e436b45a4c6636e5ba554de835b07beb0f97cc74" + digest = "1:ce0cdcf4a121add67d3c6f7cc08e6233275d0f417852f025b790d35da88fab10" name = "github.com/globalsign/mgo" packages = [ "bson", @@ -245,7 +235,7 @@ revision = "20b96f641a5ea98f2f8619ff4f3e061cff4833bd" [[projects]] - digest = "1:5b7a60e28d9315ba79fb73e6294e5823997673ee64797d28ba2dc7bf71dc6ba6" + digest = "1:e101aa2e25fac7e82ba4d2f66807eedd4bcf11abc5afcb4a4629a88f9a652b84" name = "github.com/go-openapi/analysis" packages = [ ".", @@ -288,7 +278,7 @@ version = "v0.18.0" [[projects]] - digest = "1:36b4e8fb9b6f5896fe776b279a6e3a4115ab7d0258d0e0d2ac9c6c58e12531c7" + digest = "1:757a8958779fedcfddafb3ac93f707876db7b4fbc71b76fbc25450b3f057025e" name = "github.com/go-openapi/runtime" packages = [ ".", @@ -345,7 +335,7 @@ version = "v5.0.1" [[projects]] - digest = "1:34e8cbba4f0ad2eeda81c98d3f53af4c5862518ec0ebae38730fc36f8a7705f0" + digest = "1:0dfc35f448d29c2ff6a29fb3a6643f44175dc2a07925b1add2dea74e1dd6bf8d" name = "github.com/gogo/protobuf" packages = [ "gogoproto", @@ -358,7 +348,7 @@ revision = "342cbe0a04158f6dcb03ca0079991a51a4248c02" [[projects]] - digest = "1:a8b59d8995b50db3b206d9160817e00aace183e456cb60abf5157de16d12e3c9" + digest = "1:2d0636a8c490d2272dd725db26f74a537111b99b9dbdda0d8b98febe63702aa4" name = "github.com/golang/protobuf" packages = [ "proto", @@ -405,16 +395,9 @@ pruneopts = "NUT" revision = "48dd1c031530fce9bf16b0f6a7305979cedd8fc9" -[[projects]] - digest = "1:04054595e5c5a35d1553a7f3464d18577caf597445d643992998643df56d4afd" - name = "github.com/kubernetes-incubator/cri-o" - packages = ["pkg/annotations"] - pruneopts = "NUT" - revision = "3394b3b2d6af0e41d185bb695c6378be5dd4d61d" - [[projects]] branch = "master" - digest = "1:ebd709f6c64e850ee37ffd662604b647934ba1b7da39c7ba26381d634a4b6d4d" + digest = "1:84a5a2b67486d5d67060ac393aa255d05d24ed5ee41daecd5635ec22657b6492" name = "github.com/mailru/easyjson" packages = [ "buffer", @@ -447,7 +430,7 @@ version = "v1.0.0-rc1" [[projects]] - digest = "1:d4dcb47c4324ed0af861eda17778f56229d44422819770972183bee0217f9cff" + digest = "1:26537bc93f1e164bbc305117029de9933656ff81c4549609939212aca20a4710" name = "github.com/opencontainers/runc" packages = [ "libcontainer/configs", @@ -467,7 +450,7 @@ revision = "5806c35637336642129d03657419829569abc5aa" [[projects]] - digest = "1:7fea98b6541d058ba0ae5496d57d420d396a3f121a0aec64b4ec2171b0a93846" + digest = "1:7da29c22bcc5c2ffb308324377dc00b5084650348c2799e573ed226d8cc9faf0" name = "github.com/opentracing/opentracing-go" packages = [ ".", @@ -518,7 +501,7 @@ version = "v0.9.0" [[projects]] - digest = "1:e2930b698575a7f45df1eaa5473c76109b04a87d6a464e674a68f9c1dff244a1" + digest = "1:432ba4d123dc14d6e3b71ca22051bd1a5aa20a8e466e47edabd9af46405c5cfb" name = "github.com/sirupsen/logrus" packages = [ ".", @@ -535,7 +518,7 @@ revision = "890a5c3458b43e6104ff5da8dfa139d013d77544" [[projects]] - digest = "1:d43a3612c85e592ffcefdbc426d3fc0bdbc71435c930664bef8c36034181d681" + digest = "1:87dee780f88f86f300bbd90116e933347cf4a3c65c1960072d412597a8896d50" name = "github.com/uber/jaeger-client-go" packages = [ ".", @@ -576,7 +559,7 @@ revision = "ac249472b7de27a9e8990819566d9be95ab5b816" [[projects]] - digest = "1:e53b4392978149151080be2de940b1cfbb542c3b2bc3281e091678a3626397f8" + digest = "1:51b28ecbdddc7e0260899b64d8cf13343bb8f66b4b00585b46c775509755095a" name = "github.com/vishvananda/netlink" packages = [ ".", @@ -601,7 +584,7 @@ revision = "8dd112bcdc25174059e45e07517d9fc663123347" [[projects]] - digest = "1:5985d67e107c875e2584b5a65f1590adee7677a4e44eb7e62cd54c7709abba4a" + digest = "1:b20c63a56900e442d5f435613fefc9392cbe8849467510fcc3869dbdad9441bb" name = "golang.org/x/net" packages = [ "context", @@ -616,7 +599,7 @@ revision = "a8b9294777976932365dabb6640cf1468d95c70f" [[projects]] - digest = "1:bfb083c1c1ae3c793c66773f32fa2f5934241d8c6327636f4761f269d018a171" + digest = "1:2fd19a8bed3f4ba8e3b26620f114efec5f39c7b02635a89a915b1cbaefeab5ff" name = "golang.org/x/sys" packages = [ "unix", @@ -626,7 +609,7 @@ revision = "1d2aa6dbdea45adaaebb9905d0666e4537563829" [[projects]] - digest = "1:4e48d0d8df75f1bd0a0afe837599fc9ad96b59eecdd1900fc0dcceccaa5fdffc" + digest = "1:e33513a825fcd765e97b5de639a2f7547542d1a8245df0cef18e1fd390b778a9" name = "golang.org/x/text" packages = [ "collate", @@ -658,7 +641,7 @@ revision = "5fe7a883aa19554f42890211544aa549836af7b7" [[projects]] - digest = "1:c09d7ef1564ca6aee8193b8b9d2d831cb69d29581f53b1b1e6331142d07fddbd" + digest = "1:3d43152515ea791363eb0d1d21378fbf70e7df4a3954fd315898532cf5e64a8c" name = "google.golang.org/grpc" packages = [ ".", @@ -701,8 +684,6 @@ analyzer-version = 1 input-imports = [ "github.com/BurntSushi/toml", - "github.com/clearcontainers/proxy/api", - "github.com/clearcontainers/proxy/client", "github.com/containerd/cgroups", "github.com/containerd/containerd/api/events", "github.com/containerd/containerd/api/types", @@ -735,7 +716,6 @@ "github.com/kata-containers/agent/pkg/types", "github.com/kata-containers/agent/protocols/client", "github.com/kata-containers/agent/protocols/grpc", - "github.com/kubernetes-incubator/cri-o/pkg/annotations", "github.com/mitchellh/mapstructure", "github.com/opencontainers/runc/libcontainer/configs", "github.com/opencontainers/runc/libcontainer/specconv", diff --git a/Gopkg.toml b/Gopkg.toml index 803d5092c3..ddcc66a9f2 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -1,7 +1,3 @@ -[[constraint]] - name = "github.com/clearcontainers/proxy" - revision = "1d2a6a3ea132a86abd0731408b7dc34f2fc17d55" - [[constraint]] name = "github.com/containernetworking/plugins" revision = "7f98c94613021d8b57acfa1a2f0c8d0f6fd7ae5a" diff --git a/vendor/github.com/clearcontainers/proxy/COPYING b/vendor/github.com/clearcontainers/proxy/COPYING deleted file mode 100644 index d645695673..0000000000 --- a/vendor/github.com/clearcontainers/proxy/COPYING +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - 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. diff --git a/vendor/github.com/clearcontainers/proxy/api/doc.go b/vendor/github.com/clearcontainers/proxy/api/doc.go deleted file mode 100644 index 280157edf0..0000000000 --- a/vendor/github.com/clearcontainers/proxy/api/doc.go +++ /dev/null @@ -1,84 +0,0 @@ -// Copyright (c) 2017 Intel Corporation -// -// 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 api defines the API cc-proxy exposes to clients (processes -// connecting to the proxy AF_UNIX socket). -// -// This package contains the low level definitions of the protocol, frame -// structure and the various payloads that can be sent and received. -// -// The proxy protocol is composed of commands, responses and notifications. -// They all share the same frame structure: a header followed by an optional -// payload. -// -// • Commands are always initiated by a client, never by the proxy itself. -// -// • Responses are sent by the proxy to acknowledge commands. -// -// • Notifications are sent by either the proxy or clients and do not generate -// responses. -// -// Frame Structure -// -// The frame format is illustrated below: -// -// 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 -// 0 1 2 3 4 5 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 -// ┌───────────────────────────┬───────────────┬───────────────┐ -// │ Version │ Header Length │ Reserved │ -// ├───────────────────────────┼─────┬─┬───────┼───────────────┤ -// │ Reserved │ Res.│E│ Type │ Opcode │ -// ├───────────────────────────┴─────┴─┴───────┴───────────────┤ -// │ Payload Length │ -// ├───────────────────────────────────────────────────────────┤ -// │ │ -// │ Payload │ -// │ │ -// │ (variable length, optional and opcode-specific) │ -// │ │ -// └───────────────────────────────────────────────────────────┘ -// -// All header fields are encoded in network order (big endian). -// -// • Version (16 bits) is the proxy protocol version. See api.Version for -// details about what information it encodes. -// -// • Header Length (8 bits) is the length of the header in number of 32-bit -// words. Header Length is greater or equal to 3 (12 bytes). -// -// • Type (4 bits) is the frame type: command (0x0), response (0x1), -// stream (0x2) or notification (0x3). -// -// • Opcode (8 bits) specifies the kind of command, response, stream or -// notification this frame represents. In conjunction with Type, this field -// will dictate the payload content. -// -// • E, Error. This flag is set when a response returns an error. Currently -// Error can ony be set in response frames. -// -// • Payload Length (32 bits) is in bytes. -// -// • Payload is optional data that can be sent with the various frames. -// Commands, responses and notifications usually encode their payloads in JSON -// while stream frames have raw data payloads. -// -// • Reserved fields are reserved for future use and must be zeroed. -// -// Frame Size and Header Length -// -// The full size of a frame is (Header Length + Payload Length). The Payload -// starts at offset Header Length from the start of the frame. -// -// It is guaranteed that future header sizes will be at least 12 bytes. -package api diff --git a/vendor/github.com/clearcontainers/proxy/api/frame.go b/vendor/github.com/clearcontainers/proxy/api/frame.go deleted file mode 100644 index 242c7c2541..0000000000 --- a/vendor/github.com/clearcontainers/proxy/api/frame.go +++ /dev/null @@ -1,235 +0,0 @@ -// Copyright (c) 2017 Intel Corporation -// -// 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 api - -import ( - "encoding/json" -) - -// Version encodes the proxy protocol version. -// -// List of changes: -// -// • version 2: initial version released with Clear Containers 3.0 -// -// ⚠⚠⚠ backward incompatible with version 1 ⚠⚠⚠ -// -// List of changes: -// -// • Changed the frame header to include additional fields: version, -// header length, type and opcode. -// • Added a log messages for clients to insert log entries to the -// consolidated proxy log. -// -// • version 1: initial version released with Clear Containers 2.1 -const Version = 2 - -// FrameType is the type of frame and is part of the frame header. -type FrameType int - -const ( - // TypeCommand is a command from a client to the proxy. - TypeCommand FrameType = iota - // TypeResponse is a command response back from the proxy to a client. - TypeResponse - // TypeStream is a stream of data from a client to the proxy. Streams - // are to be forwarded onto the VM agent. - TypeStream - // TypeNotification is a notification sent by either the proxy or - // clients. Notifications are one way only and do not prompt a - // response. - TypeNotification - // TypeMax is the number of types. - TypeMax -) - -const unknown = "unknown" - -// String implements Stringer for FrameType. -func (t FrameType) String() string { - switch t { - case TypeCommand: - return "command" - case TypeResponse: - return "response" - case TypeStream: - return "stream" - case TypeNotification: - return "notification" - default: - return unknown - } -} - -// Command is the kind of command being sent. In the frame header, Opcode must -// have one of these values when Type is api.TypeCommand. -type Command int - -const ( - // CmdRegisterVM registers a new VM/POD. - CmdRegisterVM Command = iota - // CmdUnregisterVM unregisters a VM/POD. - CmdUnregisterVM - // CmdAttachVM attaches to a registered VM. - CmdAttachVM - // CmdHyper sends a hyperstart command through the proxy. - CmdHyper - // CmdConnectShim identifies the client as a shim. - CmdConnectShim - // CmdDisconnectShim unregisters a shim. DisconnectShim is a bit - // special and doesn't send a Response back but closes the connection. - CmdDisconnectShim - // CmdSignal sends a signal to the process inside the VM. A client - // needs to be connected as a shim before it can issue that command. - CmdSignal - // CmdMax is the number of commands. - CmdMax -) - -// String implements Stringer for Command. -func (t Command) String() string { - switch t { - case CmdRegisterVM: - return "RegisterVM" - case CmdUnregisterVM: - return "UnregisterVM" - case CmdAttachVM: - return "AttachVM" - case CmdHyper: - return "Hyper" - case CmdConnectShim: - return "ConnectShim" - case CmdDisconnectShim: - return "DisconnectShim" - case CmdSignal: - return "Signal" - default: - return unknown - } -} - -// Stream is the kind of stream being sent. In the frame header, Opcode must -// have one of the these values when Type is api.TypeStream. -type Stream int - -const ( - // StreamStdin is a stream conveying stdin data. - StreamStdin Stream = iota - // StreamStdout is a stream conveying stdout data. - StreamStdout - // StreamStderr is a stream conveying stderr data. - StreamStderr - // StreamLog is a stream conveying structured logs messages. Each Log frame - // contains a JSON object which fields are the structured log. By convention - // it would be nice to have a few common fields in log entries to ease - // post-processing. See the LogEntry payload for details. - StreamLog - // StreamMax is the number of stream types. - StreamMax -) - -// String implements Stringer for Stream. -func (s Stream) String() string { - switch s { - case StreamStdin: - return "stdin" - case StreamStdout: - return "stdout" - case StreamStderr: - return "stderr" - case StreamLog: - return "log" - default: - return unknown - } -} - -// Notification is the kind of notification being sent. In the frame header, -// Opcode must have one of the these values when Type is api.TypeNotification. -type Notification int - -const ( - // NotificationProcessExited is sent to signal a process in the VM has exited. - NotificationProcessExited = iota - // NotificationMax is the number of notification types. - NotificationMax -) - -// String implements Stringer for Notification. -func (n Notification) String() string { - switch n { - case NotificationProcessExited: - return "ProcessExited" - default: - return unknown - } -} - -// FrameHeader is the header of a Frame. -type FrameHeader struct { - Version int - // HeaderLength in the size of the header in bytes (the on-wire - // HeaderLength is in number of 32-bits words tough). - HeaderLength int - Type FrameType - Opcode int - PayloadLength int - InError bool -} - -// Frame is the basic communication unit with the proxy. -type Frame struct { - Header FrameHeader - Payload []byte -} - -// NewFrame creates a new Frame with type t, operand op and given payload. -func NewFrame(t FrameType, op int, payload []byte) *Frame { - return &Frame{ - Header: FrameHeader{ - Version: Version, - HeaderLength: minHeaderLength, - Type: t, - Opcode: op, - PayloadLength: len(payload), - }, - Payload: payload, - } -} - -// NewFrameJSON creates a new Frame with type t, operand op and given payload. -// The payload structure is marshalled into JSON. -func NewFrameJSON(t FrameType, op int, payload interface{}) (*Frame, error) { - var data []byte - - if payload != nil { - var err error - - if data, err = json.Marshal(payload); err != nil { - return nil, err - } - } - - return &Frame{ - Header: FrameHeader{ - Version: Version, - HeaderLength: minHeaderLength, - Type: t, - Opcode: op, - PayloadLength: len(data), - }, - Payload: data, - }, nil -} diff --git a/vendor/github.com/clearcontainers/proxy/api/payload.go b/vendor/github.com/clearcontainers/proxy/api/payload.go deleted file mode 100644 index c7d13b6ca0..0000000000 --- a/vendor/github.com/clearcontainers/proxy/api/payload.go +++ /dev/null @@ -1,183 +0,0 @@ -// Copyright (c) 2016,2017 Intel Corporation -// -// 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 api - -import ( - "encoding/json" -) - -// The RegisterVM payload is issued first after connecting to the proxy socket. -// It is used to let the proxy know about a new container on the system along -// with the paths go hyperstart's command and I/O channels (AF_UNIX sockets). -// -// Console can be used to indicate the path of a socket linked to the VM -// console. The proxy can output this data when asked for verbose output. -// -// { -// "containerId": "756535dc6e9ab9b560f84c8...", -// "ctlSerial": "/tmp/sh.hyper.channel.0.sock", -// "ioSerial": "/tmp/sh.hyper.channel.1.sock", -// "numIOStreams: 1 -// } -type RegisterVM struct { - ContainerID string `json:"containerId"` - CtlSerial string `json:"ctlSerial"` - IoSerial string `json:"ioSerial"` - Console string `json:"console,omitempty"` - // NumIOStreams asks for a number of I/O tokens. An I/O token - // represents the communication between a container process inside - // the VM and a shim process outside the VM. This communication - // includes I/O streams (stdin, out, err) but also signals, exit - // status, ... - // The response frame will contain NumIOStreams I/O tokens. - NumIOStreams int `json:"numIOStreams,omitempty"` -} - -// IOResponse is the response data in RegisterVMResponse and AttachVMResponse -// when the client is asking for I/O tokens from the proxy (NumIOStreams > 0). -type IOResponse struct { - // URL is the URL a shim process should connect to in order to initiate - // the I/O communication with the process inside the VM - URL string - // IOTokens is a array of I/O tokens of length NumIOStreams. See - // RegisterVM for some details on I/O tokens. - Tokens []string `json:"tokens"` -} - -// RegisterVMResponse is the result from a successful RegisterVM. -// -// { -// "io": { -// "url": "unix:///run/clearcontainers/proxy.sock", -// "tokens": [ -// "bwgxfmQj9uG3YCsFHrvontwDw41CJJ76Y7qVt4Bi9wc=" -// ] -// } -// } -type RegisterVMResponse struct { - // IO contains the proxy answer when asking for I/O tokens. - IO IOResponse `json:"io,omitempty"` -} - -// The AttachVM payload can be used to associate clients to an already known -// VM. AttachVM cannot be issued if a RegisterVM for this container hasn't been -// issued beforehand. -// -// { -// "containerId": "756535dc6e9ab9b560f84c8...". -// "numIOStreams: 1 -// } -type AttachVM struct { - ContainerID string `json:"containerId"` - // NumIOStreams asks for a number of I/O tokens. See RegisterVM for - // some details on I/O tokens. - NumIOStreams int `json:"numIOStreams,omitempty"` -} - -// AttachVMResponse is the result from a successful AttachVM. -// -// { -// "io": { -// "url": "unix:///run/clearcontainers/proxy.sock", -// "tokens": [ -// "bwgxfmQj9uG3YCsFHrvontwDw41CJJ76Y7qVt4Bi9wc=" -// ] -// } -// } -type AttachVMResponse struct { - // IO contains the proxy answer when asking for I/O tokens. - IO IOResponse `json:"io,omitempty"` -} - -// The UnregisterVM payload does the opposite of what RegisterVM does, -// indicating to the proxy it should release resources created by RegisterVM -// for the container identified by containerId. -// -// { -// "containerId": "756535dc6e9ab9b560f84c8..." -// } -type UnregisterVM struct { - ContainerID string `json:"containerId"` -} - -// The Hyper payload will forward an hyperstart command to hyperstart. -// -// Note: the newcontainer and execmd hyperstart commands start one or more -// processes. When sending those commands, tokens acquired through either -// RegisterVM or AttachVM need to be sent along in the tokens array. The number -// of tokens sent has to match the number of processes to be started. -// -// { -// "hyperName": "newcontainer", -// "tokens": [ -// "bwgxfmQj9uG3YCsFHrvontwDw41CJJ76Y7qVt4Bi9wc=" -// ], -// "data": { -// "id": "756535dc6e9ab9b560f84c8...", -// "rootfs": "/foo/bar", -// ... -// } -// } -// } -type Hyper struct { - HyperName string `json:"hyperName"` - Tokens []string `json:"tokens"` - Data json.RawMessage `json:"data,omitempty"` -} - -// ConnectShim identifies a shim against the proxy. A shim process is a process -// running on host shadowing a container process running inside the VM. A shim -// will forward stdin and signals to the process inside the VM and will receive -// stdout, stderr and the exit status. -type ConnectShim struct { - // Token is id corresponding to the process the shim wants to handle - // the I/O streams, signals, exit status for. Tokens are allocated with - // a call to RegisterVM or AttachVM. - Token string `json:"token"` -} - -// DisconnectShim unregister a shim from the proxy. -type DisconnectShim struct { -} - -// Signal is used to send signals to the container process inside the VM. This -// payload is only valid after a successful ConnectShim. -type Signal struct { - SignalNumber int `json:"signalNumber"` - // Columns is only valid for SIGWINCH and is the new number of columns of - // the terminal. - Columns int `json:"columns,omitempty"` - // Rows is only valid for SIGWINCH and is the new number of rows of the - // terminal. - Rows int `json:"rows,omitempty"` -} - -// ErrorResponse is the payload send in Responses where the Error flag is set. -type ErrorResponse struct { - Message string `json:"msg"` -} - -// LogEntry is the payload for the StreamLog data. -type LogEntry struct { - // Source is the source of the log entry. One of "shim" or "runtime". - Source string `json:"source"` - // ContainerID is the ID of the container the log entry is for (optional). - ContainerID string `json:"containerId,omitempty"` - // Level is the verbosity level of the log entry. One of "debug", "info", "warn" - // or "error". - Level string `json:"level"` - // Message is the log message - Message string `json:"msg"` -} diff --git a/vendor/github.com/clearcontainers/proxy/api/protocol.go b/vendor/github.com/clearcontainers/proxy/api/protocol.go deleted file mode 100644 index 00ce51a8c9..0000000000 --- a/vendor/github.com/clearcontainers/proxy/api/protocol.go +++ /dev/null @@ -1,213 +0,0 @@ -// Copyright (c) 2016 Intel Corporation -// -// 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 api - -import ( - "encoding/binary" - "encoding/json" - "errors" - "fmt" - "io" -) - -// minHeaderLength is the length of the header in the version 2 of protocol. -// It is guaranteed later versions will have a header at least that big. -const minHeaderLength = 12 // in bytes - -// A Request is a JSON message sent from a client to the proxy. This message -// embed a payload identified by "id". A payload can have data associated with -// it. It's useful to think of Request as an RPC call with "id" as function -// name and "data" as arguments. -// -// The list of possible payloads are documented in this package. -// -// Each Request has a corresponding Response message sent back from the proxy. -type Request struct { - ID string `json:"id"` - Data json.RawMessage `json:"data,omitempty"` -} - -// A Response is a JSON message sent back from the proxy to a client after a -// Request has been issued. The Response holds the result of the Request, -// including its success state and optional data. It's useful to think of -// Response as the result of an RPC call with ("success", "error") describing -// if the call has been successful and "data" holding the optional results. -type Response struct { - Success bool `json:"success"` - Error string `json:"error,omitempty"` - Data map[string]interface{} `json:"data,omitempty"` -} - -// Offsets (in bytes) of frame headers fields. -const ( - versionOffset = 0 - headerLengthOffset = 2 - typeOffset = 6 - flagsOffset = 6 - opcodeOffset = 7 - payloadLengthOffset = 8 -) - -// Size (in bytes) of frame header fields (when larger than 1 byte). -const ( - versionSize = 2 - payloadLengthSize = 4 -) - -// Masks needed to extract fields -const ( - typeMask = 0x0f - flagsMask = 0xf0 -) - -func maxOpcodeForFrameType(t FrameType) int { - switch t { - default: - fallthrough - case TypeCommand: - return int(CmdMax) - case TypeResponse: - return int(CmdMax) - case TypeStream: - return int(StreamMax) - case TypeNotification: - return int(NotificationMax) - } -} - -// ReadFrame reads a full frame (header and payload) from r. -func ReadFrame(r io.Reader) (*Frame, error) { - // Read the header. - buf := make([]byte, minHeaderLength) - n, err := r.Read(buf) - if err != nil { - return nil, err - } - if n != minHeaderLength { - return nil, errors.New("frame: couldn't read the full header") - } - - // Decode it. - frame := &Frame{} - header := &frame.Header - header.Version = int(binary.BigEndian.Uint16(buf[versionOffset : versionOffset+versionSize])) - if header.Version < 2 || header.Version > Version { - return nil, fmt.Errorf("frame: bad version %d", header.Version) - } - header.HeaderLength = int(buf[headerLengthOffset]) * 4 - header.Type = FrameType(buf[typeOffset] & typeMask) - flags := buf[flagsOffset] & flagsMask - if flags&flagInError != 0 { - header.InError = true - } - if header.Type >= TypeMax { - return nil, fmt.Errorf("frame: bad type %s", header.Type) - } - header.Opcode = int(buf[opcodeOffset]) - if header.Opcode >= maxOpcodeForFrameType(header.Type) { - return nil, fmt.Errorf("frame: bad opcode (%d) for type %s", header.Opcode, - header.Type) - } - header.PayloadLength = int(binary.BigEndian.Uint32(buf[payloadLengthOffset : payloadLengthOffset+payloadLengthSize])) - - // Read the payload. - received := 0 - need := header.HeaderLength - minHeaderLength + header.PayloadLength - payload := make([]byte, need) - for received < need { - n, err := r.Read(payload[received:need]) - if err != nil { - return nil, err - } - - received += n - } - - // Skip the bytes part of a bigger header than expected to just keep - // the payload. - frame.Payload = payload[header.HeaderLength-minHeaderLength : need] - - return frame, nil -} - -const ( - flagInError = 1 << (4 + iota) -) - -// WriteFrame writes a frame into w. -// -// Note that frame.Header.PayloadLength dictates the amount of data of -// frame.Payload to write, so frame.Header.Payload must be less or equal to -// len(frame.Payload). -func WriteFrame(w io.Writer, frame *Frame) error { - header := &frame.Header - - if len(frame.Payload) < header.PayloadLength { - return fmt.Errorf("frame: bad payload length %d", - header.PayloadLength) - } - - // Prepare the header. - len := minHeaderLength + header.PayloadLength - buf := make([]byte, len) - binary.BigEndian.PutUint16(buf[versionOffset:versionOffset+versionSize], uint16(header.Version)) - buf[headerLengthOffset] = byte(header.HeaderLength / 4) - flags := byte(0) - if frame.Header.InError { - flags |= flagInError - } - buf[typeOffset] = flags | byte(header.Type)&typeMask - buf[opcodeOffset] = byte(header.Opcode) - binary.BigEndian.PutUint32(buf[payloadLengthOffset:payloadLengthOffset+payloadLengthSize], - uint32(header.PayloadLength)) - - // Write payload if needed - if header.PayloadLength > 0 { - copy(buf[minHeaderLength:], frame.Payload[0:header.PayloadLength]) - } - - n, err := w.Write(buf) - if err != nil { - return err - } - - if n != len { - return errors.New("frame: couldn't write frame") - } - - return nil -} - -// WriteCommand is a convenience wrapper around WriteFrame to send commands. -func WriteCommand(w io.Writer, op Command, payload []byte) error { - return WriteFrame(w, NewFrame(TypeCommand, int(op), payload)) -} - -// WriteResponse is a convenience wrapper around WriteFrame to send responses. -func WriteResponse(w io.Writer, op Command, inError bool, payload []byte) error { - frame := NewFrame(TypeResponse, int(op), payload) - frame.Header.InError = inError - return WriteFrame(w, frame) -} - -// WriteStream is a convenience wrapper around WriteFrame to send stream packets. -func WriteStream(w io.Writer, op Stream, payload []byte) error { - return WriteFrame(w, NewFrame(TypeStream, int(op), payload)) -} - -// WriteNotification is a convenience wrapper around WriteFrame to send notifications. -func WriteNotification(w io.Writer, op Notification, payload []byte) error { - return WriteFrame(w, NewFrame(TypeNotification, int(op), payload)) -} diff --git a/vendor/github.com/clearcontainers/proxy/client/client.go b/vendor/github.com/clearcontainers/proxy/client/client.go deleted file mode 100644 index 13db189eea..0000000000 --- a/vendor/github.com/clearcontainers/proxy/client/client.go +++ /dev/null @@ -1,410 +0,0 @@ -// Copyright (c) 2016 Intel Corporation -// -// 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 client - -import ( - "encoding/json" - "errors" - "fmt" - "net" - "syscall" - - "github.com/clearcontainers/proxy/api" -) - -// The Client struct can be used to issue proxy API calls with a convenient -// high level API. -type Client struct { - conn net.Conn -} - -// NewClient creates a new client object to communicate with the proxy using -// the connection conn. The user should call Close() once finished with the -// client object to close conn. -func NewClient(conn net.Conn) *Client { - return &Client{ - conn: conn, - } -} - -// Close a client, closing the underlying AF_UNIX socket. -func (client *Client) Close() { - client.conn.Close() -} - -func (client *Client) sendCommandFull(cmd api.Command, payload interface{}, - waitForResponse bool) (*api.Frame, error) { - var data []byte - var frame *api.Frame - var err error - - if payload != nil { - if data, err = json.Marshal(payload); err != nil { - return nil, err - } - } - - if err := api.WriteCommand(client.conn, cmd, data); err != nil { - return nil, err - } - - if !waitForResponse { - return nil, nil - } - - if frame, err = api.ReadFrame(client.conn); err != nil { - return nil, err - } - - if cmd == api.CmdSignal { - payloadSignal, ok := payload.(*api.Signal) - if !ok { - return nil, err - } - - if payloadSignal.SignalNumber == int(syscall.SIGKILL) || - payloadSignal.SignalNumber == int(syscall.SIGTERM) { - if frame.Header.Type != api.TypeNotification { - return nil, fmt.Errorf("unexpected frame type %v", frame.Header.Type) - } - - if frame, err = api.ReadFrame(client.conn); err != nil { - return nil, err - } - } - } - - if frame.Header.Type != api.TypeResponse { - return nil, fmt.Errorf("unexpected frame type %v", frame.Header.Type) - } - - if frame.Header.Opcode != int(cmd) { - return nil, fmt.Errorf("unexpected opcode %v", frame.Header.Opcode) - } - - return frame, nil -} - -func (client *Client) sendCommand(cmd api.Command, payload interface{}) (*api.Frame, error) { - return client.sendCommandFull(cmd, payload, true) -} - -func (client *Client) sendCommandNoResponse(cmd api.Command, payload interface{}) error { - _, err := client.sendCommandFull(cmd, payload, false) - return err -} - -func errorFromResponse(resp *api.Frame) error { - // We should always have an error with the response, but better safe - // than sorry. - if !resp.Header.InError { - return nil - } - - decoded := api.ErrorResponse{} - if err := json.Unmarshal(resp.Payload, &decoded); err != nil { - return err - } - - if decoded.Message == "" { - return errors.New("unknown error") - } - - return errors.New(decoded.Message) -} - -func unmarshalResponse(resp *api.Frame, decoded interface{}) error { - if len(resp.Payload) == 0 { - return nil - } - - if err := json.Unmarshal(resp.Payload, decoded); err != nil { - return err - } - - return nil -} - -// RegisterVMOptions holds extra arguments one can pass to the RegisterVM -// function. -// -// See the api.RegisterVM payload for more details. -type RegisterVMOptions struct { - Console string - NumIOStreams int -} - -// RegisterVMReturn contains the return values from RegisterVM. -// -// See the api.RegisterVM and api.RegisterVMResponse payloads. -type RegisterVMReturn api.RegisterVMResponse - -// RegisterVM wraps the api.RegisterVM payload. -// -// See payload description for more details. -func (client *Client) RegisterVM(containerID, ctlSerial, ioSerial string, - options *RegisterVMOptions) (*RegisterVMReturn, error) { - payload := api.RegisterVM{ - ContainerID: containerID, - CtlSerial: ctlSerial, - IoSerial: ioSerial, - } - - if options != nil { - payload.Console = options.Console - payload.NumIOStreams = options.NumIOStreams - } - - resp, err := client.sendCommand(api.CmdRegisterVM, &payload) - if err != nil { - return nil, err - } - - if err := errorFromResponse(resp); err != nil { - return nil, err - } - - decoded := RegisterVMReturn{} - err = unmarshalResponse(resp, &decoded) - return &decoded, err -} - -// AttachVMOptions holds extra arguments one can pass to the AttachVM function. -// -// See the api.AttachVM payload for more details. -type AttachVMOptions struct { - NumIOStreams int -} - -// AttachVMReturn contains the return values from AttachVM. -// -// See the api.AttachVM and api.AttachVMResponse payloads. -type AttachVMReturn api.AttachVMResponse - -// AttachVM wraps the api.AttachVM payload. -// -// See the api.AttachVM payload description for more details. -func (client *Client) AttachVM(containerID string, options *AttachVMOptions) (*AttachVMReturn, error) { - payload := api.AttachVM{ - ContainerID: containerID, - } - - if options != nil { - payload.NumIOStreams = options.NumIOStreams - } - - resp, err := client.sendCommand(api.CmdAttachVM, &payload) - if err != nil { - return nil, err - } - - if err := errorFromResponse(resp); err != nil { - return nil, err - } - - decoded := AttachVMReturn{} - err = unmarshalResponse(resp, &decoded) - return &decoded, err -} - -// Hyper wraps the Hyper payload (see payload description for more details) -func (client *Client) Hyper(hyperName string, hyperMessage interface{}) ([]byte, error) { - return client.HyperWithTokens(hyperName, nil, hyperMessage) -} - -// HyperWithTokens is a Hyper variant where the users can specify a list of I/O tokens. -// -// See the api.Hyper payload description for more details. -func (client *Client) HyperWithTokens(hyperName string, tokens []string, hyperMessage interface{}) ([]byte, error) { - var data []byte - - if hyperMessage != nil { - var err error - - data, err = json.Marshal(hyperMessage) - if err != nil { - return nil, err - } - } - - hyper := api.Hyper{ - HyperName: hyperName, - Data: data, - } - - if tokens != nil { - hyper.Tokens = tokens - } - - resp, err := client.sendCommand(api.CmdHyper, &hyper) - if err != nil { - return nil, err - } - - if err = errorFromResponse(resp); err != nil { - return nil, err - } - - return resp.Payload, errorFromResponse(resp) -} - -// UnregisterVM wraps the api.UnregisterVM payload. -// -// See the api.UnregisterVM payload description for more details. -func (client *Client) UnregisterVM(containerID string) error { - payload := api.UnregisterVM{ - ContainerID: containerID, - } - - resp, err := client.sendCommand(api.CmdUnregisterVM, &payload) - if err != nil { - return err - } - - return errorFromResponse(resp) -} - -// ConnectShim wraps the api.CmdConnectShim command and associated -// api.ConnectShim payload. -func (client *Client) ConnectShim(token string) error { - payload := api.ConnectShim{ - Token: token, - } - - resp, err := client.sendCommand(api.CmdConnectShim, &payload) - if err != nil { - return err - } - - return errorFromResponse(resp) -} - -// DisconnectShim wraps the api.CmdDisconnectShim command and associated -// api.DisconnectShim payload. -func (client *Client) DisconnectShim() error { - return client.sendCommandNoResponse(api.CmdDisconnectShim, nil) -} - -func (client *Client) signal(signal syscall.Signal, columns, rows int) error { - payload := api.Signal{ - SignalNumber: int(signal), - Columns: columns, - Rows: rows, - } - - resp, err := client.sendCommand(api.CmdSignal, &payload) - if err != nil { - return err - } - - return errorFromResponse(resp) -} - -// Kill wraps the api.CmdSignal command and can be used by a shim to send a -// signal to the associated process. -func (client *Client) Kill(signal syscall.Signal) error { - return client.signal(signal, 0, 0) -} - -// SendTerminalSize wraps the api.CmdSignal command and can be used by a shim -// to send a new signal to the associated process. -func (client *Client) SendTerminalSize(columns, rows int) error { - return client.signal(syscall.SIGWINCH, columns, rows) -} - -func (client *Client) sendStream(op api.Stream, data []byte) error { - return api.WriteStream(client.conn, op, data) -} - -// SendStdin sends stdin data. This can only be used from shim clients. -func (client *Client) SendStdin(data []byte) error { - return client.sendStream(api.StreamStdin, data) -} - -// LogLevel is the severity of log entries. -type LogLevel uint8 - -const ( - // LogLevelDebug is for log messages only useful debugging. - LogLevelDebug LogLevel = iota - // LogLevelInfo is for reporting landmark events. - LogLevelInfo - // LogLevelWarn is for reporting warnings. - LogLevelWarn - // LogLevelError is for reporting errors. - LogLevelError - - logLevelMax -) - -var levelToString = []string{"debug", "info", "warn", "error"} - -// String implements stringer for LogLevel. -func (l LogLevel) String() string { - if l < logLevelMax { - return levelToString[l] - } - - return "unknown" -} - -// LogSource is the source of log entries -type LogSource uint8 - -const ( - // LogSourceRuntime represents a runtime. - LogSourceRuntime LogSource = iota - // LogSourceShim represents a shim. - LogSourceShim - - logSourceMax -) - -var sourceToString = []string{"runtime", "shim"} - -// String implements stringer for LogSource -func (s LogSource) String() string { - if s < logSourceMax { - return sourceToString[s] - } - - return "unknown" -} - -// Log sends log entries. -func (client *Client) Log(level LogLevel, source LogSource, containerID string, args ...interface{}) { - payload := api.LogEntry{ - Level: level.String(), - Source: source.String(), - ContainerID: containerID, - Message: fmt.Sprint(args...), - } - - data, _ := json.Marshal(&payload) - _ = client.sendStream(api.StreamLog, data) -} - -// Logf sends log entries. -func (client *Client) Logf(level LogLevel, source LogSource, containerID string, format string, args ...interface{}) { - payload := api.LogEntry{ - Level: level.String(), - Source: source.String(), - ContainerID: containerID, - Message: fmt.Sprintf(format, args...), - } - - data, _ := json.Marshal(&payload) - _ = client.sendStream(api.StreamLog, data) -} diff --git a/vendor/github.com/kata-containers/agent/protocols/grpc/agent.pb.go b/vendor/github.com/kata-containers/agent/protocols/grpc/agent.pb.go index c617fa60b1..ee57ad0759 100644 --- a/vendor/github.com/kata-containers/agent/protocols/grpc/agent.pb.go +++ b/vendor/github.com/kata-containers/agent/protocols/grpc/agent.pb.go @@ -45,8 +45,6 @@ Interfaces Routes UpdateInterfaceRequest - AddInterfaceRequest - RemoveInterfaceRequest UpdateRoutesRequest ListInterfacesRequest ListRoutesRequest @@ -61,6 +59,8 @@ Device StringUser CopyFileRequest + StartTracingRequest + StopTracingRequest CheckRequest HealthCheckResponse VersionCheckResponse @@ -1176,38 +1176,6 @@ func (m *UpdateInterfaceRequest) GetInterface() *types.Interface { return nil } -type AddInterfaceRequest struct { - Interface *types.Interface `protobuf:"bytes,1,opt,name=interface" json:"interface,omitempty"` -} - -func (m *AddInterfaceRequest) Reset() { *m = AddInterfaceRequest{} } -func (m *AddInterfaceRequest) String() string { return proto.CompactTextString(m) } -func (*AddInterfaceRequest) ProtoMessage() {} -func (*AddInterfaceRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{35} } - -func (m *AddInterfaceRequest) GetInterface() *types.Interface { - if m != nil { - return m.Interface - } - return nil -} - -type RemoveInterfaceRequest struct { - Interface *types.Interface `protobuf:"bytes,1,opt,name=interface" json:"interface,omitempty"` -} - -func (m *RemoveInterfaceRequest) Reset() { *m = RemoveInterfaceRequest{} } -func (m *RemoveInterfaceRequest) String() string { return proto.CompactTextString(m) } -func (*RemoveInterfaceRequest) ProtoMessage() {} -func (*RemoveInterfaceRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{36} } - -func (m *RemoveInterfaceRequest) GetInterface() *types.Interface { - if m != nil { - return m.Interface - } - return nil -} - type UpdateRoutesRequest struct { Routes *Routes `protobuf:"bytes,1,opt,name=routes" json:"routes,omitempty"` } @@ -1215,7 +1183,7 @@ type UpdateRoutesRequest struct { func (m *UpdateRoutesRequest) Reset() { *m = UpdateRoutesRequest{} } func (m *UpdateRoutesRequest) String() string { return proto.CompactTextString(m) } func (*UpdateRoutesRequest) ProtoMessage() {} -func (*UpdateRoutesRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{37} } +func (*UpdateRoutesRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{35} } func (m *UpdateRoutesRequest) GetRoutes() *Routes { if m != nil { @@ -1230,7 +1198,7 @@ type ListInterfacesRequest struct { func (m *ListInterfacesRequest) Reset() { *m = ListInterfacesRequest{} } func (m *ListInterfacesRequest) String() string { return proto.CompactTextString(m) } func (*ListInterfacesRequest) ProtoMessage() {} -func (*ListInterfacesRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{38} } +func (*ListInterfacesRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{36} } type ListRoutesRequest struct { } @@ -1238,7 +1206,7 @@ type ListRoutesRequest struct { func (m *ListRoutesRequest) Reset() { *m = ListRoutesRequest{} } func (m *ListRoutesRequest) String() string { return proto.CompactTextString(m) } func (*ListRoutesRequest) ProtoMessage() {} -func (*ListRoutesRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{39} } +func (*ListRoutesRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{37} } type OnlineCPUMemRequest struct { // Wait specifies if the caller waits for the agent to online all resources. @@ -1254,7 +1222,7 @@ type OnlineCPUMemRequest struct { func (m *OnlineCPUMemRequest) Reset() { *m = OnlineCPUMemRequest{} } func (m *OnlineCPUMemRequest) String() string { return proto.CompactTextString(m) } func (*OnlineCPUMemRequest) ProtoMessage() {} -func (*OnlineCPUMemRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{40} } +func (*OnlineCPUMemRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{38} } func (m *OnlineCPUMemRequest) GetWait() bool { if m != nil { @@ -1285,7 +1253,7 @@ type ReseedRandomDevRequest struct { func (m *ReseedRandomDevRequest) Reset() { *m = ReseedRandomDevRequest{} } func (m *ReseedRandomDevRequest) String() string { return proto.CompactTextString(m) } func (*ReseedRandomDevRequest) ProtoMessage() {} -func (*ReseedRandomDevRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{41} } +func (*ReseedRandomDevRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{39} } func (m *ReseedRandomDevRequest) GetData() []byte { if m != nil { @@ -1312,7 +1280,7 @@ type AgentDetails struct { func (m *AgentDetails) Reset() { *m = AgentDetails{} } func (m *AgentDetails) String() string { return proto.CompactTextString(m) } func (*AgentDetails) ProtoMessage() {} -func (*AgentDetails) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{42} } +func (*AgentDetails) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{40} } func (m *AgentDetails) GetVersion() string { if m != nil { @@ -1363,7 +1331,7 @@ type GuestDetailsRequest struct { func (m *GuestDetailsRequest) Reset() { *m = GuestDetailsRequest{} } func (m *GuestDetailsRequest) String() string { return proto.CompactTextString(m) } func (*GuestDetailsRequest) ProtoMessage() {} -func (*GuestDetailsRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{43} } +func (*GuestDetailsRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{41} } func (m *GuestDetailsRequest) GetMemBlockSize() bool { if m != nil { @@ -1389,7 +1357,7 @@ type GuestDetailsResponse struct { func (m *GuestDetailsResponse) Reset() { *m = GuestDetailsResponse{} } func (m *GuestDetailsResponse) String() string { return proto.CompactTextString(m) } func (*GuestDetailsResponse) ProtoMessage() {} -func (*GuestDetailsResponse) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{44} } +func (*GuestDetailsResponse) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{42} } func (m *GuestDetailsResponse) GetMemBlockSizeBytes() uint64 { if m != nil { @@ -1421,7 +1389,7 @@ type MemHotplugByProbeRequest struct { func (m *MemHotplugByProbeRequest) Reset() { *m = MemHotplugByProbeRequest{} } func (m *MemHotplugByProbeRequest) String() string { return proto.CompactTextString(m) } func (*MemHotplugByProbeRequest) ProtoMessage() {} -func (*MemHotplugByProbeRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{45} } +func (*MemHotplugByProbeRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{43} } func (m *MemHotplugByProbeRequest) GetMemHotplugProbeAddr() []uint64 { if m != nil { @@ -1440,7 +1408,7 @@ type SetGuestDateTimeRequest struct { func (m *SetGuestDateTimeRequest) Reset() { *m = SetGuestDateTimeRequest{} } func (m *SetGuestDateTimeRequest) String() string { return proto.CompactTextString(m) } func (*SetGuestDateTimeRequest) ProtoMessage() {} -func (*SetGuestDateTimeRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{46} } +func (*SetGuestDateTimeRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{44} } func (m *SetGuestDateTimeRequest) GetSec() int64 { if m != nil { @@ -1489,7 +1457,7 @@ type Storage struct { func (m *Storage) Reset() { *m = Storage{} } func (m *Storage) String() string { return proto.CompactTextString(m) } func (*Storage) ProtoMessage() {} -func (*Storage) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{47} } +func (*Storage) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{45} } func (m *Storage) GetDriver() string { if m != nil { @@ -1572,7 +1540,7 @@ type Device struct { func (m *Device) Reset() { *m = Device{} } func (m *Device) String() string { return proto.CompactTextString(m) } func (*Device) ProtoMessage() {} -func (*Device) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{48} } +func (*Device) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{46} } func (m *Device) GetId() string { if m != nil { @@ -1618,7 +1586,7 @@ type StringUser struct { func (m *StringUser) Reset() { *m = StringUser{} } func (m *StringUser) String() string { return proto.CompactTextString(m) } func (*StringUser) ProtoMessage() {} -func (*StringUser) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{49} } +func (*StringUser) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{47} } func (m *StringUser) GetUid() string { if m != nil { @@ -1666,7 +1634,7 @@ type CopyFileRequest struct { func (m *CopyFileRequest) Reset() { *m = CopyFileRequest{} } func (m *CopyFileRequest) String() string { return proto.CompactTextString(m) } func (*CopyFileRequest) ProtoMessage() {} -func (*CopyFileRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{50} } +func (*CopyFileRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{48} } func (m *CopyFileRequest) GetPath() string { if m != nil { @@ -1724,6 +1692,22 @@ func (m *CopyFileRequest) GetData() []byte { return nil } +type StartTracingRequest struct { +} + +func (m *StartTracingRequest) Reset() { *m = StartTracingRequest{} } +func (m *StartTracingRequest) String() string { return proto.CompactTextString(m) } +func (*StartTracingRequest) ProtoMessage() {} +func (*StartTracingRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{49} } + +type StopTracingRequest struct { +} + +func (m *StopTracingRequest) Reset() { *m = StopTracingRequest{} } +func (m *StopTracingRequest) String() string { return proto.CompactTextString(m) } +func (*StopTracingRequest) ProtoMessage() {} +func (*StopTracingRequest) Descriptor() ([]byte, []int) { return fileDescriptorAgent, []int{50} } + func init() { proto.RegisterType((*CreateContainerRequest)(nil), "grpc.CreateContainerRequest") proto.RegisterType((*StartContainerRequest)(nil), "grpc.StartContainerRequest") @@ -1760,8 +1744,6 @@ func init() { proto.RegisterType((*Interfaces)(nil), "grpc.Interfaces") proto.RegisterType((*Routes)(nil), "grpc.Routes") proto.RegisterType((*UpdateInterfaceRequest)(nil), "grpc.UpdateInterfaceRequest") - proto.RegisterType((*AddInterfaceRequest)(nil), "grpc.AddInterfaceRequest") - proto.RegisterType((*RemoveInterfaceRequest)(nil), "grpc.RemoveInterfaceRequest") proto.RegisterType((*UpdateRoutesRequest)(nil), "grpc.UpdateRoutesRequest") proto.RegisterType((*ListInterfacesRequest)(nil), "grpc.ListInterfacesRequest") proto.RegisterType((*ListRoutesRequest)(nil), "grpc.ListRoutesRequest") @@ -1776,6 +1758,8 @@ func init() { proto.RegisterType((*Device)(nil), "grpc.Device") proto.RegisterType((*StringUser)(nil), "grpc.StringUser") proto.RegisterType((*CopyFileRequest)(nil), "grpc.CopyFileRequest") + proto.RegisterType((*StartTracingRequest)(nil), "grpc.StartTracingRequest") + proto.RegisterType((*StopTracingRequest)(nil), "grpc.StopTracingRequest") } // Reference imports to suppress errors if they are not otherwise used. @@ -1814,12 +1798,13 @@ type AgentServiceClient interface { CloseStdin(ctx context.Context, in *CloseStdinRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error) TtyWinResize(ctx context.Context, in *TtyWinResizeRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error) // networking - AddInterface(ctx context.Context, in *AddInterfaceRequest, opts ...grpc1.CallOption) (*types.Interface, error) UpdateInterface(ctx context.Context, in *UpdateInterfaceRequest, opts ...grpc1.CallOption) (*types.Interface, error) - RemoveInterface(ctx context.Context, in *RemoveInterfaceRequest, opts ...grpc1.CallOption) (*types.Interface, error) UpdateRoutes(ctx context.Context, in *UpdateRoutesRequest, opts ...grpc1.CallOption) (*Routes, error) ListInterfaces(ctx context.Context, in *ListInterfacesRequest, opts ...grpc1.CallOption) (*Interfaces, error) ListRoutes(ctx context.Context, in *ListRoutesRequest, opts ...grpc1.CallOption) (*Routes, error) + // tracing + StartTracing(ctx context.Context, in *StartTracingRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error) + StopTracing(ctx context.Context, in *StopTracingRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error) // misc (TODO: some rpcs can be replaced by hyperstart-exec) CreateSandbox(ctx context.Context, in *CreateSandboxRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error) DestroySandbox(ctx context.Context, in *DestroySandboxRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error) @@ -1983,15 +1968,6 @@ func (c *agentServiceClient) TtyWinResize(ctx context.Context, in *TtyWinResizeR return out, nil } -func (c *agentServiceClient) AddInterface(ctx context.Context, in *AddInterfaceRequest, opts ...grpc1.CallOption) (*types.Interface, error) { - out := new(types.Interface) - err := grpc1.Invoke(ctx, "/grpc.AgentService/AddInterface", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - func (c *agentServiceClient) UpdateInterface(ctx context.Context, in *UpdateInterfaceRequest, opts ...grpc1.CallOption) (*types.Interface, error) { out := new(types.Interface) err := grpc1.Invoke(ctx, "/grpc.AgentService/UpdateInterface", in, out, c.cc, opts...) @@ -2001,15 +1977,6 @@ func (c *agentServiceClient) UpdateInterface(ctx context.Context, in *UpdateInte return out, nil } -func (c *agentServiceClient) RemoveInterface(ctx context.Context, in *RemoveInterfaceRequest, opts ...grpc1.CallOption) (*types.Interface, error) { - out := new(types.Interface) - err := grpc1.Invoke(ctx, "/grpc.AgentService/RemoveInterface", in, out, c.cc, opts...) - if err != nil { - return nil, err - } - return out, nil -} - func (c *agentServiceClient) UpdateRoutes(ctx context.Context, in *UpdateRoutesRequest, opts ...grpc1.CallOption) (*Routes, error) { out := new(Routes) err := grpc1.Invoke(ctx, "/grpc.AgentService/UpdateRoutes", in, out, c.cc, opts...) @@ -2037,6 +2004,24 @@ func (c *agentServiceClient) ListRoutes(ctx context.Context, in *ListRoutesReque return out, nil } +func (c *agentServiceClient) StartTracing(ctx context.Context, in *StartTracingRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error) { + out := new(google_protobuf2.Empty) + err := grpc1.Invoke(ctx, "/grpc.AgentService/StartTracing", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *agentServiceClient) StopTracing(ctx context.Context, in *StopTracingRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error) { + out := new(google_protobuf2.Empty) + err := grpc1.Invoke(ctx, "/grpc.AgentService/StopTracing", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *agentServiceClient) CreateSandbox(ctx context.Context, in *CreateSandboxRequest, opts ...grpc1.CallOption) (*google_protobuf2.Empty, error) { out := new(google_protobuf2.Empty) err := grpc1.Invoke(ctx, "/grpc.AgentService/CreateSandbox", in, out, c.cc, opts...) @@ -2137,12 +2122,13 @@ type AgentServiceServer interface { CloseStdin(context.Context, *CloseStdinRequest) (*google_protobuf2.Empty, error) TtyWinResize(context.Context, *TtyWinResizeRequest) (*google_protobuf2.Empty, error) // networking - AddInterface(context.Context, *AddInterfaceRequest) (*types.Interface, error) UpdateInterface(context.Context, *UpdateInterfaceRequest) (*types.Interface, error) - RemoveInterface(context.Context, *RemoveInterfaceRequest) (*types.Interface, error) UpdateRoutes(context.Context, *UpdateRoutesRequest) (*Routes, error) ListInterfaces(context.Context, *ListInterfacesRequest) (*Interfaces, error) ListRoutes(context.Context, *ListRoutesRequest) (*Routes, error) + // tracing + StartTracing(context.Context, *StartTracingRequest) (*google_protobuf2.Empty, error) + StopTracing(context.Context, *StopTracingRequest) (*google_protobuf2.Empty, error) // misc (TODO: some rpcs can be replaced by hyperstart-exec) CreateSandbox(context.Context, *CreateSandboxRequest) (*google_protobuf2.Empty, error) DestroySandbox(context.Context, *DestroySandboxRequest) (*google_protobuf2.Empty, error) @@ -2446,24 +2432,6 @@ func _AgentService_TtyWinResize_Handler(srv interface{}, ctx context.Context, de return interceptor(ctx, in, info, handler) } -func _AgentService_AddInterface_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) { - in := new(AddInterfaceRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(AgentServiceServer).AddInterface(ctx, in) - } - info := &grpc1.UnaryServerInfo{ - Server: srv, - FullMethod: "/grpc.AgentService/AddInterface", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(AgentServiceServer).AddInterface(ctx, req.(*AddInterfaceRequest)) - } - return interceptor(ctx, in, info, handler) -} - func _AgentService_UpdateInterface_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) { in := new(UpdateInterfaceRequest) if err := dec(in); err != nil { @@ -2482,24 +2450,6 @@ func _AgentService_UpdateInterface_Handler(srv interface{}, ctx context.Context, return interceptor(ctx, in, info, handler) } -func _AgentService_RemoveInterface_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) { - in := new(RemoveInterfaceRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(AgentServiceServer).RemoveInterface(ctx, in) - } - info := &grpc1.UnaryServerInfo{ - Server: srv, - FullMethod: "/grpc.AgentService/RemoveInterface", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(AgentServiceServer).RemoveInterface(ctx, req.(*RemoveInterfaceRequest)) - } - return interceptor(ctx, in, info, handler) -} - func _AgentService_UpdateRoutes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) { in := new(UpdateRoutesRequest) if err := dec(in); err != nil { @@ -2554,6 +2504,42 @@ func _AgentService_ListRoutes_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +func _AgentService_StartTracing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) { + in := new(StartTracingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AgentServiceServer).StartTracing(ctx, in) + } + info := &grpc1.UnaryServerInfo{ + Server: srv, + FullMethod: "/grpc.AgentService/StartTracing", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AgentServiceServer).StartTracing(ctx, req.(*StartTracingRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AgentService_StopTracing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) { + in := new(StopTracingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AgentServiceServer).StopTracing(ctx, in) + } + info := &grpc1.UnaryServerInfo{ + Server: srv, + FullMethod: "/grpc.AgentService/StopTracing", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AgentServiceServer).StopTracing(ctx, req.(*StopTracingRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _AgentService_CreateSandbox_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) { in := new(CreateSandboxRequest) if err := dec(in); err != nil { @@ -2766,18 +2752,10 @@ var _AgentService_serviceDesc = grpc1.ServiceDesc{ MethodName: "TtyWinResize", Handler: _AgentService_TtyWinResize_Handler, }, - { - MethodName: "AddInterface", - Handler: _AgentService_AddInterface_Handler, - }, { MethodName: "UpdateInterface", Handler: _AgentService_UpdateInterface_Handler, }, - { - MethodName: "RemoveInterface", - Handler: _AgentService_RemoveInterface_Handler, - }, { MethodName: "UpdateRoutes", Handler: _AgentService_UpdateRoutes_Handler, @@ -2790,6 +2768,14 @@ var _AgentService_serviceDesc = grpc1.ServiceDesc{ MethodName: "ListRoutes", Handler: _AgentService_ListRoutes_Handler, }, + { + MethodName: "StartTracing", + Handler: _AgentService_StartTracing_Handler, + }, + { + MethodName: "StopTracing", + Handler: _AgentService_StopTracing_Handler, + }, { MethodName: "CreateSandbox", Handler: _AgentService_CreateSandbox_Handler, @@ -4210,62 +4196,6 @@ func (m *UpdateInterfaceRequest) MarshalTo(dAtA []byte) (int, error) { return i, nil } -func (m *AddInterfaceRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *AddInterfaceRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if m.Interface != nil { - dAtA[i] = 0xa - i++ - i = encodeVarintAgent(dAtA, i, uint64(m.Interface.Size())) - n20, err := m.Interface.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n20 - } - return i, nil -} - -func (m *RemoveInterfaceRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *RemoveInterfaceRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if m.Interface != nil { - dAtA[i] = 0xa - i++ - i = encodeVarintAgent(dAtA, i, uint64(m.Interface.Size())) - n21, err := m.Interface.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n21 - } - return i, nil -} - func (m *UpdateRoutesRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -4285,11 +4215,11 @@ func (m *UpdateRoutesRequest) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintAgent(dAtA, i, uint64(m.Routes.Size())) - n22, err := m.Routes.MarshalTo(dAtA[i:]) + n20, err := m.Routes.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n22 + i += n20 } return i, nil } @@ -4533,11 +4463,11 @@ func (m *GuestDetailsResponse) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintAgent(dAtA, i, uint64(m.AgentDetails.Size())) - n23, err := m.AgentDetails.MarshalTo(dAtA[i:]) + n21, err := m.AgentDetails.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n23 + i += n21 } if m.SupportMemHotplugProbe { dAtA[i] = 0x18 @@ -4568,21 +4498,21 @@ func (m *MemHotplugByProbeRequest) MarshalTo(dAtA []byte) (int, error) { var l int _ = l if len(m.MemHotplugProbeAddr) > 0 { - dAtA25 := make([]byte, len(m.MemHotplugProbeAddr)*10) - var j24 int + dAtA23 := make([]byte, len(m.MemHotplugProbeAddr)*10) + var j22 int for _, num := range m.MemHotplugProbeAddr { for num >= 1<<7 { - dAtA25[j24] = uint8(uint64(num)&0x7f | 0x80) + dAtA23[j22] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j24++ + j22++ } - dAtA25[j24] = uint8(num) - j24++ + dAtA23[j22] = uint8(num) + j22++ } dAtA[i] = 0xa i++ - i = encodeVarintAgent(dAtA, i, uint64(j24)) - i += copy(dAtA[i:], dAtA25[:j24]) + i = encodeVarintAgent(dAtA, i, uint64(j22)) + i += copy(dAtA[i:], dAtA23[:j22]) } return i, nil } @@ -4849,6 +4779,42 @@ func (m *CopyFileRequest) MarshalTo(dAtA []byte) (int, error) { return i, nil } +func (m *StartTracingRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StartTracingRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *StopTracingRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StopTracingRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + func encodeVarintAgent(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -5461,26 +5427,6 @@ func (m *UpdateInterfaceRequest) Size() (n int) { return n } -func (m *AddInterfaceRequest) Size() (n int) { - var l int - _ = l - if m.Interface != nil { - l = m.Interface.Size() - n += 1 + l + sovAgent(uint64(l)) - } - return n -} - -func (m *RemoveInterfaceRequest) Size() (n int) { - var l int - _ = l - if m.Interface != nil { - l = m.Interface.Size() - n += 1 + l + sovAgent(uint64(l)) - } - return n -} - func (m *UpdateRoutesRequest) Size() (n int) { var l int _ = l @@ -5723,6 +5669,18 @@ func (m *CopyFileRequest) Size() (n int) { return n } +func (m *StartTracingRequest) Size() (n int) { + var l int + _ = l + return n +} + +func (m *StopTracingRequest) Size() (n int) { + var l int + _ = l + return n +} + func sovAgent(x uint64) (n int) { for { n++ @@ -10226,172 +10184,6 @@ func (m *UpdateInterfaceRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *AddInterfaceRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAgent - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: AddInterfaceRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AddInterfaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Interface", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAgent - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthAgent - } - postIndex := iNdEx + msglen - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Interface == nil { - m.Interface = &types.Interface{} - } - if err := m.Interface.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipAgent(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthAgent - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *RemoveInterfaceRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAgent - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: RemoveInterfaceRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RemoveInterfaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Interface", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAgent - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthAgent - } - postIndex := iNdEx + msglen - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Interface == nil { - m.Interface = &types.Interface{} - } - if err := m.Interface.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipAgent(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthAgent - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func (m *UpdateRoutesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -12134,6 +11926,106 @@ func (m *CopyFileRequest) Unmarshal(dAtA []byte) error { } return nil } +func (m *StartTracingRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAgent + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StartTracingRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StartTracingRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipAgent(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthAgent + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StopTracingRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAgent + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StopTracingRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StopTracingRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipAgent(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthAgent + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipAgent(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 @@ -12242,173 +12134,173 @@ var ( func init() { proto.RegisterFile("agent.proto", fileDescriptorAgent) } var fileDescriptorAgent = []byte{ - // 2675 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x19, 0xdb, 0x6e, 0x1b, 0xc7, - 0x15, 0xbc, 0x88, 0x22, 0x0f, 0x49, 0x51, 0x1c, 0xc9, 0x32, 0x4d, 0x27, 0xae, 0xb3, 0x49, 0x1d, - 0xa5, 0x69, 0xa8, 0xc4, 0x09, 0x9a, 0x8b, 0x91, 0x1a, 0x96, 0xac, 0x5a, 0x6a, 0xe2, 0x5a, 0x5d, - 0x45, 0x48, 0x81, 0xa2, 0x58, 0xac, 0x76, 0x47, 0xe4, 0x44, 0xdc, 0x9d, 0xcd, 0xce, 0xac, 0x6c, - 0xa6, 0x40, 0x1f, 0xfb, 0xda, 0x2f, 0xe8, 0x0f, 0x14, 0x7d, 0xeb, 0x63, 0x5f, 0xfb, 0x10, 0xf4, - 0xa9, 0xef, 0x05, 0x8a, 0x22, 0x9f, 0xd0, 0x2f, 0x28, 0xe6, 0xb6, 0x17, 0x72, 0xa9, 0xa4, 0x8a, - 0x80, 0xbe, 0x10, 0x73, 0x2e, 0x73, 0x6e, 0x33, 0x73, 0xf6, 0x9c, 0x43, 0x68, 0xbb, 0x63, 0x1c, - 0xf2, 0x51, 0x14, 0x53, 0x4e, 0x51, 0x7d, 0x1c, 0x47, 0xde, 0xb0, 0x45, 0x3d, 0xa2, 0x10, 0xc3, - 0x9f, 0x8c, 0x09, 0x9f, 0x24, 0xa7, 0x23, 0x8f, 0x06, 0x3b, 0xe7, 0x2e, 0x77, 0xdf, 0xf2, 0x68, - 0xc8, 0x5d, 0x12, 0xe2, 0x98, 0xed, 0xc8, 0x8d, 0x3b, 0xd1, 0xf9, 0x78, 0x87, 0xcf, 0x22, 0xcc, - 0xd4, 0xaf, 0xde, 0x77, 0x7b, 0x4c, 0xe9, 0x78, 0x8a, 0x77, 0x24, 0x74, 0x9a, 0x9c, 0xed, 0xe0, - 0x20, 0xe2, 0x33, 0x45, 0xb4, 0xfe, 0x58, 0x85, 0xad, 0xbd, 0x18, 0xbb, 0x1c, 0xef, 0x19, 0x69, - 0x36, 0xfe, 0x32, 0xc1, 0x8c, 0xa3, 0x57, 0xa0, 0x93, 0x6a, 0x70, 0x88, 0x3f, 0xa8, 0xdc, 0xad, - 0x6c, 0xb7, 0xec, 0x76, 0x8a, 0x3b, 0xf4, 0xd1, 0x4d, 0x58, 0xc5, 0x2f, 0xb0, 0x27, 0xa8, 0x55, - 0x49, 0x6d, 0x08, 0xf0, 0xd0, 0x47, 0xef, 0x40, 0x9b, 0xf1, 0x98, 0x84, 0x63, 0x27, 0x61, 0x38, - 0x1e, 0xd4, 0xee, 0x56, 0xb6, 0xdb, 0xf7, 0xd7, 0x47, 0xc2, 0xa5, 0xd1, 0xb1, 0x24, 0x9c, 0x30, - 0x1c, 0xdb, 0xc0, 0xd2, 0x35, 0xba, 0x07, 0xab, 0x3e, 0xbe, 0x20, 0x1e, 0x66, 0x83, 0xfa, 0xdd, - 0xda, 0x76, 0xfb, 0x7e, 0x47, 0xb1, 0x3f, 0x96, 0x48, 0xdb, 0x10, 0xd1, 0x1b, 0xd0, 0x64, 0x9c, - 0xc6, 0xee, 0x18, 0xb3, 0xc1, 0x8a, 0x64, 0xec, 0x1a, 0xb9, 0x12, 0x6b, 0xa7, 0x64, 0xf4, 0x12, - 0xd4, 0x9e, 0xed, 0x1d, 0x0e, 0x1a, 0x52, 0x3b, 0x68, 0xae, 0x08, 0x7b, 0xb6, 0x40, 0xa3, 0x57, - 0xa1, 0xcb, 0xdc, 0xd0, 0x3f, 0xa5, 0x2f, 0x9c, 0x88, 0xf8, 0x21, 0x1b, 0xac, 0xde, 0xad, 0x6c, - 0x37, 0xed, 0x8e, 0x46, 0x1e, 0x09, 0x9c, 0xf5, 0x11, 0xdc, 0x38, 0xe6, 0x6e, 0xcc, 0xaf, 0x10, - 0x1d, 0xeb, 0x04, 0xb6, 0x6c, 0x1c, 0xd0, 0x8b, 0x2b, 0x85, 0x76, 0x00, 0xab, 0x9c, 0x04, 0x98, - 0x26, 0x5c, 0x86, 0xb6, 0x6b, 0x1b, 0xd0, 0xfa, 0x73, 0x05, 0xd0, 0xfe, 0x0b, 0xec, 0x1d, 0xc5, - 0xd4, 0xc3, 0x8c, 0xfd, 0x9f, 0x8e, 0xeb, 0x75, 0x58, 0x8d, 0x94, 0x01, 0x83, 0xba, 0x64, 0xd7, - 0xa7, 0x60, 0xac, 0x32, 0x54, 0xeb, 0x0b, 0xd8, 0x3c, 0x26, 0xe3, 0xd0, 0x9d, 0x5e, 0xa3, 0xbd, - 0x5b, 0xd0, 0x60, 0x52, 0xa6, 0x34, 0xb5, 0x6b, 0x6b, 0xc8, 0x3a, 0x02, 0xf4, 0xb9, 0x4b, 0xf8, - 0xf5, 0x69, 0xb2, 0xde, 0x82, 0x8d, 0x82, 0x44, 0x16, 0xd1, 0x90, 0x61, 0x69, 0x00, 0x77, 0x79, - 0xc2, 0xa4, 0xb0, 0x15, 0x5b, 0x43, 0x16, 0x86, 0xcd, 0x4f, 0x09, 0x33, 0xec, 0xf8, 0x7f, 0x31, - 0x61, 0x0b, 0x1a, 0x67, 0x34, 0x0e, 0x5c, 0x6e, 0x2c, 0x50, 0x10, 0x42, 0x50, 0x77, 0xe3, 0x31, - 0x1b, 0xd4, 0xee, 0xd6, 0xb6, 0x5b, 0xb6, 0x5c, 0x8b, 0x5b, 0x39, 0xa7, 0x46, 0xdb, 0xf5, 0x0a, - 0x74, 0x74, 0xdc, 0x9d, 0x29, 0x61, 0x5c, 0xea, 0xe9, 0xd8, 0x6d, 0x8d, 0x13, 0x7b, 0x2c, 0x0a, - 0x5b, 0x27, 0x91, 0x7f, 0xc5, 0x07, 0x7f, 0x1f, 0x5a, 0x31, 0x66, 0x34, 0x89, 0xc5, 0x33, 0xad, - 0xca, 0x73, 0xdf, 0x54, 0xe7, 0xfe, 0x29, 0x09, 0x93, 0x17, 0xb6, 0xa1, 0xd9, 0x19, 0x9b, 0x7e, - 0x42, 0x9c, 0x5d, 0xe5, 0x09, 0x7d, 0x04, 0x37, 0x8e, 0xdc, 0x84, 0x5d, 0xc5, 0x56, 0xeb, 0x81, - 0x78, 0x7e, 0x2c, 0x09, 0xae, 0xb4, 0xf9, 0x4f, 0x15, 0x68, 0xee, 0x45, 0xc9, 0x09, 0x73, 0xc7, - 0x18, 0xfd, 0x00, 0xda, 0x9c, 0x72, 0x77, 0xea, 0x24, 0x02, 0x94, 0xec, 0x75, 0x1b, 0x24, 0x4a, - 0x31, 0x88, 0xb0, 0xe3, 0xd8, 0x8b, 0x12, 0xcd, 0x51, 0xbd, 0x5b, 0xdb, 0xae, 0xdb, 0x6d, 0x85, - 0x53, 0x2c, 0x23, 0xd8, 0x90, 0x34, 0x87, 0x84, 0xce, 0x39, 0x8e, 0x43, 0x3c, 0x0d, 0xa8, 0x8f, - 0xe5, 0xfd, 0xad, 0xdb, 0x7d, 0x49, 0x3a, 0x0c, 0x3f, 0x49, 0x09, 0xe8, 0x47, 0xd0, 0x4f, 0xf9, - 0xc5, 0xa3, 0x94, 0xdc, 0x75, 0xc9, 0xdd, 0xd3, 0xdc, 0x27, 0x1a, 0x6d, 0xfd, 0x0e, 0xd6, 0x3e, - 0x9b, 0xc4, 0x94, 0xf3, 0x29, 0x09, 0xc7, 0x8f, 0x5d, 0xee, 0x8a, 0xec, 0x11, 0xe1, 0x98, 0x50, - 0x9f, 0x69, 0x6b, 0x0d, 0x88, 0xde, 0x84, 0x3e, 0x57, 0xbc, 0xd8, 0x77, 0x0c, 0x4f, 0x55, 0xf2, - 0xac, 0xa7, 0x84, 0x23, 0xcd, 0xfc, 0x43, 0x58, 0xcb, 0x98, 0x45, 0xfe, 0xd1, 0xf6, 0x76, 0x53, - 0xec, 0x67, 0x24, 0xc0, 0xd6, 0x85, 0x8c, 0x95, 0x3c, 0x64, 0xf4, 0x26, 0xb4, 0xb2, 0x38, 0x54, - 0xe4, 0x0d, 0x59, 0x53, 0x37, 0xc4, 0x84, 0xd3, 0x6e, 0xa6, 0x41, 0xf9, 0x18, 0x7a, 0x3c, 0x35, - 0xdc, 0xf1, 0x5d, 0xee, 0x16, 0x2f, 0x55, 0xd1, 0x2b, 0x7b, 0x8d, 0x17, 0x60, 0xeb, 0x01, 0xb4, - 0x8e, 0x88, 0xcf, 0x94, 0xe2, 0x01, 0xac, 0x7a, 0x49, 0x1c, 0xe3, 0x90, 0x1b, 0x97, 0x35, 0x88, - 0x36, 0x61, 0x65, 0x4a, 0x02, 0xc2, 0xb5, 0x9b, 0x0a, 0xb0, 0x28, 0xc0, 0x53, 0x1c, 0xd0, 0x78, - 0x26, 0x03, 0xb6, 0x09, 0x2b, 0xf9, 0xc3, 0x55, 0x00, 0xba, 0x0d, 0xad, 0xc0, 0x7d, 0x91, 0x1e, - 0xaa, 0xa0, 0x34, 0x03, 0xf7, 0x85, 0x32, 0x7e, 0x00, 0xab, 0x67, 0x2e, 0x99, 0x7a, 0x21, 0xd7, - 0x51, 0x31, 0x60, 0xa6, 0xb0, 0x9e, 0x57, 0xf8, 0xb7, 0x2a, 0xb4, 0x95, 0x46, 0x65, 0xf0, 0x26, - 0xac, 0x78, 0xae, 0x37, 0x49, 0x55, 0x4a, 0x00, 0xdd, 0x33, 0x86, 0x54, 0xf3, 0x49, 0x38, 0xb3, - 0xd4, 0x98, 0xb6, 0x03, 0xc0, 0x9e, 0xbb, 0x91, 0xb6, 0xad, 0xb6, 0x84, 0xb9, 0x25, 0x78, 0x94, - 0xb9, 0xef, 0x42, 0x47, 0xdd, 0x3b, 0xbd, 0xa5, 0xbe, 0x64, 0x4b, 0x5b, 0x71, 0xa9, 0x4d, 0xaf, - 0x42, 0x37, 0x61, 0xd8, 0x99, 0x10, 0x1c, 0xbb, 0xb1, 0x37, 0x99, 0x0d, 0x56, 0xd4, 0x37, 0x32, - 0x61, 0xf8, 0xc0, 0xe0, 0xd0, 0x7d, 0x58, 0x11, 0xe9, 0x8f, 0x0d, 0x1a, 0xf2, 0x73, 0xfc, 0x52, - 0x5e, 0xa4, 0x74, 0x75, 0x24, 0x7f, 0xf7, 0x43, 0x1e, 0xcf, 0x6c, 0xc5, 0x3a, 0xfc, 0x00, 0x20, - 0x43, 0xa2, 0x75, 0xa8, 0x9d, 0xe3, 0x99, 0x7e, 0x87, 0x62, 0x29, 0x82, 0x73, 0xe1, 0x4e, 0x13, - 0x13, 0x75, 0x05, 0x7c, 0x54, 0xfd, 0xa0, 0x62, 0x79, 0xd0, 0xdb, 0x9d, 0x9e, 0x13, 0x9a, 0xdb, - 0xbe, 0x09, 0x2b, 0x81, 0xfb, 0x05, 0x8d, 0x4d, 0x24, 0x25, 0x20, 0xb1, 0x24, 0xa4, 0xb1, 0x11, - 0x21, 0x01, 0xb4, 0x06, 0x55, 0x1a, 0xc9, 0x78, 0xb5, 0xec, 0x2a, 0x8d, 0x32, 0x45, 0xf5, 0x9c, - 0x22, 0xeb, 0x5f, 0x75, 0x80, 0x4c, 0x0b, 0xb2, 0x61, 0x48, 0xa8, 0xc3, 0x70, 0x2c, 0x4a, 0x10, - 0xe7, 0x74, 0xc6, 0x31, 0x73, 0x62, 0xec, 0x25, 0x31, 0x23, 0x17, 0xe2, 0xfc, 0x84, 0xdb, 0x37, - 0x94, 0xdb, 0x73, 0xb6, 0xd9, 0x37, 0x09, 0x3d, 0x56, 0xfb, 0x76, 0xc5, 0x36, 0xdb, 0xec, 0x42, - 0x87, 0x70, 0x23, 0x93, 0xe9, 0xe7, 0xc4, 0x55, 0x2f, 0x13, 0xb7, 0x91, 0x8a, 0xf3, 0x33, 0x51, - 0xfb, 0xb0, 0x41, 0xa8, 0xf3, 0x65, 0x82, 0x93, 0x82, 0xa0, 0xda, 0x65, 0x82, 0xfa, 0x84, 0xfe, - 0x52, 0x6e, 0xc8, 0xc4, 0x1c, 0xc1, 0xad, 0x9c, 0x97, 0xe2, 0xb9, 0xe7, 0x84, 0xd5, 0x2f, 0x13, - 0xb6, 0x95, 0x5a, 0x25, 0xf2, 0x41, 0x26, 0xf1, 0xe7, 0xb0, 0x45, 0xa8, 0xf3, 0xdc, 0x25, 0x7c, - 0x5e, 0xdc, 0xca, 0xb7, 0x38, 0x29, 0x3e, 0xba, 0x45, 0x59, 0xca, 0xc9, 0x00, 0xc7, 0xe3, 0x82, - 0x93, 0x8d, 0x6f, 0x71, 0xf2, 0xa9, 0xdc, 0x90, 0x89, 0x79, 0x04, 0x7d, 0x42, 0xe7, 0xad, 0x59, - 0xbd, 0x4c, 0x48, 0x8f, 0xd0, 0xa2, 0x25, 0xbb, 0xd0, 0x67, 0xd8, 0xe3, 0x34, 0xce, 0x5f, 0x82, - 0xe6, 0x65, 0x22, 0xd6, 0x35, 0x7f, 0x2a, 0xc3, 0xfa, 0x35, 0x74, 0x0e, 0x92, 0x31, 0xe6, 0xd3, - 0xd3, 0x34, 0x19, 0x5c, 0x5b, 0xfe, 0xb1, 0xfe, 0x53, 0x85, 0xf6, 0xde, 0x38, 0xa6, 0x49, 0x54, - 0xc8, 0xc9, 0xea, 0x91, 0xce, 0xe7, 0x64, 0xc9, 0x22, 0x73, 0xb2, 0x62, 0x7e, 0x0f, 0x3a, 0x81, - 0x7c, 0xba, 0x9a, 0x5f, 0xe5, 0xa1, 0xfe, 0xc2, 0xa3, 0xb6, 0xdb, 0x41, 0x2e, 0x99, 0x8d, 0x00, - 0x22, 0xe2, 0x33, 0xbd, 0x47, 0xa5, 0xa3, 0x9e, 0xae, 0x08, 0x4d, 0x8a, 0xb6, 0x5b, 0x51, 0x9a, - 0xad, 0xdf, 0x81, 0xf6, 0xa9, 0x08, 0x92, 0xde, 0x50, 0x48, 0x46, 0x59, 0xf4, 0x6c, 0x38, 0xcd, - 0x1e, 0xe1, 0x01, 0x74, 0x27, 0x2a, 0x64, 0x7a, 0x93, 0xba, 0x43, 0xaf, 0x6a, 0x4f, 0x32, 0x7f, - 0x47, 0xf9, 0xc8, 0xaa, 0x03, 0xe8, 0x4c, 0x72, 0xa8, 0xe1, 0x31, 0xf4, 0x17, 0x58, 0x4a, 0x72, - 0xd0, 0x76, 0x3e, 0x07, 0xb5, 0xef, 0x23, 0xa5, 0x28, 0xbf, 0x33, 0x9f, 0x97, 0x7e, 0x01, 0x5b, - 0xf3, 0x65, 0x8e, 0x2e, 0xca, 0xde, 0x83, 0x8e, 0x27, 0xad, 0x2b, 0x9c, 0x40, 0x7f, 0xc1, 0x6e, - 0xbb, 0xed, 0x65, 0x80, 0xe5, 0x03, 0xfa, 0x3c, 0x26, 0x1c, 0x1f, 0xf3, 0x18, 0xbb, 0xc1, 0x75, - 0x54, 0xcd, 0x08, 0xea, 0xf2, 0x13, 0x5b, 0x93, 0x45, 0xa1, 0x5c, 0x5b, 0xaf, 0xc3, 0x46, 0x41, - 0x8b, 0x36, 0x79, 0x1d, 0x6a, 0x53, 0x1c, 0x4a, 0xe9, 0x5d, 0x5b, 0x2c, 0x2d, 0x17, 0xfa, 0x36, - 0x76, 0xfd, 0xeb, 0xb3, 0x46, 0xab, 0xa8, 0x65, 0x2a, 0xb6, 0x01, 0xe5, 0x55, 0x68, 0x53, 0x8c, - 0xd5, 0x95, 0x9c, 0xd5, 0xcf, 0xa0, 0xbf, 0x37, 0xa5, 0x0c, 0x1f, 0x73, 0x9f, 0x84, 0xd7, 0x51, - 0xe6, 0xff, 0x16, 0x36, 0x3e, 0xe3, 0xb3, 0xcf, 0x85, 0x30, 0x46, 0xbe, 0xc2, 0xd7, 0xe4, 0x5f, - 0x4c, 0x9f, 0x1b, 0xff, 0x62, 0xfa, 0x5c, 0x54, 0xf8, 0x1e, 0x9d, 0x26, 0x41, 0x28, 0xaf, 0x7b, - 0xd7, 0xd6, 0x90, 0xf5, 0xcf, 0x0a, 0x6c, 0xaa, 0x1e, 0xfc, 0x58, 0xb5, 0x9e, 0x46, 0xfd, 0x10, - 0x9a, 0x13, 0xca, 0x78, 0xe8, 0x06, 0x58, 0xab, 0x4e, 0x61, 0x21, 0x5e, 0xf4, 0xac, 0x55, 0xd9, - 0x15, 0x88, 0x65, 0xa1, 0x31, 0xae, 0x5d, 0xde, 0x18, 0x2f, 0xb4, 0xbe, 0xf5, 0xc5, 0xd6, 0x17, - 0xbd, 0x0c, 0x60, 0x98, 0x88, 0x2f, 0x3f, 0xfc, 0x2d, 0xbb, 0xa5, 0x31, 0x87, 0x3e, 0xba, 0x07, - 0xbd, 0xb1, 0xb0, 0xd2, 0x99, 0x50, 0x7a, 0xee, 0x44, 0x2e, 0x9f, 0xc8, 0x46, 0xbb, 0x65, 0x77, - 0x25, 0xfa, 0x80, 0xd2, 0xf3, 0x23, 0x97, 0x4f, 0xac, 0x9b, 0x70, 0xe3, 0x31, 0x66, 0x3c, 0xa6, - 0xb3, 0xa2, 0x77, 0xd6, 0x4f, 0x01, 0x0e, 0x43, 0x8e, 0xe3, 0x33, 0x57, 0xb4, 0xf5, 0x6f, 0xe7, - 0x21, 0xfd, 0x49, 0x5d, 0x1f, 0xa9, 0x39, 0x46, 0x4a, 0xb0, 0x73, 0x3c, 0xd6, 0x08, 0x1a, 0x36, - 0x4d, 0x38, 0x66, 0xe8, 0x35, 0xb3, 0xd2, 0xfb, 0x3a, 0x7a, 0x9f, 0x44, 0xda, 0x9a, 0x66, 0x1d, - 0x98, 0xc6, 0x27, 0x13, 0xa7, 0xe3, 0x3c, 0x82, 0x16, 0x31, 0x38, 0xfd, 0x3a, 0x17, 0x55, 0x67, - 0x2c, 0xd6, 0x3e, 0x6c, 0x3c, 0xf2, 0xfd, 0xef, 0x2d, 0xe6, 0xc0, 0xcc, 0x07, 0xbe, 0xb7, 0xa4, - 0x07, 0xb0, 0xa1, 0x5c, 0x53, 0xae, 0x1a, 0x31, 0xaf, 0x41, 0x23, 0x36, 0x71, 0xa9, 0x64, 0x13, - 0x15, 0xcd, 0xa4, 0x69, 0xe2, 0x80, 0x44, 0x63, 0x98, 0x45, 0xd6, 0x1c, 0xd0, 0x06, 0xf4, 0x05, - 0xa1, 0x20, 0xd3, 0xfa, 0x0d, 0x6c, 0x3c, 0x0b, 0xa7, 0x24, 0xc4, 0x7b, 0x47, 0x27, 0x4f, 0x71, - 0x9a, 0x09, 0x10, 0xd4, 0xc5, 0x67, 0x5e, 0x2a, 0x6a, 0xda, 0x72, 0x2d, 0x9e, 0x46, 0x78, 0xea, - 0x78, 0x51, 0xc2, 0xf4, 0x08, 0xa3, 0x11, 0x9e, 0xee, 0x45, 0x09, 0x43, 0xb7, 0x40, 0x7c, 0x6e, - 0x1c, 0x1a, 0x4e, 0x67, 0xf2, 0x7d, 0x34, 0xed, 0x55, 0x2f, 0x4a, 0x9e, 0x85, 0xd3, 0x99, 0xf5, - 0x63, 0xd9, 0xb4, 0x61, 0xec, 0xdb, 0x6e, 0xe8, 0xd3, 0xe0, 0x31, 0xbe, 0xc8, 0x69, 0x48, 0x1b, - 0x04, 0x93, 0x07, 0xbe, 0xae, 0x40, 0xe7, 0xd1, 0x18, 0x87, 0xfc, 0x31, 0xe6, 0x2e, 0x99, 0xca, - 0x26, 0xe0, 0x02, 0xc7, 0x8c, 0xd0, 0x50, 0x3f, 0x18, 0x03, 0x8a, 0x1e, 0x8e, 0x84, 0x84, 0x3b, - 0xbe, 0x8b, 0x03, 0x1a, 0x4a, 0x29, 0x4d, 0x1b, 0x04, 0xea, 0xb1, 0xc4, 0xa0, 0xd7, 0xa1, 0xa7, - 0x46, 0x4c, 0xce, 0xc4, 0x0d, 0xfd, 0x29, 0x8e, 0x4d, 0xcb, 0xbd, 0xa6, 0xd0, 0x07, 0x1a, 0x8b, - 0xde, 0x80, 0x75, 0xfd, 0x90, 0x32, 0xce, 0xba, 0xe4, 0xec, 0x69, 0x7c, 0x81, 0x35, 0x89, 0x22, - 0x1a, 0x73, 0xe6, 0x30, 0xec, 0x79, 0x34, 0x88, 0x74, 0x05, 0xdd, 0x33, 0xf8, 0x63, 0x85, 0xb6, - 0xc6, 0xb0, 0xf1, 0x44, 0xf8, 0xa9, 0x3d, 0xc9, 0x8e, 0x70, 0x2d, 0xc0, 0x81, 0x73, 0x3a, 0xa5, - 0xde, 0xb9, 0x23, 0x52, 0x93, 0x8e, 0xb0, 0xf8, 0x46, 0xef, 0x0a, 0xe4, 0x31, 0xf9, 0x4a, 0x36, - 0x8b, 0x82, 0x6b, 0x42, 0x79, 0x34, 0x4d, 0xc6, 0x4e, 0x14, 0xd3, 0x53, 0xac, 0x5d, 0xec, 0x05, - 0x38, 0x38, 0x50, 0xf8, 0x23, 0x81, 0xb6, 0xfe, 0x5a, 0x81, 0xcd, 0xa2, 0x26, 0x9d, 0x68, 0x77, - 0x60, 0xb3, 0xa8, 0x4a, 0x15, 0xba, 0xba, 0x22, 0xe9, 0xe7, 0x15, 0xca, 0x52, 0x16, 0xbd, 0x0f, - 0x5d, 0x39, 0x77, 0x74, 0x7c, 0x25, 0xa9, 0xf8, 0x9d, 0xcc, 0x9f, 0x8b, 0xdd, 0x71, 0xf3, 0xa7, - 0xf4, 0x21, 0xdc, 0xd2, 0xee, 0x3b, 0x8b, 0x66, 0xab, 0x0b, 0xb1, 0xa5, 0x19, 0x9e, 0xce, 0x59, - 0xff, 0x29, 0x0c, 0x32, 0xd4, 0xee, 0x4c, 0x22, 0x4d, 0xac, 0xde, 0x86, 0x8d, 0x39, 0x67, 0x1f, - 0xf9, 0x7e, 0x2c, 0x73, 0x42, 0xdd, 0x2e, 0x23, 0x59, 0x0f, 0xe1, 0xe6, 0x31, 0xe6, 0x2a, 0x1a, - 0x2e, 0xd7, 0xc5, 0xab, 0x12, 0xb6, 0x0e, 0xb5, 0x63, 0xec, 0x49, 0xe7, 0x6b, 0xb6, 0x58, 0x8a, - 0x0b, 0x78, 0xc2, 0xb0, 0x27, 0xbd, 0xac, 0xd9, 0x72, 0x6d, 0xfd, 0xa5, 0x02, 0xab, 0x3a, 0xbd, - 0x8a, 0xf4, 0xee, 0xc7, 0xe4, 0x02, 0xc7, 0xfa, 0xea, 0x69, 0x48, 0x34, 0xd1, 0x6a, 0xe5, 0xd0, - 0x88, 0x13, 0x9a, 0x26, 0xed, 0xae, 0xc2, 0x3e, 0x53, 0x48, 0x39, 0x52, 0x92, 0x13, 0x13, 0xdd, - 0x9c, 0x68, 0x48, 0xce, 0x85, 0x98, 0x78, 0xfb, 0x32, 0x49, 0xb7, 0x6c, 0x0d, 0x89, 0xab, 0x6e, - 0xe4, 0xad, 0x48, 0x79, 0x06, 0x14, 0x57, 0x3d, 0xa0, 0x49, 0xc8, 0x9d, 0x88, 0x92, 0x90, 0xeb, - 0xac, 0x0c, 0x12, 0x75, 0x24, 0x30, 0xd6, 0xef, 0x2b, 0xd0, 0x50, 0x63, 0x55, 0xd1, 0x0e, 0xa5, - 0xdf, 0xb5, 0x2a, 0x91, 0x35, 0x82, 0xd4, 0xa5, 0xbe, 0x65, 0x72, 0x2d, 0xde, 0xf1, 0x45, 0xa0, - 0x32, 0xbc, 0x36, 0xed, 0x22, 0x10, 0xa9, 0x5d, 0x78, 0x96, 0x7d, 0x1e, 0x25, 0x5d, 0x99, 0xd8, - 0x4d, 0xb1, 0x92, 0x6d, 0xa9, 0xa5, 0xd6, 0xaf, 0x44, 0x17, 0x98, 0x8e, 0x14, 0xd7, 0xa1, 0x96, - 0xa4, 0xc6, 0x88, 0xa5, 0xc0, 0x8c, 0xd3, 0x0f, 0xab, 0x58, 0xa2, 0x7b, 0xb0, 0xe6, 0xfa, 0x3e, - 0x11, 0xdb, 0xdd, 0xe9, 0x13, 0xe2, 0xa7, 0x8f, 0xb4, 0x88, 0xb5, 0xfe, 0x5e, 0x81, 0xde, 0x1e, - 0x8d, 0x66, 0x3f, 0x23, 0x53, 0x9c, 0xcb, 0x20, 0xd2, 0x48, 0xa5, 0x40, 0xae, 0x45, 0x85, 0x7d, - 0x46, 0xa6, 0x58, 0x3d, 0x2d, 0x75, 0xb2, 0x4d, 0x81, 0x90, 0xcf, 0xca, 0x10, 0xd3, 0x49, 0x4d, - 0x57, 0x11, 0x9f, 0x52, 0x1f, 0x8b, 0x24, 0xe6, 0x93, 0xd8, 0x49, 0xe7, 0x32, 0x5d, 0x7b, 0xd5, - 0x27, 0xb1, 0x24, 0x69, 0x47, 0x56, 0xe4, 0x68, 0x30, 0xef, 0x48, 0x43, 0x61, 0x84, 0x23, 0x5b, - 0xd0, 0xa0, 0x67, 0x67, 0x0c, 0x73, 0x39, 0x76, 0xae, 0xd9, 0x1a, 0x4a, 0xd3, 0x5c, 0x33, 0x4b, - 0x73, 0xf7, 0xff, 0xb0, 0xae, 0xd3, 0x9c, 0x6e, 0xb2, 0xd0, 0x13, 0xe8, 0xcd, 0x0d, 0xed, 0x91, - 0xee, 0xba, 0xcb, 0x67, 0xf9, 0xc3, 0xad, 0x91, 0xfa, 0x13, 0x60, 0x64, 0xfe, 0x04, 0x18, 0xed, - 0x07, 0x11, 0x9f, 0xa1, 0x7d, 0x58, 0x2b, 0x8e, 0xb7, 0xd1, 0x6d, 0x53, 0x33, 0x94, 0x0c, 0xbd, - 0x97, 0x8a, 0x79, 0x02, 0xbd, 0xb9, 0x49, 0xb7, 0xb1, 0xa7, 0x7c, 0x00, 0xbe, 0x54, 0xd0, 0x43, - 0x68, 0xe7, 0x46, 0xdb, 0x68, 0xa0, 0x84, 0x2c, 0x4e, 0xbb, 0x97, 0x0a, 0xd8, 0x83, 0x6e, 0x61, - 0xda, 0x8c, 0x86, 0xda, 0x9f, 0x92, 0x11, 0xf4, 0x52, 0x21, 0xbb, 0xd0, 0xce, 0x0d, 0x7d, 0x8d, - 0x15, 0x8b, 0x93, 0xe5, 0xe1, 0xad, 0x12, 0x8a, 0xce, 0xa6, 0x07, 0xd0, 0x2d, 0x8c, 0x68, 0x8d, - 0x21, 0x65, 0xe3, 0xe1, 0xe1, 0xed, 0x52, 0x9a, 0x96, 0xf4, 0x04, 0x7a, 0x73, 0x03, 0x5b, 0x13, - 0xdc, 0xf2, 0x39, 0xee, 0x52, 0xb7, 0x3e, 0x91, 0x87, 0x9d, 0xeb, 0x50, 0x72, 0x87, 0xbd, 0x38, - 0x9e, 0x1d, 0xbe, 0x54, 0x4e, 0xd4, 0x56, 0xed, 0xc3, 0x5a, 0x71, 0x32, 0x6b, 0x84, 0x95, 0xce, - 0x6b, 0x2f, 0xbf, 0x39, 0x85, 0x21, 0x6d, 0x76, 0x73, 0xca, 0x66, 0xb7, 0x4b, 0x05, 0x3d, 0x02, - 0xd0, 0x8d, 0x8c, 0x4f, 0xc2, 0xf4, 0xc8, 0x16, 0x1a, 0xa8, 0xf4, 0xc8, 0x4a, 0x9a, 0x9e, 0x87, - 0x00, 0xaa, 0xff, 0xf0, 0x69, 0xc2, 0xd1, 0x4d, 0x63, 0xc6, 0x5c, 0xd3, 0x33, 0x1c, 0x2c, 0x12, - 0x16, 0x04, 0xe0, 0x38, 0xbe, 0x8a, 0x80, 0x8f, 0x01, 0xb2, 0xbe, 0xc6, 0x08, 0x58, 0xe8, 0x74, - 0x2e, 0x89, 0x41, 0x27, 0xdf, 0xc5, 0x20, 0xed, 0x6b, 0x49, 0x67, 0xb3, 0x54, 0xc4, 0x03, 0xe8, - 0xe4, 0x4b, 0x5b, 0x23, 0xa2, 0xa4, 0xdc, 0x1d, 0x2e, 0x54, 0xa4, 0xe8, 0x91, 0xb9, 0xa9, 0x19, - 0xaa, 0x70, 0x53, 0xbf, 0x9b, 0x88, 0xb9, 0x9a, 0xb8, 0x98, 0x49, 0xbe, 0x83, 0x88, 0xf7, 0xa1, - 0x93, 0x2f, 0x86, 0x8d, 0x0b, 0x25, 0x05, 0xf2, 0xb0, 0x50, 0x10, 0xa3, 0x87, 0xb0, 0x56, 0x2c, - 0x84, 0x51, 0xee, 0x5d, 0x2e, 0x94, 0xc7, 0x43, 0x3d, 0xad, 0xc8, 0xb1, 0xbf, 0x0b, 0x90, 0x15, - 0xcc, 0xe6, 0xf8, 0x16, 0x4a, 0xe8, 0x39, 0xad, 0x7b, 0xd0, 0x2d, 0x34, 0x7f, 0x26, 0x51, 0x94, - 0x75, 0x84, 0x97, 0xe5, 0xf1, 0x62, 0x93, 0x65, 0x4c, 0x2f, 0x6d, 0xbd, 0x2e, 0xbb, 0x40, 0xf9, - 0xe2, 0xde, 0x84, 0xae, 0xa4, 0xe0, 0xff, 0x96, 0x07, 0x9d, 0x2f, 0xe0, 0x73, 0x0f, 0xba, 0xa4, - 0xae, 0x5f, 0x2a, 0xe8, 0x00, 0x7a, 0x4f, 0x4c, 0x6d, 0xa6, 0xeb, 0x46, 0x6d, 0x4e, 0x49, 0x9d, - 0x3c, 0x1c, 0x96, 0x91, 0xf4, 0xab, 0xfa, 0x04, 0xfa, 0x0b, 0x35, 0x23, 0xba, 0x93, 0x0e, 0xb4, - 0x4a, 0x8b, 0xc9, 0xa5, 0x66, 0x1d, 0xc2, 0xfa, 0x7c, 0xc9, 0x88, 0x5e, 0xd6, 0x99, 0xb2, 0xbc, - 0x94, 0x5c, 0x2a, 0xea, 0x43, 0x68, 0x9a, 0x12, 0x05, 0xe9, 0xc1, 0xe1, 0x5c, 0xc9, 0xb2, 0x6c, - 0xeb, 0x6e, 0xe7, 0xeb, 0x6f, 0xee, 0x54, 0xfe, 0xf1, 0xcd, 0x9d, 0xca, 0xbf, 0xbf, 0xb9, 0x53, - 0x39, 0x6d, 0x48, 0xea, 0xbb, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xbe, 0xbd, 0x6e, 0x1d, 0x40, - 0x20, 0x00, 0x00, + // 2679 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x18, 0xdb, 0x6e, 0x1b, 0xc7, + 0x15, 0xbc, 0x48, 0x22, 0x0f, 0x49, 0x51, 0x1c, 0xc9, 0x32, 0x4d, 0x27, 0xae, 0xb3, 0x49, 0x1d, + 0xa5, 0x69, 0xa8, 0xc4, 0x09, 0x9a, 0x1b, 0x52, 0xc3, 0x92, 0x5d, 0x4b, 0x4d, 0x5c, 0xab, 0x4b, + 0x0b, 0x29, 0x50, 0x14, 0x8b, 0xd5, 0xee, 0x88, 0x9c, 0x88, 0xbb, 0xb3, 0x99, 0x9d, 0x95, 0xcd, + 0x14, 0xe8, 0x63, 0x7f, 0xa0, 0xcf, 0xfd, 0x81, 0xa2, 0x6f, 0x7d, 0xec, 0x6b, 0x1f, 0x82, 0x3e, + 0xf5, 0xbd, 0x40, 0x51, 0xe4, 0x13, 0xfa, 0x05, 0xc5, 0xdc, 0xf6, 0x42, 0x2e, 0x19, 0x54, 0x10, + 0xd0, 0x97, 0xc5, 0x9e, 0xcb, 0x9c, 0xdb, 0xcc, 0x9c, 0x39, 0xe7, 0x40, 0xcb, 0x1d, 0xe3, 0x90, + 0x0f, 0x23, 0x46, 0x39, 0x45, 0xf5, 0x31, 0x8b, 0xbc, 0x41, 0x93, 0x7a, 0x44, 0x21, 0x06, 0x3f, + 0x19, 0x13, 0x3e, 0x49, 0xce, 0x86, 0x1e, 0x0d, 0xf6, 0x2f, 0x5c, 0xee, 0xbe, 0xe3, 0xd1, 0x90, + 0xbb, 0x24, 0xc4, 0x2c, 0xde, 0x97, 0x0b, 0xf7, 0xa3, 0x8b, 0xf1, 0x3e, 0x9f, 0x45, 0x38, 0x56, + 0x5f, 0xbd, 0xee, 0xf6, 0x98, 0xd2, 0xf1, 0x14, 0xef, 0x4b, 0xe8, 0x2c, 0x39, 0xdf, 0xc7, 0x41, + 0xc4, 0x67, 0x8a, 0x68, 0xfd, 0xb1, 0x0a, 0xbb, 0x87, 0x0c, 0xbb, 0x1c, 0x1f, 0x1a, 0x69, 0x36, + 0xfe, 0x3a, 0xc1, 0x31, 0x47, 0xaf, 0x41, 0x3b, 0xd5, 0xe0, 0x10, 0xbf, 0x5f, 0xb9, 0x5b, 0xd9, + 0x6b, 0xda, 0xad, 0x14, 0x77, 0xec, 0xa3, 0x9b, 0xb0, 0x81, 0x5f, 0x62, 0x4f, 0x50, 0xab, 0x92, + 0xba, 0x2e, 0xc0, 0x63, 0x1f, 0xbd, 0x07, 0xad, 0x98, 0x33, 0x12, 0x8e, 0x9d, 0x24, 0xc6, 0xac, + 0x5f, 0xbb, 0x5b, 0xd9, 0x6b, 0xdd, 0xdf, 0x1a, 0x0a, 0x97, 0x86, 0x23, 0x49, 0x38, 0x8d, 0x31, + 0xb3, 0x21, 0x4e, 0xff, 0xd1, 0x3d, 0xd8, 0xf0, 0xf1, 0x25, 0xf1, 0x70, 0xdc, 0xaf, 0xdf, 0xad, + 0xed, 0xb5, 0xee, 0xb7, 0x15, 0xfb, 0x23, 0x89, 0xb4, 0x0d, 0x11, 0xbd, 0x05, 0x8d, 0x98, 0x53, + 0xe6, 0x8e, 0x71, 0xdc, 0x5f, 0x93, 0x8c, 0x1d, 0x23, 0x57, 0x62, 0xed, 0x94, 0x8c, 0x5e, 0x81, + 0xda, 0xb3, 0xc3, 0xe3, 0xfe, 0xba, 0xd4, 0x0e, 0x9a, 0x2b, 0xc2, 0x9e, 0x2d, 0xd0, 0xe8, 0x75, + 0xe8, 0xc4, 0x6e, 0xe8, 0x9f, 0xd1, 0x97, 0x4e, 0x44, 0xfc, 0x30, 0xee, 0x6f, 0xdc, 0xad, 0xec, + 0x35, 0xec, 0xb6, 0x46, 0x9e, 0x08, 0x9c, 0xf5, 0x09, 0xdc, 0x18, 0x71, 0x97, 0xf1, 0x2b, 0x44, + 0xc7, 0x3a, 0x85, 0x5d, 0x1b, 0x07, 0xf4, 0xf2, 0x4a, 0xa1, 0xed, 0xc3, 0x06, 0x27, 0x01, 0xa6, + 0x09, 0x97, 0xa1, 0xed, 0xd8, 0x06, 0xb4, 0xfe, 0x5c, 0x01, 0xf4, 0xf8, 0x25, 0xf6, 0x4e, 0x18, + 0xf5, 0x70, 0x1c, 0xff, 0x9f, 0xb6, 0xeb, 0x4d, 0xd8, 0x88, 0x94, 0x01, 0xfd, 0xba, 0x64, 0xd7, + 0xbb, 0x60, 0xac, 0x32, 0x54, 0xeb, 0x2b, 0xd8, 0x19, 0x91, 0x71, 0xe8, 0x4e, 0xaf, 0xd1, 0xde, + 0x5d, 0x58, 0x8f, 0xa5, 0x4c, 0x69, 0x6a, 0xc7, 0xd6, 0x90, 0x75, 0x02, 0xe8, 0x4b, 0x97, 0xf0, + 0xeb, 0xd3, 0x64, 0xbd, 0x03, 0xdb, 0x05, 0x89, 0x71, 0x44, 0xc3, 0x18, 0x4b, 0x03, 0xb8, 0xcb, + 0x93, 0x58, 0x0a, 0x5b, 0xb3, 0x35, 0x64, 0x61, 0xd8, 0xf9, 0x82, 0xc4, 0x86, 0x1d, 0xff, 0x2f, + 0x26, 0xec, 0xc2, 0xfa, 0x39, 0x65, 0x81, 0xcb, 0x8d, 0x05, 0x0a, 0x42, 0x08, 0xea, 0x2e, 0x1b, + 0xc7, 0xfd, 0xda, 0xdd, 0xda, 0x5e, 0xd3, 0x96, 0xff, 0xe2, 0x54, 0xce, 0xa9, 0xd1, 0x76, 0xbd, + 0x06, 0x6d, 0x1d, 0x77, 0x67, 0x4a, 0x62, 0x2e, 0xf5, 0xb4, 0xed, 0x96, 0xc6, 0x89, 0x35, 0x16, + 0x85, 0xdd, 0xd3, 0xc8, 0xbf, 0xe2, 0x85, 0xbf, 0x0f, 0x4d, 0x86, 0x63, 0x9a, 0x30, 0x71, 0x4d, + 0xab, 0x72, 0xdf, 0x77, 0xd4, 0xbe, 0x7f, 0x41, 0xc2, 0xe4, 0xa5, 0x6d, 0x68, 0x76, 0xc6, 0xa6, + 0xaf, 0x10, 0x8f, 0xaf, 0x72, 0x85, 0x3e, 0x81, 0x1b, 0x27, 0x6e, 0x12, 0x5f, 0xc5, 0x56, 0xeb, + 0x53, 0x71, 0xfd, 0xe2, 0x24, 0xb8, 0xd2, 0xe2, 0x3f, 0x55, 0xa0, 0x71, 0x18, 0x25, 0xa7, 0xb1, + 0x3b, 0xc6, 0xe8, 0x07, 0xd0, 0xe2, 0x94, 0xbb, 0x53, 0x27, 0x11, 0xa0, 0x64, 0xaf, 0xdb, 0x20, + 0x51, 0x8a, 0x41, 0x84, 0x1d, 0x33, 0x2f, 0x4a, 0x34, 0x47, 0xf5, 0x6e, 0x6d, 0xaf, 0x6e, 0xb7, + 0x14, 0x4e, 0xb1, 0x0c, 0x61, 0x5b, 0xd2, 0x1c, 0x12, 0x3a, 0x17, 0x98, 0x85, 0x78, 0x1a, 0x50, + 0x1f, 0xcb, 0xf3, 0x5b, 0xb7, 0x7b, 0x92, 0x74, 0x1c, 0x7e, 0x9e, 0x12, 0xd0, 0x8f, 0xa0, 0x97, + 0xf2, 0x8b, 0x4b, 0x29, 0xb9, 0xeb, 0x92, 0xbb, 0xab, 0xb9, 0x4f, 0x35, 0xda, 0xfa, 0x1d, 0x6c, + 0x3e, 0x9f, 0x30, 0xca, 0xf9, 0x94, 0x84, 0xe3, 0x47, 0x2e, 0x77, 0x45, 0xf6, 0x88, 0x30, 0x23, + 0xd4, 0x8f, 0xb5, 0xb5, 0x06, 0x44, 0x6f, 0x43, 0x8f, 0x2b, 0x5e, 0xec, 0x3b, 0x86, 0xa7, 0x2a, + 0x79, 0xb6, 0x52, 0xc2, 0x89, 0x66, 0xfe, 0x21, 0x6c, 0x66, 0xcc, 0x22, 0xff, 0x68, 0x7b, 0x3b, + 0x29, 0xf6, 0x39, 0x09, 0xb0, 0x75, 0x29, 0x63, 0x25, 0x37, 0x19, 0xbd, 0x0d, 0xcd, 0x2c, 0x0e, + 0x15, 0x79, 0x42, 0x36, 0xd5, 0x09, 0x31, 0xe1, 0xb4, 0x1b, 0x69, 0x50, 0x3e, 0x83, 0x2e, 0x4f, + 0x0d, 0x77, 0x7c, 0x97, 0xbb, 0xc5, 0x43, 0x55, 0xf4, 0xca, 0xde, 0xe4, 0x05, 0xd8, 0xfa, 0x14, + 0x9a, 0x27, 0xc4, 0x8f, 0x95, 0xe2, 0x3e, 0x6c, 0x78, 0x09, 0x63, 0x38, 0xe4, 0xc6, 0x65, 0x0d, + 0xa2, 0x1d, 0x58, 0x9b, 0x92, 0x80, 0x70, 0xed, 0xa6, 0x02, 0x2c, 0x0a, 0xf0, 0x14, 0x07, 0x94, + 0xcd, 0x64, 0xc0, 0x76, 0x60, 0x2d, 0xbf, 0xb9, 0x0a, 0x40, 0xb7, 0xa1, 0x19, 0xb8, 0x2f, 0xd3, + 0x4d, 0x15, 0x94, 0x46, 0xe0, 0xbe, 0x54, 0xc6, 0xf7, 0x61, 0xe3, 0xdc, 0x25, 0x53, 0x2f, 0xe4, + 0x3a, 0x2a, 0x06, 0xcc, 0x14, 0xd6, 0xf3, 0x0a, 0xff, 0x56, 0x85, 0x96, 0xd2, 0xa8, 0x0c, 0xde, + 0x81, 0x35, 0xcf, 0xf5, 0x26, 0xa9, 0x4a, 0x09, 0xa0, 0x7b, 0xc6, 0x90, 0x6a, 0x3e, 0x09, 0x67, + 0x96, 0x1a, 0xd3, 0xf6, 0x01, 0xe2, 0x17, 0x6e, 0xa4, 0x6d, 0xab, 0x2d, 0x61, 0x6e, 0x0a, 0x1e, + 0x65, 0xee, 0xfb, 0xd0, 0x56, 0xe7, 0x4e, 0x2f, 0xa9, 0x2f, 0x59, 0xd2, 0x52, 0x5c, 0x6a, 0xd1, + 0xeb, 0xd0, 0x49, 0x62, 0xec, 0x4c, 0x08, 0x66, 0x2e, 0xf3, 0x26, 0xb3, 0xfe, 0x9a, 0x7a, 0x23, + 0x93, 0x18, 0x1f, 0x19, 0x1c, 0xba, 0x0f, 0x6b, 0x22, 0xfd, 0xc5, 0xfd, 0x75, 0xf9, 0x1c, 0xbf, + 0x92, 0x17, 0x29, 0x5d, 0x1d, 0xca, 0xef, 0xe3, 0x90, 0xb3, 0x99, 0xad, 0x58, 0x07, 0x1f, 0x01, + 0x64, 0x48, 0xb4, 0x05, 0xb5, 0x0b, 0x3c, 0xd3, 0xf7, 0x50, 0xfc, 0x8a, 0xe0, 0x5c, 0xba, 0xd3, + 0xc4, 0x44, 0x5d, 0x01, 0x9f, 0x54, 0x3f, 0xaa, 0x58, 0x1e, 0x74, 0x0f, 0xa6, 0x17, 0x84, 0xe6, + 0x96, 0xef, 0xc0, 0x5a, 0xe0, 0x7e, 0x45, 0x99, 0x89, 0xa4, 0x04, 0x24, 0x96, 0x84, 0x94, 0x19, + 0x11, 0x12, 0x40, 0x9b, 0x50, 0xa5, 0x91, 0x8c, 0x57, 0xd3, 0xae, 0xd2, 0x28, 0x53, 0x54, 0xcf, + 0x29, 0xb2, 0xfe, 0x55, 0x07, 0xc8, 0xb4, 0x20, 0x1b, 0x06, 0x84, 0x3a, 0x31, 0x66, 0xa2, 0x04, + 0x71, 0xce, 0x66, 0x1c, 0xc7, 0x0e, 0xc3, 0x5e, 0xc2, 0x62, 0x72, 0x29, 0xf6, 0x4f, 0xb8, 0x7d, + 0x43, 0xb9, 0x3d, 0x67, 0x9b, 0x7d, 0x93, 0xd0, 0x91, 0x5a, 0x77, 0x20, 0x96, 0xd9, 0x66, 0x15, + 0x3a, 0x86, 0x1b, 0x99, 0x4c, 0x3f, 0x27, 0xae, 0xba, 0x4a, 0xdc, 0x76, 0x2a, 0xce, 0xcf, 0x44, + 0x3d, 0x86, 0x6d, 0x42, 0x9d, 0xaf, 0x13, 0x9c, 0x14, 0x04, 0xd5, 0x56, 0x09, 0xea, 0x11, 0xfa, + 0x4b, 0xb9, 0x20, 0x13, 0x73, 0x02, 0xb7, 0x72, 0x5e, 0x8a, 0xeb, 0x9e, 0x13, 0x56, 0x5f, 0x25, + 0x6c, 0x37, 0xb5, 0x4a, 0xe4, 0x83, 0x4c, 0xe2, 0xcf, 0x61, 0x97, 0x50, 0xe7, 0x85, 0x4b, 0xf8, + 0xbc, 0xb8, 0xb5, 0xef, 0x71, 0x52, 0x3c, 0xba, 0x45, 0x59, 0xca, 0xc9, 0x00, 0xb3, 0x71, 0xc1, + 0xc9, 0xf5, 0xef, 0x71, 0xf2, 0xa9, 0x5c, 0x90, 0x89, 0x79, 0x08, 0x3d, 0x42, 0xe7, 0xad, 0xd9, + 0x58, 0x25, 0xa4, 0x4b, 0x68, 0xd1, 0x92, 0x03, 0xe8, 0xc5, 0xd8, 0xe3, 0x94, 0xe5, 0x0f, 0x41, + 0x63, 0x95, 0x88, 0x2d, 0xcd, 0x9f, 0xca, 0xb0, 0x7e, 0x0d, 0xed, 0xa3, 0x64, 0x8c, 0xf9, 0xf4, + 0x2c, 0x4d, 0x06, 0xd7, 0x96, 0x7f, 0xac, 0xff, 0x54, 0xa1, 0x75, 0x38, 0x66, 0x34, 0x89, 0x0a, + 0x39, 0x59, 0x5d, 0xd2, 0xf9, 0x9c, 0x2c, 0x59, 0x64, 0x4e, 0x56, 0xcc, 0x1f, 0x40, 0x3b, 0x90, + 0x57, 0x57, 0xf3, 0xab, 0x3c, 0xd4, 0x5b, 0xb8, 0xd4, 0x76, 0x2b, 0xc8, 0x25, 0xb3, 0x21, 0x40, + 0x44, 0xfc, 0x58, 0xaf, 0x51, 0xe9, 0xa8, 0xab, 0x2b, 0x42, 0x93, 0xa2, 0xed, 0x66, 0x94, 0x66, + 0xeb, 0xf7, 0xa0, 0x75, 0x26, 0x82, 0xa4, 0x17, 0x14, 0x92, 0x51, 0x16, 0x3d, 0x1b, 0xce, 0xb2, + 0x4b, 0x78, 0x04, 0x9d, 0x89, 0x0a, 0x99, 0x5e, 0xa4, 0xce, 0xd0, 0xeb, 0xda, 0x93, 0xcc, 0xdf, + 0x61, 0x3e, 0xb2, 0x6a, 0x03, 0xda, 0x93, 0x1c, 0x6a, 0x30, 0x82, 0xde, 0x02, 0x4b, 0x49, 0x0e, + 0xda, 0xcb, 0xe7, 0xa0, 0xd6, 0x7d, 0xa4, 0x14, 0xe5, 0x57, 0xe6, 0xf3, 0xd2, 0x2f, 0x60, 0x77, + 0xbe, 0xcc, 0xd1, 0x45, 0xd9, 0x07, 0xd0, 0xf6, 0xa4, 0x75, 0x85, 0x1d, 0xe8, 0x2d, 0xd8, 0x6d, + 0xb7, 0xbc, 0x0c, 0xb0, 0x7c, 0x40, 0x5f, 0x32, 0xc2, 0xf1, 0x88, 0x33, 0xec, 0x06, 0xd7, 0x51, + 0x35, 0x23, 0xa8, 0xcb, 0x27, 0xb6, 0x26, 0x8b, 0x42, 0xf9, 0x6f, 0xbd, 0x09, 0xdb, 0x05, 0x2d, + 0xda, 0xe4, 0x2d, 0xa8, 0x4d, 0x71, 0x28, 0xa5, 0x77, 0x6c, 0xf1, 0x6b, 0xb9, 0xd0, 0xb3, 0xb1, + 0xeb, 0x5f, 0x9f, 0x35, 0x5a, 0x45, 0x2d, 0x53, 0xb1, 0x07, 0x28, 0xaf, 0x42, 0x9b, 0x62, 0xac, + 0xae, 0xe4, 0xac, 0x7e, 0x06, 0xbd, 0xc3, 0x29, 0x8d, 0xf1, 0x88, 0xfb, 0x24, 0xbc, 0x8e, 0x32, + 0xff, 0xb7, 0xb0, 0xfd, 0x9c, 0xcf, 0xbe, 0x14, 0xc2, 0x62, 0xf2, 0x0d, 0xbe, 0x26, 0xff, 0x18, + 0x7d, 0x61, 0xfc, 0x63, 0xf4, 0x85, 0xa8, 0xf0, 0x3d, 0x3a, 0x4d, 0x82, 0x50, 0x1e, 0xf7, 0x8e, + 0xad, 0x21, 0xeb, 0x9f, 0x15, 0xd8, 0x51, 0x3d, 0xf8, 0x48, 0xb5, 0x9e, 0x46, 0xfd, 0x00, 0x1a, + 0x13, 0x1a, 0xf3, 0xd0, 0x0d, 0xb0, 0x56, 0x9d, 0xc2, 0x42, 0xbc, 0xe8, 0x59, 0xab, 0xb2, 0x2b, + 0x10, 0xbf, 0x85, 0xc6, 0xb8, 0xb6, 0xba, 0x31, 0x5e, 0x68, 0x7d, 0xeb, 0x8b, 0xad, 0x2f, 0x7a, + 0x15, 0xc0, 0x30, 0x11, 0x5f, 0x3e, 0xfc, 0x4d, 0xbb, 0xa9, 0x31, 0xc7, 0x3e, 0xba, 0x07, 0xdd, + 0xb1, 0xb0, 0xd2, 0x99, 0x50, 0x7a, 0xe1, 0x44, 0x2e, 0x9f, 0xc8, 0x46, 0xbb, 0x69, 0x77, 0x24, + 0xfa, 0x88, 0xd2, 0x8b, 0x13, 0x97, 0x4f, 0xac, 0x9b, 0x70, 0xe3, 0x11, 0x8e, 0x39, 0xa3, 0xb3, + 0xa2, 0x77, 0xd6, 0x4f, 0x01, 0x8e, 0x43, 0x8e, 0xd9, 0xb9, 0x2b, 0xda, 0xfa, 0x77, 0xf3, 0x90, + 0x7e, 0x52, 0xb7, 0x86, 0x6a, 0x8e, 0x91, 0x12, 0xec, 0x1c, 0x8f, 0x35, 0x84, 0x75, 0x9b, 0x26, + 0x1c, 0xc7, 0xe8, 0x0d, 0xf3, 0xa7, 0xd7, 0xb5, 0xf5, 0x3a, 0x89, 0xb4, 0x35, 0xcd, 0x3a, 0x32, + 0x8d, 0x4f, 0x26, 0x4e, 0xc7, 0x79, 0x08, 0x4d, 0x62, 0x70, 0xfa, 0x76, 0x2e, 0xaa, 0xce, 0x58, + 0xac, 0x4f, 0x61, 0x5b, 0x49, 0x52, 0x92, 0x8d, 0x98, 0x37, 0x60, 0x9d, 0x19, 0x33, 0x2a, 0xd9, + 0x00, 0x43, 0x33, 0x69, 0x9a, 0x88, 0x87, 0xe8, 0xc3, 0x32, 0x47, 0x4c, 0x3c, 0xb6, 0xa1, 0x27, + 0x08, 0x05, 0x99, 0xd6, 0x6f, 0x60, 0xfb, 0x59, 0x38, 0x25, 0x21, 0x3e, 0x3c, 0x39, 0x7d, 0x8a, + 0xd3, 0x8b, 0x87, 0xa0, 0x2e, 0x5e, 0x55, 0xa9, 0xa8, 0x61, 0xcb, 0x7f, 0x71, 0x12, 0xc3, 0x33, + 0xc7, 0x8b, 0x92, 0x58, 0x4f, 0x0c, 0xd6, 0xc3, 0xb3, 0xc3, 0x28, 0x89, 0xd1, 0x2d, 0x10, 0xd9, + 0xdd, 0xa1, 0xe1, 0x74, 0x26, 0x8f, 0x63, 0xc3, 0xde, 0xf0, 0xa2, 0xe4, 0x59, 0x38, 0x9d, 0x59, + 0x3f, 0x96, 0x3d, 0x12, 0xc6, 0xbe, 0xed, 0x86, 0x3e, 0x0d, 0x1e, 0xe1, 0xcb, 0x9c, 0x86, 0xb4, + 0x1e, 0x37, 0xd7, 0xee, 0xdb, 0x0a, 0xb4, 0x1f, 0x8e, 0x71, 0xc8, 0x1f, 0x61, 0xee, 0x92, 0xa9, + 0xac, 0xb9, 0x2f, 0x31, 0x8b, 0x09, 0x0d, 0xf5, 0xf9, 0x34, 0xa0, 0x68, 0x99, 0x48, 0x48, 0xb8, + 0xe3, 0xbb, 0x38, 0xa0, 0xa1, 0x94, 0xd2, 0xb0, 0x41, 0xa0, 0x1e, 0x49, 0x0c, 0x7a, 0x13, 0xba, + 0x6a, 0xa2, 0xe3, 0x4c, 0xdc, 0xd0, 0x9f, 0x62, 0x66, 0x3a, 0xdc, 0x4d, 0x85, 0x3e, 0xd2, 0x58, + 0xf4, 0x16, 0x6c, 0xe9, 0x73, 0x9b, 0x71, 0xd6, 0x25, 0x67, 0x57, 0xe3, 0x0b, 0xac, 0x49, 0x14, + 0x51, 0xc6, 0x63, 0x27, 0xc6, 0x9e, 0x47, 0x83, 0x48, 0x17, 0xac, 0x5d, 0x83, 0x1f, 0x29, 0xb4, + 0x35, 0x86, 0xed, 0x27, 0xc2, 0x4f, 0xed, 0x49, 0xb6, 0x85, 0x9b, 0x01, 0x0e, 0x9c, 0xb3, 0x29, + 0xf5, 0x2e, 0x1c, 0x91, 0x09, 0x74, 0x84, 0xc5, 0x93, 0x78, 0x20, 0x90, 0x23, 0xf2, 0x8d, 0xec, + 0xcd, 0x04, 0xd7, 0x84, 0xf2, 0x68, 0x9a, 0x8c, 0x9d, 0x88, 0xd1, 0x33, 0xac, 0x5d, 0xec, 0x06, + 0x38, 0x38, 0x52, 0xf8, 0x13, 0x81, 0xb6, 0xfe, 0x5a, 0x81, 0x9d, 0xa2, 0x26, 0x9d, 0xd7, 0xf6, + 0x61, 0xa7, 0xa8, 0x4a, 0xd5, 0x95, 0xba, 0x00, 0xe8, 0xe5, 0x15, 0xca, 0xca, 0x11, 0x7d, 0x08, + 0x1d, 0x39, 0xe6, 0x73, 0x7c, 0x25, 0xa9, 0xf8, 0x2c, 0xe5, 0xf7, 0xc5, 0x6e, 0xbb, 0xf9, 0x5d, + 0xfa, 0x18, 0x6e, 0x69, 0xf7, 0x9d, 0x45, 0xb3, 0xd5, 0x81, 0xd8, 0xd5, 0x0c, 0x4f, 0xe7, 0xac, + 0xff, 0x02, 0xfa, 0x19, 0xea, 0x60, 0x26, 0x91, 0x26, 0x56, 0xef, 0xc2, 0xf6, 0x9c, 0xb3, 0x0f, + 0x7d, 0x9f, 0xc9, 0x2b, 0x58, 0xb7, 0xcb, 0x48, 0xd6, 0x03, 0xb8, 0x39, 0xc2, 0x5c, 0x45, 0xc3, + 0xe5, 0xba, 0x56, 0x54, 0xc2, 0xb6, 0xa0, 0x36, 0xc2, 0x9e, 0x74, 0xbe, 0x66, 0x8b, 0x5f, 0x71, + 0x00, 0x4f, 0x63, 0xec, 0x49, 0x2f, 0x6b, 0xb6, 0xfc, 0xb7, 0xfe, 0x52, 0x81, 0x0d, 0x9d, 0xcd, + 0x44, 0x36, 0xf5, 0x19, 0xb9, 0xc4, 0x4c, 0x1f, 0x3d, 0x0d, 0x89, 0x9e, 0x55, 0xfd, 0x39, 0x34, + 0xe2, 0x84, 0xa6, 0x39, 0xb2, 0xa3, 0xb0, 0xcf, 0x14, 0x52, 0x4e, 0x70, 0xe4, 0x80, 0x42, 0xf7, + 0x02, 0x1a, 0x92, 0x63, 0x98, 0x58, 0xdc, 0x7d, 0x99, 0x13, 0x9b, 0xb6, 0x86, 0xc4, 0x51, 0x37, + 0xf2, 0xd6, 0xa4, 0x3c, 0x03, 0x8a, 0xa3, 0x1e, 0xd0, 0x24, 0xe4, 0x4e, 0x44, 0x49, 0xc8, 0x75, + 0x12, 0x04, 0x89, 0x3a, 0x11, 0x18, 0xeb, 0xf7, 0x15, 0x58, 0x57, 0x53, 0x4c, 0xd1, 0x7d, 0xa4, + 0xcf, 0x48, 0x95, 0xc8, 0x27, 0x59, 0xea, 0x52, 0x4f, 0x87, 0xfc, 0x17, 0xf7, 0xf8, 0x32, 0x50, + 0x09, 0x55, 0x9b, 0x76, 0x19, 0x88, 0x4c, 0x2a, 0x3c, 0xcb, 0x5e, 0x23, 0x49, 0x57, 0x26, 0x76, + 0x52, 0xac, 0x64, 0x5b, 0x6a, 0xa9, 0xf5, 0x2b, 0xd1, 0x74, 0xa5, 0x13, 0xbc, 0x2d, 0xa8, 0x25, + 0xa9, 0x31, 0xe2, 0x57, 0x60, 0xc6, 0xe9, 0x3b, 0x26, 0x7e, 0xd1, 0x3d, 0xd8, 0x74, 0x7d, 0x9f, + 0x88, 0xe5, 0xee, 0xf4, 0x09, 0xf1, 0xd3, 0x4b, 0x5a, 0xc4, 0x5a, 0x7f, 0xaf, 0x40, 0xf7, 0x90, + 0x46, 0xb3, 0x9f, 0x91, 0x29, 0xce, 0x65, 0x10, 0x69, 0xa4, 0x52, 0x20, 0xff, 0x45, 0x41, 0x7b, + 0x4e, 0xa6, 0x58, 0x5d, 0x2d, 0xb5, 0xb3, 0x0d, 0x81, 0x90, 0xd7, 0xca, 0x10, 0xd3, 0xc1, 0x48, + 0x47, 0x11, 0x9f, 0x52, 0x1f, 0x8b, 0x24, 0xe6, 0x13, 0xe6, 0xa4, 0x63, 0x90, 0x8e, 0xbd, 0xe1, + 0x13, 0x26, 0x49, 0xda, 0x91, 0x35, 0x39, 0x89, 0xcb, 0x3b, 0xb2, 0xae, 0x30, 0xc2, 0x91, 0x5d, + 0x58, 0xa7, 0xe7, 0xe7, 0x31, 0xe6, 0x72, 0xca, 0x5b, 0xb3, 0x35, 0x94, 0xa6, 0xb9, 0x46, 0x2e, + 0xcd, 0xdd, 0x80, 0x6d, 0x39, 0xf3, 0x7d, 0xce, 0x5c, 0x8f, 0x84, 0x63, 0x93, 0x8a, 0x77, 0x00, + 0x8d, 0x38, 0x8d, 0x8a, 0xd8, 0xfb, 0x7f, 0xd8, 0xd2, 0x39, 0x51, 0x37, 0x40, 0xe8, 0x09, 0x74, + 0xe7, 0x06, 0xea, 0x48, 0x77, 0xc4, 0xe5, 0x73, 0xf6, 0xc1, 0xee, 0x50, 0x0d, 0xe8, 0x87, 0x66, + 0x40, 0x3f, 0x7c, 0x1c, 0x44, 0x7c, 0x86, 0x1e, 0xc3, 0x66, 0x71, 0xf4, 0x8c, 0x6e, 0x9b, 0xf7, + 0xbc, 0x64, 0x20, 0xbd, 0x54, 0xcc, 0x13, 0xe8, 0xce, 0x4d, 0xa1, 0x8d, 0x3d, 0xe5, 0xc3, 0xe9, + 0xa5, 0x82, 0x1e, 0x40, 0x2b, 0x37, 0x76, 0x46, 0x7d, 0x25, 0x64, 0x71, 0x12, 0xbd, 0x54, 0xc0, + 0x21, 0x74, 0x0a, 0x93, 0x60, 0x34, 0xd0, 0xfe, 0x94, 0x8c, 0x87, 0x97, 0x0a, 0x39, 0x80, 0x56, + 0x6e, 0x20, 0x6b, 0xac, 0x58, 0x9c, 0xfa, 0x0e, 0x6e, 0x95, 0x50, 0x74, 0xea, 0x3d, 0x82, 0x4e, + 0x61, 0x7c, 0x6a, 0x0c, 0x29, 0x1b, 0xdd, 0x0e, 0x6e, 0x97, 0xd2, 0xb4, 0xa4, 0x27, 0xd0, 0x9d, + 0x1b, 0xa6, 0x9a, 0xe0, 0x96, 0xcf, 0x58, 0x97, 0xba, 0xf5, 0xb9, 0xdc, 0xec, 0x5c, 0xf7, 0x90, + 0xdb, 0xec, 0xc5, 0xd1, 0xe9, 0xe0, 0x95, 0x72, 0xa2, 0xb6, 0xea, 0x31, 0x6c, 0x16, 0xa7, 0xa6, + 0x46, 0x58, 0xe9, 0x2c, 0x75, 0xf5, 0xc9, 0x29, 0x0c, 0x50, 0xb3, 0x93, 0x53, 0x36, 0x57, 0x5d, + 0x2a, 0xe8, 0x21, 0x80, 0x6e, 0x32, 0x7c, 0x12, 0xa6, 0x5b, 0xb6, 0xd0, 0xdc, 0xa4, 0x5b, 0x56, + 0xd2, 0x90, 0x3c, 0x00, 0x50, 0xbd, 0x81, 0x4f, 0x13, 0x8e, 0x6e, 0x1a, 0x33, 0xe6, 0x1a, 0x92, + 0x41, 0x7f, 0x91, 0xb0, 0x20, 0x00, 0x33, 0x76, 0x15, 0x01, 0x9f, 0x01, 0x64, 0x3d, 0x87, 0x11, + 0xb0, 0xd0, 0x85, 0xac, 0x88, 0x41, 0x3b, 0xdf, 0x61, 0x20, 0xed, 0x6b, 0x49, 0xd7, 0xb1, 0x42, + 0x44, 0x77, 0xae, 0x80, 0x2d, 0x1e, 0xb6, 0xf9, 0xba, 0x76, 0xb0, 0x50, 0xc4, 0xa2, 0x0f, 0xa1, + 0x9d, 0xaf, 0x5c, 0x8d, 0x15, 0x25, 0xd5, 0xec, 0xa0, 0x50, 0xbd, 0xa2, 0x07, 0xb0, 0x59, 0xac, + 0x5a, 0x51, 0xee, 0x5e, 0x2c, 0xd4, 0xb2, 0x03, 0xdd, 0xc9, 0xe7, 0xd8, 0xdf, 0x07, 0xc8, 0xaa, + 0x5b, 0x13, 0xbe, 0x85, 0x7a, 0x77, 0x4e, 0xeb, 0x43, 0x68, 0xe7, 0x33, 0xb1, 0x31, 0xb7, 0x24, + 0x3b, 0xaf, 0xca, 0x5a, 0xb9, 0xac, 0x6d, 0x0e, 0xdf, 0x62, 0x22, 0x5f, 0x95, 0xb5, 0x0a, 0xcd, + 0x99, 0x49, 0x16, 0x65, 0x1d, 0xdb, 0xaa, 0x5c, 0x5e, 0x6c, 0x82, 0x4c, 0xf8, 0x4a, 0x5b, 0xa3, + 0x55, 0x87, 0x28, 0xdf, 0x0d, 0x98, 0x78, 0x94, 0x74, 0x08, 0xdf, 0x73, 0xa9, 0xf3, 0x15, 0x7f, + 0xee, 0x52, 0x97, 0x34, 0x02, 0x4b, 0x05, 0x1d, 0x41, 0xf7, 0x89, 0x29, 0xe6, 0x74, 0xa1, 0xa9, + 0xcd, 0x29, 0x29, 0xac, 0x07, 0x83, 0x32, 0x92, 0xbe, 0x59, 0x9f, 0x43, 0x6f, 0xa1, 0xc8, 0x44, + 0x77, 0xd2, 0x81, 0x53, 0x69, 0xf5, 0xb9, 0xd4, 0xac, 0x63, 0xd8, 0x9a, 0xaf, 0x31, 0xd1, 0xab, + 0x7a, 0xd3, 0xcb, 0x6b, 0xcf, 0xa5, 0xa2, 0x3e, 0x86, 0x86, 0xa9, 0x69, 0x90, 0x1e, 0xec, 0xcd, + 0xd5, 0x38, 0xcb, 0x96, 0x1e, 0xb4, 0xbf, 0xfd, 0xee, 0x4e, 0xe5, 0x1f, 0xdf, 0xdd, 0xa9, 0xfc, + 0xfb, 0xbb, 0x3b, 0x95, 0xb3, 0x75, 0x49, 0x7d, 0xff, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x33, + 0x1c, 0xc1, 0x27, 0xe0, 0x1f, 0x00, 0x00, } diff --git a/vendor/github.com/mdlayher/vsock/conn_linux.go b/vendor/github.com/mdlayher/vsock/conn_linux.go index 7de075c325..be81f4af0d 100644 --- a/vendor/github.com/mdlayher/vsock/conn_linux.go +++ b/vendor/github.com/mdlayher/vsock/conn_linux.go @@ -3,7 +3,6 @@ package vsock import ( - "errors" "net" "os" "time" @@ -11,31 +10,40 @@ import ( "golang.org/x/sys/unix" ) -var ( - // errDeadlinesNotImplemented is returned by the SetDeadline family of methods - // for conn, because access is not yet available to the runtime network poller - // for non-standard sockets types. - // See: https://github.com/golang/go/issues/10565. - errDeadlinesNotImplemented = errors.New("vsock: deadlines not implemented") -) - var _ net.Conn = &conn{} // A conn is the net.Conn implementation for VM sockets. type conn struct { - *os.File + file *os.File localAddr *Addr remoteAddr *Addr } -// LocalAddr and RemoteAddr implement the net.Conn interface for conn. -func (c *conn) LocalAddr() net.Addr { return c.localAddr } -func (c *conn) RemoteAddr() net.Addr { return c.remoteAddr } +// Implement net.Conn for type conn. +func (c *conn) LocalAddr() net.Addr { return c.localAddr } +func (c *conn) RemoteAddr() net.Addr { return c.remoteAddr } +func (c *conn) SetDeadline(t time.Time) error { return c.file.SetDeadline(t) } +func (c *conn) SetReadDeadline(t time.Time) error { return c.file.SetReadDeadline(t) } +func (c *conn) SetWriteDeadline(t time.Time) error { return c.file.SetWriteDeadline(t) } +func (c *conn) Read(b []byte) (n int, err error) { return c.file.Read(b) } +func (c *conn) Write(b []byte) (n int, err error) { return c.file.Write(b) } +func (c *conn) Close() error { return c.file.Close() } -// SetDeadline functions implement the net.Conn interface for conn. -func (c *conn) SetDeadline(_ time.Time) error { return errDeadlinesNotImplemented } -func (c *conn) SetReadDeadline(_ time.Time) error { return errDeadlinesNotImplemented } -func (c *conn) SetWriteDeadline(_ time.Time) error { return errDeadlinesNotImplemented } +// newConn creates a conn using an fd with the specified file name, local, and +// remote addresses. +func newConn(cfd fd, file string, local, remote *Addr) (*conn, error) { + // Enable integration with runtime network poller for timeout support + // in Go 1.11+. + if err := cfd.SetNonblock(true); err != nil { + return nil, err + } + + return &conn{ + file: cfd.NewFile(file), + localAddr: local, + remoteAddr: remote, + }, nil +} // dialStream is the entry point for DialStream on Linux. func dialStream(cid, port uint32) (net.Conn, error) { @@ -89,9 +97,6 @@ func dialStreamLinux(cfd fd, cid, port uint32) (net.Conn, error) { Port: port, } - return &conn{ - File: cfd.NewFile(remoteAddr.fileName()), - localAddr: localAddr, - remoteAddr: remoteAddr, - }, nil + // File name is the name of the local socket. + return newConn(cfd, localAddr.fileName(), localAddr, remoteAddr) } diff --git a/vendor/github.com/mdlayher/vsock/fd_linux.go b/vendor/github.com/mdlayher/vsock/fd_linux.go index c4713c85da..9cfd0c27dc 100644 --- a/vendor/github.com/mdlayher/vsock/fd_linux.go +++ b/vendor/github.com/mdlayher/vsock/fd_linux.go @@ -11,11 +11,12 @@ import ( type fd interface { Accept4(flags int) (fd, unix.Sockaddr, error) Bind(sa unix.Sockaddr) error - Connect(sa unix.Sockaddr) error Close() error + Connect(sa unix.Sockaddr) error Getsockname() (unix.Sockaddr, error) Listen(n int) error NewFile(name string) *os.File + SetNonblock(nonblocking bool) error } var _ fd = &sysFD{} @@ -38,6 +39,7 @@ func (fd *sysFD) Accept4(flags int) (fd, unix.Sockaddr, error) { func (fd *sysFD) Bind(sa unix.Sockaddr) error { return unix.Bind(fd.fd, sa) } func (fd *sysFD) Close() error { return unix.Close(fd.fd) } func (fd *sysFD) Connect(sa unix.Sockaddr) error { return unix.Connect(fd.fd, sa) } +func (fd *sysFD) Getsockname() (unix.Sockaddr, error) { return unix.Getsockname(fd.fd) } func (fd *sysFD) Listen(n int) error { return unix.Listen(fd.fd, n) } func (fd *sysFD) NewFile(name string) *os.File { return os.NewFile(uintptr(fd.fd), name) } -func (fd *sysFD) Getsockname() (unix.Sockaddr, error) { return unix.Getsockname(fd.fd) } +func (fd *sysFD) SetNonblock(nonblocking bool) error { return unix.SetNonblock(fd.fd, nonblocking) } diff --git a/vendor/github.com/mdlayher/vsock/listener_linux.go b/vendor/github.com/mdlayher/vsock/listener_linux.go index ecf5d8a67c..f74a263f6e 100644 --- a/vendor/github.com/mdlayher/vsock/listener_linux.go +++ b/vendor/github.com/mdlayher/vsock/listener_linux.go @@ -35,11 +35,7 @@ func (l *listener) Accept() (net.Conn, error) { Port: savm.Port, } - return &conn{ - File: cfd.NewFile(l.addr.fileName()), - localAddr: l.addr, - remoteAddr: remoteAddr, - }, nil + return newConn(cfd, l.addr.fileName(), l.addr, remoteAddr) } // listenStream is the entry point for ListenStream on Linux. @@ -87,6 +83,10 @@ func listenStreamLinux(lfd fd, cid, port uint32) (net.Listener, error) { Port: port, } + if err := lfd.SetNonblock(true); err != nil { + return nil, err + } + if err := lfd.Bind(sa); err != nil { return nil, err } diff --git a/virtcontainers/kata_agent_test.go b/virtcontainers/kata_agent_test.go index b1e27f1d9e..9ce6d1907c 100644 --- a/virtcontainers/kata_agent_test.go +++ b/virtcontainers/kata_agent_test.go @@ -191,14 +191,6 @@ func (p *gRPCProxy) DestroySandbox(ctx context.Context, req *pb.DestroySandboxRe return emptyResp, nil } -func (p *gRPCProxy) AddInterface(ctx context.Context, req *pb.AddInterfaceRequest) (*aTypes.Interface, error) { - return nil, nil -} - -func (p *gRPCProxy) RemoveInterface(ctx context.Context, req *pb.RemoveInterfaceRequest) (*aTypes.Interface, error) { - return nil, nil -} - func (p *gRPCProxy) UpdateInterface(ctx context.Context, req *pb.UpdateInterfaceRequest) (*aTypes.Interface, error) { return &aTypes.Interface{}, nil } From ed64240df2b3107b27e856d0bd657791c8b03bd9 Mon Sep 17 00:00:00 2001 From: "James O. D. Hunt" Date: Mon, 15 Apr 2019 11:54:35 +0100 Subject: [PATCH 7/7] agent: Support Kata agent tracing Add configuration options to support the various Kata agent tracing modes and types. See the comments in the built configuration files for details: - `cli/config/configuration-fc.toml` - `cli/config/configuration-qemu.toml` Fixes #1369. Signed-off-by: James O. D. Hunt --- cli/config/configuration-fc.toml.in | 21 +++ cli/config/configuration-qemu.toml.in | 21 +++ cli/kata-env.go | 12 +- cli/kata-env_test.go | 18 +++ pkg/katautils/config.go | 29 +++- pkg/katautils/config_test.go | 10 ++ virtcontainers/agent.go | 2 +- virtcontainers/kata_agent.go | 111 ++++++++++++-- virtcontainers/kata_agent_test.go | 213 ++++++++++++++++++++++++-- virtcontainers/noop_agent.go | 4 +- virtcontainers/noop_agent_test.go | 6 +- virtcontainers/sandbox.go | 18 ++- virtcontainers/vm_test.go | 2 +- 13 files changed, 424 insertions(+), 43 deletions(-) diff --git a/cli/config/configuration-fc.toml.in b/cli/config/configuration-fc.toml.in index 7cc052b728..d90c79e2d1 100644 --- a/cli/config/configuration-fc.toml.in +++ b/cli/config/configuration-fc.toml.in @@ -226,6 +226,27 @@ path = "@SHIMPATH@" # (default: disabled) #enable_debug = true +# Enable agent tracing. +# +# If enabled, the default trace mode is "dynamic" and the +# default trace type is "isolated". The trace mode and type are set +# explicity with the `trace_type=` and `trace_mode=` options. +# +# Notes: +# +# - Tracing is ONLY enabled when `enable_tracing` is set: explicitly +# setting `trace_mode=` and/or `trace_type=` without setting `enable_tracing` +# will NOT activate agent tracing. +# +# - See https://github.com/kata-containers/agent/blob/master/TRACING.md for +# full details. +# +# (default: disabled) +#enable_tracing = true +# +#trace_mode = "dynamic" +#trace_type = "isolated" + [netmon] # If enabled, the network monitoring process gets started when the # sandbox is created. This allows for the detection of some additional diff --git a/cli/config/configuration-qemu.toml.in b/cli/config/configuration-qemu.toml.in index 0c875fd4f2..c7fd600c44 100644 --- a/cli/config/configuration-qemu.toml.in +++ b/cli/config/configuration-qemu.toml.in @@ -278,6 +278,27 @@ path = "@SHIMPATH@" # (default: disabled) #enable_debug = true +# Enable agent tracing. +# +# If enabled, the default trace mode is "dynamic" and the +# default trace type is "isolated". The trace mode and type are set +# explicity with the `trace_type=` and `trace_mode=` options. +# +# Notes: +# +# - Tracing is ONLY enabled when `enable_tracing` is set: explicitly +# setting `trace_mode=` and/or `trace_type=` without setting `enable_tracing` +# will NOT activate agent tracing. +# +# - See https://github.com/kata-containers/agent/blob/master/TRACING.md for +# full details. +# +# (default: disabled) +#enable_tracing = true +# +#trace_mode = "dynamic" +#trace_type = "isolated" + [netmon] # If enabled, the network monitoring process gets started when the # sandbox is created. This allows for the detection of some additional diff --git a/cli/kata-env.go b/cli/kata-env.go index 0d6883bb75..af8c9a7513 100644 --- a/cli/kata-env.go +++ b/cli/kata-env.go @@ -27,7 +27,7 @@ import ( // // XXX: Increment for every change to the output format // (meaning any change to the EnvInfo type). -const formatVersion = "1.0.22" +const formatVersion = "1.0.23" // MetaInfo stores information on the format of the output itself type MetaInfo struct { @@ -112,8 +112,11 @@ type ShimInfo struct { // AgentInfo stores agent details type AgentInfo struct { - Type string - Debug bool + Type string + Debug bool + Trace bool + TraceMode string + TraceType string } // DistroInfo stores host operating system distribution details. @@ -321,6 +324,9 @@ func getAgentInfo(config oci.RuntimeConfig) (AgentInfo, error) { return AgentInfo{}, errors.New("cannot determine Kata agent config") } agent.Debug = agentConfig.Debug + agent.Trace = agentConfig.Trace + agent.TraceMode = agentConfig.TraceMode + agent.TraceType = agentConfig.TraceType default: // Nothing useful to report for the other agent types } diff --git a/cli/kata-env_test.go b/cli/kata-env_test.go index 23c0d65de1..21e070f630 100644 --- a/cli/kata-env_test.go +++ b/cli/kata-env_test.go @@ -43,6 +43,7 @@ var ( shimDebug = false netmonDebug = false agentDebug = false + agentTrace = false ) // makeVersionBinary creates a shell script with the specified file @@ -155,6 +156,7 @@ func makeRuntimeConfig(prefixDir string) (configFile string, config oci.RuntimeC ShimDebug: shimDebug, NetmonDebug: netmonDebug, AgentDebug: agentDebug, + AgentTrace: agentTrace, } runtimeConfig := katatestutils.MakeRuntimeConfigFileData(configFileOptions) @@ -217,6 +219,11 @@ func getExpectedAgentDetails(config oci.RuntimeConfig) (AgentInfo, error) { return AgentInfo{ Type: string(config.AgentType), Debug: agentConfig.Debug, + Trace: agentConfig.Trace, + + // No trace mode/type set by default + TraceMode: "", + TraceType: "", }, nil } @@ -496,6 +503,7 @@ func TestEnvGetEnvInfo(t *testing.T) { runtimeTrace = toggle shimDebug = toggle agentDebug = toggle + agentTrace = toggle configFile, config, err := makeRuntimeConfig(tmpdir) assert.NoError(t, err) @@ -823,6 +831,16 @@ func TestEnvGetAgentInfo(t *testing.T) { assert.NoError(t, err) assert.True(t, agent.Debug) + agentConfig.Trace = true + agentConfig.TraceMode = "traceMode" + agentConfig.TraceType = "traceType" + config.AgentConfig = agentConfig + agent, err = getAgentInfo(config) + assert.NoError(t, err) + assert.True(t, agent.Trace) + assert.Equal(t, agent.TraceMode, "traceMode") + assert.Equal(t, agent.TraceType, "traceType") + config.AgentConfig = "I am the wrong type" _, err = getAgentInfo(config) assert.Error(t, err) diff --git a/pkg/katautils/config.go b/pkg/katautils/config.go index 354c83c258..99cf9a3cd7 100644 --- a/pkg/katautils/config.go +++ b/pkg/katautils/config.go @@ -136,7 +136,10 @@ type shim struct { } type agent struct { - Debug bool `toml:"enable_debug"` + Debug bool `toml:"enable_debug"` + Tracing bool `toml:"enable_tracing"` + TraceMode string `toml:"trace_mode"` + TraceType string `toml:"trace_type"` } type netmon struct { @@ -393,6 +396,18 @@ func (a agent) debug() bool { return a.Debug } +func (a agent) trace() bool { + return a.Tracing +} + +func (a agent) traceMode() string { + return a.TraceMode +} + +func (a agent) traceType() string { + return a.TraceType +} + func (n netmon) enable() bool { return n.Enable } @@ -656,8 +671,11 @@ func updateRuntimeConfigAgent(configPath string, tomlConf tomlConfig, config *oc case kataAgentTableType: config.AgentType = vc.KataContainersAgent config.AgentConfig = vc.KataAgentConfig{ - UseVSock: config.HypervisorConfig.UseVSock, - Debug: agent.debug(), + UseVSock: config.HypervisorConfig.UseVSock, + Debug: agent.debug(), + Trace: agent.trace(), + TraceMode: agent.traceMode(), + TraceType: agent.traceType(), } default: return fmt.Errorf("%s agent type is not supported", k) @@ -720,6 +738,11 @@ func SetKernelParams(runtimeConfig *oci.RuntimeConfig) error { // next, check for agent specific kernel params if agentConfig, ok := runtimeConfig.AgentConfig.(vc.KataAgentConfig); ok { + err := vc.KataAgentSetDefaultTraceConfigOptions(&agentConfig) + if err != nil { + return err + } + params := vc.KataAgentKernelParams(agentConfig) for _, p := range params { diff --git a/pkg/katautils/config_test.go b/pkg/katautils/config_test.go index 163d9c9d39..44d4348937 100644 --- a/pkg/katautils/config_test.go +++ b/pkg/katautils/config_test.go @@ -34,6 +34,7 @@ var ( shimDebug = false netmonDebug = false agentDebug = false + agentTrace = false ) type testRuntimeConfig struct { @@ -111,6 +112,7 @@ func createAllRuntimeConfigFiles(dir, hypervisor string) (config testRuntimeConf ShimDebug: shimDebug, NetmonDebug: netmonDebug, AgentDebug: agentDebug, + AgentTrace: agentTrace, } runtimeConfigFileData := katatestutils.MakeRuntimeConfigFileData(configFileOptions) @@ -1208,6 +1210,14 @@ func TestAgentDefaults(t *testing.T) { a.Debug = true assert.Equal(a.debug(), a.Debug) + + assert.Equal(a.trace(), a.Tracing) + + a.Tracing = true + assert.Equal(a.trace(), a.Tracing) + + assert.Equal(a.traceMode(), a.TraceMode) + assert.Equal(a.traceType(), a.TraceType) } func TestGetDefaultConfigFilePaths(t *testing.T) { diff --git a/virtcontainers/agent.go b/virtcontainers/agent.go index fb24cfa4b5..bd4dd90676 100644 --- a/virtcontainers/agent.go +++ b/virtcontainers/agent.go @@ -116,7 +116,7 @@ type agent interface { // init(). // After init() is called, agent implementations should be initialized and ready // to handle all other Agent interface methods. - init(ctx context.Context, sandbox *Sandbox, config interface{}) error + init(ctx context.Context, sandbox *Sandbox, config interface{}) (disableVMShutdown bool, err error) // capabilities should return a structure that specifies the capabilities // supported by the agent. diff --git a/virtcontainers/kata_agent.go b/virtcontainers/kata_agent.go index 87cd4442f0..e30a87856d 100644 --- a/virtcontainers/kata_agent.go +++ b/virtcontainers/kata_agent.go @@ -83,12 +83,25 @@ var ( maxHostnameLen = 64 ) +const ( + agentTraceModeDynamic = "dynamic" + agentTraceModeStatic = "static" + agentTraceTypeIsolated = "isolated" + agentTraceTypeCollated = "collated" + + defaultAgentTraceMode = agentTraceModeDynamic + defaultAgentTraceType = agentTraceTypeIsolated +) + // KataAgentConfig is a structure storing information needed // to reach the Kata Containers agent. type KataAgentConfig struct { LongLiveConn bool UseVSock bool Debug bool + Trace bool + TraceMode string + TraceType string } type kataVSOCK struct { @@ -116,10 +129,11 @@ type kataAgent struct { sync.Mutex client *kataclient.AgentClient - reqHandlers map[string]reqFunc - state KataAgentState - keepConn bool - proxyBuiltIn bool + reqHandlers map[string]reqFunc + state KataAgentState + keepConn bool + proxyBuiltIn bool + dynamicTracing bool vmSocket interface{} ctx context.Context @@ -176,6 +190,34 @@ func (k *kataAgent) generateVMSocket(id string, c KataAgentConfig) error { return nil } +// KataAgentSetDefaultTraceConfigOptions validates agent trace options and +// sets defaults. +func KataAgentSetDefaultTraceConfigOptions(config *KataAgentConfig) error { + if !config.Trace { + return nil + } + + switch config.TraceMode { + case agentTraceModeDynamic: + case agentTraceModeStatic: + case "": + config.TraceMode = defaultAgentTraceMode + default: + return fmt.Errorf("invalid kata agent trace mode: %q (need %q or %q)", config.TraceMode, agentTraceModeDynamic, agentTraceModeStatic) + } + + switch config.TraceType { + case agentTraceTypeIsolated: + case agentTraceTypeCollated: + case "": + config.TraceType = defaultAgentTraceType + default: + return fmt.Errorf("invalid kata agent trace type: %q (need %q or %q)", config.TraceType, agentTraceTypeIsolated, agentTraceTypeCollated) + } + + return nil +} + // KataAgentKernelParams returns a list of Kata Agent specific kernel // parameters. func KataAgentKernelParams(config KataAgentConfig) []Param { @@ -185,10 +227,31 @@ func KataAgentKernelParams(config KataAgentConfig) []Param { params = append(params, Param{Key: "agent.log", Value: "debug"}) } + if config.Trace && config.TraceMode == agentTraceModeStatic { + params = append(params, Param{Key: "agent.trace", Value: config.TraceType}) + } + return params } -func (k *kataAgent) init(ctx context.Context, sandbox *Sandbox, config interface{}) (err error) { +func (k *kataAgent) handleTraceSettings(config KataAgentConfig) bool { + if !config.Trace { + return false + } + + disableVMShutdown := false + + switch config.TraceMode { + case agentTraceModeStatic: + disableVMShutdown = true + case agentTraceModeDynamic: + k.dynamicTracing = true + } + + return disableVMShutdown +} + +func (k *kataAgent) init(ctx context.Context, sandbox *Sandbox, config interface{}) (disableVMShutdown bool, err error) { // save k.ctx = sandbox.ctx @@ -198,21 +261,23 @@ func (k *kataAgent) init(ctx context.Context, sandbox *Sandbox, config interface switch c := config.(type) { case KataAgentConfig: if err := k.generateVMSocket(sandbox.id, c); err != nil { - return err + return false, err } + + disableVMShutdown = k.handleTraceSettings(c) k.keepConn = c.LongLiveConn default: - return vcTypes.ErrInvalidConfigType + return false, vcTypes.ErrInvalidConfigType } k.proxy, err = newProxy(sandbox.config.ProxyType) if err != nil { - return err + return false, err } k.shim, err = newShim(sandbox.config.ShimType) if err != nil { - return err + return false, err } k.proxyBuiltIn = isProxyBuiltIn(sandbox.config.ProxyType) @@ -222,7 +287,7 @@ func (k *kataAgent) init(ctx context.Context, sandbox *Sandbox, config interface k.Logger().Debug("Could not retrieve anything from storage") } - return nil + return disableVMShutdown, nil } func (k *kataAgent) agentURL() (string, error) { @@ -715,7 +780,18 @@ func (k *kataAgent) startSandbox(sandbox *Sandbox) error { } _, err = k.sendReq(req) - return err + if err != nil { + return err + } + + if k.dynamicTracing { + _, err = k.sendReq(&grpc.StartTracingRequest{}) + if err != nil { + return err + } + } + + return nil } func (k *kataAgent) stopSandbox(sandbox *Sandbox) error { @@ -732,6 +808,13 @@ func (k *kataAgent) stopSandbox(sandbox *Sandbox) error { return err } + if k.dynamicTracing { + _, err := k.sendReq(&grpc.StopTracingRequest{}) + if err != nil { + return err + } + } + if err := k.proxy.stop(k.state.ProxyPid); err != nil { return err } @@ -1645,6 +1728,12 @@ func (k *kataAgent) installReqFunc(c *kataclient.AgentClient) { k.reqHandlers["grpc.SetGuestDateTimeRequest"] = func(ctx context.Context, req interface{}, opts ...golangGrpc.CallOption) (interface{}, error) { return k.client.SetGuestDateTime(ctx, req.(*grpc.SetGuestDateTimeRequest), opts...) } + k.reqHandlers["grpc.StartTracingRequest"] = func(ctx context.Context, req interface{}, opts ...golangGrpc.CallOption) (interface{}, error) { + return k.client.StartTracing(ctx, req.(*grpc.StartTracingRequest), opts...) + } + k.reqHandlers["grpc.StopTracingRequest"] = func(ctx context.Context, req interface{}, opts ...golangGrpc.CallOption) (interface{}, error) { + return k.client.StopTracing(ctx, req.(*grpc.StopTracingRequest), opts...) + } } func (k *kataAgent) sendReq(request interface{}) (interface{}, error) { diff --git a/virtcontainers/kata_agent_test.go b/virtcontainers/kata_agent_test.go index 9ce6d1907c..c9df07c6a4 100644 --- a/virtcontainers/kata_agent_test.go +++ b/virtcontainers/kata_agent_test.go @@ -248,6 +248,14 @@ func (p *gRPCProxy) CopyFile(ctx context.Context, req *pb.CopyFileRequest) (*gpb return &gpb.Empty{}, nil } +func (p *gRPCProxy) StartTracing(ctx context.Context, req *pb.StartTracingRequest) (*gpb.Empty, error) { + return &gpb.Empty{}, nil +} + +func (p *gRPCProxy) StopTracing(ctx context.Context, req *pb.StopTracingRequest) (*gpb.Empty, error) { + return &gpb.Empty{}, nil +} + func (p *gRPCProxy) MemHotplugByProbe(ctx context.Context, req *pb.MemHotplugByProbeRequest) (*gpb.Empty, error) { return &gpb.Empty{}, nil } @@ -930,22 +938,195 @@ func TestKataCleanupSandbox(t *testing.T) { func TestKataAgentKernelParams(t *testing.T) { assert := assert.New(t) - config := KataAgentConfig{} - - params := KataAgentKernelParams(config) - assert.Empty(params) - - config.Debug = true - - params = KataAgentKernelParams(config) - assert.NotEmpty(params) - - assert.Len(params, 1) - - expected := Param{ - Key: "agent.log", - Value: "debug", + type testData struct { + debug bool + trace bool + traceMode string + traceType string + expectedParams []Param } - assert.Equal(params[0], expected) + debugParam := Param{Key: "agent.log", Value: "debug"} + + traceIsolatedParam := Param{Key: "agent.trace", Value: "isolated"} + traceCollatedParam := Param{Key: "agent.trace", Value: "collated"} + + traceFooParam := Param{Key: "agent.trace", Value: "foo"} + + data := []testData{ + {false, false, "", "", []Param{}}, + {true, false, "", "", []Param{debugParam}}, + + {false, false, "foo", "", []Param{}}, + {false, false, "foo", "", []Param{}}, + {false, false, "", "foo", []Param{}}, + {false, false, "", "foo", []Param{}}, + {false, false, "foo", "foo", []Param{}}, + {false, true, "foo", "foo", []Param{}}, + + {false, false, agentTraceModeDynamic, "", []Param{}}, + {false, false, agentTraceModeStatic, "", []Param{}}, + {false, false, "", agentTraceTypeIsolated, []Param{}}, + {false, false, "", agentTraceTypeCollated, []Param{}}, + {false, false, "foo", agentTraceTypeIsolated, []Param{}}, + {false, false, "foo", agentTraceTypeCollated, []Param{}}, + + {false, false, agentTraceModeDynamic, agentTraceTypeIsolated, []Param{}}, + {false, false, agentTraceModeDynamic, agentTraceTypeCollated, []Param{}}, + + {false, false, agentTraceModeStatic, agentTraceTypeCollated, []Param{}}, + {false, false, agentTraceModeStatic, agentTraceTypeCollated, []Param{}}, + + {false, true, agentTraceModeDynamic, agentTraceTypeIsolated, []Param{}}, + {false, true, agentTraceModeDynamic, agentTraceTypeCollated, []Param{}}, + {true, true, agentTraceModeDynamic, agentTraceTypeCollated, []Param{debugParam}}, + + {false, true, "", agentTraceTypeIsolated, []Param{}}, + {false, true, "", agentTraceTypeCollated, []Param{}}, + {true, true, "", agentTraceTypeIsolated, []Param{debugParam}}, + {true, true, "", agentTraceTypeCollated, []Param{debugParam}}, + {false, true, "foo", agentTraceTypeIsolated, []Param{}}, + {false, true, "foo", agentTraceTypeCollated, []Param{}}, + {true, true, "foo", agentTraceTypeIsolated, []Param{debugParam}}, + {true, true, "foo", agentTraceTypeCollated, []Param{debugParam}}, + + {false, true, agentTraceModeStatic, agentTraceTypeIsolated, []Param{traceIsolatedParam}}, + {false, true, agentTraceModeStatic, agentTraceTypeCollated, []Param{traceCollatedParam}}, + {true, true, agentTraceModeStatic, agentTraceTypeIsolated, []Param{traceIsolatedParam, debugParam}}, + {true, true, agentTraceModeStatic, agentTraceTypeCollated, []Param{traceCollatedParam, debugParam}}, + + {false, true, agentTraceModeStatic, "foo", []Param{traceFooParam}}, + {true, true, agentTraceModeStatic, "foo", []Param{debugParam, traceFooParam}}, + } + + for i, d := range data { + config := KataAgentConfig{ + Debug: d.debug, + Trace: d.trace, + TraceMode: d.traceMode, + TraceType: d.traceType, + } + + count := len(d.expectedParams) + + params := KataAgentKernelParams(config) + + if count == 0 { + assert.Emptyf(params, "test %d (%+v)", i, d) + continue + } + + assert.Len(params, count) + + for _, p := range d.expectedParams { + assert.Containsf(params, p, "test %d (%+v)", i, d) + } + } +} + +func TestKataAgentHandleTraceSettings(t *testing.T) { + assert := assert.New(t) + + type testData struct { + traceMode string + trace bool + expectDisableVMShutdown bool + expectDynamicTracing bool + } + + data := []testData{ + {"", false, false, false}, + {"", true, false, false}, + {agentTraceModeStatic, true, true, false}, + {agentTraceModeDynamic, true, false, true}, + } + + for i, d := range data { + k := &kataAgent{} + + config := KataAgentConfig{ + Trace: d.trace, + TraceMode: d.traceMode, + } + + disableVMShutdown := k.handleTraceSettings(config) + + if d.expectDisableVMShutdown { + assert.Truef(disableVMShutdown, "test %d (%+v)", i, d) + } else { + assert.Falsef(disableVMShutdown, "test %d (%+v)", i, d) + } + + if d.expectDynamicTracing { + assert.Truef(k.dynamicTracing, "test %d (%+v)", i, d) + } else { + assert.Falsef(k.dynamicTracing, "test %d (%+v)", i, d) + } + } +} + +func TestKataAgentSetDefaultTraceConfigOptions(t *testing.T) { + assert := assert.New(t) + + type testData struct { + traceMode string + traceType string + trace bool + expectDefaultTraceMode bool + expectDefaultTraceType bool + expectError bool + } + + data := []testData{ + {"", "", false, false, false, false}, + {agentTraceModeDynamic, agentTraceTypeCollated, false, false, false, false}, + {agentTraceModeDynamic, agentTraceTypeIsolated, false, false, false, false}, + {agentTraceModeStatic, agentTraceTypeCollated, false, false, false, false}, + {agentTraceModeStatic, agentTraceTypeIsolated, false, false, false, false}, + + {agentTraceModeDynamic, agentTraceTypeCollated, true, false, false, false}, + {agentTraceModeDynamic, agentTraceTypeIsolated, true, false, false, false}, + + {agentTraceModeStatic, agentTraceTypeCollated, true, false, false, false}, + {agentTraceModeStatic, agentTraceTypeIsolated, true, false, false, false}, + + {agentTraceModeDynamic, "", true, false, true, false}, + {agentTraceModeDynamic, "invalid", true, false, false, true}, + + {agentTraceModeStatic, "", true, false, true, false}, + {agentTraceModeStatic, "invalid", true, false, false, true}, + + {"", agentTraceTypeIsolated, true, true, false, false}, + {"invalid", agentTraceTypeIsolated, true, false, false, true}, + + {"", agentTraceTypeCollated, true, true, false, false}, + {"invalid", agentTraceTypeCollated, true, false, false, true}, + + {"", "", true, true, true, false}, + {"invalid", "invalid", true, false, false, true}, + } + + for i, d := range data { + config := &KataAgentConfig{ + Trace: d.trace, + TraceMode: d.traceMode, + TraceType: d.traceType, + } + + err := KataAgentSetDefaultTraceConfigOptions(config) + if d.expectError { + assert.Error(err, "test %d (%+v)", i, d) + continue + } else { + assert.NoError(err, "test %d (%+v)", i, d) + } + + if d.expectDefaultTraceMode { + assert.Equalf(config.TraceMode, defaultAgentTraceMode, "test %d (%+v)", i, d) + } + + if d.expectDefaultTraceType { + assert.Equalf(config.TraceType, defaultAgentTraceType, "test %d (%+v)", i, d) + } + } } diff --git a/virtcontainers/noop_agent.go b/virtcontainers/noop_agent.go index cf609128f2..592634a70e 100644 --- a/virtcontainers/noop_agent.go +++ b/virtcontainers/noop_agent.go @@ -27,8 +27,8 @@ func (n *noopAgent) startProxy(sandbox *Sandbox) error { } // init initializes the Noop agent, i.e. it does nothing. -func (n *noopAgent) init(ctx context.Context, sandbox *Sandbox, config interface{}) error { - return nil +func (n *noopAgent) init(ctx context.Context, sandbox *Sandbox, config interface{}) (bool, error) { + return false, nil } // createSandbox is the Noop agent sandbox creation implementation. It does nothing. diff --git a/virtcontainers/noop_agent_test.go b/virtcontainers/noop_agent_test.go index e62cbe0594..fd9ffbf61e 100644 --- a/virtcontainers/noop_agent_test.go +++ b/virtcontainers/noop_agent_test.go @@ -40,10 +40,14 @@ func TestNoopAgentInit(t *testing.T) { n := &noopAgent{} sandbox := &Sandbox{} - err := n.init(context.Background(), sandbox, nil) + disableVMShutdown, err := n.init(context.Background(), sandbox, nil) if err != nil { t.Fatal(err) } + + if disableVMShutdown != false { + t.Fatal(err) + } } func TestNoopAgentExec(t *testing.T) { diff --git a/virtcontainers/sandbox.go b/virtcontainers/sandbox.go index 5ca4395422..e4b08fa141 100644 --- a/virtcontainers/sandbox.go +++ b/virtcontainers/sandbox.go @@ -186,10 +186,11 @@ type Sandbox struct { wg *sync.WaitGroup - shmSize uint64 - sharePidNs bool - stateful bool - seccompSupported bool + shmSize uint64 + sharePidNs bool + stateful bool + seccompSupported bool + disableVMShutdown bool ctx context.Context } @@ -588,7 +589,7 @@ func newSandbox(ctx context.Context, sandboxConfig SandboxConfig, factory Factor return nil, err } - if err = s.agent.init(ctx, s, agentConfig); err != nil { + if s.disableVMShutdown, err = s.agent.init(ctx, s, agentConfig); err != nil { return nil, err } @@ -1034,6 +1035,13 @@ func (s *Sandbox) stopVM() error { s.Logger().WithError(err).WithField("sandboxid", s.id).Warning("Agent did not stop sandbox") } + if s.disableVMShutdown { + // Do not kill the VM - allow the agent to shut it down + // (only used to support static agent tracing). + s.Logger().Info("Not stopping VM") + return nil + } + s.Logger().Info("Stopping VM") return s.hypervisor.stopSandbox() } diff --git a/virtcontainers/vm_test.go b/virtcontainers/vm_test.go index 7b3583b4bb..bc36bcf522 100644 --- a/virtcontainers/vm_test.go +++ b/virtcontainers/vm_test.go @@ -118,7 +118,7 @@ func TestVMConfigGrpc(t *testing.T) { HypervisorType: QemuHypervisor, HypervisorConfig: newQemuConfig(), AgentType: KataContainersAgent, - AgentConfig: KataAgentConfig{false, true, false}, + AgentConfig: KataAgentConfig{false, true, false, false, "", ""}, ProxyType: NoopProxyType, }