From ccc8a5a24077d25a0344b282ec58f5268efe0b8b Mon Sep 17 00:00:00 2001 From: halfrost Date: Wed, 26 Oct 2022 09:12:40 -0700 Subject: [PATCH 1/2] Add wasm extension --- envoy.yaml | 86 ++++++++++ main.go | 456 +++++++++++++++++++++++++++++++++++++++++++++++++++ sentinel.yml | 39 +++++ 3 files changed, 581 insertions(+) create mode 100644 envoy.yaml create mode 100644 main.go create mode 100644 sentinel.yml diff --git a/envoy.yaml b/envoy.yaml new file mode 100644 index 0000000..708e5bc --- /dev/null +++ b/envoy.yaml @@ -0,0 +1,86 @@ +static_resources: + listeners: + - name: tcp + address: + socket_address: + address: 0.0.0.0 + port_value: 18000 + filter_chains: + - filters: + - name: envoy.filters.network.wasm + typed_config: + "@type": type.googleapis.com/envoy.extensions.filters.network.wasm.v3.Wasm + config: + # Instruct that the PluginContext should behave as a Tcp filter. + configuration: + "@type": type.googleapis.com/google.protobuf.StringValue + value: | + { + "config_path": "./sentinel.yml", + "resource_name": "http://localhost/" + } + # Use the same vm_config as above, so we can reuse the same VM for multiple queues. + vm_config: + vm_id: "sender" + runtime: "envoy.wasm.runtime.v8" + code: + local: + filename: "main.wasm" + + - name: envoy.tcp_proxy + typed_config: + "@type": type.googleapis.com/envoy.extensions.filters.network.tcp_proxy.v3.TcpProxy + stat_prefix: ingress + cluster: web_service + + - name: http + address: + socket_address: + address: 127.0.0.1 + port_value: 8099 + filter_chains: + - filters: + - name: envoy.http_connection_manager + typed_config: + "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager + stat_prefix: ingress_http + codec_type: auto + route_config: + name: local_route + virtual_hosts: + - name: local_service + domains: + - "*" + routes: + - match: + prefix: "/" + direct_response: + status: 200 + body: + inline_string: "example body\n" + http_filters: + - name: envoy.filters.http.router + typed_config: + "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router + + clusters: + - name: web_service + connect_timeout: 0.25s + type: STATIC + lb_policy: ROUND_ROBIN + load_assignment: + cluster_name: mock_service + endpoints: + - lb_endpoints: + - endpoint: + address: + socket_address: + address: 127.0.0.1 + port_value: 8099 + +admin: + access_log_path: "/dev/null" + address: + socket_address: + address: 0.0.0.0 + port_value: 8001 \ No newline at end of file diff --git a/main.go b/main.go new file mode 100644 index 0000000..3be7ceb --- /dev/null +++ b/main.go @@ -0,0 +1,456 @@ +package main + +import ( + "encoding/json" + "errors" + "fmt" + "io" + "log" + "net/http" + "os" + "strconv" + "time" + + sentinel "github.com/alibaba/sentinel-golang/api" + "github.com/alibaba/sentinel-golang/core/base" + "github.com/alibaba/sentinel-golang/core/circuitbreaker" + "github.com/alibaba/sentinel-golang/core/config" + "github.com/alibaba/sentinel-golang/core/flow" + "github.com/alibaba/sentinel-golang/core/hotspot" + "github.com/alibaba/sentinel-golang/core/isolation" + "github.com/alibaba/sentinel-golang/core/system" + "github.com/alibaba/sentinel-golang/logging" + "github.com/tetratelabs/proxy-wasm-go-sdk/proxywasm" + "github.com/tetratelabs/proxy-wasm-go-sdk/proxywasm/types" + "gopkg.in/yaml.v2" +) + +type Metric int + +const ( + RequestAmount Metric = iota + CpuPercentage +) + +type Mode int + +const ( + Global Mode = iota + Local +) + +type Strategy int + +const ( + SlowRequestRatio Strategy = iota + ErrorRatio + ErrorCount + BBR +) + +var ( + strategyMap = map[string]circuitbreaker.Strategy{ + "SlowRequestRatio": circuitbreaker.SlowRequestRatio, + "ErrorRatio": circuitbreaker.ErrorRatio, + "ErrorCount": circuitbreaker.ErrorCount, + } + modeMap = map[string]Mode{ + "Global": Global, + "Local": Local, + } + metricMap = map[string]hotspot.MetricType{ + "Concurrency": hotspot.Concurrency, + "QPS": hotspot.Concurrency, + } + tokenCalculateStrategyMap = map[string]flow.TokenCalculateStrategy{ + "Direct": flow.Direct, + "WarmUp": flow.WarmUp, + "MemoryAdaptive": flow.MemoryAdaptive, + } + controlBehaviorMap = map[string]flow.ControlBehavior{ + "Reject": flow.Reject, + "Throttling": flow.Throttling, + } + relationStrategyMap = map[string]flow.RelationStrategy{ + "CurrentResource": flow.CurrentResource, + "AssociatedResource": flow.AssociatedResource, + } + adaptiveStrategyMap = map[string]system.AdaptiveStrategy{ + "none": system.NoAdaptive, + "bbr": system.BBR, + } + systemMetricMap = map[string]system.MetricType{ + "load": system.Load, + "avgRT": system.AvgRT, + "concurrency": system.Concurrency, + "inboundQPS": system.InboundQPS, + "cpuUsage": system.CpuUsage, + } + confs *[]Conf +) + +type Kind int + +const ( + RateLimitStrategy Kind = 0 + ThrottlingStrategy Kind = 1 + ConcurrencyLimitStrategy Kind = 2 + CircuitBreakerStrategy Kind = 3 + AdaptiveOverloadProtectionStrategy Kind = 4 +) + +type Pair struct { + Key string `yaml:"key"` + Value string `yaml:"value"` +} + +type Conf struct { + Apiversion string `yaml:"apiVersion"` + KindType string `yaml:"kind"` + Metadata struct { + Name string `yaml:"name"` + } `yaml:"metadata"` + Spec struct { + Behavior string `yaml:"behavior"` + BehaviorDesc struct { + ResponseStatusCode int `yaml:"responseStatusCode"` + ResponseContentBody string `yaml:"responseContentBody"` + ResponseAdditionalHeaders []Pair `yaml:"responseAdditionalHeaders"` + } `yaml:"behaviorDesc"` + MetricType string `yaml:"metricType"` + LimitMode string `yaml:"limitMode"` + Threshold float64 `yaml:"threshold"` + StatDuration uint32 `yaml:"statDuration"` // unit is second + MinIntervalOfRequests uint32 `yaml:"minIntervalOfRequests"` // unit is millisecond + QueueTimeout uint32 `yaml:"queueTimeout"` // unit is millisecond + RecoveryTimeout uint32 `yaml:"recoveryTimeout"` // unit is second + RetryTimeoutMs uint32 `yaml:"retryTimeoutMs"` // unit is millisecond + StatIntervalMs uint32 `yaml:"statIntervalMs"` // unit is millisecond + MaxConcurrency uint32 `yaml:"maxConcurrency"` + StrategyType string `yaml:"strategy"` + TriggerRatio float64 `yaml:"triggerRatio"` + MinRequestAmount uint64 `yaml:"minRequestAmount"` + TriggerThreshold float64 `yaml:"triggerThreshold"` + AdaptiveStrategy string `yaml:"adaptiveStrategy"` + StatSlidingWindowBucketCount uint32 `yaml:"statSlidingWindowBucketCount"` + MaxAllowedRtMs uint64 `yaml:"maxAllowedRtMs"` + ProbeNum uint64 `yaml:"probeNum"` + TokenCalculateStrategy string `yaml:"tokenCalculateStrategy"` + ControlBehavior string `yaml:"controlBehavior"` + RelationStrategy string `yaml:"relationStrategy"` + RefResource string `yaml:"refResource"` + MaxQueueingTimeMs uint32 `yaml:"maxQueueingTimeMs"` + WarmUpPeriodSec uint32 `yaml:"warmUpPeriodSec"` + WarmUpColdFactor uint32 `yaml:"warmUpColdFactor"` + StatIntervalInMs uint32 `yaml:"statIntervalInMs"` + LowMemUsageThreshold int64 `yaml:"lowMemUsageThreshold"` + HighMemUsageThreshold int64 `yaml:"highMemUsageThreshold"` + MemLowWaterMarkBytes int64 `yaml:"memLowWaterMarkBytes"` + MemHighWaterMarkBytes int64 `yaml:"memHighWaterMarkBytes"` + ParamIndex int `yaml:"paramIndex"` + ParamKey string `yaml:"paramKey"` + BurstCount int64 `yaml:"burstCount"` + DurationInSec int64 `yaml:"durationInSec"` + ParamsMaxCapacity int64 `yaml:"paramsMaxCapacity"` + SpecificItems map[interface{}]int64 `yaml:"specificItems"` + TriggerCount float64 `yaml:"triggerCount"` + Strategy string `yaml:"strategy"` + SlowConditions struct { + MaxAllowedRt int `yaml:"maxAllowedRt"` // unit is millisecond + } `yaml:"slowConditions"` + } `yaml:"spec"` +} + +func readYaml(filename string) (*[]Conf, error) { + file, err := os.Open(filename) + if err != nil { + return nil, err + } + dec := yaml.NewDecoder(file) + confs, conf := []Conf{}, Conf{} + err = dec.Decode(&conf) + for err == nil { + confs = append(confs, conf) + fmt.Println(conf) + conf = Conf{} + err = dec.Decode(&conf) + } + if !errors.Is(err, io.EOF) { + return nil, err + } + fmt.Println("Parse yaml complete!") + return &confs, nil +} + +func main() { + proxywasm.SetVMContext(&vmContext{}) +} + +type vmContext struct { + types.DefaultVMContext + contextID uint32 +} + +func (*vmContext) NewPluginContext(contextID uint32) types.PluginContext { + return &pluginContext{contextID: contextID} +} + +func (*vmContext) OnVMStart(vmConfigurationSize int) types.OnVMStartStatus { + return types.OnVMStartStatusOK +} + +type pluginContext struct { + types.DefaultPluginContext + contextID uint32 +} + +func (*pluginContext) NewTcpContext(contextID uint32) types.TcpContext { + return &tcpContext{contextID: time.Now().UnixNano()} +} + +func (*pluginContext) OnPluginStart(pluginConfigurationSize int) types.OnPluginStartStatus { + data, err := proxywasm.GetPluginConfiguration() + if err != nil { + proxywasm.LogCriticalf("error reading plugin configuration: %v", err) + } + + proxywasm.LogInfof("plugin config: %s", string(data)) + plugConfig := map[string]string{} + json.Unmarshal([]byte(data), &plugConfig) + proxywasm.LogInfof("plugin configmap: %v", plugConfig["resource_name"]) + + conf := config.NewDefaultConfig() + conf.Sentinel.Log.Logger = logging.NewConsoleLogger() + + err = sentinel.InitWithConfig(conf) + if err != nil { + proxywasm.LogCritical(err.Error()) + } + + confs, err = readYaml(plugConfig["config_path"]) + if err != nil { + log.Fatal(err) + } + log.Printf("%v", confs) + + flowRules, hotspotRules, circuitbreakerRules, isolationRules, systemRules := []*flow.Rule{}, []*hotspot.Rule{}, []*circuitbreaker.Rule{}, + []*isolation.Rule{}, []*system.Rule{} + for _, conf := range *confs { + switch conf.KindType { + case "RateLimitStrategy": + flowRules = append(flowRules, &flow.Rule{ + Resource: plugConfig["resource_name"], + TokenCalculateStrategy: tokenCalculateStrategyMap[conf.Spec.TokenCalculateStrategy], + ControlBehavior: controlBehaviorMap[conf.Spec.ControlBehavior], + Threshold: conf.Spec.Threshold, + StatIntervalInMs: conf.Spec.StatIntervalMs, + RelationStrategy: relationStrategyMap[conf.Spec.RelationStrategy], + RefResource: conf.Spec.RefResource, + MaxQueueingTimeMs: conf.Spec.MaxQueueingTimeMs, + WarmUpPeriodSec: conf.Spec.WarmUpPeriodSec, + WarmUpColdFactor: conf.Spec.WarmUpColdFactor, + LowMemUsageThreshold: conf.Spec.LowMemUsageThreshold, + HighMemUsageThreshold: conf.Spec.HighMemUsageThreshold, + MemLowWaterMarkBytes: conf.Spec.MemLowWaterMarkBytes, + MemHighWaterMarkBytes: conf.Spec.MemHighWaterMarkBytes, + }) + case "ThrottlingStrategy": + hotspotRules = append(hotspotRules, &hotspot.Rule{ + Resource: plugConfig["resource_name"], + MetricType: hotspot.QPS, + ControlBehavior: hotspot.Throttling, + ParamIndex: conf.Spec.ParamIndex, + ParamKey: conf.Spec.ParamKey, + Threshold: int64(conf.Spec.Threshold), + MaxQueueingTimeMs: int64(conf.Spec.MaxQueueingTimeMs), + BurstCount: conf.Spec.BurstCount, + DurationInSec: conf.Spec.DurationInSec, + ParamsMaxCapacity: conf.Spec.ParamsMaxCapacity, + SpecificItems: conf.Spec.SpecificItems, + }) + case "ConcurrencyLimitStrategy": + isolationRules = append(isolationRules, &isolation.Rule{ + Resource: plugConfig["resource_name"], + MetricType: isolation.Concurrency, + Threshold: uint32(conf.Spec.Threshold), + }) + case "CircuitBreakerStrategy": + circuitbreakerRules = append(circuitbreakerRules, &circuitbreaker.Rule{ + Resource: plugConfig["resource_name"], + Strategy: strategyMap[conf.Spec.StrategyType], + RetryTimeoutMs: conf.Spec.RetryTimeoutMs, + MinRequestAmount: conf.Spec.MinRequestAmount, + StatIntervalMs: conf.Spec.StatIntervalMs, + StatSlidingWindowBucketCount: conf.Spec.StatSlidingWindowBucketCount, + Threshold: conf.Spec.Threshold, + ProbeNum: conf.Spec.ProbeNum, + MaxAllowedRtMs: conf.Spec.MaxAllowedRtMs, + }) + case "AdaptiveOverloadProtectionStrategy": + systemRules = append(systemRules, &system.Rule{ + MetricType: systemMetricMap[conf.Spec.MetricType], + TriggerCount: conf.Spec.TriggerCount, + Strategy: adaptiveStrategyMap[conf.Spec.AdaptiveStrategy], + }) + } + } + + if len(flowRules) > 0 { + _, err = flow.LoadRules(flowRules) + if err != nil { + proxywasm.LogCritical(err.Error()) + } + } + + if len(hotspotRules) > 0 { + _, err = hotspot.LoadRules(hotspotRules) + if err != nil { + proxywasm.LogCritical(err.Error()) + } + } + + if len(circuitbreakerRules) > 0 { + _, err = circuitbreaker.LoadRules(circuitbreakerRules) + if err != nil { + proxywasm.LogCritical(err.Error()) + } + } + + if len(isolationRules) > 0 { + _, err = isolation.LoadRules(isolationRules) + if err != nil { + proxywasm.LogCritical(err.Error()) + } + } + + if len(systemRules) > 0 { + _, err = system.LoadRules(systemRules) + if err != nil { + proxywasm.LogCritical(err.Error()) + } + } + return types.OnPluginStartStatusOK +} + +type tcpContext struct { + types.DefaultTcpContext + contextID int64 + entry *base.SentinelEntry + blockError *base.BlockError +} + +func (ctx *tcpContext) OnNewConnection() types.Action { + proxywasm.LogInfo("OnNewConnection") + initialValueBuf := make([]byte, 1) + if err := proxywasm.SetSharedData(strconv.FormatInt(ctx.contextID, 10), initialValueBuf, 0); err != nil { + proxywasm.LogInfof("error setting shared data on OnNewConnection: %v", err) + } + + data, err := proxywasm.GetPluginConfiguration() + if err != nil { + proxywasm.LogCriticalf("error reading plugin configuration: %v", err) + } + + proxywasm.LogInfof("plugin config: %v", string(data)) + plugConfig := map[string]string{} + json.Unmarshal([]byte(data), &plugConfig) + proxywasm.LogInfof("plugin configmap: %v", plugConfig["resource_name"]) + + go func() { + for { + e, b := sentinel.Entry(plugConfig["resource_name"], sentinel.WithTrafficType(base.Inbound)) + ctx.entry = e + ctx.blockError = b + if b != nil { + err := setBlockError(strconv.FormatInt(ctx.contextID, 10), ctx.blockError.Error()) + if err != nil { + proxywasm.LogInfof("set blockError err=%v", err) + } + } + } + }() + return types.ActionContinue +} + +func (ctx *tcpContext) OnStreamDone() { + str, err := getBlockError(strconv.FormatInt(ctx.contextID, 10)) + if err != nil { + proxywasm.LogInfof("get BlockError err = %v\n", err) + } + + if str == "" { + ctx.entry.Exit() + } + proxywasm.LogInfo("OnStreamDone") +} + +func (ctx *tcpContext) OnUpstreamData(dataSize int, endOfStream bool) types.Action { + if dataSize == 0 { + return types.ActionContinue + } + + ret, err := proxywasm.GetProperty([]string{"upstream", "address"}) + if err != nil { + proxywasm.LogCriticalf("failed to get upstream data: %v", err) + return types.ActionContinue + } + + proxywasm.LogInfof("remote address: %s", string(ret)) + + data, err := proxywasm.GetUpstreamData(0, dataSize) + if err != nil && err != types.ErrorStatusNotFound { + proxywasm.LogCritical(err.Error()) + } + + proxywasm.LogInfof("<<<<<< upstream data received <<<<<<\n%v", string(data)) + + blockErr, err := getBlockError(strconv.FormatInt(ctx.contextID, 10)) + if err != nil { + proxywasm.LogInfof("get BlockError err = %v\n", err) + } + + proxywasm.LogInfof("get BlockError = %v\n", blockErr) + + if blockErr != "" { + statusCode := 429 + body, header := "", "" + for _, conf := range *confs { + switch conf.KindType { + case "HttpRequestFallbackAction": + if conf.Spec.BehaviorDesc.ResponseStatusCode != 0 { + statusCode = conf.Spec.BehaviorDesc.ResponseStatusCode + } + body = conf.Spec.BehaviorDesc.ResponseContentBody + for key, value := range conf.Spec.BehaviorDesc.ResponseAdditionalHeaders { + header += fmt.Sprintf("%v: %v\r\n", key, value) + } + } + } + + responseData := fmt.Sprintf("HTTP/1.1 %v Too Many Requests\r\ncontent-length: %v\r\ncontent-type: text/plain\r\ndate: %v\r\nserver: envoy\r\n%v\r\n%v\n", statusCode, len(blockErr)+1, time.Now().Format(http.TimeFormat), header, body+" "+blockErr) + proxywasm.ReplaceUpstreamData([]byte(responseData)) + } + return types.ActionContinue +} + +func setBlockError(key, value string) error { + _, cas, err := proxywasm.GetSharedData(key) + if err != nil { + proxywasm.LogWarnf("error getting shared data on OnNewConnection: %v", err) + } + + if err := proxywasm.SetSharedData(key, []byte(value), cas); err != nil { + proxywasm.LogWarnf("error setting shared data on OnNewConnection: %v", err) + return err + } + return nil +} + +func getBlockError(key string) (string, error) { + value, _, err := proxywasm.GetSharedData(key) + if err != nil { + proxywasm.LogWarnf("error getting shared data: %v", err) + return "", err + } + return string(value), err +} diff --git a/sentinel.yml b/sentinel.yml new file mode 100644 index 0000000..f03d65a --- /dev/null +++ b/sentinel.yml @@ -0,0 +1,39 @@ +apiVersion: fault-tolerance.opensergo.io/v1alpha1 +kind: RateLimitStrategy +metadata: + name: rate-limit-foo +spec: + metricType: RequestAmount + limitMode: Global + threshold: 10 + statDuration: "1s" +--- +apiVersion: fault-tolerance.opensergo.io/v1alpha1 +kind: HttpRequestFallbackAction +metadata: + name: fallback-foo +spec: + behavior: ReturnProvidedResponse + behaviorDesc: + # 触发策略控制后，HTTP 请求返回 429 状态码，同时携带指定的内容和 header. + responseStatusCode: 429 + responseContentBody: "Blocked by Sentinel" + responseAdditionalHeaders: + - key: X-Sentinel-Limit + value: "foo" +--- +apiVersion: fault-tolerance.opensergo.io/v1alpha1 +kind: FaultToleranceRule +metadata: + name: my-rule + namespace: prod + labels: + app: my-app +spec: + selector: + app: my-app # 规则配置生效的应用名 + targets: + - targetResourceName: '/foo' + strategies: + - name: rate-limit-foo + fallbackAction: fallback-foo \ No newline at end of file From 8195c6dc225313f2f97c6cf7eca3382f2e7666ae Mon Sep 17 00:00:00 2001 From: halfrost Date: Sun, 30 Oct 2022 14:23:27 -0700 Subject: [PATCH 2/2] Add example client and instruction in README --- README.md | 491 +++++++++++++++++++++++++++++++++++- main.go => core/sentinel.go | 0 envoy.yaml | 2 +- example/client.go | 96 +++++++ go.mod | 29 +++ go.sum | 432 +++++++++++++++++++++++++++++++ static/plugin.png | Bin 0 -> 132607 bytes static/wasm_vm.png | Bin 0 -> 64514 bytes 8 files changed, 1047 insertions(+), 3 deletions(-) rename main.go => core/sentinel.go (100%) create mode 100644 example/client.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 static/plugin.png create mode 100644 static/wasm_vm.png diff --git a/README.md b/README.md index b2d6089..975c45d 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,489 @@ -# sentinel-go-envoy-wasm-extension -Envoy WASM extension with Sentinel Go +# sentinel-go-envoy-proxy-wasm +Sentinel Go Proxy-WASM extension + + +# Introduction + +Due to the limitations of the sentinel token server for Envoy Global Rate Limiting Service model, scenarios and performance are limited. Considering the rapid development of cloud native in recent years, the voice of sentinel wasm extension in the community is getting higher and higher. Using the Envoy wasm extension and the native implementation of sentinel go, comprehensive traffic governance capabilities and standard coverage can be implemented. + +# Environment and Tools + +- tinygo 0.24.0 linux/amd64 (using go version go1.18.4 and LLVM version 14.0.0) +- func-e 1.1.3 +- kubernetes/kubectl +- Istio +- Envoy + +# How it works + +The sentinel wasm extension implemented is based on the sentinel-go. So it uses proxy-wasm-go-sdk, which is an encapsulation of the Proxy-Wasm ABI, providing a series of APIs in the Go language. Using this SDK, it is possible to generate Wasm binaries that are compliant with the Proxy-Wasm. + +Before discussing the wasm architecture design, let’s talk about the Wasm Virtual Machine (Wasm VM). Wasm VM is the environment for loading plugins. In Envoy, VMs are created in each thread and isolated from each other. So the wasm extension program we created will be copied into the thread created by Envoy and loaded on each VM. The Proxy-Wasm allows multiple plugins in a single VM. In other words, a VM can be used by multiple plugins. + + +![](./static/wasm_vm.png) + +From the vm loading timing, the thread first loads the vm, then the vm creates the context, and then loads the plugin context. The sentinel plugin is loaded by the vm. At this time, we can load some of the rule CRD specification yaml files we specified to perform the sentinel initialization operation. After the initial operation of sentinel plugin is completed, it starts to monitor http connection. + +![](./static/plugin.png) + +For each tcp connection, the plugin will intercept each upstream and downstream data packets. At this time, there are 5 hooks that can be executed. The entry is initialized when OnNewConnection is started, and the go statistical coroutine is started. Call the exit function at OnStreamDone and output a BlockError error message. + +If there are operations such as current limiting and fusing in the process, a BlockError will be catched in OnUpstreamData, and this error message will be returned to the client. Each connection will trigger entry funciton. If it exits normally, it will trigger exit function, and if the limit traffic rule is triggered, it will return BlockError. + +# Example + +## How to run test client + +The test client is used to control qps. That is, how many requests are requested per second. + + +```go +$ cd ./example +$ go build +$ ./client -q 100 -u some-test -p 8080 +``` + +The client can receive 3 parameters, `q` is qps, the unit is per second, `u` is url path. `p` is port. + + +## How to run this Envoy Wasm Extensions + +We will be using [TinyGo](https://tinygo.org), [proxy-wasm-go-sdk](https://github.com/tetratelabs/proxy-wasm-go-sdk) and [func-e CLI](https://func-e.io) to build and test an Envoy Wasm extension. Then we'll show a way to configure the Wasm module using the EnvoyFilter resource and deploy it to Envoy sidecars in a Kubernetes cluster. + +### Installing func-e CLI + +Let's get started by downloading func-e CLI and installing it to `/usr/local/bin`: + +```sh +curl https://func-e.io/install.sh | sudo bash -s -- -b /usr/local/bin +``` + +Once downloaded, let's run it to make sure all is good: + +```sh +$ func-e --version +func-e version 1.1.3 +``` + +### Installing TinyGo + +TinyGo powers the SDK we'll be using as Wasm doesn't support the official Go compiler. + +Let's download and install the TinyGo: + +```sh +wget https://github.com/tinygo-org/tinygo/releases/download/v0.24.0/tinygo_0.24.0_amd64.deb +sudo dpkg -i tinygo_0.24.0_amd64.deb +``` + +You can run `tinygo version` to check the installation is successful: + +```sh +$ tinygo version +tinygo version 0.24.0 linux/amd64 (using go version go1.18.4 and LLVM version 14.0.0) +``` + +### Scaffolding the Wasm module + +We'll start by creating a new folder for our extension, initializing the Go module, and downloading the SDK dependency: + +```sh +$ mkdir header-filter && cd header-filter +$ go mod init header-filter +$ go mod edit -require=github.com/tetratelabs/proxy-wasm-go-sdk@main +$ go mod download github.com/tetratelabs/proxy-wasm-go-sdk +``` + +Next, let's create the `main.go` file where the code for our WASM extension will like this: [main.go](https://github.com/halfrost/sentinel-go-envoy-proxy-wasm/blob/sentinel-go/main.go) + +Save the above contents to a file called `main.go`. + +Let's build the filter to check everything is good: + +```sh +tinygo build -o main.wasm -scheduler=none -target=wasi main.go +``` + +The build command should run successfully, and it should generate a file called `main.wasm`. + +We'll use `func-e` to run a local Envoy instance to test the extension we've built. + +First, we need an Envoy config that will configure the extension: + +```yaml +static_resources: + listeners: + - name: tcp + address: + socket_address: + address: 0.0.0.0 + port_value: 18000 + filter_chains: + - filters: + - name: envoy.filters.network.wasm + typed_config: + "@type": type.googleapis.com/envoy.extensions.filters.network.wasm.v3.Wasm + config: + # Instruct that the PluginContext should behave as a Tcp filter. + configuration: + "@type": type.googleapis.com/google.protobuf.StringValue + value: | + { + "config_path": "./sentinel.yml", + "resource_name": "some-test" + } + # Use the same vm_config as above, so we can reuse the same VM for multiple queues. + vm_config: + vm_id: "sender" + runtime: "envoy.wasm.runtime.v8" + code: + local: + filename: "main.wasm" + + - name: envoy.tcp_proxy + typed_config: + "@type": type.googleapis.com/envoy.extensions.filters.network.tcp_proxy.v3.TcpProxy + stat_prefix: ingress + cluster: web_service + + - name: http + address: + socket_address: + address: 127.0.0.1 + port_value: 8099 + filter_chains: + - filters: + - name: envoy.http_connection_manager + typed_config: + "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager + stat_prefix: ingress_http + codec_type: auto + route_config: + name: local_route + virtual_hosts: + - name: local_service + domains: + - "*" + routes: + - match: + prefix: "/" + direct_response: + status: 200 + body: + inline_string: "example body\n" + http_filters: + - name: envoy.filters.http.router + typed_config: + "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router + + clusters: + - name: web_service + connect_timeout: 0.25s + type: STATIC + lb_policy: ROUND_ROBIN + load_assignment: + cluster_name: mock_service + endpoints: + - lb_endpoints: + - endpoint: + address: + socket_address: + address: 127.0.0.1 + port_value: 8099 + +admin: + access_log_path: "/dev/null" + address: + socket_address: + address: 0.0.0.0 + port_value: 8001 +``` + +Save the above to `envoy.yaml` file. + +The Envoy configuration sets up a single listener on port 18000 that returns a direct response (HTTP 200) with body `example body`. Inside the `http_filters` section, we're configuring the `envoy.filters.http.wasm` filter and referencing the local WASM file (`main.wasm`) we've built earlier. + +Let's run the Envoy with this configuration in the background: + +```sh +func-e run -c envoy.yaml & +``` + +Envoy instance should start without any issues. Once it's started, we can send a request to the port Envoy is listening on (`18000`): + +```sh +$ curl localhost:10000 +[2021-06-22 16:39:31.491][5314][info][wasm] [external/envoy/source/extensions/common/wasm/context.cc:1218] wasm log: OnHttpRequestHeaders +[2021-06-22 16:39:31.491][5314][info][wasm] [external/envoy/source/extensions/common/wasm/context.cc:1218] wasm log: OnHttpResponseHeaders +[2021-06-22 16:39:31.492][5314][info][wasm] [external/envoy/source/extensions/common/wasm/context.cc:1218] wasm log: 2 finished +example body +``` + +The output shows the two log entries - one from the OnHttpRequestHeaders handler and the second one from the OnHttpResponseHeaders handler. The last line is the example response returned by the direct response configuration in the filter. + +You can stop the proxy by bringing the process to the foreground with `fg` and pressing CTRL+C to stop it. + + +### Deploying Wasm module to Istio using EnvoyFilter + +The resource we can use to deploy a Wasm module to Istio is called the EnvoyFilter. EnvoyFilter gives us the ability to customize the Envoy configuration. It allows us to modify values, configure new listeners or clusters, and add filters. + +In the previous example, there was no need to push or publish the `main.wasm` file anywhere, as it was accessible by the Envoy proxy because everything was running locally. However, now that we want to run the Wasm module in Envoy proxies that are part of the Istio service mesh, we need to make the `main.wasm` file available to all those proxies so they can load and run it. + +Since Envoy can be extended using filters, we can use the Envoy HTTP Wasm filter to implement an HTTP filter with a Wasm module. This filter allows us to configure the Wasm module and load the module file. + +Here's a snippet that shows how to load a Wasm module using the Envoy HTTP Wasm filter: + +```yaml +name: envoy.filters.http.wasm +typed_config: + "@type": type.googleapis.com/envoy.extensions.filters.http.wasm.v3.Wasm + config: + config: + name: "my_plugin" + vm_config: + runtime: "envoy.wasm.runtime.v8" + code: + local: + filename: "/etc/envoy_filter_http_wasm_example.wasm" + allow_precompiled: true + configuration: + '@type': type.googleapis.com/google.protobuf.StringValue + value: | + {} +``` + +This particular snippet is reading the Wasm file from the local path. Note that "local" in this case refers to the container the Envoy proxy is running in. + +One way we could bring the Wasm module to that container is to use a persistent volume, for example. We'd then copy the Wasm file to the persistent disk and use the following annotations to mount the volume into the Envoy proxy sidecars: + +```yaml +sidecar.istio.io/userMount: '[{"name": "wasmfilters", "mountPath": "/wasmfilters"}]' +sidecar.istio.io/userVolume: '[{"name": "wasmfilters", "gcePersistentDisk": { "pdName": "my-data-disk", "fsType": "ext4" }}]' +``` + +Note that the above snippet assumes a persistent disk running in GCP. The disk could be any other persistent volume as well. We'd then have to patch the existing Kubernetes deployments and 'inject' the above annotations. + +Luckily for us, there is another option. Remember the local field from the Envoy HTTP Wasm filter configuration? Well, there's also a remote field we can use to load the Wasm module from a remote location, a URL. The remote field simplifies things a lot! We can upload the .wasm file to remote storage, get the public URL to the module, and then use it. + +In this example, we'll upload the module to a GCP storage account and made the file publicly accessible. + +The updated configuration would now look like this: + +```yaml +vm_config: + runtime: envoy.wasm.runtime.v8 + code: + remote: + http_uri: + uri: [PUBLIC-URL]/extension.wasm + sha256: "[sha]" +``` + +You can get the SHA by running sha256sum command. If you're using Istio 1.9 or newer, you don't have to provide the sha256 checksum, as Istio will fill that automatically. However, if you're using Istio 1.8 or older, the sha256 checksum is required, and it prevents the Wasm module from being downloaded each time. + +Let's create a new storage bucket first (use your name/alias instead of the `wasm-bucket` value), using the `gsutil` command (the command is available in the GCP cloud shell): + +```sh +gsutil mb gs://wasm-bucket +Creating gs://wasm-bucket/... +``` + +>Note that you can use any other storage service to host the Wasm extension. + +Next, we use the commands below to copy the built extension to the Google Cloud Storage and make it publicly accessible: + +```sh +BUCKET_NAME="wasm-bucket" + +# Copy the extension to the storage bucket +gsutil cp main.wasm gs://$BUCKET_NAME + +# Make the extension readable to all users +gsutil acl ch -u AllUsers:R gs://$BUCKET_NAME/main.wasm +``` + +The URL where the uploaded file is available is: `http://BUCKET_NAME.storage.googleapis.com/OBJECT_NAME`. For example, `http://wasm-bucket.storage.googleapis.com/main.wasm`. + +We can now create the EnvoyFilter resource that tells Envoy where to download the extension as well as where to inject it (make sure you update the `uri` field with your bucket URI): + +```yaml +apiVersion: networking.istio.io/v1alpha3 +kind: EnvoyFilter +metadata: + name: headers-extension +spec: + configPatches: + - applyTo: EXTENSION_CONFIG + patch: + operation: ADD + value: + name: headers-extension + typed_config: + "@type": type.googleapis.com/udpa.type.v1.TypedStruct + type_url: type.googleapis.com/envoy.extensions.filters.http.wasm.v3.Wasm + value: + config: + vm_config: + vm_id: headers-extension-vm + runtime: envoy.wasm.runtime.v8 + code: + remote: + http_uri: + uri: http://istio-weekly-ep7.storage.googleapis.com/main.wasm + configuration: + "@type": type.googleapis.com/google.protobuf.StringValue + value: | + header_1=somevalue + header_2=secondvalue + - applyTo: HTTP_FILTER + match: + context: SIDECAR_INBOUND + listener: + filterChain: + filter: + name: envoy.filters.network.http_connection_manager + patch: + operation: INSERT_BEFORE + value: + name: headers-extension + config_discovery: + config_source: + ads: {} + initial_fetch_timeout: 0s # wait indefinitely to prevent bad Wasm fetch + type_urls: [ "type.googleapis.com/envoy.extensions.filters.http.wasm.v3.Wasm"] +``` + +Note that we're deploying the EnvoyFilters to the default namespace. We could also deploy them to a root namespace (e.g. `istio-system`) if we wanted to apply the filter to all workloads in the mesh. Additionally, we could specify the selectors to pick the workloads to which we want to apply the filter. + +Save the above YAML to `envoyfilter.yaml` file and create it: + +```sh +$ kubectl apply -f envoyfilter.yaml +envoyfilter.networking.istio.io/headers-extension created +``` + +To try out the module, you can deploy a sample workload. + +I am using this httpbin example: + +```yaml +apiVersion: v1 +kind: ServiceAccount +metadata: + name: httpbin +--- +apiVersion: v1 +kind: Service +metadata: + name: httpbin + labels: + app: httpbin + service: httpbin +spec: + ports: + - name: http + port: 8000 + targetPort: 80 + selector: + app: httpbin +--- +apiVersion: apps/v1 +kind: Deployment +metadata: + name: httpbin +spec: + replicas: 1 + selector: + matchLabels: + app: httpbin + version: v1 + template: + metadata: + labels: + app: httpbin + version: v1 + spec: + serviceAccountName: httpbin + containers: + - image: docker.io/kennethreitz/httpbin + imagePullPolicy: IfNotPresent + name: httpbin + ports: + - containerPort: 80 +``` + +Save the above file to `httpbin.yaml` and deploy it using `kubectl apply -f httpbin.yaml`. + +Before continuing, check that the httpbin Pod is up and running: + +```sh +$ kubectl get po +NAME READY STATUS RESTARTS AGE +httpbin-66cdbdb6c5-4pv44 2/2 Running 1 11m +``` + +To see if something went wrong with downloading the Wasm module, you can look at the istiod logs. + +Let's try out the deployed Wasm module! + +We will create a single Pod inside the cluster, and from there, we will send a request to `http://httpbin:8000/get` + +```sh +$ kubectl run curl --image=curlimages/curl -it --rm -- /bin/sh +Defaulted container "curl" out of: curl, istio-proxy, istio-init (init) +If you don't see a command prompt, try pressing enter. +/ $ +``` + +Once you get the prompt to the curl container, send a request to the `httpbin` service: + +```sh +/ $ curl -v http://httpbin:8000/headers +> GET /headers HTTP/1.1 +> User-Agent: curl/7.35.0 +> Host: httpbin:8000 +> Accept: */* +> +< HTTP/1.1 200 OK +< server: envoy +< date: Mon, 22 Jun 2021 18:52:17 GMT +< content-type: application/json +< content-length: 525 +< access-control-allow-origin: * +< access-control-allow-credentials: true +< x-envoy-upstream-service-time: 3 +... +``` + +Then start the client with some configuration, we can begin testing. + +### Cleanup + +To delete all created resources from your cluster, run the following: + +```sh +kubectl delete envoyfilter headers-extension +kubectl delete deployment httpbin +kubectl delete svc httpbin +kubectl delete sa httpbin +``` + +# To be solved + +## 1. Tinygo has limitations + +Given the limitations of tinygo, cgo is not perfectly supported. This means that I cannot use etcd and prometheus related functions. Because both of them will depend on xxhash. xxhash requires cgo compile dependencies. So I commented out etcd and prometheus and their associated dependencies. After commenting out these code, recompiling can indeed pass. But sentinel will have bugs. After debugging, it is found that in the line of exporter/metric/prometheus/exporter.go:20:2, if without prometheus client dependency package, the metric is 0, which will cause part of the underlying statistical count of sentinel to be 0. The flow control logic will not be triggered. + +In the wasm plugin, common statistical counts are easy to implement, but it involves some low-level metrics in prometheus, which are currently limited by tinygo, resulting in compilation errors. I also looked for solutions on Stack Overflow and github, and saw some more complicated wasm plugins. The tinygo version has not yet written functions related to prometheus. Regarding the issue of cgo, an issue has been raised to the tinygo team. They are currently working on a fix, the issue is here: [https://github.com/tinygo-org/tinygo/issues/3044](https://github.com/tinygo-org/tinygo/issues/3044) + +## 2. Problems with reflect + +Apart from the cgo issue, there are some issues with reflect. You may be curious, where is reflect used? In fact, it will be used when reading yaml files. Use map to pass some values ​​to plugin in yaml file, such as resource name, crd path. These are wrapped in a json. When tinygo parses it, it doesn't know what fields are in it, it parses it with interface{} type. This part will use reflect package. In the current implementation code, the code for reading crd yaml is implemented. The bug is the same as this issue: [https://github.com/tinygo-org/tinygo/issues/2660](https://github.com/tinygo-org/tinygo/issues/2660). There is a workaround for this problem, that is, don't pass a map of mutable structures by value. In this way, tinygo will not use interface to serialize when parsing, and it will not trigger the reflect bug. But this bug is really common. If you pass a json data, it will panic. json is a map of mutable structures. + + +# Next + +- Solved cgo compile problem. +- Combine opensergo to refactor some module. diff --git a/main.go b/core/sentinel.go similarity index 100% rename from main.go rename to core/sentinel.go diff --git a/envoy.yaml b/envoy.yaml index 708e5bc..d9090d3 100644 --- a/envoy.yaml +++ b/envoy.yaml @@ -17,7 +17,7 @@ static_resources: value: | { "config_path": "./sentinel.yml", - "resource_name": "http://localhost/" + "resource_name": "some-test" } # Use the same vm_config as above, so we can reuse the same VM for multiple queues. vm_config: diff --git a/example/client.go b/example/client.go new file mode 100644 index 0000000..102cbbb --- /dev/null +++ b/example/client.go @@ -0,0 +1,96 @@ +package main + +import ( + "context" + "flag" + "fmt" + "io/ioutil" + "net/http" + "os" + "os/signal" + "strconv" + "sync/atomic" + "syscall" + "time" +) + +var ( + qps int + path string + port int + totalNum int64 +) + +func init() { + flag.IntVar(&qps, "q", 0, "qps settings") + flag.StringVar(&path, "u", "", "url path") + flag.IntVar(&port, "p", 8080, "port") + flag.Parse() +} + +func listenSysSignals(cancel context.CancelFunc) { + signalChan := make(chan os.Signal, 1) + ignoreChan := make(chan os.Signal, 1) + + signal.Notify(ignoreChan, syscall.SIGHUP) + signal.Notify(signalChan, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM) + + select { + case sig := <-signalChan: + fmt.Printf("main exit due to system signal occur: %s\n", sig) + cancel() + case sig := <-ignoreChan: + fmt.Printf("ignore system signal: %s\n", sig) + } +} + +func main() { + ctx, cancel := context.WithCancel(context.Background()) + for i := 0; i < 200*qps; i++ { + go startQPSTest(ctx) + } + go startStatistics(ctx) + listenSysSignals(cancel) +} + +func startStatistics(ctx context.Context) { + ticker := time.NewTicker(time.Second * 1) + defer ticker.Stop() + + var counter int64 + for { + select { + case <-ticker.C: + fmt.Printf("QPS: %v | totalNum: %v\n", totalNum-counter, totalNum) + counter = totalNum + case <-ctx.Done(): + fmt.Printf("Child startStatistics goroutine exit.\n") + return + } + } +} + +func startQPSTest(ctx context.Context) { + ticker := time.NewTicker(time.Second * 1) + defer ticker.Stop() + + for { + select { + case <-ticker.C: + resp, err := http.Get("http://localhost:" + strconv.Itoa(port) + "/" + path) + if err != nil { + fmt.Println(err) + } + defer resp.Body.Close() + body, err := ioutil.ReadAll(resp.Body) + if err != nil { + fmt.Println(err) + } + fmt.Printf("body = %v | statusCode = %v\n", string(body), resp.StatusCode) + atomic.AddInt64(&totalNum, 1) + case <-ctx.Done(): + fmt.Printf("Child startQPSTest goroutine exit.\n") + return + } + } +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..757d64c --- /dev/null +++ b/go.mod @@ -0,0 +1,29 @@ +module sentinel-go-proxy-wasm-extension + +go 1.19 + +require ( + github.com/alibaba/sentinel-golang v1.0.4 + github.com/tetratelabs/proxy-wasm-go-sdk v0.20.0 + gopkg.in/yaml.v2 v2.4.0 +) + +require ( + github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d // indirect + github.com/beorn7/perks v1.0.1 // indirect + github.com/cespare/xxhash/v2 v2.1.1 // indirect + github.com/go-ole/go-ole v1.2.4 // indirect + github.com/golang/protobuf v1.4.3 // indirect + github.com/google/uuid v1.1.1 // indirect + github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/prometheus/client_golang v1.9.0 // indirect + github.com/prometheus/client_model v0.2.0 // indirect + github.com/prometheus/common v0.15.0 // indirect + github.com/prometheus/procfs v0.2.0 // indirect + github.com/shirou/gopsutil/v3 v3.21.6 // indirect + github.com/tklauser/go-sysconf v0.3.6 // indirect + github.com/tklauser/numcpus v0.2.2 // indirect + golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa // indirect + google.golang.org/protobuf v1.23.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..14d6bb7 --- /dev/null +++ b/go.sum @@ -0,0 +1,432 @@ +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0= +github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo= +github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI= +github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d h1:G0m3OIz70MZUWq3EgK3CesDbo8upS2Vm9/P3FtgI+Jk= +github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg= +github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g= +github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c= +github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= +github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= +github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= +github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= +github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho= +github.com/alibaba/sentinel-golang v1.0.4 h1:i0wtMvNVdy7vM4DdzYrlC4r/Mpk1OKUUBurKKkWhEo8= +github.com/alibaba/sentinel-golang v1.0.4/go.mod h1:Lag5rIYyJiPOylK8Kku2P+a23gdKMMqzQS7wTnjWEpk= +github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ= +github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ= +github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= +github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= +github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= +github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A= +github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU= +github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= +github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g= +github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= +github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= +github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ= +github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM= +github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY= +github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8= +github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI= +github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= +github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= +github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= +github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ= +github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= +github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs= +github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU= +github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= +github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= +github.com/envoyproxy/go-control-plane v0.6.9/go.mod h1:SBwIajubJHhxtWwsL9s8ss4safvEdbitLhGGK48rN6g= +github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= +github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4= +github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= +github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= +github.com/go-kit/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o= +github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= +github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= +github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= +github.com/go-ole/go-ole v1.2.4 h1:nNBDSCOigTSiarFpYE9J/KtEA1IOW4CNeqT9TQDqCxI= +github.com/go-ole/go-ole v1.2.4/go.mod h1:XCwSNxSkXRo4vlyPy93sltvi/qJq0jqQhjqQNIwKuxM= +github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= +github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s= +github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= +github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= +github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM= +github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY= +github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg= +github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= +github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= +github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= +github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs= +github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk= +github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= +github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE= +github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= +github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= +github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM= +github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU= +github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU= +github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4= +github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90= +github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= +github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ= +github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I= +github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg= +github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= +github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= +github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= +github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo= +github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4= +github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= +github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= +github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= +github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM= +github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= +github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM= +github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4= +github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ= +github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= +github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU= +github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= +github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= +github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= +github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= +github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI= +github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg= +github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY= +github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= +github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= +github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg= +github.com/nats-io/jwt v0.3.2/go.mod h1:/euKqTS1ZD+zzjYrY7pseZrTtWQSjujC7xjPc8wL6eU= +github.com/nats-io/nats-server/v2 v2.1.2/go.mod h1:Afk+wRZqkMQs/p45uXdrVLuab3gwv3Z8C4HTBu8GD/k= +github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w= +github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w= +github.com/nats-io/nkeys v0.1.3/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w= +github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= +github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtbWGs= +github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA= +github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk= +github.com/opentracing-contrib/go-observer v0.0.0-20170622124052-a52f23424492/go.mod h1:Ngi6UdF0k5OKD5t5wlmGhe/EDKPoUM3BXZSSfIuJbis= +github.com/opentracing/basictracer-go v1.0.0/go.mod h1:QfBfYuafItcjQuMwinw9GhYKwFXS9KnPs5lxoYwgW74= +github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/openzipkin-contrib/zipkin-go-opentracing v0.4.5/go.mod h1:/wsWhb9smxSfWAKL3wpBW7V8scJMt8N8gnaMCS9E/cA= +github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw= +github.com/openzipkin/zipkin-go v0.2.1/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4= +github.com/openzipkin/zipkin-go v0.2.2/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4= +github.com/pact-foundation/pact-go v1.0.4/go.mod h1:uExwJY4kCzNPcHRj+hCR/HBbOOIwwtUjcrb0b5/5kLM= +github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= +github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= +github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac= +github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc= +github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY= +github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= +github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= +github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs= +github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= +github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og= +github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M= +github.com/prometheus/client_golang v1.9.0 h1:Rrch9mh17XcxvEu9D9DEpb4isxjGBtcevQjKvxPRQIU= +github.com/prometheus/client_golang v1.9.0/go.mod h1:FqZLKOZnGdFAhOK4nqGHa7D66IdsO+O441Eve7ptJDU= +github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= +github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= +github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M= +github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= +github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= +github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA= +github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo= +github.com/prometheus/common v0.15.0 h1:4fgOnadei3EZvgRwxJ7RMpG1k1pOZth5Pc13tyspaKM= +github.com/prometheus/common v0.15.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s= +github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= +github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= +github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= +github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A= +github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= +github.com/prometheus/procfs v0.2.0 h1:wH4vA7pcjKuZzjF7lM8awk4fnuJO6idemZXoKnULUx4= +github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= +github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= +github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= +github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E= +github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= +github.com/shirou/gopsutil/v3 v3.21.6 h1:vU7jrp1Ic/2sHB7w6UNs7MIkn7ebVtTb5D9j45o9VYE= +github.com/shirou/gopsutil/v3 v3.21.6/go.mod h1:JfVbDpIBLVzT8oKbvMg9P3wEIMDDpVn+LwHTKj0ST88= +github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= +github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= +github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= +github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88= +github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= +github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= +github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM= +github.com/sony/gobreaker v0.4.1/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= +github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= +github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= +github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= +github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A= +github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= +github.com/tetratelabs/proxy-wasm-go-sdk v0.20.0 h1:i/xtxt/jHXtp/yImhlp4pAWx0eVzIBKOaay3Nu4Iw3k= +github.com/tetratelabs/proxy-wasm-go-sdk v0.20.0/go.mod h1:7uUubjgZpmccNAPqSS6Il6CF+tk3BGf4qSCJZp3W8s8= +github.com/tklauser/go-sysconf v0.3.6 h1:oc1sJWvKkmvIxhDHeKWvZS4f6AW+YcoguSfRF2/Hmo4= +github.com/tklauser/go-sysconf v0.3.6/go.mod h1:MkWzOF4RMCshBAMXuhXJs64Rte09mITnppBXY/rYEFI= +github.com/tklauser/numcpus v0.2.2 h1:oyhllyrScuYI6g+h/zUvNXNp1wy7x8qQy3t/piefldA= +github.com/tklauser/numcpus v0.2.2/go.mod h1:x3qojaO3uyYt0i56EW/VUYs7uBvdl2fkfZFu0T9wgjM= +github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= +github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA= +github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= +github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= +go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= +go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg= +go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= +go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= +go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= +go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= +go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= +go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= +go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= +go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU= +go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= +go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= +go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= +golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191220142924-d4481acd189f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201214210602-f9fddec55a1e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa h1:ZYxPR6aca/uhfRJyaOAtflSHjJYiktO7QnJC5ut7iY4= +golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk= +google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190530194941-fb225487d101/go.mod h1:z3L6/3dTEVtUr6QSP8miRzeRqwQOioJ9I66odjN4I7s= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM= +google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= +google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= +google.golang.org/grpc v1.22.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/cheggaaa/pb.v1 v1.0.25/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw= +gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o= +gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI= +gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= +sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= +sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU= diff --git a/static/plugin.png b/static/plugin.png new file mode 100644 index 0000000000000000000000000000000000000000..9a3271544579e4ca7c27b2313019ab4cea1bc935 GIT binary patch literal 132607 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

8rtxh1c-pfCKVVW*Z)Wq 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%0AQk%yv6) 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 literal 0 HcmV?d00001 diff --git a/static/wasm_vm.png b/static/wasm_vm.png new file mode 100644 index 0000000000000000000000000000000000000000..f5162d5170d4a9c34a5f521c2bb9b29cad9dffc7 GIT binary patch literal 64514 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 literal 0 HcmV?d00001